hash/index/atom

1. Hash.c/hash.h

typedef struct hash
{
    HashFunctions fun;   /* Function block */
    int is_allocated;    /* 0 iff hash structure is on stack or is static */
    ErtsAlcType_t type;
    char* name;          /* Table name (static string, for debugging) */
    int size; /* Number of slots */
    int size20percent;   /* 20 percent of number of slots */
    int size80percent;   /* 80 percent of number of slots */
    int ix;              /* Size index in size table */
    int used; /* Number of slots used */
    HashBucket** bucket; /* Vector of bucket pointers (objects) */
} Hash;

函数：
typedef struct hash_functions
{
    H_FUN hash; //取值
    HCMP_FUN cmp; //比较
    HALLOC_FUN alloc;
    HFREE_FUN free;
} HashFunctions;

桶：
/*
** This bucket must be placed in top of
** every object that uses hashing!!!
** (Object*) == (Object*) &bucket
*/
typedef struct hash_bucket
{
    struct hash_bucket* next; /* Next bucket */
    HashValue hvalue;           /* Store hash value for get, rehash */
} HashBucket;

查找：
/*
** Find an object in the hash table
**
*/
void* hash_get(Hash* h, void* tmpl)
{
    HashValue hval = h->fun.hash(tmpl);
    int ix = hval % h->size;
    HashBucket* b = h->bucket[ix];

    while(b != (HashBucket*) 0) {
if ((b->hvalue == hval) && (h->fun.cmp(tmpl, (void*)b) == 0))
    return (void*) b;
b = b->next;
    }
    return (void*) 0;
}

Rehash？？？
2. Index.c/index.h


typedef struct index_table
{
    Hash htable; /* Mapping obj -> index */
    ErtsAlcType_t type;
    int size; /* Allocated size */
    int limit; /* Max size */
    int entries; /* Number of entries */
    IndexSlot*** seg_table; /* Mapping index -> obj */
} IndexTable;


Hash中应该存储的是 obj -> index(即IndexSlot*)


int
index_put(IndexTable* t, void* tmpl)
{
    int ix;
    IndexSlot* p = (IndexSlot*) hash_put(&t->htable, tmpl);

    if (p->index >= 0) {
return p->index;
    }

    ix = t->entries;
    if (ix >= t->size) {
Uint sz;
if (ix >= t->limit) {
    erl_exit(1, "no more index entries in %s (max=%d)\n",
     t->htable.name, t->limit);
}
sz = INDEX_PAGE_SIZE*sizeof(IndexSlot*);
t->seg_table[ix>>INDEX_PAGE_SHIFT] = erts_alloc(t->type, sz);
t->size += INDEX_PAGE_SIZE;
    }
    t->entries++;
    p->index = ix;
    t->seg_table[ix>>INDEX_PAGE_SHIFT][ix&INDEX_PAGE_MASK] = p;
    return ix;
}

其实就是hash表，再加一个Index -> HashBucket的映射（即IndexSlot*）

3. Atom
typedef struct atom {
    IndexSlot slot;  /* MUST BE LOCATED AT TOP OF STRUCT!!! */
    int len;         /* length of atom name */
    int ord0;        /* ordinal value of first 3 bytes + 7 bits */
    byte* name;      /* name of atom */
} Atom;

Eterm
am_atom_put(const char* name, int len)
{
    Atom a;
    Eterm ret;
    int aix;

    /*
     * Silently truncate the atom if it is too long. Overlong atoms
     * could occur in situations where we have no good way to return
     * an error, such as in the I/O system. (Unfortunately, many
     * drivers don't check for errors.)
     *
     * If an error should be produced for overlong atoms (such in
     * list_to_atom/1), the caller should check the length before
     * calling this function.
     */
    if (len > MAX_ATOM_LENGTH) {
len = MAX_ATOM_LENGTH;
    }
    a.len = len;
    a.name = (byte*)name;
    atom_read_lock();
    aix = index_get(&erts_atom_table, (void*) &a);
    atom_read_unlock();
    if (aix >= 0)
ret = make_atom(aix);
    else {
atom_write_lock();
ret = make_atom(index_put(&erts_atom_table, (void*) &a));
atom_write_unlock();
    }
    return ret;
}
如果erts_atom_table中有这个atom，则直接生成一个atom；
否则先index_put进来，在生成一个atom

#define make_atom(x)  ((Eterm)(((x) << _TAG_IMMED2_SIZE) + _TAG_IMMED2_ATOM))

Atom的Eterm就是把一个index包上tag，length。。。