X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fbatchtest.c;h=8d4be06ea2b0c07afee533ee265af86bc99a605c;hb=728d0c3ea0f5f236770ac2f330dccada59c59366;hp=598eb7fd4efc61700bfd4de9246601796508b1a3;hpb=911b7a3cb75980b888435aa13d2902f202048944;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/batchtest.c b/ltt/branches/poly/lttv/lttv/batchtest.c index 598eb7fd..8d4be06e 100644 --- a/ltt/branches/poly/lttv/lttv/batchtest.c +++ b/ltt/branches/poly/lttv/lttv/batchtest.c @@ -20,7 +20,11 @@ all the events in the main tracefile while testing the speed and functionality of the state and stats computations. */ +#ifdef HAVE_CONFIG_H +#include +#endif +#include #include #include #include @@ -32,6 +36,9 @@ #include #include #include +#include + +#define __UNUSED__ __attribute__((__unused__)) static LttvTraceset *traceset; @@ -42,8 +49,9 @@ static LttvHooks *after_trace, *before_tracefile, *after_tracefile, - *before_event, - *after_event, + //*before_event, + //*after_event, + *event_hook, *main_hooks; static char *a_trace; @@ -68,8 +76,12 @@ static gboolean a_test5, a_test6, a_test7, + a_test8, a_test_all; +static GQuark QUARK_BLOCK_START, + QUARK_BLOCK_END; + LttEventPosition *a_event_position; typedef struct _save_state { @@ -83,13 +95,16 @@ typedef struct _save_state { } SaveState; -static void lttv_trace_option(void *hook_data) +static void lttv_trace_option(void __UNUSED__ *hook_data) { LttTrace *trace; trace = ltt_trace_open(a_trace); - if(trace == NULL) g_critical("cannot open trace %s", a_trace); - lttv_traceset_add(traceset, lttv_trace_new(trace)); + if(trace == NULL) { + g_critical("cannot open trace %s", a_trace); + } else { + lttv_traceset_add(traceset, lttv_trace_new(trace)); + } } static double get_time() @@ -104,11 +119,17 @@ static double run_one_test(LttvTracesetState *ts, LttTime start, LttTime end) { double t0, t1; - int i; + unsigned int i; - lttv_traceset_context_add_hooks(&ts->parent, - before_traceset, after_traceset, NULL, before_trace, after_trace, - NULL, before_tracefile, after_tracefile, NULL, before_event, after_event); + //lttv_traceset_context_add_hooks(&ts->parent, + //before_traceset, after_traceset, NULL, before_trace, after_trace, + //NULL, before_tracefile, after_tracefile, NULL, before_event, after_event); + lttv_process_traceset_begin(&ts->parent, + before_traceset, + before_trace, + before_tracefile, + event_hook, + NULL); for(i = 0 ; i < lttv_traceset_number(traceset) ; i++) { ((LttvTraceState *)(ts->parent.traces[i]))->save_interval =a_save_interval; @@ -116,58 +137,99 @@ static double run_one_test(LttvTracesetState *ts, LttTime start, LttTime end) t0 = get_time(); lttv_state_traceset_seek_time_closest(ts, start); - lttv_process_traceset(&ts->parent, end, G_MAXULONG); + //lttv_process_traceset(&ts->parent, end, G_MAXULONG); + lttv_process_traceset_middle(&ts->parent, + end, + G_MAXULONG, + NULL); t1 = get_time(); - lttv_traceset_context_remove_hooks(&ts->parent, - before_traceset, after_traceset, NULL, before_trace, after_trace, - NULL, before_tracefile, after_tracefile, NULL, before_event, after_event); + //lttv_traceset_context_remove_hooks(&ts->parent, + //before_traceset, after_traceset, NULL, before_trace, after_trace, + //NULL, before_tracefile, after_tracefile, NULL, before_event, after_event); + lttv_process_traceset_end(&ts->parent, + after_traceset, + after_trace, + after_tracefile, + event_hook, + NULL); return t1 - t0; } -gboolean trace_event(void *hook_data, void *call_data) +gboolean trace_event(void __UNUSED__ *hook_data, void *call_data) { LttvTracefileState *tfs = (LttvTracefileState *)call_data; - guint nb_block, nb_event; + guint nb_block, offset; - LttTracefile *tf; + guint64 tsc; - ltt_event_position(tfs->parent.e, a_event_position); - ltt_event_position_get(a_event_position, &nb_block, &nb_event, &tf); - fprintf(stderr,"Event %s %lu.%09lu [%lu %lu]\n", - ltt_eventtype_name(ltt_event_eventtype(tfs->parent.e)), + LttTracefile *tf; + LttEvent *e = ltt_tracefile_get_event(tfs->parent.tf); + ltt_event_position(e, a_event_position); + ltt_event_position_get(a_event_position, &tf, &nb_block, &offset, &tsc); + fprintf(stderr,"Event %s %lu.%09lu [%u 0x%x tsc %llu]\n", + g_quark_to_string(ltt_eventtype_name(ltt_event_eventtype(e))), tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec, - nb_block, nb_event); + nb_block, offset, tsc); return FALSE; } +static LttTime count_previous_time = { 0, 0 }; -gboolean count_event(void *hook_data, void *call_data) +gboolean count_event(void *hook_data, void __UNUSED__ *call_data) { + LttvTracefileState *tfs = (LttvTracefileState *)call_data; + LttTracefile *tracefile = tfs->parent.tf; + guint nb_block, offset; + LttTracefile *tf_pos; + guint64 tsc; + LttEvent * event = ltt_tracefile_get_event(tracefile); + LttTime time; guint *pcount = (guint *)hook_data; (*pcount)++; + + time = ltt_event_time(event); + ltt_event_position(event, a_event_position); + ltt_event_position_get(a_event_position, &tf_pos, &nb_block, &offset, &tsc); + + if(ltt_time_compare(time, count_previous_time) < 0) { + g_warning("Time decreasing trace %s tracefile %s cpu %u position %u/0x%x", + g_quark_to_string(ltt_trace_name(ltt_tracefile_get_trace(tracefile))), + g_quark_to_string(ltt_tracefile_name(tracefile)), + ltt_tracefile_num(tracefile), nb_block, offset); + g_warning("last time %lu.%lu vs current %lu.%lu", + count_previous_time.tv_sec, count_previous_time.tv_nsec, + time.tv_sec, time.tv_nsec); + } + count_previous_time = time; + + + return FALSE; } gboolean save_state_copy_event(void *hook_data, void *call_data) { - SaveState *save_state = (SaveState *)hook_data; + SaveState __UNUSED__ *save_state = (SaveState *)hook_data; LttvTracefileState *tfs = (LttvTracefileState *)call_data; LttvTraceState *ts = (LttvTraceState *)tfs->parent.t_context; + LttEvent *e = ltt_tracefile_get_event(tfs->parent.tf); + GString *filename; FILE *fp; - if(ts->nb_event == 0 && strcmp(ltt_eventtype_name( - ltt_event_eventtype(tfs->parent.e)), "block_start") == 0) { + if(ts->nb_event == 0 && + ltt_eventtype_name(ltt_event_eventtype(e)) + == QUARK_BLOCK_START) { if(a_save_sample != NULL) { filename = g_string_new(""); g_string_printf(filename, "%s.copy.%lu.%09lu.xml", a_save_sample, @@ -216,37 +278,134 @@ gboolean save_state_event(void *hook_data, void *call_data) } -static gboolean process_traceset(void *hook_data, void *call_data) +static void sanitize_name(gchar *name) { - LttvTracesetStats *tscs; - - LttvTracesetState *ts; + while(*name != '\0') { + if(*name == '/') *name = '_'; + name++; + } + +} - LttvTracesetContext *tc; +static void compute_tracefile(LttTracefile *tracefile, void *hook_data) +{ GString *filename; - + guint nb_equal, nb_block, offset; + guint64 tsc; FILE *fp; + LttTime time, previous_time; + LttEvent *event = ltt_tracefile_get_event(tracefile); + LttFacility *facility; + LttEventType *event_type; + int err; + gchar mod_name[PATH_MAX]; + + /* start_count is always initialized in this function _if_ there is always + * a block_start before a block_end. + */ + long long unsigned cycle_count, start_count=0, delta_cycle; + + + filename = g_string_new(""); + strcpy(mod_name, g_quark_to_string(ltt_tracefile_name(tracefile))); + + sanitize_name(mod_name); + + g_warning("test %s test", g_quark_to_string(ltt_tracefile_name(tracefile))); + g_string_printf(filename, "%s.%s.%u.trace", a_dump_tracefiles, + mod_name, ltt_tracefile_num(tracefile)); + fp = fopen(filename->str, "w"); + if(fp == NULL) g_error("Cannot open %s", filename->str); + g_string_free(filename, TRUE); + err = ltt_tracefile_seek_time(tracefile, ltt_time_zero); + if(err) goto close; + + previous_time = ltt_time_zero; + nb_equal = 0; + + do { + LttTracefile *tf_pos; + facility = ltt_event_facility(event); + event_type = ltt_event_eventtype(event); + time = ltt_event_time(event); + ltt_event_position(event, a_event_position); + ltt_event_position_get(a_event_position, &tf_pos, &nb_block, &offset, &tsc); + //fprintf(fp,"%s.%s: %llu %lu.%09lu position %u/%u\n", + fprintf(fp, "%s.%s: %llu %lu.%09lu position %u/%u, tracefile %s\n", + g_quark_to_string(ltt_facility_name(facility)), + g_quark_to_string(ltt_eventtype_name(event_type)), + tsc, (unsigned long)time.tv_sec, + (unsigned long)time.tv_nsec, + nb_block, offset, + g_quark_to_string(ltt_tracefile_name(tracefile))); + + if(ltt_time_compare(time, previous_time) < 0) { + g_warning("Time decreasing trace %s tracefile %s cpu %u position %u/0x%x", + g_quark_to_string(ltt_trace_name(ltt_tracefile_get_trace(tracefile))), + g_quark_to_string(ltt_tracefile_name(tracefile)), + ltt_tracefile_num(tracefile), nb_block, offset); + g_warning("last time %lu.%lu vs current %lu.%lu", + previous_time.tv_sec, previous_time.tv_nsec, + time.tv_sec, time.tv_nsec); + } - double t; - - guint i, j, count, nb_control, nb_tracefile, nb_block, nb_event, nb_equal; +#if 0 //FIXME + if(ltt_eventtype_name(event_type) == QUARK_BLOCK_START) { + start_count = cycle_count; + start_time = time; + } + else if(ltt_eventtype_name(event_type) == QUARK_BLOCK_END) { + delta_cycle = cycle_count - start_count; + end_nsec_sec = (long long unsigned)time.tv_sec * (long long unsigned)1000000000; + end_nsec_nsec = time.tv_nsec; + end_nsec = end_nsec_sec + end_nsec_nsec; + start_nsec = (long long unsigned)start_time.tv_sec * (long long unsigned)1000000000 + (long long unsigned)start_time.tv_nsec; + delta_nsec = end_nsec - start_nsec; + cycle_per_nsec = (double)delta_cycle / (double)delta_nsec; + nsec_per_cycle = (double)delta_nsec / (double)delta_cycle; + added_nsec = (double)delta_cycle * nsec_per_cycle; + interpolated_nsec = start_nsec + added_nsec; + added_nsec2 = (double)delta_cycle / cycle_per_nsec; + interpolated_nsec2 = start_nsec + added_nsec2; + + fprintf(fp,"Time: start_count %llu, end_count %llu, delta_cycle %llu, start_nsec %llu, end_nsec_sec %llu, end_nsec_nsec %llu, end_nsec %llu, delta_nsec %llu, cycle_per_nsec %.25f, nsec_per_cycle %.25f, added_nsec %llu, added_nsec2 %llu, interpolated_nsec %llu, interpolated_nsec2 %llu\n", start_count, cycle_count, delta_cycle, start_nsec, end_nsec_sec, end_nsec_nsec, end_nsec, delta_nsec, cycle_per_nsec, nsec_per_cycle, added_nsec, added_nsec2, interpolated_nsec, interpolated_nsec2); + } + else { +#endif //0 + if(ltt_time_compare(time, previous_time) == 0) nb_equal++; + else if(nb_equal > 0) { + g_warning("Consecutive %d events with time %lu.%09lu", + nb_equal + 1, previous_time.tv_sec, previous_time.tv_nsec); + nb_equal = 0; + } + previous_time = time; + //} + } while((!ltt_tracefile_read(tracefile))); - LttTrace *trace; +close: + fclose(fp); +} - LttTracefile *tracefile, *tf; +static gboolean process_traceset(void __UNUSED__ *hook_data, + void __UNUSED__ *call_data) +{ + GString *filename; + LttvTracesetStats *tscs; - LttEvent *event; + LttvTracesetState *ts; - LttFacility *facility; + LttvTracesetContext *tc; - LttType *type; + FILE *fp; - LttEventType *event_type; + double t; - LttTime time, previous_time; + //guint count, nb_control, nb_tracefile, nb_block, nb_event; + //guint i, j, count, nb_control, nb_tracefile, nb_block, nb_event, nb_equal; + guint i, j, count; - long long unsigned cycle_count, start_count, delta_cycle; + LttTrace *trace; long long unsigned start_nsec, end_nsec, delta_nsec, added_nsec, added_nsec2; @@ -256,83 +415,26 @@ static gboolean process_traceset(void *hook_data, void *call_data) LttTime start_time; - LttTime zero_time = ltt_time_zero; - LttTime max_time = { G_MAXULONG, G_MAXULONG }; a_event_position = ltt_event_position_new(); + GData **tracefiles_groups; + + struct compute_tracefile_group_args args; + + args.func = compute_tracefile; + args.func_args = NULL; + if(a_dump_tracefiles != NULL) { for(i = 0 ; i < lttv_traceset_number(traceset) ; i++) { trace = lttv_trace(lttv_traceset_get(traceset, i)); - nb_control = ltt_trace_control_tracefile_number(trace); - nb_tracefile = nb_control + ltt_trace_per_cpu_tracefile_number(trace); - for(j = 0 ; j < nb_tracefile ; j++) { - if(j < nb_control) { - tracefile = ltt_trace_control_tracefile_get(trace,j); - } - else { - tracefile = ltt_trace_per_cpu_tracefile_get(trace,j - nb_control); - } + tracefiles_groups = ltt_trace_get_tracefiles_groups(trace); - filename = g_string_new(""); - g_string_printf(filename, "%s.%u.%u.trace", a_dump_tracefiles, i, j); - fp = fopen(filename->str, "w"); - if(fp == NULL) g_error("Cannot open %s", filename->str); - g_string_free(filename, TRUE); - ltt_tracefile_seek_time(tracefile, zero_time); - previous_time = zero_time; - nb_equal = 0; - while((event = ltt_tracefile_read(tracefile)) != NULL) { - facility = ltt_event_facility(event); - event_type = ltt_event_eventtype(event); - time = ltt_event_time(event); - cycle_count = ltt_event_cycle_count(event); - ltt_event_position(event, a_event_position); - ltt_event_position_get(a_event_position, &nb_block, &nb_event, &tf); - fprintf(fp,"%s.%s: %llu %lu.%09lu position %u/%u\n", - ltt_facility_name(facility), ltt_eventtype_name(event_type), - cycle_count, (unsigned long)time.tv_sec, - (unsigned long)time.tv_nsec, - nb_block, nb_event); - - if(ltt_time_compare(time, previous_time) < 0) { - g_warning("Time decreasing trace %d tracefile %d position %u/%u", - i, j, nb_block, nb_event); - } - - if(strcmp(ltt_eventtype_name(event_type),"block_start") == 0) { - start_count = cycle_count; - start_time = time; - } - else if(strcmp(ltt_eventtype_name(event_type),"block_end") == 0) { - delta_cycle = cycle_count - start_count; - end_nsec_sec = (long long unsigned)time.tv_sec * (long long unsigned)1000000000; - end_nsec_nsec = time.tv_nsec; - end_nsec = end_nsec_sec + end_nsec_nsec; - start_nsec = (long long unsigned)start_time.tv_sec * (long long unsigned)1000000000 + (long long unsigned)start_time.tv_nsec; - delta_nsec = end_nsec - start_nsec; - cycle_per_nsec = (double)delta_cycle / (double)delta_nsec; - nsec_per_cycle = (double)delta_nsec / (double)delta_cycle; - added_nsec = (double)delta_cycle * nsec_per_cycle; - interpolated_nsec = start_nsec + added_nsec; - added_nsec2 = (double)delta_cycle / cycle_per_nsec; - interpolated_nsec2 = start_nsec + added_nsec2; - - fprintf(fp,"Time: start_count %llu, end_count %llu, delta_cycle %llu, start_nsec %llu, end_nsec_sec %llu, end_nsec_nsec %llu, end_nsec %llu, delta_nsec %llu, cycle_per_nsec %.25f, nsec_per_cycle %.25f, added_nsec %llu, added_nsec2 %llu, interpolated_nsec %llu, interpolated_nsec2 %llu\n", start_count, cycle_count, delta_cycle, start_nsec, end_nsec_sec, end_nsec_nsec, end_nsec, delta_nsec, cycle_per_nsec, nsec_per_cycle, added_nsec, added_nsec2, interpolated_nsec, interpolated_nsec2); - } - else { - if(ltt_time_compare(time, previous_time) == 0) nb_equal++; - else if(nb_equal > 0) { - g_warning("Consecutive %d events with time %lu.%09lu", - nb_equal + 1, previous_time.tv_sec, previous_time.tv_nsec); - nb_equal = 0; - } - previous_time = time; - } - } - fclose(fp); - } + g_datalist_foreach(tracefiles_groups, + (GDataForeachFunc)compute_tracefile_group, + &args); + } } @@ -348,10 +450,10 @@ static gboolean process_traceset(void *hook_data, void *call_data) if(a_test1 || a_test_all) { count = 0; - lttv_hooks_add(after_event, count_event, &count); - t = run_one_test(ts, zero_time, max_time); - lttv_hooks_remove_data(after_event, count_event, &count); - g_warning( + lttv_hooks_add(event_hook, count_event, &count, LTTV_PRIO_DEFAULT); + t = run_one_test(ts, ltt_time_zero, max_time); + lttv_hooks_remove_data(event_hook, count_event, &count); + g_message( "Processing trace while counting events (%u events in %g seconds)", count, t); } @@ -360,9 +462,9 @@ static gboolean process_traceset(void *hook_data, void *call_data) if(a_test2 || a_test_all) { lttv_state_add_event_hooks(ts); - t = run_one_test(ts, zero_time, max_time); + t = run_one_test(ts, ltt_time_zero, max_time); lttv_state_remove_event_hooks(ts); - g_warning("Processing trace while updating state (%g seconds)", t); + g_message("Processing trace while updating state (%g seconds)", t); } /* Run through all events computing the state and writing it out @@ -382,10 +484,11 @@ static gboolean process_traceset(void *hook_data, void *call_data) save_state.position = 0; save_state.version = i; lttv_state_add_event_hooks(ts); - lttv_hooks_add(after_event, save_state_event, &save_state); - t = run_one_test(ts, zero_time, max_time); + lttv_hooks_add(event_hook, save_state_event, &save_state, + LTTV_PRIO_DEFAULT); + t = run_one_test(ts, ltt_time_zero, max_time); lttv_state_remove_event_hooks(ts); - lttv_hooks_remove_data(after_event, save_state_event, &save_state); + lttv_hooks_remove_data(event_hook, save_state_event, &save_state); g_warning("Processing while updating/writing state (%g seconds)", t); } } @@ -399,9 +502,9 @@ static gboolean process_traceset(void *hook_data, void *call_data) } lttv_stats_add_event_hooks(tscs); - t = run_one_test(ts, zero_time, max_time); + t = run_one_test(ts, ltt_time_zero, max_time); lttv_stats_remove_event_hooks(tscs); - g_warning("Processing trace while counting stats (%g seconds)", t); + g_message("Processing trace while counting stats (%g seconds)", t); if(lttv_profile_memory) { g_message("Memory summary after computing stats"); @@ -434,10 +537,10 @@ static gboolean process_traceset(void *hook_data, void *call_data) lttv_state_add_event_hooks(ts); lttv_stats_add_event_hooks(tscs); - t = run_one_test(ts, zero_time, max_time); + t = run_one_test(ts, ltt_time_zero, max_time); lttv_state_remove_event_hooks(ts); lttv_stats_remove_event_hooks(tscs); - g_warning( + g_message( "Processing trace while counting state and stats (%g seconds)", t); if(lttv_profile_memory) { @@ -456,7 +559,8 @@ static gboolean process_traceset(void *hook_data, void *call_data) /* Run through all events computing and saving the state. */ - if(a_trace_event) lttv_hooks_add(after_event, trace_event, NULL); + if(a_trace_event) lttv_hooks_add(event_hook, trace_event, NULL, + LTTV_PRIO_DEFAULT); if(a_test6 || a_test_all) { if(lttv_profile_memory) { @@ -467,14 +571,15 @@ static gboolean process_traceset(void *hook_data, void *call_data) lttv_state_add_event_hooks(ts); lttv_state_save_add_event_hooks(ts); if(a_save_state_copy) - lttv_hooks_add(after_event, save_state_copy_event, &save_state); - t = run_one_test(ts, zero_time, max_time); + lttv_hooks_add(event_hook, save_state_copy_event, &save_state, + LTTV_PRIO_DEFAULT); + t = run_one_test(ts, ltt_time_zero, max_time); lttv_state_remove_event_hooks(ts); lttv_state_save_remove_event_hooks(ts); if(a_save_state_copy) - lttv_hooks_remove_data(after_event,save_state_copy_event, &save_state); + lttv_hooks_remove_data(event_hook,save_state_copy_event, &save_state); - g_warning("Processing trace while updating/saving state (%g seconds)", t); + g_message("Processing trace while updating/saving state (%g seconds)", t); if(lttv_profile_memory) { g_message("Memory summary after computing/saving state"); @@ -485,15 +590,16 @@ static gboolean process_traceset(void *hook_data, void *call_data) /* Seek a few times to each saved position */ if((a_test7 && a_test3) || a_test_all) { - int i, j; - - for(i = 0 ; i < a_seek_number ; i++) { - for(j = save_state.position - 1 ; j >= 0 ; j--) { + g_assert(a_seek_number >= 0); + for(i = 0 ; i < (guint)a_seek_number ; i++) { + gint reverse_j; /* just to make sure j is unsigned */ + for(reverse_j = save_state.position - 1 ; reverse_j >= 0 ; reverse_j--) { + j = (guint)reverse_j; lttv_state_add_event_hooks(ts); t = run_one_test(ts, save_state.write_time[j], save_state.write_time[j]); lttv_state_remove_event_hooks(ts); - g_warning("Seeking to %lu.%lu (%g seconds)", + g_message("Seeking to %lu.%lu (%g seconds)", save_state.write_time[j].tv_sec, save_state.write_time[j].tv_nsec, t); @@ -513,7 +619,37 @@ static gboolean process_traceset(void *hook_data, void *call_data) } } - if(a_trace_event) lttv_hooks_remove_data(after_event, trace_event, NULL); + /* Seek at specified interval, using states computed in 6, making + * sure that there is no more than the number of events between + * state save interval to read before getting there. + */ + + if((a_test8 && a_test6) || a_test_all) { + g_message("Running test 8 : check save interval"); + LttTime time = tc->time_span.start_time; + LttTime interval; + interval.tv_sec = 0; + interval.tv_nsec = 175674987; + guint count; + + while(ltt_time_compare(time, tc->time_span.end_time) < 0) { + //g_message("Seeking at time %u.%u", time.tv_sec, time.tv_nsec); + lttv_process_traceset_seek_time(&ts->parent, ltt_time_zero); + lttv_state_traceset_seek_time_closest(ts, time); + /* We add no hook to the traceset, not necessary */ + count = lttv_process_traceset_middle(&ts->parent, + time, G_MAXUINT, NULL); + g_info("Number of events to jump over : %u", count); + + if(count > LTTV_STATE_SAVE_INTERVAL) + g_warning("Oops! Save interval is %u and it took %u events to seek to a time %lu.%lu supposed to be closer from the last saved state.", + LTTV_STATE_SAVE_INTERVAL, count, time.tv_sec, time.tv_nsec); + time = ltt_time_add(time, interval); + } + + } + + if(a_trace_event) lttv_hooks_remove_data(event_hook, trace_event, NULL); g_free(save_state.write_time); g_free(a_event_position); @@ -526,6 +662,7 @@ static gboolean process_traceset(void *hook_data, void *call_data) } g_info("BatchTest end process traceset"); + return 0; } @@ -537,6 +674,11 @@ static void init() g_info("Init batchtest.c"); + /* Init GQuarks */ + QUARK_BLOCK_START = g_quark_from_string("block_start"); + QUARK_BLOCK_END = g_quark_from_string("block_end"); + + lttv_option_add("trace", 't', "add a trace to the trace set to analyse", "pathname of the directory containing the trace", @@ -612,6 +754,10 @@ static void init() lttv_option_add("test7", '7', "Test seeking to positions written out in 3", "", LTTV_OPT_NONE, &a_test7, NULL, NULL); + a_test8 = FALSE; + lttv_option_add("test8", '8', "Test seeking to positions using saved states computed at 6 : check if number of events fits", + "", LTTV_OPT_NONE, &a_test8, NULL, NULL); + a_test_all = FALSE; lttv_option_add("testall", 'a', "Run all tests ", "", LTTV_OPT_NONE, &a_test_all, NULL, NULL); @@ -624,8 +770,10 @@ static void init() after_trace = lttv_hooks_new(); before_tracefile = lttv_hooks_new(); after_tracefile = lttv_hooks_new(); - before_event = lttv_hooks_new(); - after_event = lttv_hooks_new(); + //before_event = lttv_hooks_new(); + //after_event = lttv_hooks_new(); + event_hook = lttv_hooks_new(); + g_assert(lttv_iattribute_find_by_path(attributes, "hooks/traceset/before", LTTV_POINTER, &value)); @@ -645,17 +793,19 @@ static void init() g_assert(lttv_iattribute_find_by_path(attributes, "hooks/tracefile/after", LTTV_POINTER, &value)); *(value.v_pointer) = after_tracefile; - g_assert(lttv_iattribute_find_by_path(attributes, "hooks/event/before", - LTTV_POINTER, &value)); - *(value.v_pointer) = before_event; - g_assert(lttv_iattribute_find_by_path(attributes, "hooks/event/after", + //g_assert(lttv_iattribute_find_by_path(attributes, "hooks/event/before", + // LTTV_POINTER, &value)); + //*(value.v_pointer) = before_event; + //g_assert(lttv_iattribute_find_by_path(attributes, "hooks/event/after", + // LTTV_POINTER, &value)); + //*(value.v_pointer) = after_event; + g_assert(lttv_iattribute_find_by_path(attributes, "hooks/event", LTTV_POINTER, &value)); - *(value.v_pointer) = after_event; - + *(value.v_pointer) = event_hook; g_assert(lttv_iattribute_find_by_path(attributes, "hooks/main/before", LTTV_POINTER, &value)); g_assert((main_hooks = *(value.v_pointer)) != NULL); - lttv_hooks_add(main_hooks, process_traceset, NULL); + lttv_hooks_add(main_hooks, process_traceset, NULL, LTTV_PRIO_DEFAULT); } @@ -682,6 +832,7 @@ static void destroy() lttv_option_remove("test5"); lttv_option_remove("test6"); lttv_option_remove("test7"); + lttv_option_remove("test8"); lttv_option_remove("testall"); lttv_hooks_destroy(before_traceset); @@ -690,13 +841,15 @@ static void destroy() lttv_hooks_destroy(after_trace); lttv_hooks_destroy(before_tracefile); lttv_hooks_destroy(after_tracefile); - lttv_hooks_destroy(before_event); - lttv_hooks_destroy(after_event); + //lttv_hooks_destroy(before_event); + //lttv_hooks_destroy(after_event); + lttv_hooks_destroy(event_hook); lttv_hooks_remove_data(main_hooks, process_traceset, NULL); nb = lttv_traceset_number(traceset); for(i = 0 ; i < nb ; i++) { trace = lttv_traceset_get(traceset, i); + lttv_traceset_remove(traceset,i); ltt_trace_close(lttv_trace(trace)); lttv_trace_destroy(trace); }