X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fdoc%2Fdeveloper%2Flttvwindow_events_delivery.txt;h=08390a2410ff28e42f2f5c5c3f36df62fd53f994;hb=9087aaaa388495bca8c0458b0e9101740ac406b5;hp=4e77884a96b74a09ad3dc5682808ce6f7b6b939d;hpb=4a97e95bde4dbf593a015c04285dc1f296a35d99;p=lttv.git diff --git a/ltt/branches/poly/doc/developer/lttvwindow_events_delivery.txt b/ltt/branches/poly/doc/developer/lttvwindow_events_delivery.txt index 4e77884a..08390a24 100644 --- a/ltt/branches/poly/doc/developer/lttvwindow_events_delivery.txt +++ b/ltt/branches/poly/doc/developer/lttvwindow_events_delivery.txt @@ -141,16 +141,12 @@ Added to the lttvwindow API : void lttvwindow_events_request -( MainWindow *main_win, - EventsRequest *events_request); - -void lttvwindow_events_request -( MainWindow *main_win, - EventsRequest events_request); +( Tab *tab, + const EventsRequest *events_request); void lttvwindow_events_request_remove_all -( MainWindow *main_win, - gpointer viewer); +( Tab *tab, + gconstpointer viewer); Internal functions : @@ -189,14 +185,6 @@ Background Computation Request The types of background computation that can be requested by a viewer : state computation (main window scope) or viewer specific background computation. -A background computation request is asked via lttvwindow_events_request, with a -priority field set with a low priority. - -If a lttvwindow_events_request_remove_all is done on the viewer pointer, it will -not affect the state computation as no viewer pointer will have been passed in -the initial request. This is the expected result. For the background processings -that call viewer's hooks, they will be removed. - A New "Redraw" Button @@ -236,7 +224,6 @@ requests until there is no more request left. - Implementation @@ -252,24 +239,22 @@ each viewer through process traceset. - lttvwindow_events_request -It adds the an EventsRequest struct to the array of time requests +It adds the an EventsRequest struct to the list of events requests pending and registers a pending request for the next g_idle if none is registered. The viewer can access this structure during the read as its hook_data. Only the stop_flag can be changed by the viewer through the event hooks. -typedef LttvEventsRequestPrio guint; - typedef struct _EventsRequest { - gpointer viewer_data; + gpointer owner; /* Owner of the request */ + gpointer viewer_data; /* Unset : NULL */ gboolean servicing; /* service in progress: TRUE */ - LttvEventsRequestPrio prio; /* Ev. Req. priority */ - LttTime start_time; /* Unset : { 0, 0 } */ - LttvTracesetContextPosition *start_position; /* Unset : num_traces = 0 */ + LttTime start_time;/* Unset : { G_MAXUINT, G_MAXUINT }*/ + LttvTracesetContextPosition *start_position; /* Unset : NULL */ gboolean stop_flag; /* Continue:TRUE Stop:FALSE */ - LttTime end_time; /* Unset : { 0, 0 } */ + LttTime end_time;/* Unset : { G_MAXUINT, G_MAXUINT } */ guint num_events; /* Unset : G_MAXUINT */ - LttvTracesetContextPosition *end_position; /* Unset : num_traces = 0 */ + LttvTracesetContextPosition *end_position; /* Unset : NULL */ LttvHooks *before_traceset; /* Unset : NULL */ LttvHooks *before_trace; /* Unset : NULL */ LttvHooks *before_tracefile;/* Unset : NULL */ @@ -278,18 +263,17 @@ typedef struct _EventsRequest { LttvHooks *after_tracefile; /* Unset : NULL */ LttvHooks *after_trace; /* Unset : NULL */ LttvHooks *after_traceset; /* Unset : NULL */ - LttvHooks *before_chunk; /* Unset : NULL */ - LttvHooks *after_chunk /* Unset : NULL */ + LttvHooks *before_request; /* Unset : NULL */ + LttvHooks *after_request /* Unset : NULL */ } EventsRequest; - - - lttvwindow_events_request_remove_all -It removes all the events requests from the pool that has their "viewer" field -maching the viewer pointer given in argument. +It removes all the events requests from the pool that has their "owner" field +maching the owner pointer given as argument. -It calls the traceset/trace/tracefile end hooks for each request removed. +It calls the traceset/trace/tracefile end hooks for each request removed if +they are currently serviced. - lttvwindow_process_pending_requests @@ -306,11 +290,10 @@ calls. Here is the detailed description of the way it works : The reads are splitted in chunks. After a chunk is over, we want to check if there is a GTK Event pending and execute it. It can add or remove events requests from the event requests list. If it happens, we want to start over -the algorithm from the beginning. - -Two levels of priority exists. High priority and low priority. High prio -requests are serviced first, even if lower priority requests has lower start -time or position. +the algorithm from the beginning. The after traceset/trace/tracefile hooks are +called after each chunk, and before traceset/trace/tracefile are +called when the request processing resumes. Before and after request hooks are +called respectively before and after the request processing. Data structures necessary : @@ -324,18 +307,18 @@ list_in : empty list_out : many events requests -A. While list_in !empty and list_out !empty and !GTK Event pending +// NOT A. While (list_in !empty or list_out !empty) and !GTK Event pending + +We do this once, go back to GTK, then get called again... +We remove the g_idle function when list_in and list_out are empty + 1. If list_in is empty (need a seek) 1.1 Add requests to list_in - 1.1.1 Find all time requests with the highest priority and lowest start - time in list_out (ltime) - 1.1.2 Find all position requests with the highest priority and lowest - position in list_out (lpos) - 1.1.3 If lpos.prio > ltime.prio - || (lpos.prio == ltime.prio && lpos.start time < ltime) + 1.1.1 Find all time requests with lowest start time in list_out (ltime) + 1.1.2 Find all position requests with lowest position in list_out (lpos) + 1.1.3 If lpos.start time < ltime - Add lpos to list_in, remove them from list_out - 1.1.4 Else, (lpos.prio < ltime.prio - ||(lpos.prio == ltime.prio && lpos.start time >= ltime)) + 1.1.4 Else, (lpos.start time >= ltime) - Add ltime to list_in, remove them from list_out 1.2 Seek 1.2.1 If first request in list_in is a time request @@ -343,27 +326,26 @@ A. While list_in !empty and list_out !empty and !GTK Event pending - Seek to that time 1.2.2 Else, the first request in list_in is a position request - If first req in list_in pos != current pos - - If the position is the same than the saved state, restore state - - Else, seek to that position - 1.3 Add hooks and call begin for all list_in members + - seek to that position + 1.3 Add hooks and call before request for all list_in members 1.3.1 If !servicing - - begin hooks called + - begin request hooks called - servicing = TRUE - 1.3.2 call before_chunk + 1.3.2 call before chunk 1.3.3 events hooks added 2. Else, list_in is not empty, we continue a read 2.1 For each req of list_out - if req.start time == current context time - Add to list_in, remove from list_out - If !servicing - - Call begin + - Call before request - servicing = TRUE - - Call before_chunk + - Call before chunk - events hooks added - if req.start position == current position - Add to list_in, remove from list_out - If !servicing - - Call begin + - Call before request - servicing = TRUE - Call before_chunk - events hooks added @@ -372,7 +354,7 @@ A. While list_in !empty and list_out !empty and !GTK Event pending 3.1 End time 3.1.1 Find lowest end time in list_in 3.1.2 Find lowest start time in list_out (>= than current time*) - * To eliminate lower prio requests + * To eliminate lower prio requests (not used) 3.1.3 Use lowest of both as end time 3.2 Number of events 3.2.1 Find lowest number of events in list_in @@ -389,48 +371,40 @@ A. While list_in !empty and list_out !empty and !GTK Event pending 5. After process traceset middle - if current context time > traceset.end time - For each req in list_in - - Call end for req - Remove events hooks for req + - Call end chunk for req + - Call end request for req - remove req from list_in 5.1 For each req in list_in - req.num -= count - if req.num == 0 - - Call end for req - Remove events hooks for req + - Call end chunk for req + - Call end request for req - remove req from list_in - if current context time > req.end time - - Call end for req - Remove events hooks for req + - Call end chunk for req + - Call end request for req - remove req from list_in - if req.end pos == current pos - - Call end for req - Remove events hooks for req + - Call end_chunk for req + - Call end request for req - remove req from list_in - if req.stop_flag == TRUE - - Call end for req - Remove events hooks for req + - Call end chunk for req + - Call end request for req - remove req from list_in - - if exists one events requests in list_out that has - higher priority and time != current time - - Use current position as start position for req - - Remove start time from req - - Call after_chunk for req - - Remove event hooks for req - - Put req back in list_out, remove from list_in - - Save current state into saved_state. - -B. When interrupted + +B. Between each chunk (interrupted or not) 1. for each request in list_in 1.1. Use current postition as start position 1.2. Remove start time - 1.3. Call after_chunk + 1.3. Call after_chunk_traceset 1.4. Remove event hooks 1.5. Put it back in list_out - 2. Save current state into saved_state. - 2.1 Free old saved state. - 2.2 save current state. - - @@ -446,26 +420,12 @@ The >= for position is necessary to make ensure consistency between start time requests and positions requests that happens to be at the exact same start time and position. -We only keep one saved state in memory. If, for example, a low priority -servicing is interrupted, a high priority is serviced, then the low priority -will use the saved state to start back where it was instead of seeking to the -time. In the very specific case where a low priority servicing is interrupted, -and then a high priority servicing on top of it is also interrupted, well, the -low priority will loose its state and will have to seek back. It should not -occur often. The solution to it would be to save one state per priority. - - - Weaknesses -- There is a possibility that we must use seek if more than one interruption - occurs, i.e. low priority interrupted by addition of high priority, and then - high priority interrupted. The seek will be necessary for the low priority. - It could be a good idea to keep one saved_state per priority ? - +- ? Strengths @@ -476,5 +436,3 @@ Strengths - Solves all the weaknesses idenfied in the actual boundaryless traceset reading. -- Background processing available. -