对 cloudwu 简单的 cstring 进行简单解析

面朝大海，春暖花开

              海子 于

从明天起，做一个幸福的人

喂马、劈柴，周游世界

从明天起，关心粮食和蔬菜

我有一所房子，面朝大海，春暖花开

从明天起，和每一个亲人通信

告诉他们我的幸福

那幸福的闪电告诉我的

我将告诉每一个人

给每一条河每一座山取一个温暖的名字

陌生人，我也为你祝福

愿你有一个灿烂的前程

愿你有情人终成眷属

愿你在尘世获得幸福

我只愿面朝大海，春暖花开

同名歌曲

面朝大海 http://music.163.com/#/song?id=27946316

正题

首先下载云风的cstring 源码结构如下:

对 cloudwu 简单的 cstring 进行简单解析

首先看 cstring.h 文件

#ifndef cstring_h

#define cstring_h

#include <stdint.h>

#include <stddef.h>

#define CSTRING_PERMANENT 1

#define CSTRING_INTERNING 2

#define CSTRING_ONSTACK 4

#define CSTRING_INTERNING_SIZE 32

#define CSTRING_STACK_SIZE 128

struct cstring_data {

    char * cstr;

    uint32_t hash_size;

    uint16_t type;

    uint16_t ref;

};

typedef struct _cstring_buffer {

    struct cstring_data * str;

} cstring_buffer[];

typedef struct cstring_data * cstring;

#define CSTRING_BUFFER(var) \

    char var##_cstring [CSTRING_STACK_SIZE] = { '\0' };    \

    struct cstring_data var##_cstring_data = { var##_cstring , , CSTRING_ONSTACK,  };    \

    cstring_buffer var;    \

    var->str = &var##_cstring_data;

#define CSTRING_LITERAL(var, cstr)    \

    static cstring var = NULL;    \

    if (var) {} else {    \

        cstring tmp = cstring_persist(""cstr, (sizeof(cstr)/sizeof(char))-);    \

        if (!__sync_bool_compare_and_swap(&var, NULL, tmp)) {    \

            cstring_free_persist(tmp);    \

        }    \

    }

#define CSTRING(s) ((s)->str)

#define CSTRING_CLOSE(var) \

    if ((var)->str->type != ) {} else \

        cstring_release((var)->str);

/* low level api, don't use directly */

cstring cstring_persist(const char * cstr, size_t sz);

void cstring_free_persist(cstring s);

/* public api */

cstring cstring_grab(cstring s);

void cstring_release(cstring s);

cstring cstring_cat(cstring_buffer sb, const char * str);

cstring cstring_printf(cstring_buffer sb, const char * format, ...)

#ifdef __GNUC__

    __attribute__((format(printf, , )))

#endif

;

int cstring_equal(cstring a, cstring b);

uint32_t cstring_hash(cstring s);

#endif

第一部分对头文件 cstring.h 简单解析如下(对于源码全部解释,自己说的不爽,别人看也会不爽,毕竟不是原创)

1.1 字符串类型

#define CSTRING_PERMANENT 1

上面声明表示一个永久的串类型,实现采用static 变量类型声明

#define CSTRINT_INTERNING 2

上面表示一个符号表字符串类型,实现方式直接 "root" 这么搞

#define CSTRING_ONSTACK  4

这大家都知道临时字符串类型,实现方式利用宏嵌到函数代码体中

1.2 字符串大小宏

#define CSTRING_INTERNING_SIZE 32

上面是符号表串,小于32字节的都可以声明为 CSTRINT_INTERNING

#define CSTRING_STACK_SIZE  128

上面是表明小于128字节的都可以放到栈上类型 CSTRING_ONSTACK

2.1 特殊的结构体

typedef struct cstring_buffer {

    struct cstring_data * str;

} cstring_buffer[];

上面定义的 cstring_buffer 类型,是C中一个声明技巧

例如 cstring_buffer cb; 其中 cb 内存分配在栈上但是可以当指针使用,传入到 struct cstring_buffer* 地方.

更简单一点如下,其它就自己悟吧

cstring_buffer cb; => struct cstring_buffer cb[];

3.1 函数宏分析

