1. 18 Aug, 2020 1 commit
  2. 21 Apr, 2020 1 commit
  3. 03 Nov, 2019 1 commit
    • Oran Agra's avatar
      Module API for loading and saving long double · 779aebc9
      Oran Agra authored
      looks like each platform implements long double differently (different bit count)
      so we can't save them as binary, and we also want to avoid creating a new RDB
      format version, so we save these are hex strings using "%La".
      
      This commit includes a change in the arguments of ld2string to support this.
      as well as tests for coverage and short reads.
      
      coded by @guybe7
      779aebc9
  4. 02 Sep, 2019 1 commit
  5. 28 Jan, 2019 1 commit
  6. 09 Jan, 2019 4 commits
  7. 28 Nov, 2017 1 commit
  8. 29 Jun, 2017 1 commit
  9. 11 Jan, 2017 1 commit
  10. 20 Jun, 2016 1 commit
  11. 04 Nov, 2015 1 commit
    • antirez's avatar
      Fix HINCRBYFLOAT to work with long doubles. · 71aa9b75
      antirez authored
      During the refactoring needed for lazy free, specifically the conversion
      of t_hash from struct robj to plain SDS strings, HINCRBFLOAT was
      accidentally moved away from long doubles to doubles for internal
      processing of increments and formatting.
      
      The diminished precision created more obvious artifacts in the way small
      numbers are formatted once we convert from decimal number in radix 10 to
      double and back to its string in radix 10.
      
      By using more precision, we now have less surprising results at least
      with small numbers like "1.23", exactly like in the previous versions of
      Redis.
      
      See issue #2846.
      71aa9b75
  12. 01 Oct, 2015 6 commits
  13. 27 Jul, 2015 1 commit
  14. 26 Jul, 2015 6 commits
  15. 27 Feb, 2015 3 commits
  16. 21 Feb, 2015 1 commit
  17. 02 Dec, 2014 1 commit
  18. 05 Nov, 2013 1 commit
    • antirez's avatar
      SCAN code refactored to parse cursor first. · ebcb6251
      antirez authored
      The previous implementation of SCAN parsed the cursor in the generic
      function implementing SCAN, SSCAN, HSCAN and ZSCAN.
      
      The actual higher-level command implementation only checked for empty
      keys and return ASAP in that case. The result was that inverting the
      arguments of, for instance, SSCAN for example and write:
      
          SSCAN 0 key
      
      Instead of
      
          SSCAN key 0
      
      Resulted into no error, since 0 is a non-existing key name very likely.
      Just the iterator returned no elements at all.
      
      In order to fix this issue the code was refactored to extract the
      function to parse the cursor and return the error. Every higher level
      command implementation now parses the cursor and later checks if the key
      exist or not.
      ebcb6251
  19. 28 Oct, 2013 2 commits
  20. 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
  21. 15 Feb, 2013 1 commit
  22. 28 Jan, 2013 2 commits
  23. 08 Nov, 2012 1 commit