1. 19 Aug, 2013 1 commit
    • antirez's avatar
      dict.c iterator API misuse protection. · 48cde3fe
      antirez authored
      dict.c allows the user to create unsafe iterators, that are iterators
      that will not touch the dictionary data structure in any way, preventing
      copy on write, but at the same time are limited in their usage.
      
      The limitation is that when itearting with an unsafe iterator, no call
      to other dictionary functions must be done inside the iteration loop,
      otherwise the dictionary may be incrementally rehashed resulting into
      missing elements in the set of the elements returned by the iterator.
      
      However after introducing this kind of iterators a number of bugs were
      found due to misuses of the API, and we are still finding
      bugs about this issue. The bugs are not trivial to track because the
      effect is just missing elements during the iteartion.
      
      This commit introduces auto-detection of the API misuse. The idea is
      that an unsafe iterator has a contract: from initialization to the
      release of the iterator the dictionary should not change.
      
      So we take a fingerprint of the dictionary state, xoring a few important
      dict properties when the unsafe iteartor is initialized. We later check
      when the iterator is released if the fingerprint is still the same. If it
      is not, we found a misuse of the iterator, as not allowed API calls
      changed the internal state of the dictionary.
      
      This code was checked against a real bug, issue #1240.
      
      This is what Redis prints (aborting) when a misuse is detected:
      
      Assertion failed: (iter->fingerprint == dictFingerprint(iter->d)),
      function dictReleaseIterator, file dict.c, line 587.
      48cde3fe
  2. 12 Aug, 2013 6 commits
  3. 08 Aug, 2013 2 commits
    • antirez's avatar
      redis-benchmark: changes to random arguments substitution. · db862e8e
      antirez authored
      Before this commit redis-benchmark supported random argumetns in the
      form of :rand:000000000000. In every string of that form, the zeros were
      replaced with a random number of 12 digits at every command invocation.
      
      However this was far from perfect as did not allowed to generate simply
      random numbers as arguments, there was always the :rand: prefix.
      
      Now instead every argument in the form __rand_int__ is replaced with a
      12 digits number. Note that "__rand_int__" is 12 characters itself.
      
      In order to implement the new semantic, it was needed to change a few
      thigns in the internals of redis-benchmark, as new clients are created
      cloning old clients, so without a stable prefix such as ":rand:" the old
      way of cloning the client was no longer able to understand, from the old
      command line, what was the position of the random strings to substitute.
      
      Now instead a client structure is passed as a reference for cloning, so
      that we can directly clone the offsets inside the command line.
      db862e8e
    • antirez's avatar
      redis-benchmark: replace snprintf()+memcpy with faster code. · 92ab77f8
      antirez authored
      This change was profiler-driven, but the actual effect is hard to
      measure in real-world redis benchmark runs.
      92ab77f8
  4. 07 Aug, 2013 4 commits
  5. 06 Aug, 2013 6 commits
  6. 05 Aug, 2013 2 commits
    • antirez's avatar
      Darft #2 for key collection algo: more improvements. · 66a26471
      antirez authored
      This commit makes the fast collection cycle time configurable, at
      the same time it does not allow to run a new fast collection cycle
      for the same amount of time as the max duration of the fast
      collection cycle.
      66a26471
    • antirez's avatar
      Draft #1 of a new expired keys collection algorithm. · b09ea1bd
      antirez authored
      The main idea here is that when we are no longer to expire keys at the
      rate the are created, we can't block more in the normal expire cycle as
      this would result in too big latency spikes.
      
      For this reason the commit introduces a "fast" expire cycle that does
      not run for more than 1 millisecond but is called in the beforeSleep()
      hook of the event loop, so much more often, and with a frequency bound
      to the frequency of executed commnads.
      
      The fast expire cycle is only called when the standard expiration
      algorithm runs out of time, that is, consumed more than
      REDIS_EXPIRELOOKUPS_TIME_PERC of CPU in a given cycle without being able
      to take the number of already expired keys that are yet not collected
      to a number smaller than 25% of the number of keys.
      
      You can test this commit with different loads, but a simple way is to
      use the following:
      
      Extreme load with pipelining:
      
      redis-benchmark -r 100000000 -n 100000000  \
              -P 32 set ele:rand:000000000000 foo ex 2
      
      Remove the -P32 in order to avoid the pipelining for a more real-world
      load.
      
      In another terminal tab you can monitor the Redis behavior with:
      
      redis-cli -i 0.1 -r -1 info keyspace
      
      and
      
      redis-cli --latency-history
      
      Note: this commit will make Redis printing a lot of debug messages, it
      is not a good idea to use it in production.
      b09ea1bd
  7. 29 Jul, 2013 1 commit
  8. 28 Jul, 2013 2 commits
  9. 25 Jul, 2013 1 commit
  10. 24 Jul, 2013 3 commits
  11. 23 Jul, 2013 2 commits
  12. 22 Jul, 2013 5 commits
    • antirez's avatar
      Test: regression test for issue #1208. · ddccd0ed
      antirez authored
      ddccd0ed
    • antirez's avatar
      Fix setDeferredMultiBulkLength() c->reply_bytes handling with EMBSTR · dbaa5b0b
      antirez authored
      This function missed proper handling of reply_bytes when gluing to the
      previous object was used. The issue was introduced with the EMBSTR new
      string object encoding.
      
      This fixes issue #1208.
      dbaa5b0b
    • antirez's avatar
      7ed76528
    • antirez's avatar
      a3169341
    • antirez's avatar
      Introduction of a new string encoding: EMBSTR · 894eba07
      antirez authored
      Previously two string encodings were used for string objects:
      
      1) REDIS_ENCODING_RAW: a string object with obj->ptr pointing to an sds
      stirng.
      
      2) REDIS_ENCODING_INT: a string object where the obj->ptr void pointer
      is casted to a long.
      
      This commit introduces a experimental new encoding called
      REDIS_ENCODING_EMBSTR that implements an object represented by an sds
      string that is not modifiable but allocated in the same memory chunk as
      the robj structure itself.
      
      The chunk looks like the following:
      
      +--------------+-----------+------------+--------+----+
      | robj data... | robj->ptr | sds header | string | \0 |
      +--------------+-----+-----+------------+--------+----+
                           |                       ^
                           +-----------------------+
      
      The robj->ptr points to the contiguous sds string data, so the object
      can be manipulated with the same functions used to manipulate plan
      string objects, however we need just on malloc and one free in order to
      allocate or release this kind of objects. Moreover it has better cache
      locality.
      
      This new allocation strategy should benefit both the memory usage and
      the performances. A performance gain between 60 and 70% was observed
      during micro-benchmarks, however there is more work to do to evaluate
      the performance impact and the memory usage behavior.
      894eba07
  13. 17 Jul, 2013 1 commit
  14. 16 Jul, 2013 3 commits
    • antirez's avatar
      Fixed typo in rio.h, simgle -> single. · f590dd82
      antirez authored
      f590dd82
    • yoav's avatar
    • antirez's avatar
      Make sure that ZADD can accept the full range of double values. · 9d520a7f
      antirez authored
      This fixes issue #1194, that contains many details.
      
      However in short, it was possible for ZADD to not accept as score values
      that was however possible to obtain with multiple calls to ZINCRBY, like
      in the following example:
      
      redis 127.0.0.1:6379> zadd k 2.5e-308 m
      (integer) 1
      redis 127.0.0.1:6379> zincrby k -2.4e-308 m
      "9.9999999999999694e-310"
      redis 127.0.0.1:6379> zscore k m
      "9.9999999999999694e-310"
      redis 127.0.0.1:6379> zadd k 9.9999999999999694e-310 m1
      (error) ERR value is not a valid float
      
      The problem was due to strtod() returning ERANGE in the following case
      specified by POSIX:
      
      "If the correct value would cause an underflow, a value whose magnitude
      is no greater than the smallest normalized positive number in the return
      type shall be returned and errno set to [ERANGE].".
      
      Now instead the returned value is accepted even when ERANGE is returned
      as long as the return value of the function is not negative or positive
      HUGE_VAL or zero.
      9d520a7f
  15. 12 Jul, 2013 1 commit