static size_t gt_tableoflcpvalues_realloc(GtLcpvalues *tableoflcpvalues,
GtUword numoflcpvalues)
{
if (numoflcpvalues > tableoflcpvalues->numofentries)
{
size_t sizeofinfo;
tableoflcpvalues->bucketoflcpvalues
= gt_realloc(tableoflcpvalues->bucketoflcpvalues,
sizeof (*tableoflcpvalues->bucketoflcpvalues) *
numoflcpvalues);
sizeofinfo = sizeof (*tableoflcpvalues->bucketoflcpvalues) *
(numoflcpvalues - tableoflcpvalues->numofentries);
#ifndef NDEBUG
GT_INITBITTABGENERIC(tableoflcpvalues->isset,
tableoflcpvalues->isset,
numoflcpvalues);
#endif
sizeofinfo += GT_NUMOFINTSFORBITS(numoflcpvalues -
tableoflcpvalues->numofentries)
* sizeof (GtBitsequence);
tableoflcpvalues->numoflargelcpvalues = 0;
tableoflcpvalues->numofentries = numoflcpvalues;
tableoflcpvalues->lcptaboffset = 0;
return sizeofinfo;
}
return 0;
}
void gt_Sfxmappedrange_usetmp(GtSfxmappedrange *sfxmappedrange,
const GtStr *tmpfilename,
void **usedptrptr,
GtUword numofentries,
bool writable)
{
gt_assert(sfxmappedrange != NULL);
sfxmappedrange->ptr = NULL;
/*gt_assert(usedptrptr != NULL && *usedptrptr == NULL);*/
sfxmappedrange->usedptrptr = usedptrptr;
sfxmappedrange->filename = gt_str_clone(tmpfilename);
sfxmappedrange->writable = writable;
if (sfxmappedrange->type == GtSfxGtBitsequence)
{
sfxmappedrange->numofunits = GT_NUMOFINTSFORBITS(numofentries);
} else
{
sfxmappedrange->numofunits = (size_t) numofentries;
}
gt_log_log("use file %s for table %s ("GT_WU" units of "GT_WU" bytes)",
gt_str_get(sfxmappedrange->filename),
gt_str_get(sfxmappedrange->tablename),
(GtUword) sfxmappedrange->numofunits,
(GtUword) sfxmappedrange->sizeofunit);
gt_free(*sfxmappedrange->usedptrptr);
*sfxmappedrange->usedptrptr = NULL;
}
static inline void gt_cntlist_show_bit(GtBitsequence *cntlist,
GtUword nofreads, FILE *file)
{
gt_assert(file != NULL);
gt_xfputc(GT_CNTLIST_BIT_HEADER, file);
gt_xfputc((char)sizeof(GtUword), file);
gt_xfwrite(&(nofreads), sizeof (GtUword), (size_t)1, file);
gt_xfwrite(cntlist, sizeof (GtBitsequence), GT_NUMOFINTSFORBITS(nofreads),
file);
}
static int gt_cntlist_parse_bit(FILE *infp, bool alloc_cntlist,
GtBitsequence **cntlist, GtUword *nofreads, GtError *err)
{
int had_err = gt_cntlist_parse_bin_or_bit_header(infp, nofreads, err);
if (had_err == 0)
{
size_t n;
gt_assert(cntlist != NULL);
if (alloc_cntlist)
{
GT_INITBITTAB(*cntlist, *nofreads);
n = fread(*cntlist, sizeof (GtBitsequence),
GT_NUMOFINTSFORBITS(*nofreads), infp);
if (n != GT_NUMOFINTSFORBITS(*nofreads))
{
gt_error_set(err, "contained reads file: unrecognized format");
had_err = -1;
}
}
else
{
/* combine using OR with existing data */
size_t i;
for (i = 0; i < GT_NUMOFINTSFORBITS(*nofreads); i++)
{
GtBitsequence value;
n = fread(&value, sizeof (GtBitsequence), (size_t)1, infp);
if (n != (size_t)1)
{
gt_error_set(err, "contained reads file: unrecognized format");
had_err = -1;
break;
}
*cntlist[i] |= value;
}
}
}
return had_err;
}
GtSfxmappedrange *gt_Sfxmappedrange_new(const char *tablename,
GtUword numofentries,
GtSfxmappedrangetype type,
GtSfxmappedrangetransformfunc
transformfunc,
const void *transformfunc_data)
{
GtSfxmappedrange *sfxmappedrange;
sfxmappedrange = gt_malloc(sizeof (*sfxmappedrange));
sfxmappedrange->ptr = NULL;
sfxmappedrange->pagesize = gt_pagesize();
sfxmappedrange->usedptrptr = NULL;
sfxmappedrange->filename = NULL;
sfxmappedrange->writable = false;
sfxmappedrange->entire = NULL;
sfxmappedrange->transformfunc = transformfunc;
sfxmappedrange->transformfunc_data = transformfunc_data;
sfxmappedrange->type = type;
sfxmappedrange->tablename = gt_str_new_cstr(tablename);
sfxmappedrange->currentminindex = sfxmappedrange->currentmaxindex = 0;
sfxmappedrange->indexrange_defined = false;
switch (type)
{
case GtSfxGtBitsequence:
sfxmappedrange->sizeofunit = sizeof (GtBitsequence);
sfxmappedrange->numofunits = GT_NUMOFINTSFORBITS(numofentries);
break;
case GtSfxuint32_t:
sfxmappedrange->sizeofunit = sizeof (uint32_t);
sfxmappedrange->numofunits = (size_t) numofentries;
break;
case GtSfxunsignedlong:
sfxmappedrange->sizeofunit = sizeof (GtUword);
sfxmappedrange->numofunits = (size_t) numofentries;
break;
default:
gt_assert(false);
break;
}
return sfxmappedrange;
}
static int gt_compressedbits_runner(GT_UNUSED int argc,
GT_UNUSED const char **argv,
GT_UNUSED int parsed_args,
void *tool_arguments,
GtError *err)
{
GtCompressdbitsArguments *arguments = tool_arguments;
int had_err = 0;
unsigned long idx;
unsigned long long num_of_bits = 0ULL;
GtBitsequence *bits = NULL;
GtCompressedBitsequence *cbs = NULL, *read_cbs = NULL;
GtStr *filename = gt_str_new();
FILE *fp = NULL;
gt_error_check(err);
gt_assert(arguments);
gt_assert(argc == parsed_args);
if (gt_option_is_set(arguments->filename_op)) {
FILE *file = NULL;
gt_assert(arguments->filename != NULL);
file = gt_xfopen(gt_str_get(arguments->filename), "r");
if ((size_t) 1 != gt_xfread(&num_of_bits,
sizeof (num_of_bits), (size_t) 1, file)) {
had_err = -1;
}
if (!had_err) {
gt_log_log("bits to read: %llu", num_of_bits);
arguments->size = (unsigned long) GT_NUMOFINTSFORBITS(num_of_bits);
bits = gt_malloc(sizeof (*bits) * arguments->size);
if ((size_t) arguments->size !=
gt_xfread(bits, sizeof (*bits),
(size_t) arguments->size, file)) {
had_err = -1;
}
}
gt_xfclose(file);
}
else {
bits = gt_calloc(sizeof (*bits), (size_t) arguments->size);
num_of_bits = (unsigned long long) (GT_INTWORDSIZE * arguments->size);
if (arguments->fill_random) {
for (idx = 0; idx < arguments->size; idx++) {
bits[idx] =
(GtBitsequence) (0xAAAAAAAAAAAAAAAAUL ^ gt_rand_max(ULONG_MAX));
}
}
else {
for (idx = 0; idx < arguments->size; idx++)
bits[idx] = (GtBitsequence) (0xAAAAAAAAAAAAAAAAUL ^ idx);
}
}
if (!had_err) {
fp = gt_xtmpfp(filename);
gt_fa_xfclose(fp);
fp = NULL;
gt_log_log("filename: %s", gt_str_get(filename));
gt_log_log("size in words: %lu", arguments->size);
cbs = gt_compressed_bitsequence_new(
bits, arguments->samplerate,
(unsigned long) num_of_bits);
gt_log_log("original size in MB: %2.3f",
(sizeof (*bits) * arguments->size) / (1024.0 * 1024.0));
gt_log_log("compressed size in MB: %2.3f",
gt_compressed_bitsequence_size(cbs) / (1024.0 * 1024.0));
gt_log_log("popcount table size thereof in MB: %2.3f",
gt_popcount_tab_calculate_size(15U) / (1024.0 * 1024.0));
had_err = gt_compressed_bitsequence_write(cbs, gt_str_get(filename), err);
}
if (!had_err)
{
read_cbs =
gt_compressed_bitsequence_new_from_file(gt_str_get(filename), err);
if (read_cbs == NULL)
had_err = -1;
}
if (!had_err && bits != NULL && arguments->check_consistency) {
for (idx = 0; (unsigned long long) idx < num_of_bits; ++idx) {
int GT_UNUSED bit = gt_compressed_bitsequence_access(read_cbs, idx);
int GT_UNUSED original = GT_ISIBITSET(bits, idx) ? 1 : 0;
gt_assert(gt_compressed_bitsequence_access(cbs, idx) == bit);
gt_assert(original == bit);
}
}
gt_compressed_bitsequence_delete(cbs);
gt_compressed_bitsequence_delete(read_cbs);
gt_free(bits);
gt_str_delete(filename);
return had_err;
}
