【读书笔记】第二章、简单动态字符串
一、数据结构
struct sds{
int len; //buf 已经占用的字节数
int free; //buf 中剩余可用字节数
char buf[];
}
1）内容存放在柔性数组的 buf 中， SDS 对上层暴露的指针不是指向结构体的 SDS 的指针，二十直接指向柔性数组 buf 的指针。
2）读写字符串不依赖 “\0” 终止符。
问题？
不同结构的字符串是否有必要占用相同大小的头？一个 int 占 4 个字节。对于一个短字符串来说上述定义太夸张了。 len free 占一个字节就够了。
我们区分三种情况。
短字符串， len 和 free 占用一个字节就够了。长字符串， 用 2 字节或者 4 字节；更长的字符串用 8 字节。
那么我们如何区分这三种情况呢？还有 len free 能不能继续压缩呢？
我们可以再加一个 flags 字段用来表示，用一个字节放在 柔性数组 buf 之前。
对于压缩，因为 1 字节已经最小了。我们可以使用 位 来储存 len 的大小。
最后我们给出五种类型：
长度为 1 字节，2 字节， 4 字节， 8 字节， 小于 1 字节。
所以至少需要 三个位 来储存类型。（ 2^3 = 8 ）, 剩余 5 位储存长度。这样旧满足长度小于 32 的短字符串。
struct __attribute__ ((__packed__)) sdshdr5{
unsigned char flags; /* 低 3 位存储类型， 高 5 位存储长度 */
char buf[];
}
| flags | flags | flags | flags | flags | flags | flags | flags | flags | buf[1] | buf[...] | buf[n] |
|---|---|---|---|---|---|---|---|---|---|---|---|
| type | type | type | len | len | len | len | len | len | char | ... | char |
那么字符串长度大于 31 的字符串呢？
| len | alloc | flags | buf[1] | buf[...] | buf[n] |
|---|---|---|---|---|---|
| 2 Byte | 2 Byte | 1 Byte | 1 Byte | 1 Byte | 1 Byte |
对于 flags
| flags | flags | flags | ||||||
|---|---|---|---|---|---|---|---|---|
| 1bit | 1bit | 1bit | 1bit | 1bit | 1bit | 1bit | 1bit | 1bit |
这里我们的 len 用了 2 字节， 所以 现在这个例子是 sdshdr16.
flags 除了头三位的类型， 剩余高位部分是没有使用的。
由此我们常用的几种 redis 字符串类型便有了。
#defined SDS_TYPE_5 0
#defined SDS_TYPE_8 1
#defined SDS_TYPE_16 2
#defined SDS_TYPE_32 3
#defined SDS_TYPE_64 4
struct __attribute__ ((__packed__)) sdshdr8{
uint8_t len; /* 已知长度， 1 字节储存 */
uint8_t alloc; /* 总长度 1 字节 ，表示已经分配字节数 */
unsigned char flags; /* 低 3 位存储类型， 高 5 位预留 */
char buf[];
}
struct __attribute__ ((__packed__)) sdshdr16{
uint16_t len; /* 已知长度， 2 字节储存 */
uint16_t alloc; /* 总长度 2 字节 ，表示已经分配字节数 */
unsigned char flags; /* 低 3 位存储类型， 高 5 位预留 */
char buf[];
}
struct __attribute__ ((__packed__)) sdshdr32{
uint32_t len; /* 已知长度， 4 字节储存 */
uint32_t alloc; /* 总长度 4 字节 ，表示已经分配字节数 */
unsigned char flags; /* 低 3 位存储类型， 高 5 位预留 */
char buf[];
}
struct __attribute__ ((__packed__)) sdshdr64{
uint64_t len; /* 已知长度， 8 字节储存 */
uint64_t alloc; /* 总长度 8 字节 ，表示已经分配字节数 */
unsigned char flags; /* 低 3 位存储类型， 高 5 位预留 */
char buf[];
}
/*
题外话： __attribute__ ((__packed__))
一般情况下，结构体会按照所有变量的最小公倍数对齐。
使用 packed 修饰后，结构体变为按 1 字节对齐。
如果没有这个属性，可见 unsigned char 占用内存会变大。使用之后， sdshdr32 可以省略 3 个字节。
另外， SDS 返给上层的是 指向内容的 buf指针。
//这里记录一个自己长久依赖的误区，
1、关于对齐，柔性数组没有大小，可以看作一个占位符。
所以应该能想到，柔性数组必须在 struct 最后，而且一个struct 只能有一个，并且必须存在于含有成员变量的 struct 内部。这就是柔性数组的语法规范
只能有一个柔性数组：结构体中最多只能定义一个柔性数组成员。
必须位于结构体末尾：柔性数组必须是结构体的最后一个成员。
不能指定数组大小：声明时使用空方括号 []，不能写具体大小（如 [0] 或 [1]）。
前面至少有一个其他成员：结构体不能只包含柔性数组。
2、成员变量对齐位置地址起始值应该为，其大小的整数倍。并不是按照倍数无脑填充成整数倍。
*/
好处
1、节省了内存
2、SDS 因为返还给上层的是 buf 指针，所以通过 (char*)sh+hdrlen 即可访问到 buf 指针地址。主要是非对齐的直接通过 sizeof 成员变量得到buf地址。
针对《Redis 5 设计与源码分析》的作者说的另一个优点，使用packed 可以使得各种类型的 sdshdr 都能通过 buf[-1] 访问到 flags。我对这个存疑，可能是我没有理解。
因为 buf 无论是否使用 packed 都紧跟在 flags 后面。所以无论是否对齐，buf[-1] 必然是 flags。
我还想提一句就是 ai 都会出现的幻答，认为所谓对齐是要求所有变量都从所有成员变量的最小公倍数 的 倍数地址开始。这样计算的 偏移地址是错误的。
这样的思想会认为 flags 与 柔性数组buf 之间可能有填充。buf 必然紧跟 flags，而 flags 又是 1个字节。所以我在想这个优点是不是其他论坛的人凭感觉说的。
二、基本操作
1. 创建字符串
//摘自 redis 源码 /src/sds.c
//默认构造
sds sdsnewlen(const void *init, size_t initlen) {
return _sdsnewlen(init, initlen, 0);
}
sds _sdsnewlen(const void *init, size_t initlen, int trymalloc) {
void *sh;
char type = sdsReqType(initlen);
/* Empty strings are usually created in order to append. Use type 8
* since type 5 is not good at this. */
if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
int hdrlen = sdsHdrSize(type);
size_t bufsize;
assert(initlen + hdrlen + 1 > initlen); /* Catch size_t overflow */
sh = trymalloc?
s_trymalloc_usable(hdrlen+initlen+1, &bufsize) :
s_malloc_usable(hdrlen+initlen+1, &bufsize);
if (sh == NULL) return NULL;
adjustTypeIfNeeded(&type, &hdrlen, bufsize);
return sdsnewplacement(sh, bufsize, type, init, initlen);
}
static inline int adjustTypeIfNeeded(char *type, int *hdrlen, size_t bufsize) {
size_t usable = bufsize - *hdrlen - 1;
if (*type != SDS_TYPE_5 && usable > sdsTypeMaxSize(*type)) {
*type = sdsReqType(usable);
*hdrlen = sdsHdrSize(*type);
return 1;
}
return 0;
}
//其他
char sdsReqType(size_t string_size) {
if (string_size < 1 << 5) return SDS_TYPE_5;
if (string_size <= (1 << 8) - sizeof(struct sdshdr8) - 1) return SDS_TYPE_8;
if (string_size <= (1 << 16) - sizeof(struct sdshdr16) - 1) return SDS_TYPE_16;
#if (LONG_MAX == LLONG_MAX)
if (string_size <= (1ll << 32) - sizeof(struct sdshdr32) - 1) return SDS_TYPE_32;
return SDS_TYPE_64;
#else
return SDS_TYPE_32;
#endif
}
# 摘自 redis 源码 /src/sds.h
static inline int sdsHdrSize(char type) {
switch(type&SDS_TYPE_MASK) {
case SDS_TYPE_5:
return sizeof(struct sdshdr5);
case SDS_TYPE_8:
return sizeof(struct sdshdr8);
case SDS_TYPE_16:
return sizeof(struct sdshdr16);
case SDS_TYPE_32:
return sizeof(struct sdshdr32);
case SDS_TYPE_64:
return sizeof(struct sdshdr64);
}
return 0;
}
# /src/sdsalloc.h
#include "zmalloc.h" //redis 内部文件
#define s_malloc_usable zmalloc_usable
#define s_realloc_usable zrealloc_usable
#define s_trymalloc_usable ztrymalloc_usable
笔记：
关于 zmalloc.h
zmalloc.h 是 Redis 源码中的一个关键头文件，它定义了 Redis 内部的内存分配函数。这个文件提供了一套自定义的内存管理接口，主要用于以下目的：
核心功能
内存分配与释放：
- 封装了标准库的 malloc、realloc、free 等函数。
- 提供 zmalloc、zrealloc、zfree 等替代接口。
内存统计：
- 跟踪已分配内存的总量。
- 记录内存分配的峰值。
内存对齐：
- 确保分配的内存按 8 字节或 16 字节对齐，提高访问效率。
内存溢出检测：
- 在调试模式下检测内存越界访问。
内存分配失败处理：
- 当内存分配失败时，提供统一的错误处理机制。
2. 释放字符串
// /src/sds.c
/* Free an sds string. No operation is performed if 's' is NULL. */
void sdsfree(sds s) {
if (s == NULL) return;
s_free((char*)s-sdsHdrSize(s[-1]));
}
// 为了优化性能，sds 提供了不直接释放内存，二十通过重置统计值达到清空目的的方法 -- sdsclear
void sdsclear(sds s) {
sdssetlen(s, 0);
s[0] = '\0';
}
3. 拼接字符串
//暴露给上层
sds sdscatsds(sds s, const sds t) {
return sdscatlen(s, t, sdslen(t));
}
sds sdscatlen(sds s, const void *t, size_t len) {
size_t curlen = sdslen(s);
s = sdsMakeRoomFor(s,len);
if (s == NULL) return NULL;
memcpy(s+curlen, t, len);
sdssetlen(s, curlen+len);
s[curlen+len] = '\0';
return s;
}
sds sdsMakeRoomFor(sds s, size_t addlen) {
return _sdsMakeRoomFor(s, addlen, 1);
}
sds _sdsMakeRoomFor(sds s, size_t addlen, int greedy) {
void *sh, *newsh;
size_t avail = sdsavail(s);
size_t len, newlen, reqlen;
char type, oldtype = sdsType(s);
int hdrlen;
size_t bufsize, usable;
int use_realloc;
//1.可用大于增加，直接返回
/* Return ASAP if there is enough space left. */
if (avail >= addlen) return s;
len = sdslen(s);
sh = (char*)s-sdsHdrSize(oldtype);
reqlen = newlen = (len+addlen);
assert(newlen > len); /* Catch size_t overflow */
//greedy 给的是默认模式 1
//看样子这个模式是决定了 字符串增加的大小规则，其他地方调用可能就不是这个规则。
//#define SDS_MAX_PREALLOC (1024*1024)
//小于 1GB 直接增长一倍，大于 1MB 则添加 1MB
if (greedy == 1) {
if (newlen < SDS_MAX_PREALLOC)
newlen *= 2;
else
newlen += SDS_MAX_PREALLOC;
}
type = sdsReqType(newlen);
/* 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. */
if (type == SDS_TYPE_5) type = SDS_TYPE_8;
hdrlen = sdsHdrSize(type);
assert(hdrlen + newlen + 1 > reqlen); /* Catch size_t overflow */
//类型是否改变，如果改变就不能简单修改 头里面指定的大小值。因为头也要改变
use_realloc = (oldtype == type);
if (use_realloc) {
//类型未改变，直接扩大柔性数组就行
// s_realloc_usable 就是 zrealloc_usable 在 zmalloc.c 文件中，作者解释为
/* Reallocate memory or panic.* '*usable' is set to the usable size if non NULL. */
// 为什么你用了 hdrlen + newlen + 1 ，还要返回 bufsize？ 因为 申请内存和返回可用内存值是不一样的。
// 可能你申请了 100m ，但是系统返回却是 116m 或者， 128m 。 这导致了，还要再判断一次 adjustTypeIfNeeded。
newsh = s_realloc_usable(sh, hdrlen + newlen + 1, &bufsize);
if (newsh == NULL) return NULL;
s = (char*)newsh + hdrlen;
// s_realloc_usable 只负责分配内存，
if (adjustTypeIfNeeded(&type, &hdrlen, bufsize)) {
memmove((char *)newsh + hdrlen, s, len + 1);
s = (char *)newsh + hdrlen;
s[-1] = type;
sdssetlen(s, len);
}
} else {
/* Since the header size changes, need to move the string forward,
* and can't use realloc */
newsh = s_malloc_usable(hdrlen + newlen + 1, &bufsize);
if (newsh == NULL) return NULL;
adjustTypeIfNeeded(&type, &hdrlen, bufsize);
memcpy((char*)newsh+hdrlen, s, len+1);
//释放之前的指针
s_free(sh);
s = (char*)newsh+hdrlen;
s[-1] = type;
sdssetlen(s, len);
}
usable = bufsize - hdrlen - 1;
assert(type == SDS_TYPE_5 || usable <= sdsTypeMaxSize(type));
sdssetalloc(s, usable);
return s;
}
# /src/sds.h
static inline size_t sdsavail(const sds s) {
switch(sdsType(s)) {
case SDS_TYPE_5: {
return 0;
}
case SDS_TYPE_8: {
SDS_HDR_VAR(8,s);
return sh->alloc - sh->len;
}
case SDS_TYPE_16: {
SDS_HDR_VAR(16,s);
return sh->alloc - sh->len;
}
case SDS_TYPE_32: {
SDS_HDR_VAR(32,s);
return sh->alloc - sh->len;
}
case SDS_TYPE_64: {
SDS_HDR_VAR(64,s);
return sh->alloc - sh->len;
}
}
return 0;
}
static inline int adjustTypeIfNeeded(char *type, int *hdrlen, size_t bufsize) {
size_t usable = bufsize - *hdrlen - 1;
//分配完空间后，确保
if (*type != SDS_TYPE_5 && usable > sdsTypeMaxSize(*type)) {
*type = sdsReqType(usable);
*hdrlen = sdsHdrSize(*type);
return 1;
}
return 0;
}
static inline size_t sdsTypeMaxSize(char type) {
if (type == SDS_TYPE_5)
return (1<<5) - 1;
if (type == SDS_TYPE_8)
return (1<<8) - 1;
if (type == SDS_TYPE_16)
return (1<<16) - 1;
#if (LONG_MAX == LLONG_MAX)
if (type == SDS_TYPE_32)
return (1ll<<32) - 1;
#endif
return -1; /* this is equivalent to the max SDS_TYPE_64 or SDS_TYPE_32 */
}
笔记：
newsh = s_realloc_usable(sh, hdrlen + newlen + 1, &bufsize);
既然我申请了 hdrlen + newlen + 1 内存，为何还需要 bufsize？
因为 实际分配的内存会比请求的大？
- 内存对齐（Alignment）
硬件限制：现代 CPU 访问对齐的内存（如 8 字节对齐）比未对齐的内存更快。
操作系统要求：大多数系统要求内存分配按页（通常 4KB）或特定边界对齐。 - 内存块管理开销
分配器需要在内存块中存储元数据（如块大小、是否已分配）。
这些元数据通常存储在内存块的开头或结尾。
4.其他 API
/* Create an empty (zero length) sds string. Even in this case the string
* always has an implicit null term. */
sds sdsempty(void) {
return sdsnewlen("",0);
}
/* Create a new sds string starting from a null terminated C string. */
sds sdsnew(const char *init) {
size_t initlen = (init == NULL) ? 0 : strlen(init);
return sdsnewlen(init, initlen);
}
浙公网安备 33010602011771号