* MA 02111-1307, USA.
*/
-
+#include <string.h>
#include <lttv/tracecontext.h>
#include <ltt/event.h>
#include <ltt/facility.h>
{
gint comparison;
- LttvTracefileContext *trace_a = (LttvTracefileContext *)a;
+ const LttvTracefileContext *trace_a = (const LttvTracefileContext *)a;
- LttvTracefileContext *trace_b = (LttvTracefileContext *)b;
+ const LttvTracefileContext *trace_b = (const LttvTracefileContext *)b;
if(trace_a == trace_b) return 0;
comparison = ltt_time_compare(trace_a->timestamp, trace_b->timestamp);
else if(trace_a->index > trace_b->index) return 1;
if(trace_a->t_context->index < trace_b->t_context->index) return -1;
else if(trace_a->t_context->index > trace_b->t_context->index) return 1;
+
g_assert(FALSE);
+ return 0; /* This should never happen */
}
struct _LttvTraceContextPosition {
- LttEventPosition **tf_pos; /* Position in each trace */
+ LttEventPosition **tf_pos; /* Position in each tracefile */
guint nb_tracefile; /* Number of tracefiles (check) */
};
struct _LttvTracesetContextPosition {
- LttvTraceContextPosition *t_pos; /* Position in each trace */
+ LttvTraceContextPosition *t_pos; /* Position in each trace */
guint nb_trace; /* Number of traces (check) */
+ LttTime timestamp; /* Current time at the saved position */
};
void lttv_context_init(LttvTracesetContext *self, LttvTraceset *ts)
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);
}
}
+ self->pqueue = g_tree_new(compare_tracefile);
lttv_process_traceset_seek_time(self, null_time);
lttv_traceset_context_compute_time_span(self, &self->time_span);
- self->e = NULL;
- self->pqueue = g_tree_new(compare_tracefile);
}
for(j = 0 ; j < nb_tracefile ; j++) {
tfc = tc->tracefiles[j];
+ ltt_event_destroy(tfc->e);
lttv_hooks_destroy(tfc->event);
lttv_hooks_by_id_destroy(tfc->event_by_id);
g_object_unref(tfc->a);
lttv_hooks_add_list(self->event, event);
if(event_by_id != NULL)
for(i = 0; i < lttv_hooks_by_id_max_id(event_by_id); i++) {
- hook = lttv_hooks_by_id_get(self->event_by_id, i);
- if(hook != NULL)
- lttv_hooks_remove_list(hook, lttv_hooks_by_id_get(event_by_id, i));
+ hook = lttv_hooks_by_id_find(self->event_by_id, i);
+ lttv_hooks_add_list(hook, lttv_hooks_by_id_get(event_by_id, i));
}
}
lttv_hooks_remove_list(self->event, event);
if(event_by_id != NULL)
for(i = 0; i < lttv_hooks_by_id_max_id(event_by_id); i++) {
- hook = lttv_hooks_by_id_find(self->event_by_id, i);
- lttv_hooks_add_list(hook, lttv_hooks_by_id_get(event_by_id, i));
+ hook = lttv_hooks_by_id_get(self->event_by_id, i);
+ if(hook != NULL)
+ lttv_hooks_remove_list(hook, lttv_hooks_by_id_get(event_by_id, i));
}
lttv_hooks_call(after_tracefile, self);
NULL, /* class_data */
sizeof (LttvTracesetContext),
0, /* n_preallocs */
- (GInstanceInitFunc) traceset_context_instance_init /* instance_init */
+ (GInstanceInitFunc) traceset_context_instance_init, /* instance_init */
+ NULL /* Value handling */
};
type = g_type_register_static (G_TYPE_OBJECT, "LttvTracesetContextType",
NULL, /* class_data */
sizeof (LttvTraceContext),
0, /* n_preallocs */
- (GInstanceInitFunc) trace_context_instance_init /* instance_init */
+ (GInstanceInitFunc) trace_context_instance_init, /* instance_init */
+ NULL /* Value handling */
};
type = g_type_register_static (G_TYPE_OBJECT, "LttvTraceContextType",
NULL, /* class_data */
sizeof (LttvTracefileContext),
0, /* n_preallocs */
- (GInstanceInitFunc) tracefile_context_instance_init /* instance_init */
+ (GInstanceInitFunc) tracefile_context_instance_init, /* instance_init */
+ NULL /* Value handling */
};
type = g_type_register_static (G_TYPE_OBJECT, "LttvTracefileContextType",
-gboolean get_first(gpointer key, gpointer value, gpointer user_data) {
+static gboolean get_first(gpointer key, gpointer value, gpointer user_data) {
*((LttvTracefileContext **)user_data) = (LttvTracefileContext *)value;
return TRUE;
}
+/* Put all the tracefiles at the tracefile context position */
+void lttv_process_traceset_synchronize_tracefiles(LttvTracesetContext *self)
+{
+ guint iter_trace, nb_trace;
+
+ LttvTraceContext *tc;
+
+ nb_trace = lttv_traceset_number(self->ts);
+
+ for(iter_trace = 0 ; iter_trace < nb_trace ; iter_trace++) {
+ tc = self->traces[iter_trace];
+ {
+ /* each trace */
+ guint iter_tf, nb_tracefile;
+
+ LttvTracefileContext *tfc;
+
+ nb_tracefile = ltt_trace_control_tracefile_number(tc->t) +
+ ltt_trace_per_cpu_tracefile_number(tc->t);
+
+ for(iter_tf = 0 ; iter_tf < nb_tracefile ; iter_tf++) {
+ tfc = tc->tracefiles[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_tracefile_seek_position(tfc->tf, ep);
+ g_free(ep);
+ }
+ }
+ }
+ }
+}
+
+
void lttv_process_traceset_begin(LttvTracesetContext *self,
LttvHooks *before_traceset,
/* Note : a _middle must be preceded from a _seek or another middle */
guint lttv_process_traceset_middle(LttvTracesetContext *self,
LttTime end,
- unsigned nb_events,
+ guint nb_events,
const LttvTracesetContextPosition *end_position)
{
GTree *pqueue = self->pqueue;
LttvTracefileContext *tfc;
- LttEvent *event;
-
unsigned count = 0;
gboolean last_ret = FALSE; /* return value of the last hook list called */
if(last_ret == TRUE ||
count >= nb_events ||
- lttv_traceset_context_ctx_pos_compare(self,
- end_position) >= 0 ||
+ (end_position!=NULL&<tv_traceset_context_ctx_pos_compare(self,
+ end_position) == 0)||
ltt_time_compare(tfc->timestamp, end) >= 0)
{
return count;
last_ret = lttv_hooks_call_merge(tfc->event, tfc,
lttv_hooks_by_id_get(tfc->event_by_id, id), tfc);
- event = ltt_tracefile_read(tfc->tf);
- if(event != NULL) {
- tfc->e = event;
- tfc->timestamp = ltt_event_time(event);
+ if(ltt_tracefile_read(tfc->tf, tfc->e) != NULL) {
+ tfc->timestamp = ltt_event_time(tfc->e);
g_tree_insert(pqueue, tfc, tfc);
}
}
LttvTracefileContext *tfc;
- LttEvent *event;
+ GTree *pqueue = self->ts_context->pqueue;
nb_tracefile = ltt_trace_control_tracefile_number(self->t) +
ltt_trace_per_cpu_tracefile_number(self->t);
for(i = 0 ; i < nb_tracefile ; i++) {
tfc = self->tracefiles[i];
ltt_tracefile_seek_time(tfc->tf, start);
- event = ltt_tracefile_read(tfc->tf);
- tfc->e = event;
- if(event != NULL) {
- tfc->timestamp = ltt_event_time(event);
- g_tree_insert(self->ts_context->pqueue, tfc, tfc);
+ 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);
}
}
}
LttvTraceContext *tc;
- LttvTracefileContext *tfc;
-
- /* Empty the pqueue */
-
- while(TRUE){
- tfc = NULL;
- g_tree_foreach(self->pqueue, get_first, &tfc);
- if(tfc == NULL) break;
- g_tree_remove(self->pqueue, &(tfc->timestamp));
- }
-
nb_trace = lttv_traceset_number(self->ts);
for(i = 0 ; i < nb_trace ; i++) {
tc = self->traces[i];
}
+gboolean lttv_process_tracefile_seek_position(LttvTracefileContext *self,
+ const LttEventPosition *pos)
+{
+ LttvTracefileContext *tfc = self;
+
+ GTree *pqueue = self->t_context->ts_context->pqueue;
+
+ 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);
+ }
+
+ return TRUE;
+}
+
gboolean lttv_process_trace_seek_position(LttvTraceContext *self,
const LttvTraceContextPosition *pos)
{
LttvTracefileContext *tfc;
- LttEvent *event;
-
nb_tracefile = ltt_trace_control_tracefile_number(self->t) +
ltt_trace_per_cpu_tracefile_number(self->t);
for(i = 0 ; i < nb_tracefile ; i++) {
tfc = self->tracefiles[i];
- ltt_tracefile_seek_position(tfc->tf, pos->tf_pos[i]);
- event = ltt_tracefile_read(tfc->tf);
- tfc->e = event;
- if(event != NULL) {
- tfc->timestamp = ltt_event_time(event);
- g_tree_insert(self->ts_context->pqueue, tfc, tfc);
- }
+ lttv_process_tracefile_seek_position(tfc, pos->tf_pos[i]);
}
return TRUE;
LttvTraceContext *tc;
- LttvTracefileContext *tfc;
-
nb_trace = lttv_traceset_number(self->ts);
if(nb_trace != pos->nb_trace)
return FALSE; /* Error */
- /* Empty the pqueue */
-
- while(TRUE){
- tfc = NULL;
- g_tree_foreach(self->pqueue, get_first, &tfc);
- if(tfc == NULL) break;
- g_tree_remove(self->pqueue, &(tfc->timestamp));
- }
-
for(i = 0 ; i < nb_trace ; i++) {
tc = self->traces[i];
sum_ret = sum_ret && lttv_process_trace_seek_position(tc, &pos->t_pos[i]);
LttEventType *et;
- guint nb, pos, i;
-
- char *name;
+ guint nb, pos;
nb = ltt_trace_facility_find(t, facility, &pos);
if(nb < 1) g_error("No %s facility", facility);
}
+LttvTracesetContextPosition *lttv_traceset_context_position_new()
+{
+ return g_new(LttvTracesetContextPosition,1);
+}
+
+
void lttv_traceset_context_position_save(const LttvTracesetContext *self,
LttvTracesetContextPosition *pos)
{
LttEvent *event;
+ LttTime timestamp = self->time_span.end_time;
+
pos->nb_trace = nb_trace = lttv_traceset_number(self->ts);
pos->t_pos = g_new(LttvTraceContextPosition, nb_trace);
pos->t_pos[iter_trace].tf_pos = g_new(LttEventPosition*, nb_tracefile);
for(iter_tracefile = 0; iter_tracefile < nb_tracefile; iter_tracefile++) {
- pos->t_pos[iter_trace].tf_pos[iter_tracefile]
- = ltt_event_position_new();
tfc = tc->tracefiles[iter_tracefile];
event = tfc->e;
- ltt_event_position(event,
- pos->t_pos[iter_trace].tf_pos[iter_tracefile]);
+ if(event!=NULL) {
+ pos->t_pos[iter_trace].tf_pos[iter_tracefile]
+ = ltt_event_position_new();
+ ltt_event_position(event,
+ pos->t_pos[iter_trace].tf_pos[iter_tracefile]);
+ } else {
+ pos->t_pos[iter_trace].tf_pos[iter_tracefile] = NULL;
+ }
+ if(ltt_time_compare(tfc->timestamp, timestamp) < 0)
+ timestamp = tfc->timestamp;
}
}
+ pos->timestamp = timestamp;
}
void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos)
{
- guint nb_trace, nb_tracefile;
+ guint nb_trace;
guint iter_trace, iter_tracefile;
nb_trace = pos->nb_trace;
for(iter_tracefile = 0; iter_tracefile <
pos->t_pos[iter_trace].nb_tracefile;
iter_tracefile++) {
-
- g_free(pos->t_pos[iter_trace].tf_pos[iter_tracefile]);
+ if(pos->t_pos[iter_trace].tf_pos[iter_tracefile] != NULL)
+ g_free(pos->t_pos[iter_trace].tf_pos[iter_tracefile]);
}
g_free(pos->t_pos[iter_trace].tf_pos);
}
}
+void lttv_traceset_context_position_copy(LttvTracesetContextPosition *dest,
+ const LttvTracesetContextPosition *src)
+{
+ guint nb_trace, nb_tracefile;
+ guint iter_trace, iter_tracefile;
+
+ nb_trace = dest->nb_trace = src->nb_trace;
+ dest->t_pos = g_new(LttvTraceContextPosition, nb_trace);
+
+ 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;
+
+ for(iter_tracefile = 0; iter_tracefile < nb_tracefile; iter_tracefile++) {
+ dest->t_pos[iter_trace].tf_pos[iter_tracefile] =
+ ltt_event_position_new();
+ if(src->t_pos[iter_trace].tf_pos[iter_tracefile] != NULL)
+ ltt_event_position_copy(
+ dest->t_pos[iter_trace].tf_pos[iter_tracefile],
+ src->t_pos[iter_trace].tf_pos[iter_tracefile]);
+ else
+ dest->t_pos[iter_trace].tf_pos[iter_tracefile] = NULL;
+ }
+ }
+
+ dest->timestamp = src->timestamp;
+}
+
gint lttv_traceset_context_ctx_pos_compare(const LttvTracesetContext *self,
const LttvTracesetContextPosition *pos)
{
for(iter_tracefile = 0; iter_tracefile < nb_tracefile; iter_tracefile++) {
tfc = tc->tracefiles[iter_tracefile];
event = tfc->e;
- if(
- ret =
- ltt_event_event_position_compare(event,
- pos->t_pos[iter_trace].tf_pos[iter_tracefile])
- != 0)
+ ret = ltt_event_event_position_compare(event,
+ pos->t_pos[iter_trace].tf_pos[iter_tracefile]);
+ if(ret != 0)
return ret;
}
}
g_error("lttv_traceset_context_ctx_pos_compare : nb_tracefile does not match.");
for(iter_tracefile = 0; iter_tracefile < nb_tracefile; iter_tracefile++) {
- if(ret =
- ltt_event_position_compare(
+ ret = ltt_event_position_compare(
pos1->t_pos[iter_trace].tf_pos[iter_tracefile],
- pos2->t_pos[iter_trace].tf_pos[iter_tracefile])
- != 0)
+ pos2->t_pos[iter_trace].tf_pos[iter_tracefile]);
+ if(ret != 0)
return ret;
}
}
}
+LttTime lttv_traceset_context_position_get_time(
+ const LttvTracesetContextPosition *pos)
+{
+ return pos->timestamp;
+}
+
+
+LttvTracefileContext *lttv_traceset_context_get_current_tfc(LttvTracesetContext *self)
+{
+ GTree *pqueue = self->pqueue;
+ LttvTracefileContext *tfc = NULL;
+
+ g_tree_foreach(pqueue, get_first, &tfc);
+
+ return tfc;
+}
projects / lttv.git / blobdiff