unfinished conversion of gui modules

[lttv.git] / ltt / branches / poly / lttv / modules / gui / tutorial / tutorial.c

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2005 Peter Ho
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, 
 * MA 02111-1307, USA.
 */
/******************************************************************
 Each field of the interrupt viewer is summarized as follows:
 
- CPUID: processor ID

- IrqId: IRQ ID

- Frequency (Hz): the number of interrupts per second (Hz). 
                  We compute the total number of interrupts. Then 
		  we divide it by the time interval.

- Total Duration (nsec): the sum of each interrupt duration in nsec. 
	         For a given Irq ID, we sum the duration of each interrupt
		 to give us the total duration 

		 
*******************************************************************/
		 

#include <math.h>
#include <glib.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ltt/ltt.h>
#include <ltt/event.h>
#include <ltt/trace.h>
#include <lttv/module.h>
#include <lttv/hook.h>
#include <lttv/tracecontext.h>
#include <lttv/state.h>
#include <lttv/filter.h>
#include <lttvwindow/lttvwindow.h>
#include <lttvwindow/lttv_plugin_tab.h>
#include <ltt/time.h>

#include "hTutorialInsert.xpm" 

#define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
#define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
#define NO_ITEMS 0
  
typedef struct 
{
	guint cpu_id;
	guint id;
	guint TotalNumberOfInterrupts;
	LttTime total_duration;	
}Irq;

typedef struct 
{
	guint id;
	guint cpu_id;
	LttTime event_time;
}irq_entry;

enum type_t 
{
   IRQ_ENTRY,
   IRQ_EXIT		
};

/** Array containing instanced objects. Used when module is unloaded */
static GSList *interrupt_data_list = NULL ;
 

#define TRACE_NUMBER 0

typedef struct _InterruptEventData 
{

  /* Graphical Widgets */ 
  GtkWidget * ScrollWindow;
  GtkListStore *ListStore;
  GtkWidget *Hbox;
  GtkWidget *TreeView;
  GtkTreeSelection *SelectionTree;
  
  Tab 	     * tab; /* tab that contains this plug-in*/ 
  LttvPluginTab    * ptab;
  LttvHooks  * event_hooks;
  LttvHooks  * hooks_trace_after;
  LttvHooks  * hooks_trace_before;
  TimeWindow   time_window;
  LttvHooksById * event_by_id_hooks;
  GArray *IrqExit;
  GArray *IrqEntry;
} InterruptEventData ;


/* Function prototypes */
 
static gboolean interrupt_update_time_window(void * hook_data, void * call_data);
static GtkWidget *interrupts(LttvPlugin *plugin);
static InterruptEventData *system_info(LttvPluginTab *ptab);
void interrupt_destructor(InterruptEventData *event_viewer_data);
static void request_event(InterruptEventData *event_data );  
static guint64 get_interrupt_id(LttEvent *e);
static gboolean trace_header(void *hook_data, void *call_data);
static gboolean interrupt_display (void *hook_data, void *call_data);
static void calcul_duration(LttTime time_exit,  guint cpu_id,  InterruptEventData *event_data);
static void sum_interrupt_data(irq_entry *e, LttTime time_exit, GArray *interrupt_counters);
static gboolean irq_entry_callback(void *hook_data, void *call_data);
static gboolean irq_exit_callback(void *hook_data, void *call_data);
static void InterruptFree(InterruptEventData *event_viewer_data);
static int FrequencyInHZ(gint NumerofInterruptions, TimeWindow time_window);
/* Enumeration of the columns */
enum{
  CPUID_COLUMN,
  IRQ_ID_COLUMN,
  FREQUENCY_COLUMN,
  DURATION_COLUMN,
  N_COLUMNS
};
 
 
 
/**
 *  init function
 *
 * 
 * This is the entry point of the viewer.
 *
 */
static void init() 
{
  g_info("interrupts: init()");
  
  lttvwindow_register_constructor("tutorial",
                                  "/",
                                  "Insert  Interrupts View",
                                  hTutorialInsert_xpm,
                                  "Insert Interrupts View",
                                  interrupts);   
}


/**
 *  Constructor hook
 *
 */
static GtkWidget *interrupts(LttvPlugin *plugin)
{
  LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin);
  InterruptEventData* event_data = system_info(ptab) ;
  if(event_data)
    return event_data->Hbox;
  else 
    return NULL; 
}

/**
 * This function initializes the Event Viewer functionnality through the
 * GTK  API. 
 */
