Subject: Re: [linux-audio-dev] A "best" event delegation strategy?
From: Lukas Degener (AFBLukas_AT_gmx.de)
Date: Sun Jun 01 2003 - 16:32:33 EEST
>
>
>
>
>>B) How to implement a lock-free fifo? Or rather: is there some ready to
>>use implementation of it?
>>
>>
>
>i just use RingBuffer<Event*> (assuming you know C++ syntax). pseudo
>code:
>
>delivery:
>
> Event* event;
> event = new Event (arg1, arg2, ...);
> pending_events.write (&event, 1);
>
>receipt:
>
> Event* event;
>
> if (pending_events.read (&event, 1) == 1) {
> process_event (event);
> }
>
>
>
Sorry, i don't seem to understand this completely.
What is the underlying data structure (for pending_events)?
How can be guarantied that the write and read operations are atomic?
What is the second argument of write/read ("1")?
"&event" is a pointer to a pointer? Why not store a pointer to an Event
object?
Or to put it different: What is happening in the read/write methods?
My adhoc (and maybe naive) approach would look something like this
(assuming ++some_ptr is atomic):
Event** read_ptr;
Event** write_ptr;
bool read(Event ** e){
(... on "xrun" return false ...) (*)
*e = *read_ptr;
++read_ptr;
(... wrap arround at end of array ...)
return true;
}
void write(Event ** e){
(... on "xrun" return false ...) (*)
*write_ptr = *e;
++write_ptr;
(... wrap arround at end of array ...)
}
The critical line seems to be the one marked with (*).
How would this be done? Can it be implemented as an "atomic" operation?
To tell the truth, i'm getting pretty much confused when trying to
determine what would be an overrrun and would be an underrun in the
above implementation. I guess a general xrun occurs if either of the two
pointers overtakes the other one. If in the the write method the
write_ptr overtakes the read_ptr, that would be an overrun, if in the
read method the read_ptr overtakes the write_ptr, this would be an
underrun. Is this correct?
And of course this only works with a single reader and a single writer
thread. so if communication has to happen between event sources on
several different threads and a single "event delegation" thread, then
there has to be one fifo for each of the threads that create events. Right?
What happens if this runs on a multi processor system? even if the
operations are atomic, they could happen at the same time than, couldn't
they?
Propably this are very basic issues, and propably i am not the first one
to ask this questions. Please have patience with me :-)
Regards,
Lukas
This archive was generated by hypermail 2b28 : Sun Jun 01 2003 - 16:43:24 EEST