/* The Redis HyperLogLog implementation is based on the following ideas:
Redis的超对数实现是基于以下的想法：
 * * The use of a 64 bit hash function as proposed in [1], in order to don't
 *   limited to cardinalities up to 10^9, at the cost of just 1 additional
 *   bit per register.
使用文1推荐的64位的哈希函数，仅用对每个寄存器增加一个比特的代价，就可以突破基数个数10的9次方的限制。
 * * The use of 16384 6-bit registers for a great level of accuracy, using
 *   a total of 12k per key.
为了获得一个比较高的精度，使用16384个6比特的寄存器，每个键值使用了12k(2的14次方 * 6 = 12k)
 * * The use of the Redis string data type. No new type is introduced.
 * * No attempt is made to compress the data structure as in [1]. Also the
 *   algorithm used is the original HyperLogLog Algorithm as in [2], with
 *   the only difference that a 64 bit hash function is used, so no correction
 *   is performed for values near 2^32 as in [1].
使用的是redis的字符串类型，没有引入新的数据类型。
没有采用文1中压缩数据结构的算法。同时使用了文2中原始的超对数算法，唯一不同的是使用了64位的哈希函数，
所以不用对类似文1中接近2^32的值做修正。
 * [1] Heule, Nunkesser, Hall: HyperLogLog in Practice: Algorithmic
 *     Engineering of a State of The Art Cardinality Estimation Algorithm.
 *
 * [2] P. Flajolet, Eric Fusy, O. Gandouet, and F. Meunier. Hyperloglog: The
 *     analysis of a near-optimal cardinality estimation algorithm.
(这两篇文章留到后面再慢慢翻译)
 * Redis uses two representations:
redis使用两种表示方式：
 * 1) A "dense" representation where every entry is represented by
 *    a 6-bit integer.
密集表示方式 每个实体用6比特整数来表示
 * 2) A "sparse" representation using run length compression suitable
 *    for representing HyperLogLogs with many registers set to 0 in
 *    a memory efficient way.
稀疏表示方式  使用行程长的压缩方式表示具有很多个0值寄存器的超级日志，这是一中非常有效的内存表示方法
 *
 * HLL header  HLL的头部
 * ===
 *
 * Both the dense and sparse representation have a 16 byte header as follows:
密集和稀疏的表示都拥有一个16个字节的如下头部：
 * +------+---+-----+----------+
 * | HYLL | E | N/U | Cardin.  |
 * +------+---+-----+----------+
 *
 * The first 4 bytes are a magic string set to the bytes "HYLL".
 * "E" is one byte encoding, currently set to HLL_DENSE or
 * HLL_SPARSE. N/U are three not used bytes.
开始的4个字节是一个魔法数，被设置为HYLL.
E表示一个字节的编码，当前用来设置HLL_DENSE或者HLL_SPARSE。N/U是3个还么有被使用的字节。
 * The "Cardin." field is a 64 bit integer stored in little endian format
 * with the latest cardinality computed that can be reused if the data
 * structure was not modified since the last computation (this is useful
 * because there are high probabilities that HLLADD operations don't
 * modify the actual data structure and hence the approximated cardinality).
Cardin.字段 是一个小端格式保存的最近计算得到64位的集合中元素个数。
如果自从上次计算之后数据结构没有发生变化，那么可以这个数值可以重复使用。
(这个是很有用的，因为HLLADD操作大概率不会修改实际的数据结构，从而不需要修改近似的集合中元素个数)

 * When the most significant bit in the most significant byte of the cached
 * cardinality is set, it means that the data structure was modified and
 * we can't reuse the cached value that must be recomputed.
一旦缓存基数的最重要字节的最重要的比特位被设置，
那就意味着数据结构被修改并且我们不能使用缓存的值，必须要重新计算
 * Dense representation  密集表示
 * ===
 *
 * The dense representation used by Redis is the following:
redis使用的密集表示如下
 * +--------+--------+--------+------//      //--+
 * |11000000|22221111|33333322|55444444 ....     |
 * +--------+--------+--------+------//      //--+
 *
 * The 6 bits counters are encoded one after the other starting from the
 * LSB to the MSB, and using the next bytes as needed.
6个比特位从lsb到msb依次编码，根据情况使用下一个字节的比特位。

 * Sparse representation 稀疏表示
 * ===
 *
 * The sparse representation encodes registers using a run length
 * encoding composed of three opcodes, two using one byte, and one using
 * of two bytes. The opcodes are called ZERO, XZERO and VAL.
稀疏表示编码寄存器使用了包含3种操作符的行程长编码，其中两个操作符使用1个字节，一个操作符使用两个字节。
这三个操作符分别为 ZERO, XZERO and VAL.
 * ZERO opcode is represented as 00xxxxxx. The 6-bit integer represented
 * by the six bits 'xxxxxx', plus 1, means that there are N registers set
 * to 0. This opcode can represent from 1 to 64 contiguous registers set
 * to the value of 0.
ZERO操作符表示为00xxxxxx。6比特的整数用六个比特的'xxxxxx'表示，还要加上1，即意味着有N个寄存器被设置为0.
这个操作符可以表示从1到64个连续为0的寄存器。
 * XZERO opcode is represented by two bytes 01xxxxxx yyyyyyyy. The 14-bit
 * integer represented by the bits 'xxxxxx' as most significant bits and
 * 'yyyyyyyy' as least significant bits, plus 1, means that there are N
 * registers set to 0. This opcode can represent from 0 to 16384 contiguous
 * registers set to the value of 0.
XZERO操作符用两个字节01xxxxxx yyyyyyyy来表示。14个比特的整数用高6位的比特'xxxxxx'和低8位的比特'yyyyyyyy'表示。
同时还需要加1，即意味着N个寄存器设置为0.这个操作符能够代表从0(加1的话，这里应该为1）到16384个连续为0的寄存器。
 * VAL opcode is represented as 1vvvvvxx. It contains a 5-bit integer
 * representing the value of a register, and a 2-bit integer representing
 * the number of contiguous registers set to that value 'vvvvv'.
 * To obtain the value and run length, the integers vvvvv and xx must be
 * incremented by one. This opcode can represent values from 1 to 32,
 * repeated from 1 to 4 times.
VAL操作符由1vvvvvxx表示，其中'vvvvv'5比特的整数表示寄存器的值，'xx'2比特的整数表示连续的值为'vvvvv'的寄存器个数。
为了获取值和行程长，整数 vvvvv 和 xx 必须加1.这个操作符表示从1到32的值，和1到4的重复次数。
 * The sparse representation can't represent registers with a value greater
 * than 32, however it is very unlikely that we find such a register in an
 * HLL with a cardinality where the sparse representation is still more
 * memory efficient than the dense representation. When this happens the
 * HLL is converted to the dense representation.
稀疏表示不能表示值超过值为32的寄存器，然而，不可能在HLL算法中找到这样一个寄存器，稀疏表示任然比密集表示更加内存有效。
如果这种情况发生，那么HLL算法就改用密集表示。
 * The sparse representation is purely positional. For example a sparse
 * representation of an empty HLL is just: XZERO:16384.
稀疏表示纯粹是位置表示。举一个稀疏表示的例子，一个空的HLL表示，就是 XZERO:16384
 * An HLL having only 3 non-zero registers at position 1000, 1020, 1021
 * respectively set to 2, 3, 3, is represented by the following three
 * opcodes:
一个HLL只有3个非零的寄存器，分别在位置1000, 1020, 1021，对应的值为2，3，3， 可以用如下的操作符来表示
 * XZERO:1000 (Registers 0-999 are set to 0)   从0到999的寄存器都是0
 * VAL:2,1    (1 register set to value 2, that is register 1000)   寄存器1000的值是2
 * ZERO:19    (Registers 1001-1019 set to 0)  寄存器1001到1019的寄存器都是0
 * VAL:3,2    (2 registers set to value 3, that is registers 1020,1021) 寄存器1020,1021的值都是3
 * XZERO:15362 (Registers 1022-16383 set to 0) 寄存器1022到16383的值都是0
 *
 * In the example the sparse representation used just 7 bytes instead
 * of 12k in order to represent the HLL registers. In general for low
 * cardinality there is a big win in terms of space efficiency, traded
 * with CPU time since the sparse representation is slower to access:
在上面的例子中，稀疏表示值使用了7个字节而不是12K表示了HLL寄存器。一般来说，对于低基数，在空间效率方面有很大优势，
因为稀疏表示访问速度比较慢，可以用CPU的时间来交换。

 * The following table shows average cardinality vs bytes used, 100
 * samples per cardinality (when the set was not representable because
 * of registers with too big value, the dense representation size was used
 * as a sample).
下面的表格展示了平均基数 和 使用字节的对比,
每基数100个样本（当集合由于值太大而无法表示时，使用密集表示大小作为样本）

 * 100 267
 * 200 485
 * 300 678
 * 400 859
 * 500 1033
 * 600 1205
 * 700 1375
 * 800 1544
 * 900 1713
 * 1000 1882
 * 2000 3480
 * 3000 4879
 * 4000 6089
 * 5000 7138
 * 6000 8042
 * 7000 8823
 * 8000 9500
 * 9000 10088
 * 10000 10591
 *
 * The dense representation uses 12288 bytes, so there is a big win up to
 * a cardinality of ~2000-3000. For bigger cardinalities the constant times
 * involved in updating the sparse representation is not justified by the
 * memory savings. The exact maximum length of the sparse representation
 * when this implementation switches to the dense representation is
 * configured via the define server.hll_sparse_max_bytes.
 */
密集表示法使用12288字节，因此在基数为~2000-3000的情况下有很大的优势。
对更大的基数，更新稀疏表示的常量时间不是简单的内存节省。
当实现切换到密集表示的时，准确的稀疏表示的最大长度被配置在变量 server.hll_sparse_max_bytes中

config.c中  默认的初始化配置为3000
createSizeTConfig("hll-sparse-max-bytes", NULL, MODIFIABLE_CONFIG, 0, LONG_MAX, server.hll_sparse_max_bytes, 3000, MEMORY_CONFIG, NULL, NULL)