InterruptEventData *system_info(LttvPluginTab *ptab)
{
  LttTime end;
  GtkTreeViewColumn *column;
  GtkCellRenderer *renderer;
  InterruptEventData* event_viewer_data = g_new(InterruptEventData,1) ;
  Tab *tab = ptab->tab;
   
  event_viewer_data->tab = tab;
  event_viewer_data->ptab = ptab;
  
  /*Get the current time frame from the main window */
  event_viewer_data->time_window  =  lttvwindow_get_time_window(tab);
  event_viewer_data->IrqExit = g_array_new(FALSE, FALSE, sizeof(Irq));
  event_viewer_data->IrqEntry   =  g_array_new(FALSE, FALSE, sizeof(irq_entry));
  
  /*Create tha main window for the viewer */					 	
  event_viewer_data->ScrollWindow = gtk_scrolled_window_new (NULL, NULL);
  gtk_widget_show (event_viewer_data->ScrollWindow);
  gtk_scrolled_window_set_policy(
      GTK_SCROLLED_WINDOW(event_viewer_data->ScrollWindow), 
      GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 
  /* Create a model for storing the data list */
  event_viewer_data->ListStore = gtk_list_store_new (
    N_COLUMNS,      /* Total number of columns     */
    G_TYPE_INT,     /* CPUID                       */
    G_TYPE_INT,     /* IRQ_ID                      */
    G_TYPE_INT,     /* Frequency 		   */
    G_TYPE_UINT64   /* Duration                    */
    );  
 
  event_viewer_data->TreeView = gtk_tree_view_new_with_model (GTK_TREE_MODEL (event_viewer_data->ListStore)); 
   
  g_object_unref (G_OBJECT (event_viewer_data->ListStore));
    
  renderer = gtk_cell_renderer_text_new ();
  column = gtk_tree_view_column_new_with_attributes ("CPU ID",
                 renderer,
                 "text", CPUID_COLUMN,
                 NULL);
  gtk_tree_view_column_set_alignment (column, 0.0);
  gtk_tree_view_column_set_fixed_width (column, 45);
  gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->TreeView), column);

   
  renderer = gtk_cell_renderer_text_new ();
  column = gtk_tree_view_column_new_with_attributes ("IRQ ID",
                 renderer,
                 "text", IRQ_ID_COLUMN,
                 NULL);
  gtk_tree_view_column_set_alignment (column, 0.0);
  gtk_tree_view_column_set_fixed_width (column,  220);
  gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->TreeView), column);

  renderer = gtk_cell_renderer_text_new ();
  column = gtk_tree_view_column_new_with_attributes ("Frequency (HZ)",
                 renderer,
                 "text", FREQUENCY_COLUMN,
                 NULL);
  gtk_tree_view_column_set_alignment (column, 1.0);
  gtk_tree_view_column_set_fixed_width (column, 220);
  gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->TreeView), column);

  renderer = gtk_cell_renderer_text_new ();
  column = gtk_tree_view_column_new_with_attributes ("Total Duration (nsec)",
                 renderer,
                 "text", DURATION_COLUMN,
                 NULL);
  gtk_tree_view_column_set_alignment (column, 0.0);
  gtk_tree_view_column_set_fixed_width (column, 145);
  gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->TreeView), column);

  event_viewer_data->SelectionTree = gtk_tree_view_get_selection (GTK_TREE_VIEW (event_viewer_data->TreeView));
  gtk_tree_selection_set_mode (event_viewer_data->SelectionTree, GTK_SELECTION_SINGLE);
   
  gtk_container_add (GTK_CONTAINER (event_viewer_data->ScrollWindow), event_viewer_data->TreeView);
   
  event_viewer_data->Hbox = gtk_hbox_new(0, 0);
  gtk_box_pack_start(GTK_BOX(event_viewer_data->Hbox), event_viewer_data->ScrollWindow, TRUE, TRUE, 0);
 
  gtk_widget_show(event_viewer_data->Hbox);
  gtk_widget_show(event_viewer_data->TreeView);

  interrupt_data_list = g_slist_append(interrupt_data_list, event_viewer_data);
  
  /* Registration for time notification */
  lttvwindow_register_time_window_notify(tab,
                                         interrupt_update_time_window,
                                         event_viewer_data);	
   
  g_object_set_data_full(G_OBJECT(event_viewer_data->Hbox),
      "event_data",
       event_viewer_data,
      (GDestroyNotify) InterruptFree);  					 
					 
  
  request_event(event_viewer_data );
  return event_viewer_data;
}

