Initial port of the detailed event view

[lttv.git] / lttv / lttv / traceset-process.c

diff --git a/lttv/lttv/traceset-process.c b/lttv/lttv/traceset-process.c
index 56543855f64a20bb6163ba7191eb181feeb516ed..8ce68981882dd0d76c5a441ab9a845aa9043bbbc 100644 (file)
--- a/lttv/lttv/traceset-process.c
+++ b/lttv/lttv/traceset-process.c
@@ -25,7 +25,7 @@
 #include <lttv/event.h>
 #include <babeltrace/context.h>
 #include <babeltrace/iterator.h>
-
+#include <babeltrace/trace-handle.h>
 #include <babeltrace/ctf/events.h>
 #include <babeltrace/ctf/iterator.h>
 
@@ -54,29 +54,37 @@ void lttv_process_traceset_begin(LttvTraceset *traceset,
 }
 
 guint lttv_process_traceset_middle(LttvTraceset *traceset,
-               LttTime end,
-               gulong nb_events,
-               const LttvTracesetPosition *end_position)
+                                       LttTime end,
+                                       gulong nb_events,
+                                       const LttvTracesetPosition *end_position)
 {
-       
        unsigned count = 0;
-               
+       gint last_ret = 0;
+       LttvTracesetPosition *currentPos;
+        
        struct bt_ctf_event *bt_event;
        
        LttvEvent event;
   
        while(TRUE) {
 
-               if((count >= nb_events) && (nb_events != G_MAXULONG)) {
+               if(last_ret == TRUE || ((count >= nb_events) && (nb_events != G_MAXULONG))) {
                        break;
                }
 
                if((bt_event = bt_ctf_iter_read_event(traceset->iter)) != NULL) {
+
+                       LttTime time = ltt_time_from_uint64(bt_ctf_get_timestamp_raw(bt_event));
+                       if(ltt_time_compare(end, time) <= 0) {
+                               break;
+                       }
                        
-                       if(ltt_time_compare(end, ltt_time_from_uint64( bt_ctf_get_timestamp(bt_event))) <= 0) {
+                       currentPos = lttv_traceset_create_position(traceset);
+                       if(lttv_traceset_position_compare(currentPos,end_position ) == 0){
+                               lttv_traceset_destroy_position(currentPos);
                                break;
                        }
-
+                       lttv_traceset_destroy_position(currentPos);
                        count++;
 
                        event.bt_event = bt_event;
@@ -85,7 +93,7 @@ guint lttv_process_traceset_middle(LttvTraceset *traceset,
                        event.state = g_ptr_array_index(traceset->state_trace_handle_index,
                                                        bt_ctf_event_get_handle_id(bt_event));
                        
-                       lttv_hooks_call(traceset->event_hooks, &event);
+                       last_ret = lttv_hooks_call(traceset->event_hooks, &event);
 
                        if(bt_iter_next(bt_ctf_get_iter(traceset->iter)) < 0) {
                                printf("ERROR NEXT\n");
@@ -98,9 +106,6 @@ guint lttv_process_traceset_middle(LttvTraceset *traceset,
                
                }
        }
-       
-
-
        return count;
 }
 
@@ -124,7 +129,6 @@ void lttv_traceset_add_hooks(LttvTraceset *traceset,
                             LttvHooks *before_trace,
                             LttvHooks *event)
 {
-       
        guint i, nb_trace;
 
        LttvTrace *trace;
@@ -148,7 +152,6 @@ void lttv_traceset_remove_hooks(LttvTraceset *traceset,
                                LttvHooks *after_trace,
                                LttvHooks *event)
 {
-
        guint i, nb_trace;
 
        LttvTrace *trace;
@@ -163,6 +166,7 @@ void lttv_traceset_remove_hooks(LttvTraceset *traceset,
 
        }
 
+       lttv_hooks_remove_list(traceset->event_hooks, event);
        lttv_hooks_call(after_traceset, traceset);
 
 
@@ -182,7 +186,6 @@ void lttv_trace_remove_hooks(LttvTrace *trace,
 
 {
        lttv_hooks_call(after_trace, trace);
-
 }
 
 void lttv_process_traceset_seek_time(LttvTraceset *traceset, LttTime start)
@@ -200,5 +203,94 @@ void lttv_process_traceset_seek_time(LttvTraceset *traceset, LttTime start)
         if(ret < 0) {
                 printf("Seek by time error: %s,\n",strerror(-ret));
         }
- 
+}
+
+guint lttv_process_traceset_seek_n_forward(LttvTraceset *traceset,
+                guint n,
+                check_handler *check,
+                gboolean *stop_flag,
+                LttvFilter *filter1,
+                LttvFilter *filter2,
+                LttvFilter *filter3,
+                gpointer data)
+{
+        struct bt_ctf_event *bt_event;
+        unsigned count = 0;
+        while(count < n) {
+               if(bt_iter_next(bt_ctf_get_iter(traceset->iter)) < 0) {
+                       printf("ERROR NEXT\n");
+                       break;
+               }
+               count++;
+        }
+      return count;  
+}
+
+guint lttv_process_traceset_seek_n_backward(LttvTraceset *ts,
+                guint n,
+                gdouble ratio,
+                check_handler *check,
+                gboolean *stop_flag,
+                LttvFilter *filter1,
+                LttvFilter *filter2,
+                LttvFilter *filter3,
+                gpointer data)
+{
+        guint i, count, ret;
+        gint extraEvent = 0;
+        guint64 initialTimeStamp, previousTimeStamp;
+        LttvTracesetPosition *initialPos, *previousPos, *currentPos;
+        
+        /*Save initial position of the traceset*/
+        initialPos = lttv_traceset_create_position (ts);
+        
+        /*Get the timespan of the initial position*/
+        initialTimeStamp = lttv_traceset_position_get_timestamp(initialPos);
+        /* 
+         * Create a position before the initial timestamp according
+         * to the ratio of nanosecond/nanosecond hopefully before the
+         * the desired seek position
+         */
+        while(1){
+               previousTimeStamp = initialTimeStamp - n*(guint)ceil(ratio);
+
+               previousPos = lttv_traceset_create_time_position(ts,ltt_time_from_uint64(previousTimeStamp));
+               if(initialTimeStamp == previousTimeStamp)
+                       break;
+                
+                currentPos = lttv_traceset_create_time_position(ts,ltt_time_from_uint64(previousTimeStamp));
+                /*move traceset position */
+                lttv_traceset_seek_to_position(previousPos);
+                /* iterate to the initial position counting the number of event*/
+                count = 0;
+                do {
+                        if((ret = lttv_traceset_position_compare(currentPos,initialPos)) == 1){       
+                                bt_iter_next(bt_ctf_get_iter(ts->iter));
+                                lttv_traceset_destroy_position(currentPos);
+                                currentPos = lttv_traceset_create_position(ts);
+                                count++;
+                        }
+                }while(ret != 0);
+                lttv_traceset_destroy_position(currentPos);
+                /*substract the desired number of event to the count*/
+                extraEvent = count - n;
+                if(extraEvent >= 0){
+                        //if the extraEvent is over 0 go back to previousPos and 
+                        //move forward the value of extraEvent times
+                        lttv_traceset_seek_to_position(previousPos);
+                        
+                        for(i = 0 ; i < extraEvent ; i++){
+                                if(bt_iter_next(bt_ctf_get_iter(ts->iter)) < 0){
+                                        printf("ERROR NEXT\n");
+                                        break;
+                                }
+                                
+                        }
+                        break; /* we successfully seeked backward */
+                }
+                else{ /* if the extraEvent is below 0 create a position before and start over*/  
+                        ratio = ratio * 16;
+                }
+        }
+        return 0;
 }