OpenMP: Параллелдік бағдарламалау стандарты

Open standard for parallelizing

OpenMP (Open Multi Processing) is an application programming interface (API) that supports multi platform shared memory multiprocessing programming in C, C++, and Fortran, on many platforms, instruction set architectures and operating systems, including Solaris, AIX, FreeBSD, HP UX, Linux, macOS, and Windows. It consists of a set of compiler directives, library routines, and environment variables that influence run time behavior. OpenMP is managed by the nonprofit technology consortium OpenMP Architecture Review Board (or OpenMP ARB), jointly defined by a broad swath of leading computer hardware and software vendors, including Arm, AMD, IBM, Intel, Cray, HP, Fujitsu, Nvidia, NEC, Red Hat, Texas Instruments, and Oracle Corporation. to translate OpenMP into MPI
and to extend OpenMP for non shared memory systems.

OpenMP is an implementation of multithreading, a method of parallelizing whereby a primary thread (a series of instructions executed consecutively) forks a specified number of sub threads and the system divides a task among them. The threads then run concurrently, with the runtime environment allocating threads to different processors. The section of code that is meant to run in parallel is marked accordingly, with a compiler directive that will cause the threads to form before the section is executed. Version 3.0 was released in May 2008. Included in the new features in 3.0 is the concept of tasks and the task construct, significantly broadening the scope of OpenMP beyond the parallel loop constructs that made up most of OpenMP 2.0. Version 4.0 of the specification was released in July 2013. It adds or improves the following features: support for accelerators; atomics; error handling; thread affinity; tasking extensions; user defined reduction; SIMD support; Fortran 2003 support. The current version is 5.2, released in November 2021. Version 6.0 is due for release in 2024. Note that not all compilers (and OSes) support the full set of features for the latest version/s.

The core elements of OpenMP are the constructs for thread creation, workload distribution (work sharing), data environment management, thread synchronization, user level runtime routines and environment variables. In C/C++, OpenMP uses #pragmas. The OpenMP specific pragmas are listed below.

A method to alter the execution features of OpenMP applications. Used to control loop iterations scheduling, default number of threads, etc. For example, OMP NUM THREADS is used to specify number of threads for an application.

One might expect to get an N times speedup when running a program parallelized using OpenMP on a N processor platform. However, this seldom occurs for these reasons:
When a dependency exists, a process must wait until the data it depends on is computed. When multiple processes share a non parallel proof resource (like a file to write in), their requests are executed sequentially. Therefore, each thread must wait until the other thread releases the resource. A large part of the program may not be parallelized by OpenMP, which means that the theoretical upper limit of speedup is limited according to Amdahl's law. N processors in a symmetric multiprocessing (SMP) may have N times the computation power, but the memory bandwidth usually does not scale up N times. Quite often, the original memory path is shared by multiple processors and performance degradation may be observed when they compete for the shared memory bandwidth. Many other common problems affecting the final speedup in parallel computing also apply to OpenMP, like load balancing and synchronization overhead. Compiler optimisation may not be as effective when invoking OpenMP. This can commonly lead to a single threaded OpenMP program running slower than the same code compiled without an OpenMP flag (which will be fully serial).

Some vendors recommend setting the processor affinity on OpenMP threads to associate them with particular processor cores. This minimizes thread migration and context switching cost among cores. It also improves the data locality and reduces the cache coherency traffic among the cores (or processors).