* MA 02111-1307, USA.
*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
#include <string.h>
#include <lttv/tracecontext.h>
#include <ltt/event.h>
-gint compare_tracefile(gconstpointer a, gconstpointer b)
+static gint compare_tracefile(gconstpointer a, gconstpointer b)
{
gint comparison = 0;
const LttvTracefileContext *trace_a = (const LttvTracefileContext *)a;
const LttvTracefileContext *trace_b = (const LttvTracefileContext *)b;
- if(trace_a != trace_b) {
+ if(likely(trace_a != trace_b)) {
comparison = ltt_time_compare(trace_a->timestamp, trace_b->timestamp);
- if(comparison == 0) {
+ if(unlikely(comparison == 0)) {
if(trace_a->index < trace_b->index) comparison = -1;
else if(trace_a->index > trace_b->index) comparison = 1;
else if(trace_a->t_context->index < trace_b->t_context->index)
}
}
+static void init_tracefile_context(LttTracefile *tracefile,
+ LttvTraceContext *tc)
+{
+ LttvTracefileContext *tfc;
+ LttvTracesetContext *tsc = tc->ts_context;
+
+ tfc = LTTV_TRACESET_CONTEXT_GET_CLASS(tsc)->new_tracefile_context(tsc);
+
+ tfc->index = tc->tracefiles->len;
+ tc->tracefiles = g_array_append_val(tc->tracefiles, tfc);
+
+ tfc->tf = tracefile;
+
+ tfc->t_context = tc;
+ tfc->event = lttv_hooks_new();
+ tfc->event_by_id = lttv_hooks_by_id_new();
+ tfc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
+}
+
static void
init(LttvTracesetContext *self, LttvTraceset *ts)
LttvTraceContext *tc;
- LttvTracefileContext *tfc;
+ GData *tracefiles_groups;
- LttTime null_time = {0, 0};
+ struct compute_tracefile_group_args args;
nb_trace = lttv_traceset_number(ts);
self->ts = ts;
tc->t = lttv_trace(tc->vt);
tc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
tc->t_a = lttv_trace_attribute(tc->vt);
+
+ tracefiles_groups = ltt_trace_get_tracefiles_groups(tc->t);
+
+ args.func = (ForEachTraceFileFunc)init_tracefile_context;
+ args.func_args = tc;
+
+ g_datalist_foreach(&tracefiles_groups,
+ (GDataForeachFunc)compute_tracefile_group,
+ &args);
+
+#if 0
nb_control = ltt_trace_control_tracefile_number(tc->t);
nb_per_cpu = ltt_trace_per_cpu_tracefile_number(tc->t);
nb_tracefile = nb_control + nb_per_cpu;
tfc->control = FALSE;
tfc->tf = ltt_trace_per_cpu_tracefile_get(tc->t, j - nb_control);
}
+
tfc->t_context = tc;
tfc->e = ltt_event_new();
tfc->event = lttv_hooks_new();
tfc->event_by_id = lttv_hooks_by_id_new();
tfc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
}
+#endif //0
+
}
self->pqueue = g_tree_new(compare_tracefile);
- lttv_process_traceset_seek_time(self, null_time);
+ lttv_process_traceset_seek_time(self, ltt_time_zero);
lttv_traceset_context_compute_time_span(self, &self->time_span);
}
g_object_unref(tc->a);
- nb_tracefile = ltt_trace_control_tracefile_number(tc->t) +
- ltt_trace_per_cpu_tracefile_number(tc->t);
+ nb_tracefile = tc->tracefiles->len;
for(j = 0 ; j < nb_tracefile ; j++) {
- tfc = tc->tracefiles[j];
- ltt_event_destroy(tfc->e);
+ tfc = &g_array_index(tc->tracefiles, LttvTracefileContext, j);
lttv_hooks_destroy(tfc->event);
lttv_hooks_by_id_destroy(tfc->event_by_id);
g_object_unref(tfc->a);
g_object_unref(tfc);
}
- g_free(tc->tracefiles);
+ g_array_free(tc->tracefiles, TRUE);
g_object_unref(tc);
}
g_free(self->traces);
LttvTracefileContext *tfc;
lttv_hooks_call(before_trace, self);
- nb_tracefile = ltt_trace_control_tracefile_number(self->t) +
- ltt_trace_per_cpu_tracefile_number(self->t);
+
+ nb_tracefile = self->tracefiles->len;
for(i = 0 ; i < nb_tracefile ; i++) {
- tfc = self->tracefiles[i];
+ tfc = &g_array_index(self->tracefiles, LttvTracefileContext, i);
lttv_tracefile_context_add_hooks(tfc,
before_tracefile,
event,
LttvTracefileContext *tfc;
- nb_tracefile = ltt_trace_control_tracefile_number(self->t) +
- ltt_trace_per_cpu_tracefile_number(self->t);
+ nb_tracefile = self->tracefiles->len;
for(i = 0 ; i < nb_tracefile ; i++) {
- tfc = self->tracefiles[i];
+ tfc = &g_array_index(self->tracefiles, LttvTracefileContext, i);
lttv_tracefile_context_remove_hooks(tfc,
after_tracefile,
event,
LttvTracefileContext *tfc;
- nb_tracefile = ltt_trace_control_tracefile_number(tc->t) +
- ltt_trace_per_cpu_tracefile_number(tc->t);
+ nb_tracefile = tc->tracefiles->len;
for(iter_tf = 0 ; iter_tf < nb_tracefile ; iter_tf++) {
- tfc = tc->tracefiles[iter_tf];
+ tfc = &g_array_index(tc->tracefiles, LttvTracefileContext, iter_tf);
{
/* each tracefile */
//ltt_tracefile_copy(tfc->tf_sync_data, tfc->tf);
LttEventPosition *ep = ltt_event_position_new();
- ltt_event_position(tfc->e, ep);
+ ltt_event_position(ltt_tracefile_get_event(tfc->tf), ep);
ltt_tracefile_seek_position(tfc->tf, ep);
g_free(ep);
LttvTracefileContext *tfc;
+ LttEvent *e;
+
unsigned count = 0;
gboolean last_ret = FALSE; /* return value of the last hook list called */
tfc = NULL;
g_tree_foreach(pqueue, get_first, &tfc);
/* End of traceset : tfc is NULL */
- if(tfc == NULL)
+ if(unlikely(tfc == NULL))
{
return count;
}
* break the loop.
*/
- if(last_ret == TRUE ||
- count >= nb_events ||
+ if(unlikely(last_ret == TRUE ||
+ count >= nb_events ||
(end_position!=NULL&<tv_traceset_context_ctx_pos_compare(self,
end_position) == 0)||
- ltt_time_compare(end, tfc->timestamp) <= 0)
+ ltt_time_compare(end, tfc->timestamp) <= 0))
{
return count;
}
g_tree_remove(pqueue, tfc);
count++;
-
- id = ltt_event_eventtype_id(tfc->e);
+
+ e = ltt_tracefile_get_event(tfc->tf);
+ id = ltt_event_eventtype_id(e);
last_ret = lttv_hooks_call_merge(tfc->event, tfc,
lttv_hooks_by_id_get(tfc->event_by_id, id), tfc);
- if(ltt_tracefile_read(tfc->tf, tfc->e) != NULL) {
- tfc->timestamp = ltt_event_time(tfc->e);
+ if(likely(!ltt_tracefile_read(tfc->tf))) {
+ tfc->timestamp = ltt_event_time(e);
g_tree_insert(pqueue, tfc, tfc);
}
}
{
guint i, nb_tracefile;
+ gint ret;
+
LttvTracefileContext *tfc;
GTree *pqueue = self->ts_context->pqueue;
- nb_tracefile = ltt_trace_control_tracefile_number(self->t) +
- ltt_trace_per_cpu_tracefile_number(self->t);
+ nb_tracefile = self->tracefiles->len;
for(i = 0 ; i < nb_tracefile ; i++) {
- tfc = self->tracefiles[i];
- ltt_tracefile_seek_time(tfc->tf, start);
+ tfc = &g_array_index(self->tracefiles, LttvTracefileContext, i);
+ ret = ltt_tracefile_seek_time(tfc->tf, start);
+ if(ret) g_error("error in lttv_process_trace_seek_time seek");
g_tree_remove(pqueue, tfc);
- if(ltt_tracefile_read(tfc->tf, tfc->e) != NULL) {
- tfc->timestamp = ltt_event_time(tfc->e);
- g_tree_insert(pqueue, tfc, tfc);
- }
+ tfc->timestamp = ltt_event_time(ltt_tracefile_get_event(tfc->tf));
+ g_tree_insert(pqueue, tfc, tfc);
}
}
ltt_tracefile_seek_position(tfc->tf, pos);
g_tree_remove(pqueue, tfc);
- if(ltt_tracefile_read(tfc->tf, tfc->e) != NULL) {
- tfc->timestamp = ltt_event_time(tfc->e);
- g_tree_insert(pqueue, tfc, tfc);
- }
+ tfc->timestamp = ltt_event_time(ltt_tracefile_get_event(tfc->tf));
+ g_tree_insert(pqueue, tfc, tfc);
return TRUE;
}
LttvTracefileContext *tfc;
- nb_tracefile = ltt_trace_control_tracefile_number(self->t) +
- ltt_trace_per_cpu_tracefile_number(self->t);
+ nb_tracefile = self->tracefiles->len;
if(nb_tracefile != pos->nb_tracefile)
return FALSE; /* Error */
for(i = 0 ; i < nb_tracefile ; i++) {
- tfc = self->tracefiles[i];
+ tfc = &g_array_index(self->tracefiles, LttvTracefileContext, i);
lttv_process_tracefile_seek_position(tfc, pos->tf_pos[i]);
}
static LttField *
-find_field(LttEventType *et, const char *field)
+find_field(LttEventType *et, const GQuark field)
{
LttType *t;
guint i, nb;
- char *name;
-
- if(field == NULL) return NULL;
+ GQuark name;
+ /* Field is unset */
+ if(field == 0) return NULL;
+
f = ltt_eventtype_field(et);
t = ltt_eventtype_type(et);
g_assert(ltt_type_class(t) == LTT_STRUCT);
nb = ltt_type_member_number(t);
for(i = 0 ; i < nb ; i++) {
ltt_type_member_type(t, i, &name);
- if(strcmp(name, field) == 0) break;
+ if(name == field) break;
}
g_assert(i < nb);
return ltt_field_member(f, i);
}
+LttvTraceHookByFacility *lttv_trace_hook_get_fac(LttvTraceHook *th,
+ guint facility_id)
+{
+ return &g_array_index(th->fac_index, LttvTraceHookByFacility, facility_id);
+}
+
+/* Get the first facility corresponding to the name. As the types must be
+ * compatible, it is relevant to use the field name and sizes of the first
+ * facility to create data structures and assume the data will be compatible
+ * thorough the trace */
+LttvTraceHookByFacility *lttv_trace_hook_get_first(LttvTraceHook *th)
+{
+ g_assert(th->fac_list->len > 0);
+ return g_array_index(th->fac_list, LttvTraceHookByFacility*, 0);
+}
+
-void
-lttv_trace_find_hook(LttTrace *t, char *facility, char *event_type,
- char *field1, char *field2, char *field3, LttvHook h, LttvTraceHook *th)
+/* Returns 0 on success, -1 if fails. */
+gint
+lttv_trace_find_hook(LttTrace *t, GQuark facility, GQuark event,
+ GQuark field1, GQuark field2, GQuark field3, LttvHook h, LttvTraceHook *th)
{
LttFacility *f;
- LttEventType *et;
+ LttEventType *et, *first_et;
+
+ GArray *facilities;
+
+ guint i, fac_id;
+
+ LttvTraceHookByFacility *thf, *first_thf;
+
+ facilities = ltt_trace_facility_get_by_name(t, facility);
+
+ if(unlikely(facilities == NULL)) goto facility_error;
+
+ th->fac_index = g_array_sized_new(FALSE, TRUE,
+ sizeof(LttvTraceHookByFacility),
+ NUM_FACILITIES);
+ th->fac_index = g_array_set_size(th->fac_index, NUM_FACILITIES);
+
+ th->fac_list = g_array_sized_new(FALSE, TRUE,
+ sizeof(LttvTraceHookByFacility*),
+ facilities->len);
+ th->fac_list = g_array_set_size(th->fac_list, facilities->len);
+
+ fac_id = g_array_index(facilities, guint, 0);
+ f = ltt_trace_get_facility_by_num(t, fac_id);
+
+ et = ltt_facility_eventtype_get_by_name(f, ltt_eventtype_name(et));
+ if(unlikely(et == NULL)) goto event_error;
+
+ thf = &g_array_index(th->fac_index, LttvTraceHookByFacility, fac_id);
+ g_array_index(th->fac_list, LttvTraceHookByFacility*, 0)
+ = thf;
+ thf->h = h;
+ thf->id = ltt_eventtype_id(et);
+ thf->f1 = find_field(et, field1);
+ thf->f2 = find_field(et, field2);
+ thf->f3 = find_field(et, field3);
+
+ first_thf = thf;
+
+ /* Check for type compatibility too */
+ for(i=1;i<facilities->len;i++) {
+ fac_id = g_array_index(facilities, guint, i);
+ f = ltt_trace_get_facility_by_num(t, fac_id);
+
+ et = ltt_facility_eventtype_get_by_name(f, ltt_eventtype_name(et));
+ if(unlikely(et == NULL)) goto event_error;
+
+ thf = &g_array_index(th->fac_index, LttvTraceHookByFacility, fac_id);
+ g_array_index(th->fac_list, LttvTraceHookByFacility*, i)
+ = thf;
+ thf->h = h;
+ thf->id = ltt_eventtype_id(et);
+ thf->f1 = find_field(et, field1);
+ if(check_fields_compatibility(first_et, et,
+ first_thf->f1, thf->f1))
+ goto type_error;
+
+ thf->f2 = find_field(et, field2);
+ if(check_fields_compatibility(first_et, et,
+ first_thf->f2, thf->f2))
+ goto type_error;
+
+ thf->f3 = find_field(et, field3);
+ if(check_fields_compatibility(first_et, et,
+ first_thf->f3, thf->f3))
+ goto type_error;
+ }
- guint nb, pos;
+ return 0;
- nb = ltt_trace_facility_find(t, facility, &pos);
- if(nb < 1) g_error("No %s facility", facility);
- f = ltt_trace_facility_get(t, pos);
- et = ltt_facility_eventtype_get_by_name(f, event_type);
- if(et == NULL) g_error("Event %s does not exist", event_type);
+type_error:
+ goto free;
+event_error:
+ g_error("Event type %s does not exist",
+ g_quark_to_string(ltt_eventtype_name(et)));
+ goto free;
+facility_error:
+ g_error("No %s facility", g_quark_to_string(facility));
+ goto free;
+free:
+ g_array_free(th->fac_index, TRUE);
+ g_array_free(th->fac_list, TRUE);
+ th->fac_index = NULL;
+ th->fac_list = NULL;
+ return -1;
+}
- th->h = h;
- th->id = ltt_eventtype_id(et);
- th->f1 = find_field(et, field1);
- th->f2 = find_field(et, field2);
- th->f3 = find_field(et, field3);
+void lttv_trace_hook_destroy(LttvTraceHook *th)
+{
+ g_array_free(th->fac_index, TRUE);
+ g_array_free(th->fac_list, TRUE);
}
for(iter_trace = 0 ; iter_trace < nb_trace ; iter_trace++) {
tc = self->traces[iter_trace];
- pos->t_pos[iter_trace].nb_tracefile = nb_tracefile =
- ltt_trace_control_tracefile_number(tc->t) +
- ltt_trace_per_cpu_tracefile_number(tc->t);
+ nb_tracefile = tc->tracefiles->len;
+ pos->t_pos[iter_trace].nb_tracefile = nb_tracefile;
+
pos->t_pos[iter_trace].tf_pos = g_new(LttEventPosition*, nb_tracefile);
for(iter_tracefile = 0; iter_tracefile < nb_tracefile; iter_tracefile++) {
- tfc = tc->tracefiles[iter_tracefile];
- event = tfc->e;
+ tfc = &g_array_index(tc->tracefiles, LttvTracefileContext,
+ iter_tracefile);
+ event = ltt_tracefile_get_event(tfc->tf);
if(event!=NULL) {
pos->t_pos[iter_trace].tf_pos[iter_tracefile]
= ltt_event_position_new();
for(iter_trace = 0 ; iter_trace < nb_trace ; iter_trace++) {
- nb_tracefile = dest->t_pos[iter_trace].nb_tracefile =
- src->t_pos[iter_trace].nb_tracefile;
+ nb_tracefile = src->t_pos[iter_trace].nb_tracefile;
+
+ dest->t_pos[iter_trace].nb_tracefile = nb_tracefile;
+
+ dest->t_pos[iter_trace].tf_pos = g_new(LttEventPosition*, nb_tracefile);
for(iter_tracefile = 0; iter_tracefile < nb_tracefile; iter_tracefile++) {
dest->t_pos[iter_trace].tf_pos[iter_tracefile] =
nb_trace = lttv_traceset_number(self->ts);
- if(pos->nb_trace != nb_trace)
+ if(unlikely(pos->nb_trace != nb_trace))
g_error("lttv_traceset_context_ctx_pos_compare : nb_trace does not match.");
for(iter_trace = 0 ; iter_trace < nb_trace ; iter_trace++) {
tc = self->traces[iter_trace];
- nb_tracefile = ltt_trace_control_tracefile_number(tc->t) +
- ltt_trace_per_cpu_tracefile_number(tc->t);
+ nb_tracefile = tc->tracefiles->len;
- if(pos->t_pos[iter_trace].nb_tracefile != nb_tracefile)
+ if(unlikely(pos->t_pos[iter_trace].nb_tracefile != nb_tracefile))
g_error("lttv_traceset_context_ctx_pos_compare : nb_tracefile does not match.");
for(iter_tracefile = 0; iter_tracefile < nb_tracefile; iter_tracefile++) {
- tfc = tc->tracefiles[iter_tracefile];
- event = tfc->e;
- ret = ltt_event_event_position_compare(event,
+ tfc = &g_array_index(tc->tracefiles, LttvTracefileContext,
+ iter_tracefile);
+ event = ltt_tracefile_get_event(tfc->tf);
+ ret = ltt_event_position_compare((LttEventPosition*)event,
pos->t_pos[iter_trace].tf_pos[iter_tracefile]);
if(ret != 0)
return ret;
gint ret;
nb_trace = pos1->nb_trace;
- if(nb_trace != pos2->nb_trace)
+ if(unlikely(nb_trace != pos2->nb_trace))
g_error("lttv_traceset_context_pos_pos_compare : nb_trace does not match.");
for(iter_trace = 0 ; iter_trace < nb_trace ; iter_trace++) {
nb_tracefile = pos1->t_pos[iter_trace].nb_tracefile;
- if(nb_tracefile != pos2->t_pos[iter_trace].nb_tracefile)
+ if(unlikely(nb_tracefile != pos2->t_pos[iter_trace].nb_tracefile))
g_error("lttv_traceset_context_ctx_pos_compare : nb_tracefile does not match.");
for(iter_tracefile = 0; iter_tracefile < nb_tracefile; iter_tracefile++) {