#define CSTRING_BUFFER(var) \

    char var##_cstring[CSTRING_STACK_SIZE] = { '\0' }; \

    struct cstring_data var##_cstring_data = { var##_cstring, , CSTRING_ONSTACK,  }; \

    cstring_buffer var; \

    var->str = &var##cstring_data;

这个宏也很巧妙, ## 表示链接宏假如 var 是 abc,var只能同变量,不能有双引号

那么就声明了一个

char abc_cstring[] = { '\0' };

这个变量内存在栈上,通常不需要回收.

这个宏作用是声明了一个名为 var 的 cstring_buffer 对象但是在函数结束时，应该使用 CSTRING_CLOSE(var) 关闭它。

3.2 另一个出彩的函数宏

#define CSTRING_LITERAL(var, cstr) \

    static cstring var = NULL; \

    if (var) {} else { \

        cstring tmp = cstring_persist(""cstr, (sizeof(cstr)/sizeof(char)-)); \

        if(!__sync_bool_compare_and_swap(&var, NULL, tmp)){ \

            cstring_free_persist(tmp); \

        } \

    }

这个函数宏声明变量都是全局存储区的变量,这里认为是常量cstring.

但是cstr必须是引起""引起宏.

这里这个

cstring_persist(""cstr, (sizeof(cstr)/sizeof(char)-));

""特别亮,在函数编译的时候就能找出错误!第二参数常量字符串最后一个字符的索引

后面 __sync_bool_compare_and_swap 是gcc 内置的原子函数,推荐用最新的gcc版本测试

详细一点介绍是

bool __sync_bool_compare_and_swap (type *ptr, type oldval, type newval, ...);

__sync_bool_compare_and_swap 内置函数比较 oldval 和 *ptr。如果它们匹配，就把 newval 复制到 *ptr。此时返回返回值是 true，否则是 false.

这个函数在并发编程中甩掉互斥锁N条街.

4.1 函数解析,首先是cstring 如果需要把字符串做参数传递，就应该使用 cstring 类型，而不是 cstring_buffer 类型。

CSTRING(var) 可以把 var 这个 cstring_buffer 对象，转换为 cstring 类型。

但是，在对 cstring_buffer 对象做新的操作后，这个 cstring 可能无效。

所以每次传递 cstring_buffer 内的值，最好都重新用 CSTRING 宏取一次。

函数调用的参数以及返回值，都应该使用 cstring 类型。

如果 cstring 是由外部传入的，无法确定它的数据在栈上还是堆上，所以不能长期持有。

如果需要把 cstring 保存在数据结构中，可以使用这对 API :

cstring cstring_grab(cstring s); 

void cstring_release(cstring s);

把 cstring 转化为标准的 const char * ，只需要用 s->cstr 即可。

cstring 的比较操作以及 hash 操作都比 const char * 廉价，所以，请使用以下 API :

int cstring_equal(cstring a, cstring b);

uint32_t cstring_hash(cstring s);

这里还有一个函数声明

cstring cstring_printf(cstring_buffer sb, const char * format, ...)

#ifdef __GNUC__

    __attribute__((format(printf, , )))

#endif

重点是后面的 __attribute__() 这也是个gcc 内置语法,是对编译器编译行为进行一些约定 , 这里 format (printf, 2, 3)告诉编译器，

cstring_printf的format相当于printf的format，而可变参数是从cstring_printf的第3个参数开始。

这样编译器就会在编译时用和printf一样的check法则来确认可变参数是否正确了.

关于 gcc编译器的控制行为,还是比较多的.自己可以搜索一下 gcc __attribute__,这些都很死,不是大神推荐不要用太多编译器指令,不通用技巧性太强,容易东施效颦!

到这里第一部分基本就解释完毕了.

这里再扩展一点对于结构

struct cstring_data {

    char *        cstr;

    uint32_t    hash_size;

    uint16_t    type;

    uint16_t    ref;

};

后面使用的时候常出现这样的代码

    struct cstring_data *p = malloc(sizeof(struct cstring_data) + sz + );

    // todo: memory alloc error

    assert(p);

    void * ptr = (void *)(p + );

    p->cstr = ptr;

    p->type = ;

    p->ref = ;

    memcpy(ptr, cstr, sz);

    ((char*)ptr)[sz] = '\0';

    p->hash_size = ;

