0

I'm implementing a boss/worker design pattern using pthreads on Linux. I want to have a boss thread that constantly checks for work, and if there is work, then wakes up a sleeping worker to do the work. My question is: what type of IPC synchronization/mechanism should I use to achieve the least latency between my boss thread handing off to my worker, and my worker waking up?

The easy solution is to use Pthread conditional variables and call pthread_cond_signal in the boss thread, and pthread_cond_wait in each of the worker threads, but I'm wondering is there something faster that I can use to implement the blocking and signaling? For example, how would using pipes between the boss and worker threads fare?

how can I measure the performance of one type of IPC versus another? For example, I see benchmarks for pipe()'s and fork()'s, but nothing for using pipe()'s as an interthread communication.

Let me know if I can clarify anything in my questions!

EDIT As an example of how I would use pipe()'s to implement blocking between my worker and boss threads, the worker thread would read() a pipe, and since it's empty would then block on that read call until the boss calls write() on it.

Improve this question

3 Answers 3

Reset to default
2

The glibc implementation of pthreads uses the low-level "futex" locks to implement pthread_cond_wait() / pthread_cond_signal(). Futexes were designed to be a fast synchronisation primitive, so these are likely to outperform pipes or similar methods (at the very least, using pipes requires copying a byte to and from kernel space that isn't needed for futexes).

If pthread_cond_wait() / pthread_cond_signal() map well onto your problem (and it sounds like they do), then the only way to outperform them is likely to be to implement something on futexes yourself (for example, you could eliminate the handling of thread cancellation if you do not use that).

It is probably worthwhile benchmarking your application - unless your work units are very small indeed, then the condition variable wakeup latency is unlikely to dominate.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Thanks for the answer. The work units are indeed very small, and the bottleneck is actually in the boss waking up the worker threads, so if I can get that down, that would be golden.
@yoyoyo: Then it would likely to most profitable to put some thought into a design that batches up the work units into larger blocks of work that can be more efficiently handled.
1

What you should do first is being sure you need something faster. Since pthread signaling is implemented using futex, where futex stands for fast user space mutex, I don't think you can out perform them.

If you have waiting threads, by definition you will have to wake them up, and this round trip through the kernel will be the source of your unwanted latency.

But what you should do is really think about your problem :

  • if you constantly have work to do, then your worker thread is always busy. Work will be done when previous work is finished, and you don't care about the latency.

  • If what matters is the latency between the boss detecting an event and the worker starting to work, then why do you use a boss -> worker pattern ?

My advice would be to look for a faster thing when you really need it, at this time you will probably have a much mre detailed question to ask. Maybe I am wrong, but it looks like you are trying to optimize preemptively, which as you perhaps know is the root of all evil. Of course, bad design can lead to massive rework, but here you are dealing with a very small detail of your real design decision which is using a boss / worker pattern.

Implement your design with pthread_signal, or perhaps semp_post() / sem_wait(), and then look where your latency really is, and if it is really a problem.

Improve this answer

Comments

0

I would guess signal and wait would be the best. Most OS recognize threads and can have them just idle until the interrupt comes. With pipes the worker would have to keep waking up and checking the pipe for output. The best testing I've found for efficiency has usually been using the unix command to get the running time from start to finish(assuming the program isn't meant to keep running in the background), set up a script to do it a few times and compare.

Improve this answer

1 Comment

This is false: "With pipes the worker would have to keep waking up and checking the pipe for output." select, poll, epoll, kqueue, etc.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.