static inline void gt_readjoiner_assembly_show_current_space(const char *label)
{
GtUword m, f;
if (gt_ma_bookkeeping_enabled())
{
m = gt_ma_get_space_current();
f = gt_fa_get_space_current();
gt_log_log("used space %s: %.2f MB (ma: %.2f MB; fa: %.2f MB)",
label == NULL ? "" : label, GT_MEGABYTES(m + f), GT_MEGABYTES(m),
GT_MEGABYTES(f));
}
}
void gt_ma_show_space_peak(FILE *fp)
{
gt_assert(ma);
fprintf(fp, "# space peak in megabytes: %.2f (in "GT_LLU" events)\n",
GT_MEGABYTES(ma->max_size),
ma->mallocevents);
}
static void gt_firstcodes_updatemax(GtFirstcodesspacelog *fcsl)
{
if (fcsl->workspace + fcsl->splitspace > fcsl->spacepeak)
{
fcsl->spacepeak = fcsl->workspace + fcsl->splitspace;
gt_log_log("update spacepeak to %.2f MB",
GT_MEGABYTES(fcsl->spacepeak));
}
}
void gt_spacepeak_show_space_peak(FILE *outfp)
{
gt_assert(peaklogger);
fprintf(outfp, "# combined space peak in megabytes: %.2f\n",
GT_MEGABYTES(peaklogger->max));
}
void gt_firstcodes_spacelog_add(GtFirstcodesspacelog *fcsl,
int line,
const char *filename,
bool add,
const char *title,
bool work,
size_t size)
{
GtFirstcodespacelogentry *entry;
size_t logspace;
if (add)
{
entry = gt_spacelog_find(fcsl,title);
if (entry != NULL)
{
if (entry->size != 0)
{
fprintf(stderr,"existing entry for title \"%s\""
"(from file %s, line %d) "
"in spacelog entries must have size 0\n",
title,filename,line);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
gt_spacelog_updateaddentry(entry,filename,line,title,size,work);
} else
{
gt_spacelog_addentry(fcsl,filename,line,title,size,work);
}
if (work)
{
fcsl->workspace += size;
} else
{
fcsl->splitspace += size;
}
gt_firstcodes_updatemax(fcsl);
} else
{
entry = gt_spacelog_find(fcsl,title);
if (entry == NULL)
{
fprintf(stderr,"cannot find title \"%s\" (from file %s, line %d) "
"in spacelog entries\n",title,filename,line);
(void) gt_firstcodes_spacelog_showentries(stderr,fcsl);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
if ((entry->work && !work) || (!entry->work && work))
{
fprintf(stderr,"for title \"%s\" (from file %s, line %d) "
"in spacelog entries: inconsistent work/splitassignment\n",
title,filename,line);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
if (work)
{
if (entry->size > fcsl->workspace)
{
gt_firstcodes_subtract_error(title, filename, line, entry->size, true,
fcsl->workspace);
(void) gt_firstcodes_spacelog_showentries(stderr,fcsl);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
fcsl->workspace -= entry->size;
} else
{
if (entry->size > fcsl->splitspace)
{
gt_firstcodes_subtract_error(title, filename, line, entry->size, false,
fcsl->splitspace);
(void) gt_firstcodes_spacelog_showentries(stderr,fcsl);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
fcsl->splitspace -= entry->size;
}
if (size > 0)
{
gt_spacelog_updateaddentry(entry,filename,line,title,size,work);
if (work)
{
fcsl->workspace += size;
} else
{
fcsl->splitspace += size;
}
gt_firstcodes_updatemax(fcsl);
if (size > entry->size)
{
add = true;
size -= entry->size;
} else
{
size = entry->size - size;
}
} else
{
size = entry->size;
entry->size = 0;
}
}
logspace = fcsl->workspace+fcsl->splitspace;
gt_log_log(
#ifdef SKDEBUG
"file %s, line %d: "
#endif
"%s %s= %.2f, %s, w=%.2f, s=%.2f, sum=%.2f MB",
#ifdef SKDEBUG
filename,
line,
#endif
work ? "w" : "s",
add ? "+" : "-",
GT_MEGABYTES(size),
title,
GT_MEGABYTES(fcsl->workspace),
GT_MEGABYTES(fcsl->splitspace),
GT_MEGABYTES(logspace));
#ifdef SKDEBUG
if (gt_ma_bookkeeping_enabled())
{
unsigned long realspace = gt_ma_get_space_current() +
gt_fa_get_space_current();
gt_log_log("current space usage %.2f MB (%.2f+%.2f)",
GT_MEGABYTES(realspace),
GT_MEGABYTES(gt_ma_get_space_current()),
GT_MEGABYTES(gt_fa_get_space_current()));
if (fcsl->calc_difference)
{
double percent_difference;
if ((unsigned long) logspace > realspace)
{
fprintf(stderr,"overestimating logspace\n");
exit(GT_EXIT_PROGRAMMING_ERROR);
}
if (realspace >= 1000000UL)
{
/*
printf("realspace=%lu,logspace=%lu\n",realspace,
(unsigned long) logspace);
*/
percent_difference = 100.0 * (double) (realspace - logspace)/realspace;
if (gt_double_larger_double(percent_difference,3.0))
{
fprintf(stderr,"space difference of %.2f%% is too large\n",
percent_difference);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
if (gt_double_smaller_double(fcsl->max_percent_difference,
percent_difference))
{
fcsl->max_percent_difference = percent_difference;
}
}
}
}
#endif
}
static int enumeratelcpintervals(const char *inputindex,
Sequentialsuffixarrayreader *ssar,
const char *storeindex,
bool storecounts,
GtUword mersize,
GtUword minocc,
GtUword maxocc,
bool performtest,
GtLogger *logger,
GtError *err)
{
TyrDfsstate *state;
bool haserr = false;
unsigned int alphasize;
gt_error_check(err);
state = gt_malloc(sizeof (*state));
GT_INITARRAY(&state->occdistribution,Countwithpositions);
state->esrspace = gt_encseq_create_reader_with_readmode(
gt_encseqSequentialsuffixarrayreader(ssar),
gt_readmodeSequentialsuffixarrayreader(ssar),
0);
state->mersize = (GtUword) mersize;
state->encseq = gt_encseqSequentialsuffixarrayreader(ssar);
alphasize = gt_alphabet_num_of_chars(gt_encseq_alphabet(state->encseq));
state->readmode = gt_readmodeSequentialsuffixarrayreader(ssar);
state->storecounts = storecounts;
state->minocc = minocc;
state->maxocc = maxocc;
state->totallength = gt_encseq_total_length(state->encseq);
state->performtest = performtest;
state->countoutputmers = 0;
state->merindexfpout = NULL;
state->countsfilefpout = NULL;
GT_INITARRAY(&state->largecounts,Largecount);
if (strlen(storeindex) == 0)
{
state->sizeofbuffer = 0;
state->bytebuffer = NULL;
} else
{
state->sizeofbuffer = MERBYTES(mersize);
state->bytebuffer = gt_malloc(sizeof *state->bytebuffer
* state->sizeofbuffer);
}
if (performtest)
{
state->currentmer = gt_malloc(sizeof *state->currentmer
* state->mersize);
state->suftab = gt_suftabSequentialsuffixarrayreader(ssar);
} else
{
state->currentmer = NULL;
state->suftab = NULL;
}
if (state->mersize > state->totallength)
{
gt_error_set(err,"mersize "GT_WU" > "GT_WU" = totallength not allowed",
state->mersize,
state->totallength);
haserr = true;
} else
{
if (strlen(storeindex) == 0)
{
state->processoccurrencecount = adddistpos2distribution;
} else
{
state->merindexfpout = gt_fa_fopen_with_suffix(storeindex,MERSUFFIX,
"wb",err);
if (state->merindexfpout == NULL)
{
haserr = true;
} else
{
if (state->storecounts)
{
state->countsfilefpout
= gt_fa_fopen_with_suffix(storeindex,COUNTSSUFFIX,"wb",err);
if (state->countsfilefpout == NULL)
{
haserr = true;
}
}
}
state->processoccurrencecount = outputsortedstring2index;
}
if (!haserr)
{
if (gt_depthfirstesa(ssar,
tyr_allocateDfsinfo,
tyr_freeDfsinfo,
tyr_processleafedge,
NULL,
tyr_processcompletenode,
tyr_assignleftmostleaf,
tyr_assignrightmostleaf,
(Dfsstate*) state,
logger,
err) != 0)
{
haserr = true;
}
if (strlen(storeindex) == 0)
{
showfinalstatistics(state,inputindex,logger);
}
}
if (!haserr)
{
if (state->countsfilefpout != NULL)
{
gt_logger_log(logger,"write "GT_WU" mercounts > "GT_WU
" to file \"%s%s\"",
state->largecounts.nextfreeLargecount,
(GtUword) MAXSMALLMERCOUNT,
storeindex,
COUNTSSUFFIX);
gt_xfwrite(state->largecounts.spaceLargecount, sizeof (Largecount),
(size_t) state->largecounts.nextfreeLargecount,
state->countsfilefpout);
}
}
if (!haserr)
{
gt_logger_log(logger,"number of "GT_WU"-mers in index: "GT_WU"",
mersize,
state->countoutputmers);
gt_logger_log(logger,"index size: %.2f megabytes\n",
GT_MEGABYTES(state->countoutputmers * state->sizeofbuffer +
sizeof (GtUword) * EXTRAINTEGERS));
}
}
/* now out EXTRAINTEGERS integer values */
if (!haserr && state->merindexfpout != NULL)
{
outputbytewiseUlongvalue(state->merindexfpout,
(GtUword) state->mersize);
outputbytewiseUlongvalue(state->merindexfpout,(GtUword) alphasize);
}
gt_fa_xfclose(state->merindexfpout);
gt_fa_xfclose(state->countsfilefpout);
GT_FREEARRAY(&state->occdistribution,Countwithpositions);
gt_free(state->currentmer);
gt_free(state->bytebuffer);
GT_FREEARRAY(&state->largecounts,Largecount);
gt_encseq_reader_delete(state->esrspace);
gt_free(state);
return haserr ? -1 : 0;
}
static void showoptions(const Suffixeratoroptions *so)
{
GtUword i;
Sfxstrategy sfxtrategy;
GtLogger *logger = gt_logger_new(true, GT_LOGGER_DEFLT_PREFIX, stdout);
if (gt_str_length(gt_encseq_options_smap_value(so->encopts)) > 0)
{
gt_logger_log_force(logger, "smap=\"%s\"",
gt_str_get(gt_encseq_options_smap_value(so->encopts)));
}
if (gt_encseq_options_dna_value(so->encopts))
{
gt_logger_log_force(logger, "dna=yes");
}
if (gt_encseq_options_protein_value(so->encopts))
{
gt_logger_log_force(logger, "protein=yes");
}
if (gt_encseq_options_plain_value(so->encopts))
{
gt_logger_log_force(logger, "plain=yes");
}
gt_logger_log_force(logger, "indexname=\"%s\"",
gt_str_get(so->indexname));
if (gt_index_options_prefixlength_value(so->idxopts)
== GT_PREFIXLENGTH_AUTOMATIC)
{
gt_logger_log_force(logger, "prefixlength=automatic");
} else
{
gt_logger_log_force(logger, "prefixlength=%u",
gt_index_options_prefixlength_value(so->idxopts));
}
sfxtrategy = gt_index_options_sfxstrategy_value(so->idxopts);
gt_logger_log_force(logger, "storespecialcodes=%s",
sfxtrategy.storespecialcodes ? "true" : "false");
for (i=0; i<gt_str_array_size(so->db); i++)
{
gt_logger_log_force(logger, "inputfile["GT_WU"]=%s", i,
gt_str_array_get(so->db, i));
}
if (gt_str_length(so->inputindex) > 0)
{
gt_logger_log_force(logger, "inputindex=%s",
gt_str_get(so->inputindex));
}
gt_assert(gt_str_length(so->indexname) > 0);
gt_logger_log_force(logger, "indexname=%s",
gt_str_get(so->indexname));
gt_logger_log_force(logger, "outtistab=%s,outsuftab=%s,outlcptab=%s,"
"outbwttab=%s,outbcktab=%s,outdestab=%s,"
"outsdstab=%s,outssptab=%s,outkystab=%s",
gt_encseq_options_tis_value(so->encopts) ? "true" : "false",
gt_index_options_outsuftab_value(so->idxopts) ? "true" : "false",
gt_index_options_outlcptab_value(so->idxopts) ? "true" : "false",
gt_index_options_outbwttab_value(so->idxopts) ? "true" : "false",
gt_index_options_outbcktab_value(so->idxopts) ? "true" : "false",
gt_encseq_options_des_value(so->encopts) ? "true" : "false",
gt_encseq_options_sds_value(so->encopts) ? "true" : "false",
gt_encseq_options_ssp_value(so->encopts) ? "true" : "false",
gt_index_options_outkystab_value(so->idxopts) ?
(gt_index_options_outkyssort_value(so->idxopts) ?
"true with sort" : "true") :
"false");
if (gt_index_options_maximumspace_value(so->idxopts) > 0)
{
gt_assert(gt_index_options_numofparts_value(so->idxopts) == 1U);
gt_logger_log_force(logger, "maximumspace=%.0f MB",
GT_MEGABYTES(gt_index_options_maximumspace_value(so->idxopts)));
} else
{
gt_logger_log_force(logger, "parts=%u",
gt_index_options_numofparts_value(so->idxopts));
}
gt_logger_log_force(logger, "maxinsertionsort="GT_WU"",
sfxtrategy.maxinsertionsort);
gt_logger_log_force(logger, "maxbltriesort="GT_WU"",
sfxtrategy.maxbltriesort);
gt_logger_log_force(logger, "maxcountingsort="GT_WU"",
sfxtrategy.maxcountingsort);
gt_logger_log_force(logger, "lcpdist=%s",
gt_index_options_lcpdist_value(so->idxopts)
? "true"
: "false");
gt_logger_delete(logger);
}