int main(){
struct cache_manager *lru_manager;
int i;
lru_init(&lru_manager,"LRU", 500, 500, 1, 0);
for(i =0;i < 1000000;i++){
struct lru_node *ln = NULL;
unsigned int blkno = RND(10000);
ln = CACHE_SEARCH(lru_manager, blkno);
if(!ln){
ln = CACHE_REPLACE(lru_manager, 0, FCL_REPLACE_ANY);
ln = CACHE_ALLOC(lru_manager, ln, blkno);
CACHE_INSERT(lru_manager, ln);
}else{
ln = CACHE_REMOVE(lru_manager, ln);
CACHE_INSERT(lru_manager, ln);
}
}
CACHE_PRINT(lru_manager, stdout);
CACHE_CLOSE(lru_manager);
return 0;
}
static int init_resolver(struct engine *engine)
{
/* Open resolution context */
engine->resolver.trust_anchors = map_make();
engine->resolver.negative_anchors = map_make();
engine->resolver.pool = engine->pool;
engine->resolver.modules = &engine->modules;
/* Create OPT RR */
engine->resolver.opt_rr = mm_alloc(engine->pool, sizeof(knot_rrset_t));
if (!engine->resolver.opt_rr) {
return kr_error(ENOMEM);
}
knot_edns_init(engine->resolver.opt_rr, KR_EDNS_PAYLOAD, 0, KR_EDNS_VERSION, engine->pool);
/* Set default root hints */
kr_zonecut_init(&engine->resolver.root_hints, (const uint8_t *)"", engine->pool);
kr_zonecut_set_sbelt(&engine->resolver, &engine->resolver.root_hints);
/* Open NS rtt + reputation cache */
engine->resolver.cache_rtt = mm_alloc(engine->pool, lru_size(kr_nsrep_lru_t, LRU_RTT_SIZE));
if (engine->resolver.cache_rtt) {
lru_init(engine->resolver.cache_rtt, LRU_RTT_SIZE);
}
engine->resolver.cache_rep = mm_alloc(engine->pool, lru_size(kr_nsrep_lru_t, LRU_REP_SIZE));
if (engine->resolver.cache_rep) {
lru_init(engine->resolver.cache_rep, LRU_REP_SIZE);
}
/* Load basic modules */
engine_register(engine, "iterate", NULL, NULL);
engine_register(engine, "validate", NULL, NULL);
engine_register(engine, "rrcache", NULL, NULL);
engine_register(engine, "pktcache", NULL, NULL);
/* Initialize storage backends */
struct storage_api lmdb = {
"lmdb://", knot_db_lmdb_api, knot_db_lmdb_mkopts
};
return array_push(engine->storage_registry, lmdb);
}
/***************************************************************************
*
* block-cache related functions
*
***************************************************************************
*/
int
bc_init(void) {
if (unlikely(blk_cache_init))
return 1;
if (unlikely(!enable_blk_cache))
return 0;
if (!(blk_cache = (block_cache_t*)MYMALLOC(sizeof(block_cache_t))))
return 0;
blk_cache->blks = rbt_create();
if (!blk_cache->blks) {
free(blk_cache);
return 0;
}
lru_init();
blk_cache_init = 1;
return 1;
}
int main(int argc, char **argv) {
config_init();
int c;
while (-1 != (c = getopt(argc, argv, "n:m:k:d:p:h"))) {
switch(c) {
case 'n':
config.num = atoi(optarg);
break;
case 'm':
config.maxbytes = ((size_t)atoi(optarg)) * 1024 * 1024;
break;
case 'k':
config.keysize = atoi(optarg);
break;
case 'd':
config.datasize = atoi(optarg);
break;
case 'p':
config.hashpower = atoi(optarg);
break;
case 'h':
usage();
return EXIT_SUCCESS;
default:
usage();
return EXIT_FAILURE;
}
}
generate_key_init();
print_env();
lru *l = lru_init(config.maxbytes, config.hashpower);
char *bvalue = malloc(config.datasize);
memset(bvalue, 'x', config.datasize);
char *key = malloc(config.keysize);
memset(key, 0, config.keysize);
int gnum = config.keysize - num_;
generate_key_reset();
bench_start("SET");
int i;
for (i = 0; i < config.num; i++) {
snprintf(key, config.keysize, fmt_, gnum, generate_key(gnum), i);
int r = item_set(l, key, config.keysize, bvalue, config.datasize);
assert(r == 0);
process_report();
}
bench_stop();
print_stat(l);
char *buf = malloc(config.datasize);
size_t sz;
generate_key_reset();
bench_start("GET");
for (i = 0; i < config.num; i++) {
snprintf(key, config.keysize, fmt_, gnum, generate_key(gnum), i);
int r = item_get(l, key, config.keysize, buf, config.datasize, &sz);
if (!r) {
assert((int)sz == config.datasize);
assert(memcmp(bvalue, buf, config.datasize) == 0);
}
memset(buf, 0, config.datasize);
process_report();
}
bench_stop();
print_stat(l);
generate_key_reset();
bench_start("DELETE");
for (i = 0; i < config.num; i++) {
snprintf(key, config.keysize, fmt_, gnum, generate_key(gnum), i);
item_delete(l, key, config.keysize);
process_report();
}
bench_stop();
print_stat(l);
free(buf);
free(bvalue);
free(key);
free(fmt_);
free(key_);
lru_free(l);
/*
printf("print any key to exit...\n");
getchar();
*/
return EXIT_SUCCESS;
}
/****************************** 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;
}
int main(int argc, char **argv) {
lru_init(10);
lru_touch("/some_item");
return fuse_main(argc, argv, &filesystem_operations, NULL);
}
