void fvt_kv_utils_REP_LOOP(ARK *ark,
void* (*db_create)(uint32_t, uint32_t, uint32_t),
uint32_t (*db_regen) (kv_t*, uint32_t, uint32_t),
uint32_t klen,
uint32_t vlen,
uint32_t len,
uint32_t secs)
{
uint32_t i = 0;
uint32_t start = 0;
uint32_t cur = 0;
int32_t LEN = (int32_t)len;
kv_t *db = NULL;
uint32_t regen_vlen = vlen;
ASSERT_TRUE(NULL != ark);
ASSERT_TRUE(NULL != db_create);
ASSERT_TRUE(NULL != db_regen);
db = (kv_t*)db_create(LEN, klen, vlen);
ASSERT_TRUE(db != NULL);
start = time(0);
do
{
/* don't regen on first iteration */
if (i > 0)
{
/* regenerate values to each key */
if (i%2) regen_vlen = vlen+1;
else regen_vlen = vlen;
ASSERT_TRUE(0 == db_regen(db, LEN, regen_vlen));
}
/* load/replace all key/value pairs from the db into the ark */
fvt_kv_utils_load(ark, db, LEN);
/* query all key/value pairs from the db */
fvt_kv_utils_query(ark, db, regen_vlen, LEN);
cur = time(0);
++i;
}
while (cur-start < secs);
/* delete all key/value pairs from the db */
fvt_kv_utils_del(ark, db, LEN);
kv_db_destroy(db, LEN);
}
void fvt_kv_utils_SGD_LOOP(ARK *ark,
void* (*db_create)(uint32_t, uint32_t, uint32_t),
uint32_t klen,
uint32_t vlen,
uint32_t len,
uint32_t secs)
{
uint32_t start = 0;
uint32_t cur = 0;
int32_t LEN = (int32_t)len;
kv_t *db = NULL;
ASSERT_TRUE(NULL != ark);
ASSERT_TRUE(NULL != db_create);
start = time(0);
do
{
db = (kv_t*)db_create(LEN, klen, vlen);
ASSERT_TRUE(db != NULL);
/* load all key/value pairs from the db into the ark */
fvt_kv_utils_load(ark, db, LEN);
/* query all key/value pairs from the db */
fvt_kv_utils_query(ark, db, vlen, LEN);
/* delete all key/value pairs from the db */
fvt_kv_utils_del(ark, db, LEN);
/* query all key/value pairs from the db */
fvt_kv_utils_query_empty(ark, db, vlen, LEN);
kv_db_destroy(db, LEN);
cur = time(0);
}
while (cur-start < secs);
}
/**
*******************************************************************************
* \brief
******************************************************************************/
void kv_async_job_perf(uint32_t jobs, uint32_t klen, uint32_t vlen,uint32_t len)
{
long int wr_us = 0;
long int rd_us = 0;
long int mil = 1000000;
float wr_s = 0;
float rd_s = 0;
float wr_mb = 0;
float rd_mb = 0;
uint64_t mb64_1 = (uint64_t)KV_1M;
uint64_t wr_bytes = 0;
uint64_t rd_bytes = 0;
uint64_t ops = 0;
uint64_t post_ops = 0;
uint64_t ios = 0;
uint64_t post_ios = 0;
float wr_ops = 0;
float wr_ios = 0;
float rd_ops = 0;
float rd_ios = 0;
uint32_t secs = 5;
uint32_t job = 0;
struct timeval stop, start;
kv_async_init_ctxt(0, secs);
for (job=0; job<jobs; job++)
{
kv_async_init_job(KV_ASYNC_CB_SGD|KV_ASYNC_CB_WRITE_PERF,
ASYNC_SINGLE_CONTEXT,
job, klen+job, vlen, len);
}
pCTs->flags |= KV_ASYNC_CT_PERF;
/* do writes */
(void)ark_stats(kv_async_get_ark(ASYNC_SINGLE_CONTEXT), &ops, &ios);
KV_TRC(pFT, "PERF wr: ops:%"PRIu64" ios:%"PRIu64"", ops, ios);
gettimeofday(&start, NULL);
kv_async_run_jobs(); /* run write jobs */
KV_TRC(pFT, "writes done");
gettimeofday(&stop, NULL);
wr_us += (stop.tv_sec*mil + stop.tv_usec) -
(start.tv_sec*mil + start.tv_usec);
(void)ark_stats(kv_async_get_ark(ASYNC_SINGLE_CONTEXT),&post_ops,&post_ios);
KV_TRC(pFT, "PERF wr: ops:%"PRIu64" ios:%"PRIu64"", post_ops, post_ios);
wr_ops += post_ops - ops;
wr_ios += post_ios - ios;
/* calc bytes written */
for (job=0; job<jobs; job++)
{
wr_bytes += (klen+vlen+job)*len*(pCTs->pCBs+job)->perf_loops;
}
/* do reads */
for (job=0; job<jobs; job++)
{
if ((pCTs->pCBs+job)->perf_loops)
{
(pCTs->pCBs+job)->perf_loops = 0;
(pCTs->pCBs+job)->flags = KV_ASYNC_CB_GET |
KV_ASYNC_CB_QUEUED |
KV_ASYNC_CB_READ_PERF;
}
}
pCTs->flags |= KV_ASYNC_CT_RUNNING;
(void)ark_stats(kv_async_get_ark(0), &ops, &ios);
KV_TRC(pFT, "PERF rd: ops:%"PRIu64" ios:%"PRIu64"", ops, ios);
gettimeofday(&start, NULL);
kv_async_run_jobs(); /* run read jobs */
gettimeofday(&stop, NULL);
KV_TRC(pFT, "reads done");
rd_us += (stop.tv_sec*mil + stop.tv_usec) -
(start.tv_sec*mil + start.tv_usec);
(void)ark_stats(kv_async_get_ark(0), &post_ops, &post_ios);
KV_TRC(pFT, "PERF rd: ops:%"PRIu64" ios:%"PRIu64"", post_ops, post_ios);
rd_ops += post_ops - ops;
rd_ios += post_ios - ios;
ASSERT_EQ(0, ark_delete(pCTs->ark));
/* calc bytes read */
for (job=0; job<jobs; job++)
{
rd_bytes += vlen*len*(pCTs->pCBs+job)->perf_loops;
kv_db_destroy((pCTs->pCBs+job)->db, (pCTs->pCBs+job)->len);
if ((pCTs->pCBs+job)->gvalue)
free((pCTs->pCBs+job)->gvalue);
}
/* calc and print results */
wr_s = (float)((float)wr_us/(float)mil);
wr_mb = (float)((double)wr_bytes / (double)mb64_1);
rd_s = (float)((float)rd_us/(float)mil);
rd_mb = (float)((double)rd_bytes / (double)mb64_1);
printf("ASYNC %dx%dx%d writes: %.3d jobs %2.3f mb in %.1f secs at ",
klen, vlen, len, jobs, wr_mb, wr_s);
printf("%2.3f mbps, %6.0f op/s, %.0f io/s\n",
wr_mb/wr_s,
wr_ops/wr_s,
wr_ios/wr_s);
printf("ASYNC %dx%dx%d reads: %.3d jobs %2.3f mb in %.1f secs at ",
klen, vlen, len, jobs, rd_mb, rd_s);
printf("%2.3f mbps, %6.0f op/s, %.0f io/s\n",
rd_mb/rd_s,
rd_ops/rd_s,
rd_ios/rd_s);
}
/**
*******************************************************************************
* \brief
* callback function for set/get/exists/del
******************************************************************************/
static void kv_async_cb(int errcode, uint64_t dt, int64_t res)
{
async_CB_t *pCB = (async_CB_t*)dt;
kv_t *p_kv = NULL;
uint64_t tag = (uint64_t)pCB;
if (pCB == NULL)
{
KV_TRC_FFDC(pFT, "FFDC: pCB NULL");
return;
}
if (pCB->b_mark != B_MARK)
{
KV_TRC_FFDC(pFT, "FFDC: B_MARK FAILURE %p: %"PRIx64"", pCB, pCB->b_mark);
return;
}
if (pCB->e_mark != E_MARK)
{
KV_TRC_FFDC(pFT, "FFDC: E_MARK FAILURE %p: %"PRIx64"", pCB, pCB->e_mark);
return;
}
if (EBUSY == errcode) {kv_async_q_retry(pCB); goto done;}
if (IS_GTEST)
{
EXPECT_EQ(0, errcode);
EXPECT_EQ(tag, pCB->tag);
}
p_kv = pCB->db + pCB->len_i;
++pCB->len_i;
if (pCB->flags & KV_ASYNC_CB_SET)
{
KV_TRC_IO(pFT, "KV_ASYNC_CB_SET, %p %d %d", pCB, pCB->len_i, pCB->len);
if (0 != errcode) printf("ark_set failed, errcode=%d\n", errcode);
if (tag != pCB->tag) printf("ark_set bad tag\n");
if (res != p_kv->vlen) printf("ark_set bad vlen\n");
if (IS_GTEST) { EXPECT_EQ(res, p_kv->vlen);}
/* end of db len sequence, move to next step */
if (pCB->len_i == pCB->len)
{
if (pCB->flags & KV_ASYNC_CB_WRITE_PERF)
{
pCB->len_i = 0;
kv_async_perf_done(pCB);
goto done;
}
pCB->len_i = 0;
pCB->flags &= ~KV_ASYNC_CB_SET;
pCB->flags |= KV_ASYNC_CB_GET;
kv_async_GET_KEY(pCB);
goto done;
}
kv_async_SET_KEY(pCB);
goto done;
}
else if (pCB->flags & KV_ASYNC_CB_GET)
{
uint32_t miscompare = memcmp(p_kv->value, pCB->gvalue, p_kv->vlen);
KV_TRC_IO(pFT, "KV_ASYNC_CB_GET, %p %d %d", pCB, pCB->len_i, pCB->len);
if (0 != errcode) printf("ark_get failed, errcode=%d\n", errcode);
if (tag != pCB->tag) printf("ark_get bad tag\n");
if (res != p_kv->vlen) printf("ark_get bad vlen\n");
if (IS_GTEST) { EXPECT_EQ(0, miscompare);}
/* end of db len sequence, move to next step */
if (pCB->len_i == pCB->len)
{
if (pCB->flags & KV_ASYNC_CB_READ_PERF)
{
pCB->len_i = 0;
kv_async_perf_done(pCB);
goto done;
}
pCB->len_i = 0;
pCB->flags &= ~KV_ASYNC_CB_GET;
pCB->flags |= KV_ASYNC_CB_EXISTS;
kv_async_EXISTS_KEY(pCB);
goto done;
}
kv_async_GET_KEY(pCB);
goto done;
}
else if (pCB->flags & KV_ASYNC_CB_EXISTS)
{
KV_TRC_IO(pFT, "KV_ASYNC_CB_EXISTS, %p %d %d", pCB, pCB->len_i, pCB->len);
if (0 != errcode) printf("ark_exists failed,errcode=%d\n",errcode);
if (tag != pCB->tag) printf("ark_exists bad tag\n");
if (res != p_kv->vlen) printf("ark_exists bad vlen\n");
if (IS_GTEST) { EXPECT_EQ(res, p_kv->vlen);}
/* if end of db len sequence, move to next step */
if (pCB->len_i == pCB->len)
{
pCB->len_i = 0;
pCB->flags &= ~KV_ASYNC_CB_EXISTS;
if (pCB->flags & KV_ASYNC_CB_SGD)
{
pCB->flags |= KV_ASYNC_CB_DEL;
kv_async_DEL_KEY(pCB);
goto done;
}
else if (pCB->flags & KV_ASYNC_CB_REPLACE)
{
/* make sure we don't shutdown before we have replaced once */
if (pCB->replace &&
pCB->flags & KV_ASYNC_CB_SHUTDOWN)
{
pCB->flags |= KV_ASYNC_CB_DEL;
kv_async_DEL_KEY(pCB);
goto done;
}
pCB->replace = TRUE;
if (0 != pCB->regen(pCB->db, pCB->len, pCB->regen_len))
{
printf("regen failure, fatal\n");
KV_TRC_FFDC(pFT, "FFDC: regen failure");
memset(pCB, 0, sizeof(async_CB_t));
goto done;
}
pCB->flags |= KV_ASYNC_CB_SET;
kv_async_SET_KEY(pCB);
goto done;
}
else
{
/* should not be here */
EXPECT_TRUE(0);
}
}
kv_async_EXISTS_KEY(pCB);
goto done;
}
else if (pCB->flags & KV_ASYNC_CB_DEL)
{
KV_TRC_IO(pFT, "KV_ASYNC_CB_DEL, %p i:%d len:%d", pCB, pCB->len_i,pCB->len);
if (0 != errcode) printf("ark_del failed, errcode=%d\n",errcode);
if (tag != pCB->tag) printf("ark_del bad tag\n");
if (res != p_kv->vlen) printf("ark_del bad vlen\n");
if (IS_GTEST) { EXPECT_EQ(res, p_kv->vlen);}
/* end of db len sequence, move to next step */
if (pCB->len_i == pCB->len)
{
if (pCB->flags & KV_ASYNC_CB_SHUTDOWN)
{
if (!(pCB->flags & KV_ASYNC_CB_MULTI_CTXT_IO))
{
kv_db_destroy(pCB->db, pCB->len);
}
if (pCB->gvalue) free(pCB->gvalue);
memset(pCB, 0, sizeof(async_CB_t));
KV_TRC_IO(pFT, "LOOP_DONE: %p", pCB);
goto done;
}
KV_TRC_IO(pFT, "NEXT_LOOP, %p", pCB);
pCB->flags &= ~KV_ASYNC_CB_DEL;
pCB->flags |= KV_ASYNC_CB_SET;
pCB->len_i = 0;
kv_async_SET_KEY(pCB);
goto done;
}
kv_async_DEL_KEY(pCB);
goto done;
}
else
{
/* should not be here */
EXPECT_TRUE(0);
}
done:
return;
}
/**
*******************************************************************************
* \brief
******************************************************************************/
void kv_async_run_jobs(void)
{
async_CB_t *pCB = NULL;
uint32_t ctxt_running = 0;
uint32_t jobs_running = 0;
uint32_t i = 0;
uint32_t next = 0;
uint32_t elapse = 0;
uint32_t inject = 0;
uint32_t secs = 0;
uint32_t log_interval = 600;
uint64_t ops = 0;
uint64_t ios = 0;
uint32_t tops = 0;
uint32_t tios = 0;
uint32_t perf = 0;
KV_TRC(pFT, "ASYNC START: 0 minutes");
if (!(pCTs->pCBs->flags & KV_ASYNC_CB_RUNNING)) start = time(0);
next = log_interval;
do
{
ctxt_running = FALSE;
if (elapse > next)
{
KV_TRC(pFT, "ASYNC RUNNING: %d elapsed minutes", elapse/60);
next += log_interval;
}
for (i=0; i<KV_ASYNC_MAX_CONTEXTS; i++)
{
if (! (pCTs[i].flags & KV_ASYNC_CT_RUNNING)) continue;
jobs_running = kv_async_dispatch_jobs(i);
if (!jobs_running)
{
pCTs[i].flags &= ~KV_ASYNC_CT_RUNNING;
pCTs[i].flags |= KV_ASYNC_CT_DONE;
KV_TRC(pFT, "ASYNC DONE ctxt %d %x", i, pCTs[i].flags);
continue;
}
else
{
ctxt_running = TRUE;
}
elapse = time(0) - start;
if (elapse >= inject &&
pCTs[i].flags & KV_ASYNC_CT_ERROR_INJECT)
{
KV_TRC_FFDC(pFT, "FFDC: INJECT ERRORS");
FVT_KV_INJECT_READ_ERROR;
FVT_KV_INJECT_WRITE_ERROR;
FVT_KV_INJECT_ALLOC_ERROR;
++inject;
}
if (elapse >= pCTs[i].secs)
{
for (pCB=pCTs[i].pCBs;pCB<pCTs[i].pCBs+KV_ASYNC_JOB_Q;pCB++)
{
if ((pCB->flags & KV_ASYNC_CB_RUNNING ||
pCB->flags & KV_ASYNC_CB_QUEUED)
&&
(!(pCB->flags & KV_ASYNC_CB_SHUTDOWN)) )
{
pCB->flags |= KV_ASYNC_CB_SHUTDOWN;
KV_TRC_IO(pFT, "SHUTDOWN pCB %p (%d >= %d)", pCB, elapse, pCTs[i].secs);
}
}
}
usleep(100);
}
}
while (ctxt_running);
stop = time(0);
secs = stop - start;
KV_TRC(pFT, "ASYNC RUNNING DONE: %d minutes", elapse/60);
/* log cleanup, since the first ark_delete closes the log file */
for (i=0; i<KV_ASYNC_MAX_CONTEXTS; i++)
{
if (pCTs[i].flags & KV_ASYNC_CT_DONE)
KV_TRC(pFT, "ASYNC CLEANUP: ctxt:%d ark:%p", i, pCTs[i].ark);
}
/* check for MULTI_CTXT_IO, destroy common kv dbs */
for (pCB=pCTs->pCBs;pCB<pCTs->pCBs+KV_ASYNC_JOB_Q;pCB++)
{
if (pCB->flags & KV_ASYNC_CB_MULTI_CTXT_IO)
{
kv_db_destroy(pCB->db, pCB->len);
}
}
for (i=0; i<KV_ASYNC_MAX_CONTEXTS; i++)
{
/* if this context didn't run any I/O */
if (! (pCTs[i].flags & KV_ASYNC_CT_DONE)) continue;
pCTs[i].flags &= ~KV_ASYNC_CT_DONE;
/* if perf then don't delete the ark here */
if (pCTs[i].flags & KV_ASYNC_CT_PERF)
{
perf = TRUE;
continue;
}
(void)ark_stats(pCTs[i].ark, &ops, &ios);
tops += (uint32_t)ops;
tios += (uint32_t)ios;
KV_TRC(pFT, "PERF ark%p ops:%"PRIu64" ios:%"PRIu64"", pCTs[i].ark, ops, ios);
EXPECT_EQ(0, ark_delete(pCTs[i].ark));
}
if (!perf)
{
tops = tops / secs;
tios = tios / secs;
printf("op/s:%d io/s:%d secs:%d\n", tops, tios, secs);
KV_TRC(pFT, "PERF op/s:%d io/s:%d secs:%d",
tops, tios, secs);
}
}
void fvt_kv_utils_perf(ARK *ark, uint32_t vlen, uint32_t mb, uint32_t LEN)
{
kv_t *db = NULL;
uint64_t mb64_1 = (uint64_t)KV_1M;
uint64_t bytes = mb64_1*mb;
uint32_t i = 0;
uint32_t klen = 16;
uint64_t lchunk = LEN*vlen;
uint32_t loops = mb;
long int wr_us = 0;
long int rd_us = 0;
long int mil = 1000000;
float wr_s = 0;
float rd_s = 0;
float wr_mb = 0;
uint64_t ops = 0;
uint64_t post_ops = 0;
uint64_t io = 0;
uint64_t post_io = 0;
float wr_ops = 0;
float wr_ios = 0;
float rd_ops = 0;
float rd_ios = 0;
struct timeval stop, start;
ASSERT_TRUE(NULL != ark);
loops = (uint32_t)(bytes / lchunk);
db = (kv_t*)kv_db_create_fixed(LEN, klen, vlen);
ASSERT_TRUE(db != NULL);
printf("SYNC %dx%dx%d\n", klen, vlen, LEN);
for (i=0; i<loops; i++)
{
/* write/load all key/value pairs from the db into the ark */
(void)ark_stats(ark, &ops, &io);
gettimeofday(&start, NULL);
fvt_kv_utils_load(ark, db, LEN);
gettimeofday(&stop, NULL);
wr_us += (stop.tv_sec*mil + stop.tv_usec) -
(start.tv_sec*mil + start.tv_usec);
(void)ark_stats(ark, &post_ops, &post_io);
wr_ops += post_ops - ops;
wr_ios += post_io - io;
/* read/query all key/value pairs from the db */
(void)ark_stats(ark, &ops, &io);
gettimeofday(&start, NULL);
fvt_kv_utils_read(ark, db, vlen, LEN);
gettimeofday(&stop, NULL);
rd_us += (stop.tv_sec*mil + stop.tv_usec) -
(start.tv_sec*mil + start.tv_usec);
(void)ark_stats(ark, &post_ops, &post_io);
rd_ops += post_ops - ops;
rd_ios += post_io - io;
/* delete all key/value pairs from the db */
fvt_kv_utils_del(ark, db, LEN);
}
wr_s = (float)((float)wr_us/(float)mil);
rd_s = (float)((float)rd_us/(float)mil);
wr_mb = (float)((double)(bytes+(uint64_t)(klen*LEN*loops)) / (double)mb64_1);
printf(" writes: %d mb in %.1f secs at %.3f mbps, %.0f op/s, %.0f io/s\n",
mb,
wr_s,
wr_mb/wr_s,
wr_ops/wr_s,
wr_ios/wr_s);
printf(" reads: %d mb in %.1f secs at %.3f mbps, %.0f op/s, %.0f io/s\n",
mb,
rd_s,
(float)mb/rd_s,
rd_ops/rd_s,
rd_ios/rd_s);
kv_db_destroy(db, LEN);
}
/**
*******************************************************************************
* \brief
******************************************************************************/
void Sync_pth::run_multi_ctxt_wr(uint32_t num_ctxt,
uint32_t num_pth,
uint32_t npool,
uint32_t vlen,
uint32_t LEN,
uint32_t secs)
{
uint32_t i = 0;
uint32_t ctxt_i = 0;
uint32_t pth_i = 0;
uint32_t klen = 16;
uint32_t tot_pth = num_ctxt * num_pth;
set_get_args_t pth_args[tot_pth];
ARK *ark[num_ctxt];
kv_t *db[num_pth];
struct timeval stop, start;
uint64_t ops = 0;
uint64_t ios = 0;
uint32_t t_ops = 0;
uint32_t t_ios = 0;
if (num_pth > MAX_PTH_PER_CONTEXT)
{
printf("cannot exceed %d pthreads for sync ops\n", MAX_PTH_PER_CONTEXT);
return;
}
memset(pth_args, 0, sizeof(set_get_args_t) * tot_pth);
/* alloc one set of db's, to be used for each context */
for (i=0; i<num_pth; i++)
{
db[i] = (kv_t*)kv_db_create_fixed(LEN, klen+i, vlen+i);
}
/* alloc one ark for each context */
for (ctxt_i=0; ctxt_i<num_ctxt; ctxt_i++)
{
ASSERT_EQ(0, ark_create_verbose(getenv("FVT_DEV"), &ark[ctxt_i],
1048576,
4096,
1048576,
npool,
256,
8*1024,
ARK_KV_VIRTUAL_LUN));
ASSERT_TRUE(NULL != ark[ctxt_i]);
}
/* start timer */
gettimeofday(&start, NULL);
/* init each pth per context and run the pth */
ctxt_i = 0;
i = 0;
while (i < tot_pth)
{
pth_args[i].ark = ark[ctxt_i];
pth_args[i].db = db[pth_i];
pth_args[i].vlen = vlen+pth_i;
pth_args[i].LEN = LEN;
pth_args[i].secs = secs;
run_write_loop(pth_args+i);
++pth_i;
++i;
if ((i%num_pth) == 0)
{
/* reset for next context */
++ctxt_i;
pth_i = 0;
}
}
printf("SYNC %dx%dx%d ctxt:%d pth:%d npool:%d ",
klen, vlen, LEN, num_ctxt, num_pth, npool); fflush(stdout);
for (i=0; i<tot_pth; i++)
{
wait(pth_args+i);
}
/* stop timer */
gettimeofday(&stop, NULL);
secs = stop.tv_sec - start.tv_sec;
t_ops = 0;
t_ios = 0;
for (i=0; i<num_ctxt; i++)
{
(void)ark_stats(ark[i], &ops, &ios);
t_ops += (uint32_t)ops;
t_ios += (uint32_t)ios;
EXPECT_EQ(0, ark_delete(ark[i]));
}
for (i=0; i<num_pth; i++)
{
kv_db_destroy(db[i], LEN);
}
t_ops = t_ops / secs;
t_ios = t_ios / secs;
printf("op/s:%d io/s:%d secs:%d\n", t_ops, t_ios, secs);
}
/**
*******************************************************************************
* \brief
******************************************************************************/
TEST(FVT_KV_GOOD_PATH, PERSIST_FIXED_512x128x50000)
{
ARK *ark = NULL;
kv_t *fdb = NULL;
kv_t *mdb = NULL;
uint32_t klen = 512;
uint32_t vlen = 128;
uint32_t LEN = 50000;
uint32_t i = 0;
int64_t res = 0;
char *dev = getenv("FVT_DEV_PERSIST");
uint8_t gvalue[vlen];
struct stat sbuf;
if (NULL == dev || stat(dev,&sbuf) != 0)
{
TESTCASE_SKIP("FVT_DEV_PERSIST==NULL or file not found");
return;
}
printf("create k/v databases\n");
fflush(stdout);
fdb = (kv_t*)kv_db_create_fixed(LEN, klen, vlen);
ASSERT_TRUE(fdb != NULL);
mdb = (kv_t*)kv_db_create_mixed(LEN, klen-1, vlen);
ASSERT_TRUE(mdb != NULL);
printf("create ark\n");
fflush(stdout);
ARK_CREATE_NEW_PERSIST;
printf("run 5 sec mixed REP_LOOP\n");
fflush(stdout);
fvt_kv_utils_REP_LOOP(ark,
kv_db_create_mixed,
kv_db_mixed_regen_values,
klen+1,
vlen,
1000,
5);
printf("load ark with fixed db\n");
fflush(stdout);
fvt_kv_utils_load (ark, fdb, LEN);
printf("query fixed db\n");
fflush(stdout);
fvt_kv_utils_query(ark, fdb, vlen, LEN);
printf("persist ark\n");
fflush(stdout);
ARK_DELETE;
printf("re-open ark and read persisted data\n");
fflush(stdout);
ARK_CREATE_PERSIST;
printf("query fixed db\n");
fflush(stdout);
fvt_kv_utils_query(ark, fdb, vlen, LEN);
printf("load ark with the mixed db\n");
fflush(stdout);
fvt_kv_utils_load (ark, mdb, LEN);
printf("query mixed db\n");
fflush(stdout);
fvt_kv_utils_query(ark, mdb, vlen, LEN);
printf("query fixed db\n");
fflush(stdout);
fvt_kv_utils_query(ark, fdb, vlen, LEN);
printf("delete fixed db from ark\n");
fflush(stdout);
fvt_kv_utils_del(ark, fdb, LEN);
printf("re-load ark with the fixed db\n");
fflush(stdout);
fvt_kv_utils_load (ark, fdb, LEN);
printf("query db\n");
fflush(stdout);
fvt_kv_utils_query(ark, fdb, vlen, LEN);
printf("delete mixed db from ark\n");
fflush(stdout);
fvt_kv_utils_del(ark, mdb, LEN);
printf("persist ark\n");
fflush(stdout);
ARK_DELETE;
printf("re-open ark without LOAD\n");
fflush(stdout);
ARK_CREATE_NEW_PERSIST;
printf("verify ark is empty\n");
fflush(stdout);
for (i=0; i<LEN; i++)
{
ASSERT_EQ(ENOENT, ark_get(ark,
fdb[i].klen,
fdb[i].key,
fdb[i].vlen,
gvalue,
0,
&res));
}
kv_db_destroy(fdb, LEN);
ARK_DELETE;
}
/**
*******************************************************************************
* \brief
******************************************************************************/
TEST(FVT_KV_GOOD_PATH, PERSIST)
{
ARK *ark = NULL;
kv_t *fdb = NULL;
kv_t *mdb = NULL;
kv_t *bdb = NULL;
uint32_t klen = 512;
uint32_t vlen = 256;
uint32_t LEN = 10000;
uint32_t BLEN = 1000;
uint32_t i = 0;
int64_t res = 0;
char *dev = getenv("FVT_DEV_PERSIST");
uint8_t gvalue[vlen];
struct stat sbuf;
if (NULL == dev || stat(dev,&sbuf) != 0)
{
TESTCASE_SKIP("FVT_DEV_PERSIST==NULL or file not found");
return;
}
printf("create k/v databases\n");
fflush(stdout);
fdb = (kv_t*)kv_db_create_fixed(LEN, klen, vlen);
ASSERT_TRUE(fdb != NULL);
bdb = (kv_t*)kv_db_create_fixed(BLEN, klen+1, KV_1M);
ASSERT_TRUE(bdb != NULL);
mdb = (kv_t*)kv_db_create_mixed(LEN, klen-1, vlen);
ASSERT_TRUE(mdb != NULL);
printf("create new ark\n");
fflush(stdout);
ARK_CREATE_NEW_PERSIST;
printf("delete ark\n");
fflush(stdout);
ARK_DELETE;
printf("re-open empty ark\n");
fflush(stdout);
ARK_CREATE_PERSIST;
printf("load ark with fixed db\n");
fflush(stdout);
fvt_kv_utils_load (ark, fdb, LEN);
printf("query fixed db\n");
fflush(stdout);
fvt_kv_utils_query(ark, fdb, vlen, LEN);
printf("delete ark\n");
fflush(stdout);
ARK_DELETE;
printf("re-open ark containing fixed db\n");
fflush(stdout);
ARK_CREATE_PERSIST;
printf("run SGD_LOOP on fixed db\n");
fflush(stdout);
fvt_kv_utils_SGD_LOOP(ark, kv_db_create_fixed, klen+10, vlen+10,1000,5);
printf("query fixed db\n");
fflush(stdout);
fvt_kv_utils_query(ark, fdb, vlen, LEN);
printf("delete ark\n");
fflush(stdout);
ARK_DELETE;
printf("re-open ark containing fixed db\n");
fflush(stdout);
ARK_CREATE_PERSIST;
printf("load ark with BIG db\n");
fflush(stdout);
fvt_kv_utils_load (ark, bdb, BLEN);
printf("query BIG db\n");
fflush(stdout);
fvt_kv_utils_query(ark, bdb, KV_1M, BLEN);
printf("query fixed db\n");
fflush(stdout);
fvt_kv_utils_query(ark, fdb, vlen, LEN);
printf("run REP_LOOP on fixed db\n");
fflush(stdout);
fvt_kv_utils_REP_LOOP(ark,
kv_db_create_fixed,
kv_db_fixed_regen_values,
klen+100,
vlen,
5000,
5);
printf("delete BIG db from ark\n");
fflush(stdout);
fvt_kv_utils_del(ark, bdb, BLEN);
printf("load ark with the mixed db\n");
fflush(stdout);
fvt_kv_utils_load(ark, mdb, LEN);
printf("query mixed db\n");
fflush(stdout);
fvt_kv_utils_query(ark, mdb, vlen, LEN);
printf("delete ark\n");
fflush(stdout);
ARK_DELETE;
printf("re-open ark with fixed and mixed db\n");
fflush(stdout);
ARK_CREATE_PERSIST;
printf("query fixed db\n");
fflush(stdout);
fvt_kv_utils_query(ark, fdb, vlen, LEN);
printf("delete fixed db from ark\n");
fflush(stdout);
fvt_kv_utils_del(ark, fdb, LEN);
printf("query mixed db\n");
fflush(stdout);
fvt_kv_utils_query(ark, mdb, vlen, LEN);
printf("delete mixed db from ark\n");
fflush(stdout);
fvt_kv_utils_del(ark, mdb, LEN);
printf("run REP_LOOP on mixed db\n");
fflush(stdout);
fvt_kv_utils_REP_LOOP(ark,
kv_db_create_mixed,
kv_db_mixed_regen_values,
klen+256,
vlen,
100,
5);
printf("load ark with the mixed db\n");
fflush(stdout);
fvt_kv_utils_load (ark, mdb, LEN);
printf("query mixed db\n");
fflush(stdout);
fvt_kv_utils_query(ark, mdb, vlen, LEN);
printf("delete ark\n");
fflush(stdout);
ARK_DELETE;
printf("open new ark\n");
fflush(stdout);
ARK_CREATE_NEW_PERSIST;
printf("verify empty\n");
fflush(stdout);
for (i=0; i<LEN; i++)
{
ASSERT_EQ(ENOENT, ark_get(ark,
mdb[i].klen,
mdb[i].key,
mdb[i].vlen,
gvalue,
0,
&res));
}
printf("delete ark\n");
fflush(stdout);
ARK_DELETE;
printf("re-open ark as readonly\n");
fflush(stdout);
ARK_CREATE_PERSIST_READONLY;
printf("load ark with the mixed db\n");
fflush(stdout);
fvt_kv_utils_load (ark, mdb, LEN);
printf("query mixed db\n");
fflush(stdout);
fvt_kv_utils_query(ark, mdb, vlen, LEN);
printf("run REP_LOOP on mixed db\n");
fflush(stdout);
fvt_kv_utils_REP_LOOP(ark,
kv_db_create_mixed,
kv_db_mixed_regen_values,
klen,
vlen,
LEN,
5);
printf("delete ark\n");
fflush(stdout);
ARK_DELETE;
printf("open new ark\n");
fflush(stdout);
ARK_CREATE_PERSIST;
printf("verify empty\n");
fflush(stdout);
for (i=0; i<LEN; i++)
{
ASSERT_EQ(ENOENT, ark_get(ark,
mdb[i].klen,
mdb[i].key,
mdb[i].vlen,
gvalue,
0,
&res));
}
printf("delete ark\n");
fflush(stdout);
ARK_DELETE;
kv_db_destroy(fdb, LEN);
kv_db_destroy(mdb, LEN);
kv_db_destroy(bdb, BLEN);
}