/* returns TME_FALSE if the entry is not found */
uint32 normal_lut_wo_insert(uint8 *key, TME_DATA *data, MEM_TYPE *mem_ex, struct time_conv *time_ref)
{
uint32 i;
uint32 tocs=0;
uint32 *key32=(uint32*) key;
uint32 shrinked_key=0;
uint32 index;
RECORD *records=(RECORD*)data->lut_base_address;
uint8 *offset;
uint32 key_len=data->key_len;
/*the key is shrinked into a 32-bit value */
for (i=0; i<key_len;i++)
shrinked_key^=key32[i];
/*the first index in the table is calculated*/
index=shrinked_key % data->lut_entries;
while (tocs<=data->filled_entries)
{
if (records[index].block==0)
{ /*out of table, insertion is not allowed*/
GET_TIME((struct timeval *)(data->shared_memory_base_address+4*key_len),time_ref);
data->last_found=NULL;
return TME_FALSE;
}
/*offset contains the absolute pointer to the block*/
/*associated with the current entry */
offset=mem_ex->buffer+SW_ULONG_AT(&records[index].block,0);
for (i=0; (i<key_len) && (key32[i]==ULONG_AT(offset,i*4)); i++);
if (i==key_len)
{
/*key in the block matches the one provided, right entry*/
GET_TIME((struct timeval *)(offset+4*key_len),time_ref);
data->last_found=(uint8*)&records[index];
return TME_TRUE;
}
else
{
/*wrong entry, rehashing*/
index=(index+data->rehashing_value) % data->lut_entries;
tocs++;
}
}
/*nothing found, last found= out of lut*/
GET_TIME((struct timeval *)(data->shared_memory_base_address+4*key_len),time_ref);
data->last_found=NULL;
return TME_FALSE;
}
/* manage values of 16, 32 bits. */
uint32 bucket_lookup(uint8 *key, TME_DATA *data, MEM_TYPE *mem_ex, struct time_conv *time_ref)
{
uint32 value;
uint32 i,j;
int found=-1;
uint32 blocks;
uint32 block_size;
uint8 *temp;
UNUSED(mem_ex);
if ((data->key_len!=1)&& /*16 bit value*/
(data->key_len!=2)) /*32 bit value*/
return TME_ERROR;
/*32 bit values*/
blocks=data->filled_blocks-1;
block_size=data->block_size;
i=blocks/2; /*relative shift*/
j=i;
temp=data->shared_memory_base_address+block_size;
if (data->key_len==2)
{
value=SW_ULONG_AT(key,0);
if((value<SW_ULONG_AT(temp,0))||(value>SW_ULONG_AT(temp+block_size*(blocks-1),4)))
{
uint32 *key32=(uint32*) key;
key32[0]=key32[1]=0;
GET_TIME((struct timeval *)(data->shared_memory_base_address+8),time_ref);
data->last_found=NULL;
return TME_FALSE;
}
while(found==-1) /* search routine */
{
i=(i==1)? 1:i>>1;
if (SW_ULONG_AT(temp+block_size*j,0)>value)
if (SW_ULONG_AT(temp+block_size*(j-1),4)<value)
found=-2;
else
j-=i;
else
if (SW_ULONG_AT(temp+block_size*j,4)<value)
if (SW_ULONG_AT(temp+block_size*j,0)>value)
found=-2;
else
j+=i;
else found=j;
}
if (found<0)
{
uint32 *key32=(uint32*) key;
key32[0]=key32[1]=0;
GET_TIME((struct timeval *)(data->shared_memory_base_address+8),time_ref);
data->last_found=NULL;
return TME_FALSE;
}
data->last_found=data->lut_base_address+found*sizeof(RECORD);
COPY_MEMORY(key,temp+block_size*found,8);
GET_TIME((struct timeval *)(temp+block_size*found+8),time_ref);
return TME_TRUE;
}
/* returns TME_FALSE if no more blocks are available */
uint32 normal_lut_w_insert(uint8 *key, TME_DATA *data, MEM_TYPE *mem_ex, struct time_conv *time_ref)
{
uint32 i;
uint32 tocs=0;
uint32 *key32=(uint32*) key;
uint32 shrinked_key=0;
uint32 index;
RECORD *records=(RECORD*)data->lut_base_address;
uint8 *offset;
uint32 key_len=data->key_len;
/*the key is shrinked into a 32-bit value */
for (i=0; i<key_len;i++)
shrinked_key^=key32[i];
/*the first index in the table is calculated*/
index=shrinked_key % data->lut_entries;
while (tocs<=data->filled_entries)
{
if (records[index].block==0)
{ /*creation of a new entry*/
if (data->filled_blocks==data->shared_memory_blocks)
{
/*no more free blocks*/
GET_TIME((struct timeval *)(data->shared_memory_base_address+4*key_len),time_ref);
data->last_found=NULL;
return TME_FALSE;
}
/*offset=absolute pointer to the block associated*/
/*with the newly created entry*/
offset=data->shared_memory_base_address+
data->block_size*data->filled_blocks;
/*copy the key in the block*/
COPY_MEMORY(offset,key32,key_len*4);
GET_TIME((struct timeval *)(offset+4*key_len),time_ref);
/*assign the block relative offset to the entry, in NBO*/
SW_ULONG_ASSIGN(&records[index].block,offset-mem_ex->buffer);
data->filled_blocks++;
/*assign the exec function ID to the entry, in NBO*/
SW_ULONG_ASSIGN(&records[index].exec_fcn,data->default_exec);
data->filled_entries++;
data->last_found=(uint8*)&records[index];
return TME_TRUE;
}
/*offset contains the absolute pointer to the block*/
/*associated with the current entry */
offset=mem_ex->buffer+SW_ULONG_AT(&records[index].block,0);
for (i=0; (i<key_len) && (key32[i]==ULONG_AT(offset,i*4)); i++);
if (i==key_len)
{
/*key in the block matches the one provided, right entry*/
GET_TIME((struct timeval *)(offset+4*key_len),time_ref);
data->last_found=(uint8*)&records[index];
return TME_TRUE;
}
else
{
/* wrong entry, rehashing */
if (IS_DELETABLE(offset+key_len*4,data))
{
ZERO_MEMORY(offset,data->block_size);
COPY_MEMORY(offset,key32,key_len*4);
SW_ULONG_ASSIGN(&records[index].exec_fcn,data->default_exec);
GET_TIME((struct timeval*)(offset+key_len*4),time_ref);
data->last_found=(uint8*)&records[index];
return TME_TRUE;
}
else
{
index=(index+data->rehashing_value) % data->lut_entries;
tocs++;
}
}
}
/* nothing found, last found= out of lut */
GET_TIME((struct timeval *)(data->shared_memory_base_address+4*key_len),time_ref);
data->last_found=NULL;
return TME_FALSE;
}
