1. 24 Mar, 2014 6 commits
    • Matt Stancliff's avatar
      Add REDIS_MIN_RESERVED_FDS define for open fds · 3b54ee6e
      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.
      3b54ee6e
    • Matt Stancliff's avatar
      Fix infinite loop on startup if ulimit too low · 90b84421
      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.
      90b84421
    • Matt Stancliff's avatar
      Improve error handling around setting ulimits · 4a25983f
      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.
      4a25983f
    • Matt Stancliff's avatar
      Replace magic 32 with REDIS_EVENTLOOP_FDSET_INCR · 491532a7
      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).
      491532a7
    • antirez's avatar
      Sample and cache RSS in serverCron(). · 93253c27
      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.
      93253c27
    • antirez's avatar
      Cache uname() output across INFO calls. · d3efe04c
      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.
      d3efe04c
  2. 20 Mar, 2014 5 commits
    • antirez's avatar
      Use new dictGetRandomKeys() API to get samples for eviction. · c641b670
      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.
      c641b670
    • antirez's avatar
      struct dictEntry -> dictEntry. · 82b53c65
      antirez authored
      82b53c65
    • antirez's avatar
      LRU eviction pool implementation. · 22c9cfaf
      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.
      22c9cfaf
    • antirez's avatar
      Obtain LRU clock in a resolution dependent way. · ad6b0f70
      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.
      ad6b0f70
    • antirez's avatar
      Specify LRU resolution in milliseconds. · d77e2316
      antirez authored
      d77e2316
  3. 19 Mar, 2014 1 commit
  4. 13 Mar, 2014 1 commit
  5. 10 Mar, 2014 3 commits
    • antirez's avatar
      Cluster: SORT get keys helper implemented. · 04cf02e8
      antirez authored
      04cf02e8
    • antirez's avatar
      Cluster: evalGetKey() added for EVAL/EVALSHA. · c0e818ab
      antirez authored
      Previously we used zunionInterGetKeys(), however after this function was
      fixed to account for the destination key (not needed when the API was
      designed for "diskstore") the two set of commands can no longer be served
      by an unique keys-extraction function.
      c0e818ab
    • antirez's avatar
      Cluster: getKeysFromCommand() API cleaned up. · 787b2970
      antirez authored
      This API originated from the "diskstore" experiment, not for Redis
      Cluster itself, so there were legacy/useless things trying to
      differentiate between keys that are going to be overwritten and keys
      that need to be fetched from disk (preloaded).
      
      All useless with Cluster, so removed with the result of code
      simplification.
      787b2970
  6. 07 Mar, 2014 1 commit
  7. 03 Mar, 2014 2 commits
  8. 28 Feb, 2014 1 commit
    • Matt Stancliff's avatar
      Force INFO used_memory_peak to match peak memory · f1c9a203
      Matt Stancliff authored
      used_memory_peak only updates in serverCron every server.hz,
      but Redis can use more memory and a user can request memory
      INFO before used_memory_peak gets updated in the next
      cron run.
      
      This patch updates used_memory_peak to the current
      memory usage if the current memory usage is higher
      than the recorded used_memory_peak value.
      
      (And it only calls zmalloc_used_memory() once instead of
      twice as it was doing before.)
      f1c9a203
  9. 27 Feb, 2014 1 commit
    • antirez's avatar
      Initial implementation of BITPOS. · 38c620b3
      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.
      38c620b3
  10. 21 Feb, 2014 1 commit
    • Matt Stancliff's avatar
      Add cluster or sentinel to proc title · 2c273e35
      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]"
      2c273e35
  11. 19 Feb, 2014 1 commit
    • Matt Stancliff's avatar
      Fix "can't bind to address" error reporting. · b20ae393
      Matt Stancliff authored
      Report the actual port used for the listening attempt instead of
      server.port.
      
      Originally, Redis would just listen on server.port.
      But, with clustering, Redis uses a Cluster Port too,
      so we can't say server.port is always where we are listening.
      
      If you tried to launch Redis with a too-high port number (any
      port where Port+10000 > 65535), Redis would refuse to start, but
      only print an error saying it can't connect to the Redis port.
      
      This patch fixes much confusions.
      b20ae393
  12. 17 Feb, 2014 1 commit
    • antirez's avatar
      Get absoulte config file path before processig 'dir'. · ede33fb9
      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.
      ede33fb9
  13. 13 Feb, 2014 1 commit
    • antirez's avatar
      Update cached time in rdbLoad() callback. · 51bd9da1
      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.
      51bd9da1
  14. 12 Feb, 2014 2 commits
    • antirez's avatar
      AOF write error: retry with a frequency of 1 hz. · fc08c859
      antirez authored
      fc08c859
    • antirez's avatar
      AOF: don't abort on write errors unless fsync is 'always'. · fe835254
      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.
      fe835254
  15. 07 Feb, 2014 2 commits
  16. 04 Feb, 2014 1 commit
    • antirez's avatar
      CLIENT PAUSE and related API implemented. · 4919a13f
      antirez authored
      The API is one of the bulding blocks of CLUSTER FAILOVER command that
      executes a manual failover in Redis Cluster. However exposed as a
      command that the user can call directly, it makes much simpler to
      upgrade a standalone Redis instance using a slave in a safer way.
      
      The commands works like that:
      
          CLIENT PAUSE <milliesconds>
      
      All the clients that are not slaves and not in MONITOR state are paused
      for the specified number of milliesconds. This means that slaves are
      normally served in the meantime.
      
      At the end of the specified amount of time all the clients are unblocked
      and will continue operations normally. This command has no effects on
      the population of the slow log, since clients are not blocked in the
      middle of operations but only when there is to process new data.
      
      Note that while the clients are unblocked, still new commands are
      accepted and queued in the client buffer, so clients will likely not
      block while writing to the server while the pause is active.
      4919a13f
  17. 03 Feb, 2014 1 commit
  18. 31 Jan, 2014 3 commits
  19. 28 Jan, 2014 1 commit
  20. 14 Jan, 2014 1 commit
    • antirez's avatar
      Cluster: support to read from slave nodes. · 28273394
      antirez authored
      A client can enter a special cluster read-only mode using the READONLY
      command: if the client read from a slave instance after this command,
      for slots that are actually served by the instance's master, the queries
      will be processed without redirection, allowing clients to read from
      slaves (but without any kind fo read-after-write guarantee).
      
      The READWRITE command can be used in order to exit the readonly state.
      28273394
  21. 23 Dec, 2013 1 commit
  22. 19 Dec, 2013 1 commit
  23. 11 Dec, 2013 1 commit
    • antirez's avatar
      Replication: publish the slave_repl_offset when disconnected from master. · a5ec247f
      antirez authored
      When a slave was disconnected from its master the replication offset was
      reported as -1. Now it is reported as the replication offset of the
      previous master, so that failover can be performed using this value in
      order to try to select a slave with more processed data from a set of
      slaves of the old master.
      a5ec247f
  24. 05 Dec, 2013 1 commit