void test_bt_1(CuTest* tc) {
int val;
int i;
bt* tree;
tree = bt_new(sizeof(int), 4);
printf("Empty:\n");
bt_print(tree, print_int);
printf("\n");
{
int vals[] = { 10, 5, 100, 10, 50, 50, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 200,200,200,200,200,250,150 };
for (i=0; i<sizeof(vals)/sizeof(int); i++) {
val = vals[i];
printf("Insert %i:\n", val);
bt_insert(tree, &val, 0, compare_ints);
//bt_print(tree, print_int);
printf("\n");
}
}
printf("Values: ");
for (i=0; i<tree->N; i++) {
int val = *(int*)bt_access(tree, i);
printf("%i ", val);
// these tests depend on the values in the "vals" array above.
if (i < 11) {
CuAssertIntEquals(tc, 1, val);
} else if (i < 12) {
CuAssertIntEquals(tc, 5, val);
} else if (i < 14) {
CuAssertIntEquals(tc, 10, val);
} else if (i < 16) {
CuAssertIntEquals(tc, 50, val);
} else if (i < 17) {
CuAssertIntEquals(tc, 100, val);
} else if (i < 18) {
CuAssertIntEquals(tc, 150, val);
} else if (i < 23) {
CuAssertIntEquals(tc, 200, val);
} else {
CuAssertIntEquals(tc, 250, val);
}
}
printf("\n");
{
int vals[] = { 0, 1, 2, 9, 10, 11, 49, 50, 51, 99, 100, 101, 149, 150, 151, 199, 200, 201, 249, 250, 251 };
int doesit[]={ 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0 };
for (i=0; i<sizeof(vals)/sizeof(int); i++) {
int youthink;
val = vals[i];
youthink = bt_contains(tree, &val, compare_ints);
printf("Contains %i: %s\n", val, (youthink ? "yes" : "no"));
CuAssertIntEquals(tc, doesit[i], youthink);
}
}
bt_free(tree);
}
/*
* Make a new dataset
*/
int make_dataset(char *name)
{
Btree bt;
int retval;
/*
* Fill in parts of the structure. For the sizes, we
* give what we want. The only real restriction is that
* block_size - split must leave enough room to insert
* the largest possible record or key.
*/
strcpy(bt.fdata[NDX].filename, name);
strcat(bt.fdata[NDX].filename, ".ndx");
bt.fdata[NDX].modified = 0;
bt.fdata[NDX].bufferlist = NULL;
bt.fdata[NDX].sizes.block_size = 2048;
#if defined(TESTSIZES)
bt.fdata[NDX].sizes.split = 80;
bt.fdata[NDX].sizes.merge = 45;
#else
bt.fdata[NDX].sizes.split = 2000; /* room for one key */
bt.fdata[NDX].sizes.merge = 1024;
#endif
bt.fdata[NDX].sizes.levels = 4;
strcpy(bt.fdata[DAT].filename, name);
strcat(bt.fdata[DAT].filename, ".dat");
bt.fdata[DAT].modified = 0;
bt.fdata[DAT].bufferlist = NULL;
bt.fdata[DAT].sizes.block_size = 4096;
#if defined(TESTSIZES)
bt.fdata[DAT].sizes.split = 500;
bt.fdata[DAT].sizes.merge = 300;
#else
bt.fdata[DAT].sizes.split = 3950; /* room for a rec */
bt.fdata[DAT].sizes.merge = 2048;
#endif
bt.fdata[DAT].sizes.levels = 0; /* any value is OK */
bt.getkeysize = UserGetKeySize; /* user.c */
bt.getkeyNrecsize = UserGetKeyNRecSize;
bt.getrecsize = UserGetRecSize;
bt.key2keycmp = UserKey2KeyCmp;
bt.key2reccmp = UserKey2RecCmp;
bt.rec2keycpy = UserRec2KeyCpy;
bt.error_code = 0;
bt.duplicatesOK = 1;
retval = bt_new(&bt, MaxRec.key, &MaxRec);
if(retval == TREE_OK)
printf("Data files created.\n");
else
printf("Create failed: %s.\n",
ErrorText[bt.error_code]);
return retval;
}
void test_bt_many(CuTest* tc) {
int val;
int i;
bt* tree;
printf("Inserting many items...\n");
tree = bt_new(sizeof(int), 32);
for (i=0; i<100000; i++) {
val = rand() % 1000;
bt_insert(tree, &val, 0, compare_ints);
//bt_check(tree);
}
printf("Checking...\n");
CuAssertIntEquals(tc, 0, bt_check(tree));
printf("Done.\n");
bt_free(tree);
}
int hpquads(startree_t* starkd,
codefile_t* codes,
quadfile_t* quads,
int Nside,
double scale_min_arcmin,
double scale_max_arcmin,
int dimquads,
int passes,
int Nreuses,
int Nloosen,
int id,
anbool scanoccupied,
void* sort_data,
int (*sort_func)(const void*, const void*),
int sort_size,
char** args, int argc) {
hpquads_t myhpquads;
hpquads_t* me = &myhpquads;
int i;
int pass;
anbool circle = TRUE;
double radius2;
il* hptotry;
int Nhptotry = 0;
int nquads;
double hprad;
double quadscale;
int skhp, sknside;
qfits_header* qhdr;
qfits_header* chdr;
int N;
int dimcodes;
int quadsize;
int NHP;
memset(me, 0, sizeof(hpquads_t));
if (Nside > HP_MAX_INT_NSIDE) {
ERROR("Error: maximum healpix Nside = %i", HP_MAX_INT_NSIDE);
return -1;
}
if (Nreuses > 255) {
ERROR("Error, reuse (-r) must be less than 256");
return -1;
}
me->Nside = Nside;
me->dimquads = dimquads;
NHP = 12 * Nside * Nside;
dimcodes = dimquad2dimcode(dimquads);
quadsize = sizeof(unsigned int) * dimquads;
logmsg("Nside=%i. Nside^2=%i. Number of healpixes=%i. Healpix side length ~ %g arcmin.\n",
me->Nside, me->Nside*me->Nside, NHP, healpix_side_length_arcmin(me->Nside));
me->sort_data = sort_data;
me->sort_func = sort_func;
me->sort_size = sort_size;
tic();
me->starkd = starkd;
N = startree_N(me->starkd);
logmsg("Star tree contains %i objects.\n", N);
// get the "HEALPIX" header from the skdt...
skhp = qfits_header_getint(startree_header(me->starkd), "HEALPIX", -1);
if (skhp == -1) {
if (!qfits_header_getboolean(startree_header(me->starkd), "ALLSKY", FALSE)) {
logmsg("Warning: skdt does not contain \"HEALPIX\" header. Code and quad files will not contain this header either.\n");
}
}
// likewise "HPNSIDE"
sknside = qfits_header_getint(startree_header(me->starkd), "HPNSIDE", 1);
if (sknside && Nside % sknside) {
logerr("Error: Nside (-n) must be a multiple of the star kdtree healpixelisation: %i\n", sknside);
return -1;
}
if (!scanoccupied && (N*(skhp == -1 ? 1 : sknside*sknside*12) < NHP)) {
logmsg("\n\n");
logmsg("NOTE, your star kdtree is sparse (has only a fraction of the stars expected)\n");
logmsg(" so you probably will get much faster results by setting the \"-E\" command-line\n");
logmsg(" flag.\n");
logmsg("\n\n");
}
quads->dimquads = me->dimquads;
codes->dimcodes = dimcodes;
quads->healpix = skhp;
codes->healpix = skhp;
quads->hpnside = sknside;
codes->hpnside = sknside;
if (id) {
quads->indexid = id;
codes->indexid = id;
}
qhdr = quadfile_get_header(quads);
chdr = codefile_get_header(codes);
add_headers(qhdr, args, argc, startree_header(me->starkd), circle, passes);
add_headers(chdr, args, argc, startree_header(me->starkd), circle, passes);
if (quadfile_write_header(quads)) {
ERROR("Couldn't write headers to quad file");
return -1;
}
if (codefile_write_header(codes)) {
ERROR("Couldn't write headers to code file");
return -1;
}
quads->numstars = codes->numstars = N;
me->quad_dist2_upper = arcmin2distsq(scale_max_arcmin);
me->quad_dist2_lower = arcmin2distsq(scale_min_arcmin);
codes->index_scale_upper = quads->index_scale_upper = distsq2rad(me->quad_dist2_upper);
codes->index_scale_lower = quads->index_scale_lower = distsq2rad(me->quad_dist2_lower);
me->nuses = calloc(N, sizeof(unsigned char));
// hprad = sqrt(2) * (healpix side length / 2.)
hprad = arcmin2dist(healpix_side_length_arcmin(Nside)) * M_SQRT1_2;
quadscale = 0.5 * sqrt(me->quad_dist2_upper);
// 1.01 for a bit of safety. we'll look at a few extra stars.
radius2 = square(1.01 * (hprad + quadscale));
me->radius2 = radius2;
logmsg("Healpix radius %g arcsec, quad scale %g arcsec, total %g arcsec\n",
distsq2arcsec(hprad*hprad),
distsq2arcsec(quadscale*quadscale),
distsq2arcsec(radius2));
hptotry = il_new(1024);
if (scanoccupied) {
logmsg("Scanning %i input stars...\n", N);
for (i=0; i<N; i++) {
double xyz[3];
int j;
if (startree_get(me->starkd, i, xyz)) {
ERROR("Failed to get star %i", i);
return -1;
}
j = xyzarrtohealpix(xyz, Nside);
il_insert_unique_ascending(hptotry, j);
if (log_get_level() > LOG_VERB) {
double ra,dec;
if (startree_get_radec(me->starkd, i, &ra, &dec)) {
ERROR("Failed to get RA,Dec for star %i\n", i);
return -1;
}
logdebug("star %i: RA,Dec %g,%g; xyz %g,%g,%g; hp %i\n",
i, ra, dec, xyz[0], xyz[1], xyz[2], j);
}
}
logmsg("Will check %zu healpixes.\n", il_size(hptotry));
if (log_get_level() > LOG_VERB) {
logdebug("Checking healpixes: [ ");
for (i=0; i<il_size(hptotry); i++)
logdebug("%i ", il_get(hptotry, i));
logdebug("]\n");
}
} else {
if (skhp == -1) {
// Try all healpixes.
il_free(hptotry);
hptotry = NULL;
Nhptotry = NHP;
} else {
// The star kdtree may itself be healpixed
int starhp, starx, stary;
// In that case, the healpixes we are interested in form a rectangle
// within a big healpix. These are the coords (in [0, Nside)) of
// that rectangle.
int x0, x1, y0, y1;
int x, y;
healpix_decompose_xy(skhp, &starhp, &starx, &stary, sknside);
x0 = starx * (Nside / sknside);
x1 = (starx+1) * (Nside / sknside);
y0 = stary * (Nside / sknside);
y1 = (stary+1) * (Nside / sknside);
for (y=y0; y<y1; y++) {
for (x=x0; x<x1; x++) {
int j = healpix_compose_xy(starhp, x, y, Nside);
il_append(hptotry, j);
}
}
assert(il_size(hptotry) == (Nside/sknside) * (Nside/sknside));
}
}
if (hptotry)
Nhptotry = il_size(hptotry);
me->quadlist = bl_new(65536, quadsize);
if (Nloosen)
me->retryhps = il_new(1024);
for (pass=0; pass<passes; pass++) {
char key[64];
int nthispass;
logmsg("Pass %i of %i.\n", pass+1, passes);
logmsg("Trying %i healpixes.\n", Nhptotry);
nthispass = build_quads(me, Nhptotry, hptotry, Nreuses);
logmsg("Made %i quads (out of %i healpixes) this pass.\n", nthispass, Nhptotry);
logmsg("Made %i quads so far.\n", (me->bigquadlist ? bt_size(me->bigquadlist) : 0) + (int)bl_size(me->quadlist));
sprintf(key, "PASS%i", pass+1);
fits_header_mod_int(chdr, key, nthispass, "quads created in this pass");
fits_header_mod_int(qhdr, key, nthispass, "quads created in this pass");
logmsg("Merging quads...\n");
if (!me->bigquadlist)
me->bigquadlist = bt_new(quadsize, 256);
for (i=0; i<bl_size(me->quadlist); i++) {
void* q = bl_access(me->quadlist, i);
bt_insert2(me->bigquadlist, q, FALSE, compare_quads, &me->dimquads);
}
bl_remove_all(me->quadlist);
}
il_free(hptotry);
hptotry = NULL;
if (Nloosen) {
int R;
for (R=Nreuses+1; R<=Nloosen; R++) {
il* trylist;
int nthispass;
logmsg("Loosening reuse maximum to %i...\n", R);
logmsg("Trying %zu healpixes.\n", il_size(me->retryhps));
if (!il_size(me->retryhps))
break;
trylist = me->retryhps;
me->retryhps = il_new(1024);
nthispass = build_quads(me, il_size(trylist), trylist, R);
logmsg("Made %i quads (out of %zu healpixes) this pass.\n", nthispass, il_size(trylist));
il_free(trylist);
for (i=0; i<bl_size(me->quadlist); i++) {
void* q = bl_access(me->quadlist, i);
bt_insert2(me->bigquadlist, q, FALSE, compare_quads, &me->dimquads);
}
bl_remove_all(me->quadlist);
}
}
if (me->retryhps)
il_free(me->retryhps);
kdtree_free_query(me->res);
me->res = NULL;
me->inds = NULL;
me->stars = NULL;
free(me->nuses);
me->nuses = NULL;
logmsg("Writing quads...\n");
// add the quads from the big-quadlist
nquads = bt_size(me->bigquadlist);
for (i=0; i<nquads; i++) {
unsigned int* q = bt_access(me->bigquadlist, i);
quad_write(codes, quads, q, me->starkd, me->dimquads, dimcodes);
}
// add the quads that were made during the final round.
for (i=0; i<bl_size(me->quadlist); i++) {
unsigned int* q = bl_access(me->quadlist, i);
quad_write(codes, quads, q, me->starkd, me->dimquads, dimcodes);
}
// fix output file headers.
if (quadfile_fix_header(quads)) {
ERROR("Failed to fix quadfile headers");
return -1;
}
if (codefile_fix_header(codes)) {
ERROR("Failed to fix codefile headers");
return -1;
}
bl_free(me->quadlist);
bt_free(me->bigquadlist);
toc();
logmsg("Done.\n");
return 0;
}
int ark_create_verbose(char *path, ARK **arkret,
uint64_t size, uint64_t bsize, uint64_t hcount,
int nthrds, int nqueue, int basyncs, uint64_t flags)
{
int rc = 0;
int p_rc = 0;
uint64_t bcount = 0;
uint64_t x = 0;
int i = 0;
int tnum = 0;
int rnum = 0;
scb_t *scbp = NULL;
KV_TRC_OPEN(pAT, "arkdb");
if (NULL == arkret)
{
KV_TRC_FFDC(pAT, "Incorrect value for ARK control block: rc=EINVAL");
rc = EINVAL;
goto ark_create_ark_err;
}
if ( (flags & (ARK_KV_PERSIST_LOAD|ARK_KV_PERSIST_STORE)) &&
(flags & ARK_KV_VIRTUAL_LUN) )
{
KV_TRC_FFDC(pAT, "Invalid persistence combination with ARK flags: %016lx",
flags);
rc = EINVAL;
goto ark_create_ark_err;
}
if (nthrds <= 0)
{
KV_TRC_FFDC(pAT, "invalid nthrds:%d", nthrds);
rc = EINVAL;
goto ark_create_ark_err;
}
_ARK *ark = am_malloc(sizeof(_ARK));
if (ark == NULL) {
rc = ENOMEM;
KV_TRC_FFDC(pAT, "Out of memory allocating ARK control structure for %ld",
sizeof(_ARK));
goto ark_create_ark_err;
}
KV_TRC(pAT, "%p path(%s) size %ld bsize %ld hcount %ld "
"nthrds %d nqueue %d basyncs %d flags:%08lx",
ark, path, size, bsize, hcount,
nthrds, nqueue, basyncs, flags);
ark->bsize = bsize;
ark->rthread = 0;
ark->persload = 0;
ark->nasyncs = ((nqueue <= 0) ? ARK_MAX_ASYNC_OPS : nqueue);
ark->basyncs = basyncs;
ark->ntasks = ARK_MAX_TASK_OPS;
ark->nthrds = ARK_VERBOSE_NTHRDS_DEF; // hardcode, perf requirement
// Create the KV storage, whether that will be memory based
// or flash
ark->ea = ea_new(path, ark->bsize, basyncs, &size, &bcount,
(flags & ARK_KV_VIRTUAL_LUN));
if (ark->ea == NULL)
{
if (!errno) {KV_TRC_FFDC(pAT, "UNSET_ERRNO"); errno=ENOMEM;}
rc = errno;
KV_TRC_FFDC(pAT, "KV storage initialization failed: rc/errno:%d", rc);
goto ark_create_ea_err;
}
// Now that the "connection" to the store has been established
// we need to check to see if data was persisted from a previous
// instantiation of the KV store.
p_rc = ark_check_persistence(ark, flags);
if (p_rc > 0)
{
// We ran into an error while trying to read from
// the store.
rc = p_rc;
KV_TRC_FFDC(pAT, "Persistence check failed: %d", rc);
goto ark_create_persist_err;
}
else if (p_rc == -1)
{
KV_TRC(pAT, "NO PERSIST LOAD FLAG");
// There was no persistence data, so we just build off
// of what was passed into the API.
ark->size = size;
ark->bcount = bcount;
ark->hcount = hcount;
ark->vlimit = ARK_VERBOSE_VLIMIT_DEF;
ark->blkbits = ARK_VERBOSE_BLKBITS_DEF;
ark->grow = ARK_VERBOSE_GROW_DEF;
ark->rthread = 0;
ark->flags = flags;
ark->astart = 0;
ark->blkused = 1;
ark->ark_exit = 0;
ark->nactive = 0;
ark->pers_stats.kv_cnt = 0;
ark->pers_stats.blk_cnt = 0;
ark->pers_stats.byte_cnt = 0;
ark->pcmd = PT_IDLE;
// Create the requests and tag control blocks and queues.
x = ark->hcount / ark->nthrds;
ark->npart = x + (ark->hcount % ark->nthrds ? 1 : 0);
// Create the hash table
ark->ht = hash_new(ark->hcount);
if (ark->ht == NULL)
{
if (!errno) {KV_TRC_FFDC(pAT, "UNSET_ERRNO"); errno=ENOMEM;}
rc = errno;
KV_TRC_FFDC(pAT, "Hash initialization failed: %d", rc);
goto ark_create_ht_err;
}
// Create the block list
ark->bl = bl_new(ark->bcount, ark->blkbits);
if (ark->bl == NULL)
{
if (!errno) {KV_TRC_FFDC(pAT, "UNSET_ERRNO"); errno=ENOMEM;}
rc = errno;
KV_TRC_FFDC(pAT, "Block list initialization failed: %d", rc);
goto ark_create_bl_err;
}
if (flags & ARK_KV_PERSIST_STORE)
{
ark_persistence_calc(ark);
if (bl_reserve(ark->bl, ark->pers_max_blocks))
{goto ark_create_bl_err;}
}
}
else
{
KV_TRC(pAT, "PERSIST: %p path(%s) size %ld bsize %ld hcount %ld "
"nthrds %d nqueue %ld basyncs %d bcount %ld blkbits %ld",
ark, path, ark->size, ark->bsize, ark->hcount,
ark->nthrds, ark->nasyncs, ark->basyncs,
ark->bcount, ark->blkbits);
}
rc = pthread_mutex_init(&ark->mainmutex,NULL);
if (rc != 0)
{
KV_TRC_FFDC(pAT, "pthread_mutex_init for main mutex failed: %d", rc);
goto ark_create_pth_mutex_err;
}
ark->rtags = tag_new(ark->nasyncs);
if ( NULL == ark->rtags )
{
rc = ENOMEM;
KV_TRC_FFDC(pAT, "Tag initialization for requests failed: %d", rc);
goto ark_create_rtag_err;
}
ark->ttags = tag_new(ark->ntasks);
if ( NULL == ark->ttags )
{
rc = ENOMEM;
KV_TRC_FFDC(pAT, "Tag initialization for tasks failed: %d", rc);
goto ark_create_ttag_err;
}
ark->rcbs = am_malloc(ark->nasyncs * sizeof(rcb_t));
if ( NULL == ark->rcbs )
{
rc = ENOMEM;
KV_TRC_FFDC(pAT, "Out of memory allocation of %"PRIu64" bytes for request control blocks", (ark->nasyncs * sizeof(rcb_t)));
goto ark_create_rcbs_err;
}
ark->tcbs = am_malloc(ark->ntasks * sizeof(tcb_t));
if ( NULL == ark->tcbs )
{
rc = ENOMEM;
KV_TRC_FFDC(pAT, "Out of memory allocation of %"PRIu64" bytes for task control blocks", (ark->ntasks * sizeof(rcb_t)));
goto ark_create_tcbs_err;
}
ark->iocbs = am_malloc(ark->ntasks * sizeof(iocb_t));
if ( NULL == ark->iocbs )
{
rc = ENOMEM;
KV_TRC_FFDC(pAT, "Out of memory allocation of %"PRIu64" bytes for io control blocks", (ark->ntasks * sizeof(iocb_t)));
goto ark_create_iocbs_err;
}
ark->poolthreads = am_malloc(ark->nthrds * sizeof(scb_t));
if ( NULL == ark->poolthreads )
{
rc = ENOMEM;
KV_TRC_FFDC(pAT, "Out of memory allocation of %"PRIu64" bytes for server thread control blocks", (ark->nthrds * sizeof(scb_t)));
goto ark_create_poolthreads_err;
}
for ( rnum = 0; rnum < ark->nasyncs ; rnum++ )
{
ark->rcbs[rnum].stat = A_NULL;
pthread_cond_init(&(ark->rcbs[rnum].acond), NULL);
pthread_mutex_init(&(ark->rcbs[rnum].alock), NULL);
}
for ( tnum = 0; tnum < ark->ntasks; tnum++ )
{
ark->tcbs[tnum].inb = bt_new(0, ark->vlimit, sizeof(uint64_t),
&(ark->tcbs[tnum].inblen),
&(ark->tcbs[tnum].inb_orig));
if (ark->tcbs[tnum].inb == NULL)
{
if (!errno) {KV_TRC_FFDC(pAT, "UNSET_ERRNO"); errno=ENOMEM;}
rc = errno;
KV_TRC_FFDC(pAT, "Bucket allocation for inbuffer failed: %d", rc);
goto ark_create_taskloop_err;
}
ark->tcbs[tnum].oub = bt_new(0, ark->vlimit, sizeof(uint64_t),
&(ark->tcbs[tnum].oublen),
&(ark->tcbs[tnum].oub_orig));
if (ark->tcbs[tnum].oub == NULL)
{
if (!errno) {KV_TRC_FFDC(pAT, "UNSET_ERRNO"); errno=ENOMEM;}
rc = errno;
KV_TRC_FFDC(pAT, "Bucket allocation for outbuffer failed: %d", rc);
goto ark_create_taskloop_err;
}
//ark->tcbs[tnum].vbsize = bsize * 1024;
ark->tcbs[tnum].vbsize = bsize * 256;
ark->tcbs[tnum].vb_orig = am_malloc(ark->tcbs[tnum].vbsize);
if (ark->tcbs[tnum].vb_orig == NULL)
{
rc = ENOMEM;
KV_TRC_FFDC(pAT, "Out of memory allocation for %"PRIu64" bytes for variable size buffer", (bsize * 1024));
goto ark_create_taskloop_err;
}
ark->tcbs[tnum].vb = ptr_align(ark->tcbs[tnum].vb_orig);
}
*arkret = (void *)ark;
ark->pts = (PT *)am_malloc(sizeof(PT) * ark->nthrds);
if ( ark->pts == NULL )
{
rc = ENOMEM;
KV_TRC_FFDC(pAT, "Out of memory allocation for %"PRIu64" bytes for server thread data", (sizeof(PT) * ark->nthrds));
goto ark_create_taskloop_err;
}
for (i = 0; i < ark->nthrds; i++) {
PT *pt = &(ark->pts[i]);
scbp = &(ark->poolthreads[i]);
memset(scbp, 0, sizeof(scb_t));
// Start off the random start point for this thread
// at -1, to show that it has not been part of a
// ark_random call.
scbp->rlast = -1;
scbp->holds = 0;
scbp->poolstate = PT_RUN;
scbp->poolstats.io_cnt = 0;
scbp->poolstats.ops_cnt = 0;
scbp->poolstats.kv_cnt = 0;
scbp->poolstats.blk_cnt = 0;
scbp->poolstats.byte_cnt = 0;
pthread_mutex_init(&(scbp->poolmutex), NULL);
pthread_cond_init(&(scbp->poolcond), NULL);
scbp->rqueue = queue_new(ark->nasyncs);
scbp->tqueue = queue_new(ark->ntasks);
scbp->ioqueue = queue_new(ark->ntasks);
pt->id = i;
pt->ark = ark;
rc = pthread_create(&(scbp->pooltid), NULL, pool_function, pt);
if (rc != 0)
{
KV_TRC_FFDC(pAT, "pthread_create of server thread failed: %d", rc);
goto ark_create_poolloop_err;
}
}
#if 0
while (ark->nactive < ark->nthrds) {
usleep(1);
//printf("Create waiting %d/%d\n", ark->nactive, ark->nthrds);
}
#endif
ark->pcmd = PT_RUN;
goto ark_create_return;
ark_create_poolloop_err:
for (; i >= 0; i--)
{
scbp = &(ark->poolthreads[i]);
if (scbp->pooltid != 0)
{
queue_lock(scbp->rqueue);
queue_wakeup(scbp->rqueue);
queue_unlock(scbp->rqueue);
pthread_join(scbp->pooltid, NULL);
pthread_mutex_destroy(&(scbp->poolmutex));
pthread_cond_destroy(&(scbp->poolcond));
if ( scbp->rqueue != NULL )
{
queue_free(scbp->rqueue);
}
if ( scbp->tqueue != NULL )
{
queue_free(scbp->tqueue);
}
if ( scbp->ioqueue != NULL )
{
queue_free(scbp->ioqueue);
}
}
}
if ( ark->pts != NULL )
{
am_free(ark->pts);
}
ark_create_taskloop_err:
for ( tnum = 0; tnum < ark->ntasks; tnum++ )
{
if (ark->tcbs[tnum].inb)
{
bt_delete(ark->tcbs[tnum].inb);
}
if (ark->tcbs[tnum].oub)
{
bt_delete(ark->tcbs[tnum].oub);
}
if (ark->tcbs[tnum].vb_orig)
{
am_free(ark->tcbs[tnum].vb_orig);
}
}
for (rnum = 0; rnum < ark->nasyncs; rnum++)
{
pthread_cond_destroy(&(ark->rcbs[rnum].acond));
pthread_mutex_destroy(&(ark->rcbs[rnum].alock));
}
if ( ark->poolthreads != NULL )
{
am_free(ark->poolthreads);
}
ark_create_poolthreads_err:
if (ark->iocbs)
{
am_free(ark->iocbs);
}
ark_create_iocbs_err:
if (ark->tcbs)
{
am_free(ark->tcbs);
}
ark_create_tcbs_err:
if (ark->rcbs)
{
am_free(ark->rcbs);
}
ark_create_rcbs_err:
if (ark->ttags)
{
tag_free(ark->ttags);
}
ark_create_ttag_err:
if (ark->rtags)
{
tag_free(ark->rtags);
}
ark_create_rtag_err:
pthread_mutex_destroy(&ark->mainmutex);
ark_create_pth_mutex_err:
bl_delete(ark->bl);
ark_create_bl_err:
hash_free(ark->ht);
ark_create_ht_err:
ark_create_persist_err:
ea_delete(ark->ea);
ark_create_ea_err:
am_free(ark);
*arkret = NULL;
ark_create_ark_err:
KV_TRC_CLOSE(pAT);
ark_create_return:
return rc;
}
int
read_seno_dtree_file(dtree_t **out_dt,
const char *file_name)
{
uint32 n_base;
uint32 n_cd;
char tree_id[64];
float32 ent;
uint32 key, l_key, r_key, n_key = 0, *k2q = NULL;
char q_str[1024], *rem_q_str;
FILE *fp;
int i, j, n_quest;
dtree_t *dt;
bt_node_t *node;
bt_t *tree;
comp_quest_t *q;
float32 *q2ent;
*out_dt = dt = (dtree_t *)ckd_calloc(1, sizeof(dtree_t));
dt->tree = tree = bt_new();
fp = fopen(file_name, "r");
if (fp == NULL) {
E_WARN_SYSTEM("Unable to open %s for reading", file_name);
return S3_ERROR;
}
for (n_quest = 0; fgets(q_str, 1024, fp) != NULL; n_quest++);
--n_quest; /* account for header line */
dt->n_quest = n_quest;
rewind(fp);
read_header_line(&n_base, tree_id, &n_cd, fp);
for (i = 0; read_node_line(&ent, &key, &l_key, &r_key, q_str, fp) > 0; i++) {
if (n_key < l_key)
n_key = l_key;
if (n_key < r_key)
n_key = r_key;
}
++n_key;
dt->n_key = n_key;
rewind(fp);
read_header_line(&n_base, tree_id, &n_cd, fp);
E_INFO("Reading tree %s (%u base phones, %u CD phones, %u quest)\n",
tree_id, n_base, n_cd, n_quest);
dt->quest = q = (comp_quest_t *)ckd_calloc(n_quest,
sizeof(comp_quest_t));
dt->k2q = k2q = (uint32 *)ckd_calloc(n_key, sizeof(uint32));
dt->q2ent = q2ent = (float32 *)ckd_calloc(n_quest, sizeof(float32));
for (i = 0; i < n_key; i++) {
k2q[i] = NO_MAP;
}
for (i = 0; read_node_line(&ent, &key, &l_key, &r_key, q_str, fp) > 0; i++) {
if (tree->root) {
E_INFO("%u\n", key);
node = bt_find_node(tree, key);
if (node) {
/* grow left and right children */
bt_add_left(node, l_key);
bt_add_right(node, r_key);
}
else {
E_FATAL("Find node w/ key %u failed\n", key);
}
}
else {
E_INFO("root %u\n", key);
tree->root = bt_new_node(key);
bt_add_left(tree->root, l_key);
bt_add_right(tree->root, r_key);
}
k2q[key] = i;
q2ent[i] = ent;
parse_compound_q(&q[i], q_str);
}
assert(i == n_quest);
return S3_SUCCESS;
}