/**
 * 
 * For each trace in the traceset, this function:
 *  - registers a callback function to each hook
 *  - calls lttv_trace_find_hook() registers a hook function to event_by_id_hooks
 *  - calls lttvwindow_events_request() to request data in a specific 
 *    time interval to the main window
 * 
 */
static void request_event(InterruptEventData *event_data )
{
  guint i, k, l, nb_trace;
 
  LttvTraceHook *hook;
   
  guint ret; 
  
  LttvTraceState *ts;
    
  GArray *hooks;
   
  EventsRequest *events_request;
  
  LttvTraceHookByFacility *thf;
  
  LttvTracesetContext *tsc = lttvwindow_get_traceset_context(event_data->tab);
  
  
  /* Get the traceset */
  LttvTraceset *traceset = tsc->ts;
 
  nb_trace = lttv_traceset_number(traceset);
  
  /* There are many traces in a traceset. Iteration for each trace. */  
  for(i = 0; i<MIN(TRACE_NUMBER+1, nb_trace);i++)
  {
        events_request = g_new(EventsRequest, 1); 
	
      	hooks = g_array_new(FALSE, FALSE, sizeof(LttvTraceHook));
      	
	hooks = g_array_set_size(hooks, 2);
    
	event_data->hooks_trace_before = lttv_hooks_new();
	
  	/* Registers a hook function */
	lttv_hooks_add(event_data->hooks_trace_before, trace_header, event_data, LTTV_PRIO_DEFAULT);	

  	event_data->hooks_trace_after = lttv_hooks_new();
  	/* Registers a hook function */
	lttv_hooks_add(event_data->hooks_trace_after, interrupt_display, event_data, LTTV_PRIO_DEFAULT);
 	/* Get a trace state */
	ts = (LttvTraceState *)tsc->traces[i];
	/* Create event_by_Id hooks */
  	event_data->event_by_id_hooks = lttv_hooks_by_id_new();
  
 	/*Register event_by_id_hooks with a callback function*/ 
          ret = lttv_trace_find_hook(ts->parent.t,
		LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
		LTT_FIELD_IRQ_ID, 0, 0,
		irq_entry_callback,
		events_request,
		&g_array_index(hooks, LttvTraceHook, 0));
	 
	 ret = lttv_trace_find_hook(ts->parent.t,
		LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_EXIT,
		LTT_FIELD_IRQ_ID, 0, 0,
		irq_exit_callback,
		events_request,
		&g_array_index(hooks, LttvTraceHook, 1));
		
	  g_assert(!ret);
 	 
	/*iterate through the facility list*/
	for(k = 0 ; k < hooks->len; k++) 
	{ 
	        hook = &g_array_index(hooks, LttvTraceHook, k);
		for(l=0; l<hook->fac_list->len; l++) 
		{
			thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l); 
			lttv_hooks_add(lttv_hooks_by_id_find(event_data->event_by_id_hooks, thf->id),
				thf->h,
				event_data,
				LTTV_PRIO_DEFAULT);
			 
		}
	}
	
	/* Initalize the EventsRequest structure */
	events_request->owner       = event_data; 
	events_request->viewer_data = event_data; 
	events_request->servicing   = FALSE;     
	events_request->start_time  = event_data->time_window.start_time; 
	events_request->start_position  = NULL;
	events_request->stop_flag	   = FALSE;
	events_request->end_time 	   = event_data->time_window.end_time;
	events_request->num_events  	   = G_MAXUINT;      
	events_request->end_position       = NULL; 
	events_request->trace 	   = i;    
	
	events_request->hooks = hooks;
	
	events_request->before_chunk_traceset = NULL; 
	events_request->before_chunk_trace    = event_data->hooks_trace_before; 
	events_request->before_chunk_tracefile= NULL; 
	events_request->event		        = NULL;  
	events_request->event_by_id		= event_data->event_by_id_hooks; 
	events_request->after_chunk_tracefile = NULL; 
	events_request->after_chunk_trace     = NULL;   
	events_request->after_chunk_traceset	= NULL; 
	events_request->before_request	= NULL; 
	events_request->after_request		= event_data->hooks_trace_after; 
	
	lttvwindow_events_request(event_data->tab, events_request);   
   }
   
}

/**
 *  This function is called whenever an irq_entry event occurs.  
 *  
 */ 
