Первые шаги в OpenMP

/* Директива привязывается только к "a=b", поскольку
 * "c=d" - это уже следующий оператор */
#pragma trampampam
  a = b;
  c = d;
 
/* Директива привязывается ко всему лексическому блоку,
 * содержащему "a=b" и "c=d" */
#pragma trampampam
  {
    a = b;
    c = d;
  }
 
/* Директива привязывается к составному оператору "запятая", который
 * включает в себя "a=b" и "c=d" */
#pragma trampampam
  a = b, c = d;
 
/* Директива привязывается к составному оператору for, который
 * включает в себя "a=b" и "c=d" */
#pragma trampampam
  for (i = 0; i < 10; i++)
    {
      a = b;
      c = d;
    }

#define FOO() \
  a = b; \
  c = d
 
/* Директива будет привязана только к "a=b" */
#pragma trampampam
  FOO();

/* Демонстрационный код, не имеющий полезного смысла */
 
#include <stdio.h>
 
int main (void)
{
  printf ("serial region 1\n");
 
#pragma omp parallel
  {
    printf ("parallel region\n");
  }
 
  printf ("serial region 2\n");
 
  return 0;
}

/* Демонстрационный код, не имеющий полезного смысла */
 
#include <stdio.h>
 
int main (void)
{
  printf ("serial region 1\n");
 
#pragma omp parallel
  {
    printf ("a");
    printf ("b");
    printf ("c");
    printf ("d");
    printf ("e");
    printf ("f");
    printf ("g");
    printf ("h");
    printf ("\n");
  }
 
  printf ("serial region 2\n");
 
  return 0;
}

#pragma omp parallel num_threads(4)

  int n = 4;
#pragma omp parallel num_threads(n)

/* Демонстрационный код, не имеющий полезного смысла */
 
#include <stdio.h>
#include <omp.h>
 
int main (void)
{
  printf ("serial region 1\n");
 
#pragma omp parallel
  {
    printf ("parallel region, thread=%d\n", omp_get_thread_num());
  }
 
  printf ("serial region 2\n");
 
  return 0;
}

/* Демонстрационный код, не имеющий полезного смысла */
 
#include <stdio.h>
#include <omp.h>
 
int main (void)
{
  printf ("serial region 1\n");
 
#pragma omp parallel
  {
#ifdef _OPENMP
    printf ("parallel region, thread=%d\n", omp_get_thread_num());
#else
    printf ("parallel region, thread=main\n");
#endif
  }
 
  printf ("serial region 2\n");
 
  return 0;
}

#include <stdio.h>
 
/* Нужно для sleep. На системах, отличных от linux, может потребоваться
 * другой заголовочный файл */
#include <unistd.h>
 
void foo (const char *in, const char *out)
{
  printf ("%s -> %s: start\n", in, out);
 
  /* Эмуляция того, что данная функция работает долго. На системах, отличных от linux,
   * данная функция может называться по другому */
  sleep (1);
 
  printf ("%s -> %s: finish\n", in, out);
}
 
int main (void)
{
  printf ("start\n");
 
  foo ("A", "B");
  foo ("C", "D");
  
  printf ("finish\n");
 
  return 0;
}

/* Ошибочный код */
 
#pragma omp parallel
  {
    foo ("A", "B");
    foo ("C", "D");
  }

#include <stdio.h>
 
/* Нужно для sleep. На системах, отличных от linux, может потребоваться
 * другой заголовочный файл */
#include <unistd.h>
 
void foo (const char *in, const char *out)
{
  printf ("%s -> %s: start\n", in, out);
 
  /* Эмуляция того, что данная функция работает долго. На системах, отличных от linux,
   * данная функция может называться по другому */
  sleep (1);
 
  printf ("%s -> %s: finish\n", in, out);
}
 
int main (void)
{
  printf ("start\n");
 
#pragma omp parallel sections
  {
#pragma omp section
    {
      foo ("A", "B");
    }
#pragma omp section
    {
      foo ("C", "D");
    }
  }
  
  printf ("finish\n");
 
  return 0;
}

