OSNews

One approach to reduce the amount of semaphores/mutex is to use one thread for each group of resources you may need to lock. Then, as you know that just a single thread modifies that resources, you don't need mutexes. You can adjust the scalability for multiple cores by changing the granularity of the resource groups (smaller groups need more threads).

Each of these threads have a queue of work to be done and you'll have to model your "work" as structs/objects that can be stored in a queue.

So, instead of having:

Component blah:
...do some_stuff with blah;
...wait(lock_for_foobar);
...do X with foobar;
...release(lock_for_foobar);
...do more_stuff with blah;

You will end up with:

Blah.some_stuff:
...do some_stuff with blah;
...enqueue "do X and then notify Blah" to Foobar

Foobar.X:
...do X with foobar;
...enqueue "X done" to Blah

Blah.X_done:
...do more_stuff with blah;

This way you can get rid of mutexes and use only async calls.

Empirically, this approach seems to have larger latency but better throughput. Anybody have seen performance comparisons among these kind of programming models?

Edited 2011-05-27 14:06 UTC