static gboolean irq_entry_callback(void *hook_data, void *call_data)
{
  
  LttTime  event_time; 
  unsigned cpu_id;
  irq_entry entry;
  LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
  LttvTracefileState *tfs = (LttvTracefileState *)call_data;
  InterruptEventData *event_data = (InterruptEventData *)hook_data;
  GArray* IrqEntry  = event_data->IrqEntry; 
  LttEvent *e = ltt_tracefile_get_event(tfc->tf); 
  event_time = ltt_event_time(e);
  cpu_id = ltt_event_cpu_id(e);
   
  if ((ltt_time_compare(event_time,event_data->time_window.start_time) == TRUE) &&    
     (ltt_time_compare(event_data->time_window.end_time,event_time) == TRUE))
  { 	 
	entry.id =get_interrupt_id(e);	  
	entry.cpu_id = cpu_id;
	entry.event_time =  event_time;		
	g_array_append_val (IrqEntry, entry);
  } 
  return FALSE;
}

/**
 *  This function gets the id of the interrupt. The id is stored in a dynamic structure. 
 *  Refer to the print.c file for howto extract data from a dynamic structure.
 */ 
static guint64 get_interrupt_id(LttEvent *e)
{
  guint i, num_fields;
  LttEventType *event_type;
  LttField *element;  
  LttField *field;
   guint64  irq_id;
  event_type = ltt_event_eventtype(e);
  num_fields = ltt_eventtype_num_fields(event_type);
  for(i = 0 ; i < num_fields-1 ; i++) 
  {   
        field = ltt_eventtype_field(event_type, i);
  	irq_id = ltt_event_get_long_unsigned(e,field);
  }
  return  irq_id;

} 
/**
 *  This function is called whenever an irq_exit event occurs.  
 *  
 */ 
gboolean irq_exit_callback(void *hook_data, void *call_data)
{
  LttTime  event_time; 
  unsigned cpu_id;
  LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
  LttvTracefileState *tfs = (LttvTracefileState *)call_data;
  InterruptEventData *event_data = (InterruptEventData *)hook_data;
  LttEvent *e = ltt_tracefile_get_event(tfc->tf);
  LttEventType *type = ltt_event_eventtype(e);
  event_time = ltt_event_time(e);
  cpu_id = ltt_event_cpu_id(e);
  if ((ltt_time_compare(event_time,event_data->time_window.start_time) == TRUE) &&    
     (ltt_time_compare(event_data->time_window.end_time,event_time) == TRUE))
     {
     	 calcul_duration( event_time,  cpu_id, event_data);
	 
     }
   return FALSE;
}

/**
 *  This function calculates the duration of an interrupt.  
 *  
 */ 
static void calcul_duration(LttTime time_exit,  guint cpu_id,InterruptEventData *event_data){
  
  gint i, irq_id;
  irq_entry *element; 
  LttTime duration;
  GArray *IrqExit = event_data->IrqExit;
  GArray *IrqEntry = event_data->IrqEntry;
  for(i = 0; i < IrqEntry->len; i++){
    element = &g_array_index(IrqEntry,irq_entry,i);
    if(element->cpu_id == cpu_id)
    {
      sum_interrupt_data(element,time_exit,  IrqExit);    
      g_array_remove_index(IrqEntry, i);
      break;
    }
  }
}
/**
 *  This function calculates the total duration of an interrupt.  
 *  
 */ 
static void sum_interrupt_data(irq_entry *e, LttTime time_exit, GArray *IrqExit)
{
  Irq irq;
  Irq *element; 
  guint i;
  LttTime duration;
  gboolean  notFound = FALSE;
  memset ((void*)&irq, 0,sizeof(Irq));
  
  
  if(IrqExit->len == NO_ITEMS)
  {
    irq.cpu_id = e->cpu_id;
    irq.id    =  e->id;
    irq.TotalNumberOfInterrupts++;
    irq.total_duration =  ltt_time_sub(time_exit, e->event_time);
    g_array_append_val (IrqExit, irq);
  }
  else{
    for(i = 0; i < IrqExit->len; i++)
    {
      element = &g_array_index(IrqExit, Irq, i);
      if(element->id == e->id){
	notFound = TRUE;
	duration =  ltt_time_sub(time_exit, e->event_time);
	element->total_duration = ltt_time_add(element->total_duration, duration);
	element->TotalNumberOfInterrupts++;
      }
    }
    
    if(!notFound)
    {
      irq.cpu_id = e->cpu_id;
      irq.id    =  e->id;
      irq.TotalNumberOfInterrupts++;
      irq.total_duration =  ltt_time_sub(time_exit, e->event_time);
      g_array_append_val (IrqExit, irq);
    }
  } 
}

/**
 *  This function displays the result on the viewer 
 *  
 */ 
