OpenMP (Open Multi-Processing) is a widely used API (Application Programming Interface) for shared-memory parallel programming in languages like C, C++, and Fortran. It allows developers to write programs that can run on multiple CPU cores simultaneously, improving performance without requiring a complete rewrite of code. It consists of a set of compiler directives, library routines, and environment variables that influence run-time behavior.
OpenMP is an Application Program Interface (API), jointly defined by a group of major computer hardware and software vendors. OpenMP provides a portable, scalable model for developers of shared memory parallel applications. The API supports C/C++ and Fortran on a wide variety of architectures. This tutorial covers most of the major features of OpenMP, including its various constructs and directives for specifying parallel regions, work sharing, synchronization and data environment. Runtime library functions and environment variables are also covered. This tutorial includes both C and Fortran example codes and a lab exercise.
Why do we use OpenMP?
We use OpenMP mainly to:
• Speed up computation by using multiple CPU cores
• Reduce execution time for large, compute-heavy programs
• Avoid the complexity of low-level thread management (like with pthreads)
It’s especially useful when:
• Tasks can be split into independent chunks
• You are working on multi-core processors (which is almost always today)
When should you use OpenMP?
OpenMP is a good choice when:
• You are working on shared-memory systems (e.g., a single machine with multiple cores)
• Your problem can be parallelized (e.g., loops, numerical simulations)
• You want a quick and incremental way to parallelize existing code
Typical use cases:
• Scientific computing (matrix operations, simulations)
• Image processing
• Data analysis
• Engineering computations
Key Features
• Compiler directives (pragmas): e.g., #pragma omp parallel
• Incremental parallelism: add parallelism without rewriting entire code
• Portability: works across many platforms and compilers
• Automatic thread management
• Scalability: performance improves with more cores (to a limit)
Key Components of OpenMP
OpenMP consists of three main parts:
1. Compiler Directives
• Special instructions added to code (e.g., #pragma omp parallel for) to define parallel regions.
2. Runtime Library Functions
Functions to control execution:
• Thread management
• Timing
• Locks and synchronization
3. Environment Variables
Control behavior without changing code:
• OMP_NUM_THREADS → number of threads
• OMP_SCHEDULE → loop scheduling strategy
Advantages
• Easy to learn and use compared to low-level threading
• Minimal code changes needed
• Portable across compilers and systems
• Good for shared-memory parallelism
• Helps significantly reduce runtime for CPU-bound tasks
Disadvantages
• Limited to shared-memory systems (not distributed systems)
• Performance depends on proper parallelization (bad design → no speedup)
• Overhead of thread creation and synchronization
• Risk of issues like: Race conditions, Deadlocks, False sharing
• Less control compared to lower-level threading APIs
More bout OpenMP
OpenMP is an implementation of multithreading, a method of parallelizing whereby a master thread (a series of instructions executed consecutively) forks a specified number of slave threads and a task is divided among them. The threads then run concurrently, with the runtime environment allocating threads to different processors.
OpenMP is managed by the nonprofit technology consortium OpenMP Architecture Review Board (or OpenMP ARB), jointly defined by a group of major computer hardware and software vendors, including AMD, IBM, Intel, Cray, HP, Fujitsu, Nvidia, NEC, Microsoft, Texas Instruments, Oracle Corporation, and more.
OpenMP uses a portable, scalable model that gives programmers a simple and flexible interface for developing parallel applications for platforms ranging from the standard desktop computer to the supercomputer.
An application built with the hybrid model of parallel programming can run on a computer cluster using both OpenMP and Message Passing Interface (MPI), or more transparently through the use of OpenMP extensions for non-shared memory systems.
The OpenMP API supports multi-platform shared-memory parallel programming in C/C++ and Fortran. The OpenMP API defines a portable, scalable model with a simple and flexible interface for developing parallel applications on platforms from the desktop to the supercomputer.
