# Intel® Compiler Extension Routines to OpenMP*

The Intel® compiler implements the following group of routines as extensions to the OpenMP* run-time library:

- Get and set the execution environment

- Get and set the stack size for parallel threads

- Memory allocation

- Get and set the thread sleep time for the throughput execution mode

The Intel® extension routines described in this section can be used for low-level tuning to verify that the library code and application are functioning as intended. These routines are generally not recognized by other OpenMP-compliant compilers, which may cause the link stage to fail in the other compiler. To execute these OpenMP* routines, use the /Qopenmp-stubs (Windows*) or -qopenmp-stubs (Linux*) option.

In most cases, environment variables can be used in place of the extension library routines. For example, the stack size of the parallel threads may be set using the OMP_STACKSIZE environment variable rather than the kmp_set_stacksize_s() library routine.

### Note

A run-time call to an Intel extension routine takes precedence over the corresponding environment variable setting.

## Execution Environment

Function | Description
--- | ---
`void kmp_set_defaults(char const *)` | Sets OpenMP* environment variables defined as a list of variables separated by "|" in the argument.
`void kmp_set_library_throughput()` | Sets execution mode to throughput, which is the default. Allows the application to determine the runtime environment. Use in multi-user environments.
`void kmp_set_library_turnaround()` | Sets execution mode to turnaround. Use in dedicated parallel (single user) environments.
`void kmp_set_library_serial()` | Sets execution mode to serial.
`void kmp_set_library(int)` | Sets execution mode indicated by the value passed to the function. Valid values are: 1 - serial mode 2 - turnaround mode 3 - throughput mode Call this routine before the first parallel region is executed.
`int kmp_get_library()` | Returns a value corresponding to the current execution mode: 1 - serial 2 - turnaround 3 - throughput

## Stack Size

Function | Description
--- | ---
`size_t kmp_get_stacksize_s()` | Returns the number of bytes that will be allocated for each parallel thread to use as its private stack. This value can be changed with kmp_set_stacksize_s() routine, prior to the first parallel region or via the `KMP_STACKSIZE` environment variable.
`int kmp_get_stacksize()` | Provided for backwards compatibility only. Use kmp_get_stacksize_s() routine for compatibility across different families of Intel processors.
`void kmp_set_stacksize_s(size_tsize)` | Sets to size the number of bytes that will be allocated for each parallel thread to use as its private stack. This value can also be set via the `KMP_STACKSIZE` environment variable. In order for kmp_set_stacksize_s() to have an effect, it must be called before the beginning of the first (dynamically executed) parallel region in the program.
`void kmp_set_stacksize(int size)` | Provided for backward compatibility only. Use `kmp_set_stacksize_s()` for compatibility across different families of Intel® processors.

## Memory Allocation

The Intel® compiler implements a group of memory allocation routines as an extension to the OpenMP* run-time library to enable threads to allocate memory from a heap local to each thread. These routines are: kmp_malloc(), kmp_calloc(), and kmp_realloc().

The memory allocated by these routines must also be freed by the kmp_free() routine. While you can allocate memory in one thread and then free that memory in a different thread, this mode of operation incurs a slight performance penalty.

Function | Description
--- | ---
`void* kmp_malloc(size_tsize)` | Allocate memory block of size bytes from thread-local heap.
`void* kmp_calloc(size_t nelem, size_t elsize)` | Allocate array of nelem elements of size elsize from thread-local heap.
`void* kmp_realloc(void*ptr, size_t size)` | Reallocate memory block at address ptr and size bytes from thread-local heap.
`void* kmp_free(void*ptr)` | Free memory block at address ptr from thread-local heap. Memory must have been previously allocated with kmp_malloc(), kmp_calloc(), or kmp_realloc().

## Thread Sleep Time

In the throughput OpenMP* Support Libraries, threads wait for new parallel work at the ends of parallel regions, and then sleep, after a specified period of time. This time interval can be set by the `KMP_BLOCKTIME` environment variable or by the kmp_set_blocktime() function.

Function | Description
--- | ---
`int kmp_get_blocktime(void)` | Returns the number of milliseconds that a thread should wait, after completing the execution of a parallel region, before sleeping, as set either by the `KMP_BLOCKTIME` environment variable or by kmp_set_blocktime().
`void kmp_set_blocktime(int msec)` | Sets the number of milliseconds that a thread should wait, after completing the execution of a parallel region, before sleeping. This routine affects the block time setting for the calling thread and any OpenMP* team threads formed by the calling thread. The routine does not affect the block time for any other threads.

Parent topic: OpenMP* Library Support

## See Also

openmp-stubs, Qopenmp-stubs compiler option
OpenMP* Run-time Library Routines
OpenMP* Support Libraries