1. 16 Apr, 2014 9 commits
  2. 25 Mar, 2014 7 commits
    • antirez's avatar
      Fix off by one bug in freeMemoryIfNeeded() eviction pool. · 046e691a
      antirez authored
      Bug found by the continuous integration test running the Redis
      with valgrind:
      
      ==6245== Invalid read of size 8
      ==6245==    at 0x4C2DEEF: memcpy@GLIBC_2.2.5 (mc_replace_strmem.c:876)
      ==6245==    by 0x41F9E6: freeMemoryIfNeeded (redis.c:3010)
      ==6245==    by 0x41D2CC: processCommand (redis.c:2069)
      
      memmove() size argument was accounting for an extra element, going
      outside the bounds of the array.
      046e691a
    • antirez's avatar
      adjustOpenFilesLimit() refactoring. · c69c40a4
      antirez authored
      In this commit:
      * Decrement steps are semantically differentiated from the reserved FDs.
        Previously both values were 32 but the meaning was different.
      * Make it clear that we save setrlimit errno.
      * Don't explicitly handle wrapping of 'f', but prevent it from
        happening.
      * Add comments to make the function flow more readable.
      
      This integrates PR #1630
      c69c40a4
    • Matt Stancliff's avatar
      Fix potentially incorrect errno usage · b2a02cc9
      Matt Stancliff authored
      errno may be reset by the previous call to redisLog, so capture
      the original value for proper error reporting.
      b2a02cc9
    • Matt Stancliff's avatar
      Add REDIS_MIN_RESERVED_FDS define for open fds · 01fe750c
      Matt Stancliff authored
      Also update the original REDIS_EVENTLOOP_FDSET_INCR to
      include REDIS_MIN_RESERVED_FDS. REDIS_EVENTLOOP_FDSET_INCR
      exists to make sure more than (maxclients+RESERVED) entries
      are allocated, but we can only guarantee that if we include
      the current value of REDIS_MIN_RESERVED_FDS as a minimum
      for the INCR size.
      01fe750c
    • Matt Stancliff's avatar
      Fix infinite loop on startup if ulimit too low · 1e7b9980
      Matt Stancliff authored
      Fun fact: rlim_t is an unsigned long long on all platforms.
      
      Continually subtracting from a rlim_t makes it get smaller
      and smaller until it wraps, then you're up to 2^64-1.
      
      This was causing an infinite loop on Redis startup if
      your ulimit was extremely (almost comically) low.
      
      The case of (f > oldlimit) would never be met in a case like:
      
          f = 150
          while (f > 20) f -= 128
      
      Since f is unsigned, it can't go negative and would
      take on values of:
      
          Iteration 1: 150 - 128 => 22
          Iteration 2:  22 - 128 => 18446744073709551510
          Iterations 3-∞: ...
      
      To catch the wraparound, we use the previous value of f
      stored in limit.rlimit_cur.  If we subtract from f and
      get a larger number than the value it had previously,
      we print an error and exit since we don't have enough
      file descriptors to help the user at this point.
      
      Thanks to @bs3g for the inspiration to fix this problem.
      Patches existed from @bs3g at antirez#1227, but I needed to repair a few other
      parts of Redis simultaneously, so I didn't get a chance to use them.
      1e7b9980
    • Matt Stancliff's avatar
      Improve error handling around setting ulimits · f701a347
      Matt Stancliff authored
      The log messages about open file limits have always
      been slightly opaque and confusing.  Here's an attempt to
      fix their wording, detail, and meaning.  Users will have a
      better understanding of how to fix very common problems
      with these reworded messages.
      
      Also, we handle a new error case when maxclients becomes less
      than one, essentially rendering the server unusable.  We
      now exit on startup instead of leaving the user with a server
      unable to handle any connections.
      
      This fixes antirez#356 as well.
      f701a347
    • Matt Stancliff's avatar
      Replace magic 32 with REDIS_EVENTLOOP_FDSET_INCR · 6f4be459
      Matt Stancliff authored
      32 was the additional number of file descriptors Redis
      would reserve when managing a too-low ulimit.  The
      number 32 was in too many places statically, so now
      we use a macro instead that looks more appropriate.
      
      When Redis sets up the server event loop, it uses:
          server.maxclients+REDIS_EVENTLOOP_FDSET_INCR
      
      So, when reserving file descriptors, it makes sense to
      reserve at least REDIS_EVENTLOOP_FDSET_INCR FDs instead
      of only 32.  Currently, REDIS_EVENTLOOP_FDSET_INCR is
      set to 128 in redis.h.
      
      Also, I replaced the static 128 in the while f < old loop
      with REDIS_EVENTLOOP_FDSET_INCR as well, which results
      in no change since it was already 128.
      
      Impact: Users now need at least maxclients+128 as
      their open file limit instead of maxclients+32 to obtain
      actual "maxclients" number of clients.  Redis will carve
      the extra REDIS_EVENTLOOP_FDSET_INCR file descriptors it
      needs out of the "maxclients" range instead of failing
      to start (unless the local ulimit -n is too low to accomidate
      the request).
      6f4be459
  3. 24 Mar, 2014 3 commits
    • Jan-Erik Rediger's avatar
      Fixed a few typos. · 9fa96697
      Jan-Erik Rediger authored
      9fa96697
    • antirez's avatar
      Sample and cache RSS in serverCron(). · 2dd8c462
      antirez authored
      Obtaining the RSS (Resident Set Size) info is slow in Linux and OSX.
      This slowed down the generation of the INFO 'memory' section.
      
      Since the RSS does not require to be a real-time measurement, we
      now sample it with server.hz frequency (10 times per second by default)
      and use this value both to show the INFO rss field and to compute the
      fragmentation ratio.
      
      Practically this does not make any difference for memory profiling of
      Redis but speeds up the INFO call significantly.
      2dd8c462
    • antirez's avatar
      Cache uname() output across INFO calls. · 571d6b01
      antirez authored
      Uname was profiled to be a slow syscall. It produces always the same
      output in the context of a single execution of Redis, so calling it at
      every INFO output generation does not make too much sense.
      
      The uname utsname structure was modified as a static variable. At the
      same time a static integer was added to check if we need to call uname
      the first time.
      571d6b01
  4. 21 Mar, 2014 6 commits
    • antirez's avatar
      Use new dictGetRandomKeys() API to get samples for eviction. · fd5e8c01
      antirez authored
      The eviction quality degradates a bit in my tests, but since the API is
      faster, it allows to raise the number of samples, and overall is a win.
      fd5e8c01
    • antirez's avatar
      struct dictEntry -> dictEntry. · 10c8d862
      antirez authored
      10c8d862
    • antirez's avatar
      LRU eviction pool implementation. · c641074a
      antirez authored
      This is an improvement over the previous eviction algorithm where we use
      an eviction pool that is persistent across evictions of keys, and gets
      populated with the best candidates for evictions found so far.
      
      It allows to approximate LRU eviction at a given number of samples
      better than the previous algorithm used.
      c641074a
    • antirez's avatar
      Obtain LRU clock in a resolution dependent way. · 205c2ccc
      antirez authored
      For testing purposes it is handy to have a very high resolution of the
      LRU clock, so that it is possible to experiment with scripts running in
      just a few seconds how the eviction algorithms works.
      
      This commit allows Redis to use the cached LRU clock, or a value
      computed on demand, depending on the resolution. So normally we have the
      good performance of a precomputed value, and a clock that wraps in many
      days using the normal resolution, but if needed, changing a define will
      switch behavior to an high resolution LRU clock.
      205c2ccc
    • antirez's avatar
      Specify LRU resolution in milliseconds. · 8f0b7491
      antirez authored
      8f0b7491
    • antirez's avatar
      Unify stats reset for CONFIG RESETSTAT / initServer(). · 8b6a674a
      antirez authored
      Now CONFIG RESETSTAT makes sure to reset all the fields, and in the
      future it will be simpler to avoid missing new fields.
      8b6a674a
  5. 11 Mar, 2014 6 commits
  6. 05 Mar, 2014 3 commits
  7. 27 Feb, 2014 1 commit
    • antirez's avatar
      Initial implementation of BITPOS. · 1f8005ca
      antirez authored
      It appears to work but more stress testing, and both unit tests and
      fuzzy testing, is needed in order to ensure the implementation is sane.
      1f8005ca
  8. 25 Feb, 2014 1 commit
    • Matt Stancliff's avatar
      Add cluster or sentinel to proc title · 5a8c9f94
      Matt Stancliff authored
      If you launch redis with `redis-server --sentinel` then
      in a ps, your output only says "redis-server IP:Port" — this
      patch changes the proc title to include [sentinel] or
      [cluster] depending on the current server mode:
      e.g.  "redis-server IP:Port [sentinel]"
            "redis-server IP:Port [cluster]"
      5a8c9f94
  9. 17 Feb, 2014 1 commit
    • antirez's avatar
      Get absoulte config file path before processig 'dir'. · 58b6dd9b
      antirez authored
      The code tried to obtain the configuration file absolute path after
      processing the configuration file. However if config file was a relative
      path and a "dir" statement was processed reading the config, the absolute
      path obtained was wrong.
      
      With this fix the absolute path is obtained before processing the
      configuration while the server is still in the original directory where
      it was executed.
      58b6dd9b
  10. 13 Feb, 2014 1 commit
    • antirez's avatar
      Update cached time in rdbLoad() callback. · 3c1672da
      antirez authored
      server.unixtime and server.mstime are cached less precise timestamps
      that we use every time we don't need an accurate time representation and
      a syscall would be too slow for the number of calls we require.
      
      Such an example is the initialization and update process of the last
      interaction time with the client, that is used for timeouts.
      
      However rdbLoad() can take some time to load the DB, but at the same
      time it did not updated the time during DB loading. This resulted in the
      bug described in issue #1535, where in the replication process the slave
      loads the DB, creates the redisClient representation of its master, but
      the timestamp is so old that the master, under certain conditions, is
      sensed as already "timed out".
      
      Thanks to @yoav-steinberg and Redis Labs Inc for the bug report and
      analysis.
      3c1672da
  11. 12 Feb, 2014 2 commits
    • antirez's avatar
      AOF write error: retry with a frequency of 1 hz. · 0296aab6
      antirez authored
      0296aab6
    • antirez's avatar
      AOF: don't abort on write errors unless fsync is 'always'. · dd73a7bf
      antirez authored
      A system similar to the RDB write error handling is used, in which when
      we can't write to the AOF file, writes are no longer accepted until we
      are able to write again.
      
      For fsync == always we still abort on errors since there is currently no
      easy way to avoid replying with success to the user otherwise, and this
      would violate the contract with the user of only acknowledging data
      already secured on disk.
      dd73a7bf