int i;
for (i = 0; i < 100; i++)
  printf ("iteration %d\n", i);

/* Неэффективный код */
 
#pragma omp parallel sections
  {
#pragma omp section
    {
      /* Важным моментом, о котором мы пока не знаем, является то, что
       * переменная "i" должна быть объявлена внутри лексического блока,
       * с которым ассоциирована "#pragma omp section". Пока просто
       * верим на слово, а объяснение будет дано в разделе 3.5 */
      int i;
      for (i = 0; i < 25; i++)
        printf ("iteration %d\n", i);
    }
#pragma omp section
    {
      int i;
      for (i = 25; i < 50; i++)
        printf ("iteration %d\n", i);
    }
#pragma omp section
    {
      int i;
      for (i = 50; i < 75; i++)
        printf ("iteration %d\n", i);
    }
#pragma omp section
    {
      int i;
      for (i = 75; i < 100; i++)
        printf ("iteration %d\n", i);
    }
  }

int i;
 
#pragma omp parallel
  {
    /* Директива "#pragma omp for" может быть привязана только к циклу,
     * а не к лексическому блоку или другому оператору */
#pragma omp for
    for (i = 0; i < 100; i++)
      printf ("iteration %d\n", i);
  }

#include <stdio.h>
#include <omp.h>
 
int main (void)
{
  /* Здесь уже переменная цикла может быть объявлена вне параллельного
   * региона. Но опять-таки об этом поясним в разделе 3.5 */
  int i;
 
  printf ("start\n");
 
#pragma omp parallel for
  for (i = 0; i < 100; i++)
    printf ("iteration %d, thread=%d\n", i, omp_get_thread_num());
 
  printf ("finish\n");
 
  return 0;
}

/* Ошибочный код */
 
#include <stdio.h>
 
int main (void)
{
  int i;
 
  printf ("start\n");
 
#pragma omp parallel sections
  {
#pragma omp section
    {
      for (i = 0; i < 10; i++)
        printf ("iteration %d\n", i);
    }
#pragma omp section
    {
      for (i = 10; i < 20; i++)
        printf ("iteration %d\n", i);
    }
  }
    
  printf ("finish\n");
 
  return 0;
}

#include <stdio.h>
 
int main (void)
{
  int i;
 
  printf ("start\n");
 
#pragma omp parallel sections private(i)
  {
#pragma omp section
    {
      for (i = 0; i < 10; i++)
        printf ("iteration %d\n", i);
    }
#pragma omp section
    {
      for (i = 10; i < 20; i++)
        printf ("iteration %d\n", i);
    }
  }
    
  printf ("finish\n");
 
  return 0;
}

#include <stdio.h>
 
void foo (const char *s1, const char *s2, int n)
{
  int i;
 
  printf ("start: %s, %s\n", s1, s2);
 
  /* Здесь моделируется полезная работа, которая может распараллеливаться */
  for (i = 0; i < n; i++)
    printf ("%s\n", s1);
 
  /* Здесь моделируется обращение к последовательному ресурсу
   * Все итерации цикла рассматриваются как одно единое обращение,
   * оно делается в цикле для наглядности */
#pragma omp critical
  {
    for (i = 0; i < n; i++)
      printf ("%s\n", s2);
  }
    
  printf ("finish: %s, %s\n", s1, s2);
}
 
int main (void)
{
  printf ("start\n");
 
#pragma omp parallel sections
  {
#pragma omp section
    {
      foo ("parallel-1", "serial-1", 7);
    }
#pragma omp section
    {
      foo ("parallel-2", "serial-2", 10);
    }
  }
  
  printf ("finish\n");
 
  return 0;
}

/* Ошибочный код */
 
#include <stdio.h>
 
int foo (int x)
{
  /* Моделирование некоторых вычислительных действий. В реальности
   * ничего делать не будем */
  return x;
}
 
