GtAlphabet* gt_alphabet_clone(const GtAlphabet *alphabet)
{
unsigned int i;
GtAlphabet *newalpha;
gt_assert(alphabet);
newalpha = gt_malloc(sizeof *newalpha);
newalpha->domainsize = alphabet->domainsize;
newalpha->mapsize = alphabet->mapsize;
newalpha->mappedwildcards = alphabet->mappedwildcards;
newalpha->wildcardshow = alphabet->wildcardshow;
newalpha->bitspersymbol = alphabet->bitspersymbol;
newalpha->alphadef = gt_str_ref(alphabet->alphadef);
newalpha->reference_count = 0;
newalpha->refmutex = gt_mutex_new();
for (i=0; i<=(unsigned int) GT_MAXALPHABETCHARACTER; i++)
{
newalpha->symbolmap[i] = alphabet->symbolmap[i];
}
newalpha->characters = gt_malloc(alphabet->mapsize * sizeof (GtUchar));
for (i=0; i<newalpha->mapsize; i++)
{
newalpha->characters[i] = alphabet->characters[i];
}
newalpha->mapdomain = gt_malloc(alphabet->domainsize * sizeof (GtUchar));
for (i=0; i<newalpha->domainsize; i++)
{
newalpha->mapdomain[i] = alphabet->mapdomain[i];
}
return newalpha;
}
void gt_symbol_init(void)
{
if (!symbols)
symbols = gt_cstr_table_new();
if (!symbol_mutex)
symbol_mutex = gt_mutex_new();
}
unsigned int
gt_ya_rand_init(unsigned int seed)
{
unsigned int generated_seed;
int i;
if (!mutex)
mutex = gt_mutex_new();
if (seed == 0)
{
struct timeval tp;
struct timezone tzp;
gettimeofday(&tp, &tzp);
/* ignore overflow */
seed = (999*tp.tv_sec) + (1001*tp.tv_usec) + (1003 * getpid());
}
generated_seed = seed;
/* allow to call gt_ya_rand_init() multiple times */
for (i = 0; i < VectorSize; i++)
a[i] = a_source[i];
a[0] += seed;
for (i = 1; i < VectorSize; i++)
{
seed = a[i-1]*1001 + seed*999;
a[i] += seed;
}
i1 = a[0] % VectorSize;
i2 = (i1 + 024) % VectorSize;
return generated_seed;
}
void gt_spacepeak_init(void)
{
gt_assert(!peaklogger);
peaklogger = malloc(sizeof (GtSpacepeakLogger));
peaklogger->current = gt_ma_get_space_current();
peaklogger->max = 0;
peaklogger->mutex = gt_mutex_new();
}
void gt_ma_init(bool bookkeeping)
{
gt_assert(!ma);
ma = xcalloc(1, sizeof (MA), 0, __FILE__, __LINE__);
gt_assert(!ma->bookkeeping);
ma->allocated_pointer = gt_hashmap_new_no_ma(GT_HASH_DIRECT, NULL,
(GtFree) ma_info_free);
/* MA is ready to use */
ma->bookkeeping = bookkeeping;
bookkeeping_lock = gt_mutex_new();
ma->global_space_peak = false;
}
GtAlphabet* gt_alphabet_new_empty(void)
{
GtAlphabet *a = gt_malloc(sizeof *a);
a->domainsize = 0;
a->mapsize = 0;
a->mappedwildcards = 0;
a->bitspersymbol = 0;
a->reference_count = 0;
a->refmutex = gt_mutex_new();
a->wildcardshow = (GtUchar) UNDEFCHAR;
memset(a->symbolmap, (int) UNDEFCHAR, (size_t) GT_MAXALPHABETCHARACTER+1);
a->mapdomain = NULL;
a->characters = NULL;
a->alphadef = NULL;
return a;
}
/* to be called from implementing class! */
int gt_feature_index_unit_test(GtFeatureIndex *fi, GtError *err)
{
int had_err = 0, i, rval;
GtFeatureIndexTestShared sh;
GtStrArray *seqids;
GtStr *seqid;
GtRange check_range;
GtRegionNode *rn;
bool has_seqid;
gt_error_check(err);
sh.mutex = gt_mutex_new();
sh.nodes = gt_array_new(sizeof (GtFeatureNode*));
sh.error_count = 0;
sh.next_node_idx = 0;
sh.fi = fi;
sh.err = gt_error_new();
/* create region */
seqid = gt_str_new_cstr(GT_FI_TEST_SEQID);
rn = (GtRegionNode*) gt_region_node_new(seqid, GT_FI_TEST_START,
GT_FI_TEST_END);
/* test seqid is not supposed to exist */
gt_ensure(gt_feature_index_has_seqid(sh.fi, &has_seqid,
GT_FI_TEST_SEQID, err) == 0);
gt_ensure(!has_seqid);
/* add a sequence region directly and check if it has been added */
rval = gt_feature_index_add_region_node(sh.fi, rn, err);
gt_ensure(rval == 0);
gt_genome_node_delete((GtGenomeNode*) rn);
gt_ensure(gt_feature_index_has_seqid(sh.fi, &has_seqid,
GT_FI_TEST_SEQID, err) == 0);
gt_ensure(has_seqid);
gt_feature_index_get_range_for_seqid(sh.fi, &check_range, GT_FI_TEST_SEQID,
err);
gt_ensure(check_range.start == GT_FI_TEST_START
&& check_range.end == GT_FI_TEST_END);
/* set up nodes to store */
for (i=0;i<GT_FI_TEST_FEATURES_PER_THREAD*gt_jobs;i++) {
GtUword start, end;
GtFeatureNode *fn;
start = random() % (GT_FI_TEST_END - GT_FI_TEST_FEATURE_WIDTH);
end = start + random() % (GT_FI_TEST_FEATURE_WIDTH);
fn = gt_feature_node_cast(gt_feature_node_new(seqid, "gene", start, end,
GT_STRAND_FORWARD));
gt_array_add(sh.nodes, fn);
}
/* test parallel addition */
gt_multithread(gt_feature_index_unit_test_add, &sh, err);
seqids = gt_feature_index_get_seqids(fi, err);
gt_ensure(seqids);
gt_ensure(gt_feature_index_has_seqid(fi, &has_seqid,GT_FI_TEST_SEQID,
err) == 0);
gt_ensure(has_seqid);
gt_ensure(gt_str_array_size(seqids) == 1);
/* test parallel query */
if (!had_err)
gt_multithread(gt_feature_index_unit_test_query, &sh, err);
gt_ensure(sh.error_count == 0);
gt_mutex_delete(sh.mutex);
gt_error_delete(sh.err);
gt_str_array_delete(seqids);
gt_array_delete(sh.nodes);
gt_str_delete(seqid);
return had_err;
}