这里的一个技巧是直接一次 malloc 将两个内存都分配好了 .

第一个 sizeof (struct cstring_data) 是给 p用的,

第二个 sizeof (struct cstring_data) + sz + 1 给 p->cstr 用的,.

对于这个技巧还用更巧的是

struct cstring_data {

    uint32_t    hash_size;

    uint16_t    type;

    uint16_t    ref;

    char []    cstr;

};

这种结构声明方式和方式一样

    struct cstring_data *p = malloc(sizeof(struct cstring_data) + sz + );

下面这种方式和上面比有点内存更小了, 小了 sizeof (cstr).

不要在C中问出,少了4字节有什么意义,那只能推荐你去学java吧.

但是为什么云风没有这么干呢. 是这样的后面那种声明方式为不完全类型, 有点像

void* arg;

内存只能通过堆分配,不在在栈上分配,而 cstring 需要运用栈内存,具体看下面宏.

#define CSTRING_BUFFER(var) \

    char var##_cstring[CSTRING_STACK_SIZE] = { '\0' }; \

    struct cstring_data var##_cstring_data = { var##_cstring, , CSTRING_ONSTACK,  }; \

    cstring_buffer var; \

    var->str = &var##_cstring_data;

这里再扩展一下,吐槽一下云风前辈

    struct cstring_data *p = malloc(sizeof(struct cstring_data) + sz + );

    // todo: memory alloc error

    assert(p);

第一次见这样代码,看一遍觉得好,屌.

看第二遍有点不对吧.

看第三遍确定这样是用错了assert, assert 在开启 NDEBUG 会失效.

假如程序正式跑了,设置了

gcc -Wall -INDEBUG -o $^ $@

上面代码 assert 就等同于

#ifdef NDEBUG

    #define assert(expression) ((void)0)

#endif

那么程序假如另一个 BUG,将内存吃完了,这里就是未定义修改未知内存,基本是返回NULL,操作NULL,程序崩了.

服务器当了,查原因还没日志...... 这是不好的, 反正是他用错了

还是用下面这样质朴的代码吧

struct cstring_data *p = malloc(sizeof(struct cstring_data) + sz + );

// todo: memory alloc error

if(NULL == p) {

   fprintf(stderr, "[%s][%d][%s][error:malloc struct cstring_data return NULL!]",__FILE__, __LINE__, __func__) ;

   return NULL;

}

上面写的比较简单,还需要错误输出需要考虑时间.

第二部分写一个简单例子直接用云风的 test.c

#include "cstring.h"

#include <stdio.h>

static cstring

foo(cstring t) {

    CSTRING_LITERAL(hello, "hello");

    CSTRING_BUFFER(ret);

    if (cstring_equal(hello,t)) {

        cstring_cat(ret, "equal");

    } else {

        cstring_cat(ret, "not equal");

    }

    return cstring_grab(CSTRING(ret));

}

static void

test() {

    CSTRING_BUFFER(a);

    cstring_printf(a, "%s", "hello");

    cstring b = foo(CSTRING(a));

    printf("%s\n", b->cstr);

    cstring_printf(a, "very long string %01024d",);

    printf("%s\n", CSTRING(a)->cstr);

    CSTRING_CLOSE(a);

    cstring_release(b);

}

int

main() {

    test();

    return ;

}

我们采用 Ubuntu 测试一下

对 cloudwu 简单的 cstring 进行简单解析

编译失败,按照下面改

vim Makefile

gcc -g -Wall -march=native -o test test.c cstring.c

Esc

wq!

最后结果如下

对 cloudwu 简单的 cstring 进行简单解析

到这里我们代码已经跑起来了. 对于 test.c中

我们简单解释一下其中 test.c使用到的 api

    CSTRING_BUFFER(a);

    cstring_printf(a, "%s", "hello");

一开a字符串在栈上,后面输出的串比较小,仍然在栈上.后面有个

    CSTRING_CLOSE(a);

关闭这个内存,本质是

#define CSTRING_CLOSE(var) \

    if ((var)->str->type != ) {} else \

        cstring_release((var)->str);

因为 a->str->type == CSTRING_ONSTACK != 0 所以 cstring_release执行后没有反应,可有可无.

但是推荐 CSTRING_BUFFER 和 CSTRING_CLOSE 成对出现.

