schedule

Applies to the for directive.

Syntax

schedule
(type[,size])  

Parameters

type
The kind of scheduling:

• dynamic

• guided

• runtime

• static

size (optional)
Specifies the size of iterations. size must be an integer. Not valid when type is runtime.

Remarks

For more information, see 2.4.1 for Construct.

Example

// omp_schedule.cpp  
// compile with: /openmp   
#include <windows.h>  
#include <stdio.h>  
#include <omp.h>  
  
#define NUM_THREADS 4  
#define STATIC_CHUNK 5  
#define DYNAMIC_CHUNK 5  
#define NUM_LOOPS 20  
#define SLEEP_EVERY_N 3  
  
int main( )   
{  
    int nStatic1[NUM_LOOPS],   
        nStaticN[NUM_LOOPS];  
    int nDynamic1[NUM_LOOPS],   
        nDynamicN[NUM_LOOPS];  
    int nGuided[NUM_LOOPS];  
  
    omp_set_num_threads(NUM_THREADS);  
  
    #pragma omp parallel  
    {  
        #pragma omp for schedule(static, 1)  
        for (int i = 0 ; i < NUM_LOOPS ; ++i)   
        {  
            if ((i % SLEEP_EVERY_N) == 0)   
                Sleep(0);  
            nStatic1[i] = omp_get_thread_num( );  
        }  
  
        #pragma omp for schedule(static, STATIC_CHUNK)  
        for (int i = 0 ; i < NUM_LOOPS ; ++i)   
        {  
            if ((i % SLEEP_EVERY_N) == 0)   
                Sleep(0);  
            nStaticN[i] = omp_get_thread_num( );  
        }  
  
        #pragma omp for schedule(dynamic, 1)  
        for (int i = 0 ; i < NUM_LOOPS ; ++i)   
        {  
            if ((i % SLEEP_EVERY_N) == 0)   
                Sleep(0);  
            nDynamic1[i] = omp_get_thread_num( );  
        }  
  
        #pragma omp for schedule(dynamic, DYNAMIC_CHUNK)  
        for (int i = 0 ; i < NUM_LOOPS ; ++i)   
        {  
            if ((i % SLEEP_EVERY_N) == 0)   
                Sleep(0);  
            nDynamicN[i] = omp_get_thread_num( );  
        }  
  
        #pragma omp for schedule(guided)  
        for (int i = 0 ; i < NUM_LOOPS ; ++i)   
        {  
            if ((i % SLEEP_EVERY_N) == 0)   
                Sleep(0);  
            nGuided[i] = omp_get_thread_num( );  
        }  
    }  
  
    printf_s("------------------------------------------------\n");  
    printf_s("| static | static | dynamic | dynamic | guided |\n");  
    printf_s("|    1   |    %d   |    1    |    %d    |        |\n",  
             STATIC_CHUNK, DYNAMIC_CHUNK);  
    printf_s("------------------------------------------------\n");  
  
    for (int i=0; i<NUM_LOOPS; ++i)   
    {  
        printf_s("|    %d   |    %d   |    %d    |    %d    |"  
                 "    %d   |\n",  
                 nStatic1[i], nStaticN[i],  
                 nDynamic1[i], nDynamicN[i], nGuided[i]);  
    }  
  
    printf_s("------------------------------------------------\n");  
}  

------------------------------------------------  
| static | static | dynamic | dynamic | guided ||    1   |    5   |    1    |    5    ||  
------------------------------------------------  
|    0   |    0   |    0    |    2    |    1   ||    1   |    0   |    3    |    2    |    1   ||    2   |    0   |    3    |    2    |    1   ||    3   |    0   |    3    |    2    |    1   ||    0   |    0   |    2    |    2    |    1   ||    1   |    1   |    2    |    3    |    3   ||    2   |    1   |    2    |    3    |    3   ||    3   |    1   |    0    |    3    |    3   ||    0   |    1   |    0    |    3    |    3   ||    1   |    1   |    0    |    3    |    2   ||    2   |    2   |    1    |    0    |    2   ||    3   |    2   |    1    |    0    |    2   ||    0   |    2   |    1    |    0    |    3   ||    1   |    2   |    2    |    0    |    3   ||    2   |    2   |    2    |    0    |    0   ||    3   |    3   |    2    |    1    |    0   ||    0   |    3   |    3    |    1    |    1   ||    1   |    3   |    3    |    1    |    1   ||    2   |    3   |    3    |    1    |    1   ||    3   |    3   |    0    |    1    |    3   |  
------------------------------------------------  
  

See Also

Clauses