Pthreads vs. OpenMP

I'm creating a multi-threaded application in C using Linux.

I'm unsure whether I should use the POSIX thread API or the OpenMP API.

What are the pros & cons of using either?

Edit:

Could someone clarify whether both APIs create kernel-level开发者_如何学编程 or user-level threads?

Pthreads and OpenMP represent two totally different multiprocessing paradigms.

Pthreads is a very low-level API for working with threads. Thus, you have extremely fine-grained control over thread management (create/join/etc), mutexes, and so on. It's fairly bare-bones.

On the other hand, OpenMP is much higher level, is more portable and doesn't limit you to using C. It's also much more easily scaled than pthreads. One specific example of this is OpenMP's work-sharing constructs, which let you divide work across multiple threads with relative ease. (See also Wikipedia's pros and cons list.)

That said, you've really provided no detail about the specific program you're implementing, or how you plan on using it, so it's fairly impossible to recommend one API over the other.

If you use OpenMP, it can be as simple as adding a single pragma, and you'll be 90% of the way to properly multithreaded code with linear speedup. To get the same performance boost with pthreads takes a lot more work.

But as usual, you get more flexibility with pthreads.

Basically, it depends on what your application is. Do you have a trivially-parallelisable algorithm? Or do you just have lots of arbitrary tasks that you'd like to simultaneously? How much do the tasks need to talk to each other? How much synchronisation is required?

OpenMP has the advantages of being cross platform, and simpler for some operations. It handles threading in a different manner, in that it gives you higher level threading options, such as parallelization of loops, such as:

#pragma omp parallel for
for (i = 0; i < 500; i++)
    arr[i] = 2 * i;

If this interests you, and if C++ is an option, I'd also recommend Threading Building Blocks.

Pthreads is a lower level API for generating threads and synchronization explicitly. In that respect, it provides more control.

It depends on 2 things- your code base and your place within it. The key questions are- 1) "Does you code base have threads, threadpools, and the control primitives (locks, events, etc.)" and 2) "Are you developing reusable libraries or ordinary apps?"

If your library has thread tools (almost always built on some flavor of PThread), USE THOSE. If you are a library developer, spend the time (if possible) to build them. It is worth it- you can put together much more fine-grained, advanced threading than OpenMP will give you.

Conversely, if you are pressed for time or just developing apps or something off of 3rd party tools, use OpenMP. You can wrap it in a few macros and get the basic parallelism you need.

In general, OpenMP is good enough for basic multi-threading. Once you start getting to the point that you're managing system resourced directly on building highly async code, its ease-of-use advantage gets crowded out by performance and interface issues.

Think of it this way. On a linux system, it is very highly likely that the OpenMP API itself uses pthreads to implement its features such as parallelism, barriers and locks/mutex. Having said that, there are good reasons to work directly with the pthreads API.

It is my opinion that -

You use OpenMP when -

• Your program contains easy to spot for loops where each iteration is independent from other.
• You want to retain the readability of the program. (Basically keep the parallelized program looking like the sequential version)
• You want to stay away from the nitty-gritty details of how threads are spawned and controlled at a micro level.

And pthreads when -

• You don't have easy to parallelize loops.

• You have different tasks which need to be performed concurrently, you might be wanting to give different responsibilities to each of those tasks.

• You want to control the flow of thread execution at a micro level.

Feel free to correct me in the comments.