还有就是 foo 函数里面

    CSTRING_LITERAL(hello, "hello");

    CSTRING_BUFFER(ret);

hello 相当于符号表中字符串,生存周期是和程序同生共死的.ret 目前在栈上.

后面

    if (cstring_equal(hello,t)) {

        cstring_cat(ret, "equal");

    } else {

        cstring_cat(ret, "not equal");

    }

这个二者执行的 cstring_cat(ret, "equal"); 结果是塞得字符串小 ret仍然是栈上的.

后面返回

    return cstring_grab(CSTRING(ret));

变成运行时串既

cs->type = CSTRING_INTERNING;
cs->ref = 0;

所以最后就不需要 CSTRING_CLOSE (ret);

到了

    cstring_printf(a, "very long string %01024d",);

变成待释放的临时串 r->type = 0; r->ref = 1;

技巧很多,主要还是需要看源码, 将在第三部剖析一下实现 string.c中的一些技巧!

第三部分 string.c 源码观察

#include "cstring.h"

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include <string.h>

#include <stdarg.h>

#define FORMAT_TEMP_SIZE 1024

#define INTERNING_POOL_SIZE 1024

// HASH_START_SIZE must be 2 pow

#define HASH_START_SIZE 16

struct string_node {

    struct cstring_data str;

    char buffer[CSTRING_INTERNING_SIZE];

    struct string_node * next;

};

struct string_pool {

    struct string_node node[INTERNING_POOL_SIZE];

};

struct string_interning {

    int lock;

    int size;

    struct string_node ** hash;

    struct string_pool * pool;

    int index;

    int total;

};

static struct string_interning S;

static inline void

LOCK() {

    while (__sync_lock_test_and_set(&(S.lock),)) {}

}

static inline void

UNLOCK() {

    __sync_lock_release(&(S.lock));

}

static void

insert_node(struct string_node ** hash, int sz, struct string_node *n) {

    uint32_t h = n->str.hash_size;

    int index = h & (sz-);

    n->next = hash[index];

    hash[index] = n;

}

static void

expand(struct string_interning * si) {

    int new_size = si->size * ;

    if (new_size < HASH_START_SIZE) {

        new_size = HASH_START_SIZE;

    }

    assert(new_size > si->total);

    struct string_node ** new_hash = malloc(sizeof(struct string_node *) * new_size);

    memset(new_hash, , sizeof(struct string_node *) * new_size);

    int i;

    for (i=;i<si->size;i++) {

        struct string_node *node = si->hash[i];

        while (node) {

            struct string_node * tmp = node->next;

            insert_node(new_hash, new_size, node);

            node = tmp;

        }

    }

    free(si->hash);

    si->hash = new_hash;

    si->size = new_size;

}

static cstring

interning(struct string_interning * si, const char * cstr, size_t sz, uint32_t hash) {

    if (si->hash == NULL) {

        return NULL;

    }

    int index = (int)(hash & (si->size-));

    struct string_node * n = si->hash[index];

    while(n) {

        if (n->str.hash_size == hash) {

            if (strcmp(n->str.cstr, cstr) == ) {

                return &n->str;

            }

        }

        n = n->next;

    }

    // 80% (4/5) threshold

    if (si->total *  >= si->size * ) {

        return NULL;

    }

    if (si->pool == NULL) {

        // need not free pool

        // todo: check memory alloc error

        si->pool = malloc(sizeof(struct string_pool));

        assert(si->pool);

        si->index = ;

    }

    n = &si->pool->node[si->index++];

    memcpy(n->buffer, cstr, sz);

    n->buffer[sz] = '\0';

    cstring cs = &n->str;

    cs->cstr = n->buffer;

    cs->hash_size = hash;

    cs->type = CSTRING_INTERNING;

    cs->ref = ;

    n->next = si->hash[index];

    si->hash[index] = n;

    return cs;

}

static cstring

cstring_interning(const char * cstr, size_t sz, uint32_t hash) {

    cstring ret;

    LOCK();

    ret = interning(&S, cstr, sz, hash);

    if (ret == NULL) {

        expand(&S);

        ret = interning(&S, cstr, sz, hash);

    }

    ++S.total;

    UNLOCK();

    assert(ret);

    return ret;

}

