projects / lttv.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
first working version of resourceview
[lttv.git] / ltt / branches / poly / lttv / modules / gui / resourceview / eventhooks.c
CommitLineData
9e01e6d4 1/* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Mathieu Desnoyers
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
16 * MA 02111-1307, USA.
17 */
18
19
20/*****************************************************************************
21 * Hooks to be called by the main window *
22 *****************************************************************************/
23
24
25/* Event hooks are the drawing hooks called during traceset read. They draw the
26 * icons, text, lines and background color corresponding to the events read.
27 *
28 * Two hooks are used for drawing : before_schedchange and after_schedchange hooks. The
29 * before_schedchange is called before the state update that occurs with an event and
30 * the after_schedchange hook is called after this state update.
31 *
32 * The before_schedchange hooks fulfill the task of drawing the visible objects that
33 * corresponds to the data accumulated by the after_schedchange hook.
34 *
35 * The after_schedchange hook accumulates the data that need to be shown on the screen
36 * (items) into a queue. Then, the next before_schedchange hook will draw what that
37 * queue contains. That's the Right Way (TM) of drawing items on the screen,
38 * because we need to draw the background first (and then add icons, text, ...
39 * over it), but we only know the length of a background region once the state
40 * corresponding to it is over, which happens to be at the next before_schedchange
41 * hook.
42 *
43 * We also have a hook called at the end of a chunk to draw the information left
44 * undrawn in each process queue. We use the current time as end of
45 * line/background.
46 */
47
48#ifdef HAVE_CONFIG_H
49#include <config.h>
50#endif
51
52//#define PANGO_ENABLE_BACKEND
53#include <gtk/gtk.h>
54#include <gdk/gdk.h>
55#include <glib.h>
56#include <assert.h>
57#include <string.h>
58#include <stdio.h>
59
60//#include <pango/pango.h>
61
62#include <ltt/event.h>
63#include <ltt/time.h>
64#include <ltt/type.h>
65#include <ltt/trace.h>
66
67#include <lttv/lttv.h>
68#include <lttv/hook.h>
69#include <lttv/state.h>
70#include <lttvwindow/lttvwindow.h>
71#include <lttvwindow/lttvwindowtraces.h>
72#include <lttvwindow/support.h>
73
74
75#include "eventhooks.h"
76#include "cfv.h"
77#include "processlist.h"
78#include "drawing.h"
79
80
81#define MAX_PATH_LEN 256
82#define STATE_LINE_WIDTH 4
83#define COLLISION_POSITION(height) (((height - STATE_LINE_WIDTH)/2) -3)
84
85extern GSList *g_legend_list;
86
87
88/* Action to do when background computation completed.
89 *
90 * Wait for all the awaited computations to be over.
91 */
92
93static gint background_ready(void *hook_data, void *call_data)
94{
95 ControlFlowData *control_flow_data = (ControlFlowData *)hook_data;
96 LttvTrace *trace = (LttvTrace*)call_data;
97
98 control_flow_data->background_info_waiting--;
99
100 if(control_flow_data->background_info_waiting == 0) {
101 g_message("control flow viewer : background computation data ready.");
102
103 drawing_clear(control_flow_data->drawing);
104 processlist_clear(control_flow_data->process_list);
105 gtk_widget_set_size_request(
106 control_flow_data->drawing->drawing_area,
107 -1, processlist_get_height(control_flow_data->process_list));
108 redraw_notify(control_flow_data, NULL);
109 }
110
111 return 0;
112}
113
114
115/* Request background computation. Verify if it is in progress or ready first.
116 * Only for each trace in the tab's traceset.
117 */
118static void request_background_data(ControlFlowData *control_flow_data)
119{
120 LttvTracesetContext * tsc =
121 lttvwindow_get_traceset_context(control_flow_data->tab);
122 gint num_traces = lttv_traceset_number(tsc->ts);
123 gint i;
124 LttvTrace *trace;
125 LttvTraceState *tstate;
126
127 LttvHooks *background_ready_hook =
128 lttv_hooks_new();
129 lttv_hooks_add(background_ready_hook, background_ready, control_flow_data,
130 LTTV_PRIO_DEFAULT);
131 control_flow_data->background_info_waiting = 0;
132
133 for(i=0;i<num_traces;i++) {
134 trace = lttv_traceset_get(tsc->ts, i);
135 tstate = LTTV_TRACE_STATE(tsc->traces[i]);
136
137 if(lttvwindowtraces_get_ready(g_quark_from_string("state"),trace)==FALSE
138 && !tstate->has_precomputed_states) {
139
140 if(lttvwindowtraces_get_in_progress(g_quark_from_string("state"),
141 trace) == FALSE) {
142 /* We first remove requests that could have been done for the same
143 * information. Happens when two viewers ask for it before servicing
144 * starts.
145 */
146 if(!lttvwindowtraces_background_request_find(trace, "state"))
147 lttvwindowtraces_background_request_queue(
148 main_window_get_widget(control_flow_data->tab), trace, "state");
149 lttvwindowtraces_background_notify_queue(control_flow_data,
150 trace,
151 ltt_time_infinite,
152 NULL,
153 background_ready_hook);
154 control_flow_data->background_info_waiting++;
155 } else { /* in progress */
156
157 lttvwindowtraces_background_notify_current(control_flow_data,
158 trace,
159 ltt_time_infinite,
160 NULL,
161 background_ready_hook);
162 control_flow_data->background_info_waiting++;
163 }
164 } else {
165 /* Data ready. By its nature, this viewer doesn't need to have
166 * its data ready hook called there, because a background
167 * request is always linked with a redraw.
168 */
169 }
170
171 }
172
173 lttv_hooks_destroy(background_ready_hook);
174}
175
176
177
178
179/**
180 * Event Viewer's constructor hook
181 *
182 * This constructor is given as a parameter to the menuitem and toolbar button
183 * registration. It creates the list.
184 * @param tab A pointer to the parent tab.
185 * @return The widget created.
186 */
187GtkWidget *
58a9b31b 188h_resourceview(LttvPlugin *plugin)
9e01e6d4 189{
190 LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin);
191 Tab *tab = ptab->tab;
192 g_info("h_guicontrolflow, %p", tab);
58a9b31b 193 ControlFlowData *control_flow_data = resourceview(ptab);
9e01e6d4 194
195 control_flow_data->tab = tab;
196
197 // Unreg done in the GuiControlFlow_Destructor
198 lttvwindow_register_traceset_notify(tab,
199 traceset_notify,
200 control_flow_data);
201
202 lttvwindow_register_time_window_notify(tab,
203 update_time_window_hook,
204 control_flow_data);
205 lttvwindow_register_current_time_notify(tab,
206 update_current_time_hook,
207 control_flow_data);
208 lttvwindow_register_redraw_notify(tab,
209 redraw_notify,
210 control_flow_data);
211 lttvwindow_register_continue_notify(tab,
212 continue_notify,
213 control_flow_data);
214 request_background_data(control_flow_data);
215
216
217 return guicontrolflow_get_widget(control_flow_data) ;
218
219}
220
221void legend_destructor(GtkWindow *legend)
222{
223 g_legend_list = g_slist_remove(g_legend_list, legend);
224}
225
226/* Create a popup legend */
227GtkWidget *
228h_legend(LttvPlugin *plugin)
229{
230 LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin);
231 Tab *tab = ptab->tab;
232 g_info("h_legend, %p", tab);
233
234 GtkWindow *legend = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
235
236 g_legend_list = g_slist_append(
237 g_legend_list,
238 legend);
239
240 g_object_set_data_full(
241 G_OBJECT(legend),
242 "legend",
243 legend,
244 (GDestroyNotify)legend_destructor);
245
246 gtk_window_set_title(legend, "Control Flow View Legend");
247
248 GtkWidget *pixmap = create_pixmap(GTK_WIDGET(legend), "lttv-color-list.png");
249
250 // GtkImage *image = GTK_IMAGE(gtk_image_new_from_pixmap(
251 // GDK_PIXMAP(pixmap), NULL));
252
253 gtk_container_add(GTK_CONTAINER(legend), GTK_WIDGET(pixmap));
254
255 gtk_widget_show(GTK_WIDGET(pixmap));
256 gtk_widget_show(GTK_WIDGET(legend));
257
258
259 return NULL; /* This is a popup window */
260}
261
262
263int event_selected_hook(void *hook_data, void *call_data)
264{
265 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
266 guint *event_number = (guint*) call_data;
267
268 g_debug("DEBUG : event selected by main window : %u", *event_number);
269
270 return 0;
271}
272
273/* Function that selects the color of status&exemode line */
274static inline PropertiesLine prepare_s_e_line(LttvProcessState *process)
275{
276 PropertiesLine prop_line;
277 prop_line.line_width = STATE_LINE_WIDTH;
278 prop_line.style = GDK_LINE_SOLID;
279 prop_line.y = MIDDLE;
9e01e6d4 280
281 if(process->state->s == LTTV_STATE_RUN) {
282 if(process->state->t == LTTV_STATE_USER_MODE)
283 prop_line.color = drawing_colors[COL_RUN_USER_MODE];
284 else if(process->state->t == LTTV_STATE_SYSCALL)
285 prop_line.color = drawing_colors[COL_RUN_SYSCALL];
286 else if(process->state->t == LTTV_STATE_TRAP)
287 prop_line.color = drawing_colors[COL_RUN_TRAP];
288 else if(process->state->t == LTTV_STATE_IRQ)
289 prop_line.color = drawing_colors[COL_RUN_IRQ];
290 else if(process->state->t == LTTV_STATE_SOFT_IRQ)
291 prop_line.color = drawing_colors[COL_RUN_SOFT_IRQ];
292 else if(process->state->t == LTTV_STATE_MODE_UNKNOWN)
293 prop_line.color = drawing_colors[COL_MODE_UNKNOWN];
294 else
295 g_assert(FALSE); /* RUNNING MODE UNKNOWN */
296 } else if(process->state->s == LTTV_STATE_WAIT) {
297 /* We don't show if we wait while in user mode, trap, irq or syscall */
298 prop_line.color = drawing_colors[COL_WAIT];
299 } else if(process->state->s == LTTV_STATE_WAIT_CPU) {
300 /* We don't show if we wait for CPU while in user mode, trap, irq
301 * or syscall */
302 prop_line.color = drawing_colors[COL_WAIT_CPU];
303 } else if(process->state->s == LTTV_STATE_ZOMBIE) {
304 prop_line.color = drawing_colors[COL_ZOMBIE];
305 } else if(process->state->s == LTTV_STATE_WAIT_FORK) {
306 prop_line.color = drawing_colors[COL_WAIT_FORK];
307 } else if(process->state->s == LTTV_STATE_EXIT) {
308 prop_line.color = drawing_colors[COL_EXIT];
309 } else if(process->state->s == LTTV_STATE_UNNAMED) {
310 prop_line.color = drawing_colors[COL_UNNAMED];
311 } else {
312 g_critical("unknown state : %s", g_quark_to_string(process->state->s));
313 g_assert(FALSE); /* UNKNOWN STATE */
314 }
315
316 return prop_line;
317
318}
319
320
321/* before_schedchange_hook
322 *
323 * This function basically draw lines and icons. Two types of lines are drawn :
324 * one small (3 pixels?) representing the state of the process and the second
325 * type is thicker (10 pixels?) representing on which CPU a process is running
326 * (and this only in running state).
327 *
328 * Extremums of the lines :
329 * x_min : time of the last event context for this process kept in memory.
330 * x_max : time of the current event.
331 * y : middle of the process in the process list. The process is found in the
332 * list, therefore is it's position in pixels.
333 *
334 * The choice of lines'color is defined by the context of the last event for this
335 * process.
336 */
337
338
339int before_schedchange_hook(void *hook_data, void *call_data)
340{
341 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
342 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
343 ControlFlowData *control_flow_data = events_request->viewer_data;
344
345 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
346
347 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
348 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
349
350 LttEvent *e;
351 e = ltt_tracefile_get_event(tfc->tf);
352 gint target_pid_saved = tfc->target_pid;
353
354 LttTime evtime = ltt_event_time(e);
355 LttvFilter *filter = control_flow_data->filter;
356
58a9b31b 357 gchar *cpustr;
358 GQuark cpuq;
359
9e01e6d4 360 /* we are in a schedchange, before the state update. We must draw the
361 * items corresponding to the state before it changes : now is the right
362 * time to do it.
363 */
364
365 guint pid_out;
366 guint pid_in;
58a9b31b 367 pid_out = ltt_event_get_long_unsigned(e, thf->f1);
368 pid_in = ltt_event_get_long_unsigned(e, thf->f2);
369 if(pid_in != 0 && pid_out != 0) {
370 /* not a transition to/from idle */
371 return 0;
9e01e6d4 372 }
c4e6f4dc 373
374 g_debug("a");
9e01e6d4 375
376 tfc->target_pid = pid_out;
58a9b31b 377// if(!filter || !filter->head ||
378// lttv_filter_tree_parse(filter->head,e,tfc->tf,
379// tfc->t_context->t,tfc,NULL,NULL)) {
9e01e6d4 380 /* For the pid_out */
381 /* First, check if the current process is in the state computation
382 * process list. If it is there, that means we must add it right now and
383 * draw items from the beginning of the read for it. If it is not
384 * present, it's a new process and it was not present : it will
385 * be added after the state update. */
386 guint cpu = tfs->cpu;
58a9b31b 387 cpustr = g_strdup_printf("CPU%u", cpu);
388 cpuq = g_quark_from_string(cpustr);
389 g_free(cpustr);
390
9e01e6d4 391 guint trace_num = ts->parent.index;
58a9b31b 392// LttvProcessState *process = ts->running_process[cpu];
9e01e6d4 393 /* unknown state, bad current pid */
58a9b31b 394// if(process->pid != pid_out)
395// process = lttv_state_find_process(ts,
396// tfs->cpu, pid_out);
9e01e6d4 397
58a9b31b 398// if(process != NULL) {
9e01e6d4 399 /* Well, the process_out existed : we must get it in the process hash
400 * or add it, and draw its items.
401 */
402 /* Add process to process list (if not present) */
403 guint pl_height = 0;
58a9b31b 404 HashedResourceData *hashed_process_data = NULL;
9e01e6d4 405 ProcessList *process_list = control_flow_data->process_list;
58a9b31b 406// LttTime birth = process->creation_time;
9e01e6d4 407
58a9b31b 408 hashed_process_data = processlist_get_process_data(process_list, cpuq, trace_num);
409// hashed_process_data = processlist_get_process_data(process_list,
410// pid_out,
411// process->cpu,
412// &birth,
413// trace_num);
9e01e6d4 414 if(hashed_process_data == NULL)
415 {
58a9b31b 416// g_assert(pid_out == 0 || pid_out != process->ppid);
9e01e6d4 417 /* Process not present */
58a9b31b 418 ResourceInfo *process_info;
9e01e6d4 419 Drawing_t *drawing = control_flow_data->drawing;
c4e6f4dc 420 resourcelist_add(process_list,
9e01e6d4 421 drawing,
c4e6f4dc 422// pid_out,
423// process->tgid,
424// process->cpu,
425// process->ppid,
426// &birth,
58a9b31b 427 trace_num,
428 cpuq, //process->name,
c4e6f4dc 429// process->brand,
9e01e6d4 430 &pl_height,
431 &process_info,
432 &hashed_process_data);
433 gtk_widget_set_size_request(drawing->drawing_area,
434 -1,
435 pl_height);
436 gtk_widget_queue_draw(drawing->drawing_area);
437
438 }
439
440 /* Now, the process is in the state hash and our own process hash.
441 * We definitely can draw the items related to the ending state.
442 */
443
444 if(ltt_time_compare(hashed_process_data->next_good_time,
445 evtime) > 0)
446 {
447 if(hashed_process_data->x.middle_marked == FALSE) {
448
449 TimeWindow time_window =
450 lttvwindow_get_time_window(control_flow_data->tab);
451#ifdef EXTRA_CHECK
452 if(ltt_time_compare(evtime, time_window.start_time) == -1
453 || ltt_time_compare(evtime, time_window.end_time) == 1)
454 return;
455#endif //EXTRA_CHECK
456 Drawing_t *drawing = control_flow_data->drawing;
457 guint width = drawing->width;
458 guint x;
459 convert_time_to_pixels(
460 time_window,
461 evtime,
462 width,
463 &x);
464
465 /* Draw collision indicator */
466 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
467 gdk_draw_point(hashed_process_data->pixmap,
468 drawing->gc,
469 x,
470 COLLISION_POSITION(hashed_process_data->height));
471 hashed_process_data->x.middle_marked = TRUE;
472 }
473 } else {
474 TimeWindow time_window =
475 lttvwindow_get_time_window(control_flow_data->tab);
476#ifdef EXTRA_CHECK
477 if(ltt_time_compare(evtime, time_window.start_time) == -1
478 || ltt_time_compare(evtime, time_window.end_time) == 1)
479 return;
480#endif //EXTRA_CHECK
481 Drawing_t *drawing = control_flow_data->drawing;
482 guint width = drawing->width;
483 guint x;
484 convert_time_to_pixels(
485 time_window,
486 evtime,
487 width,
488 &x);
489
490
491 /* Jump over draw if we are at the same x position */
492 if(x == hashed_process_data->x.middle &&
493 hashed_process_data->x.middle_used)
494 {
495 if(hashed_process_data->x.middle_marked == FALSE) {
496 /* Draw collision indicator */
497 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
498 gdk_draw_point(hashed_process_data->pixmap,
499 drawing->gc,
500 x,
501 COLLISION_POSITION(hashed_process_data->height));
502 hashed_process_data->x.middle_marked = TRUE;
503 }
504 /* jump */
505 } else {
506 DrawContext draw_context;
507
508 /* Now create the drawing context that will be used to draw
509 * items related to the last state. */
510 draw_context.drawable = hashed_process_data->pixmap;
511 draw_context.gc = drawing->gc;
512 draw_context.pango_layout = drawing->pango_layout;
513 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
514 draw_context.drawinfo.end.x = x;
515
516 draw_context.drawinfo.y.over = 1;
517 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
518 draw_context.drawinfo.y.under = hashed_process_data->height;
519
520 draw_context.drawinfo.start.offset.over = 0;
521 draw_context.drawinfo.start.offset.middle = 0;
522 draw_context.drawinfo.start.offset.under = 0;
523 draw_context.drawinfo.end.offset.over = 0;
524 draw_context.drawinfo.end.offset.middle = 0;
525 draw_context.drawinfo.end.offset.under = 0;
526
527 {
528 /* Draw the line */
58a9b31b 529 //PropertiesLine prop_line = prepare_s_e_line(process);
530 PropertiesLine prop_line;
531 prop_line.line_width = STATE_LINE_WIDTH;
532 prop_line.style = GDK_LINE_SOLID;
533 prop_line.y = MIDDLE;
534 if(pid_out == 0)
535 //prop_line.color = { 0, 0xCCCC, 0xCCCC, 0xCCCC }; /* gray */
536 prop_line.color = drawing_colors[COL_WHITE];
537 else
538 //prop_line.color = { 0, 0x0000, 0x0000, 0xFFFF }; /* blue */
539 prop_line.color = drawing_colors[COL_EXIT];
9e01e6d4 540
9e01e6d4 541 draw_line((void*)&prop_line, (void*)&draw_context);
9e01e6d4 542
58a9b31b 543 }
544 /* become the last x position */
545 hashed_process_data->x.middle = x;
546 hashed_process_data->x.middle_used = TRUE;
547 hashed_process_data->x.middle_marked = FALSE;
9e01e6d4 548
58a9b31b 549 /* Calculate the next good time */
550 convert_pixels_to_time(width, x+1, time_window,
551 &hashed_process_data->next_good_time);
552 }
553 }
554// }
555// }
556
557// tfc->target_pid = pid_in;
558// if(!filter || !filter->head ||
559// lttv_filter_tree_parse(filter->head,e,tfc->tf,
560// tfc->t_context->t,tfc,NULL,NULL)) {
561// /* For the pid_in */
562// /* First, check if the current process is in the state computation
563// * process list. If it is there, that means we must add it right now and
564// * draw items from the beginning of the read for it. If it is not
565// * present, it's a new process and it was not present : it will
566// * be added after the state update. */
567// LttvProcessState *process;
568// process = lttv_state_find_process(ts,
569// tfs->cpu, pid_in);
570// guint trace_num = ts->parent.index;
571//
572// if(process != NULL) {
573// /* Well, the process existed : we must get it in the process hash
574// * or add it, and draw its items.
575// */
576// /* Add process to process list (if not present) */
577// guint pl_height = 0;
578// HashedResourceData *hashed_process_data = NULL;
579// ProcessList *process_list = control_flow_data->process_list;
580// LttTime birth = process->creation_time;
581//
582// hashed_process_data = processlist_get_process_data(process_list, cpuq);
583//// hashed_process_data = processlist_get_process_data(process_list,
584//// pid_in,
585//// tfs->cpu,
586//// &birth,
587//// trace_num);
588// if(hashed_process_data == NULL)
589// {
590// g_assert(pid_in == 0 || pid_in != process->ppid);
591// /* Process not present */
592// ResourceInfo *process_info;
593// Drawing_t *drawing = control_flow_data->drawing;
594// resourcelist_add(process_list,
595// drawing,
596//// pid_in,
597//// process->tgid,
598//// tfs->cpu,
599//// process->ppid,
600//// &birth,
601//// trace_num,
602// process->name,
603//// process->brand,
604// &pl_height,
605// &process_info,
606// &hashed_process_data);
607// gtk_widget_set_size_request(drawing->drawing_area,
608// -1,
609// pl_height);
610// gtk_widget_queue_draw(drawing->drawing_area);
611//
612// }
613// //We could set the current process and hash here, but will be done
614// //by after schedchange hook
615//
616// /* Now, the process is in the state hash and our own process hash.
617// * We definitely can draw the items related to the ending state.
618// */
619//
620// if(ltt_time_compare(hashed_process_data->next_good_time,
621// evtime) > 0)
622// {
623// if(hashed_process_data->x.middle_marked == FALSE) {
624//
625// TimeWindow time_window =
626// lttvwindow_get_time_window(control_flow_data->tab);
627//#ifdef EXTRA_CHECK
628// if(ltt_time_compare(evtime, time_window.start_time) == -1
629// || ltt_time_compare(evtime, time_window.end_time) == 1)
630// return;
631//#endif //EXTRA_CHECK
632// Drawing_t *drawing = control_flow_data->drawing;
633// guint width = drawing->width;
634// guint x;
635// convert_time_to_pixels(
636// time_window,
637// evtime,
638// width,
639// &x);
640//
641// /* Draw collision indicator */
642// gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
643// gdk_draw_point(hashed_process_data->pixmap,
644// drawing->gc,
645// x,
646// COLLISION_POSITION(hashed_process_data->height));
647// hashed_process_data->x.middle_marked = TRUE;
648// }
649// } else {
650// TimeWindow time_window =
651// lttvwindow_get_time_window(control_flow_data->tab);
652//#ifdef EXTRA_CHECK
653// if(ltt_time_compare(evtime, time_window.start_time) == -1
654// || ltt_time_compare(evtime, time_window.end_time) == 1)
655// return;
656//#endif //EXTRA_CHECK
657// Drawing_t *drawing = control_flow_data->drawing;
658// guint width = drawing->width;
659// guint x;
660//
661// convert_time_to_pixels(
662// time_window,
663// evtime,
664// width,
665// &x);
666//
667//
668// /* Jump over draw if we are at the same x position */
669// if(x == hashed_process_data->x.middle &&
670// hashed_process_data->x.middle_used)
671// {
672// if(hashed_process_data->x.middle_marked == FALSE) {
673// /* Draw collision indicator */
674// gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
675// gdk_draw_point(hashed_process_data->pixmap,
676// drawing->gc,
677// x,
678// COLLISION_POSITION(hashed_process_data->height));
679// hashed_process_data->x.middle_marked = TRUE;
680// }
681// /* jump */
682// } else {
683// DrawContext draw_context;
684//
685// /* Now create the drawing context that will be used to draw
686// * items related to the last state. */
687// draw_context.drawable = hashed_process_data->pixmap;
688// draw_context.gc = drawing->gc;
689// draw_context.pango_layout = drawing->pango_layout;
690// draw_context.drawinfo.start.x = hashed_process_data->x.middle;
691// draw_context.drawinfo.end.x = x;
692//
693// draw_context.drawinfo.y.over = 1;
694// draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
695// draw_context.drawinfo.y.under = hashed_process_data->height;
696//
697// draw_context.drawinfo.start.offset.over = 0;
698// draw_context.drawinfo.start.offset.middle = 0;
699// draw_context.drawinfo.start.offset.under = 0;
700// draw_context.drawinfo.end.offset.over = 0;
701// draw_context.drawinfo.end.offset.middle = 0;
702// draw_context.drawinfo.end.offset.under = 0;
703//
704// {
705// /* Draw the line */
706// PropertiesLine prop_line = prepare_s_e_line(process);
707// draw_line((void*)&prop_line, (void*)&draw_context);
708// }
709//
710//
711// /* become the last x position */
712// hashed_process_data->x.middle = x;
713// hashed_process_data->x.middle_used = TRUE;
714// hashed_process_data->x.middle_marked = FALSE;
715//
716// /* Calculate the next good time */
717// convert_pixels_to_time(width, x+1, time_window,
718// &hashed_process_data->next_good_time);
719// }
720// }
721// } else
722// g_warning("Cannot find pin_in in schedchange %u", pid_in);
723// }
724// tfc->target_pid = target_pid_saved;
725 return 0;
9e01e6d4 726
9e01e6d4 727
9e01e6d4 728
9e01e6d4 729
58a9b31b 730 /* Text dump */
731#ifdef DONTSHOW
732 GString *string = g_string_new("");;
733 gboolean field_names = TRUE, state = TRUE;
9e01e6d4 734
58a9b31b 735 lttv_event_to_string(e, tfc->tf, string, TRUE, field_names, tfs);
736 g_string_append_printf(string,"\n");
9e01e6d4 737
58a9b31b 738 if(state) {
739 g_string_append_printf(string, " %s",
740 g_quark_to_string(tfs->process->state->s));
9e01e6d4 741 }
742
58a9b31b 743 g_info("%s",string->str);
9e01e6d4 744
58a9b31b 745 g_string_free(string, TRUE);
746
747 /* End of text dump */
748#endif //DONTSHOW
9e01e6d4 749
750}
751
58a9b31b 752/* after_schedchange_hook
753 *
754 * The draw after hook is called by the reading API to have a
755 * particular event drawn on the screen.
756 * @param hook_data ControlFlowData structure of the viewer.
757 * @param call_data Event context.
758 *
759 * This function adds items to be drawn in a queue for each process.
760 *
761 */
762int after_schedchange_hook(void *hook_data, void *call_data)
9e01e6d4 763{
58a9b31b 764// LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
765// EventsRequest *events_request = (EventsRequest*)thf->hook_data;
766// ControlFlowData *control_flow_data = events_request->viewer_data;
767//
768// LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
769//
770// LttvTracefileState *tfs = (LttvTracefileState *)call_data;
771//
772// LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
773//
774// LttEvent *e;
775// e = ltt_tracefile_get_event(tfc->tf);
776//
777// LttvFilter *filter = control_flow_data->filter;
778// if(filter != NULL && filter->head != NULL)
779// if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
780// tfc->t_context->t,tfc,NULL,NULL))
781// return FALSE;
782//
783// LttTime evtime = ltt_event_time(e);
784//
785// return 0;
786// /* Add process to process list (if not present) */
787// LttvProcessState *process_in;
788// LttTime birth;
789// guint pl_height = 0;
790// HashedResourceData *hashed_process_data_in = NULL;
791//
792// ProcessList *process_list = control_flow_data->process_list;
793//
794// guint pid_in;
795// {
796// guint pid_out;
797// pid_out = ltt_event_get_long_unsigned(e, thf->f1);
798// pid_in = ltt_event_get_long_unsigned(e, thf->f2);
799// }
800//
801//
802// /* Find process pid_in in the list... */
803// //process_in = lttv_state_find_process(ts, ANY_CPU, pid_in);
804// //process_in = tfs->process;
805// guint cpu = tfs->cpu;
806// guint trace_num = ts->parent.index;
807// process_in = ts->running_process[cpu];
808// /* It should exist, because we are after the state update. */
809//#ifdef EXTRA_CHECK
810// g_assert(process_in != NULL);
811//#endif //EXTRA_CHECK
812// birth = process_in->creation_time;
813//
814// hashed_process_data_in = processlist_get_process_data(process_list, cpuq, trace_num);
815//// hashed_process_data_in = processlist_get_process_data(process_list,
816//// pid_in,
817//// process_in->cpu,
818//// &birth,
819//// trace_num);
820// if(hashed_process_data_in == NULL)
821// {
822// g_assert(pid_in == 0 || pid_in != process_in->ppid);
823// ResourceInfo *process_info;
824// Drawing_t *drawing = control_flow_data->drawing;
825// /* Process not present */
826// resourcelist_add(process_list,
827// drawing,
828// pid_in,
829// process_in->tgid,
830// process_in->cpu,
831// process_in->ppid,
832// &birth,
833// trace_num,
834// process_in->name,
835// process_in->brand,
836// &pl_height,
837// &process_info,
838// &hashed_process_data_in);
839// gtk_widget_set_size_request(drawing->drawing_area,
840// -1,
841// pl_height);
842// gtk_widget_queue_draw(drawing->drawing_area);
843// }
844// /* Set the current process */
845// process_list->current_hash_data[trace_num][process_in->cpu] =
846// hashed_process_data_in;
847//
848// if(ltt_time_compare(hashed_process_data_in->next_good_time,
849// evtime) <= 0)
850// {
851// TimeWindow time_window =
852// lttvwindow_get_time_window(control_flow_data->tab);
853//
854//#ifdef EXTRA_CHECK
855// if(ltt_time_compare(evtime, time_window.start_time) == -1
856// || ltt_time_compare(evtime, time_window.end_time) == 1)
857// return;
858//#endif //EXTRA_CHECK
859// Drawing_t *drawing = control_flow_data->drawing;
860// guint width = drawing->width;
861// guint new_x;
862//
863// convert_time_to_pixels(
864// time_window,
865// evtime,
866// width,
867// &new_x);
868//
869// if(hashed_process_data_in->x.middle != new_x) {
870// hashed_process_data_in->x.middle = new_x;
871// hashed_process_data_in->x.middle_used = FALSE;
872// hashed_process_data_in->x.middle_marked = FALSE;
873// }
874// }
875 return 0;
876}
9e01e6d4 877
58a9b31b 878/* before_execmode_hook
879 *
880 * This function basically draw lines and icons. Two types of lines are drawn :
881 * one small (3 pixels?) representing the state of the process and the second
882 * type is thicker (10 pixels?) representing on which CPU a process is running
883 * (and this only in running state).
884 *
885 * Extremums of the lines :
886 * x_min : time of the last event context for this process kept in memory.
887 * x_max : time of the current event.
888 * y : middle of the process in the process list. The process is found in the
889 * list, therefore is it's position in pixels.
890 *
891 * The choice of lines'color is defined by the context of the last event for this
892 * process.
893 */
9e01e6d4 894
58a9b31b 895//int before_execmode_hook(void *hook_data, void *call_data)
896//{
897// LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
898// EventsRequest *events_request = (EventsRequest*)thf->hook_data;
899// ControlFlowData *control_flow_data = events_request->viewer_data;
900//
901// LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
902//
903// LttvTracefileState *tfs = (LttvTracefileState *)call_data;
904//
905// LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
906//
907// LttEvent *e;
908// e = ltt_tracefile_get_event(tfc->tf);
909//
910// LttvFilter *filter = control_flow_data->filter;
911// if(filter != NULL && filter->head != NULL)
912// if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
913// tfc->t_context->t,tfc,NULL,NULL))
914// return FALSE;
915//
916// LttTime evtime = ltt_event_time(e);
917//
918// /* we are in a execmode, before the state update. We must draw the
919// * items corresponding to the state before it changes : now is the right
920// * time to do it.
921// */
922// /* For the pid */
923// //LttvProcessState *process = tfs->process;
924// guint cpu = tfs->cpu;
925// guint trace_num = ts->parent.index;
926// LttvProcessState *process = ts->running_process[cpu];
927// g_assert(process != NULL);
928//
929// guint pid = process->pid;
930//
931// /* Well, the process_out existed : we must get it in the process hash
932// * or add it, and draw its items.
933// */
934// /* Add process to process list (if not present) */
935// guint pl_height = 0;
936// HashedResourceData *hashed_process_data = NULL;
937// ProcessList *process_list = control_flow_data->process_list;
938// LttTime birth = process->creation_time;
939//
940// if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
941// hashed_process_data = process_list->current_hash_data[trace_num][cpu];
942// } else {
943// hashed_process_data = processlist_get_process_data(process_list, "CPU0");
944//// hashed_process_data = processlist_get_process_data(process_list,
945//// pid,
946//// process->cpu,
947//// &birth,
948//// trace_num);
949// if(unlikely(hashed_process_data == NULL))
950// {
951// g_assert(pid == 0 || pid != process->ppid);
952// ResourceInfo *process_info;
953// /* Process not present */
954// Drawing_t *drawing = control_flow_data->drawing;
955// processlist_add(process_list,
956// drawing,
957// pid,
958// process->tgid,
959// process->cpu,
960// process->ppid,
961// &birth,
962// trace_num,
963// process->name,
964// process->brand,
965// &pl_height,
966// &process_info,
967// &hashed_process_data);
968// gtk_widget_set_size_request(drawing->drawing_area,
969// -1,
970// pl_height);
971// gtk_widget_queue_draw(drawing->drawing_area);
972// }
973// /* Set the current process */
974// process_list->current_hash_data[trace_num][process->cpu] =
975// hashed_process_data;
976// }
977//
978// /* Now, the process is in the state hash and our own process hash.
979// * We definitely can draw the items related to the ending state.
980// */
981//
982// if(likely(ltt_time_compare(hashed_process_data->next_good_time,
983// evtime) > 0))
984// {
985// if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
986// TimeWindow time_window =
987// lttvwindow_get_time_window(control_flow_data->tab);
988//
989//#ifdef EXTRA_CHECK
990// if(ltt_time_compare(evtime, time_window.start_time) == -1
991// || ltt_time_compare(evtime, time_window.end_time) == 1)
992// return;
993//#endif //EXTRA_CHECK
994// Drawing_t *drawing = control_flow_data->drawing;
995// guint width = drawing->width;
996// guint x;
997// convert_time_to_pixels(
998// time_window,
999// evtime,
1000// width,
1001// &x);
1002//
1003// /* Draw collision indicator */
1004// gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1005// gdk_draw_point(hashed_process_data->pixmap,
1006// drawing->gc,
1007// x,
1008// COLLISION_POSITION(hashed_process_data->height));
1009// hashed_process_data->x.middle_marked = TRUE;
1010// }
1011// } else {
1012// TimeWindow time_window =
1013// lttvwindow_get_time_window(control_flow_data->tab);
1014//
1015//#ifdef EXTRA_CHECK
1016// if(ltt_time_compare(evtime, time_window.start_time) == -1
1017// || ltt_time_compare(evtime, time_window.end_time) == 1)
1018// return;
1019//#endif //EXTRA_CHECK
1020// Drawing_t *drawing = control_flow_data->drawing;
1021// guint width = drawing->width;
1022// guint x;
1023//
1024// convert_time_to_pixels(
1025// time_window,
1026// evtime,
1027// width,
1028// &x);
1029//
1030//
1031// /* Jump over draw if we are at the same x position */
1032// if(unlikely(x == hashed_process_data->x.middle &&
1033// hashed_process_data->x.middle_used))
1034// {
1035// if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1036// /* Draw collision indicator */
1037// gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1038// gdk_draw_point(hashed_process_data->pixmap,
1039// drawing->gc,
1040// x,
1041// COLLISION_POSITION(hashed_process_data->height));
1042// hashed_process_data->x.middle_marked = TRUE;
1043// }
1044// /* jump */
1045// } else {
1046//
1047// DrawContext draw_context;
1048// /* Now create the drawing context that will be used to draw
1049// * items related to the last state. */
1050// draw_context.drawable = hashed_process_data->pixmap;
1051// draw_context.gc = drawing->gc;
1052// draw_context.pango_layout = drawing->pango_layout;
1053// draw_context.drawinfo.start.x = hashed_process_data->x.middle;
1054// draw_context.drawinfo.end.x = x;
1055//
1056// draw_context.drawinfo.y.over = 1;
1057// draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
1058// draw_context.drawinfo.y.under = hashed_process_data->height;
1059//
1060// draw_context.drawinfo.start.offset.over = 0;
1061// draw_context.drawinfo.start.offset.middle = 0;
1062// draw_context.drawinfo.start.offset.under = 0;
1063// draw_context.drawinfo.end.offset.over = 0;
1064// draw_context.drawinfo.end.offset.middle = 0;
1065// draw_context.drawinfo.end.offset.under = 0;
1066//
1067// {
1068// /* Draw the line */
1069// PropertiesLine prop_line = prepare_s_e_line(process);
1070// draw_line((void*)&prop_line, (void*)&draw_context);
1071//
1072// }
1073// /* become the last x position */
1074// hashed_process_data->x.middle = x;
1075// hashed_process_data->x.middle_used = TRUE;
1076// hashed_process_data->x.middle_marked = FALSE;
1077//
1078// /* Calculate the next good time */
1079// convert_pixels_to_time(width, x+1, time_window,
1080// &hashed_process_data->next_good_time);
1081// }
1082// }
1083//
1084// return 0;
1085//}
9e01e6d4 1086
58a9b31b 1087/* before_process_exit_hook
1088 *
1089 * Draw lines for process event.
1090 *
1091 * @param hook_data ControlFlowData structure of the viewer.
1092 * @param call_data Event context.
1093 *
1094 * This function adds items to be drawn in a queue for each process.
1095 *
1096 */
9e01e6d4 1097
58a9b31b 1098//int before_process_exit_hook(void *hook_data, void *call_data)
1099//{
1100// LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1101// EventsRequest *events_request = (EventsRequest*)thf->hook_data;
1102//
1103// ControlFlowData *control_flow_data = events_request->viewer_data;
1104//
1105// LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1106//
1107// LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1108//
1109// LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1110//
1111// LttEvent *e;
1112// e = ltt_tracefile_get_event(tfc->tf);
1113//
1114// LttvFilter *filter = control_flow_data->filter;
1115// if(filter != NULL && filter->head != NULL)
1116// if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1117// tfc->t_context->t,tfc,NULL,NULL))
1118// return FALSE;
1119//
1120// LttTime evtime = ltt_event_time(e);
1121//
1122// /* Add process to process list (if not present) */
1123// //LttvProcessState *process = tfs->process;
1124// guint cpu = tfs->cpu;
1125// guint trace_num = ts->parent.index;
1126// LttvProcessState *process = ts->running_process[cpu];
1127// guint pid = process->pid;
1128// LttTime birth;
1129// guint pl_height = 0;
1130// HashedResourceData *hashed_process_data = NULL;
1131//
1132// ProcessList *process_list = control_flow_data->process_list;
1133//
1134// g_assert(process != NULL);
1135//
1136// birth = process->creation_time;
1137//
1138// if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
1139// hashed_process_data = process_list->current_hash_data[trace_num][cpu];
1140// } else {
1141// hashed_process_data = processlist_get_process_data(process_list, "CPU0");
1142//// hashed_process_data = processlist_get_process_data(process_list,
1143//// pid,
1144//// process->cpu,
1145//// &birth,
1146//// trace_num);
1147// if(unlikely(hashed_process_data == NULL))
1148// {
1149// g_assert(pid == 0 || pid != process->ppid);
1150// /* Process not present */
1151// Drawing_t *drawing = control_flow_data->drawing;
1152// ResourceInfo *process_info;
1153// processlist_add(process_list,
1154// drawing,
1155// pid,
1156// process->tgid,
1157// process->cpu,
1158// process->ppid,
1159// &birth,
1160// trace_num,
1161// process->name,
1162// process->brand,
1163// &pl_height,
1164// &process_info,
1165// &hashed_process_data);
1166// gtk_widget_set_size_request(drawing->drawing_area,
1167// -1,
1168// pl_height);
1169// gtk_widget_queue_draw(drawing->drawing_area);
1170// }
1171// }
1172//
1173// /* Now, the process is in the state hash and our own process hash.
1174// * We definitely can draw the items related to the ending state.
1175// */
1176//
1177// if(likely(ltt_time_compare(hashed_process_data->next_good_time,
1178// evtime) > 0))
1179// {
1180// if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1181// TimeWindow time_window =
1182// lttvwindow_get_time_window(control_flow_data->tab);
1183//
1184//#ifdef EXTRA_CHECK
1185// if(ltt_time_compare(evtime, time_window.start_time) == -1
1186// || ltt_time_compare(evtime, time_window.end_time) == 1)
1187// return;
1188//#endif //EXTRA_CHECK
1189// Drawing_t *drawing = control_flow_data->drawing;
1190// guint width = drawing->width;
1191// guint x;
1192// convert_time_to_pixels(
1193// time_window,
1194// evtime,
1195// width,
1196// &x);
1197//
1198// /* Draw collision indicator */
1199// gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1200// gdk_draw_point(hashed_process_data->pixmap,
1201// drawing->gc,
1202// x,
1203// COLLISION_POSITION(hashed_process_data->height));
1204// hashed_process_data->x.middle_marked = TRUE;
1205// }
1206// } else {
1207// TimeWindow time_window =
1208// lttvwindow_get_time_window(control_flow_data->tab);
1209//
1210//#ifdef EXTRA_CHECK
1211// if(ltt_time_compare(evtime, time_window.start_time) == -1
1212// || ltt_time_compare(evtime, time_window.end_time) == 1)
1213// return;
1214//#endif //EXTRA_CHECK
1215// Drawing_t *drawing = control_flow_data->drawing;
1216// guint width = drawing->width;
1217// guint x;
1218//
1219// convert_time_to_pixels(
1220// time_window,
1221// evtime,
1222// width,
1223// &x);
1224//
1225//
1226// /* Jump over draw if we are at the same x position */
1227// if(unlikely(x == hashed_process_data->x.middle &&
1228// hashed_process_data->x.middle_used))
1229// {
1230// if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1231// /* Draw collision indicator */
1232// gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1233// gdk_draw_point(hashed_process_data->pixmap,
1234// drawing->gc,
1235// x,
1236// COLLISION_POSITION(hashed_process_data->height));
1237// hashed_process_data->x.middle_marked = TRUE;
1238// }
1239// /* jump */
1240// } else {
1241// DrawContext draw_context;
1242//
1243// /* Now create the drawing context that will be used to draw
1244// * items related to the last state. */
1245// draw_context.drawable = hashed_process_data->pixmap;
1246// draw_context.gc = drawing->gc;
1247// draw_context.pango_layout = drawing->pango_layout;
1248// draw_context.drawinfo.start.x = hashed_process_data->x.middle;
1249// draw_context.drawinfo.end.x = x;
1250//
1251// draw_context.drawinfo.y.over = 1;
1252// draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
1253// draw_context.drawinfo.y.under = hashed_process_data->height;
1254//
1255// draw_context.drawinfo.start.offset.over = 0;
1256// draw_context.drawinfo.start.offset.middle = 0;
1257// draw_context.drawinfo.start.offset.under = 0;
1258// draw_context.drawinfo.end.offset.over = 0;
1259// draw_context.drawinfo.end.offset.middle = 0;
1260// draw_context.drawinfo.end.offset.under = 0;
1261//
1262// {
1263// /* Draw the line */
1264// PropertiesLine prop_line = prepare_s_e_line(process);
1265// draw_line((void*)&prop_line, (void*)&draw_context);
1266//
1267// }
1268// /* become the last x position */
1269// hashed_process_data->x.middle = x;
1270// hashed_process_data->x.middle_used = TRUE;
1271// hashed_process_data->x.middle_marked = FALSE;
1272//
1273// /* Calculate the next good time */
1274// convert_pixels_to_time(width, x+1, time_window,
1275// &hashed_process_data->next_good_time);
1276// }
1277// }
1278//
1279// return 0;
1280//
1281//}
9e01e6d4 1282
9e01e6d4 1283
58a9b31b 1284/* before_process_release_hook
1285 *
1286 * Draw lines for process event.
1287 *
1288 * @param hook_data ControlFlowData structure of the viewer.
1289 * @param call_data Event context.
1290 *
1291 * This function adds items to be drawn in a queue for each process.
1292 *
1293 */
9e01e6d4 1294
58a9b31b 1295//int before_process_release_hook(void *hook_data, void *call_data)
1296//{
1297// LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1298// EventsRequest *events_request = (EventsRequest*)thf->hook_data;
1299//
1300// ControlFlowData *control_flow_data = events_request->viewer_data;
1301//
1302// LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1303//
1304// LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1305//
1306// LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1307//
1308// LttEvent *e;
1309// e = ltt_tracefile_get_event(tfc->tf);
1310//
1311// LttvFilter *filter = control_flow_data->filter;
1312// if(filter != NULL && filter->head != NULL)
1313// if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1314// tfc->t_context->t,tfc,NULL,NULL))
1315// return FALSE;
1316//
1317// LttTime evtime = ltt_event_time(e);
1318//
1319// guint trace_num = ts->parent.index;
1320//
1321// guint pid;
1322// {
1323// pid = ltt_event_get_long_unsigned(e, thf->f1);
1324// }
1325//
1326// /* Add process to process list (if not present) */
1327// /* Don't care about the process if it's not in the state hash already :
1328// * that means a process that has never done anything in the trace and
1329// * unknown suddently gets destroyed : no state meaningful to show. */
1330// LttvProcessState *process = lttv_state_find_process(ts, ANY_CPU, pid);
1331//
1332// if(process != NULL) {
1333// LttTime birth;
1334// guint pl_height = 0;
1335// HashedResourceData *hashed_process_data = NULL;
1336//
1337// ProcessList *process_list = control_flow_data->process_list;
1338//
1339// birth = process->creation_time;
1340//
1341// /* Cannot use current process : this event happens on another process,
1342// * action done by the parent. */
1343// hashed_process_data = processlist_get_process_data(process_list, "CPU0");
1344//// hashed_process_data = processlist_get_process_data(process_list,
1345//// pid,
1346//// process->cpu,
1347//// &birth,
1348//// trace_num);
1349// if(unlikely(hashed_process_data == NULL))
1350// {
1351// g_assert(pid == 0 || pid != process->ppid);
1352// /* Process not present */
1353// Drawing_t *drawing = control_flow_data->drawing;
1354// ResourceInfo *process_info;
1355// processlist_add(process_list,
1356// drawing,
1357// pid,
1358// process->tgid,
1359// process->cpu,
1360// process->ppid,
1361// &birth,
1362// trace_num,
1363// process->name,
1364// process->brand,
1365// &pl_height,
1366// &process_info,
1367// &hashed_process_data);
1368// gtk_widget_set_size_request(drawing->drawing_area,
1369// -1,
1370// pl_height);
1371// gtk_widget_queue_draw(drawing->drawing_area);
1372// }
1373//
1374// /* Now, the process is in the state hash and our own process hash.
1375// * We definitely can draw the items related to the ending state.
1376// */
1377//
1378// if(likely(ltt_time_compare(hashed_process_data->next_good_time,
1379// evtime) > 0))
1380// {
1381// if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1382// TimeWindow time_window =
1383// lttvwindow_get_time_window(control_flow_data->tab);
1384//
1385//#ifdef EXTRA_CHECK
1386// if(ltt_time_compare(evtime, time_window.start_time) == -1
1387// || ltt_time_compare(evtime, time_window.end_time) == 1)
1388// return;
1389//#endif //EXTRA_CHECK
1390// Drawing_t *drawing = control_flow_data->drawing;
1391// guint width = drawing->width;
1392// guint x;
1393// convert_time_to_pixels(
1394// time_window,
1395// evtime,
1396// width,
1397// &x);
1398//
1399// /* Draw collision indicator */
1400// gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1401// gdk_draw_point(hashed_process_data->pixmap,
1402// drawing->gc,
1403// x,
1404// COLLISION_POSITION(hashed_process_data->height));
1405// hashed_process_data->x.middle_marked = TRUE;
1406// }
1407// } else {
1408// TimeWindow time_window =
1409// lttvwindow_get_time_window(control_flow_data->tab);
1410//
1411//#ifdef EXTRA_CHECK
1412// if(ltt_time_compare(evtime, time_window.start_time) == -1
1413// || ltt_time_compare(evtime, time_window.end_time) == 1)
1414// return;
1415//#endif //EXTRA_CHECK
1416// Drawing_t *drawing = control_flow_data->drawing;
1417// guint width = drawing->width;
1418// guint x;
1419//
1420// convert_time_to_pixels(
1421// time_window,
1422// evtime,
1423// width,
1424// &x);
1425//
1426//
1427// /* Jump over draw if we are at the same x position */
1428// if(unlikely(x == hashed_process_data->x.middle &&
1429// hashed_process_data->x.middle_used))
1430// {
1431// if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1432// /* Draw collision indicator */
1433// gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1434// gdk_draw_point(hashed_process_data->pixmap,
1435// drawing->gc,
1436// x,
1437// COLLISION_POSITION(hashed_process_data->height));
1438// hashed_process_data->x.middle_marked = TRUE;
1439// }
1440// /* jump */
1441// } else {
1442// DrawContext draw_context;
1443//
1444// /* Now create the drawing context that will be used to draw
1445// * items related to the last state. */
1446// draw_context.drawable = hashed_process_data->pixmap;
1447// draw_context.gc = drawing->gc;
1448// draw_context.pango_layout = drawing->pango_layout;
1449// draw_context.drawinfo.start.x = hashed_process_data->x.middle;
1450// draw_context.drawinfo.end.x = x;
1451//
1452// draw_context.drawinfo.y.over = 1;
1453// draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
1454// draw_context.drawinfo.y.under = hashed_process_data->height;
1455//
1456// draw_context.drawinfo.start.offset.over = 0;
1457// draw_context.drawinfo.start.offset.middle = 0;
1458// draw_context.drawinfo.start.offset.under = 0;
1459// draw_context.drawinfo.end.offset.over = 0;
1460// draw_context.drawinfo.end.offset.middle = 0;
1461// draw_context.drawinfo.end.offset.under = 0;
1462//
1463// {
1464// /* Draw the line */
1465// PropertiesLine prop_line = prepare_s_e_line(process);
1466// draw_line((void*)&prop_line, (void*)&draw_context);
1467//
1468// }
1469// /* become the last x position */
1470// hashed_process_data->x.middle = x;
1471// hashed_process_data->x.middle_used = TRUE;
1472// hashed_process_data->x.middle_marked = FALSE;
1473//
1474// /* Calculate the next good time */
1475// convert_pixels_to_time(width, x+1, time_window,
1476// &hashed_process_data->next_good_time);
1477// }
1478// }
1479// }
1480//
1481// return 0;
1482//}
9e01e6d4 1483
58a9b31b 1484/* after_process_fork_hook
9e01e6d4 1485 *
1486 * Create the processlist entry for the child process. Put the last
1487 * position in x at the current time value.
1488 *
1489 * @param hook_data ControlFlowData structure of the viewer.
1490 * @param call_data Event context.
1491 *
1492 * This function adds items to be drawn in a queue for each process.
1493 *
1494 */
58a9b31b 1495//int after_process_fork_hook(void *hook_data, void *call_data)
1496//{
1497// LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1498// EventsRequest *events_request = (EventsRequest*)thf->hook_data;
1499// ControlFlowData *control_flow_data = events_request->viewer_data;
1500//
1501// LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1502//
1503// LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1504//
1505// LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1506//
1507// LttEvent *e;
1508// e = ltt_tracefile_get_event(tfc->tf);
1509//
1510// LttvFilter *filter = control_flow_data->filter;
1511// if(filter != NULL && filter->head != NULL)
1512// if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1513// tfc->t_context->t,tfc,NULL,NULL))
1514// return FALSE;
1515//
1516// LttTime evtime = ltt_event_time(e);
1517//
1518// guint child_pid;
1519// {
1520// child_pid = ltt_event_get_long_unsigned(e, thf->f2);
1521// }
1522//
1523// /* Add process to process list (if not present) */
1524// LttvProcessState *process_child;
1525// LttTime birth;
1526// guint pl_height = 0;
1527// HashedResourceData *hashed_process_data_child = NULL;
1528//
1529// ProcessList *process_list = control_flow_data->process_list;
1530//
1531// /* Find child in the list... */
1532// process_child = lttv_state_find_process(ts, ANY_CPU, child_pid);
1533// /* It should exist, because we are after the state update. */
1534// g_assert(process_child != NULL);
1535//
1536// birth = process_child->creation_time;
1537// guint trace_num = ts->parent.index;
1538//
1539// /* Cannot use current process, because this action is done by the parent
1540// * on its child. */
1541// hashed_process_data_child = processlist_get_process_data(process_list, "CPU0");
1542//// hashed_process_data_child = processlist_get_process_data(process_list,
1543//// child_pid,
1544//// process_child->cpu,
1545//// &birth,
1546//// trace_num);
1547// if(likely(hashed_process_data_child == NULL))
1548// {
1549// g_assert(child_pid == 0 || child_pid != process_child->ppid);
1550// /* Process not present */
1551// Drawing_t *drawing = control_flow_data->drawing;
1552// ResourceInfo *process_info;
1553// processlist_add(process_list,
1554// drawing,
1555// child_pid,
1556// process_child->tgid,
1557// process_child->cpu,
1558// process_child->ppid,
1559// &birth,
1560// trace_num,
1561// process_child->name,
1562// process_child->brand,
1563// &pl_height,
1564// &process_info,
1565// &hashed_process_data_child);
1566// gtk_widget_set_size_request(drawing->drawing_area,
1567// -1,
1568// pl_height);
1569// gtk_widget_queue_draw(drawing->drawing_area);
1570// } else {
1571// processlist_set_ppid(process_list, process_child->ppid,
1572// hashed_process_data_child);
1573// processlist_set_tgid(process_list, process_child->tgid,
1574// hashed_process_data_child);
1575// }
1576//
1577//
1578// if(likely(ltt_time_compare(hashed_process_data_child->next_good_time,
1579// evtime) <= 0))
1580// {
1581// TimeWindow time_window =
1582// lttvwindow_get_time_window(control_flow_data->tab);
1583//
1584//#ifdef EXTRA_CHECK
1585// if(ltt_time_compare(evtime, time_window.start_time) == -1
1586// || ltt_time_compare(evtime, time_window.end_time) == 1)
1587// return;
1588//#endif //EXTRA_CHECK
1589// Drawing_t *drawing = control_flow_data->drawing;
1590// guint width = drawing->width;
1591// guint new_x;
1592// convert_time_to_pixels(
1593// time_window,
1594// evtime,
1595// width,
1596// &new_x);
1597//
1598// if(likely(hashed_process_data_child->x.over != new_x)) {
1599// hashed_process_data_child->x.over = new_x;
1600// hashed_process_data_child->x.over_used = FALSE;
1601// hashed_process_data_child->x.over_marked = FALSE;
1602// }
1603// if(likely(hashed_process_data_child->x.middle != new_x)) {
1604// hashed_process_data_child->x.middle = new_x;
1605// hashed_process_data_child->x.middle_used = FALSE;
1606// hashed_process_data_child->x.middle_marked = FALSE;
1607// }
1608// if(likely(hashed_process_data_child->x.under != new_x)) {
1609// hashed_process_data_child->x.under = new_x;
1610// hashed_process_data_child->x.under_used = FALSE;
1611// hashed_process_data_child->x.under_marked = FALSE;
1612// }
1613// }
1614// return 0;
1615//}
9e01e6d4 1616
9e01e6d4 1617
9e01e6d4 1618
58a9b31b 1619/* after_process_exit_hook
1620 *
1621 * Create the processlist entry for the child process. Put the last
1622 * position in x at the current time value.
1623 *
1624 * @param hook_data ControlFlowData structure of the viewer.
1625 * @param call_data Event context.
1626 *
1627 * This function adds items to be drawn in a queue for each process.
1628 *
1629 */
1630//int after_process_exit_hook(void *hook_data, void *call_data)
1631//{
1632// LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1633// EventsRequest *events_request = (EventsRequest*)thf->hook_data;
1634// ControlFlowData *control_flow_data = events_request->viewer_data;
1635//
1636// LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1637//
1638// LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1639//
1640// LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1641//
1642// LttEvent *e;
1643// e = ltt_tracefile_get_event(tfc->tf);
1644//
1645// LttvFilter *filter = control_flow_data->filter;
1646// if(filter != NULL && filter->head != NULL)
1647// if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1648// tfc->t_context->t,tfc,NULL,NULL))
1649// return FALSE;
1650//
1651// LttTime evtime = ltt_event_time(e);
1652//
1653// /* Add process to process list (if not present) */
1654// //LttvProcessState *process = tfs->process;
1655// guint cpu = tfs->cpu;
1656// guint trace_num = ts->parent.index;
1657// LttvProcessState *process = ts->running_process[cpu];
1658//
1659// /* It should exist, because we are after the state update. */
1660// g_assert(process != NULL);
1661//
1662// guint pid = process->pid;
1663// LttTime birth;
1664// guint pl_height = 0;
1665// HashedResourceData *hashed_process_data = NULL;
1666//
1667// ProcessList *process_list = control_flow_data->process_list;
1668//
1669// birth = process->creation_time;
1670//
1671// if(likely(process_list->current_hash_data[trace_num][cpu] != NULL) ){
1672// hashed_process_data = process_list->current_hash_data[trace_num][cpu];
1673// } else {
1674// hashed_process_data = processlist_get_process_data(process_list, "CPU0");
1675//// hashed_process_data = processlist_get_process_data(process_list,
1676//// pid,
1677//// process->cpu,
1678//// &birth,
1679//// trace_num);
1680// if(unlikely(hashed_process_data == NULL))
1681// {
1682// g_assert(pid == 0 || pid != process->ppid);
1683// /* Process not present */
1684// Drawing_t *drawing = control_flow_data->drawing;
1685// ResourceInfo *process_info;
1686// processlist_add(process_list,
1687// drawing,
1688// pid,
1689// process->tgid,
1690// process->cpu,
1691// process->ppid,
1692// &birth,
1693// trace_num,
1694// process->name,
1695// process->brand,
1696// &pl_height,
1697// &process_info,
1698// &hashed_process_data);
1699// gtk_widget_set_size_request(drawing->drawing_area,
1700// -1,
1701// pl_height);
1702// gtk_widget_queue_draw(drawing->drawing_area);
1703// }
1704//
1705// /* Set the current process */
1706// process_list->current_hash_data[trace_num][process->cpu] =
1707// hashed_process_data;
1708// }
1709//
1710// if(unlikely(ltt_time_compare(hashed_process_data->next_good_time,
1711// evtime) <= 0))
1712// {
1713// TimeWindow time_window =
1714// lttvwindow_get_time_window(control_flow_data->tab);
1715//
1716//#ifdef EXTRA_CHECK
1717// if(ltt_time_compare(evtime, time_window.start_time) == -1
1718// || ltt_time_compare(evtime, time_window.end_time) == 1)
1719// return;
1720//#endif //EXTRA_CHECK
1721// Drawing_t *drawing = control_flow_data->drawing;
1722// guint width = drawing->width;
1723// guint new_x;
1724// convert_time_to_pixels(
1725// time_window,
1726// evtime,
1727// width,
1728// &new_x);
1729// if(unlikely(hashed_process_data->x.middle != new_x)) {
1730// hashed_process_data->x.middle = new_x;
1731// hashed_process_data->x.middle_used = FALSE;
1732// hashed_process_data->x.middle_marked = FALSE;
1733// }
1734// }
1735//
1736// return 0;
1737//}
9e01e6d4 1738
9e01e6d4 1739
58a9b31b 1740/* Get the filename of the process to print */
1741//int after_fs_exec_hook(void *hook_data, void *call_data)
1742//{
1743// LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1744// EventsRequest *events_request = (EventsRequest*)thf->hook_data;
1745// ControlFlowData *control_flow_data = events_request->viewer_data;
1746//
1747// LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1748//
1749// LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1750//
1751// LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1752//
1753// LttEvent *e;
1754// e = ltt_tracefile_get_event(tfc->tf);
1755//
1756// LttvFilter *filter = control_flow_data->filter;
1757// if(filter != NULL && filter->head != NULL)
1758// if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1759// tfc->t_context->t,tfc,NULL,NULL))
1760// return FALSE;
1761//
1762// guint cpu = tfs->cpu;
1763// guint trace_num = ts->parent.index;
1764// LttvProcessState *process = ts->running_process[cpu];
1765// g_assert(process != NULL);
1766//
1767// guint pid = process->pid;
1768//
1769// /* Well, the process_out existed : we must get it in the process hash
1770// * or add it, and draw its items.
1771// */
1772// /* Add process to process list (if not present) */
1773// guint pl_height = 0;
1774// HashedResourceData *hashed_process_data = NULL;
1775// ProcessList *process_list = control_flow_data->process_list;
1776// LttTime birth = process->creation_time;
1777//
1778// if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
1779// hashed_process_data = process_list->current_hash_data[trace_num][cpu];
1780// } else {
1781// hashed_process_data = processlist_get_process_data(process_list, "CPU0");
1782//// hashed_process_data = processlist_get_process_data(process_list,
1783//// pid,
1784//// process->cpu,
1785//// &birth,
1786//// trace_num);
1787// if(unlikely(hashed_process_data == NULL))
1788// {
1789// g_assert(pid == 0 || pid != process->ppid);
1790// ResourceInfo *process_info;
1791// /* Process not present */
1792// Drawing_t *drawing = control_flow_data->drawing;
1793// processlist_add(process_list,
1794// drawing,
1795// pid,
1796// process->tgid,
1797// process->cpu,
1798// process->ppid,
1799// &birth,
1800// trace_num,
1801// process->name,
1802// process->brand,
1803// &pl_height,
1804// &process_info,
1805// &hashed_process_data);
1806// gtk_widget_set_size_request(drawing->drawing_area,
1807// -1,
1808// pl_height);
1809// gtk_widget_queue_draw(drawing->drawing_area);
1810// }
1811// /* Set the current process */
1812// process_list->current_hash_data[trace_num][process->cpu] =
1813// hashed_process_data;
1814// }
1815//
1816// processlist_set_name(process_list, process->name, hashed_process_data);
1817//
1818// return 0;
1819//
1820//}
9e01e6d4 1821
58a9b31b 1822/* Get the filename of the process to print */
1823//int after_user_generic_thread_brand_hook(void *hook_data, void *call_data)
1824//{
1825// LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1826// EventsRequest *events_request = (EventsRequest*)thf->hook_data;
1827// ControlFlowData *control_flow_data = events_request->viewer_data;
1828//
1829// LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1830//
1831// LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1832//
1833// LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1834//
1835// LttEvent *e;
1836// e = ltt_tracefile_get_event(tfc->tf);
1837//
1838// LttvFilter *filter = control_flow_data->filter;
1839// if(filter != NULL && filter->head != NULL)
1840// if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1841// tfc->t_context->t,tfc,NULL,NULL))
1842// return FALSE;
1843//
1844// guint cpu = tfs->cpu;
1845// guint trace_num = ts->parent.index;
1846// LttvProcessState *process = ts->running_process[cpu];
1847// g_assert(process != NULL);
1848//
1849// guint pid = process->pid;
1850//
1851// /* Well, the process_out existed : we must get it in the process hash
1852// * or add it, and draw its items.
1853// */
1854// /* Add process to process list (if not present) */
1855// guint pl_height = 0;
1856// HashedResourceData *hashed_process_data = NULL;
1857// ProcessList *process_list = control_flow_data->process_list;
1858// LttTime birth = process->creation_time;
1859//
1860// if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
1861// hashed_process_data = process_list->current_hash_data[trace_num][cpu];
1862// } else {
1863// hashed_process_data = processlist_get_process_data(process_list, "CPU0");
1864//// hashed_process_data = processlist_get_process_data(process_list,
1865//// pid,
1866//// process->cpu,
1867//// &birth,
1868//// trace_num);
1869// if(unlikely(hashed_process_data == NULL))
1870// {
1871// g_assert(pid == 0 || pid != process->ppid);
1872// ResourceInfo *process_info;
1873// /* Process not present */
1874// Drawing_t *drawing = control_flow_data->drawing;
1875// processlist_add(process_list,
1876// drawing,
1877// pid,
1878// process->tgid,
1879// process->cpu,
1880// process->ppid,
1881// &birth,
1882// trace_num,
1883// process->name,
1884// process->brand,
1885// &pl_height,
1886// &process_info,
1887// &hashed_process_data);
1888// gtk_widget_set_size_request(drawing->drawing_area,
1889// -1,
1890// pl_height);
1891// gtk_widget_queue_draw(drawing->drawing_area);
1892// }
1893// /* Set the current process */
1894// process_list->current_hash_data[trace_num][process->cpu] =
1895// hashed_process_data;
1896// }
1897//
1898// processlist_set_brand(process_list, process->brand, hashed_process_data);
1899//
1900// return 0;
1901//
1902//}
9e01e6d4 1903
9e01e6d4 1904
58a9b31b 1905/* after_event_enum_process_hook
1906 *
1907 * Create the processlist entry for the child process. Put the last
1908 * position in x at the current time value.
1909 *
1910 * @param hook_data ControlFlowData structure of the viewer.
1911 * @param call_data Event context.
1912 *
1913 * This function adds items to be drawn in a queue for each process.
1914 *
1915 */
1916//int after_event_enum_process_hook(void *hook_data, void *call_data)
1917//{
1918// LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1919// EventsRequest *events_request = (EventsRequest*)thf->hook_data;
1920// ControlFlowData *control_flow_data = events_request->viewer_data;
1921//
1922// LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1923//
1924// LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1925//
1926// LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1927//
1928// guint first_cpu, nb_cpus, cpu;
1929//
1930// LttEvent *e;
1931// e = ltt_tracefile_get_event(tfc->tf);
1932//
1933// LttvFilter *filter = control_flow_data->filter;
1934// if(filter != NULL && filter->head != NULL)
1935// if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1936// tfc->t_context->t,tfc,NULL,NULL))
1937// return FALSE;
1938//
1939// LttTime evtime = ltt_event_time(e);
1940//
1941// /* Add process to process list (if not present) */
1942// LttvProcessState *process_in;
1943// LttTime birth;
1944// guint pl_height = 0;
1945// HashedResourceData *hashed_process_data_in = NULL;
1946//
1947// ProcessList *process_list = control_flow_data->process_list;
1948// guint trace_num = ts->parent.index;
1949//
1950// guint pid_in;
1951// {
1952// pid_in = ltt_event_get_long_unsigned(e, thf->f1);
1953// }
1954//
1955// if(pid_in == 0) {
1956// first_cpu = 0;
1957// nb_cpus = ltt_trace_get_num_cpu(ts->parent.t);
1958// } else {
1959// first_cpu = ANY_CPU;
1960// nb_cpus = ANY_CPU+1;
1961// }
1962//
1963// for(cpu = first_cpu; cpu < nb_cpus; cpu++) {
1964// /* Find process pid_in in the list... */
1965// process_in = lttv_state_find_process(ts, cpu, pid_in);
1966// //process_in = tfs->process;
1967// //guint cpu = tfs->cpu;
1968// //guint trace_num = ts->parent.index;
1969// //process_in = ts->running_process[cpu];
1970// /* It should exist, because we are after the state update. */
1971// #ifdef EXTRA_CHECK
1972// //g_assert(process_in != NULL);
1973// #endif //EXTRA_CHECK
1974// birth = process_in->creation_time;
1975//
1976// hashed_process_data_in = processlist_get_process_data(process_list, "CPU0");
1977//// hashed_process_data_in = processlist_get_process_data(process_list,
1978//// pid_in,
1979//// process_in->cpu,
1980//// &birth,
1981//// trace_num);
1982// if(hashed_process_data_in == NULL)
1983// {
1984// if(pid_in != 0 && pid_in == process_in->ppid)
1985// g_critical("TEST %u , %u", pid_in, process_in->ppid);
1986// g_assert(pid_in == 0 || pid_in != process_in->ppid);
1987// ResourceInfo *process_info;
1988// Drawing_t *drawing = control_flow_data->drawing;
1989// /* Process not present */
1990// processlist_add(process_list,
1991// drawing,
1992// pid_in,
1993// process_in->tgid,
1994// process_in->cpu,
1995// process_in->ppid,
1996// &birth,
1997// trace_num,
1998// process_in->name,
1999// process_in->brand,
2000// &pl_height,
2001// &process_info,
2002// &hashed_process_data_in);
2003// gtk_widget_set_size_request(drawing->drawing_area,
2004// -1,
2005// pl_height);
2006// gtk_widget_queue_draw(drawing->drawing_area);
2007// } else {
2008// processlist_set_name(process_list, process_in->name,
2009// hashed_process_data_in);
2010// processlist_set_ppid(process_list, process_in->ppid,
2011// hashed_process_data_in);
2012// processlist_set_tgid(process_list, process_in->tgid,
2013// hashed_process_data_in);
2014// }
2015// }
2016// return 0;
2017//}
9e01e6d4 2018
2019
2020gint update_time_window_hook(void *hook_data, void *call_data)
2021{
2022 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
2023 Drawing_t *drawing = control_flow_data->drawing;
2024 ProcessList *process_list = control_flow_data->process_list;
2025
2026 const TimeWindowNotifyData *time_window_nofify_data =
2027 ((const TimeWindowNotifyData *)call_data);
2028
2029 TimeWindow *old_time_window =
2030 time_window_nofify_data->old_time_window;
2031 TimeWindow *new_time_window =
2032 time_window_nofify_data->new_time_window;
2033
2034 /* Update the ruler */
2035 drawing_update_ruler(control_flow_data->drawing,
2036 new_time_window);
2037
2038
2039 /* Two cases : zoom in/out or scrolling */
2040
2041 /* In order to make sure we can reuse the old drawing, the scale must
2042 * be the same and the new time interval being partly located in the
2043 * currently shown time interval. (reuse is only for scrolling)
2044 */
2045
2046 g_info("Old time window HOOK : %lu, %lu to %lu, %lu",
2047 old_time_window->start_time.tv_sec,
2048 old_time_window->start_time.tv_nsec,
2049 old_time_window->time_width.tv_sec,
2050 old_time_window->time_width.tv_nsec);
2051
2052 g_info("New time window HOOK : %lu, %lu to %lu, %lu",
2053 new_time_window->start_time.tv_sec,
2054 new_time_window->start_time.tv_nsec,
2055 new_time_window->time_width.tv_sec,
2056 new_time_window->time_width.tv_nsec);
2057
2058 if( new_time_window->time_width.tv_sec == old_time_window->time_width.tv_sec
2059 && new_time_window->time_width.tv_nsec == old_time_window->time_width.tv_nsec)
2060 {
2061 /* Same scale (scrolling) */
2062 g_info("scrolling");
2063 LttTime *ns = &new_time_window->start_time;
2064 LttTime *nw = &new_time_window->time_width;
2065 LttTime *os = &old_time_window->start_time;
2066 LttTime *ow = &old_time_window->time_width;
2067 LttTime old_end = old_time_window->end_time;
2068 LttTime new_end = new_time_window->end_time;
2069 //if(ns<os+w<ns+w)
2070 //if(ns<os+w && os+w<ns+w)
2071 //if(ns<old_end && os<ns)
2072 if(ltt_time_compare(*ns, old_end) == -1
2073 && ltt_time_compare(*os, *ns) == -1)
2074 {
2075 g_info("scrolling near right");
2076 /* Scroll right, keep right part of the screen */
2077 guint x = 0;
2078 guint width = control_flow_data->drawing->width;
2079 convert_time_to_pixels(
2080 *old_time_window,
2081 *ns,
2082 width,
2083 &x);
2084
2085 /* Copy old data to new location */
2086 copy_pixmap_region(process_list,
2087 NULL,
2088 control_flow_data->drawing->drawing_area->style->black_gc,
2089 NULL,
2090 x, 0,
2091 0, 0,
2092 control_flow_data->drawing->width-x+SAFETY, -1);
2093
2094 if(drawing->damage_begin == drawing->damage_end)
2095 drawing->damage_begin = control_flow_data->drawing->width-x;
2096 else
2097 drawing->damage_begin = 0;
2098
2099 drawing->damage_end = control_flow_data->drawing->width;
2100
2101 /* Clear the data request background, but not SAFETY */
2102 rectangle_pixmap(process_list,
2103 control_flow_data->drawing->drawing_area->style->black_gc,
2104 TRUE,
2105 drawing->damage_begin+SAFETY, 0,
2106 drawing->damage_end - drawing->damage_begin, // do not overlap
2107 -1);
2108 gtk_widget_queue_draw(drawing->drawing_area);
2109 //gtk_widget_queue_draw_area (drawing->drawing_area,
2110 // 0,0,
2111 // control_flow_data->drawing->width,
2112 // control_flow_data->drawing->height);
2113
2114 /* Get new data for the rest. */
2115 drawing_data_request(control_flow_data->drawing,
2116 drawing->damage_begin, 0,
2117 drawing->damage_end - drawing->damage_begin,
2118 control_flow_data->drawing->height);
2119 } else {
2120 //if(ns<os<ns+w)
2121 //if(ns<os && os<ns+w)
2122 //if(ns<os && os<new_end)
2123 if(ltt_time_compare(*ns,*os) == -1
2124 && ltt_time_compare(*os,new_end) == -1)
2125 {
2126 g_info("scrolling near left");
2127 /* Scroll left, keep left part of the screen */
2128 guint x = 0;
2129 guint width = control_flow_data->drawing->width;
2130 convert_time_to_pixels(
2131 *new_time_window,
2132 *os,
2133 width,
2134 &x);
2135
2136 /* Copy old data to new location */
2137 copy_pixmap_region (process_list,
2138 NULL,
2139 control_flow_data->drawing->drawing_area->style->black_gc,
2140 NULL,
2141 0, 0,
2142 x, 0,
2143 -1, -1);
2144
2145 if(drawing->damage_begin == drawing->damage_end)
2146 drawing->damage_end = x;
2147 else
2148 drawing->damage_end =
2149 control_flow_data->drawing->width;
2150
2151 drawing->damage_begin = 0;
2152
2153 rectangle_pixmap (process_list,
2154 control_flow_data->drawing->drawing_area->style->black_gc,
2155 TRUE,
2156 drawing->damage_begin, 0,
2157 drawing->damage_end - drawing->damage_begin, // do not overlap
2158 -1);
2159
2160 gtk_widget_queue_draw(drawing->drawing_area);
2161 //gtk_widget_queue_draw_area (drawing->drawing_area,
2162 // 0,0,
2163 // control_flow_data->drawing->width,
2164 // control_flow_data->drawing->height);
2165
2166
2167 /* Get new data for the rest. */
2168 drawing_data_request(control_flow_data->drawing,
2169 drawing->damage_begin, 0,
2170 drawing->damage_end - drawing->damage_begin,
2171 control_flow_data->drawing->height);
2172
2173 } else {
2174 if(ltt_time_compare(*ns,*os) == 0)
2175 {
2176 g_info("not scrolling");
2177 } else {
2178 g_info("scrolling far");
2179 /* Cannot reuse any part of the screen : far jump */
2180
2181
2182 rectangle_pixmap (process_list,
2183 control_flow_data->drawing->drawing_area->style->black_gc,
2184 TRUE,
2185 0, 0,
2186 control_flow_data->drawing->width+SAFETY, // do not overlap
2187 -1);
2188
2189 //gtk_widget_queue_draw_area (drawing->drawing_area,
2190 // 0,0,
2191 // control_flow_data->drawing->width,
2192 // control_flow_data->drawing->height);
2193 gtk_widget_queue_draw(drawing->drawing_area);
2194
2195 drawing->damage_begin = 0;
2196 drawing->damage_end = control_flow_data->drawing->width;
2197
2198 drawing_data_request(control_flow_data->drawing,
2199 0, 0,
2200 control_flow_data->drawing->width,
2201 control_flow_data->drawing->height);
2202
2203 }
2204 }
2205 }
2206 } else {
2207 /* Different scale (zoom) */
2208 g_info("zoom");
2209
2210 rectangle_pixmap (process_list,
2211 control_flow_data->drawing->drawing_area->style->black_gc,
2212 TRUE,
2213 0, 0,
2214 control_flow_data->drawing->width+SAFETY, // do not overlap
2215 -1);
2216
2217 //gtk_widget_queue_draw_area (drawing->drawing_area,
2218 // 0,0,
2219 // control_flow_data->drawing->width,
2220 // control_flow_data->drawing->height);
2221 gtk_widget_queue_draw(drawing->drawing_area);
2222
2223 drawing->damage_begin = 0;
2224 drawing->damage_end = control_flow_data->drawing->width;
2225
2226 drawing_data_request(control_flow_data->drawing,
2227 0, 0,
2228 control_flow_data->drawing->width,
2229 control_flow_data->drawing->height);
2230 }
2231
2232 /* Update directly when scrolling */
2233 gdk_window_process_updates(control_flow_data->drawing->drawing_area->window,
2234 TRUE);
2235
2236 return 0;
2237}
2238
2239gint traceset_notify(void *hook_data, void *call_data)
2240{
2241 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
2242 Drawing_t *drawing = control_flow_data->drawing;
2243
2244 if(unlikely(drawing->gc == NULL)) {
2245 return FALSE;
2246 }
2247 if(drawing->dotted_gc == NULL) {
2248 return FALSE;
2249 }
2250
2251 drawing_clear(control_flow_data->drawing);
2252 processlist_clear(control_flow_data->process_list);
2253 gtk_widget_set_size_request(
2254 control_flow_data->drawing->drawing_area,
2255 -1, processlist_get_height(control_flow_data->process_list));
2256 redraw_notify(control_flow_data, NULL);
2257
2258 request_background_data(control_flow_data);
2259
2260 return FALSE;
2261}
2262
2263gint redraw_notify(void *hook_data, void *call_data)
2264{
2265 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
2266 Drawing_t *drawing = control_flow_data->drawing;
2267 GtkWidget *widget = drawing->drawing_area;
2268
2269 drawing->damage_begin = 0;
2270 drawing->damage_end = drawing->width;
2271
2272 /* fun feature, to be separated someday... */
2273 drawing_clear(control_flow_data->drawing);
2274 processlist_clear(control_flow_data->process_list);
2275 gtk_widget_set_size_request(
2276 control_flow_data->drawing->drawing_area,
2277 -1, processlist_get_height(control_flow_data->process_list));
2278 // Clear the images
2279 rectangle_pixmap (control_flow_data->process_list,
2280 widget->style->black_gc,
2281 TRUE,
2282 0, 0,
2283 drawing->alloc_width,
2284 -1);
2285
2286 gtk_widget_queue_draw(drawing->drawing_area);
2287
2288 if(drawing->damage_begin < drawing->damage_end)
2289 {
2290 drawing_data_request(drawing,
2291 drawing->damage_begin,
2292 0,
2293 drawing->damage_end-drawing->damage_begin,
2294 drawing->height);
2295 }
2296
2297 //gtk_widget_queue_draw_area(drawing->drawing_area,
2298 // 0,0,
2299 // drawing->width,
2300 // drawing->height);
2301 return FALSE;
2302
2303}
2304
2305
2306gint continue_notify(void *hook_data, void *call_data)
2307{
2308 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
2309 Drawing_t *drawing = control_flow_data->drawing;
2310
2311 //g_assert(widget->allocation.width == drawing->damage_end);
2312
2313 if(drawing->damage_begin < drawing->damage_end)
2314 {
2315 drawing_data_request(drawing,
2316 drawing->damage_begin,
2317 0,
2318 drawing->damage_end-drawing->damage_begin,
2319 drawing->height);
2320 }
2321
2322 return FALSE;
2323}
2324
2325
2326gint update_current_time_hook(void *hook_data, void *call_data)
2327{
2328 ControlFlowData *control_flow_data = (ControlFlowData*)hook_data;
2329 Drawing_t *drawing = control_flow_data->drawing;
2330
2331 LttTime current_time = *((LttTime*)call_data);
2332
2333 TimeWindow time_window =
2334 lttvwindow_get_time_window(control_flow_data->tab);
2335
2336 LttTime time_begin = time_window.start_time;
2337 LttTime width = time_window.time_width;
2338 LttTime half_width;
2339 {
2340 guint64 time_ll = ltt_time_to_uint64(width);
2341 time_ll = time_ll >> 1; /* divide by two */
2342 half_width = ltt_time_from_uint64(time_ll);
2343 }
2344 LttTime time_end = ltt_time_add(time_begin, width);
2345
2346 LttvTracesetContext * tsc =
2347 lttvwindow_get_traceset_context(control_flow_data->tab);
2348
2349 LttTime trace_start = tsc->time_span.start_time;
2350 LttTime trace_end = tsc->time_span.end_time;
2351
2352 g_info("New current time HOOK : %lu, %lu", current_time.tv_sec,
2353 current_time.tv_nsec);
2354
2355
2356
2357 /* If current time is inside time interval, just move the highlight
2358 * bar */
2359
2360 /* Else, we have to change the time interval. We have to tell it
2361 * to the main window. */
2362 /* The time interval change will take care of placing the current
2363 * time at the center of the visible area, or nearest possible if we are
2364 * at one end of the trace. */
2365
2366
2367 if(ltt_time_compare(current_time, time_begin) < 0)
2368 {
2369 TimeWindow new_time_window;
2370
2371 if(ltt_time_compare(current_time,
2372 ltt_time_add(trace_start,half_width)) < 0)
2373 time_begin = trace_start;
2374 else
2375 time_begin = ltt_time_sub(current_time,half_width);
2376
2377 new_time_window.start_time = time_begin;
2378 new_time_window.time_width = width;
2379 new_time_window.time_width_double = ltt_time_to_double(width);
2380 new_time_window.end_time = ltt_time_add(time_begin, width);
2381
2382 lttvwindow_report_time_window(control_flow_data->tab, new_time_window);
2383 }
2384 else if(ltt_time_compare(current_time, time_end) > 0)
2385 {
2386 TimeWindow new_time_window;
2387
2388 if(ltt_time_compare(current_time, ltt_time_sub(trace_end, half_width)) > 0)
2389 time_begin = ltt_time_sub(trace_end,width);
2390 else
2391 time_begin = ltt_time_sub(current_time,half_width);
2392
2393 new_time_window.start_time = time_begin;
2394 new_time_window.time_width = width;
2395 new_time_window.time_width_double = ltt_time_to_double(width);
2396 new_time_window.end_time = ltt_time_add(time_begin, width);
2397
2398 lttvwindow_report_time_window(control_flow_data->tab, new_time_window);
2399
2400 }
2401 gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
2402
2403 /* Update directly when scrolling */
2404 gdk_window_process_updates(control_flow_data->drawing->drawing_area->window,
2405 TRUE);
2406
2407 return 0;
2408}
2409
2410typedef struct _ClosureData {
2411 EventsRequest *events_request;
2412 LttvTracesetState *tss;
2413 LttTime end_time;
2414 guint x_end;
2415} ClosureData;
2416
58a9b31b 2417/* Draw line until end of the screen */
9e01e6d4 2418
2419void draw_closure(gpointer key, gpointer value, gpointer user_data)
2420{
58a9b31b 2421// ResourceInfo *process_info = (ResourceInfo*)key;
2422// HashedResourceData *hashed_process_data = (HashedResourceData*)value;
2423// ClosureData *closure_data = (ClosureData*)user_data;
2424//
2425// EventsRequest *events_request = closure_data->events_request;
2426// ControlFlowData *control_flow_data = events_request->viewer_data;
2427//
2428// LttvTracesetState *tss = closure_data->tss;
2429// LttvTracesetContext *tsc = (LttvTracesetContext*)tss;
2430//
2431// LttTime evtime = closure_data->end_time;
2432//
2433// gboolean dodraw = TRUE;
2434//
2435// {
2436// /* For the process */
2437// /* First, check if the current process is in the state computation
2438// * process list. If it is there, that means we must add it right now and
2439// * draw items from the beginning of the read for it. If it is not
2440// * present, it's a new process and it was not present : it will
2441// * be added after the state update. */
2442//#ifdef EXTRA_CHECK
2443// g_assert(lttv_traceset_number(tsc->ts) > 0);
2444//#endif //EXTRA_CHECK
2445// LttvTraceContext *tc = tsc->traces[process_info->trace_num];
2446// LttvTraceState *ts = (LttvTraceState*)tc;
2447//
2448//#if 0
2449// //FIXME : optimize data structures.
2450// LttvTracefileState *tfs;
2451// LttvTracefileContext *tfc;
2452// guint i;
2453// for(i=0;i<tc->tracefiles->len;i++) {
2454// tfc = g_array_index(tc->tracefiles, LttvTracefileContext*, i);
2455// if(ltt_tracefile_name(tfc->tf) == LTT_NAME_CPU
2456// && tfs->cpu == process_info->cpu)
2457// break;
2458//
2459// }
2460// g_assert(i<tc->tracefiles->len);
2461// tfs = LTTV_TRACEFILE_STATE(tfc);
2462//#endif //0
2463// // LttvTracefileState *tfs =
2464// // (LttvTracefileState*)tsc->traces[process_info->trace_num]->
2465// // tracefiles[process_info->cpu];
2466//
2467// LttvProcessState *process;
2468// process = lttv_state_find_process(ts, process_info->cpu,
2469// process_info->pid);
2470//
2471// if(unlikely(process != NULL)) {
2472//
2473// LttvFilter *filter = control_flow_data->filter;
2474// if(filter != NULL && filter->head != NULL)
2475// if(!lttv_filter_tree_parse(filter->head,NULL,NULL,
2476// tc->t,NULL,process,tc))
2477// dodraw = FALSE;
2478//
2479// /* Only draw for processes that are currently in the trace states */
2480//
2481// ProcessList *process_list = control_flow_data->process_list;
2482//#ifdef EXTRA_CHECK
2483// /* Should be alike when background info is ready */
2484// if(control_flow_data->background_info_waiting==0)
2485// g_assert(ltt_time_compare(process->creation_time,
2486// process_info->birth) == 0);
2487//#endif //EXTRA_CHECK
2488//
2489// /* Now, the process is in the state hash and our own process hash.
2490// * We definitely can draw the items related to the ending state.
2491// */
2492//
2493// if(unlikely(ltt_time_compare(hashed_process_data->next_good_time,
2494// evtime) <= 0))
2495// {
2496// TimeWindow time_window =
2497// lttvwindow_get_time_window(control_flow_data->tab);
2498//
2499//#ifdef EXTRA_CHECK
2500// if(ltt_time_compare(evtime, time_window.start_time) == -1
2501// || ltt_time_compare(evtime, time_window.end_time) == 1)
2502// return;
2503//#endif //EXTRA_CHECK
2504// Drawing_t *drawing = control_flow_data->drawing;
2505// guint width = drawing->width;
2506//
2507// guint x = closure_data->x_end;
2508//
2509// DrawContext draw_context;
2510//
2511// /* Now create the drawing context that will be used to draw
2512// * items related to the last state. */
2513// draw_context.drawable = hashed_process_data->pixmap;
2514// draw_context.gc = drawing->gc;
2515// draw_context.pango_layout = drawing->pango_layout;
2516// draw_context.drawinfo.end.x = x;
2517//
2518// draw_context.drawinfo.y.over = 1;
2519// draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
2520// draw_context.drawinfo.y.under = hashed_process_data->height;
2521//
2522// draw_context.drawinfo.start.offset.over = 0;
2523// draw_context.drawinfo.start.offset.middle = 0;
2524// draw_context.drawinfo.start.offset.under = 0;
2525// draw_context.drawinfo.end.offset.over = 0;
2526// draw_context.drawinfo.end.offset.middle = 0;
2527// draw_context.drawinfo.end.offset.under = 0;
2528//#if 0
2529// /* Jump over draw if we are at the same x position */
2530// if(x == hashed_process_data->x.over)
2531// {
2532// /* jump */
2533// } else {
2534// draw_context.drawinfo.start.x = hashed_process_data->x.over;
2535// /* Draw the line */
2536// PropertiesLine prop_line = prepare_execmode_line(process);
2537// draw_line((void*)&prop_line, (void*)&draw_context);
2538//
2539// hashed_process_data->x.over = x;
2540// }
2541//#endif //0
2542//
2543// if(unlikely(x == hashed_process_data->x.middle &&
2544// hashed_process_data->x.middle_used)) {
2545//#if 0 /* do not mark closure : not missing information */
2546// if(hashed_process_data->x.middle_marked == FALSE) {
2547// /* Draw collision indicator */
2548// gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
2549// gdk_draw_point(drawing->pixmap,
2550// drawing->gc,
2551// x,
2552// y+(height/2)-3);
2553// hashed_process_data->x.middle_marked = TRUE;
2554// }
2555//#endif //0
2556// /* Jump */
2557// } else {
2558// draw_context.drawinfo.start.x = hashed_process_data->x.middle;
2559// /* Draw the line */
2560// if(dodraw) {
2561// PropertiesLine prop_line = prepare_s_e_line(process);
2562// draw_line((void*)&prop_line, (void*)&draw_context);
2563// }
2564//
2565// /* become the last x position */
2566// if(likely(x != hashed_process_data->x.middle)) {
2567// hashed_process_data->x.middle = x;
2568// /* but don't use the pixel */
2569// hashed_process_data->x.middle_used = FALSE;
2570//
2571// /* Calculate the next good time */
2572// convert_pixels_to_time(width, x+1, time_window,
2573// &hashed_process_data->next_good_time);
2574// }
2575// }
2576// }
2577// }
2578// }
9e01e6d4 2579 return;
2580}
2581
2582int before_chunk(void *hook_data, void *call_data)
2583{
2584 EventsRequest *events_request = (EventsRequest*)hook_data;
2585 LttvTracesetState *tss = (LttvTracesetState*)call_data;
2586 ControlFlowData *cfd = (ControlFlowData*)events_request->viewer_data;
2587#if 0
2588 /* Desactivate sort */
2589 gtk_tree_sortable_set_sort_column_id(
2590 GTK_TREE_SORTABLE(cfd->process_list->list_store),
2591 TRACE_COLUMN,
2592 GTK_SORT_ASCENDING);
2593#endif //0
2594 drawing_chunk_begin(events_request, tss);
2595
2596 return 0;
2597}
2598
2599int before_request(void *hook_data, void *call_data)
2600{
2601 EventsRequest *events_request = (EventsRequest*)hook_data;
2602 LttvTracesetState *tss = (LttvTracesetState*)call_data;
2603
2604 drawing_data_request_begin(events_request, tss);
2605
2606 return 0;
2607}
2608
2609
2610/*
2611 * after request is necessary in addition of after chunk in order to draw
2612 * lines until the end of the screen. after chunk just draws lines until
2613 * the last event.
2614 *
2615 * for each process
2616 * draw closing line
2617 * expose
2618 */
58a9b31b 2619// TODO pmf: reenable this
9e01e6d4 2620int after_request(void *hook_data, void *call_data)
2621{
58a9b31b 2622// EventsRequest *events_request = (EventsRequest*)hook_data;
2623// ControlFlowData *control_flow_data = events_request->viewer_data;
2624// LttvTracesetState *tss = (LttvTracesetState*)call_data;
2625//
2626// ProcessList *process_list = control_flow_data->process_list;
2627// LttTime end_time = events_request->end_time;
2628//
2629// ClosureData closure_data;
2630// closure_data.events_request = (EventsRequest*)hook_data;
2631// closure_data.tss = tss;
2632// closure_data.end_time = end_time;
2633//
2634// TimeWindow time_window =
2635// lttvwindow_get_time_window(control_flow_data->tab);
2636// guint width = control_flow_data->drawing->width;
2637// convert_time_to_pixels(
2638// time_window,
2639// end_time,
2640// width,
2641// &closure_data.x_end);
2642//
2643//
2644// /* Draw last items */
2645// g_hash_table_foreach(process_list->process_hash, draw_closure,
2646// (void*)&closure_data);
2647//
2648//
2649// /* Request expose */
2650// drawing_request_expose(events_request, tss, end_time);
9e01e6d4 2651 return 0;
2652}
2653
2654/*
2655 * for each process
2656 * draw closing line
2657 * expose
2658 */
2659int after_chunk(void *hook_data, void *call_data)
2660{
2661 EventsRequest *events_request = (EventsRequest*)hook_data;
2662 ControlFlowData *control_flow_data = events_request->viewer_data;
2663 LttvTracesetState *tss = (LttvTracesetState*)call_data;
2664 LttvTracesetContext *tsc = (LttvTracesetContext*)call_data;
2665 LttvTracefileContext *tfc = lttv_traceset_context_get_current_tfc(tsc);
2666 LttTime end_time;
2667
2668 ProcessList *process_list = control_flow_data->process_list;
2669 guint i;
2670 LttvTraceset *traceset = tsc->ts;
2671 guint nb_trace = lttv_traceset_number(traceset);
2672
2673 /* Only execute when called for the first trace's events request */
2674 if(!process_list->current_hash_data) return;
2675
2676 for(i = 0 ; i < nb_trace ; i++) {
2677 g_free(process_list->current_hash_data[i]);
2678 }
2679 g_free(process_list->current_hash_data);
2680 process_list->current_hash_data = NULL;
2681
2682 if(tfc != NULL)
2683 end_time = LTT_TIME_MIN(tfc->timestamp, events_request->end_time);
2684 else /* end of traceset, or position now out of request : end */
2685 end_time = events_request->end_time;
2686
2687 ClosureData closure_data;
2688 closure_data.events_request = (EventsRequest*)hook_data;
2689 closure_data.tss = tss;
2690 closure_data.end_time = end_time;
2691
2692 TimeWindow time_window =
2693 lttvwindow_get_time_window(control_flow_data->tab);
2694 guint width = control_flow_data->drawing->width;
2695 convert_time_to_pixels(
2696 time_window,
2697 end_time,
2698 width,
2699 &closure_data.x_end);
2700
2701 /* Draw last items */
2702 g_hash_table_foreach(process_list->process_hash, draw_closure,
2703 (void*)&closure_data);
2704#if 0
2705 /* Reactivate sort */
2706 gtk_tree_sortable_set_sort_column_id(
2707 GTK_TREE_SORTABLE(control_flow_data->process_list->list_store),
2708 GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
2709 GTK_SORT_ASCENDING);
2710
2711 update_index_to_pixmap(control_flow_data->process_list);
2712 /* Request a full expose : drawing scrambled */
2713 gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
2714#endif //0
2715 /* Request expose (updates damages zone also) */
2716 drawing_request_expose(events_request, tss, end_time);
2717
2718 return 0;
2719}
2720
2721/* after_statedump_end
2722 *
2723 * @param hook_data ControlFlowData structure of the viewer.
2724 * @param call_data Event context.
2725 *
2726 * This function adds items to be drawn in a queue for each process.
2727 *
2728 */
2729int before_statedump_end(void *hook_data, void *call_data)
2730{
2731 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
2732 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
2733 ControlFlowData *control_flow_data = events_request->viewer_data;
2734
2735 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
2736
2737 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
2738
2739 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
2740
2741 LttvTracesetState *tss = (LttvTracesetState*)tfc->t_context->ts_context;
2742 ProcessList *process_list = control_flow_data->process_list;
2743
2744 LttEvent *e;
2745 e = ltt_tracefile_get_event(tfc->tf);
2746
2747 LttvFilter *filter = control_flow_data->filter;
2748 if(filter != NULL && filter->head != NULL)
2749 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
2750 tfc->t_context->t,tfc,NULL,NULL))
2751 return FALSE;
2752
2753 LttTime evtime = ltt_event_time(e);
2754
2755 ClosureData closure_data;
2756 closure_data.events_request = events_request;
2757 closure_data.tss = tss;
2758 closure_data.end_time = evtime;
2759
2760 TimeWindow time_window =
2761 lttvwindow_get_time_window(control_flow_data->tab);
2762 guint width = control_flow_data->drawing->width;
2763 convert_time_to_pixels(
2764 time_window,
2765 evtime,
2766 width,
2767 &closure_data.x_end);
2768
2769 /* Draw last items */
2770 g_hash_table_foreach(process_list->process_hash, draw_closure,
2771 (void*)&closure_data);
2772#if 0
2773 /* Reactivate sort */
2774 gtk_tree_sortable_set_sort_column_id(
2775 GTK_TREE_SORTABLE(control_flow_data->process_list->list_store),
2776 GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
2777 GTK_SORT_ASCENDING);
2778
2779 update_index_to_pixmap(control_flow_data->process_list);
2780 /* Request a full expose : drawing scrambled */
2781 gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
2782#endif //0
2783 /* Request expose (updates damages zone also) */
2784 drawing_request_expose(events_request, tss, evtime);
2785
2786 return 0;
2787}
LTTng 2.x Viewer (LTTV)
This page took 0.12925 seconds and 4 git commands to generate.