projects / lttv.git / blob
? search:


617f18cb0db8f42afc870b4755fbe9156202bf33
[lttv.git] /
1 /* This file is part of the Linux Trace Toolkit Graphic User Interface
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 /* This file is the API used to launch any background computation on a trace */
20
21 /* Here is the implementation of the API */
22
23 #ifdef HAVE_CONFIG_H
24 #include <config.h>
25 #endif
26
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <unistd.h>
30 #include <string.h>
31
32 #include <ltt/time.h>
33 #include <ltt/trace.h>
34 #include <glib.h>
35 #include <lttv/lttv.h>
36 #include <lttv/traceset.h>
37 #include <lttv/attribute.h>
38 #include <lttv/tracecontext.h>
39 #include <lttvwindow/lttvwindowtraces.h>
40 #include <lttvwindow/lttvwindow.h> // for CHUNK_NUM_EVENTS
41 #include <lttvwindow/mainwindow-private.h> /* for main window structure */
42
43 extern GSList * g_main_window_list;
44
45 typedef struct _BackgroundRequest {
46 LttvAttributeName module_name; /* Hook path in global attributes,
47 where all standard hooks under computation/.
48 i.e. modulename */
49 LttvTrace *trace; /* trace concerned */
50 GtkWidget *dialog; /* Dialog linked with the request, may be NULL */
51 GtkWidget *parent_window; /* Parent window the dialog must be transient for */
52 } BackgroundRequest;
53
54 typedef struct _BackgroundNotify {
55 gpointer owner;
56 LttvTrace *trace; /* trace */
57 LttTime notify_time;
58 LttvTracesetContextPosition *notify_position;
59 LttvHooks *notify; /* Hook to call when the notify is
60 passed, or at the end of trace */
61 } BackgroundNotify;
62
63
64
65 /* Prototypes */
66 gboolean lttvwindowtraces_process_pending_requests(LttvTrace *trace);
67
68 /* Get a trace by its path name.
69 *
70 * @param path path of the trace on the virtual file system.
71 * @return Pointer to trace if found
72 * NULL is returned if the trace is not present
73 */
74
75 __EXPORT LttvTrace *lttvwindowtraces_get_trace_by_name(gchar *path)
76 {
77 guint i;
78
79 for(i=0;i<lttvwindowtraces_get_number();i++) {
80 LttvTrace *trace_v = lttvwindowtraces_get_trace(i);
81 LttTrace *trace;
82 gchar *name;
83 g_assert(trace_v != NULL);
84
85 trace = lttv_trace(trace_v);
86 g_assert(trace != NULL);
87 name = g_quark_to_string(ltt_trace_name(trace));
88
89 if(strcmp(name, path) == 0) {
90 /* Found */
91 return trace_v;
92 }
93 }
94
95 return NULL;
96 }
97
98 /* Get a trace by its number identifier */
99
100 __EXPORT LttvTrace *lttvwindowtraces_get_trace(guint num)
101 {
102 LttvAttribute *g_attribute = lttv_global_attributes();
103 LttvAttribute *attribute;
104 LttvAttributeType type;
105 LttvAttributeName name;
106 LttvAttributeValue value;
107 gboolean is_named;
108
109 attribute =
110 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
111 LTTV_TRACES));
112 g_assert(attribute);
113
114 type = lttv_iattribute_get(LTTV_IATTRIBUTE(attribute), num, &name, &value,
115 &is_named);
116
117 if(type == LTTV_POINTER) {
118 return (LttvTrace *)*(value.v_pointer);
119 }
120
121 return NULL;
122 }
123
124 /* Total number of traces */
125
126 __EXPORT guint lttvwindowtraces_get_number()
127 {
128 LttvAttribute *g_attribute = lttv_global_attributes();
129 LttvAttribute *attribute;
130
131 attribute =
132 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
133 LTTV_TRACES));
134 g_assert(attribute);
135
136 return ( lttv_iattribute_get_number(LTTV_IATTRIBUTE(attribute)) );
137 }
138
139 /* Add a trace to the global attributes */
140
141 void lttvwindowtraces_add_trace(LttvTrace *trace)
142 {
143 LttvAttribute *g_attribute = lttv_global_attributes();
144 LttvAttribute *attribute;
145 LttvAttributeValue value;
146 struct stat buf;
147 gchar attribute_path[PATH_MAX];
148 int result;
149 gboolean result_b;
150
151 if(stat(g_quark_to_string(ltt_trace_name(lttv_trace(trace))), &buf)) {
152 g_warning("lttvwindowtraces_add_trace: Trace %s not found",
153 g_quark_to_string(ltt_trace_name(lttv_trace(trace))));
154 return;
155 }
156 result = snprintf(attribute_path, PATH_MAX, "%llu:%llu", buf.st_dev, buf.st_ino);
157 g_assert(result >= 0);
158
159 attribute =
160 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
161 LTTV_TRACES));
162 g_assert(attribute);
163
164 value = lttv_attribute_add(attribute,
165 g_quark_from_string(attribute_path),
166 LTTV_POINTER);
167
168 *(value.v_pointer) = (gpointer)trace;
169
170 /* create new traceset and tracesetcontext */
171 LttvTraceset *ts;
172 LttvTracesetStats *tss;
173 //LttvTracesetContextPosition *sync_position;
174
175 attribute = lttv_trace_attribute(trace);
176 result_b = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
177 LTTV_COMPUTATION_TRACESET,
178 LTTV_POINTER,
179 &value);
180 g_assert(result_b);
181
182 ts = lttv_traceset_new();
183 *(value.v_pointer) = ts;
184
185 lttv_traceset_add(ts,trace);
186
187 result_b = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
188 LTTV_COMPUTATION_TRACESET_CONTEXT,
189 LTTV_POINTER,
190 &value);
191 g_assert(result_b);
192
193 tss = g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
194 *(value.v_pointer) = tss;
195
196 lttv_context_init(LTTV_TRACESET_CONTEXT(tss), ts);
197 #if 0
198 result_b = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
199 LTTV_COMPUTATION_SYNC_POSITION,
200 LTTV_POINTER,
201 &value);
202 g_assert(result_b);
203
204 sync_position = lttv_traceset_context_position_new();
205 *(value.v_pointer) = sync_position;
206 #endif //0
207 value = lttv_attribute_add(attribute,
208 LTTV_REQUESTS_QUEUE,
209 LTTV_POINTER);
210
211 value = lttv_attribute_add(attribute,
212 LTTV_REQUESTS_CURRENT,
213 LTTV_POINTER);
214
215 value = lttv_attribute_add(attribute,
216 LTTV_NOTIFY_QUEUE,
217 LTTV_POINTER);
218
219 value = lttv_attribute_add(attribute,
220 LTTV_NOTIFY_CURRENT,
221 LTTV_POINTER);
222 }
223
224 /* Remove a trace from the global attributes */
225
226 void lttvwindowtraces_remove_trace(LttvTrace *trace)
227 {
228 LttvAttribute *g_attribute = lttv_global_attributes();
229 LttvAttribute *attribute;
230 LttvAttributeValue value;
231 guint i;
232 gboolean result;
233
234 attribute =
235 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
236 LTTV_TRACES));
237 g_assert(attribute);
238
239 for(i=0;i<lttvwindowtraces_get_number();i++) {
240 LttvTrace *trace_v = lttvwindowtraces_get_trace(i);
241
242 g_assert(trace_v != NULL);
243
244 /* Remove and background computation that could be in progress */
245 g_idle_remove_by_data(trace_v);
246
247 if(trace_v == trace) {
248 /* Found */
249 LttvAttribute *l_attribute;
250
251 /* destroy traceset and tracesetcontext */
252 LttvTraceset *ts;
253 LttvTracesetStats *tss;
254 //LttvTracesetContextPosition *sync_position;
255
256 l_attribute = lttv_trace_attribute(trace);
257
258
259 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
260 LTTV_REQUESTS_QUEUE);
261
262 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
263 LTTV_REQUESTS_CURRENT);
264
265 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
266 LTTV_NOTIFY_QUEUE);
267
268 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
269 LTTV_NOTIFY_CURRENT);
270
271 result = lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute),
272 LTTV_COMPUTATION_TRACESET,
273 LTTV_POINTER,
274 &value);
275 g_assert(result);
276
277 ts = (LttvTraceset*)*(value.v_pointer);
278 #if 0
279 result = lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute),
280 LTTV_COMPUTATION_SYNC_POSITION,
281 LTTV_POINTER,
282 &value);
283 g_assert(result);
284
285 sync_position = (LttvTracesetContextPosition*)*(value.v_pointer);
286 lttv_traceset_context_position_destroy(sync_position);
287
288 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
289 LTTV_COMPUTATION_SYNC_POSITION);
290
291 #endif //0
292 result = lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute),
293 LTTV_COMPUTATION_TRACESET_CONTEXT,
294 LTTV_POINTER,
295 &value);
296 g_assert(result);
297
298 tss = (LttvTracesetStats*)*(value.v_pointer);
299
300 lttv_context_fini(LTTV_TRACESET_CONTEXT(tss));
301 g_object_unref(tss);
302 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
303 LTTV_COMPUTATION_TRACESET_CONTEXT);
304 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
305 LTTV_COMPUTATION_TRACESET);
306 /* Destroy the traceset and the trace also */
307 lttv_traceset_destroy(ts);
308
309 /* finally, remove the global attribute */
310 lttv_attribute_remove(attribute, i);
311
312 return;
313 }
314 }
315 }
316
317 static void destroy_dialog(BackgroundRequest *bg_req)
318 {
319 gtk_widget_destroy(bg_req->dialog);
320 bg_req->dialog = NULL;
321 }
322
323
324 /**
325 * Function to request data from a specific trace
326 *
327 * The memory allocated for the request will be managed by the API.
328 *
329 * @param widget the current Window
330 * @param trace the trace to compute
331 * @param module_name the name of the module which registered global computation
332 * hooks.
333 */
334
335 __EXPORT void lttvwindowtraces_background_request_queue
336 (GtkWidget *widget, LttvTrace *trace, gchar *module_name)
337 {
338 BackgroundRequest *bg_req;
339 LttvAttribute *attribute = lttv_trace_attribute(trace);
340 LttvAttribute *g_attribute = lttv_global_attributes();
341 LttvAttribute *module_attribute;
342 LttvAttributeValue value;
343 LttvAttributeType type;
344 GSList **slist;
345 gboolean result;
346
347 lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
348 LTTV_REQUESTS_QUEUE,
349 LTTV_POINTER,
350 &value);
351 g_assert(result);
352
353 slist = (GSList**)(value.v_pointer);
354
355 /* Verify that the calculator is loaded */
356 module_attribute =
357 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
358 LTTV_COMPUTATION));
359 g_assert(module_attribute);
360
361 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
362 g_quark_from_string(module_name),
363 &value);
364 if(type == LTTV_NONE) {
365 g_critical("Missing background calculator %s", module_name);
366 return;
367 }
368
369 bg_req = g_new(BackgroundRequest,1);
370 bg_req->module_name = g_quark_from_string(module_name);
371 bg_req->trace = trace;
372
373 *slist = g_slist_append(*slist, bg_req);
374
375 /* Priority lower than live servicing */
376 g_idle_remove_by_data(trace);
377 g_idle_add_full((G_PRIORITY_HIGH_IDLE + 23),
378 (GSourceFunc)lttvwindowtraces_process_pending_requests,
379 trace,
380 NULL);
381 /* FIXME : show message in status bar, need context and message id */
382 g_info("Background computation for %s started for trace %p", module_name,
383 trace);
384 GtkWidget *dialog =
385 gtk_message_dialog_new(
386 GTK_WINDOW(widget),
387 GTK_DIALOG_DESTROY_WITH_PARENT,
388 GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
389 "Background computation for %s started for trace %s",
390 module_name,
391 g_quark_to_string(ltt_trace_name(lttv_trace(trace))));
392 gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(widget));
393 g_signal_connect_swapped (dialog, "response",
394 G_CALLBACK (destroy_dialog),
395 bg_req);
396 bg_req->dialog = dialog;
397 /* the parent window might vanish : only use this pointer for a
398 * comparison with existing windows */
399 bg_req->parent_window = gtk_widget_get_toplevel(widget);
400 gtk_widget_show(dialog);
401 }
402
403 /**
404 * Remove a background request from a trace.
405 *
406 * This should ONLY be used by the modules which registered the global hooks
407 * (module_name). If this is called by the viewers, it may lead to incomplete
408 * and incoherent background processing information.
409 *
410 * Even if the module which deals with the hooks removes the background
411 * requests, it may cause a problem if the module gets loaded again in the
412 * session : the data will be partially calculated. The calculation function
413 * must deal with this case correctly.
414 *
415 * @param trace the trace to compute
416 * @param module_name the name of the module which registered global computation
417 * hooks.
418 */
419
420 void lttvwindowtraces_background_request_remove
421 (LttvTrace *trace, gchar *module_name)
422 {
423 LttvAttribute *attribute = lttv_trace_attribute(trace);
424 LttvAttributeValue value;
425 GSList *iter = NULL;
426 GSList **slist;
427 gboolean result;
428
429 lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
430 LTTV_REQUESTS_QUEUE,
431 LTTV_POINTER,
432 &value);
433 g_assert(result);
434
435 slist = (GSList**)(value.v_pointer);
436
437 for(iter=*slist;iter!=NULL;) {
438 BackgroundRequest *bg_req =
439 (BackgroundRequest *)iter->data;
440
441 if(bg_req->module_name == g_quark_from_string(module_name)) {
442 GSList *rem_iter = iter;
443 iter=g_slist_next(iter);
444 g_free(bg_req);
445 *slist = g_slist_delete_link(*slist, rem_iter);
446 } else {
447 iter=g_slist_next(iter);
448 }
449 }
450 }
451
452 /**
453 * Find a background request in a trace
454 *
455 */
456
457 __EXPORT gboolean lttvwindowtraces_background_request_find
458 (LttvTrace *trace, gchar *module_name)
459 {
460 LttvAttribute *attribute = lttv_trace_attribute(trace);
461 LttvAttributeValue value;
462 GSList *iter = NULL;
463 GSList **slist;
464 gboolean result;
465
466 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
467 LTTV_REQUESTS_QUEUE,
468 LTTV_POINTER,
469 &value);
470 g_assert(result);
471
472 slist = (GSList**)(value.v_pointer);
473
474 for(iter=*slist;iter!=NULL;) {
475 BackgroundRequest *bg_req =
476 (BackgroundRequest *)iter->data;
477
478 if(bg_req->module_name == g_quark_from_string(module_name)) {
479 return TRUE;
480 } else {
481 iter=g_slist_next(iter);
482 }
483 }
484 return FALSE;
485 }
486
487 /**
488 * Register a callback to be called when requested data is passed in the next
489 * queued background processing.
490 *
491 * @param owner owner of the background notification
492 * @param trace the trace computed
493 * @param notify_time time when notification hooks must be called
494 * @param notify_position position when notification hooks must be called
495 * @param notify Hook to call when the notify position is passed
496 */
497
498 __EXPORT void lttvwindowtraces_background_notify_queue
499 (gpointer owner,
500 LttvTrace *trace,
501 LttTime notify_time,
502 const LttvTracesetContextPosition *notify_position,
503 const LttvHooks *notify)
504 {
505 BackgroundNotify *bg_notify;
506 LttvAttribute *attribute = lttv_trace_attribute(trace);
507 LttvAttributeValue value;
508 GSList **slist;
509 gboolean result;
510
511 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
512 LTTV_NOTIFY_QUEUE,
513 LTTV_POINTER,
514 &value);
515 g_assert(result);
516
517 slist = (GSList**)(value.v_pointer);
518
519 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
520 LTTV_COMPUTATION_TRACESET_CONTEXT,
521 LTTV_POINTER,
522 &value);
523 g_assert(result);
524
525 LttvTracesetContext *tsc = (LttvTracesetContext*)(value.v_pointer);
526
527 bg_notify = g_new(BackgroundNotify,1);
528
529 bg_notify->owner = owner;
530 bg_notify->trace = trace;
531 bg_notify->notify_time = notify_time;
532 if(notify_position != NULL) {
533 bg_notify->notify_position = lttv_traceset_context_position_new(tsc);
534 lttv_traceset_context_position_copy(bg_notify->notify_position,
535 notify_position);
536 } else {
537 bg_notify->notify_position = NULL;
538 }
539
540 bg_notify->notify = lttv_hooks_new();
541 lttv_hooks_add_list(bg_notify->notify, notify);
542
543 *slist = g_slist_append(*slist, bg_notify);
544 }
545
546 /**
547 * Register a callback to be called when requested data is passed in the current
548 * background processing.
549 *
550 * @param owner owner of the background notification
551 * @param trace the trace computed
552 * @param notify_time time when notification hooks must be called
553 * @param notify_position position when notification hooks must be called
554 * @param notify Hook to call when the notify position is passed
555 */
556
557 __EXPORT void lttvwindowtraces_background_notify_current
558 (gpointer owner,
559 LttvTrace *trace,
560 LttTime notify_time,
561 const LttvTracesetContextPosition *notify_position,
562 const LttvHooks *notify)
563 {
564 BackgroundNotify *bg_notify;
565 LttvAttribute *attribute = lttv_trace_attribute(trace);
566 LttvAttributeValue value;
567 GSList **slist;
568 gboolean result;
569
570 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
571 LTTV_NOTIFY_CURRENT,
572 LTTV_POINTER,
573 &value);
574 g_assert(result);
575
576 slist = (GSList**)(value.v_pointer);
577
578 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
579 LTTV_COMPUTATION_TRACESET_CONTEXT,
580 LTTV_POINTER,
581 &value);
582 g_assert(result);
583
584 LttvTracesetContext *tsc = (LttvTracesetContext*)(value.v_pointer);
585
586
587 bg_notify = g_new(BackgroundNotify,1);
588
589 bg_notify->owner = owner;
590 bg_notify->trace = trace;
591 bg_notify->notify_time = notify_time;
592 if(notify_position!= NULL) {
593 bg_notify->notify_position = lttv_traceset_context_position_new(tsc);
594 lttv_traceset_context_position_copy(bg_notify->notify_position,
595 notify_position);
596 } else {
597 bg_notify->notify_position = NULL;
598 }
599 bg_notify->notify = lttv_hooks_new();
600 lttv_hooks_add_list(bg_notify->notify, notify);
601
602 *slist = g_slist_append(*slist, bg_notify);
603 }
604
605
606 static void notify_request_free(BackgroundNotify *notify_req)
607 {
608 if(notify_req == NULL) return;
609
610 if(notify_req->notify_position != NULL)
611 lttv_traceset_context_position_destroy(notify_req->notify_position);
612 if(notify_req->notify != NULL)
613 lttv_hooks_destroy(notify_req->notify);
614 g_free(notify_req);
615 }
616
617 /**
618 * Removes all the notifications requests from a specific viewer.
619 *
620 * @param owner owner of the background notification
621 */
622
623 __EXPORT void lttvwindowtraces_background_notify_remove(gpointer owner)
624 {
625 guint i;
626
627 for(i=0;i<lttvwindowtraces_get_number();i++) {
628 LttvAttribute *attribute;
629 LttvAttributeValue value;
630 LttvTrace *trace_v = lttvwindowtraces_get_trace(i);
631 GSList **slist;
632 GSList *iter = NULL;
633 gboolean result;
634
635 g_assert(trace_v != NULL);
636
637 attribute = lttv_trace_attribute(trace_v);
638
639 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
640 LTTV_NOTIFY_QUEUE,
641 LTTV_POINTER,
642 &value);
643 g_assert(result);
644
645 slist = (GSList**)(value.v_pointer);
646
647 for(iter=*slist;iter!=NULL;) {
648
649 BackgroundNotify *bg_notify = (BackgroundNotify*)iter->data;
650
651 if(bg_notify->owner == owner) {
652 GSList *rem_iter = iter;
653 iter=g_slist_next(iter);
654 notify_request_free(bg_notify);
655 *slist = g_slist_remove_link(*slist, rem_iter);
656 } else {
657 iter=g_slist_next(iter);
658 }
659 }
660
661 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
662 LTTV_NOTIFY_CURRENT,
663 LTTV_POINTER,
664 &value);
665 g_assert(result);
666
667 slist = (GSList**)(value.v_pointer);
668
669 for(iter=*slist;iter!=NULL;) {
670
671 BackgroundNotify *bg_notify = (BackgroundNotify*)iter->data;
672
673 if(bg_notify->owner == owner) {
674 GSList *rem_iter = iter;
675 iter=g_slist_next(iter);
676 notify_request_free(bg_notify);
677 *slist = g_slist_remove_link(*slist, rem_iter);
678 } else {
679 iter=g_slist_next(iter);
680 }
681 }
682 }
683 }
684
685
686 /* Background processing helper functions */
687
688 void lttvwindowtraces_add_computation_hooks(LttvAttributeName module_name,
689 LttvTracesetContext *tsc,
690 LttvHooks *hook_adder)
691 {
692 LttvAttribute *g_attribute = lttv_global_attributes();
693 LttvAttribute *module_attribute;
694 LttvAttributeType type;
695 LttvAttributeValue value;
696
697
698 module_attribute =
699 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
700 LTTV_COMPUTATION));
701 g_assert(module_attribute);
702
703 module_attribute =
704 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
705 LTTV_IATTRIBUTE(module_attribute),
706 module_name));
707 g_assert(module_attribute);
708
709 /* Call the module's hook adder */
710 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
711 LTTV_HOOK_ADDER,
712 &value);
713 if(type == LTTV_POINTER) {
714 //lttv_hooks_call((LttvHooks*)*(value.v_pointer), (gpointer)tss);
715 if(hook_adder != NULL)
716 lttv_hooks_add_list(hook_adder, (LttvHooks*)*(value.v_pointer));
717 }
718 }
719
720 void lttvwindowtraces_remove_computation_hooks(LttvAttributeName module_name,
721 LttvTracesetContext *tsc,
722 LttvHooks *hook_remover)
723 {
724 LttvAttribute *g_attribute = lttv_global_attributes();
725 LttvAttribute *module_attribute;
726 LttvAttributeType type;
727 LttvAttributeValue value;
728
729 module_attribute =
730 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
731 LTTV_COMPUTATION));
732 g_assert(module_attribute);
733
734 module_attribute =
735 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
736 LTTV_IATTRIBUTE(module_attribute),
737 module_name));
738 g_assert(module_attribute);
739
740 /* Call the module's hook remover */
741 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
742 LTTV_HOOK_REMOVER,
743 &value);
744 if(type == LTTV_POINTER) {
745 //lttv_hooks_call((LttvHooks*)*(value.v_pointer), (gpointer)tss);
746 if(hook_remover != NULL)
747 lttv_hooks_add_list(hook_remover, (LttvHooks*)*(value.v_pointer));
748 }
749 }
750
751 void lttvwindowtraces_call_before_chunk(LttvAttributeName module_name,
752 LttvTracesetContext *tsc)
753 {
754 LttvAttribute *g_attribute = lttv_global_attributes();
755 LttvAttribute *module_attribute;
756 LttvAttributeType type;
757 LttvAttributeValue value;
758 LttvHooks *before_chunk_traceset=NULL;
759 LttvHooks *before_chunk_trace=NULL;
760 LttvHooks *before_chunk_tracefile=NULL;
761 LttvHooks *event_hook=NULL;
762 LttvHooksById *event_hook_by_id=NULL;
763
764
765 module_attribute =
766 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
767 LTTV_COMPUTATION));
768 g_assert(module_attribute);
769
770 module_attribute =
771 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
772 LTTV_IATTRIBUTE(module_attribute),
773 module_name));
774 g_assert(module_attribute);
775
776 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
777 LTTV_BEFORE_CHUNK_TRACESET,
778 &value);
779 if(type == LTTV_POINTER) {
780 before_chunk_traceset = (LttvHooks*)*(value.v_pointer);
781 }
782
783 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
784 LTTV_BEFORE_CHUNK_TRACE,
785 &value);
786 if(type == LTTV_POINTER) {
787 before_chunk_trace = (LttvHooks*)*(value.v_pointer);
788 }
789
790 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
791 LTTV_BEFORE_CHUNK_TRACEFILE,
792 &value);
793 if(type == LTTV_POINTER) {
794 before_chunk_tracefile = (LttvHooks*)*(value.v_pointer);
795 }
796
797 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
798 LTTV_EVENT_HOOK,
799 &value);
800 if(type == LTTV_POINTER) {
801 event_hook = (LttvHooks*)*(value.v_pointer);
802 }
803
804 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
805 LTTV_EVENT_HOOK_BY_ID,
806 &value);
807 if(type == LTTV_POINTER) {
808 event_hook_by_id = (LttvHooksById*)*(value.v_pointer);
809 }
810
811 lttv_process_traceset_begin(tsc,
812 before_chunk_traceset,
813 before_chunk_trace,
814 before_chunk_tracefile,
815 event_hook,
816 event_hook_by_id);
817 }
818
819
820
821 void lttvwindowtraces_call_after_chunk(LttvAttributeName module_name,
822 LttvTracesetContext *tsc)
823 {
824 LttvAttribute *g_attribute = lttv_global_attributes();
825 LttvAttribute *module_attribute;
826 LttvAttributeType type;
827 LttvAttributeValue value;
828 LttvHooks *after_chunk_traceset=NULL;
829 LttvHooks *after_chunk_trace=NULL;
830 LttvHooks *after_chunk_tracefile=NULL;
831 LttvHooks *event_hook=NULL;
832 LttvHooksById *event_hook_by_id=NULL;
833
834 module_attribute =
835 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
836 LTTV_COMPUTATION));
837 g_assert(module_attribute);
838
839 module_attribute =
840 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
841 LTTV_IATTRIBUTE(module_attribute),
842 module_name));
843 g_assert(module_attribute);
844
845 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
846 LTTV_AFTER_CHUNK_TRACESET,
847 &value);
848 if(type == LTTV_POINTER) {
849 after_chunk_traceset = (LttvHooks*)*(value.v_pointer);
850 }
851
852 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
853 LTTV_AFTER_CHUNK_TRACE,
854 &value);
855 if(type == LTTV_POINTER) {
856 after_chunk_trace = (LttvHooks*)*(value.v_pointer);
857 }
858
859 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
860 LTTV_AFTER_CHUNK_TRACEFILE,
861 &value);
862 if(type == LTTV_POINTER) {
863 after_chunk_tracefile = (LttvHooks*)*(value.v_pointer);
864 }
865
866 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
867 LTTV_EVENT_HOOK,
868 &value);
869 if(type == LTTV_POINTER) {
870 event_hook = (LttvHooks*)*(value.v_pointer);
871 }
872
873 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
874 LTTV_EVENT_HOOK_BY_ID,
875 &value);
876 if(type == LTTV_POINTER) {
877 event_hook_by_id = (LttvHooksById*)*(value.v_pointer);
878 }
879
880 lttv_process_traceset_end(tsc,
881 after_chunk_traceset,
882 after_chunk_trace,
883 after_chunk_tracefile,
884 event_hook,
885 event_hook_by_id);
886
887 }
888
889
890 void lttvwindowtraces_set_in_progress(LttvAttributeName module_name,
891 LttvTrace *trace)
892 {
893 LttvAttribute *attribute = lttv_trace_attribute(trace);
894 LttvAttributeValue value;
895
896 attribute =
897 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
898 module_name));
899 g_assert(attribute);
900
901 value = lttv_iattribute_add(LTTV_IATTRIBUTE(attribute),
902 LTTV_IN_PROGRESS,
903 LTTV_INT);
904 /* the value is left unset. The only presence of the attribute is necessary.
905 */
906 }
907
908 void lttvwindowtraces_unset_in_progress(LttvAttributeName module_name,
909 LttvTrace *trace)
910 {
911 LttvAttribute *attribute = lttv_trace_attribute(trace);
912
913 attribute =
914 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
915 module_name));
916 g_assert(attribute);
917
918 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
919 LTTV_IN_PROGRESS);
920 }
921
922 __EXPORT gboolean lttvwindowtraces_get_in_progress(LttvAttributeName module_name,
923 LttvTrace *trace)
924 {
925 LttvAttribute *attribute = lttv_trace_attribute(trace);
926 LttvAttributeType type;
927 LttvAttributeValue value;
928
929 attribute =
930 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
931 module_name));
932 g_assert(attribute);
933
934 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
935 LTTV_IN_PROGRESS,
936 &value);
937 /* The only presence of the attribute is necessary. */
938 if(type == LTTV_NONE)
939 return FALSE;
940 else
941 return TRUE;
942 }
943
944 void lttvwindowtraces_set_ready(LttvAttributeName module_name,
945 LttvTrace *trace)
946 {
947 LttvAttribute *attribute = lttv_trace_attribute(trace);
948 LttvAttributeValue value;
949
950 attribute =
951 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
952 module_name));
953 g_assert(attribute);
954
955 value = lttv_iattribute_add(LTTV_IATTRIBUTE(attribute),
956 LTTV_READY,
957 LTTV_INT);
958 /* the value is left unset. The only presence of the attribute is necessary.
959 */
960 }
961
962 void lttvwindowtraces_unset_ready(LttvAttributeName module_name,
963 LttvTrace *trace)
964 {
965 LttvAttribute *attribute = lttv_trace_attribute(trace);
966
967 attribute =
968 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
969 module_name));
970 g_assert(attribute);
971
972 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
973 LTTV_READY);
974 }
975
976 __EXPORT gboolean lttvwindowtraces_get_ready(LttvAttributeName module_name,
977 LttvTrace *trace)
978 {
979 LttvAttribute *attribute = lttv_trace_attribute(trace);
980 LttvAttributeType type;
981 LttvAttributeValue value;
982
983 attribute =
984 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
985 module_name));
986 g_assert(attribute);
987
988 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
989 LTTV_READY,
990 &value);
991 /* The only presence of the attribute is necessary. */
992 if(type == LTTV_NONE)
993 return FALSE;
994 else
995 return TRUE;
996 }
997
998 static gint find_window_widget(MainWindow *a, GtkWidget *b)
999 {
1000 if(a->mwindow == b) return 0;
1001 else return -1;
1002 }
1003
1004
1005 /* lttvwindowtraces_process_pending_requests
1006 *
1007 * This internal function gets called by g_idle, taking care of the pending
1008 * requests.
1009 *
1010 */
1011
1012
1013 gboolean lttvwindowtraces_process_pending_requests(LttvTrace *trace)
1014 {
1015 LttvTracesetContext *tsc;
1016 LttvTracesetStats *tss;
1017 LttvTraceset *ts;
1018 //LttvTracesetContextPosition *sync_position;
1019 LttvAttribute *attribute;
1020 LttvAttribute *g_attribute = lttv_global_attributes();
1021 GSList **list_out, **list_in, **notify_in, **notify_out;
1022 LttvAttributeValue value;
1023 LttvAttributeType type;
1024 gboolean ret_val;
1025
1026 if(trace == NULL)
1027 return FALSE;
1028
1029 if(lttvwindow_preempt_count > 0) return TRUE;
1030
1031 attribute = lttv_trace_attribute(trace);
1032
1033 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1034 LTTV_REQUESTS_QUEUE,
1035 &value);
1036 g_assert(type == LTTV_POINTER);
1037 list_out = (GSList**)(value.v_pointer);
1038
1039 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1040 LTTV_REQUESTS_CURRENT,
1041 &value);
1042 g_assert(type == LTTV_POINTER);
1043 list_in = (GSList**)(value.v_pointer);
1044
1045 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1046 LTTV_NOTIFY_QUEUE,
1047 &value);
1048 g_assert(type == LTTV_POINTER);
1049 notify_out = (GSList**)(value.v_pointer);
1050
1051 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1052 LTTV_NOTIFY_CURRENT,
1053 &value);
1054 g_assert(type == LTTV_POINTER);
1055 notify_in = (GSList**)(value.v_pointer);
1056
1057 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1058 LTTV_COMPUTATION_TRACESET,
1059 &value);
1060 g_assert(type == LTTV_POINTER);
1061 ts = (LttvTraceset*)*(value.v_pointer);
1062
1063 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1064 LTTV_COMPUTATION_TRACESET_CONTEXT,
1065 &value);
1066 g_assert(type == LTTV_POINTER);
1067 tsc = (LttvTracesetContext*)*(value.v_pointer);
1068 tss = (LttvTracesetStats*)*(value.v_pointer);
1069 g_assert(LTTV_IS_TRACESET_CONTEXT(tsc));
1070 g_assert(LTTV_IS_TRACESET_STATS(tss));
1071 #if 0
1072 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1073 LTTV_COMPUTATION_SYNC_POSITION,
1074 &value);
1075 g_assert(type == LTTV_POINTER);
1076 sync_position = (LttvTracesetContextPosition*)*(value.v_pointer);
1077 #endif //0
1078 /* There is no events requests pending : we should never have been called! */
1079 g_assert(g_slist_length(*list_out) != 0 || g_slist_length(*list_in) != 0);
1080 /* 0.1 Lock traces */
1081 {
1082 guint iter_trace=0;
1083
1084 for(iter_trace=0;
1085 iter_trace<lttv_traceset_number(tsc->ts);
1086 iter_trace++) {
1087 LttvTrace *trace_v = lttv_traceset_get(tsc->ts,iter_trace);
1088
1089 if(lttvwindowtraces_lock(trace_v) != 0)
1090 return TRUE; /* Cannot get trace lock, try later */
1091
1092 }
1093 }
1094 /* 0.2 Sync tracefiles */
1095 //g_assert(lttv_process_traceset_seek_position(tsc, sync_position) == 0);
1096 lttv_process_traceset_synchronize_tracefiles(tsc);
1097 /* 1. Before processing */
1098 {
1099 /* if list_in is empty */
1100 if(g_slist_length(*list_in) == 0) {
1101
1102 {
1103 /* - Add all requests in list_out to list_in, empty list_out */
1104 GSList *iter = *list_out;
1105
1106 while(iter != NULL) {
1107 gboolean remove = FALSE;
1108 gboolean free_data = FALSE;
1109
1110 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1111
1112 remove = TRUE;
1113 free_data = FALSE;
1114 *list_in = g_slist_append(*list_in, bg_req);
1115
1116 /* Go to next */
1117 if(remove)
1118 {
1119 GSList *remove_iter = iter;
1120
1121 iter = g_slist_next(iter);
1122 if(free_data) g_free(remove_iter->data);
1123 *list_out = g_slist_remove_link(*list_out, remove_iter);
1124 } else { // not remove
1125 iter = g_slist_next(iter);
1126 }
1127 }
1128 }
1129
1130 {
1131 GSList *iter = *list_in;
1132 /* - for each request in list_in */
1133 while(iter != NULL) {
1134
1135 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1136 /* - set hooks'in_progress flag to TRUE */
1137 lttvwindowtraces_set_in_progress(bg_req->module_name,
1138 bg_req->trace);
1139
1140 /* - call before request hook */
1141 /* Get before request hook */
1142 LttvAttribute *module_attribute;
1143
1144 module_attribute =
1145 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
1146 LTTV_IATTRIBUTE(g_attribute),
1147 LTTV_COMPUTATION));
1148 g_assert(module_attribute);
1149
1150 module_attribute =
1151 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
1152 LTTV_IATTRIBUTE(module_attribute),
1153 bg_req->module_name));
1154 g_assert(module_attribute);
1155
1156 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
1157 LTTV_BEFORE_REQUEST,
1158 &value);
1159 g_assert(type == LTTV_POINTER);
1160 LttvHooks *before_request = (LttvHooks*)*(value.v_pointer);
1161
1162 if(before_request != NULL) lttv_hooks_call(before_request, tsc);
1163
1164 iter = g_slist_next(iter);
1165 }
1166 }
1167
1168 /* - seek trace to start */
1169 {
1170 LttTime start = { 0, 0};
1171 lttv_process_traceset_seek_time(tsc, start);
1172 }
1173
1174 /* - Move all notifications from notify_out to notify_in. */
1175 {
1176 GSList *iter = *notify_out;
1177 g_assert(g_slist_length(*notify_in) == 0);
1178
1179 while(iter != NULL) {
1180 gboolean remove = FALSE;
1181 gboolean free_data = FALSE;
1182
1183 BackgroundNotify *notify_req = (BackgroundNotify*)iter->data;
1184
1185 remove = TRUE;
1186 free_data = FALSE;
1187 *notify_in = g_slist_append(*notify_in, notify_req);
1188
1189 /* Go to next */
1190 if(remove)
1191 {
1192 GSList *remove_iter = iter;
1193
1194 iter = g_slist_next(iter);
1195 if(free_data)
1196 notify_request_free((BackgroundNotify*)remove_iter->data);
1197 *notify_out = g_slist_remove_link(*notify_out, remove_iter);
1198 } else { // not remove
1199 iter = g_slist_next(iter);
1200 }
1201 }
1202 }
1203 {
1204 GSList *iter = *list_in;
1205 LttvHooks *hook_adder = lttv_hooks_new();
1206 /* - for each request in list_in */
1207 while(iter != NULL) {
1208
1209 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1210 /*- add hooks to context*/
1211 lttvwindowtraces_add_computation_hooks(bg_req->module_name,
1212 tsc,
1213 hook_adder);
1214 iter = g_slist_next(iter);
1215 }
1216 lttv_hooks_call(hook_adder,tsc);
1217 lttv_hooks_destroy(hook_adder);
1218 }
1219
1220
1221 }
1222
1223 {
1224 GSList *iter = *list_in;
1225 /* - for each request in list_in */
1226 while(iter != NULL) {
1227
1228 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1229 /*- Call before chunk hooks for list_in*/
1230 lttvwindowtraces_call_before_chunk(bg_req->module_name,
1231 tsc);
1232 iter = g_slist_next(iter);
1233 }
1234 }
1235
1236 }
1237 /* 2. call process traceset middle for a chunk */
1238 {
1239 /*(assert list_in is not empty! : should not even be called in that case)*/
1240 LttTime end = ltt_time_infinite;
1241 g_assert(g_slist_length(*list_in) != 0);
1242
1243 lttv_process_traceset_middle(tsc, end, CHUNK_NUM_EVENTS, NULL);
1244 }
1245
1246 /* 3. After the chunk */
1247 {
1248 /* 3.1 call after_chunk hooks for list_in */
1249 {
1250 GSList *iter = *list_in;
1251 /* - for each request in list_in */
1252 while(iter != NULL) {
1253
1254 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1255 /* - Call after chunk hooks for list_in */
1256 lttvwindowtraces_call_after_chunk(bg_req->module_name,
1257 tsc);
1258 iter = g_slist_next(iter);
1259 }
1260 }
1261
1262 /* 3.2 for each notify_in */
1263 {
1264 GSList *iter = *notify_in;
1265 LttvTracefileContext *tfc = lttv_traceset_context_get_current_tfc(tsc);
1266
1267 while(iter != NULL) {
1268 gboolean remove = FALSE;
1269 gboolean free_data = FALSE;
1270
1271 BackgroundNotify *notify_req = (BackgroundNotify*)iter->data;
1272
1273 /* - if current time >= notify time, call notify and remove from
1274 * notify_in.
1275 * - if current position >= notify position, call notify and remove
1276 * from notify_in.
1277 */
1278 if( (tfc != NULL &&
1279 ltt_time_compare(notify_req->notify_time, tfc->timestamp) <= 0)
1280 ||
1281 (notify_req->notify_position != NULL &&
1282 lttv_traceset_context_ctx_pos_compare(tsc,
1283 notify_req->notify_position) >= 0)
1284 ) {
1285
1286 lttv_hooks_call(notify_req->notify, notify_req);
1287
1288 remove = TRUE;
1289 free_data = TRUE;
1290 }
1291
1292 /* Go to next */
1293 if(remove)
1294 {
1295 GSList *remove_iter = iter;
1296
1297 iter = g_slist_next(iter);
1298 if(free_data)
1299 notify_request_free((BackgroundNotify*)remove_iter->data);
1300 *notify_in = g_slist_remove_link(*notify_in, remove_iter);
1301 } else { // not remove
1302 iter = g_slist_next(iter);
1303 }
1304 }
1305 }
1306
1307 {
1308 LttvTracefileContext *tfc = lttv_traceset_context_get_current_tfc(tsc);
1309 /* 3.3 if end of trace reached */
1310 if(tfc != NULL)
1311 g_debug("Current time : %lu sec, %lu nsec",
1312 tfc->timestamp.tv_sec, tfc->timestamp.tv_nsec);
1313 if(tfc == NULL || ltt_time_compare(tfc->timestamp,
1314 tsc->time_span.end_time) > 0) {
1315
1316 {
1317 GSList *iter = *list_in;
1318 LttvHooks *hook_remover = lttv_hooks_new();
1319 /* - for each request in list_in */
1320 while(iter != NULL) {
1321
1322 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1323 /* - remove hooks from context */
1324 lttvwindowtraces_remove_computation_hooks(bg_req->module_name,
1325 tsc,
1326 hook_remover);
1327 iter = g_slist_next(iter);
1328 }
1329 lttv_hooks_call(hook_remover,tsc);
1330 lttv_hooks_destroy(hook_remover);
1331 }
1332
1333 /* - for each request in list_in */
1334 {
1335 GSList *iter = *list_in;
1336
1337 while(iter != NULL) {
1338 gboolean remove = FALSE;
1339 gboolean free_data = FALSE;
1340
1341 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1342
1343 /* - set hooks'in_progress flag to FALSE */
1344 lttvwindowtraces_unset_in_progress(bg_req->module_name,
1345 bg_req->trace);
1346 /* - set hooks'ready flag to TRUE */
1347 lttvwindowtraces_set_ready(bg_req->module_name,
1348 bg_req->trace);
1349 /* - call after request hook */
1350 /* Get after request hook */
1351 LttvAttribute *module_attribute;
1352
1353 module_attribute =
1354 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
1355 LTTV_IATTRIBUTE(g_attribute),
1356 LTTV_COMPUTATION));
1357 g_assert(module_attribute);
1358
1359 module_attribute =
1360 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
1361 LTTV_IATTRIBUTE(module_attribute),
1362 bg_req->module_name));
1363 g_assert(module_attribute);
1364
1365 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
1366 LTTV_AFTER_REQUEST,
1367 &value);
1368 g_assert(type == LTTV_POINTER);
1369 LttvHooks *after_request = (LttvHooks*)*(value.v_pointer);
1370 {
1371 struct sum_traceset_closure t_closure;
1372 t_closure.tss = (LttvTracesetStats*)tsc;
1373 t_closure.current_time = ltt_time_infinite;
1374 if(after_request != NULL) lttv_hooks_call(after_request,
1375 &t_closure);
1376 }
1377
1378 if(bg_req->dialog != NULL)
1379 gtk_widget_destroy(bg_req->dialog);
1380 GtkWidget *parent_window;
1381 if(g_slist_find_custom(g_main_window_list,
1382 bg_req->parent_window,
1383 (GCompareFunc)find_window_widget))
1384 parent_window = GTK_WIDGET(bg_req->parent_window);
1385 else
1386 parent_window = NULL;
1387
1388 GtkWidget *dialog =
1389 gtk_message_dialog_new(GTK_WINDOW(parent_window),
1390 GTK_DIALOG_DESTROY_WITH_PARENT,
1391 GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
1392 "Background computation %s finished for trace %s",
1393 g_quark_to_string(bg_req->module_name),
1394 g_quark_to_string(ltt_trace_name(lttv_trace(bg_req->trace))));
1395 if(parent_window != NULL)
1396 gtk_window_set_transient_for(GTK_WINDOW(dialog),
1397 GTK_WINDOW(parent_window));
1398 g_signal_connect_swapped (dialog, "response",
1399 G_CALLBACK (gtk_widget_destroy),
1400 dialog);
1401 gtk_widget_show(dialog);
1402
1403 /* - remove request */
1404 remove = TRUE;
1405 free_data = TRUE;
1406
1407 /* Go to next */
1408 if(remove)
1409 {
1410 GSList *remove_iter = iter;
1411
1412 iter = g_slist_next(iter);
1413 if(free_data) g_free(remove_iter->data);
1414 *list_in = g_slist_remove_link(*list_in, remove_iter);
1415 } else { // not remove
1416 iter = g_slist_next(iter);
1417 }
1418 }
1419 }
1420
1421 /* - for each notifications in notify_in */
1422 {
1423 GSList *iter = *notify_in;
1424
1425 while(iter != NULL) {
1426 gboolean remove = FALSE;
1427 gboolean free_data = FALSE;
1428
1429 BackgroundNotify *notify_req = (BackgroundNotify*)iter->data;
1430
1431 /* - call notify and remove from notify_in */
1432 lttv_hooks_call(notify_req->notify, notify_req);
1433 remove = TRUE;
1434 free_data = TRUE;
1435
1436 /* Go to next */
1437 if(remove)
1438 {
1439 GSList *remove_iter = iter;
1440
1441 iter = g_slist_next(iter);
1442 if(free_data)
1443 notify_request_free((BackgroundNotify*)remove_iter->data);
1444 *notify_in = g_slist_remove_link(*notify_in, remove_iter);
1445 } else { // not remove
1446 iter = g_slist_next(iter);
1447 }
1448 }
1449 }
1450 {
1451 /* - reset the context */
1452 LTTV_TRACESET_CONTEXT_GET_CLASS(tsc)->fini(tsc);
1453 LTTV_TRACESET_CONTEXT_GET_CLASS(tsc)->init(tsc,ts);
1454 }
1455 /* - if list_out is empty */
1456 if(g_slist_length(*list_out) == 0) {
1457 /* - return FALSE (scheduler stopped) */
1458 g_debug("Background computation scheduler stopped");
1459 g_info("Background computation finished for trace %p", trace);
1460 /* FIXME : remove status bar info, need context id and message id */
1461
1462 ret_val = FALSE;
1463 } else {
1464 ret_val = TRUE;
1465 }
1466 } else {
1467 /* 3.4 else, end of trace not reached */
1468 /* - return TRUE (scheduler still registered) */
1469 g_debug("Background computation left");
1470 ret_val = TRUE;
1471 }
1472 }
1473 }
1474 /* 4. Unlock traces */
1475 {
1476 lttv_process_traceset_get_sync_data(tsc);
1477 //lttv_traceset_context_position_save(tsc, sync_position);
1478 guint iter_trace;
1479
1480 for(iter_trace=0;
1481 iter_trace<lttv_traceset_number(tsc->ts);
1482 iter_trace++) {
1483 LttvTrace *trace_v = lttv_traceset_get(tsc->ts, iter_trace);
1484
1485 lttvwindowtraces_unlock(trace_v);
1486 }
1487 }
1488 return ret_val;
1489 }
1490
1491
1492
1493 /**
1494 * Register the background computation hooks for a specific module. It adds the
1495 * computation hooks to the global attrubutes, under "computation/module name".
1496 *
1497 * @param module_name A GQuark : the name of the module which computes the
1498 * information.
1499 */
1500 void lttvwindowtraces_register_computation_hooks(LttvAttributeName module_name,
1501 LttvHooks *before_chunk_traceset,
1502 LttvHooks *before_chunk_trace,
1503 LttvHooks *before_chunk_tracefile,
1504 LttvHooks *after_chunk_traceset,
1505 LttvHooks *after_chunk_trace,
1506 LttvHooks *after_chunk_tracefile,
1507 LttvHooks *before_request,
1508 LttvHooks *after_request,
1509 LttvHooks *event_hook,
1510 LttvHooksById *event_hook_by_id,
1511 LttvHooks *hook_adder,
1512 LttvHooks *hook_remover)
1513 {
1514 LttvAttribute *g_attribute = lttv_global_attributes();
1515 LttvAttribute *attribute;
1516 LttvAttributeValue value;
1517 gboolean result;
1518
1519 attribute =
1520 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
1521 LTTV_COMPUTATION));
1522 g_assert(attribute);
1523
1524 attribute =
1525 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
1526 module_name));
1527 g_assert(attribute);
1528
1529 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1530 LTTV_BEFORE_CHUNK_TRACESET,
1531 LTTV_POINTER,
1532 &value);
1533 g_assert(result);
1534
1535 *(value.v_pointer) = before_chunk_traceset;
1536
1537 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1538 LTTV_BEFORE_CHUNK_TRACE,
1539 LTTV_POINTER,
1540 &value);
1541 g_assert(result);
1542 *(value.v_pointer) = before_chunk_trace;
1543
1544 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1545 LTTV_BEFORE_CHUNK_TRACEFILE,
1546 LTTV_POINTER,
1547 &value);
1548 g_assert(result);
1549 *(value.v_pointer) = before_chunk_tracefile;
1550
1551 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1552 LTTV_AFTER_CHUNK_TRACESET,
1553 LTTV_POINTER,
1554 &value);
1555 g_assert(result);
1556 *(value.v_pointer) = after_chunk_traceset;
1557
1558 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1559 LTTV_AFTER_CHUNK_TRACE,
1560 LTTV_POINTER,
1561 &value);
1562 g_assert(result);
1563 *(value.v_pointer) = after_chunk_trace;
1564
1565 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1566 LTTV_AFTER_CHUNK_TRACEFILE,
1567 LTTV_POINTER,
1568 &value);
1569 g_assert(result);
1570 *(value.v_pointer) = after_chunk_tracefile;
1571
1572 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1573 LTTV_BEFORE_REQUEST,
1574 LTTV_POINTER,
1575 &value);
1576 g_assert(result);
1577 *(value.v_pointer) = before_request;
1578
1579 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1580 LTTV_AFTER_REQUEST,
1581 LTTV_POINTER,
1582 &value);
1583 g_assert(result);
1584 *(value.v_pointer) = after_request;
1585
1586 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1587 LTTV_EVENT_HOOK,
1588 LTTV_POINTER,
1589 &value);
1590 g_assert(result);
1591 *(value.v_pointer) = event_hook;
1592
1593 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1594 LTTV_EVENT_HOOK_BY_ID,
1595 LTTV_POINTER,
1596 &value);
1597 g_assert(result);
1598 *(value.v_pointer) = event_hook_by_id;
1599
1600 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1601 LTTV_HOOK_ADDER,
1602 LTTV_POINTER,
1603 &value);
1604 g_assert(result);
1605 *(value.v_pointer) = hook_adder;
1606
1607 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1608 LTTV_HOOK_REMOVER,
1609 LTTV_POINTER,
1610 &value);
1611 g_assert(result);
1612 *(value.v_pointer) = hook_remover;
1613
1614 }
1615
1616
1617 /**
1618 * It removes all the requests than can be currently processed by the
1619 * background computation algorithm for all the traces (list_in and list_out).
1620 *
1621 * Leaves the flag to in_progress or none.. depending if current or queue
1622 *
1623 * @param module_name A GQuark : the name of the module which computes the
1624 * information.
1625 */
1626 void lttvwindowtraces_unregister_requests(LttvAttributeName module_name)
1627 {
1628 guint i;
1629 gboolean result;
1630
1631 for(i=0;i<lttvwindowtraces_get_number();i++) {
1632 LttvTrace *trace_v = lttvwindowtraces_get_trace(i);
1633 g_assert(trace_v != NULL);
1634 LttvAttribute *attribute = lttv_trace_attribute(trace_v);
1635 LttvAttributeValue value;
1636 GSList **queue, **current;
1637 GSList *iter;
1638
1639 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1640 LTTV_REQUESTS_QUEUE,
1641 LTTV_POINTER,
1642 &value);
1643 g_assert(result);
1644
1645 queue = (GSList**)(value.v_pointer);
1646
1647 iter = *queue;
1648 while(iter != NULL) {
1649 gboolean remove = FALSE;
1650 gboolean free_data = FALSE;
1651
1652 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1653
1654 if(bg_req->module_name == module_name) {
1655 remove = TRUE;
1656 free_data = TRUE;
1657 }
1658
1659 /* Go to next */
1660 if(remove)
1661 {
1662 GSList *remove_iter = iter;
1663
1664 iter = g_slist_next(iter);
1665 if(free_data) g_free(remove_iter->data);
1666 *queue = g_slist_remove_link(*queue, remove_iter);
1667 } else { // not remove
1668 iter = g_slist_next(iter);
1669 }
1670 }
1671
1672
1673 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1674 LTTV_REQUESTS_CURRENT,
1675 LTTV_POINTER,
1676 &value);
1677 g_assert(result);
1678
1679 current = (GSList**)(value.v_pointer);
1680
1681 iter = *current;
1682 while(iter != NULL) {
1683 gboolean remove = FALSE;
1684 gboolean free_data = FALSE;
1685
1686 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1687
1688 if(bg_req->module_name == module_name) {
1689 remove = TRUE;
1690 free_data = TRUE;
1691 }
1692
1693 /* Go to next */
1694 if(remove)
1695 {
1696 GSList *remove_iter = iter;
1697
1698 iter = g_slist_next(iter);
1699 if(free_data) g_free(remove_iter->data);
1700 *current = g_slist_remove_link(*current, remove_iter);
1701 } else { // not remove
1702 iter = g_slist_next(iter);
1703 }
1704 }
1705 }
1706 }
1707
1708
1709 /**
1710 * Unregister the background computation hooks for a specific module.
1711 *
1712 * It also removes all the requests than can be currently processed by the
1713 * background computation algorithm for all the traces (list_in and list_out).
1714 *
1715 * @param module_name A GQuark : the name of the module which computes the
1716 * information.
1717 */
1718
1719 void lttvwindowtraces_unregister_computation_hooks
1720 (LttvAttributeName module_name)
1721 {
1722 LttvAttribute *g_attribute = lttv_global_attributes();
1723 LttvAttribute *attribute;
1724 LttvAttributeValue value;
1725 gboolean result;
1726
1727 attribute =
1728 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
1729 LTTV_COMPUTATION));
1730 g_assert(attribute);
1731
1732 attribute =
1733 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
1734 module_name));
1735 g_assert(attribute);
1736
1737 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1738 LTTV_BEFORE_CHUNK_TRACESET,
1739 LTTV_POINTER,
1740 &value);
1741 g_assert(result);
1742
1743 LttvHooks *before_chunk_traceset = (LttvHooks*)*(value.v_pointer);
1744 if(before_chunk_traceset != NULL)
1745 lttv_hooks_destroy(before_chunk_traceset);
1746
1747 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1748 LTTV_BEFORE_CHUNK_TRACE,
1749 LTTV_POINTER,
1750 &value);
1751 g_assert(result);
1752
1753 LttvHooks *before_chunk_trace = (LttvHooks*)*(value.v_pointer);
1754 if(before_chunk_trace != NULL)
1755 lttv_hooks_destroy(before_chunk_trace);
1756
1757 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1758 LTTV_BEFORE_CHUNK_TRACEFILE,
1759 LTTV_POINTER,
1760 &value);
1761 g_assert(result);
1762
1763 LttvHooks *before_chunk_tracefile = (LttvHooks*)*(value.v_pointer);
1764 if(before_chunk_tracefile != NULL)
1765 lttv_hooks_destroy(before_chunk_tracefile);
1766
1767 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1768 LTTV_AFTER_CHUNK_TRACESET,
1769 LTTV_POINTER,
1770 &value);
1771 g_assert(result);
1772
1773 LttvHooks *after_chunk_traceset = (LttvHooks*)*(value.v_pointer);
1774 if(after_chunk_traceset != NULL)
1775 lttv_hooks_destroy(after_chunk_traceset);
1776
1777 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1778 LTTV_AFTER_CHUNK_TRACE,
1779 LTTV_POINTER,
1780 &value);
1781 g_assert(result);
1782
1783 LttvHooks *after_chunk_trace = (LttvHooks*)*(value.v_pointer);
1784 if(after_chunk_trace != NULL)
1785 lttv_hooks_destroy(after_chunk_trace);
1786
1787 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1788 LTTV_AFTER_CHUNK_TRACEFILE,
1789 LTTV_POINTER,
1790 &value);
1791 g_assert(result);
1792
1793 LttvHooks *after_chunk_tracefile = (LttvHooks*)*(value.v_pointer);
1794 if(after_chunk_tracefile != NULL)
1795 lttv_hooks_destroy(after_chunk_tracefile);
1796
1797 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1798 LTTV_BEFORE_REQUEST,
1799 LTTV_POINTER,
1800 &value);
1801 g_assert(result);
1802
1803 LttvHooks *before_request = (LttvHooks*)*(value.v_pointer);
1804 if(before_request != NULL)
1805 lttv_hooks_destroy(before_request);
1806
1807 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1808 LTTV_AFTER_REQUEST,
1809 LTTV_POINTER,
1810 &value);
1811 g_assert(result);
1812
1813 LttvHooks *after_request = (LttvHooks*)*(value.v_pointer);
1814 if(after_request != NULL)
1815 lttv_hooks_destroy(after_request);
1816
1817 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1818 LTTV_EVENT_HOOK,
1819 LTTV_POINTER,
1820 &value);
1821 g_assert(result);
1822
1823 LttvHooks *event_hook = (LttvHooks*)*(value.v_pointer);
1824 if(event_hook != NULL)
1825 lttv_hooks_destroy(event_hook);
1826
1827 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1828 LTTV_EVENT_HOOK_BY_ID,
1829 LTTV_POINTER,
1830 &value);
1831 g_assert(result);
1832
1833 LttvHooksById *event_hook_by_id = (LttvHooksById*)*(value.v_pointer);
1834 if(event_hook_by_id != NULL)
1835 lttv_hooks_by_id_destroy(event_hook_by_id);
1836
1837 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1838 LTTV_HOOK_ADDER,
1839 LTTV_POINTER,
1840 &value);
1841 g_assert(result);
1842
1843 LttvHooks *hook_adder = (LttvHooks*)*(value.v_pointer);
1844 if(hook_adder != NULL)
1845 lttv_hooks_destroy(hook_adder);
1846
1847 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
1848 LTTV_HOOK_REMOVER,
1849 LTTV_POINTER,
1850 &value);
1851 g_assert(result);
1852
1853 LttvHooks *hook_remover = (LttvHooks*)*(value.v_pointer);
1854 if(hook_remover != NULL)
1855 lttv_hooks_destroy(hook_remover);
1856
1857
1858 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1859 LTTV_EVENT_HOOK_BY_ID);
1860 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1861 LTTV_EVENT_HOOK);
1862
1863 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1864 LTTV_AFTER_REQUEST);
1865 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1866 LTTV_BEFORE_REQUEST);
1867
1868 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1869 LTTV_AFTER_CHUNK_TRACEFILE);
1870 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1871 LTTV_AFTER_CHUNK_TRACE);
1872 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1873 LTTV_AFTER_CHUNK_TRACESET);
1874
1875 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1876 LTTV_BEFORE_CHUNK_TRACEFILE);
1877 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1878 LTTV_BEFORE_CHUNK_TRACE);
1879 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1880 LTTV_BEFORE_CHUNK_TRACESET);
1881 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1882 LTTV_HOOK_ADDER);
1883 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1884 LTTV_HOOK_REMOVER);
1885
1886 /* finally, remove module name */
1887 attribute =
1888 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
1889 LTTV_COMPUTATION));
1890 g_assert(attribute);
1891 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1892 module_name);
1893
1894 }
1895
1896 /**
1897 * Lock a trace so no other instance can use it.
1898 *
1899 * @param trace The trace to lock.
1900 * @return 0 on success, -1 if cannot get lock.
1901 */
1902 gint lttvwindowtraces_lock(LttvTrace *trace)
1903 {
1904 LttvAttribute *attribute = lttv_trace_attribute(trace);
1905 LttvAttributeValue value;
1906 LttvAttributeType type;
1907
1908 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1909 LTTV_LOCK,
1910 &value);
1911 /* Verify the absence of the lock. */
1912 if(type != LTTV_NONE) {
1913 g_critical("Cannot take trace lock");
1914 return -1;
1915 }
1916
1917 value = lttv_iattribute_add(LTTV_IATTRIBUTE(attribute),
1918 LTTV_LOCK,
1919 LTTV_INT);
1920 /* the value is left unset. The only presence of the attribute is necessary.
1921 */
1922
1923 return 0;
1924 }
1925
1926 /**
1927 * Unlock a trace.
1928 *
1929 * @param trace The trace to unlock.
1930 * @return 0 on success, -1 if cannot unlock (not locked ?).
1931 */
1932 gint lttvwindowtraces_unlock(LttvTrace *trace)
1933 {
1934 LttvAttribute *attribute = lttv_trace_attribute(trace);
1935 LttvAttributeType type;
1936 LttvAttributeValue value;
1937
1938 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1939 LTTV_LOCK,
1940 &value);
1941 /* Verify the presence of the lock. */
1942 if(type == LTTV_NONE) {
1943 g_critical("Cannot release trace lock");
1944 return -1;
1945 }
1946
1947 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1948 LTTV_LOCK);
1949
1950 return 0;
1951 }
1952
1953 /**
1954 * Verify if a trace is locked.
1955 *
1956 * @param trace The trace to verify.
1957 * @return TRUE if locked, FALSE is unlocked.
1958 */
1959 gint lttvwindowtraces_get_lock_state(LttvTrace *trace)
1960 {
1961 LttvAttribute *attribute = lttv_trace_attribute(trace);
1962 LttvAttributeType type;
1963 LttvAttributeValue value;
1964
1965 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1966 LTTV_LOCK,
1967 &value);
1968 /* The only presence of the attribute is necessary. */
1969 if(type == LTTV_NONE)
1970 return FALSE;
1971 else
1972 return TRUE;
1973 }
1974
LTTng 2.x Viewer (LTTV)
This page took 0.065549 seconds and 3 git commands to generate.