1 Dec
2009
1 Dec
'09
10:23 p.m.
Hi everyone,
I just started writing my first c++ program, and I'm kind of stuck with
something I cannot understand. After a few days of trying to figure this
out, I decided to ask for more professional help. I'm working on a kind
of arpeggiator for linux (which I intend to release under GPL).
The program uses a text file, in which the user can specify a number of
arpeggios. Each arpeggio is loaded into an object called 'Arp',
and for every Arp I make a jack port, and a ringbuffer.
(the port and ringbuffer are stored in an object called Arp_jack)
A seperate thread, watches the text file for modifications (using
inotify), and every time the file is changed, the file is loaded afresh,
and the new Arps are put in the respective ringbuffers. The ringbuffers
have a size of two Arps, and the idea is that when a new Arp arrives,
the old one is discarded. If there is only one Arp in the buffer, the
program keeps on reading the same one.
This code is part of the inotify thread:
while (i < len)
{
struct inotify_event *event;
event = (struct inotify_event *) &buf[i];
if ( event->wd == wd )
{
vector<Arp>* arps = new vector<Arp> ;
read_load_file( arps ) ;
for( uint x = 0; x < arps->size(); x++ )
{
const char* arp_char = reinterpret_cast<const char*>(&(*arps)[x]);
jack_ringbuffer_write( (*ARPS_JACK)[x].rb, arp_char, sizeof( Arp ));
}
//delete arps ;
}
The next code fragment comes from the process callback. As you can see,
I'm using jack_ringbuffer_get_read_vector to read the raw data, and I
advance the the read pointer when a new arp is available:
if( (jack_ringbuffer_read_space( (*arps_jack)[i].rb ) ) ==
(sizeof( Arp ) * 2) )
{
jack_ringbuffer_read_advance( (*arps_jack)[i].rb, sizeof(Arp) ) ;
}
if( (jack_ringbuffer_read_space( (*arps_jack)[i].rb ) ) ==
sizeof( Arp ) )
{
jack_ringbuffer_data_t data[2] ;
jack_ringbuffer_get_read_vector( (*arps_jack)[i].rb, data ) ;
if ( data[0].len > 0 )
{
arp = reinterpret_cast<Arp*>( data[0].buf ) ;
steps = &arp->steps ;
scale = &arp->scale ;
}
else if( data[1].len > 0)
{
cout << "data in second part of ringbuffer, this should not
happen!" << endl ;
}
....
Now to the question. The code works as I expect, as long as I don't
delete the vector of arps in the inotify thread (see the commented
line). When I do delete the vector, the program segfaults.
(and also when I allocate the vector on the stack, and it gets cleaned
up automatically)
I thought that writing to the ringbuffer with jack_ringbuffer_write
copies the data to the ringbuffer, so I don't understand why this should
have an influence. Is it a problem that I put the ringbuffer in
an object which is accessed by two different threads without using a
mutex? I've tried using a mutex,but I still had the segmentation fault.
Any help with this would be really appreciated.
Thanks for your help,
Lieven
1 Dec
1 Dec
10:37 p.m.
On Tue, Dec 1, 2009 at 9:22 PM, lieven moors <lievenmoors(a)gmail.com> wrote:
if( (jack_ringbuffer_read_space( (*arps_jack)[i].rb )
) ==
(sizeof( Arp ) * 2) )
{
jack_ringbuffer_read_advance( (*arps_jack)[i].rb, sizeof(Arp) ) ;
}
You've just moved the read ptrs, before reading any data. Why did you
check to see if there were 2 Arp structures available, and then skip
one of them?
if( (jack_ringbuffer_read_space( (*arps_jack)[i].rb )
) ==
sizeof( Arp ) )
this won't return true unless there ONLY one Arp struct to read.
{
jack_ringbuffer_data_t data[2] ;
jack_ringbuffer_get_read_vector( (*arps_jack)[i].rb, data ) ;
now you've got a read vector, but *after* you advanced the read ptr.
if ( data[0].len > 0 )
{
arp = reinterpret_cast<Arp*>( data[0].buf ) ;
steps = &arp->steps ;
scale = &arp->scale ;
}
else if( data[1].len > 0)
{
cout << "data in second part of ringbuffer, this should not
happen!" << endl ;
}
now you've used the data from the ringbuffer, but not advanced the read ptr.
if you're going to use get_read_vector() you want to do that first,
then explicitly advanced the read ptr.
not sure if this is all that is going wrong, but this looks odd/wrong
to me as a starting point.
10:51 p.m.
Paul Davis wrote:
On Tue, Dec 1, 2009 at 9:22 PM, lieven moors
<lievenmoors(a)gmail.com> wrote:
I want to repeat the same Arp, until there is an update to the text
file. One arp is allready
loaded in each ringbuffer in main(). When the file is modified, a second
one is added, and
process skips to the second one. Since I have only space for two arps in
the buffer, there
should always be exactly one which is readable. I know it is a bit
weird, but it seems to
work, apart from the problem I described.
if( (jack_ringbuffer_read_space(
(*arps_jack)[i].rb ) ) ==
(sizeof( Arp ) * 2) )
{
jack_ringbuffer_read_advance( (*arps_jack)[i].rb, sizeof(Arp) ) ;
}
You've just moved the read ptrs, before reading any data. Why did you
check to see if there were 2 Arp structures available, and then skip
one of them?
if( (jack_ringbuffer_read_space(
(*arps_jack)[i].rb ) ) ==
sizeof( Arp ) )
this won't return true unless there ONLY one Arp struct to read.
{
jack_ringbuffer_data_t data[2] ;
jack_ringbuffer_get_read_vector( (*arps_jack)[i].rb, data ) ;
now you've got a read vector, but *after* you advanced the read ptr.
if ( data[0].len > 0 )
{
arp = reinterpret_cast<Arp*>( data[0].buf ) ;
steps = &arp->steps ;
scale = &arp->scale ;
}
else if( data[1].len > 0)
{
cout << "data in second part of ringbuffer, this should not
happen!" << endl ;
}
now you've used the data from the ringbuffer, but not advanced the read ptr.
if you're going to use get_read_vector() you want to do that first,
then explicitly advanced the read ptr.
not sure if this is all that is going wrong, but this looks odd/wrong
to me as a starting point.
11:11 p.m.
On Tue, Dec 1, 2009 at 9:51 PM, lieven moors <lievenmoors(a)gmail.com> wrote:
I want to repeat the same Arp, until there is an
update to the text file.
One arp is allready
loaded in each ringbuffer in main(). When the file is modified, a second one
is added, and
process skips to the second one. Since I have only space for two arps in the
buffer, there
should always be exactly one which is readable. I know it is a bit weird,
but it seems to
work, apart from the problem I described.
sounds as if you might want to look into atomic pointer and/or integer
exchange instead, to get lock-free double buffering.
ringbuffers are generally for passing streaming data/events.
11:28 p.m.
Paul Davis wrote:
On Tue, Dec 1, 2009 at 9:51 PM, lieven moors
<lievenmoors(a)gmail.com> wrote:
I have no idea what that means, but I'll look into this.
Thanks for the tip.
I want to repeat the same Arp, until there is an
update to the text file.
One arp is allready
loaded in each ringbuffer in main(). When the file is modified, a second one
is added, and
process skips to the second one. Since I have only space for two arps in the
buffer, there
should always be exactly one which is readable. I know it is a bit weird,
but it seems to
work, apart from the problem I described.
sounds as if you might want to look into atomic pointer and/or integer
exchange instead, to get lock-free double buffering.
ringbuffers are generally for passing streaming data/events.
2 Dec
2 Dec
11:33 a.m.
Paul Davis wrote:
On Tue, Dec 1, 2009 at 9:51 PM, lieven moors
<lievenmoors(a)gmail.com> wrote:
Could you give me a hint on how to use atomic pointers?
Should I use __sync_val_compare_and_swap from GCC?
I've been looking around for other libraries, but I'm not sure where to
start.
Also, what did you mean with 'integer exchange'?
Is it yet another way of using CAS?
Thanks in advance,
Lieven
||
I want to repeat the same Arp, until there is an
update to the text file.
One arp is allready
loaded in each ringbuffer in main(). When the file is modified, a second one
is added, and
process skips to the second one. Since I have only space for two arps in the
buffer, there
should always be exactly one which is readable. I know it is a bit weird,
but it seems to
work, apart from the problem I described.
sounds as if you might want to look into atomic pointer and/or integer
exchange instead, to get lock-free double buffering.
ringbuffers are generally for passing streaming data/events.
3 Dec
3 Dec
1:32 a.m.
On Dec 2, 2009, at 7:33 AM, lieven moors wrote:
Paul Davis wrote:
All of that stuff is great to learn about, but on the other
hand, you've already got the hang of the ringbuffer API -- why
not just use that? The way I usually deal with this sort of
thing is to have two ringbuffers, one from the worker thread to
the process thread, and one from the process thread back to the
worker thread. Worker (inotify) thread creates a new Arp, and
passes a pointer to it through the ring buffer to the process
thread. Process thread then reads the new Arp pointer from the
first ringbuffer, begins to use it, and passes a pointer to the
old Arp back through the second ringbuffer to the worker thread.
Worker thread then reads the old Arp pointer from the second
ringbuffer, and frees or reuses it.
Disadvantage to this is it's not quite as efficient as an atomic
pointer exchange, but the advantage is you've already got everything
you need right there in jack, no need for an extra library.
HTH,
-Sean
On Tue, Dec 1, 2009 at 9:51 PM, lieven moors
<lievenmoors(a)gmail.com> wrote:
Could you give me a hint on how to use atomic pointers?
Should I use __sync_val_compare_and_swap from GCC?
I've been looking around for other libraries, but I'm not sure
where to
start.
Also, what did you mean with 'integer exchange'?
Is it yet another way of using CAS? I want to repeat the same Arp, until there is an
update to the
text file.
One arp is allready
loaded in each ringbuffer in main(). When the file is modified, a
second one
is added, and
process skips to the second one. Since I have only space for two
arps in the
buffer, there
should always be exactly one which is readable. I know it is a
bit weird,
but it seems to
work, apart from the problem I described.
sounds as if you might want to look into atomic pointer and/or
integer
exchange instead, to get lock-free double buffering.
ringbuffers are generally for passing streaming data/events.
9:14 a.m.
Sean Bolton wrote:
On Dec 2, 2009, at 7:33 AM, lieven moors wrote:
Thanks very much for your reply!
I was reluctant to start using atomic pointers,
because I might change the program later to
read longer sequences of Arps. So the ringbuffer approach
might be a good choice after all.
I think your idea is exactly what I was looking for.
Thanks again,
Greetings,
Lieven
P.S.
I would love to see a simple (maybe fake) example of how to use
atomic pointers though, because I only have a vague
idea of how they are used in practice... Anyone?
Paul Davis wrote:
All of that stuff is great to learn about, but on the other
hand, you've already got the hang of the ringbuffer API -- why
not just use that? The way I usually deal with this sort of
thing is to have two ringbuffers, one from the worker thread to
the process thread, and one from the process thread back to the
worker thread. Worker (inotify) thread creates a new Arp, and
passes a pointer to it through the ring buffer to the process
thread. Process thread then reads the new Arp pointer from the
first ringbuffer, begins to use it, and passes a pointer to the
old Arp back through the second ringbuffer to the worker thread.
Worker thread then reads the old Arp pointer from the second
ringbuffer, and frees or reuses it.
Disadvantage to this is it's not quite as efficient as an atomic
pointer exchange, but the advantage is you've already got everything
you need right there in jack, no need for an extra library.
HTH,
-Sean
On Tue, Dec 1, 2009 at 9:51 PM, lieven moors
<lievenmoors(a)gmail.com>
wrote:
Could you give me a hint on how to use atomic pointers?
Should I use __sync_val_compare_and_swap from GCC?
I've been looking around for other libraries, but I'm not sure where to
start.
Also, what did you mean with 'integer exchange'?
Is it yet another way of using CAS? I want to repeat the same Arp, until there is an
update to the text
file.
One arp is allready
loaded in each ringbuffer in main(). When the file is modified, a
second one
is added, and
process skips to the second one. Since I have only space for two
arps in the
buffer, there
should always be exactly one which is readable. I know it is a bit
weird,
but it seems to
work, apart from the problem I described.
sounds as if you might want to look into atomic pointer and/or integer
exchange instead, to get lock-free double buffering.
ringbuffers are generally for passing streaming data/events.
10:39 a.m.
On Thu, Dec 3, 2009 at 8:14 AM, lieven moors <lievenmoors(a)gmail.com> wrote:
Thanks very much for your reply!
I was reluctant to start using atomic pointers,
because I might change the program later to
read longer sequences of Arps. So the ringbuffer approach
might be a good choice after all.
I think your idea is exactly what I was looking for.
I was going to suggest the same exact thing as Sean. With the 2
ringbuffers, you're guaranteed that your RT thread is no longer
looking at the old Arp object. You're basically implementing message
passing, while still taking advantage of the threads' shared memory
(where the Arp object resides).
With an atomic pointer swap, I don't think you're guaranteed that.
Each access to the address of the old Arp object would be atomic, but
isn't it still possible that the RT thread reads the old pointer
value, is pre-empted, the other thread swaps the pointers, then the RT
threads tries to access memory a few bytes from the old pointer it
read?
5419
days inactive
5421
days old
linux-audio-dev@lists.linuxaudio.org
8 comments
4 participants
participants (4)
-
lieven moors -
Paul Coccoli -
Paul Davis -
Sean Bolton