mirror of
https://github.com/lua/lua
synced 2024-11-25 14:20:41 +03:00
b28da81cfe
pela estrategia de re-hash. Foi feito uma avaliacao da funcao de hash, e constatado sua eficiencia com uma media de 4 acessos no hash ate' 70% ocupado.
355 lines
6.7 KiB
C
355 lines
6.7 KiB
C
/*
|
|
** hash.c
|
|
** hash manager for lua
|
|
*/
|
|
|
|
char *rcs_hash="$Id: hash.c,v 2.3 1994/08/05 19:25:09 celes Exp celes $";
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "mm.h"
|
|
|
|
#include "opcode.h"
|
|
#include "hash.h"
|
|
#include "inout.h"
|
|
#include "table.h"
|
|
#include "lua.h"
|
|
|
|
#define streq(s1,s2) (*(s1) == *(s2) && strcmp(s1,s2)==0)
|
|
|
|
#define new(s) ((s *)malloc(sizeof(s)))
|
|
#define newvector(n,s) ((s *)calloc(n,sizeof(s)))
|
|
|
|
#define nhash(t) ((t)->nhash)
|
|
#define nuse(t) ((t)->nuse)
|
|
#define markarray(t) ((t)->mark)
|
|
#define nodevector(t) ((t)->node)
|
|
#define node(t,i) (&(t)->node[i])
|
|
#define ref(n) (&(n)->ref)
|
|
#define val(n) (&(n)->val)
|
|
|
|
|
|
#define REHASH_LIMIT 0.70 /* avoid more than this % full */
|
|
|
|
|
|
typedef struct ArrayList
|
|
{
|
|
Hash *array;
|
|
struct ArrayList *next;
|
|
} ArrayList;
|
|
|
|
static ArrayList *listhead = NULL;
|
|
|
|
|
|
|
|
/* hash dimensions values */
|
|
static int dimensions[] =
|
|
{7, 11, 23, 47, 97, 197, 397, 797, 1597, 3203, 6421, 12853, 25717, 51437, 0};
|
|
static int redimension (int nhash)
|
|
{
|
|
int i;
|
|
for (i=0; dimensions[i]!=0; i++)
|
|
{
|
|
if (dimensions[i] > nhash)
|
|
return dimensions[i];
|
|
}
|
|
return nhash*2+1;
|
|
}
|
|
|
|
static int index (Hash *t, Object *ref) /* hash function */
|
|
{
|
|
switch (tag(ref))
|
|
{
|
|
case T_NUMBER:
|
|
return (((int)nvalue(ref))%nhash(t));
|
|
case T_STRING:
|
|
{
|
|
int h;
|
|
char *name = svalue(ref);
|
|
for (h=0; *name!=0; name++) /* interpret name as binary number */
|
|
{
|
|
h <<= 8;
|
|
h += (unsigned char) *name; /* avoid sign extension */
|
|
h %= nhash(t); /* make it a valid index */
|
|
}
|
|
return h;
|
|
}
|
|
case T_FUNCTION:
|
|
return (((int)bvalue(ref))%nhash(t));
|
|
case T_CFUNCTION:
|
|
return (((int)fvalue(ref))%nhash(t));
|
|
case T_ARRAY:
|
|
return (((int)avalue(ref))%nhash(t));
|
|
case T_USERDATA:
|
|
return (((int)uvalue(ref))%nhash(t));
|
|
default:
|
|
lua_reportbug ("unexpected type to index table");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
static int present (Hash *t, Object *ref)
|
|
{
|
|
int h = index(t, ref);
|
|
if (h < 0) return h;
|
|
while (tag(ref(node(t, h))) != T_NIL)
|
|
{
|
|
NCOLISSIONS++;
|
|
if (tag(ref) == T_NUMBER && tag(ref(node(t, h))) == T_NUMBER &&
|
|
nvalue(ref) == nvalue(ref(node(t, h)))
|
|
) return h;
|
|
if (tag(ref) == T_STRING && tag(ref(node(t, h))) == T_STRING &&
|
|
streq(svalue(ref),svalue(ref(node(t, h))))
|
|
) return h;
|
|
if (tag(ref) == tag(ref(node(t, h))) &&
|
|
uvalue(ref) == uvalue(ref(node(t, h))) /* all others are pointers */
|
|
) return h;
|
|
h = (h+1) % nhash(t);
|
|
}
|
|
return h;
|
|
}
|
|
|
|
|
|
/*
|
|
** Alloc a vector node
|
|
*/
|
|
static Node *hashnodecreate (int nhash)
|
|
{
|
|
int i;
|
|
Node *v = newvector (nhash, Node);
|
|
if (v == NULL)
|
|
{
|
|
lua_error ("not enough memory");
|
|
return NULL;
|
|
}
|
|
for (i=0; i<nhash; i++)
|
|
tag(ref(&v[i])) = T_NIL;
|
|
return v;
|
|
}
|
|
|
|
/*
|
|
** Create a new hash. Return the hash pointer or NULL on error.
|
|
*/
|
|
static Hash *hashcreate (int nhash)
|
|
{
|
|
Hash *t = new (Hash);
|
|
if (t == NULL)
|
|
{
|
|
lua_error ("not enough memory");
|
|
return NULL;
|
|
}
|
|
nhash = redimension(nhash);
|
|
|
|
nodevector(t) = hashnodecreate(nhash);
|
|
if (nodevector(t) == NULL)
|
|
return NULL;
|
|
|
|
nhash(t) = nhash;
|
|
nuse(t) = 0;
|
|
markarray(t) = 0;
|
|
return t;
|
|
}
|
|
|
|
/*
|
|
** Delete a hash
|
|
*/
|
|
static void hashdelete (Hash *t)
|
|
{
|
|
free (nodevector(t));
|
|
free(t);
|
|
}
|
|
|
|
|
|
/*
|
|
** Mark a hash and check its elements
|
|
*/
|
|
void lua_hashmark (Hash *h)
|
|
{
|
|
if (markarray(h) == 0)
|
|
{
|
|
int i;
|
|
markarray(h) = 1;
|
|
for (i=0; i<nhash(h); i++)
|
|
{
|
|
Node *n = node(h,i);
|
|
if (tag(ref(n)) != T_NIL)
|
|
{
|
|
lua_markobject(&n->ref);
|
|
lua_markobject(&n->val);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Garbage collection to arrays
|
|
** Delete all unmarked arrays.
|
|
*/
|
|
void lua_hashcollector (void)
|
|
{
|
|
ArrayList *curr = listhead, *prev = NULL;
|
|
while (curr != NULL)
|
|
{
|
|
ArrayList *next = curr->next;
|
|
if (markarray(curr->array) != 1)
|
|
{
|
|
if (prev == NULL) listhead = next;
|
|
else prev->next = next;
|
|
hashdelete(curr->array);
|
|
free(curr);
|
|
}
|
|
else
|
|
{
|
|
markarray(curr->array) = 0;
|
|
prev = curr;
|
|
}
|
|
curr = next;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** Create a new array
|
|
** This function insert the new array at array list. It also
|
|
** execute garbage collection if the number of array created
|
|
** exceed a pre-defined range.
|
|
*/
|
|
Hash *lua_createarray (int nhash)
|
|
{
|
|
ArrayList *new = new(ArrayList);
|
|
if (new == NULL)
|
|
{
|
|
lua_error ("not enough memory");
|
|
return NULL;
|
|
}
|
|
new->array = hashcreate(nhash);
|
|
if (new->array == NULL)
|
|
{
|
|
lua_error ("not enough memory");
|
|
return NULL;
|
|
}
|
|
|
|
if (lua_nentity == lua_block)
|
|
lua_pack();
|
|
|
|
lua_nentity++;
|
|
new->next = listhead;
|
|
listhead = new;
|
|
return new->array;
|
|
}
|
|
|
|
|
|
/*
|
|
** Re-hash
|
|
*/
|
|
static void rehash (Hash *t)
|
|
{
|
|
int i;
|
|
int nold = nhash(t);
|
|
Node *vold = nodevector(t);
|
|
nhash(t) = redimension(nhash(t));
|
|
nodevector(t) = hashnodecreate(nhash(t));
|
|
for (i=0; i<nold; i++)
|
|
{
|
|
Node *n = vold+i;
|
|
if (tag(ref(n)) != T_NIL && tag(val(n)) != T_NIL)
|
|
*node(t, present(t, ref(n))) = *n; /* copy old node to new hahs */
|
|
}
|
|
free(vold);
|
|
}
|
|
|
|
/*
|
|
** If the hash node is present, return its pointer, otherwise return a
|
|
** static nil object
|
|
*/
|
|
Object *lua_hashget (Hash *t, Object *ref)
|
|
{
|
|
static Object nil_obj = {T_NIL, {NULL}};
|
|
int h = present(t, ref);
|
|
if (h < 0) return NULL;
|
|
if (tag(ref(node(t, h))) == T_NIL) return &nil_obj;
|
|
else return val(node(t, h));
|
|
}
|
|
|
|
/*
|
|
** If the hash node is present, return its pointer, otherwise create a new
|
|
** node for the given reference and also return its pointer.
|
|
** On error, return NULL.
|
|
*/
|
|
Object *lua_hashdefine (Hash *t, Object *ref)
|
|
{
|
|
int h;
|
|
Node *n;
|
|
h = present(t, ref);
|
|
if (h < 0) return NULL;
|
|
n = node(t, h);
|
|
if (tag(ref(n)) == T_NIL)
|
|
{
|
|
nuse(t)++;
|
|
if (nuse(t) > nhash(t)*REHASH_LIMIT)
|
|
{
|
|
rehash(t);
|
|
h = present(t, ref);
|
|
n = node(t, h);
|
|
}
|
|
*ref(n) = *ref;
|
|
tag(val(n)) = T_NIL;
|
|
}
|
|
return (val(n));
|
|
}
|
|
|
|
|
|
/*
|
|
** Internal function to manipulate arrays.
|
|
** Given an array object and a reference value, return the next element
|
|
** in the hash.
|
|
** This function pushs the element value and its reference to the stack.
|
|
*/
|
|
static void hashnext (Hash *t, int i)
|
|
{
|
|
if (i >= nhash(t))
|
|
{
|
|
lua_pushnil(); lua_pushnil();
|
|
return;
|
|
}
|
|
while (tag(ref(node(t,i))) == T_NIL || tag(val(node(t,i))) == T_NIL)
|
|
{
|
|
if (++i >= nhash(t))
|
|
{
|
|
lua_pushnil(); lua_pushnil();
|
|
return;
|
|
}
|
|
}
|
|
lua_pushobject(ref(node(t,i)));
|
|
lua_pushobject(val(node(t,i)));
|
|
}
|
|
|
|
void lua_next (void)
|
|
{
|
|
Hash *t;
|
|
Object *o = lua_getparam (1);
|
|
Object *r = lua_getparam (2);
|
|
if (o == NULL || r == NULL)
|
|
{ lua_error ("too few arguments to function `next'"); return; }
|
|
if (lua_getparam (3) != NULL)
|
|
{ lua_error ("too many arguments to function `next'"); return; }
|
|
if (tag(o) != T_ARRAY)
|
|
{ lua_error ("first argument of function `next' is not a table"); return; }
|
|
|
|
t = avalue(o);
|
|
if (tag(r) == T_NIL)
|
|
{
|
|
hashnext(t, 0);
|
|
}
|
|
else
|
|
{
|
|
int h = present (t, r);
|
|
if (h >= 0)
|
|
hashnext(t, h+1);
|
|
else
|
|
lua_error ("error in function 'next': reference not found");
|
|
}
|
|
}
|
|
|