Разделение итераций цикла между потоками

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

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

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

вы, вероятно, также можете использовать 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 переменная etc... Вариантов много, но хорошо определенная pragma делает всю работу за вас. В принципе, простота зависит от зависимости данных.

конечно, результат не должен быть оптимальным, как если бы вы закодировали все вручную. Но если у вас нет проблемы с балансировкой нагрузки, вы можете приблизиться к скорости 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) отличаются в вашем разделении цикла, то он должен работать, так как назначение массива будет в разных местах в вашей общей памяти. Тем не менее, всегда нужно внимательно смотреть на такие подходы.

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

Edit:

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

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