1. 08 Nov, 2023 1 commit
    • Meir Shpilraien (Spielrein)'s avatar
      Before evicted and before expired server events are not executed inside an execution unit. (#12733) · 0ffb9d2e
      Meir Shpilraien (Spielrein) authored
      Redis 7.2 (#9406) introduced a new modules event, `RedisModuleEvent_Key`.
      This new event allows the module to read the key data just before it is removed
      from the database (either deleted, expired, evicted, or overwritten).
      
      When the key is removed from the database, either by active expire or eviction.
      The new event was not called as part of an execution unit. This can cause an
      issue if the module registers a post notification job inside the event. This job will
      not be executed atomically with the expiration/eviction operation and will not
      replicated inside a Multi/Exec. Moreover, the post notification job will be executed
      right after the event where it is still not safe to perform any write operation, this will
      violate the promise that post notification job will be called atomically with the
      operation that triggered it and **only when it is safe to write**.
      
      This PR fixes the issue by wrapping each expiration/eviction of a key with an execution
      unit. This makes sure the entire operation will run atomically and all the post notification
      jobs will be executed at the end where it is safe to write.
      
      Tests were modified to verify the fix.
      0ffb9d2e
  2. 15 Oct, 2023 1 commit
    • Vitaly's avatar
      Replace cluster metadata with slot specific dictionaries (#11695) · 0270abda
      Vitaly authored
      This is an implementation of https://github.com/redis/redis/issues/10589
      
       that eliminates 16 bytes per entry in cluster mode, that are currently used to create a linked list between entries in the same slot.  Main idea is splitting main dictionary into 16k smaller dictionaries (one per slot), so we can perform all slot specific operations, such as iteration, without any additional info in the `dictEntry`. For Redis cluster, the expectation is that there will be a larger number of keys, so the fixed overhead of 16k dictionaries will be The expire dictionary is also split up so that each slot is logically decoupled, so that in subsequent revisions we will be able to atomically flush a slot of data.
      
      ## Important changes
      * Incremental rehashing - one big change here is that it's not one, but rather up to 16k dictionaries that can be rehashing at the same time, in order to keep track of them, we introduce a separate queue for dictionaries that are rehashing. Also instead of rehashing a single dictionary, cron job will now try to rehash as many as it can in 1ms.
      * getRandomKey - now needs to not only select a random key, from the random bucket, but also needs to select a random dictionary. Fairness is a major concern here, as it's possible that keys can be unevenly distributed across the slots. In order to address this search we introduced binary index tree). With that data structure we are able to efficiently find a random slot using binary search in O(log^2(slot count)) time.
      * Iteration efficiency - when iterating dictionary with a lot of empty slots, we want to skip them efficiently. We can do this using same binary index that is used for random key selection, this index allows us to find a slot for a specific key index. For example if there are 10 keys in the slot 0, then we can quickly find a slot that contains 11th key using binary search on top of the binary index tree.
      * scan API - in order to perform a scan across the entire DB, the cursor now needs to not only save position within the dictionary but also the slot id. In this change we append slot id into LSB of the cursor so it can be passed around between client and the server. This has interesting side effect, now you'll be able to start scanning specific slot by simply providing slot id as a cursor value. The plan is to not document this as defined behavior, however. It's also worth nothing the SCAN API is now technically incompatible with previous versions, although practically we don't believe it's an issue.
      * Checksum calculation optimizations - During command execution, we know that all of the keys are from the same slot (outside of a few notable exceptions such as cross slot scripts and modules). We don't want to compute the checksum multiple multiple times, hence we are relying on cached slot id in the client during the command executions. All operations that access random keys, either should pass in the known slot or recompute the slot. 
      * Slot info in RDB - in order to resize individual dictionaries correctly, while loading RDB, it's not enough to know total number of keys (of course we could approximate number of keys per slot, but it won't be precise). To address this issue, we've added additional metadata into RDB that contains number of keys in each slot, which can be used as a hint during loading.
      * DB size - besides `DBSIZE` API, we need to know size of the DB in many places want, in order to avoid scanning all dictionaries and summing up their sizes in a loop, we've introduced a new field into `redisDb` that keeps track of `key_count`. This way we can keep DBSIZE operation O(1). This is also kept for O(1) expires computation as well.
      
      ## Performance
      This change improves SET performance in cluster mode by ~5%, most of the gains come from us not having to maintain linked lists for keys in slot, non-cluster mode has same performance. For workloads that rely on evictions, the performance is similar because of the extra overhead for finding keys to evict. 
      
      RDB loading performance is slightly reduced, as the slot of each key needs to be computed during the load.
      
      ## Interface changes
      * Removed `overhead.hashtable.slot-to-keys` to `MEMORY STATS`
      * Scan API will now require 64 bits to store the cursor, even on 32 bit systems, as the slot information will be stored.
      * New RDB version to support the new op code for SLOT information. 
      
      ---------
      Co-authored-by: default avatarVitaly Arbuzov <arvit@amazon.com>
      Co-authored-by: default avatarHarkrishn Patro <harkrisp@amazon.com>
      Co-authored-by: default avatarRoshan Khatri <rvkhatri@amazon.com>
      Co-authored-by: default avatarMadelyn Olson <madelyneolson@gmail.com>
      Co-authored-by: default avatarOran Agra <oran@redislabs.com>
      0270abda
  3. 24 May, 2023 1 commit
    • judeng's avatar
      postpone the initialization of oject's lru&lfu until it is added to the db as... · d71478a8
      judeng authored
      postpone the initialization of oject's lru&lfu until it is added to the db as a value object (#11626)
      
      This pr can get two performance benefits:
      1. Stop redundant initialization when most robj objects are created
      2. LRU_CLOCK will no longer be called in io threads, so we can avoid the `atomicGet`
      
      Another code optimization:
      deleted the redundant judgment in dbSetValue, no matter in LFU or LRU, the lru field inold
      robj is always the freshest (it is always updated in lookupkey), so we don't need to judge if in LFU
      d71478a8
  4. 03 May, 2023 1 commit
    • Madelyn Olson's avatar
      Remove prototypes with empty declarations (#12020) · 5e3be1be
      Madelyn Olson authored
      Technically declaring a prototype with an empty declaration has been deprecated since the early days of C, but we never got a warning for it. C2x will apparently be introducing a breaking change if you are using this type of declarator, so Clang 15 has started issuing a warning with -pedantic. Although not apparently a problem for any of the compiler we build on, if feels like the right thing is to properly adhere to the C standard and use (void).
      5e3be1be
  5. 20 Dec, 2022 1 commit
    • guybe7's avatar
      Cleanup: Get rid of server.core_propagates (#11572) · 9c7c6924
      guybe7 authored
      1. Get rid of server.core_propagates - we can just rely on module/call nesting levels
      2. Rename in_nested_call  to execution_nesting and update the comment
      3. Remove module_ctx_nesting (redundant, we can use execution_nesting)
      4. Modify postExecutionUnitOperations according to the comment (The main purpose of this PR)
      5. trackingHandlePendingKeyInvalidations: Check the nesting level inside this function
      9c7c6924
  6. 30 Nov, 2022 1 commit
    • Huang Zhw's avatar
      Add a special notification unlink available only for modules (#9406) · c8181314
      Huang Zhw authored
      
      
      Add a new module event `RedisModule_Event_Key`, this event is fired
      when a key is removed from the keyspace.
      The event includes an open key that can be used for reading the key before
      it is removed. Modules can also extract the key-name, and use RM_Open
      or RM_Call to access key from within that event, but shouldn't modify anything
      from within this event.
      
      The following sub events are available:
        - `REDISMODULE_SUBEVENT_KEY_DELETED`
        - `REDISMODULE_SUBEVENT_KEY_EXPIRED`
        - `REDISMODULE_SUBEVENT_KEY_EVICTED`
        - `REDISMODULE_SUBEVENT_KEY_OVERWRITE`
      
      The data pointer can be casted to a RedisModuleKeyInfo structure
      with the following fields:
      ```
           RedisModuleKey *key;    // Opened Key
       ```
      
      ### internals
      
      * We also add two dict functions:
        `dictTwoPhaseUnlinkFind` finds an element from the table, also get the plink of the entry.
        The entry is returned if the element is found. The user should later call `dictTwoPhaseUnlinkFree`
        with it in order to unlink and release it. Otherwise if the key is not found, NULL is returned.
        These two functions should be used in pair. `dictTwoPhaseUnlinkFind` pauses rehash and
        `dictTwoPhaseUnlinkFree` resumes rehash.
      * We change `dbOverwrite` to `dbReplaceValue` which just replaces the value of the key and
        doesn't fire any events. The "overwrite" part (which emits events) is just when called from `setKey`,
        the other places that called dbOverwrite were ones that just update the value in-place (INCR*, SPOP,
        and dbUnshareStringValue). This should not have any real impact since `moduleNotifyKeyUnlink` and
        `signalDeletedKeyAsReady` wouldn't have mattered in these cases anyway (i.e. module keys and
        stream keys didn't have direct calls to dbOverwrite)
      * since we allow doing RM_OpenKey from withing these callbacks, we temporarily disable lazy expiry.
      * We also temporarily disable lazy expiry when we are in unlink/unlink2 callback and keyspace 
        notification callback.
      * Move special definitions to the top of redismodule.h
        This is needed to resolve compilation errors with RedisModuleKeyInfoV1
        that carries a RedisModuleKey member.
      Co-authored-by: default avatarOran Agra <oran@redislabs.com>
      c8181314
  7. 24 Nov, 2022 1 commit
    • Meir Shpilraien (Spielrein)'s avatar
      Module API to allow writes after key space notification hooks (#11199) · abc345ad
      Meir Shpilraien (Spielrein) authored
      ### Summary of API additions
      
      * `RedisModule_AddPostNotificationJob` - new API to call inside a key space
        notification (and on more locations in the future) and allow to add a post job as describe above.
      * New module option, `REDISMODULE_OPTIONS_ALLOW_NESTED_KEYSPACE_NOTIFICATIONS`,
        allows to disable Redis protection of nested key-space notifications.
      * `RedisModule_GetModuleOptionsAll` - gets the mask of all supported module options so a module
        will be able to check if a given option is supported by the current running Redis instance.
      
      ### Background
      
      The following PR is a proposal of handling write operations inside module key space notifications.
      After a lot of discussions we came to a conclusion that module should not perform any write
      operations on key space notification.
      
      Some examples of issues that such write operation can cause are describe on the following links:
      
      * Bad replication oreder - https://github.com/redis/redis/pull/10969
      * Used after free - https://github.com/redis/redis/pull/10969#issuecomment-1223771006
      * Used after free - https://github.com/redis/redis/pull/9406#issuecomment-1221684054
      
      
      
      There are probably more issues that are yet to be discovered. The underline problem with writing
      inside key space notification is that the notification runs synchronously, this means that the notification
      code will be executed in the middle on Redis logic (commands logic, eviction, expire).
      Redis **do not assume** that the data might change while running the logic and such changes
      can crash Redis or cause unexpected behaviour.
      
      The solution is to state that modules **should not** perform any write command inside key space
      notification (we can chose whether or not we want to force it). To still cover the use-case where
      module wants to perform a write operation as a reaction to key space notifications, we introduce
      a new API , `RedisModule_AddPostNotificationJob`, that allows to register a callback that will be
      called by Redis when the following conditions hold:
      
      * It is safe to perform any write operation.
      * The job will be called atomically along side the operation that triggers it (in our case, key
        space notification).
      
      Module can use this new API to safely perform any write operation and still achieve atomicity
      between the notification and the write.
      
      Although currently the API is supported on key space notifications, the API is written in a generic
      way so that in the future we will be able to use it on other places (server events for example).
      
      ### Technical Details
      
      Whenever a module uses `RedisModule_AddPostNotificationJob` the callback is added to a list
      of callbacks (called `modulePostExecUnitJobs`) that need to be invoke after the current execution
      unit ends (whether its a command, eviction, or active expire). In order to trigger those callback
      atomically with the notification effect, we call those callbacks on `postExecutionUnitOperations`
      (which was `propagatePendingCommands` before this PR). The new function fires the post jobs
      and then calls `propagatePendingCommands`.
      
      If the callback perform more operations that triggers more key space notifications. Those keys
      space notifications might register more callbacks. Those callbacks will be added to the end
      of `modulePostExecUnitJobs` list and will be invoke atomically after the current callback ends.
      This raises a concerns of entering an infinite loops, we consider infinite loops as a logical bug
      that need to be fixed in the module, an attempt to protect against infinite loops by halting the
      execution could result in violation of the feature correctness and so **Redis will make no attempt
      to protect the module from infinite loops**
      
      In addition, currently key space notifications are not nested. Some modules might want to allow
      nesting key-space notifications. To allow that and keep backward compatibility, we introduce a
      new module option called `REDISMODULE_OPTIONS_ALLOW_NESTED_KEYSPACE_NOTIFICATIONS`.
      Setting this option will disable the Redis key-space notifications nesting protection and will
      pass this responsibility to the module.
      
      ### Redis infrastructure
      
      This PR promotes the existing `propagatePendingCommands` to an "Execution Unit" concept,
      which is called after each atomic unit of execution,
      Co-authored-by: default avatarOran Agra <oran@redislabs.com>
      Co-authored-by: default avatarYossi Gottlieb <yossigo@gmail.com>
      Co-authored-by: default avatarMadelyn Olson <34459052+madolson@users.noreply.github.com>
      abc345ad
  8. 27 Oct, 2022 1 commit
    • Moti Cohen's avatar
      Refactor and (internally) rebrand from pause-clients to pause-actions (#11098) · c0d72262
      Moti Cohen authored
      Renamed from "Pause Clients" to "Pause Actions" since the mechanism can pause
      several actions in redis, not just clients (e.g. eviction, expiration).
      
      Previously each pause purpose (which has a timeout that's tracked separately from others purposes),
      also implicitly dictated what it pauses (reads, writes, eviction, etc). Now it is explicit, and
      the actions that are paused (bit flags) are defined separately from the purpose.
      
      - Previously, when using feature pause-client it also implicitly means to make the server static:
        - Pause replica traffic
        - Pauses eviction processing
        - Pauses expire processing
      
      Making the server static is used also for failover and shutdown. This PR internally rebrand
      pause-client API to become pause-action API. It also Simplifies pauseClients structure
      by replacing pointers array with static array.
      
      The context of this PR is to add another trigger to pause-client which will activated in case
      of OOM as throttling mechanism ([see here](https://github.com/redis/redis/issues/10907)).
      In this case we want only to pause client, and eviction actions.
      c0d72262
  9. 18 Sep, 2022 1 commit
    • zhaozhao.zz's avatar
      fix infinite sleep in performEvictions when have lazyfree jobs (#11237) · 464aa041
      zhaozhao.zz authored
      This bug is introduced in #7653. (Redis 6.2.0)
      
      When `server.maxmemory_eviction_tenacity` is 100, `eviction_time_limit_us` is
      `ULONG_MAX`, and if we cannot find the best key to delete (e.g. maxmemory-policy
      is `volatile-lru` and all keys with ttl have been evicted), in `cant_free` redis will sleep
      forever if some items are being freed in the lazyfree thread.
      464aa041
  10. 24 Aug, 2022 1 commit
    • Meir Shpilraien (Spielrein)'s avatar
      Reverts most of the changes of #10969 (#11178) · c1bd61a4
      Meir Shpilraien (Spielrein) authored
      The PR reverts the changes made on #10969.
      The reason for revert was trigger because of occasional test failure
      that started after the PR was merged.
      
      The issue is that if there is a lazy expire during the command invocation,
      the `del` command is added to the replication stream after the command
      placeholder. So the logical order on the primary is:
      
      * Delete the key (lazy expiration)
      * Command invocation
      
      But the replication stream gets it the other way around:
      
      * Command invocation (because the command is written into the placeholder)
      * Delete the key (lazy expiration)
      
      So if the command write to the key that was just lazy expired we will get
      inconsistency between primary and replica.
      
      One solution we considered is to add another lazy expire replication stream
      and write all the lazy expire there. Then when replicating, we will replicate the
      lazy expire replication stream first. This will solve this specific test failure but
      we realize that the issues does not ends here and the more we dig the more
      problems we find.One of the example we thought about (that can actually
      crashes Redis) is as follow:
      
      * User perform SINTERSTORE
      * When Redis tries to fetch the second input key it triggers lazy expire
      * The lazy expire trigger a module logic that deletes the first input key
      * Now Redis hold the robj of the first input key that was actually freed
      
      We believe we took the wrong approach and we will come up with another
      PR that solve the problem differently, for now we revert the changes so we
      will not have the tests failure.
      
      Notice that not the entire code was revert, some parts of the PR are changes
      that we would like to keep. The changes that **was** reverted are:
      
      * Saving a placeholder for replication at the beginning of the command (`call` function)
      * Order of the replication stream on active expire and eviction (we will decide how
        to handle it correctly on follow up PR)
      * `Spop` changes are no longer needed (because we reverted the placeholder code)
      
      Changes that **was not** reverted:
      
      * On expire/eviction, wrap the `del` and the notification effect in a multi exec.
      * `PropagateNow` function can still accept a special dbid, -1, indicating not to replicate select.
      * Keep optimisation for reusing the `alsoPropagate` array instead of allocating it each time.
      
      Tests:
      
      * All tests was kept and only few tests was modify to work correctly with the changes
      * Test was added to verify that the revert fixes the issues.
      c1bd61a4
  11. 18 Aug, 2022 1 commit
    • Meir Shpilraien (Spielrein)'s avatar
      Fix replication inconsistency on modules that uses key space notifications (#10969) · 508a1388
      Meir Shpilraien (Spielrein) authored
      Fix replication inconsistency on modules that uses key space notifications.
      
      ### The Problem
      
      In general, key space notifications are invoked after the command logic was
      executed (this is not always the case, we will discuss later about specific
      command that do not follow this rules). For example, the `set x 1` will trigger
      a `set` notification that will be invoked after the `set` logic was performed, so
      if the notification logic will try to fetch `x`, it will see the new data that was written.
      Consider the scenario on which the notification logic performs some write
      commands. for example, the notification logic increase some counter,
      `incr x{counter}`, indicating how many times `x` was changed.
      The logical order by which the logic was executed is has follow:
      
      ```
      set x 1
      incr x{counter}
      ```
      
      The issue is that the `set x 1` command is added to the replication buffer
      at the end of the command invocation (specifically after the key space
      notification logic was invoked and performed the `incr` command).
      The replication/aof sees the commands in the wrong order:
      
      ```
      incr x{counter}
      set x 1
      ```
      
      In this specific example the order is less important.
      But if, for example, the notification would have deleted `x` then we would
      end up with primary-replica inconsistency.
      
      ### The Solution
      
      Put the command that cause the notification in its rightful place. In the
      above example, the `set x 1` command logic was executed before the
      notification logic, so it should be added to the replication buffer before
      the commands that is invoked by the notification logic. To achieve this,
      without a major code refactoring, we save a placeholder in the replication
      buffer, when finishing invoking the command logic we check if the command
      need to be replicated, and if it does, we use the placeholder to add it to the
      replication buffer instead of appending it to the end.
      
      To be efficient and not allocating memory on each command to save the
      placeholder, the replication buffer array was modified to reuse memory
      (instead of allocating it each time we want to replicate commands).
      Also, to avoid saving a placeholder when not needed, we do it only for
      WRITE or MAY_REPLICATE commands.
      
      #### Additional Fixes
      
      * Expire and Eviction notifications:
        * Expire/Eviction logical order was to first perform the Expire/Eviction
          and then the notification logic. The replication buffer got this in the
          other way around (first notification effect and then the `del` command).
          The PR fixes this issue.
        * The notification effect and the `del` command was not wrap with
          `multi-exec` (if needed). The PR also fix this issue.
      * SPOP command:
        * On spop, the `spop` notification was fired before the command logic
          was executed. The change in this PR would have cause the replication
          order to be change (first `spop` command and then notification `logic`)
          although the logical order is first the notification logic and then the
          `spop` logic. The right fix would have been to move the notification to
          be fired after the command was executed (like all the other commands),
          but this can be considered a breaking change. To overcome this, the PR
          keeps the current behavior and changes the `spop` code to keep the right
          logical order when pushing commands to the replication buffer. Another PR
          will follow to fix the SPOP properly and match it to the other command (we
          split it to 2 separate PR's so it will be easy to cherry-pick this PR to 7.0 if
          we chose to).
      
      #### Unhanded Known Limitations
      
      * key miss event:
        * On key miss event, if a module performed some write command on the
          event (using `RM_Call`), the `dirty` counter would increase and the read
          command that cause the key miss event would be replicated to the replication
          and aof. This problem can also happened on a write command that open
          some keys but eventually decides not to perform any action. We decided
          not to handle this problem on this PR because the solution is complex
          and will cause additional risks in case we will want to cherry-pick this PR.
          We should decide if we want to handle it in future PR's. For now, modules
          writers is advice not to perform any write commands on key miss event.
      
      #### Testing
      
      * We already have tests to cover cases where a notification is invoking write
        commands that are also added to the replication buffer, the tests was modified
        to verify that the replica gets the command in the correct logical order.
      * Test was added to verify that `spop` behavior was kept unchanged.
      * Test was added to verify key miss event behave as expected.
      * Test was added to verify the changes do not break lazy expiration.
      
      #### Additional Changes
      
      * `propagateNow` function can accept a special dbid, -1, indicating not
        to replicate `select`. We use this to replicate `multi/exec` on `propagatePendingCommands`
        function. The side effect of this change is that now the `select` command
        will appear inside the `multi/exec` block on the replication stream (instead of
        outside of the `multi/exec` block). Tests was modified to match this new behavior.
      508a1388
  12. 21 Jun, 2022 1 commit
  13. 01 Jun, 2022 1 commit
    • Oran Agra's avatar
      Fix broken protocol in MISCONF error, RM_Yield bugs, RM_Call(EVAL) OOM check... · b2061de2
      Oran Agra authored
      Fix broken protocol in MISCONF error, RM_Yield bugs, RM_Call(EVAL) OOM check bug, and new RM_Call checks. (#10786)
      
      * Fix broken protocol when redis can't persist to RDB (general commands, not
        modules), excessive newline. regression of #10372 (7.0 RC3)
      * Fix broken protocol when Redis can't persist to AOF (modules and
        scripts), missing newline.
      * Fix bug in OOM check of EVAL scripts called from RM_Call.
        set the cached OOM state for scripts before executing module commands too,
        so that it can serve scripts that are executed by modules.
        i.e. in the past EVAL executed by RM_Call could have either falsely
        fail or falsely succeeded because of a wrong cached OOM state flag.
      * Fix bugs with RM_Yield:
        1. SHUTDOWN should only accept the NOSAVE mode
        2. Avoid eviction during yield command processing.
        3. Avoid processing master client commands while yielding from another client
      * Add new two more checks to RM_Call script mode.
        1. READONLY You can't write against a read only replica
        2. MASTERDOWN Link with MASTER is down and `replica-serve-stale-data` is set to `no`
      * Add new RM_Call flag to let redis automatically refuse `deny-oom` commands
        while over the memory limit. 
      * Add tests to cover various errors from Scripts, Modules, Modules
        calling scripts, and Modules calling commands in script mode.
      
      Add tests:
      * Looks like the MISCONF error was completely uncovered by the tests,
        add tests for it, including from scripts, and modules
      * Add tests for NOREPLICAS from scripts
      * Add tests for the various errors in module RM_Call, including RM_Call that
        calls EVAL, and RM_call in "eval mode". that includes:
        NOREPLICAS, READONLY, MASTERDOWN, MISCONF
      b2061de2
  14. 24 Apr, 2022 1 commit
    • guybe7's avatar
      isSafeToPerformEvictions: Remove redundant condition (#10610) · 8ad0cfa5
      guybe7 authored
      If was first added in #9890 to solve the problem of
      CONFIG SET maxmemory causing eviction inside MULTI/EXEC,
      but that problem is already fixed (CONFIG SET doesn't evict
      directly, it just schedules a later eviction)
      
      Keep that condition may hide bugs (i.e. performEvictions
      should always expect to have an empty server.also_propagate)
      8ad0cfa5
  15. 04 Jan, 2022 1 commit
    • zhaozhao.zz's avatar
      use startEvictionTimeProc() in config set maxmemory (#10019) · 2e1979a2
      zhaozhao.zz authored
      This would mean that the effects of `CONFIG SET maxmemory` may not be visible once the command returns.
      That could anyway happen since incremental eviction was added in redis 6.2 (see #7653)
      
      We do this to fix one of the propagation bugs about eviction see #9890 and #10014.
      2e1979a2
  16. 03 Jan, 2022 1 commit
    • chenyang8094's avatar
      Implement Multi Part AOF mechanism to avoid AOFRW overheads. (#9788) · 87789fae
      chenyang8094 authored
      
      
      Implement Multi-Part AOF mechanism to avoid overheads during AOFRW.
      Introducing a folder with multiple AOF files tracked by a manifest file.
      
      The main issues with the the original AOFRW mechanism are:
      * buffering of commands that are processed during rewrite (consuming a lot of RAM)
      * freezes of the main process when the AOFRW completes to drain the remaining part of the buffer and fsync it.
      * double disk IO for the data that arrives during AOFRW (had to be written to both the old and new AOF files)
      
      The main modifications of this PR:
      1. Remove the AOF rewrite buffer and related code.
      2. Divide the AOF into multiple files, they are classified as two types, one is the the `BASE` type,
        it represents the full amount of data (Maybe AOF or RDB format) after each AOFRW, there is only
        one `BASE` file at most. The second is `INCR` type, may have more than one. They represent the
        incremental commands since the last AOFRW.
      3. Use a AOF manifest file to record and manage these AOF files mentioned above.
      4. The original configuration of `appendfilename` will be the base part of the new file name, for example:
        `appendonly.aof.1.base.rdb` and `appendonly.aof.2.incr.aof`
      5. Add manifest-related TCL tests, and modified some existing tests that depend on the `appendfilename`
      6. Remove the `aof_rewrite_buffer_length` field in info.
      7. Add `aof-disable-auto-gc` configuration. By default we're automatically deleting HISTORY type AOFs.
        It also gives users the opportunity to preserve the history AOFs. just for testing use now.
      8. Add AOFRW limiting measure. When the AOFRW failures reaches the threshold (3 times now),
        we will delay the execution of the next AOFRW by 1 minute. If the next AOFRW also fails, it will be
        delayed by 2 minutes. The next is 4, 8, 16, the maximum delay is 60 minutes (1 hour). During the limit
        period, we can still use the 'bgrewriteaof' command to execute AOFRW immediately.
      9. Support upgrade (load) data from old version redis.
      10. Add `appenddirname` configuration, as the directory name of the append only files. All AOF files and
        manifest file will be placed in this directory.
      11. Only the last AOF file (BASE or INCR) can be truncated. Otherwise redis will exit even if
        `aof-load-truncated` is enabled.
      Co-authored-by: default avatarOran Agra <oran@redislabs.com>
      87789fae
  17. 22 Dec, 2021 1 commit
    • guybe7's avatar
      Sort out mess around propagation and MULTI/EXEC (#9890) · 7ac21307
      guybe7 authored
      The mess:
      Some parts use alsoPropagate for late propagation, others using an immediate one (propagate()),
      causing edge cases, ugly/hacky code, and the tendency for bugs
      
      The basic idea is that all commands are propagated via alsoPropagate (i.e. added to a list) and the
      top-most call() is responsible for going over that list and actually propagating them (and wrapping
      them in MULTI/EXEC if there's more than one command). This is done in the new function,
      propagatePendingCommands.
      
      Callers to propagatePendingCommands:
      1. top-most call() (we want all nested call()s to add to the also_propagate array and just the top-most
         one to propagate them) - via `afterCommand`
      2. handleClientsBlockedOnKeys: it is out of call() context and it may propagate stuff - via `afterCommand`. 
      3. handleClientsBlockedOnKeys edge case: if the looked-up key is already expired, we will propagate the
         expire but will not unblock any client so `afterCommand` isn't called. in that case, we have to propagate
         the deletion explicitly.
      4. cron stuff: active-expire and eviction may also propagate stuff
      5. modules: the module API allows to propagate stuff from just about anywhere (timers, keyspace notifications,
         threads). I could have tried to catch all the out-of-call-context places but it seemed easier to handle it in one
         place: when we free the context. in the spirit of what was done in call(), only the top-most freeing of a module
         context may cause propagation.
      6. modules: when using a thread-safe ctx it's not clear when/if the ctx will be freed. we do know that the module
         must lock the GIL before calling RM_Replicate/RM_Call so we propagate the pending commands when
         releasing the GIL.
      
      A "known limitation", which were actually a bug, was fixed because of this commit (see propagate.tcl):
         When using a mix of RM_Call with `!` and RM_Replicate, the command would propagate out-of-order:
         first all the commands from RM_Call, and then the ones from RM_Replicate
      
      Another thing worth mentioning is that if, in the past, a client would issue a MULTI/EXEC with just one
      write command the server would blindly propagate the MULTI/EXEC too, even though it's redundant.
      not anymore.
      
      This commit renames propagate() to propagateNow() in order to cause conflicts in pending PRs.
      propagatePendingCommands is the only caller of propagateNow, which is now a static, internal helper function.
      
      Optimizations:
      1. alsoPropagate will not add stuff to also_propagate if there's no AOF and replicas
      2. alsoPropagate reallocs also_propagagte exponentially, to save calls to memmove
      
      Bugfixes:
      1. CONFIG SET can create evictions, sending notifications which can cause to dirty++ with modules.
         we need to prevent it from propagating to AOF/replicas
      2. We need to set current_client in RM_Call. buggy scenario:
         - CONFIG SET maxmemory, eviction notifications, module hook calls RM_Call
         - assertion in lookupKey crashes, because current_client has CONFIG SET, which isn't CMD_WRITE
      3. minor: in eviction, call propagateDeletion after notification, like active-expire and all commands
         (we always send a notification before propagating the command)
      7ac21307
  18. 01 Dec, 2021 2 commits
    • meir@redislabs.com's avatar
      Redis Functions - Introduce script unit. · fc731bc6
      meir@redislabs.com authored
      Script unit is a new unit located on script.c.
      Its purpose is to provides an API for functions (and eval)
      to interact with Redis. Interaction includes mostly
      executing commands, but also functionalities like calling
      Redis back on long scripts or check if the script was killed.
      
      The interaction is done using a scriptRunCtx object that
      need to be created by the user and initialized using scriptPrepareForRun.
      
      Detailed list of functionalities expose by the unit:
      1. Calling commands (including all the validation checks such as
         acl, cluster, read only run, ...)
      2. Set Resp
      3. Set Replication method (AOF/REPLICATION/NONE)
      4. Call Redis back to on long running scripts to allow Redis reply
         to clients and perform script kill
      
      The commit introduce the new unit and uses it on eval commands to
      interact with Redis.
      fc731bc6
    • meir@redislabs.com's avatar
      Redis Functions - Move Lua related variable into luaCtx struct · e0cd580a
      meir@redislabs.com authored
      The following variable was renamed:
      1. lua_caller 			-> script_caller
      2. lua_time_limit 		-> script_time_limit
      3. lua_timedout 		-> script_timedout
      4. lua_oom 			-> script_oom
      5. lua_disable_deny_script 	-> script_disable_deny_script
      6. in_eval			-> in_script
      
      The following variables was moved to lctx under eval.c
      1.  lua
      2.  lua_client
      3.  lua_cur_script
      4.  lua_scripts
      5.  lua_scripts_mem
      6.  lua_replicate_commands
      7.  lua_write_dirty
      8.  lua_random_dirty
      9.  lua_multi_emitted
      10. lua_repl
      11. lua_kill
      12. lua_time_start
      13. lua_time_snapshot
      
      This commit is in a low risk of introducing any issues and it
      is just moving varibales around and not changing any logic.
      e0cd580a
  19. 25 Oct, 2021 1 commit
    • Wang Yuan's avatar
      Replication backlog and replicas use one global shared replication buffer (#9166) · c1718f9d
      Wang Yuan authored
      ## Background
      For redis master, one replica uses one copy of replication buffer, that is a big waste of memory,
      more replicas more waste, and allocate/free memory for every reply list also cost much.
      If we set client-output-buffer-limit small and write traffic is heavy, master may disconnect with
      replicas and can't finish synchronization with replica. If we set  client-output-buffer-limit big,
      master may be OOM when there are many replicas that separately keep much memory.
      Because replication buffers of different replica client are the same, one simple idea is that
      all replicas only use one replication buffer, that will effectively save memory.
      
      Since replication backlog content is the same as replicas' output buffer, now we
      can discard replication backlog memory and use global shared replication buffer
      to implement replication backlog mechanism.
      
      ## Implementation
      I create one global "replication buffer" which contains content of replication stream.
      The structure of "replication buffer" is similar to the reply list that exists in every client.
      But the node of list is `replBufBlock`, which has `id, repl_offset, refcount` fields.
      ```c
      /* Replication buffer blocks is the list of replBufBlock.
       *
       * +--------------+       +--------------+       +--------------+
       * | refcount = 1 |  ...  | refcount = 0 |  ...  | refcount = 2 |
       * +--------------+       +--------------+       +--------------+
       *      |                                            /       \
       *      |                                           /         \
       *      |                                          /           \
       *  Repl Backlog                               Replia_A      Replia_B
       * 
       * Each replica or replication backlog increments only the refcount of the
       * 'ref_repl_buf_node' which it points to. So when replica walks to the next
       * node, it should first increase the next node's refcount, and when we trim
       * the replication buffer nodes, we remove node always from the head node which
       * refcount is 0. If the refcount of the head node is not 0, we must stop
       * trimming and never iterate the next node. */
      
      /* Similar with 'clientReplyBlock', it is used for shared buffers between
       * all replica clients and replication backlog. */
      typedef struct replBufBlock {
          int refcount;           /* Number of replicas or repl backlog using. */
          long long id;           /* The unique incremental number. */
          long long repl_offset;  /* Start replication offset of the block. */
          size_t size, used;
          char buf[];
      } replBufBlock;
      ```
      So now when we feed replication stream into replication backlog and all replicas, we only need
      to feed stream into replication buffer `feedReplicationBuffer`. In this function, we set some fields of
      replication backlog and replicas to references of the global replication buffer blocks. And we also
      need to check replicas' output buffer limit to free if exceeding `client-output-buffer-limit`, and trim
      replication backlog if exceeding `repl-backlog-size`.
      
      When sending reply to replicas, we also need to iterate replication buffer blocks and send its
      content, when totally sending one block for replica, we decrease current node count and
      increase the next current node count, and then free the block which reference is 0 from the
      head of replication buffer blocks.
      
      Since now we use linked list to manage replication backlog, it may cost much time for iterating
      all linked list nodes to find corresponding replication buffer node. So we create a rax tree to
      store some nodes  for index, but to avoid rax tree occupying too much memory, i record
      one per 64 nodes for index.
      
      Currently, to make partial resynchronization as possible as much, we always let replication
      backlog as the last reference of replication buffer blocks, backlog size may exceeds our setting
      if slow replicas that reference vast replication buffer blocks, and this method doesn't increase
      memory usage since they share replication buffer. To avoid freezing server for freeing unreferenced
      replication buffer blocks when we need to trim backlog for exceeding backlog size setting,
      we trim backlog incrementally (free 64 blocks per call now), and make it faster in
      `beforeSleep` (free 640 blocks).
      
      ### Other changes
      - `mem_total_replication_buffers`: we add this field in INFO command, it means the total
        memory of replication buffers used.
      - `mem_clients_slaves`:  now even replica is slow to replicate, and its output buffer memory
        is not 0, but it still may be 0, since replication backlog and replicas share one global replication
        buffer, only if replication buffer memory is more than the repl backlog setting size, we consider
        the excess as replicas' memory. Otherwise, we think replication buffer memory is the consumption
        of repl backlog.
      - Key eviction
        Since all replicas and replication backlog share global replication buffer, we think only the
        part of exceeding backlog size the extra separate consumption of replicas.
        Because we trim backlog incrementally in the background, backlog size may exceeds our
        setting if slow replicas that reference vast replication buffer blocks disconnect.
        To avoid massive eviction loop, we don't count the delayed freed replication backlog into
        used memory even if there are no replicas, i.e. we also regard this memory as replicas's memory.
      - `client-output-buffer-limit` check for replica clients
        It doesn't make sense to set the replica clients output buffer limit lower than the repl-backlog-size
        config (partial sync will succeed and then replica will get disconnected). Such a configuration is
        ignored (the size of repl-backlog-size will be used). This doesn't have memory consumption
        implications since the replica client will share the backlog buffers memory.
      - Drop replication backlog after loading data if needed
        We always create replication backlog if server is a master, we need it because we put DELs in
        it when loading expired keys in RDB, but if RDB doesn't have replication info or there is no rdb,
        it is not possible to support partial resynchronization, to avoid extra memory of replication backlog,
        we drop it.
      - Multi IO threads
       Since all replicas and replication backlog use global replication buffer,  if I/O threads are enabled,
        to guarantee data accessing thread safe, we must let main thread handle sending the output buffer
        to all replicas. But before, other IO threads could handle sending output buffer of all replicas.
      
      ## Other optimizations
      This solution resolve some other problem:
      - When replicas disconnect with master since of out of output buffer limit, releasing the output
        buffer of replicas may freeze server if we set big `client-output-buffer-limit` for replicas, but now,
        it doesn't cause freezing.
      - This implementation may mitigate reply list copy cost time(also freezes server) when one replication
        has huge reply buffer and another replica can copy buffer for full synchronization. now, we just copy
        reference info, it is very light.
      - If we set replication backlog size big, it also may cost much time to copy replication backlog into
        replica's output buffer. But this commit eliminates this problem.
      - Resizing replication backlog size doesn't empty current replication backlog content.
      c1718f9d
  20. 23 Sep, 2021 1 commit
  21. 26 Jul, 2021 1 commit
    • Huang Zhw's avatar
      Add INFO stat total_eviction_exceeded_time and current_eviction_exceeded_time (#9031) · 17511df5
      Huang Zhw authored
      
      
      Add two INFO metrics:
      ```
      total_eviction_exceeded_time:69734
      current_eviction_exceeded_time:10230
      ```
      `current_eviction_exceeded_time` if greater than 0, means how much time current used memory is greater than `maxmemory`. And we are still over the maxmemory. If used memory is below `maxmemory`, this metric is reset to 0.
      `total_eviction_exceeded_time` means total time used memory is greater than `maxmemory` since server startup. 
      The units of these two metrics are ms.
      Co-authored-by: default avatarOran Agra <oran@redislabs.com>
      17511df5
  22. 13 Jun, 2021 1 commit
  23. 10 Jun, 2021 1 commit
    • Binbin's avatar
      Fixed some typos, add a spell check ci and others minor fix (#8890) · 0bfccc55
      Binbin authored
      This PR adds a spell checker CI action that will fail future PRs if they introduce typos and spelling mistakes.
      This spell checker is based on blacklist of common spelling mistakes, so it will not catch everything,
      but at least it is also unlikely to cause false positives.
      
      Besides that, the PR also fixes many spelling mistakes and types, not all are a result of the spell checker we use.
      
      Here's a summary of other changes:
      1. Scanned the entire source code and fixes all sorts of typos and spelling mistakes (including missing or extra spaces).
      2. Outdated function / variable / argument names in comments
      3. Fix outdated keyspace masks error log when we check `config.notify-keyspace-events` in loadServerConfigFromString.
      4. Trim the white space at the end of line in `module.c`. Check: https://github.com/redis/redis/pull/7751
      5. Some outdated https link URLs.
      6. Fix some outdated comment. Such as:
          - In README: about the rdb, we used to said create a `thread`, change to `process`
          - dbRandomKey function coment (about the dictGetRandomKey, change to dictGetFairRandomKey)
          - notifyKeyspaceEvent fucntion comment (add type arg)
          - Some others minor fix in comment (Most of them are incorrectly quoted by variable names)
      7. Modified the error log so that users can easily distinguish between TCP and TLS in `changeBindAddr`
      0bfccc55
  24. 30 May, 2021 1 commit
    • Wang Yuan's avatar
      Make full use of aofrwblock's buf (#8975) · 58a03eca
      Wang Yuan authored
      Make aof rewrite buffer memory size more accurate, before, there may be 20%
      deviation with its real memory usage.
      
      The implication are both lower memory usage, and also a more accurate INFO.
      58a03eca
  25. 20 May, 2021 1 commit
  26. 08 Feb, 2021 1 commit
  27. 08 Jan, 2021 1 commit
  28. 06 Dec, 2020 2 commits
    • Oran Agra's avatar
      prevent client tracking from causing feedback loop in performEvictions (#8100) · c4fdf09c
      Oran Agra authored
      When client tracking is enabled signalModifiedKey can increase memory usage,
      this can cause the loop in performEvictions to keep running since it was measuring
      the memory usage impact of signalModifiedKey.
      
      The section that measures the memory impact of the eviction should be just on dbDelete,
      excluding keyspace notification, client tracking, and propagation to AOF and replicas.
      
      This resolves part of the problem described in #8069
      p.s. fix took 1 minute, test took about 3 hours to write.
      c4fdf09c
    • Wang Yuan's avatar
      Limit the main db and expires dictionaries to expand (#7954) · 75f9dec6
      Wang Yuan authored
      As we know, redis may reject user's requests or evict some keys if
      used memory is over maxmemory. Dictionaries expanding may make
      things worse, some big dictionaries, such as main db and expires dict,
      may eat huge memory at once for allocating a new big hash table and be
      far more than maxmemory after expanding.
      There are related issues: #4213 #4583
      
      More details, when expand dict in redis, we will allocate a new big
      ht[1] that generally is double of ht[0], The size of ht[1] will be
      very big if ht[0] already is big. For db dict, if we have more than
      64 million keys, we need to cost 1GB for ht[1] when dict expands.
      
      If the sum of used memory and new hash table of dict needed exceeds
      maxmemory, we shouldn't allow the dict to expand. Because, if we
      enable keys eviction, we still couldn't add much more keys after
      eviction and rehashing, what's worse, redis will keep less keys when
      redis only remains a little memory for storing new hash table instead
      of users' data. Moreover users can't write data in redis if disable
      keys eviction.
      
      What this commit changed ?
      
      Add a new member function expandAllowed for dict type, it provide a way
      for caller to allow expand or not. We expose two parameters for this
      function: more memory needed for expanding and dict current load factor,
      users can implement a function to make a decision by them.
      For main db dict and expires dict type, these dictionaries may be very
      big and cost huge memory for expanding, so we implement a judgement
      function: we can stop dict to expand provisionally if used memory will
      be over maxmemory after dict expands, but to guarantee the performance
      of redis, we still allow dict to expand if dict load factor exceeds the
      safe load factor.
      Add test cases to verify we don't allow main db to expand when left
      memory is not enough, so that avoid keys eviction.
      
      Other changes:
      
      For new hash table size when expand. Before this commit, the size is
      that double used of dict and later _dictNextPower. Actually we aim to
      control a dict load factor between 0.5 and 1.0. Now we replace *2 with
      +1, since the first check is that used >= size, the outcome of before
      will usually be the same as _dictNextPower(used+1). The only case where
      it'll differ is when dict_can_resize is false during fork, so that later
      the _dictNextPower(used*2) will cause the dict to jump to *4 (i.e.
      _dictNextPower(1025*2) will return 4096).
      Fix rehash test cases due to changing algorithm of new hash table size
      when expand.
      75f9dec6
  29. 13 Oct, 2020 1 commit
    • guybe7's avatar
      performEvictions: mem_freed may be negative (#7908) · 37fd3d40
      guybe7 authored
      If 'delta' is negative 'mem_freed' may underflow and cause
      the while loop to exit prematurely (And not evicting enough
      memory)
      
      mem_freed can be negative when:
      1. We use lazy free (consuming memory by appending to a list)
      2. Thread doing an allocation between the two calls to zmalloc_used_memory.
      37fd3d40
  30. 17 Sep, 2020 1 commit
    • Wang Yuan's avatar
      Implement redisAtomic to replace _Atomic C11 builtin (#7707) · 445a4b66
      Wang Yuan authored
      Redis 6.0 introduces I/O threads, it is so cool and efficient, we use C11
      _Atomic to establish inter-thread synchronization without mutex. But the
      compiler that must supports C11 _Atomic can compile redis code, that brings a
      lot of inconvenience since some common platforms can't support by default such
      as CentOS7, so we want to implement redis atomic type to make it more portable.
      
      We have implemented our atomic variable for redis that only has 'relaxed'
      operations in src/atomicvar.h, so we implement some operations with
      'sequentially-consistent', just like the default behavior of C11 _Atomic that
      can establish inter-thread synchronization. And we replace all uses of C11
      _Atomic with redis atomic variable.
      
      Our implementation of redis atomic variable uses C11 _Atomic, __atomic or
      __sync macros if available, it supports most common platforms, and we will
      detect automatically which feature we use. In Makefile we use a dummy file to
      detect if the compiler supports C11 _Atomic. Now for gcc, we can compile redis
      code theoretically if your gcc version is not less than 4.1.2(starts to support
      __sync_xxx operations). Otherwise, we remove use mutex fallback to implement
      redis atomic variable for performance and test. You will get compiling errors
      if your compiler doesn't support all features of above.
      
      For cover redis atomic variable tests, we add other CI jobs that build redis on
      CentOS6 and CentOS7 and workflow daily jobs that run the tests on them.
      For them, we just install gcc by default in order to cover different compiler
      versions, gcc is 4.4.7 by default installation on CentOS6 and 4.8.5 on CentOS7.
      
      We restore the feature that we can test redis with Helgrind to find data race
      errors. But you need install Valgrind in the default path configuration firstly
      before running your tests, since we use macros in helgrind.h to tell Helgrind
      inter-thread happens-before relationship explicitly for avoiding false positives.
      Please open an issue on github if you find data race errors relate to this commit.
      
      Unrelated:
      - Fix redefinition of typedef 'RedisModuleUserChangedFunc'
        For some old version compilers, they will report errors or warnings, if we
        re-define function type.
      445a4b66
  31. 16 Sep, 2020 1 commit
    • Jim Brunner's avatar
      Incremental eviction processing (#7653) · 810e28a3
      Jim Brunner authored
      Rather than blindly evicting until maxmemory limit is achieved, this
      update adds a time limit to eviction.  While over the maxmemory limit,
      eviction will process before each command AND as a timeProc when no
      commands are running.
      
      This will reduce the latency impact on many cases, especially pathological
      cases like massive used memory increase during dict rehashing.
      
      There is a risk that some other edge cases (like massive pipelined use
      of MGET) could cause Redis memory usage to keep growing despite the
      eviction attempts, so a new maxmemory-eviction-tenacity config is
      introduced to let users mitigate that.
      810e28a3
  32. 10 Sep, 2020 1 commit
    • Oran Agra's avatar
      Squash merging 125 typo/grammar/comment/doc PRs (#7773) · 1c710385
      Oran Agra authored
      
      
      List of squashed commits or PRs
      ===============================
      
      commit 66801ea
      Author: hwware <wen.hui.ware@gmail.com>
      Date:   Mon Jan 13 00:54:31 2020 -0500
      
          typo fix in acl.c
      
      commit 46f55db
      Author: Itamar Haber <itamar@redislabs.com>
      Date:   Sun Sep 6 18:24:11 2020 +0300
      
          Updates a couple of comments
      
          Specifically:
      
          * RM_AutoMemory completed instead of pointing to docs
          * Updated link to custom type doc
      
      commit 61a2aa0
      Author: xindoo <xindoo@qq.com>
      Date:   Tue Sep 1 19:24:59 2020 +0800
      
          Correct errors in code comments
      
      commit a5871d1
      Author: yz1509 <pro-756@qq.com>
      Date:   Tue Sep 1 18:36:06 2020 +0800
      
          fix typos in module.c
      
      commit 41eede7
      Author: bookug <bookug@qq.com>
      Date:   Sat Aug 15 01:11:33 2020 +0800
      
          docs: fix typos in comments
      
      commit c303c84
      Author: lazy-snail <ws.niu@outlook.com>
      Date:   Fri Aug 7 11:15:44 2020 +0800
      
          fix spelling in redis.conf
      
      commit 1eb76bf
      Author: zhujian <zhujianxyz@gmail.com>
      Date:   Thu Aug 6 15:22:10 2020 +0800
      
          add a missing 'n' in comment
      
      commit 1530ec2
      Author: Daniel Dai <764122422@qq.com>
      Date:   Mon Jul 27 00:46:35 2020 -0400
      
          fix spelling in tracking.c
      
      commit e517b31
      Author: Hunter-Chen <huntcool001@gmail.com>
      Date:   Fri Jul 17 22:33:32 2020 +0800
      
          Update redis.conf
      Co-authored-by: default avatarItamar Haber <itamar@redislabs.com>
      
      commit c300eff
      Author: Hunter-Chen <huntcool001@gmail.com>
      Date:   Fri Jul 17 22:33:23 2020 +0800
      
          Update redis.conf
      Co-authored-by: default avatarItamar Haber <itamar@redislabs.com>
      
      commit 4c058a8
      Author: 陈浩鹏 <chenhaopeng@heytea.com>
      Date:   Thu Jun 25 19:00:56 2020 +0800
      
          Grammar fix and clarification
      
      commit 5fcaa81
      Author: bodong.ybd <bodong.ybd@alibaba-inc.com>
      Date:   Fri Jun 19 10:09:00 2020 +0800
      
          Fix typos
      
      commit 4caca9a
      Author: Pruthvi P <pruthvi@ixigo.com>
      Date:   Fri May 22 00:33:22 2020 +0530
      
          Fix typo eviciton => eviction
      
      commit b2a25f6
      Author: Brad Dunbar <dunbarb2@gmail.com>
      Date:   Sun May 17 12:39:59 2020 -0400
      
          Fix a typo.
      
      commit 12842ae
      Author: hwware <wen.hui.ware@gmail.com>
      Date:   Sun May 3 17:16:59 2020 -0400
      
          fix spelling in redis conf
      
      commit ddba07c
      Author: Chris Lamb <chris@chris-lamb.co.uk>
      Date:   Sat May 2 23:25:34 2020 +0100
      
          Correct a "conflicts" spelling error.
      
      commit 8fc7bf2
      Author: Nao YONASHIRO <yonashiro@r.recruit.co.jp>
      Date:   Thu Apr 30 10:25:27 2020 +0900
      
          docs: fix EXPIRE_FAST_CYCLE_DURATION to ACTIVE_EXPIRE_CYCLE_FAST_DURATION
      
      commit 9b2b67a
      Author: Brad Dunbar <dunbarb2@gmail.com>
      Date:   Fri Apr 24 11:46:22 2020 -0400
      
          Fix a typo.
      
      commit 0746f10
      Author: devilinrust <63737265+devilinrust@users.noreply.github.com>
      Date:   Thu Apr 16 00:17:53 2020 +0200
      
          Fix typos in server.c
      
      commit 92b588d
      Author: benjessop12 <56115861+benjessop12@users.noreply.github.com>
      Date:   Mon Apr 13 13:43:55 2020 +0100
      
          Fix spelling mistake in lazyfree.c
      
      commit 1da37aa
      Merge: 2d4ba28 af347a8c
      Author: hwware <wen.hui.ware@gmail.com>
      Date:   Thu Mar 5 22:41:31 2020 -0500
      
          Merge remote-tracking branch 'upstream/unstable' into expiretypofix
      
      commit 2d4ba28
      Author: hwware <wen.hui.ware@gmail.com>
      Date:   Mon Mar 2 00:09:40 2020 -0500
      
          fix typo in expire.c
      
      commit 1a746f7
      Author: SennoYuki <minakami1yuki@gmail.com>
      Date:   Thu Feb 27 16:54:32 2020 +0800
      
          fix typo
      
      commit 8599b1a
      Author: dongheejeong <donghee950403@gmail.com>
      Date:   Sun Feb 16 20:31:43 2020 +0000
      
          Fix typo in server.c
      
      commit f38d4e8
      Author: hwware <wen.hui.ware@gmail.com>
      Date:   Sun Feb 2 22:58:38 2020 -0500
      
          fix typo in evict.c
      
      commit fe143fc
      Author: Leo Murillo <leonardo.murillo@gmail.com>
      Date:   Sun Feb 2 01:57:22 2020 -0600
      
          Fix a few typos in redis.conf
      
      commit 1ab4d21
      Author: viraja1 <anchan.viraj@gmail.com>
      Date:   Fri Dec 27 17:15:58 2019 +0530
      
          Fix typo in Latency API docstring
      
      commit ca1f70e
      Author: gosth <danxuedexing@qq.com>
      Date:   Wed Dec 18 15:18:02 2019 +0800
      
          fix typo in sort.c
      
      commit a57c06b
      Author: ZYunH <zyunhjob@163.com>
      Date:   Mon Dec 16 22:28:46 2019 +0800
      
          fix-zset-typo
      
      commit b8c92b5
      Author: git-hulk <hulk.website@gmail.com>
      Date:   Mon Dec 16 15:51:42 2019 +0800
      
          FIX: typo in cluster.c, onformation->information
      
      commit 9dd981c
      Author: wujm2007 <jim.wujm@gmail.com>
      Date:   Mon Dec 16 09:37:52 2019 +0800
      
          Fix typo
      
      commit e132d7a
      Author: Sebastien Williams-Wynn <s.williamswynn.mail@gmail.com>
      Date:   Fri Nov 15 00:14:07 2019 +0000
      
          Minor typo change
      
      commit 47f44d5
      Author: happynote3966 <01ssrmikururudevice01@gmail.com>
      Date:   Mon Nov 11 22:08:48 2019 +0900
      
          fix comment typo in redis-cli.c
      
      commit b8bdb0d
      Author: fulei <fulei@kuaishou.com>
      Date:   Wed Oct 16 18:00:17 2019 +0800
      
          Fix a spelling mistake of comments  in defragDictBucketCallback
      
      commit 0def46a
      Author: fulei <fulei@kuaishou.com>
      Date:   Wed Oct 16 13:09:27 2019 +0800
      
          fix some spelling mistakes of comments in defrag.c
      
      commit f3596fd
      Author: Phil Rajchgot <tophil@outlook.com>
      Date:   Sun Oct 13 02:02:32 2019 -0400
      
          Typo and grammar fixes
      
          Redis and its documentation are great -- just wanted to submit a few corrections in the spirit of Hacktoberfest. Thanks for all your work on this project. I use it all the time and it works beautifully.
      
      commit 2b928cd
      Author: KangZhiDong <worldkzd@gmail.com>
      Date:   Sun Sep 1 07:03:11 2019 +0800
      
          fix typos
      
      commit 33aea14
      Author: Axlgrep <axlgrep@gmail.com>
      Date:   Tue Aug 27 11:02:18 2019 +0800
      
          Fixed eviction spelling issues
      
      commit e282a80
      Author: Simen Flatby <simen@oms.no>
      Date:   Tue Aug 20 15:25:51 2019 +0200
      
          Update comments to reflect prop name
      
          In the comments the prop is referenced as replica-validity-factor,
          but it is really named cluster-replica-validity-factor.
      
      commit 74d1f9a
      Author: Jim Green <jimgreen2013@qq.com>
      Date:   Tue Aug 20 20:00:31 2019 +0800
      
          fix comment error, the code is ok
      
      commit eea1407
      Author: Liao Tonglang <liaotonglang@gmail.com>
      Date:   Fri May 31 10:16:18 2019 +0800
      
          typo fix
      
          fix cna't to can't
      
      commit 0da553c
      Author: KAWACHI Takashi <tkawachi@gmail.com>
      Date:   Wed Jul 17 00:38:16 2019 +0900
      
          Fix typo
      
      commit 7fc8fb6
      Author: Michael Prokop <mika@grml.org>
      Date:   Tue May 28 17:58:42 2019 +0200
      
          Typo fixes
      
          s/familar/familiar/
          s/compatiblity/compatibility/
          s/ ot / to /
          s/itsef/itself/
      
      commit 5f46c9d
      Author: zhumoing <34539422+zhumoing@users.noreply.github.com>
      Date:   Tue May 21 21:16:50 2019 +0800
      
          typo-fixes
      
          typo-fixes
      
      commit 321dfe1
      Author: wxisme <850885154@qq.com>
      Date:   Sat Mar 16 15:10:55 2019 +0800
      
          typo fix
      
      commit b4fb131
      Merge: 267e0e6 3df1eb85
      Author: Nikitas Bastas <nikitasbst@gmail.com>
      Date:   Fri Feb 8 22:55:45 2019 +0200
      
          Merge branch 'unstable' of antirez/redis into unstable
      
      commit 267e0e6
      Author: Nikitas Bastas <nikitasbst@gmail.com>
      Date:   Wed Jan 30 21:26:04 2019 +0200
      
          Minor typo fix
      
      commit 30544e7
      Author: inshal96 <39904558+inshal96@users.noreply.github.com>
      Date:   Fri Jan 4 16:54:50 2019 +0500
      
          remove an extra 'a' in the comments
      
      commit 337969d
      Author: BrotherGao <yangdongheng11@gmail.com>
      Date:   Sat Dec 29 12:37:29 2018 +0800
      
          fix typo in redis.conf
      
      commit 9f4b121
      Merge: 423a030 e504583b
      Author: BrotherGao <yangdongheng@xiaomi.com>
      Date:   Sat Dec 29 11:41:12 2018 +0800
      
          Merge branch 'unstable' of antirez/redis into unstable
      
      commit 423a030
      Merge: 42b02b7 46a51cdc
      Author: 杨东衡 <yangdongheng@xiaomi.com>
      Date:   Tue Dec 4 23:56:11 2018 +0800
      
          Merge branch 'unstable' of antirez/redis into unstable
      
      commit 42b02b7
      Merge: 68c0e6e3 b8febe60
      
      
      Author: Dongheng Yang <yangdongheng11@gmail.com>
      Date:   Sun Oct 28 15:54:23 2018 +0800
      
          Merge pull request #1 from antirez/unstable
      
          update local data
      
      commit 714b589
      Author: Christian <crifei93@gmail.com>
      Date:   Fri Dec 28 01:17:26 2018 +0100
      
          fix typo "resulution"
      
      commit e23259d
      Author: garenchan <1412950785@qq.com>
      Date:   Wed Dec 26 09:58:35 2018 +0800
      
          fix typo: segfauls -> segfault
      
      commit a9359f8
      Author: xjp <jianping_xie@aliyun.com>
      Date:   Tue Dec 18 17:31:44 2018 +0800
      
          Fixed REDISMODULE_H spell bug
      
      commit a12c3e4
      Author: jdiaz <jrd.palacios@gmail.com>
      Date:   Sat Dec 15 23:39:52 2018 -0600
      
          Fixes hyperloglog hash function comment block description
      
      commit 770eb11
      Author: 林上耀 <1210tom@163.com>
      Date:   Sun Nov 25 17:16:10 2018 +0800
      
          fix typo
      
      commit fd97fbb
      Author: Chris Lamb <chris@chris-lamb.co.uk>
      Date:   Fri Nov 23 17:14:01 2018 +0100
      
          Correct "unsupported" typo.
      
      commit a85522d
      Author: Jungnam Lee <jungnam.lee@oracle.com>
      Date:   Thu Nov 8 23:01:29 2018 +0900
      
          fix typo in test comments
      
      commit ade8007
      Author: Arun Kumar <palerdot@users.noreply.github.com>
      Date:   Tue Oct 23 16:56:35 2018 +0530
      
          Fixed grammatical typo
      
          Fixed typo for word 'dictionary'
      
      commit 869ee39
      Author: Hamid Alaei <hamid.a85@gmail.com>
      Date:   Sun Aug 12 16:40:02 2018 +0430
      
          fix documentations: (ThreadSafeContextStart/Stop -> ThreadSafeContextLock/Unlock), minor typo
      
      commit f89d158
      Author: Mayank Jain <mayankjain255@gmail.com>
      Date:   Tue Jul 31 23:01:21 2018 +0530
      
          Updated README.md with some spelling corrections.
      
          Made correction in spelling of some misspelled words.
      
      commit 892198e
      Author: dsomeshwar <someshwar.dhayalan@gmail.com>
      Date:   Sat Jul 21 23:23:04 2018 +0530
      
          typo fix
      
      commit 8a4d780
      Author: Itamar Haber <itamar@redislabs.com>
      Date:   Mon Apr 30 02:06:52 2018 +0300
      
          Fixes some typos
      
      commit e3acef6
      Author: Noah Rosamilia <ivoahivoah@gmail.com>
      Date:   Sat Mar 3 23:41:21 2018 -0500
      
          Fix typo in /deps/README.md
      
      commit 04442fb
      Author: WuYunlong <xzsyeb@126.com>
      Date:   Sat Mar 3 10:32:42 2018 +0800
      
          Fix typo in readSyncBulkPayload() comment.
      
      commit 9f36880
      Author: WuYunlong <xzsyeb@126.com>
      Date:   Sat Mar 3 10:20:37 2018 +0800
      
          replication.c comment: run_id -> replid.
      
      commit f866b4a
      Author: Francesco 'makevoid' Canessa <makevoid@gmail.com>
      Date:   Thu Feb 22 22:01:56 2018 +0000
      
          fix comment typo in server.c
      
      commit 0ebc69b
      Author: 줍 <jubee0124@gmail.com>
      Date:   Mon Feb 12 16:38:48 2018 +0900
      
          Fix typo in redis.conf
      
          Fix `five behaviors` to `eight behaviors` in [this sentence ](antirez/redis@unstable/redis.conf#L564)
      
      commit b50a620
      Author: martinbroadhurst <martinbroadhurst@users.noreply.github.com>
      Date:   Thu Dec 28 12:07:30 2017 +0000
      
          Fix typo in valgrind.sup
      
      commit 7d8f349
      Author: Peter Boughton <peter@sorcerersisle.com>
      Date:   Mon Nov 27 19:52:19 2017 +0000
      
          Update CONTRIBUTING; refer doc updates to redis-doc repo.
      
      commit 02dec7e
      Author: Klauswk <klauswk1@hotmail.com>
      Date:   Tue Oct 24 16:18:38 2017 -0200
      
          Fix typo in comment
      
      commit e1efbc8
      Author: chenshi <baiwfg2@gmail.com>
      Date:   Tue Oct 3 18:26:30 2017 +0800
      
          Correct two spelling errors of comments
      
      commit 93327d8
      Author: spacewander <spacewanderlzx@gmail.com>
      Date:   Wed Sep 13 16:47:24 2017 +0800
      
          Update the comment for OBJ_ENCODING_EMBSTR_SIZE_LIMIT's value
      
          The value of OBJ_ENCODING_EMBSTR_SIZE_LIMIT is 44 now instead of 39.
      
      commit 63d361f
      Author: spacewander <spacewanderlzx@gmail.com>
      Date:   Tue Sep 12 15:06:42 2017 +0800
      
          Fix <prevlen> related doc in ziplist.c
      
          According to the definition of ZIP_BIG_PREVLEN and other related code,
          the guard of single byte <prevlen> should be 254 instead of 255.
      
      commit ebe228d
      Author: hanael80 <hanael80@gmail.com>
      Date:   Tue Aug 15 09:09:40 2017 +0900
      
          Fix typo
      
      commit 6b696e6
      Author: Matt Robenolt <matt@ydekproductions.com>
      Date:   Mon Aug 14 14:50:47 2017 -0700
      
          Fix typo in LATENCY DOCTOR output
      
      commit a2ec6ae
      Author: caosiyang <caosiyang@qiyi.com>
      Date:   Tue Aug 15 14:15:16 2017 +0800
      
          Fix a typo: form => from
      
      commit 3ab7699
      Author: caosiyang <caosiyang@qiyi.com>
      Date:   Thu Aug 10 18:40:33 2017 +0800
      
          Fix a typo: replicationFeedSlavesFromMaster() => replicationFeedSlavesFromMasterStream()
      
      commit 72d43ef
      Author: caosiyang <caosiyang@qiyi.com>
      Date:   Tue Aug 8 15:57:25 2017 +0800
      
          fix a typo: servewr => server
      
      commit 707c958
      Author: Bo Cai <charpty@gmail.com>
      Date:   Wed Jul 26 21:49:42 2017 +0800
      
          redis-cli.c typo: conut -> count.
      Signed-off-by: default avatarBo Cai <charpty@gmail.com>
      
      commit b9385b2
      Author: JackDrogon <jack.xsuperman@gmail.com>
      Date:   Fri Jun 30 14:22:31 2017 +0800
      
          Fix some spell problems
      
      commit 20d9230
      Author: akosel <aaronjkosel@gmail.com>
      Date:   Sun Jun 4 19:35:13 2017 -0500
      
          Fix typo
      
      commit b167bfc
      Author: Krzysiek Witkowicz <krzysiekwitkowicz@gmail.com>
      Date:   Mon May 22 21:32:27 2017 +0100
      
          Fix #4008 small typo in comment
      
      commit 2b78ac8
      Author: Jake Clarkson <jacobwclarkson@gmail.com>
      Date:   Wed Apr 26 15:49:50 2017 +0100
      
          Correct typo in tests/unit/hyperloglog.tcl
      
      commit b0f1cdb
      Author: Qi Luo <qiluo-msft@users.noreply.github.com>
      Date:   Wed Apr 19 14:25:18 2017 -0700
      
          Fix typo
      
      commit a90b0f9
      Author: charsyam <charsyam@naver.com>
      Date:   Thu Mar 16 18:19:53 2017 +0900
      
          fix typos
      
          fix typos
      
          fix typos
      
      commit 8430a79
      Author: Richard Hart <richardhart92@gmail.com>
      Date:   Mon Mar 13 22:17:41 2017 -0400
      
          Fixed log message typo in listenToPort.
      
      commit 481a1c2
      Author: Vinod Kumar <kumar003vinod@gmail.com>
      Date:   Sun Jan 15 23:04:51 2017 +0530
      
          src/db.c: Correct "save" -> "safe" typo
      
      commit 586b4d3
      Author: wangshaonan <wshn13@gmail.com>
      Date:   Wed Dec 21 20:28:27 2016 +0800
      
          Fix typo they->the in helloworld.c
      
      commit c1c4b5e
      Author: Jenner <hypxm@qq.com>
      Date:   Mon Dec 19 16:39:46 2016 +0800
      
          typo error
      
      commit 1ee1a3f
      Author: tielei <43289893@qq.com>
      Date:   Mon Jul 18 13:52:25 2016 +0800
      
          fix some comments
      
      commit 11a41fb
      Author: Otto Kekäläinen <otto@seravo.fi>
      Date:   Sun Jul 3 10:23:55 2016 +0100
      
          Fix spelling in documentation and comments
      
      commit 5fb5d82
      Author: francischan <f1ancis621@gmail.com>
      Date:   Tue Jun 28 00:19:33 2016 +0800
      
          Fix outdated comments about redis.c file.
          It should now refer to server.c file.
      
      commit 6b254bc
      Author: lmatt-bit <lmatt123n@gmail.com>
      Date:   Thu Apr 21 21:45:58 2016 +0800
      
          Refine the comment of dictRehashMilliseconds func
      
      SLAVECONF->REPLCONF in comment - by andyli029
      
      commit ee9869f
      Author: clark.kang <charsyam@naver.com>
      Date:   Tue Mar 22 11:09:51 2016 +0900
      
          fix typos
      
      commit f7b3b11
      Author: Harisankar H <harisankarh@gmail.com>
      Date:   Wed Mar 9 11:49:42 2016 +0530
      
          Typo correction: "faield" --> "failed"
      
          Typo correction: "faield" --> "failed"
      
      commit 3fd40fc
      Author: Itamar Haber <itamar@redislabs.com>
      Date:   Thu Feb 25 10:31:51 2016 +0200
      
          Fixes a typo in comments
      
      commit 621c160
      Author: Prayag Verma <prayag.verma@gmail.com>
      Date:   Mon Feb 1 12:36:20 2016 +0530
      
          Fix typo in Readme.md
      
          Spelling mistakes -
          `eviciton` > `eviction`
          `familar` > `familiar`
      
      commit d7d07d6
      Author: WonCheol Lee <toctoc21c@gmail.com>
      Date:   Wed Dec 30 15:11:34 2015 +0900
      
          Typo fixed
      
      commit a4dade7
      Author: Felix Bünemann <buenemann@louis.info>
      Date:   Mon Dec 28 11:02:55 2015 +0100
      
          [ci skip] Improve supervised upstart config docs
      
          This mentions that "expect stop" is required for supervised upstart
          to work correctly. See http://upstart.ubuntu.com/cookbook/#expect-stop
      
      
          for an explanation.
      
      commit d9caba9
      Author: daurnimator <quae@daurnimator.com>
      Date:   Mon Dec 21 18:30:03 2015 +1100
      
          README: Remove trailing whitespace
      
      commit 72d42e5
      Author: daurnimator <quae@daurnimator.com>
      Date:   Mon Dec 21 18:29:32 2015 +1100
      
          README: Fix typo. th => the
      
      commit dd6e957
      Author: daurnimator <quae@daurnimator.com>
      Date:   Mon Dec 21 18:29:20 2015 +1100
      
          README: Fix typo. familar => familiar
      
      commit 3a12b23
      Author: daurnimator <quae@daurnimator.com>
      Date:   Mon Dec 21 18:28:54 2015 +1100
      
          README: Fix typo. eviciton => eviction
      
      commit 2d1d03b
      Author: daurnimator <quae@daurnimator.com>
      Date:   Mon Dec 21 18:21:45 2015 +1100
      
          README: Fix typo. sever => server
      
      commit 3973b06
      Author: Itamar Haber <itamar@garantiadata.com>
      Date:   Sat Dec 19 17:01:20 2015 +0200
      
          Typo fix
      
      commit 4f2e460
      Author: Steve Gao <fu@2token.com>
      Date:   Fri Dec 4 10:22:05 2015 +0800
      
          Update README - fix typos
      
      commit b21667c
      Author: binyan <binbin.yan@nokia.com>
      Date:   Wed Dec 2 22:48:37 2015 +0800
      
          delete redundancy color judge in sdscatcolor
      
      commit 88894c7
      Author: binyan <binbin.yan@nokia.com>
      Date:   Wed Dec 2 22:14:42 2015 +0800
      
          the example output shoule be HelloWorld
      
      commit 2763470
      Author: binyan <binbin.yan@nokia.com>
      Date:   Wed Dec 2 17:41:39 2015 +0800
      
          modify error word keyevente
      Signed-off-by: default avatarbinyan <binbin.yan@nokia.com>
      
      commit 0847b3d
      Author: Bruno Martins <bscmartins@gmail.com>
      Date:   Wed Nov 4 11:37:01 2015 +0000
      
          typo
      
      commit bbb9e9e
      Author: dawedawe <dawedawe@gmx.de>
      Date:   Fri Mar 27 00:46:41 2015 +0100
      
          typo: zimap -> zipmap
      
      commit 5ed297e
      Author: Axel Advento <badwolf.bloodseeker.rev@gmail.com>
      Date:   Tue Mar 3 15:58:29 2015 +0800
      
          Fix 'salve' typos to 'slave'
      
      commit edec9d6
      Author: LudwikJaniuk <ludvig.janiuk@gmail.com>
      Date:   Wed Jun 12 14:12:47 2019 +0200
      
          Update README.md
      Co-Authored-By: default avatarQix <Qix-@users.noreply.github.com>
      
      commit 692a7af
      Author: LudwikJaniuk <ludvig.janiuk@gmail.com>
      Date:   Tue May 28 14:32:04 2019 +0200
      
          grammar
      
      commit d962b0a
      Author: Nick Frost <nickfrostatx@gmail.com>
      Date:   Wed Jul 20 15:17:12 2016 -0700
      
          Minor grammar fix
      
      commit 24fff01aaccaf5956973ada8c50ceb1462e211c6 (typos)
      Author: Chad Miller <chadm@squareup.com>
      Date:   Tue Sep 8 13:46:11 2020 -0400
      
          Fix faulty comment about operation of unlink()
      
      commit 3cd5c1f3326c52aa552ada7ec797c6bb16452355
      Author: Kevin <kevin.xgr@gmail.com>
      Date:   Wed Nov 20 00:13:50 2019 +0800
      
          Fix typo in server.c.
      
      From a83af59 Mon Sep 17 00:00:00 2001
      From: wuwo <wuwo@wacai.com>
      Date: Fri, 17 Mar 2017 20:37:45 +0800
      Subject: [PATCH] falure to failure
      
      From c961896 Mon Sep 17 00:00:00 2001
      From: =?UTF-8?q?=E5=B7=A6=E6=87=B6?= <veficos@gmail.com>
      Date: Sat, 27 May 2017 15:33:04 +0800
      Subject: [PATCH] fix typo
      
      From e600ef2 Mon Sep 17 00:00:00 2001
      From: "rui.zou" <rui.zou@yunify.com>
      Date: Sat, 30 Sep 2017 12:38:15 +0800
      Subject: [PATCH] fix a typo
      
      From c7d07fa Mon Sep 17 00:00:00 2001
      From: Alexandre Perrin <alex@kaworu.ch>
      Date: Thu, 16 Aug 2018 10:35:31 +0200
      Subject: [PATCH] deps README.md typo
      
      From b25cb67 Mon Sep 17 00:00:00 2001
      From: Guy Korland <gkorland@gmail.com>
      Date: Wed, 26 Sep 2018 10:55:37 +0300
      Subject: [PATCH 1/2] fix typos in header
      
      From ad28ca6 Mon Sep 17 00:00:00 2001
      From: Guy Korland <gkorland@gmail.com>
      Date: Wed, 26 Sep 2018 11:02:36 +0300
      Subject: [PATCH 2/2] fix typos
      
      commit 34924cdedd8552466fc22c1168d49236cb7ee915
      Author: Adrian Lynch <adi_ady_ade@hotmail.com>
      Date:   Sat Apr 4 21:59:15 2015 +0100
      
          Typos fixed
      
      commit fd2a1e7
      Author: Jan <jsteemann@users.noreply.github.com>
      Date:   Sat Oct 27 19:13:01 2018 +0200
      
          Fix typos
      
          Fix typos
      
      commit e14e47c1a234b53b0e103c5f6a1c61481cbcbb02
      Author: Andy Lester <andy@petdance.com>
      Date:   Fri Aug 2 22:30:07 2019 -0500
      
          Fix multiple misspellings of "following"
      
      commit 79b948ce2dac6b453fe80995abbcaac04c213d5a
      Author: Andy Lester <andy@petdance.com>
      Date:   Fri Aug 2 22:24:28 2019 -0500
      
          Fix misspelling of create-cluster
      
      commit 1fffde52666dc99ab35efbd31071a4c008cb5a71
      Author: Andy Lester <andy@petdance.com>
      Date:   Wed Jul 31 17:57:56 2019 -0500
      
          Fix typos
      
      commit 204c9ba9651e9e05fd73936b452b9a30be456cfe
      Author: Xiaobo Zhu <xiaobo.zhu@shopee.com>
      Date:   Tue Aug 13 22:19:25 2019 +0800
      
          fix typos
      
      Squashed commit of the following:
      
      commit 1d9aaf8
      Author: danmedani <danmedani@gmail.com>
      Date:   Sun Aug 2 11:40:26 2015 -0700
      
      README typo fix.
      
      Squashed commit of the following:
      
      commit 32bfa7c
      Author: Erik Dubbelboer <erik@dubbelboer.com>
      Date:   Mon Jul 6 21:15:08 2015 +0200
      
      Fixed grammer
      
      Squashed commit of the following:
      
      commit b24f69c
      Author: Sisir Koppaka <sisir.koppaka@gmail.com>
      Date:   Mon Mar 2 22:38:45 2015 -0500
      
      utils/hashtable/rehashing.c: Fix typos
      
      Squashed commit of the following:
      
      commit 4e04082
      Author: Erik Dubbelboer <erik@dubbelboer.com>
      Date:   Mon Mar 23 08:22:21 2015 +0000
      
      Small config file documentation improvements
      
      Squashed commit of the following:
      
      commit acb8773
      Author: ctd1500 <ctd1500@gmail.com>
      Date:   Fri May 8 01:52:48 2015 -0700
      
      Typo and grammar fixes in readme
      
      commit 2eb75b6
      Author: ctd1500 <ctd1500@gmail.com>
      Date:   Fri May 8 01:36:18 2015 -0700
      
      fixed redis.conf comment
      
      Squashed commit of the following:
      
      commit a8249a2
      Author: Masahiko Sawada <sawada.mshk@gmail.com>
      Date:   Fri Dec 11 11:39:52 2015 +0530
      
      Revise correction of typos.
      
      Squashed commit of the following:
      
      commit 3c02028
      Author: zhaojun11 <zhaojun11@jd.com>
      Date:   Wed Jan 17 19:05:28 2018 +0800
      
      Fix typos include two code typos in cluster.c and latency.c
      
      Squashed commit of the following:
      
      commit 9dba47c
      Author: q191201771 <191201771@qq.com>
      Date:   Sat Jan 4 11:31:04 2020 +0800
      
      fix function listCreate comment in adlist.c
      
      Update src/server.c
      
      commit 2c7c2cb536e78dd211b1ac6f7bda00f0f54faaeb
      Author: charpty <charpty@gmail.com>
      Date:   Tue May 1 23:16:59 2018 +0800
      
          server.c typo: modules system dictionary type comment
      Signed-off-by: default avatarcharpty <charpty@gmail.com>
      
      commit a8395323fb63cb59cb3591cb0f0c8edb7c29a680
      Author: Itamar Haber <itamar@redislabs.com>
      Date:   Sun May 6 00:25:18 2018 +0300
      
          Updates test_helper.tcl's help with undocumented options
      
          Specifically:
      
          * Host
          * Port
          * Client
      
      commit bde6f9ced15755cd6407b4af7d601b030f36d60b
      Author: wxisme <850885154@qq.com>
      Date:   Wed Aug 8 15:19:19 2018 +0800
      
          fix comments in deps files
      
      commit 3172474ba991532ab799ee1873439f3402412331
      Author: wxisme <850885154@qq.com>
      Date:   Wed Aug 8 14:33:49 2018 +0800
      
          fix some comments
      
      commit 01b6f2b6858b5cf2ce4ad5092d2c746e755f53f0
      Author: Thor Juhasz <thor@juhasz.pro>
      Date:   Sun Nov 18 14:37:41 2018 +0100
      
          Minor fixes to comments
      
          Found some parts a little unclear on a first read, which prompted me to have a better look at the file and fix some minor things I noticed.
          Fixing minor typos and grammar. There are no changes to configuration options.
          These changes are only meant to help the user better understand the explanations to the various configuration options
      1c710385
  33. 30 Apr, 2020 1 commit
  34. 22 Apr, 2020 1 commit
  35. 07 Oct, 2019 1 commit
    • Oran Agra's avatar
      fix issues found by a static analyzer · d1a005ab
      Oran Agra authored
      cluster.c - stack buffer memory alignment
          The pointer 'buf' is cast to a more strictly aligned pointer type
      evict.c - lazyfree_lazy_eviction, lazyfree_lazy_eviction always called
      defrag.c - bug in dead code
      server.c - casting was missing parenthesis
      rax.c - indentation / newline suggested an 'else if' was intended
      d1a005ab
  36. 06 May, 2019 1 commit
  37. 12 Dec, 2018 1 commit
  38. 11 Dec, 2018 1 commit
    • zhaozhao.zz's avatar
      evict: don't care about mem if loading · b9cd89d1
      zhaozhao.zz authored
      When loading data, we call processEventsWhileBlocked
      to process events and execute commands.
      But if we are loading AOF it's dangerous, because
      processCommand would call freeMemoryIfNeeded to evict,
      and that will break data consistency, see issue #5686.
      b9cd89d1