Деление повторений цикла среди потоков

Первый подход достаточно. Никакая потребность в сложности здесь. Если Вы начинаете играть со взаимными исключениями, Вы рискуете делать трудно для обнаружения ошибок.

Не начинайте усложнять, если Вы действительно не видите необходимость в этом. Проблемы Syncronization (особенно в случае многих потоков вместо многих процессов) могут быть действительно болезненными.

Насколько я понимаю OpenMP был сделан только, для какого Вы пытаетесь сделать, хотя я должен признать, что еще не использовал его сам. В основном это, кажется, сводится к только включая заголовок и добавление пункта прагмы.

Вы могли, вероятно, также пользоваться Библиотекой Стандартных блоков Потока Intel.

Если Вы никогда не кодировали приложение мультипотока, я пустой Вы для начала с OpenMP:

• библиотека теперь включена в gcc по умолчанию
• это очень просто в использовании

В Вашем примере Вам придется просто добавить эту прагму:

#pragma omp parallel shared(histogram)
{
for (int i1 = 0; i1 < N; i1++)
  for (int i2 = 0; i2 < N; i2++)
    for (int i3 = 0; i3 < N; i3++)
      for (int i4 = 0; i4 < N; i4++)
        histogram[bin_index(i1, i2, i3, i4)] += 1;
}

С этой прагмой компилятор добавит некоторую инструкцию создать потоки, запустить их, добавить некоторые взаимные исключения вокруг доступов к histogram переменная и т.д... Существует много опций, но четко определенная прагма делает всю работу для Вас. В основном простота зависит от зависимости по данным.

Конечно, результат не должен быть оптимальным, как будто Вы кодировали все вручную. Но если у Вас нет проблемы выравнивания нагрузки, Вы, возможно, могли бы приблизиться 2x, убыстряются. На самом деле это - только запись в матрице без пространственной зависимости в нем.

Я сделал бы что-то вроде этого:

void HistogramThread(int i1, Action<int[]> HandleResults)
{
    int[] histogram = new int[HistogramSize];

    for (int i2 = 0; i2 < N; i2++)
       for (int i3 = 0; i3 < N; i3++)
          for (int i4 = 0; i4 < N; i4++)
             histogram[bin_index(i1, i2, i3, i4)] += 1;

    HandleResults(histogram);
}

int[] CalculateHistogram()
{
    int[] histogram = new int[HistogramSize];

    ThreadPool pool; // I don't know syntax off the top of my head
    for (int i1=0; i1<N; i1++)
    {
       pool.AddNewThread(HistogramThread, i1, delegate(int[] h)
       {
           lock (histogram)
           {
               for (int i=0; i<HistogramSize; i++)
                   histogram[i] += h[i];
           }
       });
    }
    pool.WaitForAllThreadsToFinish();

    return histogram;
}

Таким образом, Вы не должны совместно использовать память до конца.

Если Вы когда-нибудь делаете это в.NET, используйте Параллельные Расширения.

Если Вы хотите написать многопоточный код перемалывания чисел (и Вы собираетесь быть выполнением большого количества его в будущем), я предложил бы, чтобы Вы смотрели на использование функционального языка как OCaml или Haskell.

Из-за отсутствия побочных эффектов и отсутствия общего состояния на функциональных языках (хорошо, главным образом) то, чтобы заставлять Ваш код натыкаться на несколько потоков НАМНОГО легче. Плюс, Вы, вероятно, найдете, что заканчиваете с намного меньшим количеством кода.

Я соглашаюсь с Sharptooth, что Ваш первый подход походит на единственный вероятный.

Ваше единственное потоковое приложение непрерывно присваивает памяти. Для получения любого ускорения несколько потоков должны были бы также непрерывно присваивать памяти. Если бы только один поток присваивается за один раз, Вы не получили бы ускорения вообще. Таким образом, если бы Ваши присвоения охраняют, целое осуществление перестало бы работать.

Это было бы опасным подходом начиная с Вас присваивающий общей памяти без защиты. Но это, кажется, стоит опасности (если x2 ускорение имеет значение). Если можно быть уверены, что все значения bin_index (i1, i2, i3, i4) отличаются в подразделении цикла, то это должно работать, так как присваивание массива было бы к различные местоположения в общей памяти. Однако, всегда нужно смотреть и трудно на подходы как это.

Я предполагаю, что Вы также произвели бы тестовую задачу для сравнения результатов этих двух версий.

Править:

Смотря на Ваш bin_index (i1, i2, i3, i4), я подозреваю, что Ваш процесс не мог быть параллелизирован без значительного усилия.

Единственный способ разделить работу вычисления в Вашем цикле состоит в том, чтобы, снова, быть верным, что Ваши потоки получат доступ к тем же областям в памяти. Однако похоже, что bin_index (i1, i2, i3, i4), вероятно, повторит значения довольно часто. Вы могли бы разделить повторение на условия, где bin_index выше, чем сокращение и где это ниже, чем сокращение. Или Вы могли разделить его произвольно и видеть, реализован ли инкремент атомарно. Но любой сложный подход поточной обработки вряд ли может обеспечивать улучшение, если у Вас может только быть два ядра для работы с запуститься с.