int Cache::get_data(const int index, Qfloat **data, int len)
{
head_t *h = &head[index];
if(h->len) lru_delete(h);
int more = len - h->len;
if(more > 0)
{
// free old space
while(size < more)
{
head_t *old = lru_head.next;
lru_delete(old);
free(old->data);
size += old->len;
old->data = 0;
old->len = 0;
}
// allocate new space
h->data = (Qfloat *)realloc(h->data,sizeof(Qfloat)*len);
size -= more;
swap(h->len,len);
}
lru_insert(h);
*data = h->data;
return len;
}
void Cache::swap_index(int i, int j)
{
if(i==j) return;
if(head[i].len) lru_delete(&head[i]);
if(head[j].len) lru_delete(&head[j]);
swap(head[i].data,head[j].data);
swap(head[i].len,head[j].len);
if(head[i].len) lru_insert(&head[i]);
if(head[j].len) lru_insert(&head[j]);
if(i>j) swap(i,j);
for(head_t *h = lru_head.next; h!=&lru_head; h=h->next)
{
if(h->len > i)
{
if(h->len > j)
swap(h->data[i],h->data[j]);
else
{
// give up
lru_delete(h);
free(h->data);
size += h->len;
h->data = 0;
h->len = 0;
}
}
}
}
Qfloat* sCache::get_data(int idx, int len, int& numRet)
{
shead_t *h = &head[idx];
h->refcount ++;
if(h->len > 0) lru_delete(h);
if(len > h->max_len)
{
int more = len + CACHE_DELTA - h->max_len;
h->max_len = h->max_len + more;
int count = 0;
// free old space
while(maxItem < more) //requested space exceeds logical limit
{
count++;
shead_t *old = lru_head.next;
lru_delete(old);
free(old->data);
old->data = NULL;
maxItem += old->max_len;
old->len = 0;
old->max_len = 0;
}
// allocate new space
h->data = (Qfloat *)realloc(h->data,sizeof(Qfloat)*h->max_len);
if (h->data == NULL)//requested space cannot be provided by physical limit
{
while(h->data == NULL && lru_head.next != &lru_head)
{
shead_t *old = lru_head.next;
lru_delete(old);
if (old->refcount <= 0)
{
free(old->data);
old->data = NULL;
maxItem += old->max_len;
old->len = 0;
old->max_len = 0;
h->data = (Qfloat *)calloc(h->max_len,sizeof(Qfloat));
}
else
{
old->refcount --;
lru_insert(old);
}
}
h->len = 0;
if (h->data == NULL)
{
printf ("sCache cannot allocate memory!\n");
return NULL;
}
}
maxItem -= more;
}
lru_insert(h);
numRet = h->len;
h->len = len;
return h->data;
}
/****************************** LOCAL FUNCTIONS *******************************/
int main ()
{
int32_t i_ret_val = -1;
PAL_RET_E e_pal_ret = ePAL_RET_FAILURE;
bool b_pal_init = false;
PAL_LOGGER_INIT_PARAMS_X x_logger_param = { false };
LRU_RET_E e_lru_ret = eLRU_RET_FAILURE;
LRU_HDL hl_lru_hdl = NULL;
LRU_INIT_PARAMS_X x_lru_init_params = {0};
LRU_NODE_DATA_X x_node_data = {eHM_KEY_TYPE_INVALID};
uint8_t uca_str_buf[1024] = {0};
int i_command = -1;
int i_ret = -1;
bool b_exit = false;
x_logger_param.b_enable_console_logging = true;
x_logger_param.e_level = eLOG_LEVEL_HIGH;
pal_logger_env_init (&x_logger_param);
e_pal_ret = pal_env_init ();
if (ePAL_RET_SUCCESS != e_pal_ret)
{
LRU_TEST_LOG ("pal_env_init failed: %d", e_pal_ret);
goto CLEAN_RETURN;
}
b_pal_init = true;
LRU_TEST_LOG ("pal_env_init success");
x_lru_init_params.ui_max_size_bytes = (1 * 1024 * 1024);
e_lru_ret = lru_init(&hl_lru_hdl, &x_lru_init_params);
if ((eLRU_RET_SUCCESS != e_lru_ret) || (NULL == hl_lru_hdl)) {
LRU_TEST_LOG ("lru_create failed: %d, %p", e_lru_ret, hl_lru_hdl);
goto CLEAN_RETURN;
}
LRU_TEST_LOG ("lru_create success: %d, %p", e_lru_ret, hl_lru_hdl);
while (1)
{
printf ("Commands:\n\t1. Add\n\t2. Search\n\t3. Delete"
"\n\t4. Delete All\n\t5. Exit\n"
"Enter Command: ");
fflush (stdout);
PAL_GET_INT32_FROM_CONSOLE(&i_command);
if (4 != i_command && 5 != i_command && 6 != i_command)
{
printf ("Enter String: "); fflush (stdout);
PAL_GET_STRING_FROM_CONSOLE(uca_str_buf, sizeof(uca_str_buf));
}
switch (i_command)
{
case 1:
{
(void) pal_memset(&x_node_data, 0x00, sizeof(x_node_data));
x_node_data.x_hm_node.e_hm_key_type = eHM_KEY_TYPE_STRING;
x_node_data.x_hm_node.u_hm_key.puc_str_key = uca_str_buf;
x_node_data.x_hm_node.p_data = malloc (100);
x_node_data.x_hm_node.ui_data_size = 100;
e_lru_ret = lru_set (hl_lru_hdl, &x_node_data);
if (eLRU_RET_SUCCESS != e_lru_ret) {
LRU_TEST_LOG ("lru_set failed: %d, %p", e_lru_ret, hl_lru_hdl);
}
else {
LRU_TEST_LOG ("lru_set success: %d, %p", e_lru_ret, hl_lru_hdl);
lru_print (hl_lru_hdl);
}
break;
}
case 2:
{
(void) pal_memset(&x_node_data, 0x00, sizeof(x_node_data));
x_node_data.x_hm_node.e_hm_key_type = eHM_KEY_TYPE_STRING;
x_node_data.x_hm_node.u_hm_key.puc_str_key = uca_str_buf;
e_lru_ret = lru_has (hl_lru_hdl, &x_node_data);
if (eLRU_RET_NODE_FOUND == e_lru_ret)
{
LRU_TEST_LOG("Key \"%s\" Found: %p", uca_str_buf, x_node_data.x_hm_node.p_data);
}
else
{
LRU_TEST_LOG("Key \"%s\" Not Found: %d", uca_str_buf, e_lru_ret);
}
break;
}
case 3:
{
(void) pal_memset(&x_node_data, 0x00, sizeof(x_node_data));
x_node_data.x_hm_node.e_hm_key_type = eHM_KEY_TYPE_STRING;
x_node_data.x_hm_node.u_hm_key.puc_str_key = uca_str_buf;
e_lru_ret = lru_delete (hl_lru_hdl, &x_node_data);
if (eLRU_RET_SUCCESS == e_lru_ret)
{
LRU_TEST_LOG("Key \"%s\" Deleted", uca_str_buf);
}
else
{
LRU_TEST_LOG("Key \"%s\" Not Found: %d", uca_str_buf, e_lru_ret);
}
lru_print (hl_lru_hdl);
break;
}
case 4:
{
e_lru_ret = lru_delete_all (hl_lru_hdl);
lru_print (hl_lru_hdl);
break;
}
case 5:
{
b_exit = true;
break;
}
}
if (true == b_exit)
{
break;
}
}
CLEAN_RETURN:
if (NULL != hl_lru_hdl) {
lru_deinit(hl_lru_hdl);
}
if (true == b_pal_init)
{
e_pal_ret = pal_env_deinit();
if (ePAL_RET_SUCCESS != e_pal_ret)
{
LRU_TEST_LOG("pal_env_deinit failed: %d", e_pal_ret);
}
else
{
LRU_TEST_LOG("pal_env_deinit success");
}
}
return i_ret_val;
}
