redis源码解析（十三）压缩链表ziplistAPI函数分析

青旅半醒 2021-11-10 14:52 199阅读 0赞

API的函数实现源码如下：

/* 创建新的压缩列表 * Create a new empty ziplist. */
    unsigned char *ziplistNew(void) { 
        unsigned int bytes = ZIPLIST_HEADER_SIZE + 1;
        unsigned char *zl = zmalloc(bytes);
        ZIPLIST_BYTES(zl) = intrev32ifbe(bytes);
        ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(ZIPLIST_HEADER_SIZE);
        ZIPLIST_LENGTH(zl) = 0;
        zl[bytes - 1] = ZIP_END;
        return zl;
    }
    
    /* 调整压缩表大小 * Resize the ziplist. */
    unsigned char *ziplistResize(unsigned char *zl, unsigned int len) { 
        zl = zrealloc(zl,len);
        ZIPLIST_BYTES(zl) = intrev32ifbe(len);
        zl[len-1] = ZIP_END;
        return zl;
    }
    
    /* 添加新的entry时对prevlen，next entry等的修改可能导致连锁反应：第一位增加 * 导致后面每一位都要增加，因此需要进行检测 * When an entry is inserted, we need to set the prevlen field of the next * entry to equal the length of the inserted entry. It can occur that this * length cannot be encoded in 1 byte and the next entry needs to be grow * a bit larger to hold the 5-byte encoded prevlen. This can be done for free, * because this only happens when an entry is already being inserted (which * causes a realloc and memmove). However, encoding the prevlen may require * that this entry is grown as well. This effect may cascade throughout * the ziplist when there are consecutive entries with a size close to * ZIP_BIG_PREVLEN, so we need to check that the prevlen can be encoded in * every consecutive entry. * * Note that this effect can also happen in reverse, where the bytes required * to encode the prevlen field can shrink. This effect is deliberately ignored, * because it can cause a "flapping" effect where a chain prevlen fields is * first grown and then shrunk again after consecutive inserts. Rather, the * field is allowed to stay larger than necessary, because a large prevlen * field implies the ziplist is holding large entries anyway. * * The pointer "p" points to the first entry that does NOT need to be * updated, i.e. consecutive fields MAY need an update. */
    unsigned char *__ziplistCascadeUpdate(unsigned char *zl, unsigned char *p) 
    { 
        size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), rawlen, rawlensize;
        size_t offset, noffset, extra;
        unsigned char *np;
        zlentry cur, next;
    
        while (p[0] != ZIP_END) { 
            zipEntry(p, &cur);
            rawlen = cur.headersize + cur.len;
            rawlensize = zipStorePrevEntryLength(NULL,rawlen);
    
            /* Abort if there is no next entry. */
            if (p[rawlen] == ZIP_END) break;
            zipEntry(p + rawlen, &next);
    
            /* Abort when "prevlen" has not changed. */
            if (next.prevrawlen == rawlen) break;
    
            if (next.prevrawlensize < rawlensize) { 
                /* The "prevlen" field of "next" needs more bytes to hold * the raw length of "cur". */
                offset = p - zl;
                extra = rawlensize-next.prevrawlensize;
                zl = ziplistResize(zl,curlen+extra);
                p = zl + offset;
    
                /* Current pointer and offset for next element. */
                np = p + rawlen;
                noffset = np - zl;
    
                /* Update tail offset when next element is not the tail element. */
                if ((zl+intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))) != np) { 
                    ZIPLIST_TAIL_OFFSET(zl) =
                        intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+extra);
                }
    
                /* Move the tail to the back. */
                memmove(np + rawlensize,
                    np+next.prevrawlensize,
                    curlen-noffset-next.prevrawlensize - 1);
                zipStorePrevEntryLength(np,rawlen);
    
                /* Advance the cursor */
                p += rawlen;
                curlen += extra;
            } else { 
                if (next.prevrawlensize > rawlensize) { 
                    /* This would result in shrinking, which we want to avoid. * So, set "rawlen" in the available bytes. */
                    zipStorePrevEntryLengthLarge(p + rawlen, rawlen);
                } else { 
                    zipStorePrevEntryLength(p + rawlen, rawlen);
                }
    
                /* Stop here, as the raw length of "next" has not changed. */
                break;
            }
        }
        return zl;
    }
    
    /* 删除从p开始的num个entry * Delete "num" entries, starting at "p". Returns pointer to the ziplist. */
    unsigned char *__ziplistDelete(unsigned char *zl, unsigned char *p, unsigned int num) 
    { 
        unsigned int i, totlen, deleted = 0;
        size_t offset;
        int nextdiff = 0;
        zlentry first, tail;
    
        zipEntry(p, &first);
        for (i = 0; p[0] != ZIP_END && i < num; i++) { 
            p += zipRawEntryLength(p);
            deleted++;
        }
    
    	/* 除去prev-entry-len之外，剩余都是要删除的 * Bytes taken by the element(s) to delete. */    
        totlen = p - first.p; 
    
        if (totlen > 0) { 
            if (p[0] != ZIP_END) { 
                /* 比较prevrawlen的大小确认是否需要扩展空间 * Storing `prevrawlen` in this entry may increase or decrease the * number of bytes required compare to the current `prevrawlen`. * There always is room to store this, because it was previously * stored by an entry that is now being deleted. */
                nextdiff = zipPrevLenByteDiff(p, first.prevrawlen);
    
                /* p后跳通常有足够的空间 * Note that there is always space when p jumps backward: if * the new previous entry is large, one of the deleted elements * had a 5 bytes prevlen header, so there is for sure at least * 5 bytes free and we need just 4. */
                p -= nextdiff;
                zipStorePrevEntryLength(p, first.prevrawlen);
    
                /* Update offset for tail */
                ZIPLIST_TAIL_OFFSET(zl) =
                    intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl)) - totlen);
    
                /* When the tail contains more than one entry, we need to take * "nextdiff" in account as well. Otherwise, a change in the * size of prevlen doesn't have an effect on the *tail* offset. */
                zipEntry(p, &tail);
                if (p[tail.headersize + tail.len] != ZIP_END) { 
                    ZIPLIST_TAIL_OFFSET(zl) =
                       intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl)) + nextdiff);
                }
    
                /* Move tail to the front of the ziplist */
                memmove(first.p,p,
                    intrev32ifbe(ZIPLIST_BYTES(zl)) - (p - zl) - 1);
            } else { 
                /* The entire tail was deleted. No need to move memory. */
                ZIPLIST_TAIL_OFFSET(zl) =
                    intrev32ifbe((first.p - zl) - first.prevrawlen);
            }
    
            /* Resize and update length */
            offset = first.p - zl;
            zl = ziplistResize(zl, intrev32ifbe(ZIPLIST_BYTES(zl)) - totlen + nextdiff);
            ZIPLIST_INCR_LENGTH(zl, -deleted);
            p = zl+offset;
    
            /* When nextdiff != 0, the raw length of the next entry has changed, so * we need to cascade the update throughout the ziplist */
            if (nextdiff != 0)
                zl = __ziplistCascadeUpdate(zl, p);
        }
        return zl;
    }
    
    /* 在p位置插入新项 * Insert item at "p". */
    unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) 
    { 
        size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), reqlen;
        unsigned int prevlensize, prevlen = 0;
        size_t offset;
        int nextdiff = 0;
        unsigned char encoding = 0;
    	
    	/* 为避免未初始化warning报错初始化赋值 * initialized to avoid warning. Using a value * that is easy to see if for some reason * we use it uninitialized. */	
        long long value = 123456789; 
        zlentry tail;
    
        /* Find out prevlen for the entry that is inserted. */
        if (p[0] != ZIP_END) { 
            ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
        } else { 
            unsigned char *ptail = ZIPLIST_ENTRY_TAIL(zl);
            if (ptail[0] != ZIP_END) { 
                prevlen = zipRawEntryLength(ptail);
            }
        }
    
        /* See if the entry can be encoded */
        if (zipTryEncoding(s,slen,&value,&encoding)) { 
            /* 'encoding' is set to the appropriate integer encoding */
            reqlen = zipIntSize(encoding);
        } else { 
            /* 'encoding' is untouched, however zipStoreEntryEncoding will use the * string length to figure out how to encode it. */
            reqlen = slen;
        }
        /* We need space for both the length of the previous entry and * the length of the payload. */
        reqlen += zipStorePrevEntryLength(NULL,prevlen);
        reqlen += zipStoreEntryEncoding(NULL,encoding,slen);
    
        /* When the insert position is not equal to the tail, we need to * make sure that the next entry can hold this entry's length in * its prevlen field. */
        int forcelarge = 0;
        nextdiff = (p[0] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : 0;
        if (nextdiff == -4 && reqlen < 4) { 
            nextdiff = 0;
            forcelarge = 1;
        }
    
        /* Store offset because a realloc may change the address of zl. */
        offset = p-zl;
        zl = ziplistResize(zl,curlen+reqlen+nextdiff);
        p = zl+offset;
    
        /* Apply memory move when necessary and update tail offset. */
        if (p[0] != ZIP_END) { 
            /* Subtract one because of the ZIP_END bytes */
            memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff);
    
            /* Encode this entry's raw length in the next entry. */
            if (forcelarge)
                zipStorePrevEntryLengthLarge(p+reqlen,reqlen);
            else
                zipStorePrevEntryLength(p+reqlen,reqlen);
    
            /* Update offset for tail */
            ZIPLIST_TAIL_OFFSET(zl) =
                intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+reqlen);
    
            /* When the tail contains more than one entry, we need to take * "nextdiff" in account as well. Otherwise, a change in the * size of prevlen doesn't have an effect on the *tail* offset. */
            zipEntry(p+reqlen, &tail);
            if (p[reqlen+tail.headersize+tail.len] != ZIP_END) { 
                ZIPLIST_TAIL_OFFSET(zl) =
                    intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);
            }
        } else { 
            /* This element will be the new tail. */
            ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(p-zl);
        }
    
        /* When nextdiff != 0, the raw length of the next entry has changed, so * we need to cascade the update throughout the ziplist */
        if (nextdiff != 0) { 
            offset = p-zl;
            zl = __ziplistCascadeUpdate(zl,p+reqlen);
            p = zl+offset;
        }
    
        /* Write the entry */
        p += zipStorePrevEntryLength(p,prevlen);
        p += zipStoreEntryEncoding(p,encoding,slen);
        if (ZIP_IS_STR(encoding)) { 
            memcpy(p,s,slen);
        } else { 
            zipSaveInteger(p,value,encoding);
        }
        ZIPLIST_INCR_LENGTH(zl,1);
        return zl;
    }
    
    /* 合并两个压缩列表：重新配置较大的表，合并另一个表 * 并入的旧有列表清空释放资源 * Merge ziplists 'first' and 'second' by appending 'second' to 'first'. * * NOTE: The larger ziplist is reallocated to contain the new merged ziplist. * Either 'first' or 'second' can be used for the result. The parameter not * used will be free'd and set to NULL. * * After calling this function, the input parameters are no longer valid since * they are changed and free'd in-place. * * The result ziplist is the contents of 'first' followed by 'second'. * * On failure: returns NULL if the merge is impossible. * On success: returns the merged ziplist (which is expanded version of either * 'first' or 'second', also frees the other unused input ziplist, and sets the * input ziplist argument equal to newly reallocated ziplist return value. */
    unsigned char *ziplistMerge(unsigned char **first, unsigned char **second) 
    { 
        /* If any params are null, we can't merge, so NULL. */
        if (first == NULL || *first == NULL || second == NULL || *second == NULL)
            return NULL;
    
        /* Can't merge same list into itself. */
        if (*first == *second)
            return NULL;
    
        size_t first_bytes = intrev32ifbe(ZIPLIST_BYTES(*first));
        size_t first_len = intrev16ifbe(ZIPLIST_LENGTH(*first));
    
        size_t second_bytes = intrev32ifbe(ZIPLIST_BYTES(*second));
        size_t second_len = intrev16ifbe(ZIPLIST_LENGTH(*second));
    
        int append;
        unsigned char *source, *target;
        size_t target_bytes, source_bytes;
    	
        /* 选择较大的压缩列表 * Pick the largest ziplist so we can resize easily in-place. * We must also track if we are now appending or prepending to * the target ziplist. */
        if (first_len >= second_len) { 
            /* retain first, append second to first. */
            target = *first;
            target_bytes = first_bytes;
            source = *second;
            source_bytes = second_bytes;
            append = 1;
        } else { 
            /* else, retain second, prepend first to second. */
            target = *second;
            target_bytes = second_bytes;
            source = *first;
            source_bytes = first_bytes;
            append = 0;
        }
    
        /* 计算合并后的字节、长度 * Calculate final bytes (subtract one pair of metadata) */
        size_t zlbytes = first_bytes + second_bytes -
                         ZIPLIST_HEADER_SIZE - ZIPLIST_END_SIZE;
        size_t zllength = first_len + second_len;
    
        /* 判断合并后是否越界 * Combined zl length should be limited within UINT16_MAX */
        zllength = zllength < UINT16_MAX ? zllength : UINT16_MAX;
    
        /* 保存偏移位置 * Save offset positions before we start ripping memory apart. */
        size_t first_offset = intrev32ifbe(ZIPLIST_TAIL_OFFSET(*first));
        size_t second_offset = intrev32ifbe(ZIPLIST_TAIL_OFFSET(*second));
    
        /* 重新分配空间 * Extend target to new zlbytes then append or prepend source. */
        target = zrealloc(target, zlbytes);
    	
    	/*append大于0表示插入第一个列表，等于0则插入第二个列表*/
        if (append) { 
            /* append == appending to target */
            /* Copy source after target (copying over original [END]): * [TARGET - END, SOURCE - HEADER] */
            memcpy(target + target_bytes - ZIPLIST_END_SIZE,
                   source + ZIPLIST_HEADER_SIZE,
                   source_bytes - ZIPLIST_HEADER_SIZE);
        } else { 
            /* !append == prepending to target */
            /* Move target *contents* exactly size of (source - [END]), * then copy source into vacataed space (source - [END]): * [SOURCE - END, TARGET - HEADER] */
            memmove(target + source_bytes - ZIPLIST_END_SIZE,
                    target + ZIPLIST_HEADER_SIZE,
                    target_bytes - ZIPLIST_HEADER_SIZE);
            memcpy(target, source, source_bytes - ZIPLIST_END_SIZE);
        }
    
        /* 更新头部数据 * Update header metadata. */
        ZIPLIST_BYTES(target) = intrev32ifbe(zlbytes);
        ZIPLIST_LENGTH(target) = intrev16ifbe(zllength);
    	
        /* 计算新的偏移量 * New tail offset is: * + N bytes of first ziplist * - 1 byte for [END] of first ziplist * + M bytes for the offset of the original tail of the second ziplist * - J bytes for HEADER because second_offset keeps no header. */
        ZIPLIST_TAIL_OFFSET(target) = intrev32ifbe(
                                       (first_bytes - ZIPLIST_END_SIZE) +
                                       (second_offset - ZIPLIST_HEADER_SIZE));
    
        /* __ziplistCascadeUpdate just fixes the prev length values until it finds a * correct prev length value (then it assumes the rest of the list is okay). * We tell CascadeUpdate to start at the first ziplist's tail element to fix * the merge seam. */
        target = __ziplistCascadeUpdate(target, target+first_offset);
    
        /* Now free and NULL out what we didn't realloc */
        if (append) { 
            zfree(*second);
            *second = NULL;
            *first = target;
        } else { 
            zfree(*first);
            *first = NULL;
            *second = target;
        }
        return target;
    }
    
    unsigned char *ziplistPush(unsigned char *zl, unsigned char *s, unsigned int slen, int where) { 
        unsigned char *p;
        p = (where == ZIPLIST_HEAD) ? ZIPLIST_ENTRY_HEAD(zl) : ZIPLIST_ENTRY_END(zl);
        return __ziplistInsert(zl, p, s, slen);
    }
    
    /* 返回压缩列表迭代器的偏移量，index为负则指向前一个偏移量 * Returns an offset to use for iterating with ziplistNext. When the given * index is negative, the list is traversed back to front. When the list * doesn't contain an element at the provided index, NULL is returned. */
    unsigned char *ziplistIndex(unsigned char *zl, int index) { 
        unsigned char *p;
        unsigned int prevlensize, prevlen = 0;
        if (index < 0) { 
            index = (-index)-1;
            p = ZIPLIST_ENTRY_TAIL(zl);
            if (p[0] != ZIP_END) { 
                ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
                while (prevlen > 0 && index--) { 
                    p -= prevlen;
                    ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
                }
            }
        } else { 
            p = ZIPLIST_ENTRY_HEAD(zl);
            while (p[0] != ZIP_END && index--) { 
                p += zipRawEntryLength(p);
            }
        }
        return (p[0] == ZIP_END || index > 0) ? NULL : p;
    }
    
    /* 返回压缩列表下一项的指针 * Return pointer to next entry in ziplist. * * zl is the pointer to the ziplist * p is the pointer to the current element * * The element after 'p' is returned, otherwise NULL if we are at the end. */
    unsigned char *ziplistNext(unsigned char *zl, unsigned char *p) 
    { 
        ((void) zl);
    
        /* "p" could be equal to ZIP_END, caused by ziplistDelete, * and we should return NULL. Otherwise, we should return NULL * when the *next* element is ZIP_END (there is no next entry). */
        if (p[0] == ZIP_END) { 
            return NULL;
        }
    
        p += zipRawEntryLength(p); 
        if (p[0] == ZIP_END) { 
            return NULL;
        }
    
        return p;
    }
    
    /* 返回压缩列表上一项 * Return pointer to previous entry in ziplist. */
    unsigned char *ziplistPrev(unsigned char *zl, unsigned char *p) { 
        unsigned int prevlensize, prevlen = 0;
    
        /* Iterating backwards from ZIP_END should return the tail. When "p" is * equal to the first element of the list, we're already at the head, * and should return NULL. */
        if (p[0] == ZIP_END) { 
            p = ZIPLIST_ENTRY_TAIL(zl);
            return (p[0] == ZIP_END) ? NULL : p;
        } else if (p == ZIPLIST_ENTRY_HEAD(zl)) { 
            return NULL;
        } else { 
            ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
            assert(prevlen > 0);
            return p-prevlen;
        }
    }
    
    /* 获取压缩列表的节点，存在sstr或sval中。 * Get entry pointed to by 'p' and store in either '*sstr' or 'sval' depending * on the encoding of the entry. '*sstr' is always set to NULL to be able * to find out whether the string pointer or the integer value was set. * Return 0 if 'p' points to the end of the ziplist, 1 otherwise. */
    unsigned int ziplistGet(unsigned char *p, unsigned char **sstr, unsigned int *slen, long long *sval) { 
        zlentry entry;
        if (p == NULL || p[0] == ZIP_END) return 0;
        if (sstr) *sstr = NULL;
    
        zipEntry(p, &entry);
        if (ZIP_IS_STR(entry.encoding)) { 
            if (sstr) { 
                *slen = entry.len;
                *sstr = p+entry.headersize;
            }
        } else { 
            if (sval) { 
                *sval = zipLoadInteger(p+entry.headersize,entry.encoding);
            }
        }
        return 1;
    }
    
    /* 在p位置插入表项 * Insert an entry at "p". */
    unsigned char *ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) { 
        return __ziplistInsert(zl, p, s, slen);
    }
    
    /* 删除压缩列表表项 * Delete a single entry from the ziplist, pointed to by *p. * Also update *p in place, to be able to iterate over the * ziplist, while deleting entries. */
    unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p) { 
        size_t offset = *p-zl;
        zl = __ziplistDelete(zl,*p,1);
    
        /* Store pointer to current element in p, because ziplistDelete will * do a realloc which might result in a different "zl"-pointer. * When the delete direction is back to front, we might delete the last * entry and end up with "p" pointing to ZIP_END, so check this. */
        *p = zl+offset;
        return zl;
    }
    
    /* Delete a range of entries from the ziplist. */
    unsigned char *ziplistDeleteRange(unsigned char *zl, int index, unsigned int num) { 
        unsigned char *p = ziplistIndex(zl,index);
        return (p == NULL) ? zl : __ziplistDelete(zl,p,num);
    }
    
    /* 比较压缩列表节点P和sstr * Compare entry pointer to by 'p' with 'sstr' of length 'slen'. */
    /* Return 1 if equal. */
    unsigned int ziplistCompare(unsigned char *p, unsigned char *sstr, unsigned int slen) { 
        zlentry entry;
        unsigned char sencoding;
        long long zval, sval;
        if (p[0] == ZIP_END) return 0;
    
        zipEntry(p, &entry);
        if (ZIP_IS_STR(entry.encoding)) { 
            /* Raw compare */
            if (entry.len == slen) { 
                return memcmp(p+entry.headersize,sstr,slen) == 0;
            } else { 
                return 0;
            }
        } else { 
            /* Try to compare encoded values. Don't compare encoding because * different implementations may encoded integers differently. */
            if (zipTryEncoding(sstr,slen,&sval,&sencoding)) { 
              zval = zipLoadInteger(p+entry.headersize,entry.encoding);
              return zval == sval;
            }
        }
        return 0;
    }
    
    /* 在压缩链表p中寻找和vstr一样的节点，skip表示跳过的节点 * Find pointer to the entry equal to the specified entry. Skip 'skip' entries * between every comparison. Returns NULL when the field could not be found. */
    unsigned char *ziplistFind(unsigned char *p, unsigned char *vstr, unsigned int vlen, unsigned int skip) { 
        int skipcnt = 0;
        unsigned char vencoding = 0;
        long long vll = 0;
    
        while (p[0] != ZIP_END) { 
            unsigned int prevlensize, encoding, lensize, len;
            unsigned char *q;
    
            ZIP_DECODE_PREVLENSIZE(p, prevlensize);
            ZIP_DECODE_LENGTH(p + prevlensize, encoding, lensize, len);
            q = p + prevlensize + lensize;
    
            if (skipcnt == 0) { 
                /* Compare current entry with specified entry */
                if (ZIP_IS_STR(encoding)) { 
                    if (len == vlen && memcmp(q, vstr, vlen) == 0) { 
                        return p;
                    }
                } else { 
                    /* Find out if the searched field can be encoded. Note that * we do it only the first time, once done vencoding is set * to non-zero and vll is set to the integer value. */
                    if (vencoding == 0) { 
                        if (!zipTryEncoding(vstr, vlen, &vll, &vencoding)) { 
                            /* If the entry can't be encoded we set it to * UCHAR_MAX so that we don't retry again the next * time. */
                            vencoding = UCHAR_MAX;
                        }
                        /* Must be non-zero by now */
                        assert(vencoding);
                    }
    
                    /* Compare current entry with specified entry, do it only * if vencoding != UCHAR_MAX because if there is no encoding * possible for the field it can't be a valid integer. */
                    if (vencoding != UCHAR_MAX) { 
                        long long ll = zipLoadInteger(q, encoding);
                        if (ll == vll) { 
                            return p;
                        }
                    }
                }
    
                /* Reset skip count */
                skipcnt = skip;
            } else { 
                /* Skip entry */
                skipcnt--;
            }
    
            /* Move to next entry */
            p = q + len;
        }
    
        return NULL;
    }
    
    /* 返回压缩链表的长度 * Return length of ziplist. */
    unsigned int ziplistLen(unsigned char *zl) { 
        unsigned int len = 0;
        if (intrev16ifbe(ZIPLIST_LENGTH(zl)) < UINT16_MAX) { 
            len = intrev16ifbe(ZIPLIST_LENGTH(zl));
        } else { 
            unsigned char *p = zl+ZIPLIST_HEADER_SIZE;
            while (*p != ZIP_END) { 
                p += zipRawEntryLength(p);
                len++;
            }
    
            /* Re-store length if small enough */
            if (len < UINT16_MAX) ZIPLIST_LENGTH(zl) = intrev16ifbe(len);
        }
        return len;
    }
    
    /* 返回压缩链表二进制大小 * Return ziplist blob size in bytes. */
    size_t ziplistBlobLen(unsigned char *zl) { 
        return intrev32ifbe(ZIPLIST_BYTES(zl));
    }