OpenMP Basics: Parallel Regions and the Loop That Ran on Every Thread

#pragma omp parallel creates a team of threads — it does not, by itself, divide any work between them. That distinction is where the first real bug in this lesson comes from.

A team of threads, each running the same block

// hello_omp.c
#include <stdio.h>
#include <omp.h>

int main() {
    #pragma omp parallel
    {
        int id = omp_get_thread_num();
        int total = omp_get_num_threads();
        printf("Hello from thread %d of %d\n", id, total);
    }
    return 0;
}

gcc -fopenmp -o hello_omp hello_omp.c
./hello_omp

Hello from thread 0 of 12
Hello from thread 9 of 12
Hello from thread 11 of 12
Hello from thread 7 of 12
Hello from thread 8 of 12
Hello from thread 10 of 12
Hello from thread 6 of 12
Hello from thread 4 of 12
Hello from thread 3 of 12
Hello from thread 1 of 12
Hello from thread 2 of 12
Hello from thread 5 of 12

Twelve threads (this machine’s core count), each running the entire block once, printing in whatever order the OS scheduler happens to run them — not sorted by thread number, and not reproducible run to run.

OMP_NUM_THREADS=4 ./hello_omp

Hello from thread 0 of 4
Hello from thread 1 of 4
Hello from thread 3 of 4
Hello from thread 2 of 4

OMP_NUM_THREADS controls the team size without recompiling anything.

The bug: a loop that ran on every thread, not divided between them

// bug_loop.c
#include <stdio.h>
#include <omp.h>

int main() {
    #pragma omp parallel num_threads(4)
    {
        for (int i = 0; i < 3; i++) {
            printf("thread %d processing item %d\n", omp_get_thread_num(), i);
        }
    }
    return 0;
}

gcc -fopenmp -o bug_loop bug_loop.c
./bug_loop

thread 0 processing item 0
thread 0 processing item 1
thread 0 processing item 2
thread 2 processing item 0
thread 2 processing item 1
thread 2 processing item 2
thread 3 processing item 0
thread 3 processing item 1
thread 3 processing item 2
thread 1 processing item 0
thread 1 processing item 1
thread 1 processing item 2

Twelve lines for a 3-item loop with 4 threads — every single thread ran the entire loop, processing items 0, 1, and 2 all by itself. #pragma omp parallel only created the team; it never told OpenMP to split the loop’s iterations across it, so each thread just ran everything independently, redundantly.

The fix: #pragma omp for actually divides the work

// fixed_loop.c
#include <stdio.h>
#include <omp.h>

int main() {
    #pragma omp parallel num_threads(4)
    {
        #pragma omp for
        for (int i = 0; i < 3; i++) {
            printf("thread %d processing item %d\n", omp_get_thread_num(), i);
        }
    }
    return 0;
}

gcc -fopenmp -o fixed_loop fixed_loop.c
./fixed_loop

thread 0 processing item 0
thread 1 processing item 1
thread 2 processing item 2

Three lines this time — each of the three items processed exactly once, by a different thread. #pragma omp for, placed inside the parallel region, is the directive that actually distributes loop iterations across the current thread team instead of duplicating the whole loop on each one.

Practice

#include <stdio.h>
#include <omp.h>

int main() {
    printf("max threads available: %d\n", omp_get_max_threads());
    printf("num threads outside parallel region: %d\n", omp_get_num_threads());
    return 0;
}

max threads available: 12
num threads outside parallel region: 1

OMP_NUM_THREADS=2 ./fixed_loop

thread 1 processing item 1
thread 2 processing item 2
thread 0 processing item 0

OMP_NUM_THREADS=2 ./bug_loop

thread 0 processing item 0
thread 0 processing item 1
thread 0 processing item 2
thread 2 processing item 0
thread 2 processing item 1
thread 2 processing item 2
thread 3 processing item 0
thread 3 processing item 1
thread 3 processing item 2
thread 1 processing item 0
thread 1 processing item 1
thread 1 processing item 2

Next: dividing work with scheduling strategies, and what changes when iterations take unequal time.