static uint32_t

hash_blob(const char * buffer, size_t len) {

    const uint8_t * ptr = (const uint8_t *) buffer;

    size_t h = len;

    size_t step = (len>>)+;

    size_t i;

    for (i=len; i>=step; i-=step)

        h = h ^ ((h<<)+(h>>)+ptr[i-]);

    if (h == )

        return ;

    else

        return h;

}

void

cstring_free_persist(cstring s) {

    if (s->type == CSTRING_PERMANENT) {

        free(s);

    }

}

static cstring

cstring_clone(const char * cstr, size_t sz) {

    if (sz < CSTRING_INTERNING_SIZE) {

        return cstring_interning(cstr, sz, hash_blob(cstr,sz));

    }

    struct cstring_data * p = malloc(sizeof(struct cstring_data) + sz + );

    // todo: memory alloc error

    assert(p);

    void * ptr = (void *)(p + );

    p->cstr = ptr;

    p->type = ;

    p->ref = ;

    memcpy(ptr, cstr, sz);

    ((char *)ptr)[sz] = '\0';

    p->hash_size = ;

    return p;

}

cstring

cstring_persist(const char * cstr, size_t sz) {

    cstring s = cstring_clone(cstr, sz);

    if (s->type == ) {

        s->type = CSTRING_PERMANENT;

        s->ref = ;

    }

    return s;

}

cstring

cstring_grab(cstring s) {

    if (s->type & (CSTRING_PERMANENT | CSTRING_INTERNING)) {

        return s;

    }

    if (s->type == CSTRING_ONSTACK) {

        cstring tmp = cstring_clone(s->cstr, s->hash_size);

        return tmp;

    } else {

        if (s->ref == ) {

            s->type = CSTRING_PERMANENT;

        } else {

            __sync_add_and_fetch(&s->ref,);

        }

        return s;

    }

}

void

cstring_release(cstring s) {

    if (s->type != ) {

        return;

    }

    if (s->ref == ) {

        return;

    }

    if (__sync_sub_and_fetch(&s->ref,) == ) {

        free(s);

    }

}

uint32_t

cstring_hash(cstring s) {

    if (s->type == CSTRING_ONSTACK)

        return hash_blob(s->cstr, s->hash_size);

    if (s->hash_size == ) {

        s->hash_size = hash_blob(s->cstr, strlen(s->cstr));

    }

    return s->hash_size;

}

int

cstring_equal(cstring a, cstring b) {

    if (a == b)

        return ;

    if ((a->type == CSTRING_INTERNING) &&

        (b->type == CSTRING_INTERNING)) {

        return ;

    }

    if ((a->type == CSTRING_ONSTACK) &&

        (b->type == CSTRING_ONSTACK)) {

        if (a->hash_size != b->hash_size) {

            return ;

        }

        return memcmp(a->cstr, b->cstr, a->hash_size) == ;

    }

    uint32_t hasha = cstring_hash(a);

    uint32_t hashb = cstring_hash(b);

    if (hasha != hashb) {

        return ;

    }

    return strcmp(a->cstr, b->cstr) == ;

}

static cstring

cstring_cat2(const char * a, const char * b) {

    size_t sa = strlen(a);

    size_t sb = strlen(b);

    if (sa + sb < CSTRING_INTERNING_SIZE) {

        char tmp[CSTRING_INTERNING_SIZE];

        memcpy(tmp, a, sa);

        memcpy(tmp+sa, b, sb);

        tmp[sa+sb] = '\0';

        return cstring_interning(tmp, sa+sb, hash_blob(tmp,sa+sb));

    }

    struct cstring_data * p = malloc(sizeof(struct cstring_data) + sa + sb + );

    // todo: memory alloc error

    assert(p);

    char * ptr = (char *)(p + );

    p->cstr = ptr;

    p->type = ;

    p->ref = ;

    memcpy(ptr, a, sa);

    memcpy(ptr+sa, b, sb);

    ptr[sa+sb] = '\0';

    p->hash_size = ;

    return p;

}

cstring

