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

面朝大海，春暖花开
              海子 于 1989
从明天起，做一个幸福的人
喂马、劈柴，周游世界
从明天起，关心粮食和蔬菜
我有一所房子，面朝大海，春暖花开

从明天起，和每一个亲人通信
告诉他们我的幸福
那幸福的闪电告诉我的
我将告诉每一个人

给每一条河每一座山取一个温暖的名字
陌生人，我也为你祝福
愿你有一个灿烂的前程
愿你有情人终成眷属
愿你在尘世获得幸福
我只愿面朝大海，春暖花开

同名歌曲

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

正题

首先下载云风的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[1];

typedef struct cstring_data * cstring;

#define CSTRING_BUFFER(var) \
    char var##_cstring [CSTRING_STACK_SIZE] = { '\0' };    \
    struct cstring_data var##_cstring_data = { var##_cstring , 0, CSTRING_ONSTACK, 0 };    \
    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))-1);    \
        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 != 0) {} 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, 2, 3)))
#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[1];

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

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

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

cstring_buffer cb; => struct cstring_buffer cb[1];

3.1 函数宏分析

#define CSTRING_BUFFER(var) \
    char var##_cstring[CSTRING_STACK_SIZE] = { '\0' }; \
    struct cstring_data var##_cstring_data = { var##_cstring, 0, CSTRING_ONSTACK, 0 }; \
    cstring_buffer var; \
    var->str = &var##cstring_data;

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

那么就声明了一个

char abc_cstring[128] = { '\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)-1)); \
        if(!__sync_bool_compare_and_swap(&var, NULL, tmp)){ \
            cstring_free_persist(tmp); \
        } \
    }

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

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

这里这个

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

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

后面 __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, 2, 3)))
#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 + 1);
    // todo: memory alloc error
    assert(p);
    void * ptr = (void *)(p + 1);
    p->cstr = ptr;
    p->type = 0;
    p->ref = 1;
    memcpy(ptr, cstr, sz);
    ((char*)ptr)[sz] = '\0';
    p->hash_size = 0;

这里的一个技巧是直接一次 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 + 1);

下面这种方式和上面比有点内存更小了, 小了 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, 0, CSTRING_ONSTACK, 0 }; \
    cstring_buffer var; \
    var->str = &var##_cstring_data;

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

    struct cstring_data *p = malloc(sizeof(struct cstring_data) + sz + 1);
    // 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 + 1);
// 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",0);
    printf("%s\n", CSTRING(a)->cstr);
    CSTRING_CLOSE(a);
    cstring_release(b);
}

int
main() {
    test();
    return 0;
}

我们采用 Ubuntu 测试一下

编译失败,按照下面改

vim Makefile
gcc -g -Wall -march=native -o test test.c cstring.c
Esc
wq!

最后结果如下

到这里我们代码已经跑起来了. 对于 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 != 0) {} 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",0);

变成待释放的临时串 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),1)) {}
}

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-1);
    n->next = hash[index];
    hash[index] = n;
}

static void
expand(struct string_interning * si) {
    int new_size = si->size * 2;
    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, 0, sizeof(struct string_node *) * new_size);
    int i;
    for (i=0;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-1));
    struct string_node * n = si->hash[index];
    while(n) {
        if (n->str.hash_size == hash) {
            if (strcmp(n->str.cstr, cstr) == 0) {
                return &n->str;
            }
        }
        n = n->next;
    }
    // 80% (4/5) threshold
    if (si->total * 5 >= si->size * 4) {
        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 = 0;
    }
    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 = 0;

    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>>5)+1;
    size_t i;
    for (i=len; i>=step; i-=step)
        h = h ^ ((h<<5)+(h>>2)+ptr[i-1]);
    if (h == 0)
        return 1;
    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 + 1);
    // todo: memory alloc error
    assert(p);
    void * ptr = (void *)(p + 1);
    p->cstr = ptr;
    p->type = 0;
    p->ref = 1;
    memcpy(ptr, cstr, sz);
    ((char *)ptr)[sz] = '\0';
    p->hash_size = 0;
    return p;
}

cstring 
cstring_persist(const char * cstr, size_t sz) {
    cstring s = cstring_clone(cstr, sz);
    if (s->type == 0) {
        s->type = CSTRING_PERMANENT;
        s->ref = 0;
    }
    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 == 0) {
            s->type = CSTRING_PERMANENT;
        } else {
            __sync_add_and_fetch(&s->ref,1);
        }
        return s;
    }
}

void 
cstring_release(cstring s) {
    if (s->type != 0) {
        return;
    }
    if (s->ref == 0) {
        return;
    }
    if (__sync_sub_and_fetch(&s->ref,1) == 0) {
        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 == 0) {
        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 1;
    if ((a->type == CSTRING_INTERNING) &&
        (b->type == CSTRING_INTERNING)) {
        return 0;
    }
    if ((a->type == CSTRING_ONSTACK) &&
        (b->type == CSTRING_ONSTACK)) {
        if (a->hash_size != b->hash_size) {
            return 0;
        }
        return memcmp(a->cstr, b->cstr, a->hash_size) == 0;
    }
    uint32_t hasha = cstring_hash(a);
    uint32_t hashb = cstring_hash(b);
    if (hasha != hashb) {
        return 0;
    }
    return strcmp(a->cstr, b->cstr) == 0;
}

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 + 1);
    // todo: memory alloc error
    assert(p);
    char * ptr = (char *)(p + 1);
    p->cstr = ptr;
    p->type = 0;
    p->ref = 1;
    memcpy(ptr, a, sa);
    memcpy(ptr+sa, b, sb);
    ptr[sa+sb] = '\0';
    p->hash_size = 0;
    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-1) {
            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 * 2;
        for (;;) {
            result = malloc(sz);
            // todo : check malloc
            assert(result);
            n = vsnprintf(result, sz, format, ap);
            if (n >= sz) {
                free(result);
                sz *= 2;
            } else {
                break;
            }
        }
    } else {
        result = temp;
    }
    cstring r = (cstring)malloc(sizeof(struct cstring_data) + n + 1);
    // todo : check malloc
    assert(r);
    r->cstr = (char *)(r+1);
    r->type = 0;
    r->ref = 1;
    r->hash_size = 0;
    memcpy(r->cstr, result, n+1);
    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), 1)) {}
}

//解锁 具体参照 原子参照
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 = 0;
    }
    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 = 0;

__inline void cnotcplusplus(void)
{
    for (int i = 0; i < 10; ++i)
        ++g_cut;

    //测试三 VS能够使用内联
    //++ g_cut;
}

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

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

    /*
     *测试一
     */
    for (int i = 0; i < 10; ++i)
        ++g_cut;

    /*
     * 测试二 内联函数 汇编代码对比
     */
    cnotcplusplus();


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

    system("pause");
    return 0;
}

编译环境是

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

--- 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 = 0; i < 10; ++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 0;
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 * 2;
    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)-1)); \
        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开发没有那么多复杂的.

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

posted on 2015-12-17 00:50 喜ω欢阅读(858) 评论(0) 编辑收藏举报

刷新页面返回顶部

喜欢

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

导航

公告