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; }