cstring_cat(cstring_buffer sb, const char * str) {

    cstring s = sb->str;

    if (s->type == CSTRING_ONSTACK) {

        int i = (int)s->hash_size;

        while (i < CSTRING_STACK_SIZE-) {

            s->cstr[i] = *str;

            if (*str == '\0') {

                return s;

            }

            ++s->hash_size;

            ++str;

            ++i;

        }

        s->cstr[i] = '\0';

    }

    cstring tmp = s;

    sb->str = cstring_cat2(tmp->cstr, str);

    cstring_release(tmp);

    return sb->str;

}

static cstring

cstring_format(const char * format, va_list ap) {

    static char * cache = NULL;

    char * result;

    char * temp = cache;

    // read cache buffer atomic

    if (temp) {

        temp = __sync_val_compare_and_swap(&cache, temp, NULL);

    }

    if (temp == NULL) {

        temp = (char *)malloc(FORMAT_TEMP_SIZE);

        // todo : check malloc

        assert(temp);

    }

    int n = vsnprintf(temp, FORMAT_TEMP_SIZE, format, ap);

    if (n >= FORMAT_TEMP_SIZE) {

        int sz = FORMAT_TEMP_SIZE * ;

        for (;;) {

            result = malloc(sz);

            // todo : check malloc

            assert(result);

            n = vsnprintf(result, sz, format, ap);

            if (n >= sz) {

                free(result);

                sz *= ;

            } else {

                break;

            }

        }

    } else {

        result = temp;

    }

    cstring r = (cstring)malloc(sizeof(struct cstring_data) + n + );

    // todo : check malloc

    assert(r);

    r->cstr = (char *)(r+);

    r->type = ;

    r->ref = ;

    r->hash_size = ;

    memcpy(r->cstr, result, n+);

    if (temp != result) {

        free(result);

    }

    // save temp atomic

    if (!__sync_bool_compare_and_swap(&cache, NULL, temp)) {

        free(temp);

    } else {

    }

    return r;

}

cstring

cstring_printf(cstring_buffer sb, const char * format, ...) {

    cstring s = sb->str;

    va_list ap;

    va_start(ap, format);

    if (s->type == CSTRING_ONSTACK) {

        int n = vsnprintf(s->cstr, CSTRING_STACK_SIZE, format, ap);

        if (n >= CSTRING_STACK_SIZE) {

            s = cstring_format(format, ap);

            sb->str = s;

        } else {

            s->hash_size = n;

        }

    } else {

        cstring_release(sb->str);

        s = cstring_format(format, ap);

        sb->str = s;

    }

    va_end(ap);

    return s;

}

上面就是 cstring.c的源码 . 总的而言还是比较短的容易理解 ,我们依次分析. 扯一点,

他这些技巧我都会,还敲了两三遍. 因为他用的比我熟练.假如你看到这, 你需要敲更多,才能掌握,C的技巧也挺难的.真的
搞起来就和算术公式一样.

首先分析数据结构,基本就是流水账了

/**

 * todo insert explain

 *

 * FORMAT_TEMP_SIZE 是后面函数 cstring_format 分配内存初始化大小 1k

 *

 * INTERNING_POOL_SIZE 表示 符号表池的大小 1k

 *

 * HASH_START_SIZE hash操作在expand中使用,插入hash使用,是 a mod b 中b的初始化值

 */

#define FORMAT_TEMP_SIZE 1024

#define INTERNING_POOL_SIZE 1024

// HASH_START_SIZE must be 2 pow

#define HASH_START_SIZE 16

/**

 * todo insert explain

 *

 * 这是一个字符串链表, hash采用桶和链表实现,这就是链表.

 * char buffer[CSTRING_INTERNING_SIZE];内存在栈上 ,直接 给 string_node.str.cstr

 * struct string_node保存运行中字符串,直接和 程序同生存周期

 */

struct string_node {

    struct cstring_data str;

    char buffer[CSTRING_INTERNING_SIZE];

    struct string_node * next;

};

/*

 * todo insert explain

 *

 * string_node 的 池,这个吃的大小是固定的,1k,过了程序会异常

 */

struct string_pool {

    struct string_node node[INTERNING_POOL_SIZE];

};

/**

 * 这是 字符串 池

 *

 * lock 加锁用的

 * size hash的大小,围绕他取余做hash

 * hash 保存字符串的对象

 * pool 符号表存储的地方

 * index 内部指示 pool使用到哪了

 * total 指示当前 string_interning 中保存了多少 字符串运行时常量

 */

