为什么RedisCluster采用16384个槽位?

/* We have 16384 hash slots. The hash slot of a given key is obtained
 * as the least significant 14 bits of the crc16 of the key.
 *
 * However if the key contains the {...} pattern, only the part between
 * { and } is hashed. This may be useful in the future to force certain
 * keys to be in the same node (assuming no resharding is in progress). */
unsigned int keyHashSlot(char *key, int keylen) {
    int s, e; /* start-end indexes of { and } */

    for (s = 0; s < keylen; s++)
        if (key[s] == '{') break;

    /* No '{' ? Hash the whole key. This is the base case. */
    if (s == keylen) return crc16(key,keylen) & 0x3FFF;

    /* '{' found? Check if we have the corresponding '}'. */
    for (e = s+1; e < keylen; e++)
        if (key[e] == '}') break;

    /* No '}' or nothing between {} ? Hash the whole key. */
    if (e == keylen || e == s+1) return crc16(key,keylen) & 0x3FFF;

    /* If we are here there is both a { and a } on its right. Hash
     * what is in the middle between { and }. */
    return crc16(key+s+1,e-s-1) & 0x3FFF;
}

/* Message types.
 *
 * Note that the PING, PONG and MEET messages are actually the same exact
 * kind of packet. PONG is the reply to ping, in the exact format as a PING,
 * while MEET is a special PING that forces the receiver to add the sender
 * as a node (if it is not already in the list). */
#define CLUSTERMSG_TYPE_PING 0          /* Ping */
#define CLUSTERMSG_TYPE_PONG 1          /* Pong (reply to Ping) */
#define CLUSTERMSG_TYPE_MEET 2          /* Meet "let's join" message */
#define CLUSTERMSG_TYPE_FAIL 3          /* Mark node xxx as failing */
#define CLUSTERMSG_TYPE_PUBLISH 4       /* Pub/Sub Publish propagation */
#define CLUSTERMSG_TYPE_FAILOVER_AUTH_REQUEST 5 /* May I failover? */
#define CLUSTERMSG_TYPE_FAILOVER_AUTH_ACK 6     /* Yes, you have my vote */
#define CLUSTERMSG_TYPE_UPDATE 7        /* Another node slots configuration */
#define CLUSTERMSG_TYPE_MFSTART 8       /* Pause clients for manual failover */
#define CLUSTERMSG_TYPE_MODULE 9        /* Module cluster API message. */
#define CLUSTERMSG_TYPE_COUNT 10        /* Total number of message types. */

#define CLUSTER_SLOTS 16384

typedef struct {
    char sig[4];        /* 签名“RCmb”（Redis群集消息总线） */
    uint32_t totlen;    /* 消息的总长度 */
    uint16_t ver;       /* 协议版本，目前设置为1 */
    uint16_t port;      /* TCP基本端口号r. */
    uint16_t type;      /* 消息类型 */
    uint16_t count;     /* 仅用于某种消息 */
    uint64_t currentEpoch;  /* 相应于发送节点的纪元 */
    uint64_t configEpoch;   /* 如果是主服务器的配置纪元，或者如果它是从
                                                         服务器则由其主服务器通告的最后一个纪元 */
    uint64_t offset;    /* 如果节点是从属节点，则节点是主节点或已处理的
                                                 复制偏移量时，主复制偏移量 */
    char sender[CLUSTER_NAMELEN]; /* 发件人节点的名称 */
    unsigned char myslots[CLUSTER_SLOTS/8]; /* 发送节点负责的槽信息 */
    char slaveof[CLUSTER_NAMELEN]; /* 如果发送节点是从节点，记录对应主节点的nodeId */
    char myip[NET_IP_STR_LEN];    /* 发件人IP，如果不存在则为零 */
    char notused1[34];  /* 34个保留字节供将来使用 */
    uint16_t cport;      /* Sender TCP集群总线端口 */
    uint16_t flags;      /* 发件人节点标志 */
    unsigned char state; /* 来自发件人POV的集群状态 */
    unsigned char mflags[3]; /* 消息标志：CLUSTERMSG_FLAG [012] _... */
    union clusterMsgData data; /* 群集消息数据 */
} clusterMsg;

/* 每秒执行10次 */
void clusterCron(void) {
    /* 省略部分代码... */
    /* 每10次迭代对一些随机节点进行1次ping操作，这样我们通常每秒ping一个随机节点 */
    if (!(iteration % 10)) {
        int j;

        /* 检查几个随机节点并使用最早的pong_received时间ping一个节点. */
        for (j = 0; j nodes);
            clusterNode *this = dictGetVal(de);

            /* Don't ping nodes disconnected or with a ping currently active.
            /* 不要ping断开连接的节点或当前活跃的节点. */
            if (this->link == NULL || this->ping_sent != 0) continue;
            if (this->flags & (CLUSTER_NODE_MYSELF|CLUSTER_NODE_HANDSHAKE))
                continue;
            if (min_pong_node == NULL || min_pong > this->pong_received) {
                min_pong_node = this;
                min_pong = this->pong_received;
            }
        }
        if (min_pong_node) {
            serverLog(LL_DEBUG,"Pinging node %.40s", min_pong_node->name);
            clusterSendPing(min_pong_node->link, CLUSTERMSG_TYPE_PING);
        }
    }
    /* 省略部分代码... */
    di = dictGetSafeIterator(server.cluster->nodes);
    while((de = dictNext(di)) != NULL) {
        /* 省略部分代码... */
        /* 如果我们当前在此实例中没有活动的ping，并且收到的PONG早于
         * 群集超时的一半，则立即发送新的ping，以确保所有节点都被ping，
         * 而没有太大的延迟 */
        if (node->link &&
            node->ping_sent == 0 &&
            (now - node->pong_received) > server.cluster_node_timeout/2)
        {
            clusterSendPing(node->link, CLUSTERMSG_TYPE_PING);
            continue;
        }
        /* 省略部分代码... */
        }
    dictReleaseIterator(di);
}