在线程之间分割循环迭代(Dividing loop iterations among threads)

 我最近编写了一个小数量的计算程序，基本上在N维网格上循环，并在每个点执行一些计算。 
 
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; // see bottom of question
 
 它工作得很好，yadda yadda yadda，可爱的图表结果;-)但是，后来我想，我的电脑上有2个内核，为什么不让这个程序多线程，所以我可以运行两倍的速度？ 
 
 现在，我的循环总共运行了大约十亿次计算，我需要一些方法将它们在线程之间分开。 我想我应该将计算分组为“任务” - 比方说最外层循环的每次迭代都是一项任务 - 并将任务交给线程。 我考虑过了 
 
 
 
 只是给线程#n最外层循环的所有迭代，其中i1 % nthreads == n - 从本质上预先确定哪些任务转到哪个线程 
 
 
 试图设置一些互斥保护的变量，它保存需要执行的下一个任务的参数（本例中为i1 ） - 动态分配任务给线程 
 
 
 有什么理由选择另一种方法？ 或者我还没有想过的另一种方法？ 它甚至重要吗？ 
 
 顺便说一下，我用C编写了这个特定的程序，但我想我会在其他语言中再次做同样的事情，所以答案不一定是C语言特定的。 （如果有人知道用于Linux的C库可以做这种事情，但我很想知道它） 
 
 编辑 ：在这种情况下， bin_index是一个确定性函数，除了它自己的局部变量外，它不会改变任何东西。 像这样的东西： 
 
int bin_index(int i1, int i2, int i3, int i4) {
    // w, d, h are constant floats
    float x1 = i1 * w / N,  x2 = i2 * w / N, y1 = i3 * d / N, y2 = i4 * d / N;
    float l = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + h * h);
    float th = acos(h / l);
    // th_max is a constant float (previously computed as a function of w, d, h)
    return (int)(th / th_max);
}
 
 （尽管我赞赏所有的评论，甚至那些不适用于确定性bin_index的评论） 

I recently wrote a small number-crunching program that basically loops over an N-dimensional grid and performs some calculation at each point.
 
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; // see bottom of question
 
It worked fine, yadda yadda yadda, lovely graphs resulted ;-) But then I thought, I have 2 cores on my computer, why not make this program multithreaded so I could run it twice as fast?
 
Now, my loops run a total of, let's say, around a billion calculations, and I need some way to split them up among threads. I figure I should group the calculations into "tasks" - say each iteration of the outermost loop is a task - and hand out the tasks to threads. I've considered
 
 
 
just giving thread #n all iterations of the outermost loop where i1 % nthreads == n - essentially predetermining which tasks go to which threads 
 
 
trying to set up some mutex-protected variable which holds the parameter(s) (i1 in this case) of the next task that needs executing - assigning tasks to threads dynamically
 
 
What reasons are there to choose one approach over the other? Or another approach I haven't thought about? Does it even matter?
 
By the way, I wrote this particular program in C, but I imagine I'll be doing the same kind of thing again in other languages as well so answers need not be C-specific. (If anyone knows a C library for Linux that does this sort of thing, though, I'd love to know about it)
 
EDIT: in this case bin_index is a deterministic function which doesn't change anything except its own local variables. Something like this:
 
int bin_index(int i1, int i2, int i3, int i4) {
    // w, d, h are constant floats
    float x1 = i1 * w / N,  x2 = i2 * w / N, y1 = i3 * d / N, y2 = i4 * d / N;
    float l = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + h * h);
    float th = acos(h / l);
    // th_max is a constant float (previously computed as a function of w, d, h)
    return (int)(th / th_max);
}
 
(although I appreciate all the comments, even those which don't apply to a deterministic bin_index)

原文：https://stackoverflow.com/questions/564577