struct string_interning {

    int lock;

    int size;

    struct string_node ** hash;

    struct string_pool * pool;

    int index;

    int total;

};

// 全局临时用的 字符串池对象

static struct string_interning S;

// 加锁

static inline void

LOCK() {

    while (__sync_lock_test_and_set(&(S.lock), )) {}

}

//解锁 具体参照 原子参照

static inline void

UNLOCK() {

    __sync_lock_release(&(S.lock));

}

这里扩展一下就相当于吐槽,首先关于

S.index 用法局限性很大

    if (si->pool == NULL) {

        // need not free pool

        //todo : check memory alloc error

        si->pool = malloc(sizeof(struct string_pool));

        assert(si->pool);

        si->index = ;

    }

    n = &si->pool->node[si->index++];

全局只用++,相当于只生产字符串,只增不减. 超过了 1024 程序就崩了. 内存访问越界. 这里我们在下一篇博文中

重构这个字符串.思路有两个

1. 打错误日志, 加大错误警报作用

2. 改变 string_interning 结构, 让其也支持自动扩容处理.

吐槽一下, 他这里写的不好, 这样的代码 , 根本不敢挂上服务器跑. 到时候再优化,保证让其从玩具变成高级玩具.

这里再吐槽一下关于 gcc inline 用法. 具体看推荐的参照资料. inline 只能用于简单的顺序结构函数.

否则这样声明编译器也还是让其变为普通函数.

测试如下,采用window 汇编,linux 也一样通过 gcc -S 看汇编.

测试 main.c 如下:

#include <stdio.h>

#include <stdlib.h>

int g_cut = ;

__inline void cnotcplusplus(void)

{

    for (int i = ; i < ; ++i)

        ++g_cut;

    //测试三 VS能够使用内联

    //++ g_cut;

}

int main(int argc, char* argv[])

{

    printf("g_cut = %d\n", g_cut);

    /*

     *测试一

     */

    for (int i = ; i < ; ++i)

        ++g_cut;

    /*

     * 测试二 内联函数 汇编代码对比

     */

    cnotcplusplus();

    printf("g_cut = %d\n", g_cut);

    system("pause");

    return ;

}

编译环境是

对 cloudwu 简单的 cstring 进行简单解析

这里运行打断点查看汇编如下

--- h:\vs_project\clouwu_string\test_inline\main.c -----------------------------

    printf("g_cut = %d\n", g_cut);

012A1040  push        dword ptr [g_cut (012A3374h)]

012A1046  push        offset string "g_cut = %d\n" (012A2108h)

012A104B  call        printf (012A1010h)  

    /*

     *测试一

     */

    for (int i = ; i < ; ++i)

        ++g_cut;

012A1050  mov         eax,dword ptr [g_cut (012A3374h)]  

    /*

     * 测试二 内联函数 汇编代码对比

     */

    cnotcplusplus();

012A1055  add         eax,14h  

    printf("g_cut = %d\n", g_cut);

012A1058  push        eax

012A1059  push        offset string "g_cut = %d\n" (012A2108h)  

    /*

     * 测试二 内联函数 汇编代码对比

     */

    cnotcplusplus();

012A105E  mov         dword ptr [g_cut (012A3374h)],eax  

    printf("g_cut = %d\n", g_cut);

012A1063  call        printf (012A1010h)  

    system("pause");

012A1068  push        offset string "pause" (012A2114h)  

    system("pause");

012A106D  call        dword ptr [__imp__system (012A2064h)]

012A1073  add         esp,14h

    return ;

012A1076  xor         eax,eax

}

大家可以自己测试测试,这里测试结果关于 inline 函数中出现 while 编译器会将这个 inline函数当做普通函数处理.

这是一个失误,如果一定要这么干, 可以用宏代替,下一个版本再搞. 这个字符串博文拖得太长了,准备就当下草草干掉了. 争取下一个版本

带来一个高级的玩具.

/*

 * 将字符串结点n 插入 到 字符串hash表中

 *

 * h & (sz -1) => h mod sz, 当然 sz 必须 是 2 正整数次幂

 */

static inline void

insert_node(struct string_node ** hash, int sz, string_node *n) ;

