schedule

Applies to the for (OpenMP) directive.

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 /c
#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) == SLEEP_EVERY_N) 
                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) == SLEEP_EVERY_N) 
                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) == SLEEP_EVERY_N) 
                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) == SLEEP_EVERY_N) 
                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) == SLEEP_EVERY_N) 
                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    |    0    |    0   |
|    1   |    0   |    0    |    0    |    0   |
|    2   |    0   |    0    |    0    |    0   |
|    3   |    0   |    0    |    0    |    0   |
|    0   |    0   |    0    |    0    |    0   |
|    1   |    1   |    0    |    0    |    0   |
|    2   |    1   |    0    |    0    |    0   |
|    3   |    1   |    0    |    0    |    0   |
|    0   |    1   |    0    |    0    |    0   |
|    1   |    1   |    0    |    0    |    0   |
|    2   |    2   |    0    |    0    |    0   |
|    3   |    2   |    0    |    0    |    0   |
|    0   |    2   |    0    |    0    |    0   |
|    1   |    2   |    0    |    0    |    0   |
|    2   |    2   |    0    |    0    |    0   |
|    3   |    3   |    0    |    0    |    0   |
|    0   |    3   |    0    |    0    |    0   |
|    1   |    3   |    0    |    0    |    0   |
|    2   |    3   |    0    |    0    |    0   |
|    3   |    3   |    0    |    0    |    0   |
------------------------------------------------

See Also

Concepts

OpenMP Clauses