static gboolean interrupt_display(void *hook_data, void *call_data)
{
  
  gint i;	
  Irq element; 
  LttTime average_duration;
  GtkTreeIter    iter;
  guint64 real_data;
  int FrequencyHZ =  0; 
  
  InterruptEventData *event_data = (InterruptEventData *)hook_data;
  GArray *IrqExit = event_data->IrqExit;  
  gtk_list_store_clear(event_data->ListStore);
  for(i = 0; i < IrqExit->len; i++)
  {  
  
    element = g_array_index(IrqExit,Irq,i);  
    real_data = element.total_duration.tv_sec;
    real_data *= NANOSECONDS_PER_SECOND;
    real_data += element.total_duration.tv_nsec;
    
    FrequencyHZ =  FrequencyInHZ(element.TotalNumberOfInterrupts,event_data->time_window);
   
    gtk_list_store_append (event_data->ListStore, &iter);
    
    gtk_list_store_set (event_data->ListStore, &iter,
      CPUID_COLUMN, element.cpu_id,
      IRQ_ID_COLUMN,  element.id,
      FREQUENCY_COLUMN, FrequencyHZ,
      DURATION_COLUMN, real_data,
      -1);
     
  } 
   
  if(event_data->IrqExit->len)
     g_array_remove_range (event_data->IrqExit,0,event_data->IrqExit->len);
   
  if(event_data->IrqEntry->len)
    g_array_remove_range (event_data->IrqEntry,0,event_data->IrqEntry->len);
  return FALSE;
}

/**
 *  This function converts the number of interrupts over a time window to
 *  frequency in HZ
 */ 
static int FrequencyInHZ(gint NumerofInterruptions, TimeWindow time_window)
{
  guint64 frequencyHz = 0;
  double timeSec;  // time in second
  double result; 
  result  = ltt_time_to_double(time_window.time_width);
  timeSec = (result/NANOSECONDS_PER_SECOND);  //time in second
  frequencyHz = NumerofInterruptions / timeSec;  
  return  frequencyHz;
}


/*
 * This function is called by the main window
 * when the time interval needs to be updated.
 **/ 
gboolean interrupt_update_time_window(void * hook_data, void * call_data)
{
  InterruptEventData *event_data = (InterruptEventData *) hook_data;
  const TimeWindowNotifyData *time_window_nofify_data =  ((const TimeWindowNotifyData *)call_data);
  event_data->time_window = *time_window_nofify_data->new_time_window;
  g_info("interrupts: interrupt_update_time_window()\n");
  Tab *tab = event_data->tab;
  lttvwindow_events_request_remove_all(tab, event_data);
  request_event(event_data );
  return FALSE;
}


gboolean trace_header(void *hook_data, void *call_data)
{

  InterruptEventData *event_data = (InterruptEventData *)hook_data;
  LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
  LttEvent *e;
  LttTime event_time;
  return FALSE;
}

void interrupt_destroy_walk(gpointer data, gpointer user_data)
{
  g_info("interrupt_destroy_walk");
  interrupt_destructor((InterruptEventData*)data);

}

void interrupt_destructor(InterruptEventData *event_viewer_data)
{
  /* May already been done by GTK window closing */
  g_info("enter interrupt_destructor \n");
  if(GTK_IS_WIDGET(event_viewer_data->Hbox))
  {
    gtk_widget_destroy(event_viewer_data->Hbox);
  }
}

/**
    This function is called when the viewer is destroyed to free hooks and memory
*/
static void InterruptFree(InterruptEventData *event_viewer_data)
{
  Tab *tab = event_viewer_data->tab;
  if(tab != NULL)
  {
     g_array_free(event_viewer_data->IrqExit, TRUE);
     
     g_array_free(event_viewer_data->IrqEntry, TRUE);
     
     lttvwindow_unregister_time_window_notify(tab, interrupt_update_time_window, event_viewer_data);
     	
     lttvwindow_events_request_remove_all(event_viewer_data->tab,
                                          event_viewer_data);	
					  
     interrupt_data_list = g_slist_remove(interrupt_data_list, event_viewer_data);					  
      
  }
 	
}

/**
 * plugin's destroy function
 *
 * This function releases the memory reserved by the module and unregisters
 * everything that has been registered in the gtkTraceSet API.
 */
static void destroy() {
  g_info("Destroy  interrupts");
  g_slist_foreach(interrupt_data_list, interrupt_destroy_walk, NULL );
  g_slist_free(interrupt_data_list); 
  lttvwindow_unregister_constructor(interrupts);
  
}

LTTV_MODULE("tutorial", "interrupts info view", \
    "Graphical module to display interrupts performance", \
	    init, destroy, "lttvwindow")