• 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
redis.conf 93.5 KB