Intel® C++ Compiler 16.0 User and Reference Guide
This is a summary of the OpenMP* pragmas and clauses supported in the Intel® C++ Compiler. For detailed information about the OpenMP*API, see the OpenMP Application Program Interface Versions 4.0 and 4.5 specifications, which are available from the OpenMP* web site.
Use this pragma to form a team of threads and execute those threads in parallel.
Pragma |
Description |
---|---|
Specifies that a structured block should be run in parallel by a team of threads. |
Use this pragma for deferring execution.
Pragma |
Description |
---|---|
Specifies the beginning of a code block whose execution may be deferred. |
Use these pragmas to share work among a team of threads.
Pragma |
Description |
---|---|
Specifies a parallel loop. Each iteration of the loop is executed by one of the threads in the team. |
|
Defines a region of structured blocks that will be distributed among the threads in a team. |
|
Specifies a structured block that will be executed only once by a single thread in the team. |
Use these pragmas to synchronize between threads.
Pragma |
Description |
---|---|
Specifies a computation that must be executed atomically. |
|
Specifies a point in the code where each thread must wait until all threads in the team arrive. |
|
Specifies a code block that is restricted to access by only one thread at a time. |
|
Identifies a point at which the view of the memory by the thread becomes consistent with the memory. |
|
Specifies the beginning of a code block that must be executed only once by the master thread of the team. |
|
Specifies the beginning of a code block that must be executed only once by the master thread of the team. |
|
Causes the program to wait until the completion of all enclosed and descendant tasks. |
|
Specifies a wait on the completion of child tasks generated since the beginning of the current task. |
|
Specifies that the current task can be suspended at this point, in favor of execution of a different task. |
Use this pragma to give threads global private data.
Pragma |
Description |
---|---|
Specifies a list of globally-visible variables that will be allocated private to each thread. |
Use these pragmas to control execution on one or more coprocessors.
Pragma |
Description |
---|---|
Specifies functions and variables that are created or mapped to a device. This pragma only applies to Intel® Many Integrated Core Architecture (Intel® MIC Architecture) and Intel® Graphics Technology. |
|
Specifies that the iterations of one of more loops should be shared among the master threads of all thread teams in a league. |
|
Creates a device data environment and then executes the construct on that device. This pragma only applies to Intel® MIC Architecture and Intel® Graphics Technology. |
|
Creates a device data environment by making a mapping of variables from the host to the target device. This pragma only applies to Intel® MIC Architecture. |
|
Makes the items listed in the device data environment consistent between the device and host, in accordance with the motion clauses on the pragma. This pragma only applies to Intel® MIC Architecture. |
|
Creates a league of thread teams to execute the structured block in the master thread of each team. |
Use these pragmas to control execution on vector hardware.
Pragma |
Description |
---|---|
Transforms the loop into a loop that will be executed concurrently using Single Instruction Multiple Data (SIMD) instructions. |
|
Creates a version of a function that can process multiple arguments using Single Instruction Multiple Data (SIMD) instructions from a single invocation from a SIMD loop. |
Pragma |
Description |
---|---|
Requests cancellation of the innermost enclosing region of the type specified, and causes the encountering task to proceed to the end of the cancelled construct. |
|
Defines a point at which implicit or explicit tasks check to see if cancellation has been requested for the innermost enclosing region of the type specified. This construct does not implement a synchronization between threads or tasks. |
Use this pragma to define reduction identifiers that can be used as reduction operators in a reduction clause.
Pragma |
Description |
---|---|
Declares User-Defined Reduction (UDR) functions (reduction identifiers) that can be used as reduction operators in a reduction clause. |
Use these pragmas as shortcuts for multiple pragmas in sequence.
Pragma |
Description |
---|---|
Specifies a loop that can be executed in parallel by multiple threads that are members of multiple teams. |
|
Specifies a loop that will be executed in parallel by multiple threads that are members of multiple teams. It will be executed concurrently using SIMD instructions. |
|
Specifies a loop that will be distributed across the master threads of the teams region. It will be executed concurrently using SIMD instructions. |
|
Specifies the beginning of a loop that can be executed concurrently using Single Instruction Multiple Data (SIMD) instructions. Each iteration of the loop is executed by one of the threads in the team. |
|
Specifies a parallel construct containing one or more associated loops. |
|
Specifies a parallel region that contains a loop to execute with Single Instruction Multiple Data (SIMD) instructions. |
|
Specifies a parallel construct that contains a single sections construct. |
|
Creates a device data environment and executes the construct on the same device. It also creates a league of thread teams with the master thread in each team execution the structured block.This pragma only applies to Intel® MIC Architecture. |
|
Creates a device data environment and then executes the construct on that device. It also specifies that loop iterations will be shared among the master threads of all thread teams in a league created by a teams construct. This pragma only applies to Intel® MIC Architecture. |
|
Creates a device data environment and then executes the construct on that device. It also specifies a loop that can be executed in parallel by multiple threads that are members of multiple teams created by a teams construct. This pragma only applies to Intel® MIC Architecture. |
|
Creates a device data environment and then executes the construct on that device. It also specifies a loop that can be executed in parallel by multiple threads that are members of multiple teams created by a teams construct. The loop will be distributed across the teams, which will be executed concurrently using SIMD instructions. This pragma only applies to Intel® MIC Architecture. |
|
Creates a device data environment and then executes the construct on that device. It also specifies that loop iterations will be shared among the master threads of all thread teams in a league created by a teams construct. It will be executed concurrently using SIMD instructions. This pragma only applies to Intel® MIC Architecture. |
|
Creates a league of thread teams to execute the structured block in the master thread of each team. It also specifies that loop iterations will be shared among the master threads of all thread teams in a league created by a teams construct. |
|
Creates a league of thread teams to execute a structured block in the master thread of each team. It also specifies a loop that can be executed in parallel by multiple threads that are members of multiple teams. |
|
Creates a league of thread teams to execute a structured block in the master thread of each team. It also specifies a loop that can be executed in parallel by multiple threads that are members of multiple teams. The loop will be distributed across the master threads of the teams region, which will be executed concurrently using SIMD instructions. |
|
Creates a league of thread teams to execute the structured block in the master thread of each team. It also specifies a loop that will be distributed across the master threads of the teams. |