gstreamer/docs/random/matth/scheduling.txt

126 lines
5.2 KiB
Text
Raw Normal View History

-----------------------------------------------------------
- GStreamer Scheduling / Synchronization (incsched) Notes -
-----------------------------------------------------------
These notes describe deadlock scenarios and proposed solutions for
GStreamer. This will be implemented in the INCSCHED1 branch.
I. Miscelaneous proposals
II. Liveness problems (sometimes deadlock ;) and propsed solutions
III. State transition approach and responsibility
MattH.
--------------------------------
- I. Miscalenous proposals -
--------------------------------
1. Change the names of GstThread and GstQueue to GstPtThread and GstPtQueue
for pthread versions of Thread and Queue.
2. Change GstPtQueue to check its pads' peers' managers and make sure
they are different. If not, fail and generate error message. (This
ensures a GstPtQueue straddles a pthread boundary.)
3. Change state transitions to NULL <-> READY <-> PAUSED <-> PLAYING.
---------------------------------------------------
- II. Deadlock Scenarios and Proposed Solutions -
- (in the order they will be implemented) -
---------------------------------------------------
1. A downstream element "waits" for a buffer from its upstream element,
a state change happens and "pauses" the upstream element -- the
downstream element is blocked and cannot execute its change_state.
Note that this can only happen within a single GstPtQueue! Either a
downstream element calls Pull, finds no buffer, and does a
wait_cond(new buffer) or an upstream element calls Push, finds no
room, and does a wait_cond(new room). Thus, GstPtQueue contains all
the cond_wait / signal code.
=> The managing container (thread, pipeline) "wakes" up any sleep
conditions of its "bottom half". (In the scenario described, it
wakes the blocked downstream element's call to Pull.) The GstPtQueue
cond_wait section determines that it woke up due to a pending state
change and does a cothread_switch(0) to return to the main loop,
which then executes the state transition.
Note that a managing container will have only one sleep condition
in its "bottom half."
2. Element "blocked" on getting I/O and cannot execute its change_state.
=> We will provide an I/O library for the elements to use that does
not actually block. (A retry-loop with timeout or select() on
2 -- or more -- file descriptors: one the one you want I/O from,
the other one that GStreamer uses to "wake" everyone up.) The
I/O library determines that it was woken due to a pending state
change and does a cothread_switch(0) to return to the main loop,
which then executes the state transition.
Note that a managing container will have only one elements in
the middle of doing blocking I/O.
3. Element using a library (code out of its control) which blocks for
some reason (e.g., using real blocking I/O) so main loop never gets
run to execute change_state.
=> Build in some timeout in the manging container (the "top half")
when waiting for bottom half to respond to pending state. If
managing container times out, kill the element's thread with a
signal (or series of signals -- escalating priority). This
requires that the element (the "bottom half") have matching
signal handler(s) that execute(s) the state-transition.
--------------------------------------------------------
- III. State-transition Approach and Responsibility -
--------------------------------------------------------
A. The "top half" context of the managing container. (This is likely the
context of the application.)
Call change_state on the managing container (GstPipeline, GstPtThread).
If its "bottom half" (main_loop) is asleep, signal the condition to
wake it up. Then do a cond_wait for the "bottom half" to execute the
state transition and return (once the state has been changed).
B. The main_loop (the "bottom half") of the managing container.
Needs to check for pending state transition after every switch back from
one of its elements. If a pending state is found, it calls change_state
on each of its elements, signals the "top half" that the state has been
changed, then continues executing the plan (if Playing) or puts itself
to sleep (Paused, Ready).
C. Element.
Implement a change_state function to make transition for that element.
The elements' change_state is what actually changes the state variable
and notifies the scheduler that the state was changed. This function
may also do things like close or open resources.
NOTE: when an element goes through certain state transitions (e.g., from
Paused to Ready) its state (stack) will be wiped out. If it wants to
preserve any state or data, it needs to store the information in a safe
place.
D. Cothread Scheduler.
Gets notified of state transition by elements' change_state functions
then (re)set the plan accordingly. Assuming
NULL <-> READY <-> PAUSED <-> PLAYING, some would be
+ Paused -> Playing: jump back where you were in the Plan and continue
its execution
+ Ready -> Paused: reset the cothread pointers foreach cothread in the
Plan (don't run)