redis源码解析（二）动态字符串sds基本功能函数

迷南。 2022-05-10 10:06 265阅读 0赞

1. 简介

  本文继上文基础上，分析动态字符串的功能函数，位于sds.c。由于函数较多，本篇介绍实现动态变化的基本增删新建释放函数。

2. 源码分析

  sdsHdrSize()函数用于返回sdshdr的大小，主要使用sizeof()函数实现。

  1. /*返回sdshdr大小，主要使用sizeof()函数*/
  2. static inline int sdsHdrSize(char type) { 
  3.     switch(type&SDS_TYPE_MASK) { 
  4.         case SDS_TYPE_5:
  5.             return sizeof(struct sdshdr5);
  6.         case SDS_TYPE_8:
  7.             return sizeof(struct sdshdr8);
  8.         case SDS_TYPE_16:
  9.             return sizeof(struct sdshdr16);
  10.         case SDS_TYPE_32:
  11.             return sizeof(struct sdshdr32);
  12.         case SDS_TYPE_64:
  13.             return sizeof(struct sdshdr64);
  14.     }
  15.     return 0;
  16. }

  sdsReqType()根据size返回sdsHdr类型

  1. /*根据size返回sds的类型*/
  2. static inline char sdsReqType(size_t string_size) { 
  3.     if (string_size < 1<<5)
  4.         return SDS_TYPE_5;
  5.     if (string_size < 1<<8)
  6.         return SDS_TYPE_8;
  7.     if (string_size < 1<<16)
  8.         return SDS_TYPE_16;
  9. #if (LONG_MAX == LLONG_MAX)
  10.     if (string_size < 1ll<<32)
  11.         return SDS_TYPE_32;
  12. #endif
  13.     return SDS_TYPE_64;
  14. }

  sdsnewlen()函数创建新的sds动态数组

  1. /* 初始化函数 * Create a new sds string with the content specified by the 'init' pointer * and 'initlen'. * If NULL is used for 'init' the string is initialized with zero bytes. * * The string is always null-termined (all the sds strings are, always) so * even if you create an sds string with: * * mystring = sdsnewlen("abc",3); * * You can print the string with printf() as there is an implicit \0 at the * end of the string. However the string is binary safe and can contain * \0 characters in the middle, as the length is stored in the sds header. */
  2. sds sdsnewlen(const void *init, size_t initlen) { 
  3.     void *sh;
  4.     sds s;
  5.     /*根据initlen返回type*/
  6.     char type = sdsReqType(initlen);
  7.     /* Empty strings are usually created in order to append. Use type 8 * since type 5 is not good at this. */
  8.     if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
  9.     /*hdrlen赋值为sds的size*/
  10.     int hdrlen = sdsHdrSize(type);
  11.     unsigned char *fp; /* flags pointer. */
  13.     /*分配空间*/
  14.     sh = s_malloc(hdrlen+initlen+1);
  15.     if (!init)
  16.         memset(sh, 0, hdrlen+initlen+1);
  18.     /*错误返回*/
  19.     if (sh == NULL) return NULL;
  20.     /*s指向数据，fp为首指针前一位，指向flag，存储type*/
  21.     s = (char*)sh+hdrlen;
  22.     fp = ((unsigned char*)s)-1;
  23.     switch(type) { 
  24.         case SDS_TYPE_5: { 
  25.             *fp = type | (initlen << SDS_TYPE_BITS);
  26.             break;
  27.         }
  28.         case SDS_TYPE_8: { 
  29.             SDS_HDR_VAR(8,s);
  30.             sh->len = initlen;
  31.             sh->alloc = initlen;
  32.             *fp = type;
  33.             break;
  34.         }
  35.         case SDS_TYPE_16: { 
  36.             SDS_HDR_VAR(16,s);
  37.             sh->len = initlen;
  38.             sh->alloc = initlen;
  39.             *fp = type;
  40.             break;
  41.         }
  42.         case SDS_TYPE_32: { 
  43.             SDS_HDR_VAR(32,s);
  44.             sh->len = initlen;
  45.             sh->alloc = initlen;
  46.             *fp = type;
  47.             break;
  48.         }
  49.         case SDS_TYPE_64: { 
  50.             SDS_HDR_VAR(64,s);
  51.             sh->len = initlen;
  52.             sh->alloc = initlen;
  53.             *fp = type;
  54.             break;
  55.         }
  56.     }
  57.     if (initlen && init)
  58.         memcpy(s, init, initlen);
  59.     s[initlen] = '\0';
  60.     return s;
  61. }

  sdsempty()函数利用sdsnewlen创建空sds动态数组

  1. /* 创建空sds * Create an empty (zero length) sds string. Even in this case the string * always has an implicit null term. */
  2. sds sdsempty(void) { 
  3.     return sdsnewlen("",0);
  4. }

  sdsnew()利用sdsnewlen()创建sds动态数组

  1. /* 创建新sds * Create a new sds string starting from a null terminated C string. */
  2. sds sdsnew(const char *init) { 
  3.     size_t initlen = (init == NULL) ? 0 : strlen(init);
  4.     return sdsnewlen(init, initlen);
  5. }

  sdsdup()函数使用sdsnewlen()复制已有的sds

  1. /* 复制sds * Duplicate an sds string. */
  2. sds sdsdup(const sds s) { 
  3.     return sdsnewlen(s, sdslen(s));
  4. }

  sdsfree()函数释放sds的空间

  1. /* 释放sds * Free an sds string. No operation is performed if 's' is NULL. */
  2. void sdsfree(sds s) { 
  3.     if (s == NULL) return;
  4.     s_free((char*)s-sdsHdrSize(s[-1]));
  5. }

  sdsupdatelen()函数更新sdsHdr的长度

  1. /* 当sds数据变化后，调用该函数更新sds长度 * Set the sds string length to the length as obtained with strlen(), so * considering as content only up to the first null term character. * * This function is useful when the sds string is hacked manually in some * way, like in the following example: * * s = sdsnew("foobar"); * s[2] = '\0'; * sdsupdatelen(s); * printf("%d\n", sdslen(s)); * * The output will be "2", but if we comment out the call to sdsupdatelen() * the output will be "6" as the string was modified but the logical length * remains 6 bytes. */
  2. void sdsupdatelen(sds s) { 
  3.     size_t reallen = strlen(s);
  4.     sdssetlen(s, reallen);
  5. }

  sdsclear()函数将sds长度和内容置零

  1. /* 清空sds * Modify an sds string in-place to make it empty (zero length). * However all the existing buffer is not discarded but set as free space * so that next append operations will not require allocations up to the * number of bytes previously available. */
  2. void sdsclear(sds s) { 
  3.     sdssetlen(s, 0);
  4.     s[0] = '\0';
  5. }

  动态字符串之扩容：sdsMakeRoomFor()函数。根据增加的addlen来调整sdsHdr的类型。

  1. /* sds扩容 * Enlarge the free space at the end of the sds string so that the caller * is sure that after calling this function can overwrite up to addlen * bytes after the end of the string, plus one more byte for nul term. * * Note: this does not change the *length* of the sds string as returned * by sdslen(), but only the free buffer space we have. */
  2. sds sdsMakeRoomFor(sds s, size_t addlen) { 
  3.     void *sh, *newsh;
  4.     size_t avail = sdsavail(s);
  5.     size_t len, newlen;
  6.     char type, oldtype = s[-1] & SDS_TYPE_MASK;
  7.     int hdrlen;
  9.     /* 可用空间够大，则不扩容了 * Return ASAP if there is enough space left. */
  10.     if (avail >= addlen) return s;
  12.     len = sdslen(s);
  13.     sh = (char*)s-sdsHdrSize(oldtype);
  14.     newlen = (len+addlen);
  15.     /*这里的翻倍规则和动态数组vector是一样的：便于下次扩容*/
  16.     if (newlen < SDS_MAX_PREALLOC)
  17.         newlen *= 2;
  18.     else
  19.         newlen += SDS_MAX_PREALLOC;
  21.     type = sdsReqType(newlen);
  23.     /* 不适用type 5 * Don't use type 5: the user is appending to the string and type 5 is * not able to remember empty space, so sdsMakeRoomFor() must be called * at every appending operation. */
  24.     if (type == SDS_TYPE_5) type = SDS_TYPE_8;
  26.     hdrlen = sdsHdrSize(type);
  27.     if (oldtype==type) { 
  28.         newsh = s_realloc(sh, hdrlen+newlen+1);
  29.         if (newsh == NULL) return NULL;
  30.         s = (char*)newsh+hdrlen;
  31.     } else { 
  32.         /* 头部size变化了 * Since the header size changes, need to move the string forward, * and can't use realloc */
  33.         newsh = s_malloc(hdrlen+newlen+1);
  34.         if (newsh == NULL) return NULL;
  35.         memcpy((char*)newsh+hdrlen, s, len+1);
  36.         s_free(sh);
  37.         s = (char*)newsh+hdrlen;
  38.         s[-1] = type;
  39.         sdssetlen(s, len);
  40.     }
  41.     sdssetalloc(s, newlen);
  42.     return s;
  43. }

  压缩空间的函数sdsRemoveFreeSpace()，功能和扩展空间相反。

  1. /* 用于节省空间，和扩容相反 * Reallocate the sds string so that it has no free space at the end. The * contained string remains not altered, but next concatenation operations * will require a reallocation. * * After the call, the passed sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */
  2. sds sdsRemoveFreeSpace(sds s) { 
  3.     void *sh, *newsh;
  4.     char type, oldtype = s[-1] & SDS_TYPE_MASK;
  5.     int hdrlen, oldhdrlen = sdsHdrSize(oldtype);
  6.     size_t len = sdslen(s);
  7.     sh = (char*)s-oldhdrlen;
  9.     /* Check what would be the minimum SDS header that is just good enough to * fit this string. */
  10.     type = sdsReqType(len);
  11.     hdrlen = sdsHdrSize(type);
  13.     /* If the type is the same, or at least a large enough type is still * required, we just realloc(), letting the allocator to do the copy * only if really needed. Otherwise if the change is huge, we manually * reallocate the string to use the different header type. */
  14.     if (oldtype==type || type > SDS_TYPE_8) { 
  15.         newsh = s_realloc(sh, oldhdrlen+len+1);
  16.         if (newsh == NULL) return NULL;
  17.         s = (char*)newsh+oldhdrlen;
  18.     } else { 
  19.         newsh = s_malloc(hdrlen+len+1);
  20.         if (newsh == NULL) return NULL;
  21.         memcpy((char*)newsh+hdrlen, s, len+1);
  22.         s_free(sh);
  23.         s = (char*)newsh+hdrlen;
  24.         s[-1] = type;
  25.         sdssetlen(s, len);
  26.     }
  27.     sdssetalloc(s, len);
  28.     return s;
  29. }

  sdsAllocSize()函数返回sds的总大小

  1. /* 返回sds对应的总大小 * Return the total size of the allocation of the specifed sds string, * including: * 1) The sds header before the pointer. * 2) The string. * 3) The free buffer at the end if any. * 4) The implicit null term. */
  2. size_t sdsAllocSize(sds s) { 
  3.     size_t alloc = sdsalloc(s);
  4.     return sdsHdrSize(s[-1])+alloc+1;
  5. }

  sdsAllocPtr()函数返回sds位置的指针

  1. /* Return the pointer of the actual SDS allocation (normally SDS strings * are referenced by the start of the string buffer). */
  2. void *sdsAllocPtr(sds s) { 
  3.     return (void*) (s-sdsHdrSize(s[-1]));
  4. }

  sdsIncrLen()函数：增加sds的长度，减少剩余空间的大小

  1. /* 增加sds长度，并减少剩余空间大小 * Increment the sds length and decrements the left free space at the * end of the string according to 'incr'. Also set the null term * in the new end of the string. * * This function is used in order to fix the string length after the * user calls sdsMakeRoomFor(), writes something after the end of * the current string, and finally needs to set the new length. * * Note: it is possible to use a negative increment in order to * right-trim the string. * * Usage example: * * Using sdsIncrLen() and sdsMakeRoomFor() it is possible to mount the * following schema, to cat bytes coming from the kernel to the end of an * sds string without copying into an intermediate buffer: * * oldlen = sdslen(s); * s = sdsMakeRoomFor(s, BUFFER_SIZE); * nread = read(fd, s+oldlen, BUFFER_SIZE); * ... check for nread <= 0 and handle it ... * sdsIncrLen(s, nread); */
  2. void sdsIncrLen(sds s, ssize_t incr) { 
  3.     unsigned char flags = s[-1];
  4.     size_t len;
  5.     switch(flags&SDS_TYPE_MASK) { 
  6.         case SDS_TYPE_5: { 
  7.             unsigned char *fp = ((unsigned char*)s)-1;
  8.             unsigned char oldlen = SDS_TYPE_5_LEN(flags);
  9.             assert((incr > 0 && oldlen+incr < 32) || (incr < 0 && oldlen >= (unsigned int)(-incr)));
  10.             *fp = SDS_TYPE_5 | ((oldlen+incr) << SDS_TYPE_BITS);
  11.             len = oldlen+incr;
  12.             break;
  13.         }
  14.         case SDS_TYPE_8: { 
  15.             SDS_HDR_VAR(8,s);
  16.             assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
  17.             len = (sh->len += incr);
  18.             break;
  19.         }
  20.         case SDS_TYPE_16: { 
  21.             SDS_HDR_VAR(16,s);
  22.             assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
  23.             len = (sh->len += incr);
  24.             break;
  25.         }
  26.         case SDS_TYPE_32: { 
  27.             SDS_HDR_VAR(32,s);
  28.             assert((incr >= 0 && sh->alloc-sh->len >= (unsigned int)incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
  29.             len = (sh->len += incr);
  30.             break;
  31.         }
  32.         case SDS_TYPE_64: { 
  33.             SDS_HDR_VAR(64,s);
  34.             assert((incr >= 0 && sh->alloc-sh->len >= (uint64_t)incr) || (incr < 0 && sh->len >= (uint64_t)(-incr)));
  35.             len = (sh->len += incr);
  36.             break;
  37.         }
  38.         default: len = 0; /* Just to avoid compilation warnings. */
  39.     }
  40.     s[len] = '\0';
  41. }

  sdsgrowzero()函数将sds增长len，正常的部分填充0.

  1. /* 将sds增长至某值，增长部分填充0 * Grow the sds to have the specified length. Bytes that were not part of * the original length of the sds will be set to zero. * * if the specified length is smaller than the current length, no operation * is performed. */
  2. sds sdsgrowzero(sds s, size_t len) { 
  3.     size_t curlen = sdslen(s);
  5.     if (len <= curlen) return s;
  6.     s = sdsMakeRoomFor(s,len-curlen);
  7.     if (s == NULL) return NULL;
  9.     /* Make sure added region doesn't contain garbage */
  10.     memset(s+curlen,0,(len-curlen+1)); /* also set trailing \0 byte */
  11.     sdssetlen(s, len);
  12.     return s;
  13. }

  sdscatlen()函数将字符串t增加在sds之后。

  1. /* Append the specified binary-safe string pointed by 't' of 'len' bytes to the * end of the specified sds string 's'. * * After the call, the passed sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */
  2. sds sdscatlen(sds s, const void *t, size_t len) { 
  3.     size_t curlen = sdslen(s);
  5.     s = sdsMakeRoomFor(s,len);
  6.     if (s == NULL) return NULL;
  7.     memcpy(s+curlen, t, len);
  8.     sdssetlen(s, curlen+len);
  9.     s[curlen+len] = '\0';
  10.     return s;
  11. }

  sdscat()函数和上面函数的区别在于不输入长度len，而使用strlen获取长度

  1. /* 在sds之后增加一个字符串t * Append the specified null termianted C string to the sds string 's'. * * After the call, the passed sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */
  2. sds sdscat(sds s, const char *t) { 
  3.     return sdscatlen(s, t, strlen(t));
  4. }

  sdscatsds()函数在已有的sds之后加上另一个sds

  1. /* 在已有的sds之后添加另一个sds * Append the specified sds 't' to the existing sds 's'. * * After the call, the modified sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */
  2. sds sdscatsds(sds s, const sds t) { 
  3.     return sdscatlen(s, t, sdslen(t));
  4. }

  sdscpylen()使用t代替已有的s

  1. /* 将已有的s内容用t代替 * Destructively modify the sds string 's' to hold the specified binary * safe string pointed by 't' of length 'len' bytes. */
  2. sds sdscpylen(sds s, const char *t, size_t len) { 
  3.     if (sdsalloc(s) < len) { 
  4.         s = sdsMakeRoomFor(s,len-sdslen(s));
  5.         if (s == NULL) return NULL;
  6.     }
  7.     memcpy(s, t, len);
  8.     s[len] = '\0';
  9.     sdssetlen(s, len);
  10.     return s;
  11. }

  sdscpy()函数和上面函数的区别在于不需要输入len，使用strlen获取

  1. /* 使用自动获取长度的方式，将s内容用以NULL结尾的字符串t代替 * Like sdscpylen() but 't' must be a null-termined string so that the length * of the string is obtained with strlen(). */
  2. sds sdscpy(sds s, const char *t) { 
  3.     return sdscpylen(s, t, strlen(t));
  4. }

  sdsll2str()函数将一个long long整数转换为字符串s

  1. /* 将一个long long整数转换为字符串s * Helper for sdscatlonglong() doing the actual number -> string * conversion. 's' must point to a string with room for at least * SDS_LLSTR_SIZE bytes. * * The function returns the length of the null-terminated string * representation stored at 's'. */
  2. #define SDS_LLSTR_SIZE 21
  3. int sdsll2str(char *s, long long value) { 
  4.     char *p, aux;
  5.     unsigned long long v;
  6.     size_t l;
  8.     /* 每次获取最低位，因此存储的是逆序的 * Generate the string representation, this method produces * an reversed string. **/
  9.     v = (value < 0) ? -value : value;
  10.     p = s;
  11.     do { 
  12.         *p++ = '0'+(v%10);
  13.         v /= 10;
  14.     } while(v);
  15.     if (value < 0) *p++ = '-';
  17.     /* Compute length and add null term. */
  18.     l = p-s;
  19.     *p = '\0';
  21.     /* Reverse the string. */
  22.     p--;
  23.     while(s < p) { 
  24.         aux = *s;
  25.         *s = *p;
  26.         *p = aux;
  27.         s++;
  28.         p--;
  29.     }
  30.     return l;
  31. }

  和上面类似，只是类型为unsigned

  1. /* 和上面类似，只是类型为unsigned * Identical sdsll2str(), but for unsigned long long type. */
  2. int sdsull2str(char *s, unsigned long long v) { 
  3.     char *p, aux;
  4.     size_t l;
  6.     /* Generate the string representation, this method produces * an reversed string. */
  7.     p = s;
  8.     do { 
  9.         *p++ = '0'+(v%10);
  10.         v /= 10;
  11.     } while(v);
  13.     /* Compute length and add null term. */
  14.     l = p-s;
  15.     *p = '\0';
  17.     /* Reverse the string. */
  18.     p--;
  19.     while(s < p) { 
  20.         aux = *s;
  21.         *s = *p;
  22.         *p = aux;
  23.         s++;
  24.         p--;
  25.     }
  26.     return l;
  27. }

  从long long类型创建一个sds

  1. /* 从long long类型创建一个sds * Create an sds string from a long long value. It is much faster than: * * sdscatprintf(sdsempty(),"%lld\n", value); */
  2. sds sdsfromlonglong(long long value) { 
  3.     char buf[SDS_LLSTR_SIZE];
  4.     int len = sdsll2str(buf,value);
  6.     return sdsnewlen(buf,len);
  7. }

  

发表评论

表情：
评论列表 （有 0 条评论，265人围观）

还没有评论，来说两句吧...

相关阅读