int main (void)
{
  int sum = 0;
 
#pragma omp parallel sections shared(sum)
  {
#pragma omp section
    {
      /* Строго говоря, хотелось бы в данном примере видеть вычисления с редкими
       * обращениями к переменной sum. Но в этом случае для визуального наблюдения
       * проблемы пришлось бы писать много кода, несимметричного в двух потоках,
       * и выполнять много запусков программы. Поэтому для упрощения здесь написан
       * цикл с частыми обращениями к переменной sum. При этом в голове надо держать,
       * что здесь должна быть другая модель программы. Это пишу для того, чтобы
       * не путать данный пример с примером из следующего раздела, в котором
       * будем распараллеливать тело цикла */
      int i;
      for (i = 0; i < 10000; i++)
        sum += foo (i);
    }
#pragma omp section
    {
      int i;
      for (i = 0; i < 10000; i++)
        sum -= foo (i);
    }
  }
  
  printf ("sum=%d\n", sum);
 
  return 0;
}

/* Неэффективный код */
 
#pragma omp section
    {
      int i;
      for (i = 0; i < 10000; i++)
      {
        /* Основные вычисления (которые моделируются вызовом функции foo)
         * должны проводиться в параллельном режиме, т.е. вне критической секции */
        int tmp = foo (i);
#pragma omp critical
        {
          sum += tmp;
        }
      }
    }
 
/* Аналогичный фрагмент пишем для второй секции с вычитанием */

#include <stdio.h>
 
int foo (int x)
{
  /* Моделирование некоторых вычислительных действий. В реальности
   * ничего делать не будем */
  return x;
}
 
int main (void)
{
  int sum = 0;
 
#pragma omp parallel sections shared(sum)
  {
#pragma omp section
    {
      /* Строго говоря, хотелось бы в данном примере видеть вычисления с редкими
       * обращениями к переменной sum. Но в этом случае для визуального наблюдения
       * проблемы пришлось бы писать много кода, несимметричного в двух потоках,
       * и выполнять много запусков программы. Поэтому для упрощения здесь написан
       * цикл с частыми обращениями к переменной sum. При этом в голове надо держать,
       * что здесь должна быть другая модель программы. Это пишу для того, чтобы
       * не путать данный пример с примером из следующего раздела, в котором
       * будем распараллеливать тело цикла */
      int i;
      for (i = 0; i < 10000; i++)
      {
        /* Директива "#pragma omp atomic" по смыслу относится только
         * к левой части выражения. Т.е. правая часть нормально будет
         * работать в параллельном режиме, и только изменение значения
         * переменной пройдёт атомарно (последовательно). Таким образом,
         * нам даже не нужно возиться с заведением дополнительной
         * переменной "tmp", как мы это делали в неэффективном примере
         * с критическими секциями */
#pragma omp atomic
        sum += foo (i);
      }
    }
#pragma omp section
    {
      int i;
      for (i = 0; i < 10000; i++)
      {
#pragma omp atomic
        sum -= foo (i);
      }
    }
  }
  
  printf ("sum=%d\n", sum);
 
  return 0;
}

/* Неэффективный код */
 
#include <stdio.h>
 
int foo (int x)
{
  /* Моделирование некоторых вычислительных действий. В реальности
   * ничего делать не будем */
  return x;
}
 
int main (void)
{
  int i, sum;
 
  sum = 0;
 
#pragma omp parallel for shared(sum)
  for (i = 0; i < 10000; i++)
  {
#pragma omp atomic
    sum += foo (i);
  }
  
  printf ("sum=%d\n", sum);
 
  return 0;
}

#include <stdio.h>
 
int foo (int x)
{
  /* Моделирование некоторых вычислительных действий. В реальности
   * ничего делать не будем */
  return x;
}
 
int main (void)
{
  int i, sum;
 
  sum = 0;
 
#pragma omp parallel for reduction(+:sum)
  for (i = 0; i < 10000; i++)
    sum += foo (i);
  
  printf ("sum=%d\n", sum);
 
  return 0;
}