#include "cfv.h"
#include "processlist.h"
#include "drawing.h"
-#include "cfv-private.h"
#define MAX_PATH_LEN 256
control_flow_data->tab = tab;
- //g_debug("time width2 : %u",time_window->time_width);
// Unreg done in the GuiControlFlow_Destructor
lttvwindow_register_traceset_notify(tab,
traceset_notify,
}
/* Function that selects the color of status&exemode line */
-static __inline__ PropertiesLine prepare_s_e_line(LttvProcessState *process)
+static inline PropertiesLine prepare_s_e_line(LttvProcessState *process)
{
PropertiesLine prop_line;
prop_line.line_width = 2;
}
#if 0
-static __inline__ PropertiesLine prepare_status_line(LttvProcessState *process)
+static inline PropertiesLine prepare_status_line(LttvProcessState *process)
{
PropertiesLine prop_line;
prop_line.line_width = 2;
{
EventsRequest *events_request = (EventsRequest*)hook_data;
ControlFlowData *control_flow_data = events_request->viewer_data;
- Drawing_t *drawing = control_flow_data->drawing;
LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts =(LttvTraceState *)((LttvTracefileContext*)tfs)->t_context;
LttEvent *e;
e = tfc->e;
LttTime evtime = ltt_event_time(e);
- guint width = drawing->width;
-
/* we are in a schedchange, before the state update. We must draw the
* items corresponding to the state before it changes : now is the right
* time to do it.
* present, it's a new process and it was not present : it will
* be added after the state update. */
LttvProcessState *process;
- process = lttv_state_find_process(tfs, pid_out);
- //process = tfs->process;
+ /* unknown state, bad current pid */
+ if(tfs->process->pid != pid_out)
+ process = lttv_state_find_process(tfs, pid_out);
+ else
+ process = tfs->process;
if(process != NULL) {
/* Well, the process_out existed : we must get it in the process hash
ProcessList *process_list = control_flow_data->process_list;
LttTime birth = process->creation_time;
- if(processlist_get_process_pixels(process_list,
+ hashed_process_data = processlist_get_process_data(process_list,
pid_out,
- process->last_cpu,
+ process->last_cpu_index,
&birth,
- tfc->t_context->index,
- &y,
- &height,
- &hashed_process_data) == 1)
+ tfc->t_context->index);
+ if(hashed_process_data == NULL)
{
g_assert(pid_out == 0 || pid_out != process->ppid);
const gchar *name = g_quark_to_string(process->name);
ProcessInfo *process_info;
processlist_add(process_list,
pid_out,
- process->last_cpu,
+ process->last_cpu_index,
process->ppid,
&birth,
tfc->t_context->index,
&process_info,
&hashed_process_data);
processlist_get_pixels_from_data(process_list,
- process_info,
hashed_process_data,
&y,
&height);
- drawing_insert_square( drawing, y, height);
+ drawing_insert_square( control_flow_data->drawing, y, height);
}
-
+
/* Now, the process is in the state hash and our own process hash.
* We definitely can draw the items related to the ending state.
*/
evtime) > 0)
{
if(hashed_process_data->x.middle_marked == FALSE) {
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
#ifdef EXTRA_CHECK
|| ltt_time_compare(evtime, time_window.end_time) == 1)
return;
#endif //EXTRA_CHECK
-
+ Drawing_t *drawing = control_flow_data->drawing;
+ guint width = drawing->width;
guint x;
convert_time_to_pixels(
time_window,
hashed_process_data->x.middle_marked = TRUE;
}
} else {
- TimeWindow time_window =
- lttvwindow_get_time_window(control_flow_data->tab);
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+
+
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
#ifdef EXTRA_CHECK
- if(ltt_time_compare(evtime, time_window.start_time) == -1
- || ltt_time_compare(evtime, time_window.end_time) == 1)
- return;
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
#endif //EXTRA_CHECK
-
+ Drawing_t *drawing = control_flow_data->drawing;
+ guint width = drawing->width;
guint x;
convert_time_to_pixels(
time_window,
ProcessList *process_list = control_flow_data->process_list;
LttTime birth = process->creation_time;
- if(processlist_get_process_pixels(process_list,
+ hashed_process_data = processlist_get_process_data(process_list,
pid_in,
- process->last_cpu,
+ process->last_cpu_index,
&birth,
- tfc->t_context->index,
- &y,
- &height,
- &hashed_process_data) == 1)
+ tfc->t_context->index);
+ if(hashed_process_data == NULL)
{
g_assert(pid_in == 0 || pid_in != process->ppid);
const gchar *name = g_quark_to_string(process->name);
ProcessInfo *process_info;
processlist_add(process_list,
pid_in,
- process->last_cpu,
+ process->last_cpu_index,
process->ppid,
&birth,
tfc->t_context->index,
&process_info,
&hashed_process_data);
processlist_get_pixels_from_data(process_list,
- process_info,
hashed_process_data,
&y,
&height);
- drawing_insert_square( drawing, y, height);
+ drawing_insert_square( control_flow_data->drawing, y, height);
}
+ //We could set the current process and hash here, but will be done
+ //by after schedchange hook
/* Now, the process is in the state hash and our own process hash.
* We definitely can draw the items related to the ending state.
evtime) > 0)
{
if(hashed_process_data->x.middle_marked == FALSE) {
+
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
#ifdef EXTRA_CHECK
|| ltt_time_compare(evtime, time_window.end_time) == 1)
return;
#endif //EXTRA_CHECK
+ Drawing_t *drawing = control_flow_data->drawing;
+ guint width = drawing->width;
guint x;
convert_time_to_pixels(
time_window,
hashed_process_data->x.middle_marked = TRUE;
}
} else {
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
#ifdef EXTRA_CHECK
|| ltt_time_compare(evtime, time_window.end_time) == 1)
return;
#endif //EXTRA_CHECK
+ Drawing_t *drawing = control_flow_data->drawing;
+ guint width = drawing->width;
guint x;
convert_time_to_pixels(
LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts =(LttvTraceState *)((LttvTracefileContext*)tfs)->t_context;
LttEvent *e;
e = tfc->e;
LttTime evtime = ltt_event_time(e);
- guint width = control_flow_data->drawing->width;
-
/* Add process to process list (if not present) */
LttvProcessState *process_out, *process_in;
LttTime birth;
/* Find process pid_in in the list... */
- process_in = lttv_state_find_process(tfs, pid_in);
+ //process_in = lttv_state_find_process(tfs, pid_in);
+ process_in = tfs->process;
/* It should exist, because we are after the state update. */
+#ifdef EXTRA_CHECK
g_assert(process_in != NULL);
-
+#endif //EXTRA_CHECK
birth = process_in->creation_time;
- if(processlist_get_process_pixels(process_list,
+ hashed_process_data_in = processlist_get_process_data(process_list,
pid_in,
- process_in->last_cpu,
+ process_in->last_cpu_index,
&birth,
- tfc->t_context->index,
- &y_in,
- &height,
- &hashed_process_data_in) == 1)
+ tfc->t_context->index);
+ if(hashed_process_data_in == NULL)
{
g_assert(pid_in == 0 || pid_in != process_in->ppid);
const gchar *name = g_quark_to_string(process_in->name);
/* Process not present */
processlist_add(process_list,
pid_in,
- process_in->last_cpu,
+ process_in->last_cpu_index,
process_in->ppid,
&birth,
tfc->t_context->index,
&process_info,
&hashed_process_data_in);
processlist_get_pixels_from_data(process_list,
- process_info,
hashed_process_data_in,
&y_in,
&height);
drawing_insert_square( control_flow_data->drawing, y_in, height);
}
+ /* Set the current process */
+ process_list->current_hash_data[process_in->last_cpu_index] =
+ hashed_process_data_in;
if(ltt_time_compare(hashed_process_data_in->next_good_time,
evtime) <= 0)
{
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data_in,
+ &y_in,
+ &height);
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
|| ltt_time_compare(evtime, time_window.end_time) == 1)
return;
#endif //EXTRA_CHECK
-
+ Drawing_t *drawing = control_flow_data->drawing;
+ guint width = drawing->width;
guint new_x;
convert_time_to_pixels(
}
#if 0
-static __inline__ PropertiesLine prepare_execmode_line(LttvProcessState *process)
+static inline PropertiesLine prepare_execmode_line(LttvProcessState *process)
{
PropertiesLine prop_line;
prop_line.line_width = 1;
{
EventsRequest *events_request = (EventsRequest*)hook_data;
ControlFlowData *control_flow_data = events_request->viewer_data;
- Drawing_t *drawing = control_flow_data->drawing;
LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts =(LttvTraceState *)((LttvTracefileContext*)tfs)->t_context;
LttEvent *e;
e = tfc->e;
LttTime evtime = ltt_event_time(e);
- guint width = drawing->width;
/* we are in a execmode, before the state update. We must draw the
* items corresponding to the state before it changes : now is the right
HashedProcessData *hashed_process_data = NULL;
ProcessList *process_list = control_flow_data->process_list;
LttTime birth = process->creation_time;
-
- if(processlist_get_process_pixels(process_list,
+
+ if(process_list->current_hash_data[tfc->index] != NULL) {
+ hashed_process_data = process_list->current_hash_data[tfc->index];
+ } else {
+ hashed_process_data = processlist_get_process_data(process_list,
+ pid,
+ process->last_cpu_index,
+ &birth,
+ tfc->t_context->index);
+ if(hashed_process_data == NULL)
+ {
+ g_assert(pid == 0 || pid != process->ppid);
+ ProcessInfo *process_info;
+ /* Process not present */
+ const gchar *name = g_quark_to_string(process->name);
+ processlist_add(process_list,
pid,
- process->last_cpu,
+ process->last_cpu_index,
+ process->ppid,
&birth,
tfc->t_context->index,
- &y,
- &height,
- &hashed_process_data) == 1)
- {
- g_assert(pid == 0 || pid != process->ppid);
- ProcessInfo *process_info;
- /* Process not present */
- const gchar *name = g_quark_to_string(process->name);
- processlist_add(process_list,
- pid,
- process->last_cpu,
- process->ppid,
- &birth,
- tfc->t_context->index,
- name,
- &pl_height,
- &process_info,
- &hashed_process_data);
- processlist_get_pixels_from_data(process_list,
- process_info,
- hashed_process_data,
- &y,
- &height);
- drawing_insert_square( drawing, y, height);
+ name,
+ &pl_height,
+ &process_info,
+ &hashed_process_data);
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+ drawing_insert_square( control_flow_data->drawing, y, height);
+ }
+ /* Set the current process */
+ process_list->current_hash_data[process->last_cpu_index] =
+ hashed_process_data;
}
/* Now, the process is in the state hash and our own process hash.
evtime) > 0)
{
if(hashed_process_data->x.middle_marked == FALSE) {
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
|| ltt_time_compare(evtime, time_window.end_time) == 1)
return;
#endif //EXTRA_CHECK
+ Drawing_t *drawing = control_flow_data->drawing;
+ guint width = drawing->width;
guint x;
convert_time_to_pixels(
time_window,
hashed_process_data->x.middle_marked = TRUE;
}
} else {
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
|| ltt_time_compare(evtime, time_window.end_time) == 1)
return;
#endif //EXTRA_CHECK
+ Drawing_t *drawing = control_flow_data->drawing;
+ guint width = drawing->width;
guint x;
convert_time_to_pixels(
*/
int after_execmode_hook(void *hook_data, void *call_data)
{
+ /**************** DOES NOTHING!! *************/
+ /* hook desactivated in drawing.c */
+ return 0;
+
+
+
EventsRequest *events_request = (EventsRequest*)hook_data;
ControlFlowData *control_flow_data = events_request->viewer_data;
LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts =(LttvTraceState *)((LttvTracefileContext*)tfs)->t_context;
LttEvent *e;
e = tfc->e;
LttTime evtime = ltt_event_time(e);
- guint width = control_flow_data->drawing->width;
/* Add process to process list (if not present) */
LttvProcessState *process;
birth = process->creation_time;
- if(processlist_get_process_pixels(process_list,
+ if(process_list->current_hash_data[tfc->index] != NULL) {
+ hashed_process_data = process_list->current_hash_data[tfc->index];
+ } else {
+ hashed_process_data = processlist_get_process_data(process_list,
+ pid,
+ process->last_cpu_index,
+ &birth,
+ tfc->t_context->index);
+ if(hashed_process_data == NULL)
+ {
+ g_assert(pid == 0 || pid != process->ppid);
+ /* Process not present */
+ const gchar *name = g_quark_to_string(process->name);
+ ProcessInfo *process_info;
+ processlist_add(process_list,
pid,
- process->last_cpu,
+ process->last_cpu_index,
+ process->ppid,
&birth,
tfc->t_context->index,
- &y,
- &height,
- &hashed_process_data) == 1)
+ name,
+ &pl_height,
+ &process_info,
+ &hashed_process_data);
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+ drawing_insert_square( control_flow_data->drawing, y, height);
+ }
+ /* Set the current process */
+ process_list->current_hash_data[process->last_cpu_index] =
+ hashed_process_data;
+ }
+
+ if(ltt_time_compare(hashed_process_data->next_good_time,
+ evtime) <= 0)
{
- g_assert(pid == 0 || pid != process->ppid);
- /* Process not present */
- const gchar *name = g_quark_to_string(process->name);
- ProcessInfo *process_info;
- processlist_add(process_list,
- pid,
- process->last_cpu,
- process->ppid,
- &birth,
- tfc->t_context->index,
- name,
- &pl_height,
- &process_info,
- &hashed_process_data);
+#if 0
processlist_get_pixels_from_data(process_list,
- process_info,
hashed_process_data,
&y,
&height);
- drawing_insert_square( control_flow_data->drawing, y, height);
- }
-
- if(ltt_time_compare(hashed_process_data->next_good_time,
- evtime) <= 0)
- {
+#endif //0
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
|| ltt_time_compare(evtime, time_window.end_time) == 1)
return;
#endif //EXTRA_CHECK
-
-
+ Drawing_t *drawing = control_flow_data->drawing;
+ guint width = drawing->width;
guint new_x;
convert_time_to_pixels(
{
EventsRequest *events_request = (EventsRequest*)hook_data;
ControlFlowData *control_flow_data = events_request->viewer_data;
- Drawing_t *drawing = control_flow_data->drawing;
LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts =(LttvTraceState *)((LttvTracefileContext*)tfs)->t_context;
LttEvent *e;
e = tfc->e;
LttTime evtime = ltt_event_time(e);
- guint width = control_flow_data->drawing->width;
guint sub_id;
{
birth = process->creation_time;
- if(processlist_get_process_pixels(process_list,
+ if(process_list->current_hash_data[tfc->index] != NULL) {
+ hashed_process_data = process_list->current_hash_data[tfc->index];
+ } else {
+ hashed_process_data = processlist_get_process_data(process_list,
+ pid,
+ process->last_cpu_index,
+ &birth,
+ tfc->t_context->index);
+ if(hashed_process_data == NULL)
+ {
+ g_assert(pid == 0 || pid != process->ppid);
+ /* Process not present */
+ const gchar *name = g_quark_to_string(process->name);
+ ProcessInfo *process_info;
+ processlist_add(process_list,
pid,
- process->last_cpu,
+ process->last_cpu_index,
+ process->ppid,
&birth,
tfc->t_context->index,
- &y,
- &height,
- &hashed_process_data) == 1)
- {
- g_assert(pid == 0 || pid != process->ppid);
- /* Process not present */
- const gchar *name = g_quark_to_string(process->name);
- ProcessInfo *process_info;
- processlist_add(process_list,
- pid,
- process->last_cpu,
- process->ppid,
- &birth,
- tfc->t_context->index,
- name,
- &pl_height,
- &process_info,
- &hashed_process_data);
- processlist_get_pixels_from_data(process_list,
- process_info,
- hashed_process_data,
- &y,
- &height);
- drawing_insert_square( control_flow_data->drawing, y, height);
+ name,
+ &pl_height,
+ &process_info,
+ &hashed_process_data);
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+ drawing_insert_square( control_flow_data->drawing, y, height);
+ }
}
/* Now, the process is in the state hash and our own process hash.
evtime) > 0)
{
if(hashed_process_data->x.middle_marked == FALSE) {
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
|| ltt_time_compare(evtime, time_window.end_time) == 1)
return;
#endif //EXTRA_CHECK
-
+ Drawing_t *drawing = control_flow_data->drawing;
+ guint width = drawing->width;
guint x;
convert_time_to_pixels(
time_window,
hashed_process_data->x.middle_marked = TRUE;
}
} else {
- TimeWindow time_window =
- lttvwindow_get_time_window(control_flow_data->tab);
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
#ifdef EXTRA_CHECK
- if(ltt_time_compare(evtime, time_window.start_time) == -1
- || ltt_time_compare(evtime, time_window.end_time) == 1)
- return;
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
#endif //EXTRA_CHECK
-
+ Drawing_t *drawing = control_flow_data->drawing;
+ guint width = drawing->width;
guint x;
convert_time_to_pixels(
LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts =(LttvTraceState *)((LttvTracefileContext*)tfs)->t_context;
LttEvent *e;
e = tfc->e;
LttTime evtime = ltt_event_time(e);
- guint width = control_flow_data->drawing->width;
guint sub_id;
guint param1;
birth = process_child->creation_time;
- if(processlist_get_process_pixels(process_list,
+ hashed_process_data_child = processlist_get_process_data(process_list,
child_pid,
- process_child->last_cpu,
+ process_child->last_cpu_index,
&birth,
- tfc->t_context->index,
- &y_child,
- &height,
- &hashed_process_data_child) == 1)
+ tfc->t_context->index);
+ if(hashed_process_data_child == NULL)
{
g_assert(child_pid == 0 || child_pid != process_child->ppid);
/* Process not present */
ProcessInfo *process_info;
processlist_add(process_list,
child_pid,
- process_child->last_cpu,
+ process_child->last_cpu_index,
process_child->ppid,
&birth,
tfc->t_context->index,
&process_info,
&hashed_process_data_child);
processlist_get_pixels_from_data(process_list,
- process_info,
hashed_process_data_child,
&y_child,
&height);
drawing_insert_square( control_flow_data->drawing, y_child, height);
}
+
if(ltt_time_compare(hashed_process_data_child->next_good_time,
evtime) <= 0)
{
+#if 0
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data_child,
+ &y_child,
+ &height);
+#endif //0
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
|| ltt_time_compare(evtime, time_window.end_time) == 1)
return;
#endif //EXTRA_CHECK
-
+ Drawing_t *drawing = control_flow_data->drawing;
+ guint width = drawing->width;
guint new_x;
convert_time_to_pixels(
time_window,
birth = process->creation_time;
- if(processlist_get_process_pixels(process_list,
+ if(process_list->current_hash_data[tfc->index] != NULL) {
+ hashed_process_data = process_list->current_hash_data[tfc->index];
+ } else {
+ hashed_process_data = processlist_get_process_data(process_list,
+ pid,
+ process->last_cpu_index,
+ &birth,
+ tfc->t_context->index);
+ if(hashed_process_data == NULL)
+ {
+ g_assert(pid == 0 || pid != process->ppid);
+ /* Process not present */
+ const gchar *name = g_quark_to_string(process->name);
+ ProcessInfo *process_info;
+ processlist_add(process_list,
pid,
- process->last_cpu,
+ process->last_cpu_index,
+ process->ppid,
&birth,
tfc->t_context->index,
- &y,
- &height,
- &hashed_process_data) == 1)
- {
- g_assert(pid == 0 || pid != process->ppid);
- /* Process not present */
- const gchar *name = g_quark_to_string(process->name);
- ProcessInfo *process_info;
- processlist_add(process_list,
- pid,
- process->last_cpu,
- process->ppid,
- &birth,
- tfc->t_context->index,
- name,
- &pl_height,
- &process_info,
- &hashed_process_data);
- processlist_get_pixels_from_data(process_list,
- process_info,
- hashed_process_data,
- &y,
- &height);
- drawing_insert_square( control_flow_data->drawing, y, height);
+ name,
+ &pl_height,
+ &process_info,
+ &hashed_process_data);
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+ drawing_insert_square( control_flow_data->drawing, y, height);
+ }
+
+ /* Set the current process */
+ process_list->current_hash_data[process->last_cpu_index] =
+ hashed_process_data;
}
if(ltt_time_compare(hashed_process_data->next_good_time,
evtime) <= 0)
{
+#if 0
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+#endif //0
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
|| ltt_time_compare(evtime, time_window.end_time) == 1)
return;
#endif //EXTRA_CHECK
-
+ Drawing_t *drawing = control_flow_data->drawing;
+ guint width = drawing->width;
guint new_x;
convert_time_to_pixels(
time_window,
EventsRequest *events_request = closure_data->events_request;
ControlFlowData *control_flow_data = events_request->viewer_data;
- Drawing_t *drawing = control_flow_data->drawing;
LttvTracesetState *tss = closure_data->tss;
- LttvTracesetContext *tsc = (LttvTracesetContext*)closure_data->tss;
+ LttvTracesetContext *tsc = (LttvTracesetContext*)tss;
LttTime evtime = closure_data->end_time;
- guint width = drawing->width;
{
/* For the process */
if(control_flow_data->background_info_waiting==0)
g_assert(ltt_time_compare(process->creation_time,
process_info->birth) == 0);
- const gchar *name = g_quark_to_string(process->name);
-
/* process HAS to be present */
processlist_get_pixels_from_data(process_list,
- process_info,
hashed_process_data,
&y,
&height);
|| ltt_time_compare(evtime, time_window.end_time) == 1)
return;
#endif //EXTRA_CHECK
+ Drawing_t *drawing = control_flow_data->drawing;
+ guint width = drawing->width;
guint x;
convert_time_to_pixels(
ProcessList *process_list = control_flow_data->process_list;
+ g_free(process_list->current_hash_data);
+ process_list->current_hash_data = NULL;
+
if(tfc != NULL)
end_time = LTT_TIME_MIN(tfc->timestamp, events_request->end_time);
else /* end of traceset, or position now out of request : end */
projects / lttv.git / blobdiff