Redis étudie le principe de la chaîne de notes

String est le type de données le plus basique de Redis. Non seulement toutes les clés sont des types de chaîne, mais les éléments composés de plusieurs autres types de données sont également des chaînes. Notez que la longueur de la chaîne ne peut pas dépasser 512 M.

Tout d'abord, qui a stipulé qu'elle ne pouvait pas dépasser 512 M ? Ou pourquoi ne pas dépasser 512M ?

// 源码定义（检查字符串长度）
static int checkStringLength(redisClient *c, long long size) {
    if (size > 512*1024*1024) {
        addReplyError(c,"string exceeds maximum allowed size (512MB)");
        return REDIS_ERR;
    }
    return REDIS_OK;
}

Corrigé par vérification du code source et ne peut pas dépasser 512 M.

Jetons un coup d'œil à la structure des chaînes redis :

struct sdshdr{
    // 记录 buf 数组中已使用字节的数量
    // 等于 SDS 所保存字符串的长度
    int len;
    // 记录 buf 数组中未使用字节的数量
    int free;
    // 字节数组，用于保存字符串
    char buf[];
}

On peut voir directement que int est de 32 bits, il devrait donc pouvoir prendre en charge un maximum de chaînes 4G, mais ce n'est pas la situation réelle .

Afin de savoir pourquoi elle ne peut pas dépasser 512 M, j'ai trouvé une réponse officielle :

Puis j'ai découvert que les informations redis que j'avais lues étaient obsolètes !

Écoutez, il y en a d'autres qui ont également été trompés. Les versions discutées dans cette discussion sont toutes antérieures à 3.2.

话不多说，继续学习 redis5.0 版本的资料。不过之前学习了的也没事，我们可以一起来看下 redis 的字符串是怎么优化的。

用如下结构来存储长度小于32的短字符串：

struct __attribute__((__packed__)) sdshdr5 {
        unsigned char flags; /* 低3位存储类型，高5位存储长度*/
        char buf[]; /* 柔性数组，存放实际内容*/
}

sdshdr5 结构中，flags占1个字节，其低3位（bit）表示type，高5位（bit）表示长度，能表示的长度区间为0～31（25-1）, flags后面就是字符串的内容。

而对于长度大于31的字符串，这个结构就不够用了，所以对于不同长度的字符串，有不同的处理方式：

#define SDS_TYPE_5  0
#define SDS_TYPE_8  1
#define SDS_TYPE_16 2
#define SDS_TYPE_32 3
#define SDS_TYPE_64 4

struct __attribute__ ((__packed__)) sdshdr8 {
    uint8_t len; /* used */
    uint8_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr16 {
    uint16_t len; /* used */
    uint16_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr32 {
    uint32_t len; /* used */
    uint32_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr64 {
    uint64_t len; /* used */
    uint64_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};

可以看到，这4种结构的成员变量类似，唯一的区别是len和alloc的类型不同。

结构体中4个字段的具体含义分别如下:

1）len：表示buf中已占用字节数。

2）alloc：表示buf中已分配字节数，不同于free，记录的是为buf分配的总长度。

3）flags：标识当前结构体的类型，低3位用作标识位，高5位预留。

4) buf : tableau flexible, un espace de données qui stocke réellement des chaînes.

Le processus de création d'une chaîne :

Redis crée SDS via la fonction sdsnewlen. Dans la fonction, le type approprié sera sélectionné en fonction de la longueur de la chaîne. Après avoir initialisé la valeur statistique correspondante, un pointeur vers le contenu de la chaîne sera renvoyé et différents types seront sélectionnés en fonction de la longueur de la chaîne. .

Pour le type sdshdr5, lors de la création d'une chaîne vide, elle sera convertie en sdshdr8. La raison peut être qu'après la création d'une chaîne vide, son contenu peut être fréquemment mis à jour et provoquer une expansion, de sorte qu'elle est directement créée en tant que sdshdr8 lors de sa création.

Épissage de chaînes :

sdscatsds est une méthode exposée à la couche supérieure, et elle appelle finalement sdscatlen. Étant donné que l'expansion de SDS peut être impliquée, sdsMakeRoomFor est appelé dans sdscatlen pour vérifier la capacité de la chaîne épissée s. Si l'expansion n'est pas requise, s est renvoyé directement si l'expansion est requise, la nouvelle chaîne développée s est renvoyée. Les valeurs de longueur telles que len et curlen dans la fonction ne contiennent pas de terminateurs lors de l'épissage, memcpy est utilisé pour assembler les deux chaînes et les longueurs pertinentes sont spécifiées, ce processus garantit donc la sécurité binaire. Un terminateur doit être ajouté à la fin.

Extension de chaîne

1. Si la longueur libre restante disponible dans sds est supérieure à la longueur du nouvel addlen de contenu, ajoutez-la simplement directement à la fin du tableau flexible buf sans extension.

2. Si la longueur libre restante disponible dans la SDS est inférieure ou égale à la longueur du nouveau contenu addlen, nous en discuterons au cas par cas : si la longueur totale après l'ajout est de len+ addlen1 Mo, la capacité sera étendue en ajoutant 1 Mo à la nouvelle longueur.

3. Enfin, resélectionnez le type de stockage en fonction de la nouvelle longueur et allouez de l'espace. S'il n'est pas nécessaire de changer le type ici, développez simplement le tableau flexible via une réallocation, sinon vous devez rouvrir la mémoire et déplacer le contenu buf de la chaîne d'origine vers un nouvel emplacement.

C'est tout pour la ficelle.

Dans la version 5.0, il n'y a pas de limite de chaînes à 512 M. Les méthodes de traitement des chaînes sont différentes selon les différents types, ce qui permet d'économiser plus de mémoire ;