lua数据结构之TString的内部实现

一、TString结构

1、结构分析

TString是存放字符串的结构体，代码如下：

typedef union TString {  L_Umaxalign dummy;  /* ensures maximum alignment for strings */  struct {    CommonHeader;    lu_byte reserved; /* 保留字段 */    unsigned int hash; /* hash值 */    size_t len; /* 字符串长度 */  } tsv;} TString;

结构很简单，主要是CommonHeader，他有两个作用。其一，用于hash值冲突时的链表结构。其二与CGObject形成多态的一个关系。结构如下：

#define CommonHeader    GCObject *next; lu_byte tt; lu_byte marked

结构也很明了，next指针指向下一个冲突的TString，tt为类型，marked是gc时用到的，暂时不敞开分析。

2、字符串的存放方式

了解完TString的结构以后，或许许多人会有疑问，那字符串数据是存放在哪的？结构中也没有char指针变量呀？的确，字符串不是放在TString这个结构里的，而是往TString后的地址上开辟一段以字符串长度为大小的内存空间，然后把字符串复制到这个空间中。代码如下：

static TString *newlstr (lua_State *L, const char *str, size_t l,                                       unsigned int h) {  TString *ts;  //创建TString内存空间，大小等于TString大小加上字符串大小。  //可以看出字符串是直接放在TString内存块地址后面的  ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));  ...省略...  memcpy(ts+1, str, l*sizeof(char));    /* 复制字符串到TString内存块地址后面的位置上。*/  ((char *)(ts+1))[l] = '\0';  /* ending 0 */  ...省略...｝

二、全局hash表

对于大量的字符串创建，为了能高效的利用内存空间，lua 有一套设计思想。 所有已创建的TString数据，都会生成一个hash值，并放到hash表里。当创建的字符串是在hash表中已存在的话，则直接返回相同的字符串。

1、stringtable的结构

hash表是放在stringtable中的，结构如下：

typedef struct stringtable {  GCObject **hash;  /* hash表，存放 TString指针的数组*/  lu_int32 nuse;  /* TString数量 */  int size;  /* hash表大小，大小为2^n */} stringtable;

2、存放TString

每次创建完TString ＊str以后，都会根据其hash值获得在hash表中相对的位置节点，把str放到当前节点。如果有hash值冲突，则把str->next指向冲突节点。存放模型如下图：

主要代码如下：

static TString *newlstr (lua_State *L, const char *str, size_t l,                                       unsigned int h) {  TString *ts;  stringtable *tb;  ...省略...  h = lmod(h, tb->size);    /*通过hash值，转换为具体下标位置*/  ts->tsv.next = tb->hash[h];  /* 新的字符串存到hash表里，并把next指向之前冲突的字符串*/  tb->hash[h] = obj2gco(ts);  ...省略...}

三、字符串的创建

创建流程如下图：

每次创建时，都会先计算当前字符串对应的hash值，在获得相对hash表里的位置节点。如果节点已经被占用，则遍历冲突节点，判断当前字符串是否已经存在。如果存在则返回已存在的节点，否则创建TString，并放到hash表中。

判断字符串是否已经存在的代码如下：

TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {  GCObject *o;  unsigned int h = cast(unsigned int, l);  /* seed */  size_t step = (l>>5)+1;  /* if string is too long, don't hash all its chars */  size_t l1;  for (l1=l; l1>=step; l1-=step)  /* 计算hash值*/    h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));    //遍历在冲突位置上的TString，查找是否已经存在相同的字符串  for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];       o != NULL;       o = o->gch.next) {        //转化为TString类型    TString *ts = rawgco2ts(o);        //判断长度和字符串是否相同    if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0)) {      /* gc部分，以后在分析 */      if (isdead(G(L), o)) changewhite(o);      return ts;    }  }    //全局string表没有找到，创建新的字符串。  return newlstr(L, str, l, h);  /* not found */}

创建新TString代码如下:

static TString *newlstr (lua_State *L, const char *str, size_t l,                                       unsigned int h) {  TString *ts;  stringtable *tb;    //字符长度是否越界  if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))    luaM_toobig(L);    //创建TString内存空间，大小等于TString大小加上字符串大小。    //可以看出字符串是直接放在TString内存块地址后面的  ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));  ts->tsv.len = l;  ts->tsv.hash = h;  ts->tsv.marked = luaC_white(G(L));  ts->tsv.tt = LUA_TSTRING;  ts->tsv.reserved = 0;    memcpy(ts+1, str, l*sizeof(char));  /* 复制字符串到TString内存块地址后面的位置上。*/  ((char *)(ts+1))[l] = '\0';  /* ending 0 */  tb = &G(L)->strt;  h = lmod(h, tb->size);    /*通过hash值，转换为具体下标位置*/  ts->tsv.next = tb->hash[h];  /* 新的字符串存到hash表里，并把next指向之前冲突的字符串*/  tb->hash[h] = obj2gco(ts);  tb->nuse++;    //hash表空间不够？  if (tb->nuse > cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)    luaS_resize(L, tb->size*2);  /* 重新设置hash表大小*/  return ts;}

四、hash表空间扩展

hash表的空间扩展大致分为三步，第一步创建新的内存空间并初始化所有的节点，第二步把旧hash表的数据赋值给新表，最后释放旧表空间。代码如下：

void luaS_resize (lua_State *L, int newsize) {  GCObject **newhash;  stringtable *tb;  int i;  if (G(L)->gcstate == GCSsweepstring)    return;  /* cannot resize during GC traverse */    //创建新空间  newhash = luaM_newvector(L, newsize, GCObject *);  tb = &G(L)->strt;    //初始化  for (i=0; i<newsize; i++) newhash[i] = NULL;  /* rehash 把老的hash表里的值换到新hash表中*/  for (i=0; i<tb->size; i++) {    GCObject *p = tb->hash[i];        //循环冲突节点    while (p) {  /* for each node in the list */      GCObject *next = p->gch.next;  /* save next */      unsigned int h = gco2ts(p)->hash;      int h1 = lmod(h, newsize);  /* 根据hash值计算相对于newsize的位置*/      lua_assert(cast_int(h%newsize) == lmod(h, newsize));      p->gch.next = newhash[h1];  /* 把旧的冲突节点放在新的冲突链表上*/      newhash[h1] = p;      p = next;    }  }    //释放旧的hash表  luaM_freearray(L, tb->hash, tb->size, TString *);  tb->size = newsize;  tb->hash = newhash;}