/*

 * 对 S 中初始化或 扩容的函数

 * 会重新hash操作,调整结构

 */

static void

expand(struct string_interning * si);

/*

 * 插入 一个字符串到 字符串池中,线程安全,运行时不安全

 */

static cstring

cstring_interning(const char * cstr, size_t sz, uint32_t hash);

/*

 * js hash 命中率 为 80%左右

 * 这里 对于 h == 0,即hash_size == 0做特殊处理,待定,没有比较久不需要生成

 */

static uint32_t

hash_blob(const char * buffer, size_t len);

这里简单说一下对于 expand 中

    int new_size = si->size * ;

    if (new_size < HASH_START_SIZE) {

        new_size = HASH_START_SIZE;

    }

第二个判断可以省略,放在 S 的声明的初始化中. 其它的改进不提了,自己看,多看看都能有见解. 这里扩展一下, 刚对他的写的代码.

还是能感觉一股铺面而来的代码美感, 能感觉都很多都是手工敲的. 他的美感多于他的失误. 但是这样的代码是不能用在实战中,为什么呢,

你用这个代码,你看几遍这个源码.用起来内存泄露的都无法控制了. 这也是很多开源的代码,不是领头羊,很少敢直接用于核心模块中,除非别无选择.

因为维护的人没时间, 而自己不是作者,改起来成本比开发一个更高.总而言之,开源和封闭是两种模式最鲜明对比就是安卓与 ios.

继续,

/*

 * 释放永久串, 相当于 释放 'static' string

 */

void

cstring_free_persist(cstring s) ;

/*

 * 这里 复制一份字符串,

 * type =0 , 表示 未初始化, 这样串可以可以被 cstring_release释放

 */

static cstring

cstring_clone(const char * cstr, size_t sz) ;

/*

 * 申请这样的永久的串

 */

cstring

cstring_persist(const char * cstr, size_t sz) ;

/*

 * 将栈上串 搞一份出来到 普通串中需要调用 释放函数 CSTRING_CLOSE

 * 如果 是 永久串 直接 变成 引用加1

 */

cstring

cstring_grab(cstring s) ;

/*

 * 释放函数.只有 type == 0 && s->ref == 1才去释放

 */

void

cstring_release(cstring s);

这里再扩展一下看 cstring.h 中宏

#define CSTRING_LITERAL(var, cstr) \

    static cstring var = NULL; \

    if (var) {} else { \

        cstring tmp = cstring_persist(""cstr, (sizeof(cstr)/sizeof(char)-)); \

        if(!__sync_bool_compare_and_swap(&var, NULL, tmp)){ \

            cstring_free_persist(tmp); \

        } \

    }

这也是个技巧,如何创建静态堆上常用变量. 相当于通过 CSTRING_LITERAL 创建静态的字符串 var 变量

并声明了内存. 云风就是在秀技巧的. 反正也是学到了,下次自己也用用.

后面还有字符串拼接,这就是相当于字符串重构,性能差. 也是为什么要有 StringBuilder 的原因

/**

 *

 * 就是一个简单的字符串拼接函数,比较低效

 *

 * 这里有个优化 是 如果串比较直接放在栈上

 */

static cstring

cstring_cat2(const char *a, const char * b) ;

/*

 * 先自己拼接一下 啥也没解决 最后给 cstring_cat2

 */

cstring

cstring_cat(cstring_buffer sb, const char *str) ;

更多的细节需要看源码. 最后分析 string_printf 函数

/*

 * 找到固定大小 塞数据进来

 */

static cstring

cstring_format(const char * format, va_list ap) ;

/*

 * 按照标准输出到 sb中,sb内存不够会给它分配 通过 cstring_format

 */

cstring

cstring_printf(cstring_buffer sb, const char *format, ...) ;

到这里源码是看完了.

多写几遍都明白了. 不好意思太晚了不扩展了,(后面有点忽悠了, 明天还要上班.)

后记

到这里错误是难免的,欢迎指正立马改. 下一篇中会对cstring 进行重构. 解决云风的坑.

最后想说一句, char * 够用了, 真的,C开发没有那么多复杂的.

我很水,但我会改正的, 欢迎批评.

秒客网

对 cloudwu 简单的 cstring 进行简单解析

相关文章