void gt_timer_show_progress_final(GT_UNUSED GtTimer *t, GT_UNUSED FILE *fp)
{
#ifndef _WIN32
struct timeval elapsed_tv, elapsed_user_tv, elapsed_sys_tv;
const char overall_desc[] = "overall";
gt_timer_stop(t);
if (!t->omit_last_stage) {
timeval_subtract(&elapsed_tv, &t->stop_tv, &t->start_tv);
timeval_subtract(&elapsed_user_tv, &t->stop_ru.ru_utime,
&t->start_ru.ru_utime);
timeval_subtract(&elapsed_sys_tv, &t->stop_ru.ru_stime,
&t->start_ru.ru_stime);
gt_timer_print_progress_report(t, &elapsed_tv, &elapsed_user_tv,
&elapsed_sys_tv, t->statedesc, fp);
}
timeval_subtract(&elapsed_tv, &t->stop_tv, &t->gstart_tv);
timeval_subtract(&elapsed_user_tv, &t->stop_ru.ru_utime,
&t->gstart_ru.ru_utime);
timeval_subtract(&elapsed_sys_tv, &t->stop_ru.ru_stime,
&t->gstart_ru.ru_stime);
gt_timer_print_progress_report(t, &elapsed_tv, &elapsed_user_tv,
&elapsed_sys_tv, overall_desc, fp);
#else
/* XXX */
fprintf(stderr, "gt_timer_show_progress_final() not implemented\n");
exit(EXIT_FAILURE);
#endif
}
void gt_timer_show_formatted(GtTimer *t, const char *fmt, FILE *fp)
{
struct timeval elapsed_tv;
if (t->state == TIMER_RUNNING)
gt_timer_stop(t);
gt_assert(t->state == TIMER_STOPPED);
timeval_subtract(&elapsed_tv, &t->stop_tv, &t->gstart_tv);
fprintf(fp, fmt,
(long)(elapsed_tv.tv_sec),
(long)(elapsed_tv.tv_usec),
(long)(t->stop_ru.ru_utime.tv_sec - t->start_ru.ru_utime.tv_sec),
(long)(t->stop_ru.ru_stime.tv_sec - t->start_ru.ru_stime.tv_sec));
}
void gt_timer_show_formatted(GtTimer *t, const char *fmt, FILE *fp)
{
#ifndef _WIN32
struct timeval elapsed_tv;
if (t->state == TIMER_RUNNING)
gt_timer_stop(t);
gt_assert(t->state == TIMER_STOPPED);
timeval_subtract(&elapsed_tv, &t->stop_tv, &t->gstart_tv);
fprintf(fp, fmt,
(GtWord)(elapsed_tv.tv_sec),
(GtWord)(elapsed_tv.tv_usec),
(GtWord)(t->stop_ru.ru_utime.tv_sec - t->start_ru.ru_utime.tv_sec),
(GtWord)(t->stop_ru.ru_stime.tv_sec - t->start_ru.ru_stime.tv_sec));
#else
/* XXX */
fprintf(stderr, "gt_timer_show_formatted() not implemented\n");
exit(EXIT_FAILURE);
#endif
}
void gt_timer_get_formatted(GtTimer *t, const char *fmt, GtStr *str)
{
#ifndef _WIN32
struct timeval elapsed_tv;
char buf[BUFSIZ];
if (t->state == TIMER_RUNNING)
gt_timer_stop(t);
gt_assert(t->state == TIMER_STOPPED);
timeval_subtract(&elapsed_tv, &t->stop_tv, &t->gstart_tv);
(void) snprintf(buf, BUFSIZ-1, fmt,
(GtWord)(elapsed_tv.tv_sec),
(GtWord)(elapsed_tv.tv_usec),
(GtWord)(t->stop_ru.ru_utime.tv_sec - t->start_ru.ru_utime.tv_sec),
(GtWord)(t->stop_ru.ru_stime.tv_sec - t->start_ru.ru_stime.tv_sec));
gt_str_append_cstr(str, buf);
#else
/* XXX */
fprintf(stderr, "gt_timer_get_formatted() not implemented\n");
exit(EXIT_FAILURE);
#endif
}
void gt_timer_show_progress_final(GtTimer *t, FILE *fp)
{
struct timeval elapsed_tv, elapsed_user_tv, elapsed_sys_tv;
const char overall_desc[] = "overall";
gt_timer_stop(t);
if (!t->omit_last_stage) {
timeval_subtract(&elapsed_tv, &t->stop_tv, &t->start_tv);
timeval_subtract(&elapsed_user_tv, &t->stop_ru.ru_utime,
&t->start_ru.ru_utime);
timeval_subtract(&elapsed_sys_tv, &t->stop_ru.ru_stime,
&t->start_ru.ru_stime);
gt_timer_print_progress_report(t, &elapsed_tv, &elapsed_user_tv,
&elapsed_sys_tv, t->statedesc, fp);
}
timeval_subtract(&elapsed_tv, &t->stop_tv, &t->gstart_tv);
timeval_subtract(&elapsed_user_tv, &t->stop_ru.ru_utime,
&t->gstart_ru.ru_utime);
timeval_subtract(&elapsed_sys_tv, &t->stop_ru.ru_stime,
&t->gstart_ru.ru_stime);
gt_timer_print_progress_report(t, &elapsed_tv, &elapsed_user_tv,
&elapsed_sys_tv, overall_desc, fp);
}
static int gt_speck_runner(int argc, const char **argv, int parsed_args,
void *tool_arguments, GtError *err)
{
GtNodeStream *gff3_in_stream = NULL, *checker_stream = NULL,
*a_in_stream = NULL, *a_out_stream = NULL,
*feature_stream = NULL, *sort_stream = NULL,
*last_stream = NULL;
GtNodeVisitor *spec_visitor = NULL;
GtSpecResults *res = NULL;
GtFeatureIndex *fi = NULL;
GtTimer *t = NULL;
GtRegionMapping *rm = NULL;
GtArray *arr = gt_array_new(sizeof (GtFeatureNode*));
SpeccheckArguments *arguments = tool_arguments;
int had_err = 0;
gt_error_check(err);
res = gt_spec_results_new();
gt_assert(res);
t = gt_timer_new();
gt_assert(t);
spec_visitor = gt_spec_visitor_new(gt_str_get(arguments->specfile), res,
err);
if (!spec_visitor)
return -1;
/* add region mapping if given */
if (gt_seqid2file_option_used(arguments->s2fi)) {
rm = gt_seqid2file_region_mapping_new(arguments->s2fi, err);
if (!rm)
had_err = -1;
if (!had_err)
gt_spec_visitor_add_region_mapping((GtSpecVisitor*) spec_visitor, rm);
}
/* set runtime error behaviour */
if (arguments->fail_hard)
gt_spec_visitor_fail_on_runtime_error((GtSpecVisitor*) spec_visitor);
else
gt_spec_visitor_report_runtime_errors((GtSpecVisitor*) spec_visitor);
/* redirect warnings */
gt_warning_set_handler(gt_speck_record_warning, res);
last_stream = gff3_in_stream = gt_gff3_in_stream_new_unsorted(
argc - parsed_args,
argv + parsed_args);
gt_assert(gff3_in_stream);
gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream*) gff3_in_stream);
/* insert sort stream if requested */
if (arguments->sort) {
last_stream = sort_stream = gt_sort_stream_new(last_stream);
}
/* if -provideindex is given, collect input features and index them first */
if (arguments->provideindex) {
fi = gt_feature_index_memory_new();
gt_assert(fi);
last_stream = feature_stream = gt_feature_stream_new(last_stream, fi);
gt_assert(feature_stream);
last_stream = a_out_stream = gt_array_out_stream_all_new(last_stream, arr,
err);
if (!a_out_stream)
had_err = -1;
gt_timer_start(t);
if (!had_err)
had_err = gt_node_stream_pull(last_stream, err);
if (!had_err) {
gt_spec_visitor_add_feature_index((GtSpecVisitor*) spec_visitor,
gt_feature_index_ref(fi));
last_stream = a_in_stream = gt_array_in_stream_new(arr, NULL, err);
if (!a_in_stream)
had_err = -1;
}
} else {
gt_timer_start(t);
}
if (!had_err) {
checker_stream = gt_visitor_stream_new(last_stream, spec_visitor);
gt_assert(checker_stream);
}
/* perform checking */
if (!had_err)
had_err = gt_node_stream_pull(checker_stream, err);
gt_timer_stop(t);
/* reset warnings output */
gt_warning_set_handler(gt_warning_default_handler, NULL);
/* output results */
if (!had_err)
gt_spec_results_report(res, arguments->outfp,
gt_str_get(arguments->specfile),
arguments->verbose, arguments->colored,
!arguments->allexpects);
if (!had_err)
gt_timer_show_formatted(t, "Finished in " GT_WD ".%06ld s.\n", stderr);
/* free */
gt_node_stream_delete(gff3_in_stream);
gt_node_stream_delete(a_in_stream);
gt_node_stream_delete(a_out_stream);
gt_node_stream_delete(checker_stream);
gt_node_stream_delete(feature_stream);
gt_node_stream_delete(sort_stream);
gt_spec_results_delete(res);
gt_feature_index_delete(fi);
gt_timer_delete(t);
gt_array_delete(arr);
return had_err;
}
/*call function with linear gap costs for all given sequences */
static int gt_all_against_all_alignment_check(bool affine,
GtAlignment *align,
const GtLinspaceArguments *arguments,
GtLinspaceManagement *spacemanager,
const GtScoreHandler *scorehandler,
const GtUchar *characters,
GtUchar wildcardshow,
const GtSequenceTable *sequence_table1,
const GtSequenceTable *sequence_table2,
GtWord left_dist,
GtWord right_dist,
GtTimer *linspacetimer,
GtError *err)
{
int had_err = 0;
const GtUchar *useq, *vseq;
GtUword i, j, ulen, vlen;
gt_error_check(err);
if (linspacetimer != NULL)
{
gt_timer_start(linspacetimer);
}
for (i = 0; !had_err && i < sequence_table1->size; i++)
{
ulen = gt_str_length(sequence_table1->seqarray[i]);
useq = (const GtUchar*) gt_str_get(sequence_table1->seqarray[i]);
for (j = 0; j< sequence_table2->size; j++)
{
vlen = gt_str_length(sequence_table2->seqarray[j]);
vseq = (const GtUchar*) gt_str_get(sequence_table2->seqarray[j]);
gt_alignment_reset(align);
if (arguments->global)
{
if (arguments->diagonal)
{
if (gt_str_array_size(arguments->diagonalbonds) == 0)
{
left_dist = LEFT_DIAGONAL_SHIFT(arguments->similarity, ulen, vlen);
right_dist = RIGHT_DIAGONAL_SHIFT(arguments->similarity, ulen,
vlen);
}
if ((left_dist > MIN(0, (GtWord)vlen-(GtWord)ulen))||
(right_dist < MAX(0, (GtWord)vlen-(GtWord)ulen)))
{
gt_error_set(err, "ERROR: invalid diagonalband for global "
"alignment (ulen: "GT_WU", vlen: "GT_WU")\n"
"left_dist <= MIN(0, vlen-ulen) and "
"right_dist >= MAX(0, vlen-ulen)", ulen, vlen);
had_err = 1;
}
if (!had_err)
{
(affine ? gt_diagonalbandalign_affinegapcost_compute_generic
: gt_diagonalbandalign_compute_generic)
(spacemanager, scorehandler, align,
useq, 0, ulen, vseq, 0, vlen,
left_dist, right_dist);
}
} else
{
(affine ? gt_linearalign_affinegapcost_compute_generic
: gt_linearalign_compute_generic)
(spacemanager, scorehandler, align,
useq, 0, ulen, vseq, 0, vlen);
}
}
else if (arguments->local)
{
(affine ? gt_linearalign_affinegapcost_compute_local_generic
: gt_linearalign_compute_local_generic)
(spacemanager, scorehandler, align,
useq, 0, ulen, vseq, 0, vlen);
}
/* show alignment*/
if (!had_err)
{
gt_assert(align != NULL);
if (!strcmp(gt_str_get(arguments->outputfile),"stdout"))
{
alignment_show_with_sequences(useq, ulen, vseq, vlen, align,
characters,
wildcardshow, arguments->showscore,
!arguments->scoreonly,
arguments->showsequences,
arguments->global,
scorehandler, stdout);
} else
{
FILE *fp = gt_fa_fopen_func(gt_str_get(arguments->outputfile),
"a", __FILE__,__LINE__,err);
if (fp == NULL)
{
had_err = -1;
} else
{
alignment_show_with_sequences(useq, ulen, vseq, vlen, align,
characters, wildcardshow,
arguments->showscore,
!arguments->scoreonly,
arguments->showsequences,
arguments->global, scorehandler,fp);
gt_fa_fclose(fp);
}
}
}
}
}
if (linspacetimer != NULL)
{
gt_timer_stop(linspacetimer);
}
if (!had_err && arguments->wildcardshow)
{
printf("# wildcards are represented by %c\n", wildcardshow);
}
return had_err;
}
static int gt_kmer_database_runner(GT_UNUSED int argc, const char **argv,
int parsed_args, void *tool_arguments,
GtError *err)
{
GtKmerDatabaseArguments *arguments = tool_arguments;
int had_err = 0;
GtEncseq *es;
GtUword es_length,
nu_kmer_codes = 0;
GtKmerDatabase *compare_db = NULL,
*db = NULL;
GtLogger *logger;
FILE *fp = NULL;
GtHashmap *kmer_hash = NULL;
GtTimer *timer = NULL;
gt_error_check(err);
gt_assert(arguments);
if (arguments->use_hash)
kmer_hash = gt_hashmap_new(GT_HASH_DIRECT, NULL,
(GtFree) gt_kmer_database_delete_hash_value);
if (arguments->bench)
timer = gt_timer_new_with_progress_description("loading encoded sequence");
logger = gt_logger_new(arguments->verbose, GT_LOGGER_DEFLT_PREFIX, stderr);
if (arguments->verbose && gt_str_length(arguments->print_filename) > 0UL) {
fp = gt_fa_fopen(gt_str_get(arguments->print_filename), "w", err);
gt_logger_set_target(logger, fp);
}
if (!had_err) {
GtEncseqLoader *es_l;
if (arguments->bench)
gt_timer_start(timer);
es_l = gt_encseq_loader_new();
es = gt_encseq_loader_load(es_l, argv[parsed_args], err);
if (arguments->bench)
gt_timer_show_progress(timer, "saving kmers (+iterating over file)",
stdout);
if (es == NULL) {
had_err = -1;
}
gt_encseq_loader_delete(es_l);
}
if (!had_err) {
es_length = gt_encseq_total_length(es);
if (es_length < (GtUword) arguments->kmersize) {
gt_error_set(err, "Input is too short for used kmersize. File length: "
GT_WU " kmersize: %u", es_length, arguments->kmersize);
had_err = -1;
}
}
if (!had_err) {
GtAlphabet *alphabet;
alphabet = gt_encseq_alphabet(es);
if (arguments->bench)
nu_kmer_codes = gt_power_for_small_exponents(
gt_alphabet_num_of_chars(alphabet),
arguments->kmersize);
if (!arguments->merge_only && !arguments->use_hash && !arguments->bench) {
compare_db = gt_kmer_database_new(gt_alphabet_num_of_chars(alphabet),
arguments->kmersize, arguments->sb_size, es);
}
if (!arguments->use_hash) {
db = gt_kmer_database_new(gt_alphabet_num_of_chars(alphabet),
arguments->kmersize,
arguments->sb_size, es);
if (arguments->cutoff) {
if (arguments->mean_cutoff)
gt_kmer_database_use_mean_cutoff(db, (GtUword) 2,
arguments->cutoff_value);
else
gt_kmer_database_set_cutoff(db, arguments->cutoff_value);
if (!arguments->prune)
gt_kmer_database_set_prune(db);
}
}
}
if (!had_err) {
GtUword startpos = 0,
endpos;
GtKmercodeiterator *iter;
const GtKmercode *kmercode = NULL;
iter = gt_kmercodeiterator_encseq_new(es, GT_READMODE_FORWARD,
arguments->kmersize, 0);
while (!had_err && startpos < es_length - (arguments->kmersize - 1)) {
GtUword startpos_add_kmer = startpos;
if (arguments->merge_only) {
endpos = startpos + (arguments->kmersize - 1) +
(gt_rand_max((arguments->sb_size - 1) * 2));
if (endpos > es_length)
endpos = es_length;
}
else {
endpos = startpos + (arguments->kmersize - 1) +
(gt_rand_max(arguments->sb_size - 1));
}
gt_kmercodeiterator_reset(iter, GT_READMODE_FORWARD, startpos);
while ((kmercode = gt_kmercodeiterator_encseq_next(iter)) != NULL &&
startpos_add_kmer <= endpos - (arguments->kmersize - 1)) {
if (!arguments->merge_only && !arguments->use_hash &&
!kmercode->definedspecialposition && !arguments->bench) {
gt_kmer_database_add_kmer(compare_db, kmercode->code,
startpos_add_kmer);
}
if (arguments->use_hash && !kmercode->definedspecialposition) {
gt_kmer_database_add_to_hash(kmer_hash, kmercode->code,
startpos_add_kmer);
}
startpos_add_kmer++;
}
if (!arguments->use_hash) {
gt_kmer_database_add_interval(db, startpos, endpos);
gt_kmer_database_print_buffer(db, logger);
if (!arguments->bench)
had_err = gt_kmer_database_check_consistency(db, err);
}
startpos = endpos + 1;
}
if (!arguments->use_hash) {
gt_kmer_database_flush(db);
gt_kmer_database_print_buffer(db, logger);
if (!had_err && !arguments->bench)
had_err = gt_kmer_database_check_consistency(db, err);
if (!arguments->merge_only && !had_err && !arguments->bench)
had_err = gt_kmer_database_check_consistency(compare_db, err);
if (!arguments->merge_only && !arguments->bench)
gt_kmer_database_print(compare_db, logger, true);
if (!arguments->merge_only && !had_err && !arguments->bench)
had_err = gt_kmer_database_compare(compare_db, db, err);
gt_kmer_database_print(db, logger, true);
}
gt_kmercodeiterator_delete(iter);
}
if (arguments->bench) {
GtKmerStartpos pos;
GtArrayGtUword *pos_hash;
GtUword rand_access = (GtUword) 50000000,
rand_code,
i,
sum = 0;
gt_timer_show_progress(timer, "random access", stdout);
for (i = 0; i < rand_access; i++) {
rand_code = gt_rand_max(nu_kmer_codes - 1);
if (arguments->use_hash) {
pos_hash = gt_hashmap_get(kmer_hash, (const void *) rand_code);
if (pos_hash != NULL)
sum += pos_hash->spaceGtUword[pos_hash->nextfreeGtUword - 1];
}
else {
pos = gt_kmer_database_get_startpos(db, rand_code);
if (pos.no_positions > 0)
sum += pos.startpos[pos.no_positions - 1];
}
}
printf("sum: " GT_WU "\n", sum);
gt_timer_show_progress(timer, "", stdout);
gt_timer_stop(timer);
gt_timer_delete(timer);
}
if (arguments->use_hash)
gt_hashmap_delete(kmer_hash);
gt_encseq_delete(es);
if (!arguments->use_hash)
gt_kmer_database_delete(db);
if (!arguments->merge_only && !arguments->bench)
gt_kmer_database_delete(compare_db);
gt_logger_delete(logger);
gt_fa_fclose(fp);
return had_err;
}
static int gt_speck_runner(int argc, const char **argv, int parsed_args,
void *tool_arguments, GtError *err)
{
GtNodeStream *gff3_in_stream = NULL, *checker_stream = NULL,
*a_in_stream = NULL, *a_out_stream = NULL,
*feature_stream = NULL, *sort_stream = NULL,
*last_stream = NULL;
GtNodeVisitor *spec_visitor = NULL;
GtSpecResults *res = NULL;
GtFeatureIndex *fi = NULL;
GtTypeChecker *type_checker = NULL;
GtTimer *t = NULL;
GtRegionMapping *rm = NULL;
GtArray *arr = gt_array_new(sizeof (GtFeatureNode*));
GtStr *prog, *speclib;
SpeccheckArguments *arguments = tool_arguments;
int had_err = 0;
gt_error_check(err);
res = gt_spec_results_new();
gt_assert(res);
if (gt_file_exists(gt_str_get(arguments->format))) {
speclib = gt_str_ref(arguments->format);
} else {
prog = gt_str_new();
gt_str_append_cstr_nt(prog, gt_error_get_progname(err),
gt_cstr_length_up_to_char(gt_error_get_progname(err), ' '));
speclib = gt_get_gtdata_path(gt_str_get(prog), NULL);
gt_str_delete(prog);
gt_str_append_cstr(speclib, "/spec/output_drivers/");
gt_str_append_str(speclib, arguments->format);
if (!gt_file_exists(gt_str_get(speclib))) {
gt_error_set(err, "output driver file \"%s\" does not exist",
gt_str_get(speclib));
had_err = -1;
}
}
if (!had_err) {
spec_visitor = gt_spec_visitor_new(gt_str_get(arguments->specfile), res,
err);
if (!spec_visitor) {
gt_spec_results_delete(res);
return -1;
}
}
t = gt_timer_new();
gt_assert(t);
/* add region mapping if given */
if (!had_err && gt_seqid2file_option_used(arguments->s2fi)) {
rm = gt_seqid2file_region_mapping_new(arguments->s2fi, err);
if (!rm)
had_err = -1;
if (!had_err)
gt_spec_visitor_add_region_mapping((GtSpecVisitor*) spec_visitor, rm);
}
/* set type checker if necessary */
if (!had_err && gt_typecheck_info_option_used(arguments->tci)) {
type_checker = gt_typecheck_info_create_type_checker(arguments->tci, err);
if (!type_checker)
had_err = -1;
if (!had_err)
gt_spec_visitor_add_type_checker((GtSpecVisitor*) spec_visitor,
type_checker);
}
if (!had_err) {
/* set runtime error behaviour */
if (arguments->fail_hard)
gt_spec_visitor_fail_on_runtime_error((GtSpecVisitor*) spec_visitor);
else
gt_spec_visitor_report_runtime_errors((GtSpecVisitor*) spec_visitor);
/* redirect warnings */
gt_warning_set_handler(gt_speck_record_warning, res);
last_stream = gff3_in_stream = gt_gff3_in_stream_new_unsorted(
argc - parsed_args,
argv + parsed_args);
gt_assert(gff3_in_stream);
gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream*) gff3_in_stream);
/* insert sort stream if requested */
if (arguments->sort) {
last_stream = sort_stream = gt_sort_stream_new(last_stream);
}
/* if -provideindex is given, collect input features and index them first */
if (arguments->provideindex) {
fi = gt_feature_index_memory_new();
gt_assert(fi);
last_stream = feature_stream = gt_feature_stream_new(last_stream, fi);
gt_assert(feature_stream);
last_stream = a_out_stream = gt_array_out_stream_all_new(last_stream, arr,
err);
if (!a_out_stream)
had_err = -1;
gt_timer_start(t);
if (!had_err)
had_err = gt_node_stream_pull(last_stream, err);
if (!had_err) {
gt_spec_visitor_add_feature_index((GtSpecVisitor*) spec_visitor,
gt_feature_index_ref(fi));
last_stream = a_in_stream = gt_array_in_stream_new(arr, NULL, err);
if (!a_in_stream)
had_err = -1;
}
} else {
gt_timer_start(t);
}
if (!had_err) {
checker_stream = gt_visitor_stream_new(last_stream, spec_visitor);
gt_assert(checker_stream);
}
/* perform checking */
if (!had_err)
had_err = gt_node_stream_pull(checker_stream, err);
gt_timer_stop(t);
/* reset warnings output */
gt_warning_set_handler(gt_warning_default_handler, NULL);
/* output results */
if (!had_err) {
GtStr *runtime = gt_str_new();
gt_timer_get_formatted(t, GT_WD ".%06ld", runtime);
had_err = gt_spec_results_render_template(res, gt_str_get(speclib),
arguments->outfp,
gt_str_get(arguments->specfile),
arguments->verbose,
arguments->colored,
gt_str_get(runtime), err);
gt_str_delete(runtime);
}
}
/* free */
gt_node_stream_delete(gff3_in_stream);
gt_node_stream_delete(a_in_stream);
gt_node_stream_delete(a_out_stream);
gt_node_stream_delete(checker_stream);
gt_node_stream_delete(feature_stream);
gt_node_stream_delete(sort_stream);
gt_spec_results_delete(res);
gt_feature_index_delete(fi);
gt_type_checker_delete(type_checker);
gt_timer_delete(t);
gt_array_delete(arr);
gt_str_delete(speclib);
return had_err;
}
