1. 18 Aug, 2014 1 commit
  2. 07 Aug, 2014 1 commit
    • Jan-Erik Rediger's avatar
      Handle large getrange requests · 53fdfda9
      Jan-Erik Rediger authored
      Previously the end was casted to a smaller type
      which resulted in a wrong check and failed
      with values larger than handled by unsigned.
      
      Closes #1847, #1844
      53fdfda9
  3. 30 Mar, 2014 1 commit
    • antirez's avatar
      String value unsharing refactored into proper function. · 543ede03
      antirez authored
      All the Redis functions that need to modify the string value of a key in
      a destructive way (APPEND, SETBIT, SETRANGE, ...) require to make the
      object unshared (if refcount > 1) and encoded in raw format (if encoding
      is not already REDIS_ENCODING_RAW).
      
      This was cut & pasted many times in multiple places of the code. This
      commit puts the small logic needed into a function called
      dbUnshareStringValue().
      543ede03
  4. 22 Jul, 2013 1 commit
    • 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
  5. 29 Mar, 2013 1 commit
  6. 28 Mar, 2013 1 commit
  7. 28 Jan, 2013 3 commits
  8. 19 Jan, 2013 2 commits
  9. 08 Nov, 2012 1 commit
  10. 31 Oct, 2012 1 commit
    • antirez's avatar
      Invert two sides of if expression in SET to avoid a lookup. · 973cb21a
      antirez authored
      Because of the short circuit behavior of && inverting the two sides of
      the if expression avoids an hash table lookup if the non-EX variant of
      SET is called.
      
      Thanks to Weibin Yao (@yaoweibin on github) for spotting this.
      973cb21a
  11. 24 May, 2012 2 commits
    • antirez's avatar
      Bit-related string operations moved to bitop.c · 760e7765
      antirez authored
      All the general string operations are implemented in t_string.c, however
      the bit operations, while targeting the string type, are better served
      in a specific file where we have the implementations of the following
      four commands and helper functions:
      
          GETBIT
          SETBIT
          BITOP
          BITCOUNT
      
      In the future this file will probably contain more code related to
      making the BITOP and BITCOUNT operations faster.
      760e7765
    • antirez's avatar
      New commands: BITOP and BITCOUNT. · 0bd6d68e
      antirez authored
      The motivation for this new commands is to be search in the usage of
      Redis for real time statistics. See the article "Fast real time metrics
      using Redis".
      
      http://blog.getspool.com/2011/11/29/fast-easy-realtime-metrics-using-redis-bitmaps/
      
      In general Redis strings when used as bitmaps using the SETBIT/GETBIT
      command provide a very space-efficient and fast way to store statistics.
      For instance in a web application with users, every user can be
      associated with a key that shows every day in which the user visited the
      web service. This information can be really valuable to extract user
      behaviour information.
      
      With Redis bitmaps doing this is very simple just saying that a given
      day is 0 (the data the service was put online) and all the next days are
      1, 2, 3, and so forth. So with SETBIT it is possible to set the bit
      corresponding to the current day every time the user visits the site.
      
      It is possible to take the count of the bit sets on the run, this is
      extremely easy using a Lua script. However a fast bit count native
      operation can be useful, especially if it can operate on ranges, or when
      the string is small like in the case of days (even if you consider many
      years it is still extremely little data).
      
      For this reason BITOP was introduced. The command counts the number of
      bits set to 1 in a string, with optional range:
      
      BITCOUNT key [start end]
      
      The start/end parameters are similar to GETRANGE. If omitted the whole
      string is tested.
      
      Population counting is more useful when bit-level operations like AND,
      OR and XOR are avaialble. For instance I can test multiple users to see
      the number of days three users visited the site at the same time. To do
      this we can take the AND of all the bitmaps, and then count the set bits.
      
      For this reason the BITOP command was introduced:
      
      BITOP [AND|OR|XOR|NOT] dest_key src_key1 src_key2 src_key3 ... src_keyN
      
      In the special case of NOT (that inverts the bits) only one source key
      can be passed.
      
      The judicious use of BITCOUNT and BITOP combined can lead to interesting
      use cases with very space efficient representation of data.
      
      The implementation provided is still not tested and optimized for speed,
      next commits will introduce unit tests. Later the implementation will be
      profiled to see if it is possible to gain an important amount of speed
      without making the code much more complex.
      0bd6d68e
  12. 21 Feb, 2012 1 commit
  13. 14 Nov, 2011 1 commit
  14. 12 Nov, 2011 1 commit
  15. 10 Nov, 2011 1 commit
  16. 09 Nov, 2011 1 commit
    • antirez's avatar
      Initial support for key expire times with millisecond resolution. RDB version... · 7dcc10b6
      antirez authored
      Initial support for key expire times with millisecond resolution. RDB version is now 3, new opcoded added for high resolution times. Redis is still able to correctly load RDB version 2. Tests passing but still a work in progress. API to specify milliseconds expires still missing, but the precision of normal expires is now already improved and working.
      7dcc10b6
  17. 20 Jun, 2011 2 commits
  18. 04 Mar, 2011 1 commit
  19. 29 Dec, 2010 1 commit
  20. 23 Dec, 2010 1 commit
  21. 19 Dec, 2010 1 commit
  22. 15 Dec, 2010 3 commits
  23. 14 Dec, 2010 5 commits
  24. 10 Dec, 2010 6 commits