projects / lttv.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
move examples
[lttv.git] / trunk / lttv / 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>
43ed82b5 59#include <inttypes.h>
9e01e6d4 60
61//#include <pango/pango.h>
62
63#include <ltt/event.h>
64#include <ltt/time.h>
9e01e6d4 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
3d27be8a 82#define STATE_LINE_WIDTH 6
9e01e6d4 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{
67f72973 95 ControlFlowData *resourceview_data = (ControlFlowData *)hook_data;
9e01e6d4 96
67f72973 97 resourceview_data->background_info_waiting--;
9e01e6d4 98
67f72973 99 if(resourceview_data->background_info_waiting == 0) {
9e01e6d4 100 g_message("control flow viewer : background computation data ready.");
101
67f72973 102 drawing_clear(resourceview_data->drawing);
103 processlist_clear(resourceview_data->process_list);
9e01e6d4 104 gtk_widget_set_size_request(
67f72973 105 resourceview_data->drawing->drawing_area,
106 -1, processlist_get_height(resourceview_data->process_list));
107 redraw_notify(resourceview_data, NULL);
9e01e6d4 108 }
109
110 return 0;
111}
112
113
114/* Request background computation. Verify if it is in progress or ready first.
115 * Only for each trace in the tab's traceset.
116 */
67f72973 117static void request_background_data(ControlFlowData *resourceview_data)
9e01e6d4 118{
119 LttvTracesetContext * tsc =
67f72973 120 lttvwindow_get_traceset_context(resourceview_data->tab);
9e01e6d4 121 gint num_traces = lttv_traceset_number(tsc->ts);
122 gint i;
123 LttvTrace *trace;
124 LttvTraceState *tstate;
125
126 LttvHooks *background_ready_hook =
127 lttv_hooks_new();
67f72973 128 lttv_hooks_add(background_ready_hook, background_ready, resourceview_data,
9e01e6d4 129 LTTV_PRIO_DEFAULT);
67f72973 130 resourceview_data->background_info_waiting = 0;
9e01e6d4 131
132 for(i=0;i<num_traces;i++) {
133 trace = lttv_traceset_get(tsc->ts, i);
134 tstate = LTTV_TRACE_STATE(tsc->traces[i]);
135
136 if(lttvwindowtraces_get_ready(g_quark_from_string("state"),trace)==FALSE
137 && !tstate->has_precomputed_states) {
138
139 if(lttvwindowtraces_get_in_progress(g_quark_from_string("state"),
140 trace) == FALSE) {
141 /* We first remove requests that could have been done for the same
142 * information. Happens when two viewers ask for it before servicing
143 * starts.
144 */
145 if(!lttvwindowtraces_background_request_find(trace, "state"))
146 lttvwindowtraces_background_request_queue(
67f72973 147 main_window_get_widget(resourceview_data->tab), trace, "state");
148 lttvwindowtraces_background_notify_queue(resourceview_data,
9e01e6d4 149 trace,
150 ltt_time_infinite,
151 NULL,
152 background_ready_hook);
67f72973 153 resourceview_data->background_info_waiting++;
9e01e6d4 154 } else { /* in progress */
155
67f72973 156 lttvwindowtraces_background_notify_current(resourceview_data,
9e01e6d4 157 trace,
158 ltt_time_infinite,
159 NULL,
160 background_ready_hook);
67f72973 161 resourceview_data->background_info_waiting++;
9e01e6d4 162 }
163 } else {
164 /* Data ready. By its nature, this viewer doesn't need to have
165 * its data ready hook called there, because a background
166 * request is always linked with a redraw.
167 */
168 }
9e01e6d4 169 }
170
171 lttv_hooks_destroy(background_ready_hook);
172}
173
174
9e01e6d4 175/**
176 * Event Viewer's constructor hook
177 *
178 * This constructor is given as a parameter to the menuitem and toolbar button
179 * registration. It creates the list.
180 * @param tab A pointer to the parent tab.
181 * @return The widget created.
182 */
183GtkWidget *
58a9b31b 184h_resourceview(LttvPlugin *plugin)
9e01e6d4 185{
186 LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin);
187 Tab *tab = ptab->tab;
188 g_info("h_guicontrolflow, %p", tab);
67f72973 189 ControlFlowData *resourceview_data = resourceview(ptab);
9e01e6d4 190
67f72973 191 resourceview_data->tab = tab;
9e01e6d4 192
193 // Unreg done in the GuiControlFlow_Destructor
194 lttvwindow_register_traceset_notify(tab,
195 traceset_notify,
67f72973 196 resourceview_data);
9e01e6d4 197
198 lttvwindow_register_time_window_notify(tab,
199 update_time_window_hook,
67f72973 200 resourceview_data);
9e01e6d4 201 lttvwindow_register_current_time_notify(tab,
202 update_current_time_hook,
67f72973 203 resourceview_data);
9e01e6d4 204 lttvwindow_register_redraw_notify(tab,
205 redraw_notify,
67f72973 206 resourceview_data);
9e01e6d4 207 lttvwindow_register_continue_notify(tab,
208 continue_notify,
67f72973 209 resourceview_data);
210 request_background_data(resourceview_data);
9e01e6d4 211
212
67f72973 213 return guicontrolflow_get_widget(resourceview_data) ;
9e01e6d4 214
215}
216
217void legend_destructor(GtkWindow *legend)
218{
219 g_legend_list = g_slist_remove(g_legend_list, legend);
220}
221
222/* Create a popup legend */
223GtkWidget *
224h_legend(LttvPlugin *plugin)
225{
226 LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin);
227 Tab *tab = ptab->tab;
228 g_info("h_legend, %p", tab);
229
230 GtkWindow *legend = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
231
232 g_legend_list = g_slist_append(
233 g_legend_list,
234 legend);
235
236 g_object_set_data_full(
237 G_OBJECT(legend),
238 "legend",
239 legend,
240 (GDestroyNotify)legend_destructor);
241
242 gtk_window_set_title(legend, "Control Flow View Legend");
243
244 GtkWidget *pixmap = create_pixmap(GTK_WIDGET(legend), "lttv-color-list.png");
245
9e01e6d4 246 gtk_container_add(GTK_CONTAINER(legend), GTK_WIDGET(pixmap));
247
248 gtk_widget_show(GTK_WIDGET(pixmap));
249 gtk_widget_show(GTK_WIDGET(legend));
250
251
252 return NULL; /* This is a popup window */
253}
254
255
256int event_selected_hook(void *hook_data, void *call_data)
257{
67f72973 258 ControlFlowData *resourceview_data = (ControlFlowData*) hook_data;
9e01e6d4 259 guint *event_number = (guint*) call_data;
260
261 g_debug("DEBUG : event selected by main window : %u", *event_number);
262
263 return 0;
264}
265
d3d99fde 266static void cpu_set_line_color(PropertiesLine *prop_line, LttvCPUState *s)
598026ba 267{
1b171947 268 GQuark present_state;
269
270 if(s->mode_stack->len == 0)
271 present_state = LTTV_CPU_UNKNOWN;
272 else
273 present_state = ((GQuark*)s->mode_stack->data)[s->mode_stack->len-1];
d3d99fde 274
201fcc15 275 if(present_state == LTTV_CPU_IDLE) {
598026ba 276 prop_line->color = drawing_colors_cpu[COL_CPU_IDLE];
277 }
278 else if(present_state == LTTV_CPU_BUSY) {
279 prop_line->color = drawing_colors_cpu[COL_CPU_BUSY];
280 }
281 else if(present_state == LTTV_CPU_IRQ) {
282 prop_line->color = drawing_colors_cpu[COL_CPU_IRQ];
283 }
d34141ca 284 else if(present_state == LTTV_CPU_SOFT_IRQ) {
285 prop_line->color = drawing_colors_cpu[COL_CPU_SOFT_IRQ];
286 }
d3d99fde 287 else if(present_state == LTTV_CPU_TRAP) {
288 prop_line->color = drawing_colors_cpu[COL_CPU_TRAP];
201fcc15 289 } else {
290 prop_line->color = drawing_colors_cpu[COL_CPU_UNKNOWN];
d3d99fde 291 }
598026ba 292}
9e01e6d4 293
8743690d 294static void irq_set_line_color(PropertiesLine *prop_line, LttvIRQState *s)
295{
1b171947 296 GQuark present_state;
297 if(s->mode_stack->len == 0)
298 present_state = LTTV_IRQ_UNKNOWN;
299 else
300 present_state = ((GQuark*)s->mode_stack->data)[s->mode_stack->len-1];
8743690d 301
1b171947 302 if(present_state == LTTV_IRQ_IDLE) {
8743690d 303 prop_line->color = drawing_colors_irq[COL_IRQ_IDLE];
304 }
305 else if(present_state == LTTV_IRQ_BUSY) {
306 prop_line->color = drawing_colors_irq[COL_IRQ_BUSY];
307 }
1b171947 308 else {
309 prop_line->color = drawing_colors_irq[COL_IRQ_UNKNOWN];
310 }
8743690d 311}
312
0305fe77 313static void soft_irq_set_line_color(PropertiesLine *prop_line, LttvSoftIRQState *s)
314{
315 GQuark present_state;
67c73bb3 316 if(s->running)
0305fe77 317 prop_line->color = drawing_colors_soft_irq[COL_SOFT_IRQ_BUSY];
67c73bb3 318 else if(s->pending)
319 prop_line->color = drawing_colors_soft_irq[COL_SOFT_IRQ_PENDING];
320 else
321 prop_line->color = drawing_colors_soft_irq[COL_SOFT_IRQ_IDLE];
0305fe77 322}
323
38726a78 324static void trap_set_line_color(PropertiesLine *prop_line, LttvTrapState *s)
325{
326 GQuark present_state;
327 if(s->running == 0)
328 prop_line->color = drawing_colors_trap[COL_TRAP_IDLE];
329 else
330 prop_line->color = drawing_colors_trap[COL_TRAP_BUSY];
331}
332
20d16f82 333static void bdev_set_line_color(PropertiesLine *prop_line, LttvBdevState *s)
334{
1b171947 335 GQuark present_state;
23e59a12 336 if(s == 0 || s->mode_stack->len == 0)
1b171947 337 present_state = LTTV_BDEV_UNKNOWN;
338 else
339 present_state = ((GQuark*)s->mode_stack->data)[s->mode_stack->len-1];
20d16f82 340
1b171947 341 if(present_state == LTTV_BDEV_IDLE) {
20d16f82 342 prop_line->color = drawing_colors_bdev[COL_BDEV_IDLE];
343 }
344 else if(present_state == LTTV_BDEV_BUSY_READING) {
345 prop_line->color = drawing_colors_bdev[COL_BDEV_BUSY_READING];
346 }
347 else if(present_state == LTTV_BDEV_BUSY_WRITING) {
348 prop_line->color = drawing_colors_bdev[COL_BDEV_BUSY_WRITING];
349 }
1b171947 350 else {
351 prop_line->color = drawing_colors_bdev[COL_BDEV_UNKNOWN];
352 }
20d16f82 353}
354
9e01e6d4 355/* before_schedchange_hook
356 *
357 * This function basically draw lines and icons. Two types of lines are drawn :
358 * one small (3 pixels?) representing the state of the process and the second
359 * type is thicker (10 pixels?) representing on which CPU a process is running
360 * (and this only in running state).
361 *
362 * Extremums of the lines :
363 * x_min : time of the last event context for this process kept in memory.
364 * x_max : time of the current event.
365 * y : middle of the process in the process list. The process is found in the
366 * list, therefore is it's position in pixels.
367 *
368 * The choice of lines'color is defined by the context of the last event for this
369 * process.
370 */
371
372
373int before_schedchange_hook(void *hook_data, void *call_data)
374{
dd455fb8 375 LttvTraceHook *th = (LttvTraceHook*)hook_data;
376 EventsRequest *events_request = (EventsRequest*)th->hook_data;
67f72973 377 ControlFlowData *resourceview_data = events_request->viewer_data;
9e01e6d4 378
379 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
380
381 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
382 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
383
384 LttEvent *e;
385 e = ltt_tracefile_get_event(tfc->tf);
386 gint target_pid_saved = tfc->target_pid;
387
388 LttTime evtime = ltt_event_time(e);
67f72973 389 LttvFilter *filter = resourceview_data->filter;
58a9b31b 390
9e01e6d4 391 /* we are in a schedchange, before the state update. We must draw the
392 * items corresponding to the state before it changes : now is the right
393 * time to do it.
394 */
395
396 guint pid_out;
397 guint pid_in;
ca5c76ed 398 pid_out = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
399 pid_in = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1));
67f72973 400// TODO: can't we reenable this? pmf
44ffb95f 401// if(pid_in != 0 && pid_out != 0) {
402// /* not a transition to/from idle */
403// return 0;
404// }
c4e6f4dc 405
9e01e6d4 406 tfc->target_pid = pid_out;
58a9b31b 407
67f72973 408 guint cpu = tfs->cpu;
9e01e6d4 409
67f72973 410 guint trace_num = ts->parent.index;
411 /* Add process to process list (if not present) */
412 guint pl_height = 0;
413 HashedResourceData *hashed_process_data = NULL;
414 ProcessList *process_list = resourceview_data->process_list;
9e01e6d4 415
67f72973 416 hashed_process_data = resourcelist_obtain_cpu(resourceview_data, trace_num, cpu);
417
418 /* Now, the process is in the state hash and our own process hash.
419 * We definitely can draw the items related to the ending state.
420 */
421
422 if(ltt_time_compare(hashed_process_data->next_good_time,
423 evtime) > 0)
424 {
425 if(hashed_process_data->x.middle_marked == FALSE) {
426
427 TimeWindow time_window =
428 lttvwindow_get_time_window(resourceview_data->tab);
9e01e6d4 429#ifdef EXTRA_CHECK
67f72973 430 if(ltt_time_compare(evtime, time_window.start_time) == -1
431 || ltt_time_compare(evtime, time_window.end_time) == 1)
432 return;
9e01e6d4 433#endif //EXTRA_CHECK
67f72973 434 Drawing_t *drawing = resourceview_data->drawing;
435 guint width = drawing->width;
436 guint x;
437 convert_time_to_pixels(
438 time_window,
439 evtime,
440 width,
441 &x);
442
443 /* Draw collision indicator */
444 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
445 gdk_draw_point(hashed_process_data->pixmap,
446 drawing->gc,
447 x,
448 COLLISION_POSITION(hashed_process_data->height));
449 hashed_process_data->x.middle_marked = TRUE;
450 }
451 } else {
452 TimeWindow time_window =
453 lttvwindow_get_time_window(resourceview_data->tab);
9e01e6d4 454#ifdef EXTRA_CHECK
67f72973 455 if(ltt_time_compare(evtime, time_window.start_time) == -1
9e01e6d4 456 || ltt_time_compare(evtime, time_window.end_time) == 1)
67f72973 457 return;
9e01e6d4 458#endif //EXTRA_CHECK
67f72973 459 Drawing_t *drawing = resourceview_data->drawing;
460 guint width = drawing->width;
461 guint x;
462 convert_time_to_pixels(
463 time_window,
464 evtime,
465 width,
466 &x);
9e01e6d4 467
67f72973 468 /* Jump over draw if we are at the same x position */
469 if(x == hashed_process_data->x.middle &&
470 hashed_process_data->x.middle_used)
471 {
472 if(hashed_process_data->x.middle_marked == FALSE) {
473 /* Draw collision indicator */
474 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
475 gdk_draw_point(hashed_process_data->pixmap,
476 drawing->gc,
477 x,
478 COLLISION_POSITION(hashed_process_data->height));
479 hashed_process_data->x.middle_marked = TRUE;
58a9b31b 480 }
67f72973 481 /* jump */
482 } else {
483 DrawContext draw_context;
9e01e6d4 484
67f72973 485 /* Now create the drawing context that will be used to draw
486 * items related to the last state. */
487 draw_context.drawable = hashed_process_data->pixmap;
488 draw_context.gc = drawing->gc;
489 draw_context.pango_layout = drawing->pango_layout;
490 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
491 draw_context.drawinfo.end.x = x;
9e01e6d4 492
67f72973 493 draw_context.drawinfo.y.over = 1;
494 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
495 draw_context.drawinfo.y.under = hashed_process_data->height;
9e01e6d4 496
67f72973 497 draw_context.drawinfo.start.offset.over = 0;
498 draw_context.drawinfo.start.offset.middle = 0;
499 draw_context.drawinfo.start.offset.under = 0;
500 draw_context.drawinfo.end.offset.over = 0;
501 draw_context.drawinfo.end.offset.middle = 0;
502 draw_context.drawinfo.end.offset.under = 0;
9e01e6d4 503
67f72973 504 {
505 /* Draw the line */
506 //PropertiesLine prop_line = prepare_s_e_line(process);
507 PropertiesLine prop_line;
508 prop_line.line_width = STATE_LINE_WIDTH;
509 prop_line.style = GDK_LINE_SOLID;
510 prop_line.y = MIDDLE;
511 cpu_set_line_color(&prop_line, tfs->cpu_state);
512 draw_line((void*)&prop_line, (void*)&draw_context);
9e01e6d4 513
67f72973 514 }
515 /* become the last x position */
516 hashed_process_data->x.middle = x;
517 hashed_process_data->x.middle_used = TRUE;
518 hashed_process_data->x.middle_marked = FALSE;
9e01e6d4 519
67f72973 520 /* Calculate the next good time */
521 convert_pixels_to_time(width, x+1, time_window,
522 &hashed_process_data->next_good_time);
523 }
9e01e6d4 524 }
525
67f72973 526 return 0;
9e01e6d4 527}
528
58a9b31b 529/* after_schedchange_hook
530 *
531 * The draw after hook is called by the reading API to have a
532 * particular event drawn on the screen.
533 * @param hook_data ControlFlowData structure of the viewer.
534 * @param call_data Event context.
535 *
536 * This function adds items to be drawn in a queue for each process.
537 *
538 */
539int after_schedchange_hook(void *hook_data, void *call_data)
9e01e6d4 540{
dd455fb8 541 LttvTraceHook *th = (LttvTraceHook*)hook_data;
542 EventsRequest *events_request = (EventsRequest*)th->hook_data;
67f72973 543 ControlFlowData *resourceview_data = events_request->viewer_data;
44ffb95f 544 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
44ffb95f 545 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
44ffb95f 546 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
44ffb95f 547 LttEvent *e;
67f72973 548
44ffb95f 549 e = ltt_tracefile_get_event(tfc->tf);
550
67f72973 551 LttvFilter *filter = resourceview_data->filter;
44ffb95f 552 if(filter != NULL && filter->head != NULL)
553 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
554 tfc->t_context->t,tfc,NULL,NULL))
555 return FALSE;
556
557 LttTime evtime = ltt_event_time(e);
558
44ffb95f 559 /* Add process to process list (if not present) */
560 LttvProcessState *process_in;
561 LttTime birth;
562 guint pl_height = 0;
563 HashedResourceData *hashed_process_data_in = NULL;
564
67f72973 565 ProcessList *process_list = resourceview_data->process_list;
44ffb95f 566
567 guint pid_in;
568 {
569 guint pid_out;
ca5c76ed 570 pid_out = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
571 pid_in = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1));
44ffb95f 572 }
573
574
575 /* Find process pid_in in the list... */
576 //process_in = lttv_state_find_process(ts, ANY_CPU, pid_in);
577 //process_in = tfs->process;
578 guint cpu = tfs->cpu;
44ffb95f 579 guint trace_num = ts->parent.index;
580 process_in = ts->running_process[cpu];
581 /* It should exist, because we are after the state update. */
582#ifdef EXTRA_CHECK
583 g_assert(process_in != NULL);
584#endif //EXTRA_CHECK
585 birth = process_in->creation_time;
586
67f72973 587 //hashed_process_data_in = processlist_get_process_data(process_list, cpuq, trace_num);
588 hashed_process_data_in = resourcelist_obtain_cpu(resourceview_data, trace_num, cpu);
589
44ffb95f 590 /* Set the current process */
591 process_list->current_hash_data[trace_num][process_in->cpu] =
592 hashed_process_data_in;
593
594 if(ltt_time_compare(hashed_process_data_in->next_good_time,
595 evtime) <= 0)
596 {
597 TimeWindow time_window =
67f72973 598 lttvwindow_get_time_window(resourceview_data->tab);
44ffb95f 599
600#ifdef EXTRA_CHECK
601 if(ltt_time_compare(evtime, time_window.start_time) == -1
602 || ltt_time_compare(evtime, time_window.end_time) == 1)
603 return;
604#endif //EXTRA_CHECK
67f72973 605 Drawing_t *drawing = resourceview_data->drawing;
44ffb95f 606 guint width = drawing->width;
607 guint new_x;
608
609 convert_time_to_pixels(
610 time_window,
611 evtime,
612 width,
613 &new_x);
614
615 if(hashed_process_data_in->x.middle != new_x) {
616 hashed_process_data_in->x.middle = new_x;
617 hashed_process_data_in->x.middle_used = FALSE;
618 hashed_process_data_in->x.middle_marked = FALSE;
619 }
620 }
58a9b31b 621 return 0;
622}
9e01e6d4 623
43ed82b5 624int before_execmode_hook_irq(void *hook_data, void *call_data);
625int before_execmode_hook_soft_irq(void *hook_data, void *call_data);
626int before_execmode_hook_trap(void *hook_data, void *call_data);
627
58a9b31b 628/* before_execmode_hook
629 *
630 * This function basically draw lines and icons. Two types of lines are drawn :
631 * one small (3 pixels?) representing the state of the process and the second
632 * type is thicker (10 pixels?) representing on which CPU a process is running
633 * (and this only in running state).
634 *
635 * Extremums of the lines :
636 * x_min : time of the last event context for this process kept in memory.
637 * x_max : time of the current event.
638 * y : middle of the process in the process list. The process is found in the
639 * list, therefore is it's position in pixels.
640 *
641 * The choice of lines'color is defined by the context of the last event for this
642 * process.
643 */
9e01e6d4 644
598026ba 645int before_execmode_hook(void *hook_data, void *call_data)
646{
dd455fb8 647 LttvTraceHook *th = (LttvTraceHook*)hook_data;
648 EventsRequest *events_request = (EventsRequest*)th->hook_data;
67f72973 649 ControlFlowData *resourceview_data = events_request->viewer_data;
598026ba 650
651 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
652
653 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
654 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
655
656 LttEvent *e;
657 e = ltt_tracefile_get_event(tfc->tf);
658
659 LttTime evtime = ltt_event_time(e);
660
8743690d 661 before_execmode_hook_irq(hook_data, call_data);
0305fe77 662 before_execmode_hook_soft_irq(hook_data, call_data);
38726a78 663 before_execmode_hook_trap(hook_data, call_data);
8743690d 664
598026ba 665 /* we are in a execmode, before the state update. We must draw the
666 * items corresponding to the state before it changes : now is the right
667 * time to do it.
668 */
669 /* For the pid */
598026ba 670 guint cpu = tfs->cpu;
67f72973 671
598026ba 672 guint trace_num = ts->parent.index;
673 LttvProcessState *process = ts->running_process[cpu];
674 g_assert(process != NULL);
675
598026ba 676 /* Well, the process_out existed : we must get it in the process hash
677 * or add it, and draw its items.
678 */
679 /* Add process to process list (if not present) */
680 guint pl_height = 0;
681 HashedResourceData *hashed_process_data = NULL;
67f72973 682 ProcessList *process_list = resourceview_data->process_list;
683
598026ba 684 LttTime birth = process->creation_time;
685
686 if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
687 hashed_process_data = process_list->current_hash_data[trace_num][cpu];
688 } else {
67f72973 689 hashed_process_data = resourcelist_obtain_cpu(resourceview_data, trace_num, cpu);
690
598026ba 691 /* Set the current process */
692 process_list->current_hash_data[trace_num][process->cpu] =
693 hashed_process_data;
694 }
695
696 /* Now, the process is in the state hash and our own process hash.
697 * We definitely can draw the items related to the ending state.
698 */
699
700 if(likely(ltt_time_compare(hashed_process_data->next_good_time,
701 evtime) > 0))
702 {
703 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
704 TimeWindow time_window =
67f72973 705 lttvwindow_get_time_window(resourceview_data->tab);
598026ba 706
707#ifdef EXTRA_CHECK
708 if(ltt_time_compare(evtime, time_window.start_time) == -1
709 || ltt_time_compare(evtime, time_window.end_time) == 1)
710 return;
711#endif //EXTRA_CHECK
67f72973 712 Drawing_t *drawing = resourceview_data->drawing;
598026ba 713 guint width = drawing->width;
714 guint x;
715 convert_time_to_pixels(
716 time_window,
717 evtime,
718 width,
719 &x);
720
721 /* Draw collision indicator */
722 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
723 gdk_draw_point(hashed_process_data->pixmap,
724 drawing->gc,
725 x,
726 COLLISION_POSITION(hashed_process_data->height));
727 hashed_process_data->x.middle_marked = TRUE;
728 }
d3d99fde 729 }
730 else {
598026ba 731 TimeWindow time_window =
67f72973 732 lttvwindow_get_time_window(resourceview_data->tab);
598026ba 733
734#ifdef EXTRA_CHECK
735 if(ltt_time_compare(evtime, time_window.start_time) == -1
736 || ltt_time_compare(evtime, time_window.end_time) == 1)
737 return;
738#endif //EXTRA_CHECK
67f72973 739 Drawing_t *drawing = resourceview_data->drawing;
598026ba 740 guint width = drawing->width;
741 guint x;
742
743 convert_time_to_pixels(
744 time_window,
745 evtime,
746 width,
747 &x);
748
749
750 /* Jump over draw if we are at the same x position */
751 if(unlikely(x == hashed_process_data->x.middle &&
752 hashed_process_data->x.middle_used))
753 {
754 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
755 /* Draw collision indicator */
756 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
757 gdk_draw_point(hashed_process_data->pixmap,
758 drawing->gc,
759 x,
760 COLLISION_POSITION(hashed_process_data->height));
761 hashed_process_data->x.middle_marked = TRUE;
762 }
763 /* jump */
d3d99fde 764 }
765 else {
598026ba 766
767 DrawContext draw_context;
768 /* Now create the drawing context that will be used to draw
769 * items related to the last state. */
770 draw_context.drawable = hashed_process_data->pixmap;
771 draw_context.gc = drawing->gc;
772 draw_context.pango_layout = drawing->pango_layout;
773 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
774 draw_context.drawinfo.end.x = x;
775
776 draw_context.drawinfo.y.over = 1;
777 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
778 draw_context.drawinfo.y.under = hashed_process_data->height;
779
780 draw_context.drawinfo.start.offset.over = 0;
781 draw_context.drawinfo.start.offset.middle = 0;
782 draw_context.drawinfo.start.offset.under = 0;
783 draw_context.drawinfo.end.offset.over = 0;
784 draw_context.drawinfo.end.offset.middle = 0;
785 draw_context.drawinfo.end.offset.under = 0;
786
787 {
788 /* Draw the line */
789 PropertiesLine prop_line;
d3d99fde 790 prop_line.line_width = STATE_LINE_WIDTH;
791 prop_line.style = GDK_LINE_SOLID;
792 prop_line.y = MIDDLE;
793 cpu_set_line_color(&prop_line, tfs->cpu_state);
598026ba 794 draw_line((void*)&prop_line, (void*)&draw_context);
795 }
796 /* become the last x position */
797 hashed_process_data->x.middle = x;
798 hashed_process_data->x.middle_used = TRUE;
799 hashed_process_data->x.middle_marked = FALSE;
800
801 /* Calculate the next good time */
802 convert_pixels_to_time(width, x+1, time_window,
803 &hashed_process_data->next_good_time);
804 }
805 }
806
807 return 0;
808}
9e01e6d4 809
8743690d 810int before_execmode_hook_irq(void *hook_data, void *call_data)
811{
dd455fb8 812 LttvTraceHook *th = (LttvTraceHook*)hook_data;
813 EventsRequest *events_request = (EventsRequest*)th->hook_data;
67f72973 814 ControlFlowData *resourceview_data = events_request->viewer_data;
8743690d 815
816 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
817
818 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
819 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
750eb11a 820 struct marker_info *minfo;
8743690d 821
822 LttEvent *e;
823 e = ltt_tracefile_get_event(tfc->tf);
824
825 LttTime evtime = ltt_event_time(e);
826
ca5c76ed 827 LttTrace *trace = tfc->t_context->t;
828
8743690d 829 /* we are in a execmode, before the state update. We must draw the
830 * items corresponding to the state before it changes : now is the right
831 * time to do it.
832 */
833 /* For the pid */
834
835 guint64 irq;
836 guint cpu = tfs->cpu;
837
750eb11a 838 /*
839 * Check for LTT_CHANNEL_KERNEL channel name and event ID
840 * corresponding to LTT_EVENT_IRQ_ENTRY or LTT_EVENT_IRQ_EXIT.
841 */
842 if (tfc->tf->name != LTT_CHANNEL_KERNEL)
843 return 0;
844 minfo = marker_get_info_from_id(tfc->tf->mdata, e->event_id);
845 g_assert(minfo != NULL);
846 if (minfo->name == LTT_EVENT_IRQ_ENTRY) {
ca5c76ed 847 irq = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
750eb11a 848 } else if (minfo->name == LTT_EVENT_IRQ_EXIT) {
8743690d 849 irq = ts->cpu_states[cpu].last_irq;
750eb11a 850 } else
8743690d 851 return 0;
8743690d 852
8743690d 853 guint trace_num = ts->parent.index;
854
8743690d 855 /* Well, the process_out existed : we must get it in the process hash
856 * or add it, and draw its items.
857 */
858 /* Add process to process list (if not present) */
859 guint pl_height = 0;
860 HashedResourceData *hashed_process_data = NULL;
67f72973 861 ProcessList *process_list = resourceview_data->process_list;
862
863 hashed_process_data = resourcelist_obtain_irq(resourceview_data, trace_num, irq);
671c625b 864 // TODO: fix this, it's ugly and slow:
865 GQuark name;
866 {
867 gchar *str;
43ed82b5 868 str = g_strdup_printf("IRQ %" PRIu64 " [%s]", irq, (char*)g_quark_to_string(ts->irq_names[irq]));
671c625b 869 name = g_quark_from_string(str);
870 g_free(str);
871 }
872 gtk_tree_store_set(resourceview_data->process_list->list_store, &hashed_process_data->y_iter, NAME_COLUMN, g_quark_to_string(name), -1);
8743690d 873
874 /* Now, the process is in the state hash and our own process hash.
875 * We definitely can draw the items related to the ending state.
876 */
877
878 if(likely(ltt_time_compare(hashed_process_data->next_good_time,
879 evtime) > 0))
880 {
881 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
882 TimeWindow time_window =
67f72973 883 lttvwindow_get_time_window(resourceview_data->tab);
8743690d 884
885#ifdef EXTRA_CHECK
886 if(ltt_time_compare(evtime, time_window.start_time) == -1
887 || ltt_time_compare(evtime, time_window.end_time) == 1)
888 return;
889#endif //EXTRA_CHECK
67f72973 890 Drawing_t *drawing = resourceview_data->drawing;
8743690d 891 guint width = drawing->width;
892 guint x;
893 convert_time_to_pixels(
894 time_window,
895 evtime,
896 width,
897 &x);
898
899 /* Draw collision indicator */
900 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
901 gdk_draw_point(hashed_process_data->pixmap,
902 drawing->gc,
903 x,
904 COLLISION_POSITION(hashed_process_data->height));
905 hashed_process_data->x.middle_marked = TRUE;
906 }
907 }
908 else {
909 TimeWindow time_window =
67f72973 910 lttvwindow_get_time_window(resourceview_data->tab);
8743690d 911
912#ifdef EXTRA_CHECK
913 if(ltt_time_compare(evtime, time_window.start_time) == -1
914 || ltt_time_compare(evtime, time_window.end_time) == 1)
915 return;
916#endif //EXTRA_CHECK
67f72973 917 Drawing_t *drawing = resourceview_data->drawing;
8743690d 918 guint width = drawing->width;
919 guint x;
920
921 convert_time_to_pixels(
922 time_window,
923 evtime,
924 width,
925 &x);
926
927
928 /* Jump over draw if we are at the same x position */
929 if(unlikely(x == hashed_process_data->x.middle &&
930 hashed_process_data->x.middle_used))
931 {
932 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
933 /* Draw collision indicator */
934 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
935 gdk_draw_point(hashed_process_data->pixmap,
936 drawing->gc,
937 x,
938 COLLISION_POSITION(hashed_process_data->height));
939 hashed_process_data->x.middle_marked = TRUE;
940 }
941 /* jump */
942 }
943 else {
944
945 DrawContext draw_context;
946 /* Now create the drawing context that will be used to draw
947 * items related to the last state. */
948 draw_context.drawable = hashed_process_data->pixmap;
949 draw_context.gc = drawing->gc;
950 draw_context.pango_layout = drawing->pango_layout;
951 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
952 draw_context.drawinfo.end.x = x;
953
954 draw_context.drawinfo.y.over = 1;
955 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
956 draw_context.drawinfo.y.under = hashed_process_data->height;
957
958 draw_context.drawinfo.start.offset.over = 0;
959 draw_context.drawinfo.start.offset.middle = 0;
960 draw_context.drawinfo.start.offset.under = 0;
961 draw_context.drawinfo.end.offset.over = 0;
962 draw_context.drawinfo.end.offset.middle = 0;
963 draw_context.drawinfo.end.offset.under = 0;
964
965 {
966 /* Draw the line */
967 PropertiesLine prop_line;
968 prop_line.line_width = STATE_LINE_WIDTH;
969 prop_line.style = GDK_LINE_SOLID;
970 prop_line.y = MIDDLE;
971 irq_set_line_color(&prop_line, &ts->irq_states[irq]);
972 draw_line((void*)&prop_line, (void*)&draw_context);
973 }
974 /* become the last x position */
975 hashed_process_data->x.middle = x;
976 hashed_process_data->x.middle_used = TRUE;
977 hashed_process_data->x.middle_marked = FALSE;
978
979 /* Calculate the next good time */
980 convert_pixels_to_time(width, x+1, time_window,
981 &hashed_process_data->next_good_time);
982 }
983 }
984
985 return 0;
986}
987
0305fe77 988int before_execmode_hook_soft_irq(void *hook_data, void *call_data)
989{
990 LttvTraceHook *th = (LttvTraceHook*)hook_data;
991 EventsRequest *events_request = (EventsRequest*)th->hook_data;
992 ControlFlowData *resourceview_data = events_request->viewer_data;
993
994 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
995
996 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
997 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
750eb11a 998 struct marker_info *minfo;
0305fe77 999
1000 LttEvent *e;
1001 e = ltt_tracefile_get_event(tfc->tf);
1002
1003 LttTime evtime = ltt_event_time(e);
1004
1005 LttTrace *trace = tfc->t_context->t;
1006
1007 /* we are in a execmode, before the state update. We must draw the
1008 * items corresponding to the state before it changes : now is the right
1009 * time to do it.
1010 */
1011 /* For the pid */
1012
1013 guint64 softirq;
1014 guint cpu = tfs->cpu;
1015
750eb11a 1016 /*
1017 * Check for LTT_CHANNEL_KERNEL channel name and event ID
1018 * corresponding to LTT_EVENT_SOFT_IRQ_RAISE, LTT_EVENT_SOFT_IRQ_ENTRY
1019 * or LTT_EVENT_SOFT_IRQ_EXIT.
1020 */
1021 if (tfc->tf->name != LTT_CHANNEL_KERNEL)
1022 return 0;
1023 minfo = marker_get_info_from_id(tfc->tf->mdata, e->event_id);
1024 g_assert(minfo != NULL);
1025 if (minfo->name == LTT_EVENT_SOFT_IRQ_RAISE
1026 || minfo->name == LTT_EVENT_SOFT_IRQ_ENTRY) {
0305fe77 1027 softirq = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
750eb11a 1028 } else if (minfo->name == LTT_EVENT_SOFT_IRQ_EXIT) {
0305fe77 1029 softirq = ts->cpu_states[cpu].last_soft_irq;
750eb11a 1030 } else
0305fe77 1031 return 0;
0305fe77 1032
1033 guint trace_num = ts->parent.index;
1034
1035 /* Well, the process_out existed : we must get it in the process hash
1036 * or add it, and draw its items.
1037 */
1038 /* Add process to process list (if not present) */
1039 guint pl_height = 0;
1040 HashedResourceData *hashed_process_data = NULL;
1041 ProcessList *process_list = resourceview_data->process_list;
1042
1043 hashed_process_data = resourcelist_obtain_soft_irq(resourceview_data, trace_num, softirq);
1044
1045 /* Now, the process is in the state hash and our own process hash.
1046 * We definitely can draw the items related to the ending state.
1047 */
1048
1049 if(likely(ltt_time_compare(hashed_process_data->next_good_time,
1050 evtime) > 0))
1051 {
1052 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1053 TimeWindow time_window =
1054 lttvwindow_get_time_window(resourceview_data->tab);
1055
1056#ifdef EXTRA_CHECK
1057 if(ltt_time_compare(evtime, time_window.start_time) == -1
1058 || ltt_time_compare(evtime, time_window.end_time) == 1)
1059 return;
1060#endif //EXTRA_CHECK
1061 Drawing_t *drawing = resourceview_data->drawing;
1062 guint width = drawing->width;
1063 guint x;
1064 convert_time_to_pixels(
1065 time_window,
1066 evtime,
1067 width,
1068 &x);
1069
1070 /* Draw collision indicator */
1071 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1072 gdk_draw_point(hashed_process_data->pixmap,
1073 drawing->gc,
1074 x,
1075 COLLISION_POSITION(hashed_process_data->height));
1076 hashed_process_data->x.middle_marked = TRUE;
1077 }
1078 }
1079 else {
1080 TimeWindow time_window =
1081 lttvwindow_get_time_window(resourceview_data->tab);
1082
1083#ifdef EXTRA_CHECK
1084 if(ltt_time_compare(evtime, time_window.start_time) == -1
1085 || ltt_time_compare(evtime, time_window.end_time) == 1)
1086 return;
1087#endif //EXTRA_CHECK
1088 Drawing_t *drawing = resourceview_data->drawing;
1089 guint width = drawing->width;
1090 guint x;
1091
1092 convert_time_to_pixels(
1093 time_window,
1094 evtime,
1095 width,
1096 &x);
1097
1098
1099 /* Jump over draw if we are at the same x position */
1100 if(unlikely(x == hashed_process_data->x.middle &&
1101 hashed_process_data->x.middle_used))
1102 {
1103 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1104 /* Draw collision indicator */
1105 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1106 gdk_draw_point(hashed_process_data->pixmap,
1107 drawing->gc,
1108 x,
1109 COLLISION_POSITION(hashed_process_data->height));
1110 hashed_process_data->x.middle_marked = TRUE;
1111 }
1112 /* jump */
1113 }
1114 else {
1115
1116 DrawContext draw_context;
1117 /* Now create the drawing context that will be used to draw
1118 * items related to the last state. */
1119 draw_context.drawable = hashed_process_data->pixmap;
1120 draw_context.gc = drawing->gc;
1121 draw_context.pango_layout = drawing->pango_layout;
1122 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
1123 draw_context.drawinfo.end.x = x;
1124
1125 draw_context.drawinfo.y.over = 1;
1126 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
1127 draw_context.drawinfo.y.under = hashed_process_data->height;
1128
1129 draw_context.drawinfo.start.offset.over = 0;
1130 draw_context.drawinfo.start.offset.middle = 0;
1131 draw_context.drawinfo.start.offset.under = 0;
1132 draw_context.drawinfo.end.offset.over = 0;
1133 draw_context.drawinfo.end.offset.middle = 0;
1134 draw_context.drawinfo.end.offset.under = 0;
1135
1136 {
1137 /* Draw the line */
1138 PropertiesLine prop_line;
1139 prop_line.line_width = STATE_LINE_WIDTH;
1140 prop_line.style = GDK_LINE_SOLID;
1141 prop_line.y = MIDDLE;
1142 soft_irq_set_line_color(&prop_line, &ts->soft_irq_states[softirq]);
1143 draw_line((void*)&prop_line, (void*)&draw_context);
1144 }
1145 /* become the last x position */
1146 hashed_process_data->x.middle = x;
1147 hashed_process_data->x.middle_used = TRUE;
1148 hashed_process_data->x.middle_marked = FALSE;
1149
1150 /* Calculate the next good time */
1151 convert_pixels_to_time(width, x+1, time_window,
1152 &hashed_process_data->next_good_time);
1153 }
1154 }
1155
1156 return 0;
1157}
1158
38726a78 1159int before_execmode_hook_trap(void *hook_data, void *call_data)
1160{
1161 LttvTraceHook *th = (LttvTraceHook*)hook_data;
1162 EventsRequest *events_request = (EventsRequest*)th->hook_data;
1163 ControlFlowData *resourceview_data = events_request->viewer_data;
1164
1165 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1166
1167 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1168 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
750eb11a 1169 struct marker_info *minfo;
38726a78 1170
1171 LttEvent *e;
1172 e = ltt_tracefile_get_event(tfc->tf);
1173
1174 LttTime evtime = ltt_event_time(e);
1175
1176 LttTrace *trace = tfc->t_context->t;
1177
1178 /* we are in a execmode, before the state update. We must draw the
1179 * items corresponding to the state before it changes : now is the right
1180 * time to do it.
1181 */
1182 /* For the pid */
1183
1184 guint64 trap;
1185 guint cpu = tfs->cpu;
1186
750eb11a 1187 /*
1188 * Check for LTT_CHANNEL_KERNEL channel name and event ID
1189 * corresponding to LTT_EVENT_TRAP_ENTRY or LTT_EVENT_TRAP_EXIT.
1190 */
1191 if (tfc->tf->name != LTT_CHANNEL_KERNEL)
1192 return 0;
1193 minfo = marker_get_info_from_id(tfc->tf->mdata, e->event_id);
1194 g_assert(minfo != NULL);
1195 if (minfo->name == LTT_EVENT_TRAP_ENTRY) {
38726a78 1196 trap = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
750eb11a 1197 } else if (minfo->name == LTT_EVENT_TRAP_EXIT) {
38726a78 1198 trap = ts->cpu_states[cpu].last_trap;
750eb11a 1199 } else
38726a78 1200 return 0;
38726a78 1201
1202 guint trace_num = ts->parent.index;
1203
1204 /* Well, the process_out existed : we must get it in the process hash
1205 * or add it, and draw its items.
1206 */
1207 /* Add process to process list (if not present) */
1208 guint pl_height = 0;
1209 HashedResourceData *hashed_process_data = NULL;
1210 ProcessList *process_list = resourceview_data->process_list;
1211
1212 hashed_process_data = resourcelist_obtain_trap(resourceview_data, trace_num, trap);
1213
1214 /* Now, the process is in the state hash and our own process hash.
1215 * We definitely can draw the items related to the ending state.
1216 */
1217
1218 if(likely(ltt_time_compare(hashed_process_data->next_good_time,
1219 evtime) > 0))
1220 {
1221 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1222 TimeWindow time_window =
1223 lttvwindow_get_time_window(resourceview_data->tab);
1224
1225#ifdef EXTRA_CHECK
1226 if(ltt_time_compare(evtime, time_window.start_time) == -1
1227 || ltt_time_compare(evtime, time_window.end_time) == 1)
1228 return;
1229#endif //EXTRA_CHECK
1230 Drawing_t *drawing = resourceview_data->drawing;
1231 guint width = drawing->width;
1232 guint x;
1233 convert_time_to_pixels(
1234 time_window,
1235 evtime,
1236 width,
1237 &x);
1238
1239 /* Draw collision indicator */
1240 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1241 gdk_draw_point(hashed_process_data->pixmap,
1242 drawing->gc,
1243 x,
1244 COLLISION_POSITION(hashed_process_data->height));
1245 hashed_process_data->x.middle_marked = TRUE;
1246 }
1247 }
1248 else {
1249 TimeWindow time_window =
1250 lttvwindow_get_time_window(resourceview_data->tab);
1251
1252#ifdef EXTRA_CHECK
1253 if(ltt_time_compare(evtime, time_window.start_time) == -1
1254 || ltt_time_compare(evtime, time_window.end_time) == 1)
1255 return;
1256#endif //EXTRA_CHECK
1257 Drawing_t *drawing = resourceview_data->drawing;
1258 guint width = drawing->width;
1259 guint x;
1260
1261 convert_time_to_pixels(
1262 time_window,
1263 evtime,
1264 width,
1265 &x);
1266
1267
1268 /* Jump over draw if we are at the same x position */
1269 if(unlikely(x == hashed_process_data->x.middle &&
1270 hashed_process_data->x.middle_used))
1271 {
1272 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1273 /* Draw collision indicator */
1274 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1275 gdk_draw_point(hashed_process_data->pixmap,
1276 drawing->gc,
1277 x,
1278 COLLISION_POSITION(hashed_process_data->height));
1279 hashed_process_data->x.middle_marked = TRUE;
1280 }
1281 /* jump */
1282 }
1283 else {
1284
1285 DrawContext draw_context;
1286 /* Now create the drawing context that will be used to draw
1287 * items related to the last state. */
1288 draw_context.drawable = hashed_process_data->pixmap;
1289 draw_context.gc = drawing->gc;
1290 draw_context.pango_layout = drawing->pango_layout;
1291 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
1292 draw_context.drawinfo.end.x = x;
1293
1294 draw_context.drawinfo.y.over = 1;
1295 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
1296 draw_context.drawinfo.y.under = hashed_process_data->height;
1297
1298 draw_context.drawinfo.start.offset.over = 0;
1299 draw_context.drawinfo.start.offset.middle = 0;
1300 draw_context.drawinfo.start.offset.under = 0;
1301 draw_context.drawinfo.end.offset.over = 0;
1302 draw_context.drawinfo.end.offset.middle = 0;
1303 draw_context.drawinfo.end.offset.under = 0;
1304
1305 {
1306 /* Draw the line */
1307 PropertiesLine prop_line;
1308 prop_line.line_width = STATE_LINE_WIDTH;
1309 prop_line.style = GDK_LINE_SOLID;
1310 prop_line.y = MIDDLE;
1311 trap_set_line_color(&prop_line, &ts->trap_states[trap]);
1312 draw_line((void*)&prop_line, (void*)&draw_context);
1313 }
1314 /* become the last x position */
1315 hashed_process_data->x.middle = x;
1316 hashed_process_data->x.middle_used = TRUE;
1317 hashed_process_data->x.middle_marked = FALSE;
1318
1319 /* Calculate the next good time */
1320 convert_pixels_to_time(width, x+1, time_window,
1321 &hashed_process_data->next_good_time);
1322 }
1323 }
1324
1325 return 0;
1326}
1327
0305fe77 1328
20d16f82 1329int before_bdev_event_hook(void *hook_data, void *call_data)
1330{
dd455fb8 1331 LttvTraceHook *th = (LttvTraceHook*)hook_data;
1332 EventsRequest *events_request = (EventsRequest*)th->hook_data;
67f72973 1333 ControlFlowData *resourceview_data = events_request->viewer_data;
20d16f82 1334
1335 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1336
1337 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1338 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1339
1340 LttEvent *e;
1341 e = ltt_tracefile_get_event(tfc->tf);
1342
1343 LttTime evtime = ltt_event_time(e);
1344
20d16f82 1345 /* we are in a execmode, before the state update. We must draw the
1346 * items corresponding to the state before it changes : now is the right
1347 * time to do it.
1348 */
1349 /* For the pid */
1350
1351 guint cpu = tfs->cpu;
ca5c76ed 1352 guint8 major = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
1353 guint8 minor = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1));
1354 guint oper = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 2));
20d16f82 1355 gint devcode_gint = MKDEV(major,minor);
1356
20d16f82 1357 guint trace_num = ts->parent.index;
1358
1359 LttvBdevState *bdev = g_hash_table_lookup(ts->bdev_states, &devcode_gint);
23e59a12 1360 /* the result of the lookup might be NULL. that's ok, the rest of the function
1361 should understand it was not found and that its state is unknown */
20d16f82 1362
20d16f82 1363 /* Well, the process_out existed : we must get it in the process hash
1364 * or add it, and draw its items.
1365 */
1366 /* Add process to process list (if not present) */
1367 guint pl_height = 0;
1368 HashedResourceData *hashed_process_data = NULL;
67f72973 1369 ProcessList *process_list = resourceview_data->process_list;
20d16f82 1370// LttTime birth = process->creation_time;
1371
1372// if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
1373// hashed_process_data = process_list->current_hash_data[trace_num][cpu];
1374// } else {
67f72973 1375 hashed_process_data = resourcelist_obtain_bdev(resourceview_data, trace_num, devcode_gint);
1376 ////hashed_process_data = processlist_get_process_data(process_list, resourceq, trace_num);
20d16f82 1377// hashed_process_data = processlist_get_process_data(process_list,
1378// pid,
1379// process->cpu,
1380// &birth,
1381// trace_num);
67f72973 1382//
20d16f82 1383 /* Set the current process */
1384// process_list->current_hash_data[trace_num][process->cpu] =
1385// hashed_process_data;
1386// }
1387
1388 /* Now, the process is in the state hash and our own process hash.
1389 * We definitely can draw the items related to the ending state.
1390 */
1391
1392 if(likely(ltt_time_compare(hashed_process_data->next_good_time,
1393 evtime) > 0))
1394 {
1395 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1396 TimeWindow time_window =
67f72973 1397 lttvwindow_get_time_window(resourceview_data->tab);
20d16f82 1398
1399#ifdef EXTRA_CHECK
1400 if(ltt_time_compare(evtime, time_window.start_time) == -1
1401 || ltt_time_compare(evtime, time_window.end_time) == 1)
1402 return;
1403#endif //EXTRA_CHECK
67f72973 1404 Drawing_t *drawing = resourceview_data->drawing;
20d16f82 1405 guint width = drawing->width;
1406 guint x;
1407 convert_time_to_pixels(
1408 time_window,
1409 evtime,
1410 width,
1411 &x);
1412
1413 /* Draw collision indicator */
1414 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1415 gdk_draw_point(hashed_process_data->pixmap,
1416 drawing->gc,
1417 x,
1418 COLLISION_POSITION(hashed_process_data->height));
1419 hashed_process_data->x.middle_marked = TRUE;
1420 }
1421 }
1422 else {
1423 TimeWindow time_window =
67f72973 1424 lttvwindow_get_time_window(resourceview_data->tab);
20d16f82 1425
1426#ifdef EXTRA_CHECK
1427 if(ltt_time_compare(evtime, time_window.start_time) == -1
1428 || ltt_time_compare(evtime, time_window.end_time) == 1)
1429 return;
1430#endif //EXTRA_CHECK
67f72973 1431 Drawing_t *drawing = resourceview_data->drawing;
20d16f82 1432 guint width = drawing->width;
1433 guint x;
1434
1435 convert_time_to_pixels(
1436 time_window,
1437 evtime,
1438 width,
1439 &x);
1440
1441
1442 /* Jump over draw if we are at the same x position */
1443 if(unlikely(x == hashed_process_data->x.middle &&
1444 hashed_process_data->x.middle_used))
1445 {
1446 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1447 /* Draw collision indicator */
1448 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1449 gdk_draw_point(hashed_process_data->pixmap,
1450 drawing->gc,
1451 x,
1452 COLLISION_POSITION(hashed_process_data->height));
1453 hashed_process_data->x.middle_marked = TRUE;
1454 }
1455 /* jump */
1456 }
1457 else {
1458
1459 DrawContext draw_context;
1460 /* Now create the drawing context that will be used to draw
1461 * items related to the last state. */
1462 draw_context.drawable = hashed_process_data->pixmap;
1463 draw_context.gc = drawing->gc;
1464 draw_context.pango_layout = drawing->pango_layout;
1465 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
1466 draw_context.drawinfo.end.x = x;
1467
1468 draw_context.drawinfo.y.over = 1;
1469 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
1470 draw_context.drawinfo.y.under = hashed_process_data->height;
1471
1472 draw_context.drawinfo.start.offset.over = 0;
1473 draw_context.drawinfo.start.offset.middle = 0;
1474 draw_context.drawinfo.start.offset.under = 0;
1475 draw_context.drawinfo.end.offset.over = 0;
1476 draw_context.drawinfo.end.offset.middle = 0;
1477 draw_context.drawinfo.end.offset.under = 0;
1478
1479 {
1480 /* Draw the line */
1481 PropertiesLine prop_line;
1482 prop_line.line_width = STATE_LINE_WIDTH;
1483 prop_line.style = GDK_LINE_SOLID;
1484 prop_line.y = MIDDLE;
1485 bdev_set_line_color(&prop_line, bdev);
1486 draw_line((void*)&prop_line, (void*)&draw_context);
1487 }
1488 /* become the last x position */
1489 hashed_process_data->x.middle = x;
1490 hashed_process_data->x.middle_used = TRUE;
1491 hashed_process_data->x.middle_marked = FALSE;
1492
1493 /* Calculate the next good time */
1494 convert_pixels_to_time(width, x+1, time_window,
1495 &hashed_process_data->next_good_time);
1496 }
1497 }
1498
1499 return 0;
1500}
1501
9e01e6d4 1502gint update_time_window_hook(void *hook_data, void *call_data)
1503{
67f72973 1504 ControlFlowData *resourceview_data = (ControlFlowData*) hook_data;
1505 Drawing_t *drawing = resourceview_data->drawing;
1506 ProcessList *process_list = resourceview_data->process_list;
9e01e6d4 1507
1508 const TimeWindowNotifyData *time_window_nofify_data =
1509 ((const TimeWindowNotifyData *)call_data);
1510
1511 TimeWindow *old_time_window =
1512 time_window_nofify_data->old_time_window;
1513 TimeWindow *new_time_window =
1514 time_window_nofify_data->new_time_window;
1515
1516 /* Update the ruler */
67f72973 1517 drawing_update_ruler(resourceview_data->drawing,
9e01e6d4 1518 new_time_window);
1519
1520
1521 /* Two cases : zoom in/out or scrolling */
1522
1523 /* In order to make sure we can reuse the old drawing, the scale must
1524 * be the same and the new time interval being partly located in the
1525 * currently shown time interval. (reuse is only for scrolling)
1526 */
1527
1528 g_info("Old time window HOOK : %lu, %lu to %lu, %lu",
1529 old_time_window->start_time.tv_sec,
1530 old_time_window->start_time.tv_nsec,
1531 old_time_window->time_width.tv_sec,
1532 old_time_window->time_width.tv_nsec);
1533
1534 g_info("New time window HOOK : %lu, %lu to %lu, %lu",
1535 new_time_window->start_time.tv_sec,
1536 new_time_window->start_time.tv_nsec,
1537 new_time_window->time_width.tv_sec,
1538 new_time_window->time_width.tv_nsec);
1539
1540 if( new_time_window->time_width.tv_sec == old_time_window->time_width.tv_sec
1541 && new_time_window->time_width.tv_nsec == old_time_window->time_width.tv_nsec)
1542 {
1543 /* Same scale (scrolling) */
1544 g_info("scrolling");
1545 LttTime *ns = &new_time_window->start_time;
1546 LttTime *nw = &new_time_window->time_width;
1547 LttTime *os = &old_time_window->start_time;
1548 LttTime *ow = &old_time_window->time_width;
1549 LttTime old_end = old_time_window->end_time;
1550 LttTime new_end = new_time_window->end_time;
1551 //if(ns<os+w<ns+w)
1552 //if(ns<os+w && os+w<ns+w)
1553 //if(ns<old_end && os<ns)
1554 if(ltt_time_compare(*ns, old_end) == -1
1555 && ltt_time_compare(*os, *ns) == -1)
1556 {
1557 g_info("scrolling near right");
1558 /* Scroll right, keep right part of the screen */
1559 guint x = 0;
67f72973 1560 guint width = resourceview_data->drawing->width;
9e01e6d4 1561 convert_time_to_pixels(
1562 *old_time_window,
1563 *ns,
1564 width,
1565 &x);
1566
1567 /* Copy old data to new location */
1568 copy_pixmap_region(process_list,
1569 NULL,
67f72973 1570 resourceview_data->drawing->drawing_area->style->black_gc,
9e01e6d4 1571 NULL,
1572 x, 0,
1573 0, 0,
67f72973 1574 resourceview_data->drawing->width-x+SAFETY, -1);
9e01e6d4 1575
1576 if(drawing->damage_begin == drawing->damage_end)
67f72973 1577 drawing->damage_begin = resourceview_data->drawing->width-x;
9e01e6d4 1578 else
1579 drawing->damage_begin = 0;
1580
67f72973 1581 drawing->damage_end = resourceview_data->drawing->width;
9e01e6d4 1582
1583 /* Clear the data request background, but not SAFETY */
1584 rectangle_pixmap(process_list,
67f72973 1585 resourceview_data->drawing->drawing_area->style->black_gc,
9e01e6d4 1586 TRUE,
1587 drawing->damage_begin+SAFETY, 0,
1588 drawing->damage_end - drawing->damage_begin, // do not overlap
1589 -1);
1590 gtk_widget_queue_draw(drawing->drawing_area);
9e01e6d4 1591
1592 /* Get new data for the rest. */
67f72973 1593 drawing_data_request(resourceview_data->drawing,
9e01e6d4 1594 drawing->damage_begin, 0,
1595 drawing->damage_end - drawing->damage_begin,
67f72973 1596 resourceview_data->drawing->height);
9e01e6d4 1597 } else {
9e01e6d4 1598 if(ltt_time_compare(*ns,*os) == -1
1599 && ltt_time_compare(*os,new_end) == -1)
1600 {
1601 g_info("scrolling near left");
1602 /* Scroll left, keep left part of the screen */
1603 guint x = 0;
67f72973 1604 guint width = resourceview_data->drawing->width;
9e01e6d4 1605 convert_time_to_pixels(
1606 *new_time_window,
1607 *os,
1608 width,
1609 &x);
1610
1611 /* Copy old data to new location */
1612 copy_pixmap_region (process_list,
1613 NULL,
67f72973 1614 resourceview_data->drawing->drawing_area->style->black_gc,
9e01e6d4 1615 NULL,
1616 0, 0,
1617 x, 0,
1618 -1, -1);
1619
1620 if(drawing->damage_begin == drawing->damage_end)
1621 drawing->damage_end = x;
1622 else
1623 drawing->damage_end =
67f72973 1624 resourceview_data->drawing->width;
9e01e6d4 1625
1626 drawing->damage_begin = 0;
1627
1628 rectangle_pixmap (process_list,
67f72973 1629 resourceview_data->drawing->drawing_area->style->black_gc,
9e01e6d4 1630 TRUE,
1631 drawing->damage_begin, 0,
1632 drawing->damage_end - drawing->damage_begin, // do not overlap
1633 -1);
1634
1635 gtk_widget_queue_draw(drawing->drawing_area);
9e01e6d4 1636
1637 /* Get new data for the rest. */
67f72973 1638 drawing_data_request(resourceview_data->drawing,
9e01e6d4 1639 drawing->damage_begin, 0,
1640 drawing->damage_end - drawing->damage_begin,
67f72973 1641 resourceview_data->drawing->height);
9e01e6d4 1642
1643 } else {
1644 if(ltt_time_compare(*ns,*os) == 0)
1645 {
1646 g_info("not scrolling");
1647 } else {
1648 g_info("scrolling far");
1649 /* Cannot reuse any part of the screen : far jump */
1650
1651
1652 rectangle_pixmap (process_list,
67f72973 1653 resourceview_data->drawing->drawing_area->style->black_gc,
9e01e6d4 1654 TRUE,
1655 0, 0,
67f72973 1656 resourceview_data->drawing->width+SAFETY, // do not overlap
9e01e6d4 1657 -1);
1658
9e01e6d4 1659 gtk_widget_queue_draw(drawing->drawing_area);
1660
1661 drawing->damage_begin = 0;
67f72973 1662 drawing->damage_end = resourceview_data->drawing->width;
9e01e6d4 1663
67f72973 1664 drawing_data_request(resourceview_data->drawing,
9e01e6d4 1665 0, 0,
67f72973 1666 resourceview_data->drawing->width,
1667 resourceview_data->drawing->height);
9e01e6d4 1668
1669 }
1670 }
1671 }
1672 } else {
1673 /* Different scale (zoom) */
1674 g_info("zoom");
1675
1676 rectangle_pixmap (process_list,
67f72973 1677 resourceview_data->drawing->drawing_area->style->black_gc,
9e01e6d4 1678 TRUE,
1679 0, 0,
67f72973 1680 resourceview_data->drawing->width+SAFETY, // do not overlap
9e01e6d4 1681 -1);
1682
9e01e6d4 1683 gtk_widget_queue_draw(drawing->drawing_area);
1684
1685 drawing->damage_begin = 0;
67f72973 1686 drawing->damage_end = resourceview_data->drawing->width;
9e01e6d4 1687
67f72973 1688 drawing_data_request(resourceview_data->drawing,
9e01e6d4 1689 0, 0,
67f72973 1690 resourceview_data->drawing->width,
1691 resourceview_data->drawing->height);
9e01e6d4 1692 }
1693
1694 /* Update directly when scrolling */
67f72973 1695 gdk_window_process_updates(resourceview_data->drawing->drawing_area->window,
9e01e6d4 1696 TRUE);
1697
1698 return 0;
1699}
1700
1701gint traceset_notify(void *hook_data, void *call_data)
1702{
67f72973 1703 ControlFlowData *resourceview_data = (ControlFlowData*) hook_data;
1704 Drawing_t *drawing = resourceview_data->drawing;
9e01e6d4 1705
1706 if(unlikely(drawing->gc == NULL)) {
1707 return FALSE;
1708 }
1709 if(drawing->dotted_gc == NULL) {
1710 return FALSE;
1711 }
1712
67f72973 1713 drawing_clear(resourceview_data->drawing);
1714 processlist_clear(resourceview_data->process_list);
9e01e6d4 1715 gtk_widget_set_size_request(
67f72973 1716 resourceview_data->drawing->drawing_area,
1717 -1, processlist_get_height(resourceview_data->process_list));
1718 redraw_notify(resourceview_data, NULL);
9e01e6d4 1719
67f72973 1720 request_background_data(resourceview_data);
9e01e6d4 1721
1722 return FALSE;
1723}
1724
1725gint redraw_notify(void *hook_data, void *call_data)
1726{
67f72973 1727 ControlFlowData *resourceview_data = (ControlFlowData*) hook_data;
1728 Drawing_t *drawing = resourceview_data->drawing;
9e01e6d4 1729 GtkWidget *widget = drawing->drawing_area;
1730
1731 drawing->damage_begin = 0;
1732 drawing->damage_end = drawing->width;
1733
1734 /* fun feature, to be separated someday... */
67f72973 1735 drawing_clear(resourceview_data->drawing);
1736 processlist_clear(resourceview_data->process_list);
9e01e6d4 1737 gtk_widget_set_size_request(
67f72973 1738 resourceview_data->drawing->drawing_area,
1739 -1, processlist_get_height(resourceview_data->process_list));
9e01e6d4 1740 // Clear the images
67f72973 1741 rectangle_pixmap (resourceview_data->process_list,
9e01e6d4 1742 widget->style->black_gc,
1743 TRUE,
1744 0, 0,
1745 drawing->alloc_width,
1746 -1);
1747
1748 gtk_widget_queue_draw(drawing->drawing_area);
1749
1750 if(drawing->damage_begin < drawing->damage_end)
1751 {
1752 drawing_data_request(drawing,
1753 drawing->damage_begin,
1754 0,
1755 drawing->damage_end-drawing->damage_begin,
1756 drawing->height);
1757 }
1758
9e01e6d4 1759 return FALSE;
1760
1761}
1762
1763
1764gint continue_notify(void *hook_data, void *call_data)
1765{
67f72973 1766 ControlFlowData *resourceview_data = (ControlFlowData*) hook_data;
1767 Drawing_t *drawing = resourceview_data->drawing;
9e01e6d4 1768
1769 if(drawing->damage_begin < drawing->damage_end)
1770 {
1771 drawing_data_request(drawing,
1772 drawing->damage_begin,
1773 0,
1774 drawing->damage_end-drawing->damage_begin,
1775 drawing->height);
1776 }
1777
1778 return FALSE;
1779}
1780
1781
1782gint update_current_time_hook(void *hook_data, void *call_data)
1783{
67f72973 1784 ControlFlowData *resourceview_data = (ControlFlowData*)hook_data;
1785 Drawing_t *drawing = resourceview_data->drawing;
9e01e6d4 1786
1787 LttTime current_time = *((LttTime*)call_data);
1788
1789 TimeWindow time_window =
67f72973 1790 lttvwindow_get_time_window(resourceview_data->tab);
9e01e6d4 1791
1792 LttTime time_begin = time_window.start_time;
1793 LttTime width = time_window.time_width;
1794 LttTime half_width;
1795 {
1796 guint64 time_ll = ltt_time_to_uint64(width);
1797 time_ll = time_ll >> 1; /* divide by two */
1798 half_width = ltt_time_from_uint64(time_ll);
1799 }
1800 LttTime time_end = ltt_time_add(time_begin, width);
1801
1802 LttvTracesetContext * tsc =
67f72973 1803 lttvwindow_get_traceset_context(resourceview_data->tab);
9e01e6d4 1804
1805 LttTime trace_start = tsc->time_span.start_time;
1806 LttTime trace_end = tsc->time_span.end_time;
1807
1808 g_info("New current time HOOK : %lu, %lu", current_time.tv_sec,
1809 current_time.tv_nsec);
9e01e6d4 1810
1811 /* If current time is inside time interval, just move the highlight
1812 * bar */
1813
1814 /* Else, we have to change the time interval. We have to tell it
1815 * to the main window. */
1816 /* The time interval change will take care of placing the current
1817 * time at the center of the visible area, or nearest possible if we are
1818 * at one end of the trace. */
1819
1820
1821 if(ltt_time_compare(current_time, time_begin) < 0)
1822 {
1823 TimeWindow new_time_window;
1824
1825 if(ltt_time_compare(current_time,
1826 ltt_time_add(trace_start,half_width)) < 0)
1827 time_begin = trace_start;
1828 else
1829 time_begin = ltt_time_sub(current_time,half_width);
1830
1831 new_time_window.start_time = time_begin;
1832 new_time_window.time_width = width;
1833 new_time_window.time_width_double = ltt_time_to_double(width);
1834 new_time_window.end_time = ltt_time_add(time_begin, width);
1835
67f72973 1836 lttvwindow_report_time_window(resourceview_data->tab, new_time_window);
9e01e6d4 1837 }
1838 else if(ltt_time_compare(current_time, time_end) > 0)
1839 {
1840 TimeWindow new_time_window;
1841
1842 if(ltt_time_compare(current_time, ltt_time_sub(trace_end, half_width)) > 0)
1843 time_begin = ltt_time_sub(trace_end,width);
1844 else
1845 time_begin = ltt_time_sub(current_time,half_width);
1846
1847 new_time_window.start_time = time_begin;
1848 new_time_window.time_width = width;
1849 new_time_window.time_width_double = ltt_time_to_double(width);
1850 new_time_window.end_time = ltt_time_add(time_begin, width);
1851
67f72973 1852 lttvwindow_report_time_window(resourceview_data->tab, new_time_window);
9e01e6d4 1853
1854 }
67f72973 1855 gtk_widget_queue_draw(resourceview_data->drawing->drawing_area);
9e01e6d4 1856
1857 /* Update directly when scrolling */
67f72973 1858 gdk_window_process_updates(resourceview_data->drawing->drawing_area->window,
9e01e6d4 1859 TRUE);
1860
1861 return 0;
1862}
1863
1864typedef struct _ClosureData {
1865 EventsRequest *events_request;
1866 LttvTracesetState *tss;
1867 LttTime end_time;
1868 guint x_end;
1869} ClosureData;
1870
58a9b31b 1871/* Draw line until end of the screen */
9e01e6d4 1872
1873void draw_closure(gpointer key, gpointer value, gpointer user_data)
1874{
67f72973 1875 ResourceUniqueNumeric *process_info = (ResourceUniqueNumeric*)key;
44ffb95f 1876 HashedResourceData *hashed_process_data = (HashedResourceData*)value;
1877 ClosureData *closure_data = (ClosureData*)user_data;
1878
1879 EventsRequest *events_request = closure_data->events_request;
67f72973 1880 ControlFlowData *resourceview_data = events_request->viewer_data;
44ffb95f 1881
1882 LttvTracesetState *tss = closure_data->tss;
1883 LttvTracesetContext *tsc = (LttvTracesetContext*)tss;
1884
1885 LttTime evtime = closure_data->end_time;
1886
1887 gboolean dodraw = TRUE;
1888
67f72973 1889 if(hashed_process_data->type == RV_RESOURCE_MACHINE)
1890 return;
1891
44ffb95f 1892 {
1893 /* For the process */
1894 /* First, check if the current process is in the state computation
1895 * process list. If it is there, that means we must add it right now and
1896 * draw items from the beginning of the read for it. If it is not
1897 * present, it's a new process and it was not present : it will
1898 * be added after the state update. */
1899#ifdef EXTRA_CHECK
1900 g_assert(lttv_traceset_number(tsc->ts) > 0);
1901#endif //EXTRA_CHECK
1902 LttvTraceContext *tc = tsc->traces[process_info->trace_num];
1903 LttvTraceState *ts = (LttvTraceState*)tc;
1904
67f72973 1905 /* Only draw for processes that are currently in the trace states */
44ffb95f 1906
67f72973 1907 ProcessList *process_list = resourceview_data->process_list;
44ffb95f 1908#ifdef EXTRA_CHECK
67f72973 1909 /* Should be alike when background info is ready */
1910 if(resourceview_data->background_info_waiting==0)
44ffb95f 1911 g_assert(ltt_time_compare(process->creation_time,
1912 process_info->birth) == 0);
1913#endif //EXTRA_CHECK
1914
67f72973 1915 /* Now, the process is in the state hash and our own process hash.
1916 * We definitely can draw the items related to the ending state.
1917 */
1918
1919 if(unlikely(ltt_time_compare(hashed_process_data->next_good_time,
1920 evtime) <= 0))
1921 {
1922 TimeWindow time_window =
1923 lttvwindow_get_time_window(resourceview_data->tab);
44ffb95f 1924
1925#ifdef EXTRA_CHECK
67f72973 1926 if(ltt_time_compare(evtime, time_window.start_time) == -1
1927 || ltt_time_compare(evtime, time_window.end_time) == 1)
1928 return;
44ffb95f 1929#endif //EXTRA_CHECK
67f72973 1930 Drawing_t *drawing = resourceview_data->drawing;
1931 guint width = drawing->width;
1932
1933 guint x = closure_data->x_end;
1934
1935 DrawContext draw_context;
1936
1937 /* Now create the drawing context that will be used to draw
1938 * items related to the last state. */
1939 draw_context.drawable = hashed_process_data->pixmap;
1940 draw_context.gc = drawing->gc;
1941 draw_context.pango_layout = drawing->pango_layout;
1942 draw_context.drawinfo.end.x = x;
1943
1944 draw_context.drawinfo.y.over = 1;
1945 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
1946 draw_context.drawinfo.y.under = hashed_process_data->height;
1947
1948 draw_context.drawinfo.start.offset.over = 0;
1949 draw_context.drawinfo.start.offset.middle = 0;
1950 draw_context.drawinfo.start.offset.under = 0;
1951 draw_context.drawinfo.end.offset.over = 0;
1952 draw_context.drawinfo.end.offset.middle = 0;
1953 draw_context.drawinfo.end.offset.under = 0;
44ffb95f 1954#if 0
67f72973 1955 /* Jump over draw if we are at the same x position */
1956 if(x == hashed_process_data->x.over)
1957 {
1958 /* jump */
1959 } else {
1960 draw_context.drawinfo.start.x = hashed_process_data->x.over;
1961 /* Draw the line */
1962 PropertiesLine prop_line = prepare_execmode_line(process);
1963 draw_line((void*)&prop_line, (void*)&draw_context);
44ffb95f 1964
67f72973 1965 hashed_process_data->x.over = x;
1966 }
44ffb95f 1967#endif //0
1968
67f72973 1969 if(unlikely(x == hashed_process_data->x.middle &&
1970 hashed_process_data->x.middle_used)) {
44ffb95f 1971#if 0 /* do not mark closure : not missing information */
67f72973 1972 if(hashed_process_data->x.middle_marked == FALSE) {
1973 /* Draw collision indicator */
1974 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1975 gdk_draw_point(drawing->pixmap,
1976 drawing->gc,
1977 x,
1978 y+(height/2)-3);
1979 hashed_process_data->x.middle_marked = TRUE;
1980 }
44ffb95f 1981#endif //0
67f72973 1982 /* Jump */
1983 } else {
1984 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
1985 /* Draw the line */
1986 if(dodraw) {
1987 PropertiesLine prop_line;
1988 prop_line.line_width = STATE_LINE_WIDTH;
1989 prop_line.style = GDK_LINE_SOLID;
1990 prop_line.y = MIDDLE;
1991 if(hashed_process_data->type == RV_RESOURCE_CPU)
1992 cpu_set_line_color(&prop_line, &ts->cpu_states[process_info->id]);
1993 else if(hashed_process_data->type == RV_RESOURCE_IRQ)
1994 irq_set_line_color(&prop_line, &ts->irq_states[process_info->id]);
0305fe77 1995 else if(hashed_process_data->type == RV_RESOURCE_SOFT_IRQ)
1996 soft_irq_set_line_color(&prop_line, &ts->soft_irq_states[process_info->id]);
38726a78 1997 else if(hashed_process_data->type == RV_RESOURCE_TRAP)
1998 trap_set_line_color(&prop_line, &ts->trap_states[process_info->id]);
67f72973 1999 else if(hashed_process_data->type == RV_RESOURCE_BDEV) {
2000 gint devcode_gint = process_info->id;
2001 LttvBdevState *bdev = g_hash_table_lookup(ts->bdev_states, &devcode_gint);
2002 // the lookup may return null; bdev_set_line_color must act appropriately
2003 bdev_set_line_color(&prop_line, bdev);
44ffb95f 2004 }
67f72973 2005
2006 draw_line((void*)&prop_line, (void*)&draw_context);
2007 }
44ffb95f 2008
67f72973 2009 /* become the last x position */
2010 if(likely(x != hashed_process_data->x.middle)) {
2011 hashed_process_data->x.middle = x;
2012 /* but don't use the pixel */
2013 hashed_process_data->x.middle_used = FALSE;
44ffb95f 2014
67f72973 2015 /* Calculate the next good time */
2016 convert_pixels_to_time(width, x+1, time_window,
2017 &hashed_process_data->next_good_time);
44ffb95f 2018 }
2019 }
67f72973 2020 }
44ffb95f 2021 }
9e01e6d4 2022}
2023
2024int before_chunk(void *hook_data, void *call_data)
2025{
2026 EventsRequest *events_request = (EventsRequest*)hook_data;
2027 LttvTracesetState *tss = (LttvTracesetState*)call_data;
2028 ControlFlowData *cfd = (ControlFlowData*)events_request->viewer_data;
2029#if 0
67f72973 2030 /* Deactivate sort */
9e01e6d4 2031 gtk_tree_sortable_set_sort_column_id(
2032 GTK_TREE_SORTABLE(cfd->process_list->list_store),
2033 TRACE_COLUMN,
2034 GTK_SORT_ASCENDING);
2035#endif //0
2036 drawing_chunk_begin(events_request, tss);
2037
2038 return 0;
2039}
2040
d389bc8d 2041/* before_request
2042 *
2043 * This gets executed just before an events request is executed
2044 */
2045
9e01e6d4 2046int before_request(void *hook_data, void *call_data)
2047{
2048 EventsRequest *events_request = (EventsRequest*)hook_data;
2049 LttvTracesetState *tss = (LttvTracesetState*)call_data;
2050
2051 drawing_data_request_begin(events_request, tss);
2052
2053 return 0;
2054}
2055
2056
2057/*
2058 * after request is necessary in addition of after chunk in order to draw
2059 * lines until the end of the screen. after chunk just draws lines until
2060 * the last event.
2061 *
2062 * for each process
2063 * draw closing line
2064 * expose
2065 */
2066int after_request(void *hook_data, void *call_data)
2067{
67f72973 2068 guint i;
2069 EventsRequest *events_request = (EventsRequest*)hook_data;
2070 ControlFlowData *resourceview_data = events_request->viewer_data;
2071 LttvTracesetState *tss = (LttvTracesetState*)call_data;
2072
2073 ProcessList *process_list = resourceview_data->process_list;
2074 LttTime end_time = events_request->end_time;
2075
2076 ClosureData closure_data;
2077 closure_data.events_request = (EventsRequest*)hook_data;
2078 closure_data.tss = tss;
2079 closure_data.end_time = end_time;
2080
2081 TimeWindow time_window =
2082 lttvwindow_get_time_window(resourceview_data->tab);
2083 guint width = resourceview_data->drawing->width;
2084 convert_time_to_pixels(
2085 time_window,
2086 end_time,
2087 width,
2088 &closure_data.x_end);
2089
2090
2091 /* Draw last items */
2092 for(i=0; i<RV_RESOURCE_COUNT; i++) {
2093 g_hash_table_foreach(resourcelist_get_resource_hash_table(resourceview_data, i), draw_closure,
2094 (void*)&closure_data);
2095 }
2096
2097 /* Request expose */
2098 drawing_request_expose(events_request, tss, end_time);
9e01e6d4 2099 return 0;
2100}
2101
2102/*
2103 * for each process
2104 * draw closing line
2105 * expose
2106 */
2107int after_chunk(void *hook_data, void *call_data)
2108{
2109 EventsRequest *events_request = (EventsRequest*)hook_data;
67f72973 2110 ControlFlowData *resourceview_data = events_request->viewer_data;
9e01e6d4 2111 LttvTracesetState *tss = (LttvTracesetState*)call_data;
2112 LttvTracesetContext *tsc = (LttvTracesetContext*)call_data;
2113 LttvTracefileContext *tfc = lttv_traceset_context_get_current_tfc(tsc);
2114 LttTime end_time;
2115
67f72973 2116 ProcessList *process_list = resourceview_data->process_list;
9e01e6d4 2117 guint i;
2118 LttvTraceset *traceset = tsc->ts;
2119 guint nb_trace = lttv_traceset_number(traceset);
2120
2121 /* Only execute when called for the first trace's events request */
43ed82b5 2122 if(!process_list->current_hash_data)
2123 return 0;
9e01e6d4 2124
2125 for(i = 0 ; i < nb_trace ; i++) {
2126 g_free(process_list->current_hash_data[i]);
2127 }
2128 g_free(process_list->current_hash_data);
2129 process_list->current_hash_data = NULL;
2130
2131 if(tfc != NULL)
2132 end_time = LTT_TIME_MIN(tfc->timestamp, events_request->end_time);
2133 else /* end of traceset, or position now out of request : end */
2134 end_time = events_request->end_time;
2135
2136 ClosureData closure_data;
2137 closure_data.events_request = (EventsRequest*)hook_data;
2138 closure_data.tss = tss;
2139 closure_data.end_time = end_time;
2140
2141 TimeWindow time_window =
67f72973 2142 lttvwindow_get_time_window(resourceview_data->tab);
2143 guint width = resourceview_data->drawing->width;
9e01e6d4 2144 convert_time_to_pixels(
2145 time_window,
2146 end_time,
2147 width,
2148 &closure_data.x_end);
2149
2150 /* Draw last items */
67f72973 2151 for(i=0; i<RV_RESOURCE_COUNT; i++) {
2152 g_hash_table_foreach(resourcelist_get_resource_hash_table(resourceview_data, i), draw_closure,
9e01e6d4 2153 (void*)&closure_data);
67f72973 2154 }
9e01e6d4 2155#if 0
2156 /* Reactivate sort */
2157 gtk_tree_sortable_set_sort_column_id(
67f72973 2158 GTK_TREE_SORTABLE(resourceview_data->process_list->list_store),
9e01e6d4 2159 GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
2160 GTK_SORT_ASCENDING);
2161
67f72973 2162 update_index_to_pixmap(resourceview_data->process_list);
9e01e6d4 2163 /* Request a full expose : drawing scrambled */
67f72973 2164 gtk_widget_queue_draw(resourceview_data->drawing->drawing_area);
9e01e6d4 2165#endif //0
2166 /* Request expose (updates damages zone also) */
2167 drawing_request_expose(events_request, tss, end_time);
2168
2169 return 0;
2170}
2171
2172/* after_statedump_end
2173 *
2174 * @param hook_data ControlFlowData structure of the viewer.
2175 * @param call_data Event context.
2176 *
2177 * This function adds items to be drawn in a queue for each process.
2178 *
2179 */
2180int before_statedump_end(void *hook_data, void *call_data)
2181{
67f72973 2182 gint i;
2183
dd455fb8 2184 LttvTraceHook *th = (LttvTraceHook*)hook_data;
2185 EventsRequest *events_request = (EventsRequest*)th->hook_data;
67f72973 2186 ControlFlowData *resourceview_data = events_request->viewer_data;
9e01e6d4 2187
2188 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
2189
2190 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
2191
2192 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
2193
2194 LttvTracesetState *tss = (LttvTracesetState*)tfc->t_context->ts_context;
67f72973 2195 ProcessList *process_list = resourceview_data->process_list;
9e01e6d4 2196
2197 LttEvent *e;
2198 e = ltt_tracefile_get_event(tfc->tf);
2199
67f72973 2200 LttvFilter *filter = resourceview_data->filter;
9e01e6d4 2201 if(filter != NULL && filter->head != NULL)
2202 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
2203 tfc->t_context->t,tfc,NULL,NULL))
2204 return FALSE;
2205
2206 LttTime evtime = ltt_event_time(e);
2207
2208 ClosureData closure_data;
2209 closure_data.events_request = events_request;
2210 closure_data.tss = tss;
2211 closure_data.end_time = evtime;
2212
2213 TimeWindow time_window =
67f72973 2214 lttvwindow_get_time_window(resourceview_data->tab);
2215 guint width = resourceview_data->drawing->width;
9e01e6d4 2216 convert_time_to_pixels(
2217 time_window,
2218 evtime,
2219 width,
2220 &closure_data.x_end);
2221
2222 /* Draw last items */
67f72973 2223
2224 for(i=0; i<RV_RESOURCE_COUNT; i++) {
2225 g_hash_table_foreach(resourcelist_get_resource_hash_table(resourceview_data, i), draw_closure,
9e01e6d4 2226 (void*)&closure_data);
67f72973 2227 }
9e01e6d4 2228#if 0
2229 /* Reactivate sort */
2230 gtk_tree_sortable_set_sort_column_id(
67f72973 2231 GTK_TREE_SORTABLE(resourceview_data->process_list->list_store),
9e01e6d4 2232 GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
2233 GTK_SORT_ASCENDING);
2234
67f72973 2235 update_index_to_pixmap(resourceview_data->process_list);
9e01e6d4 2236 /* Request a full expose : drawing scrambled */
67f72973 2237 gtk_widget_queue_draw(resourceview_data->drawing->drawing_area);
9e01e6d4 2238#endif //0
2239 /* Request expose (updates damages zone also) */
2240 drawing_request_expose(events_request, tss, evtime);
2241
2242 return 0;
2243}
LTTng 2.x Viewer (LTTV)
This page took 0.12951 seconds and 4 git commands to generate.