blocks|key|721254|text|我在dotNET上遇到了类似的问题，并最终编写了一个智能队列对象，一旦这些对象可用，它将一次返回十几个对象。一旦我手头有了一个包，我就会决定一个可以一次性处理所有这些包的线程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|721255|在解决这个问题时，我牢记W-queues比M-queues更好。有多个工人的一条长线比每个工人有一条线要好。|721256|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I had a similar problem on dotNET, and ended up writing a smart queue object that would return a dozen objects at a time, once they are available. Once I have a package in hand, I'd decide on a thread that can process all of them in one go.

When working on this problem, I kept in mind that W-queues are better than M-queues. It's better to have one long line with multiple workers, than to have a line for each worker.

blocks|key|721313|text|只要N在运行时是已知的，就没有问题；我不确定为什么您认为它必须在编译时已知。如果必须在编译时知道所有的事情，那么OMP循环构造的用处将非常有限。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|721314|#include+<stdio.h>
#include+<stdlib.h>
#include+<omp.h>

int+main(int+argc,+char+**argv)+{
++++int+n;
++++int+chunksize;

++++if+(argc+!=+2)+{
++++++++fprintf(stderr,"Usage:+%25s+n,+where+n+=+number+of+iterations.\n",+argv[0]);
++++++++exit(-1);
++++}
++++n+=+atoi(argv[1]);
++++if+(n<1+%7C%7C+n>200)+n+=+10;

++++chunksize+=+n/2;

++++#pragma+omp+parallel+num_threads(2)+default(none)+shared(n,chunksize)
++++{
++++++++int+nthread+=+omp_get_thread_num();
++++++++#pragma+omp+for+schedule(static,chunksize)+
++++++++for+(int+i=0;+i<n;+i%2B%2B)+{
++++++++++++printf("Iter+%25d+being+done+by+thread+%25d\n",+i,+nthread);
++++++++}
++++}

++++return+0;
}|code-block|syntax|javascript|721315|它的运行非常简单，如下所示：|721316|$+gcc+-v
[...]
gcc+version+4.4.0+(GCC)+

$+gcc+-o+loop+loop.c+-fopenmp

$+./loop+10
Iter+5+being+done+by+thread+1
Iter+6+being+done+by+thread+1
Iter+7+being+done+by+thread+1
Iter+8+being+done+by+thread+1
Iter+9+being+done+by+thread+1
Iter+0+being+done+by+thread+0
Iter+1+being+done+by+thread+0
Iter+2+being+done+by+thread+0
Iter+3+being+done+by+thread+0
Iter+4+being+done+by+thread+0|721317|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

There's no problem as long as N is known at runtime; I'm not sure why you think it has to be known at compile time. OMP loop constructs would be of very limited use indeed if everything had to be known at compile time.

<pre><code>#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;omp.h&gt;

int main(int argc, char **argv) {
 int n;
 int chunksize;

 if (argc != 2) {
 fprintf(stderr,"Usage: %s n, where n = number of iterations.\n", argv[0]);
 exit(-1);
 }
 n = atoi(argv[1]);
 if (n&lt;1 || n&gt;200) n = 10;

 chunksize = n/2;

 #pragma omp parallel num_threads(2) default(none) shared(n,chunksize)
 {
 int nthread = omp_get_thread_num();
 #pragma omp for schedule(static,chunksize) 
 for (int i=0; i&lt;n; i++) {
 printf("Iter %d being done by thread %d\n", i, nthread);
 }
 }

 return 0;
}
</code></pre>

And it runs simply enough, as so:

<pre><code>$ gcc -v
[...]
gcc version 4.4.0 (GCC) 

$ gcc -o loop loop.c -fopenmp

$ ./loop 10
Iter 5 being done by thread 1
Iter 6 being done by thread 1
Iter 7 being done by thread 1
Iter 8 being done by thread 1
Iter 9 being done by thread 1
Iter 0 being done by thread 0
Iter 1 being done by thread 0
Iter 2 being done by thread 0
Iter 3 being done by thread 0
Iter 4 being done by thread 0
</code></pre>

blocks|key|721381|text|如果您不想使用内置openmp调度选项，如@Jonathan+Dursi's+answer所示，那么您可以自己实现所需的选项：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|721382|#include+<stdio.h>
#include+<omp.h>
/*+$+gcc+-O3+-fopenmp+-Wall+*.c+&&+./a.out++*/

static+void+doloop(int+n)+{
++int+thread_num,+num_threads,+start,+end,+i;
#pragma+omp+parallel+private(i,thread_num,num_threads,start,end)
++{
++++thread_num+=+omp_get_thread_num();
++++num_threads+=+omp_get_num_threads();
++++start+=+thread_num+*+n+/+num_threads;
++++end+=+(thread_num+%2B+1)+*+n+/+num_threads;

++++for+(i+=+start;+i+!=+end;+%2B%2Bi)+{
++++++printf("%25d+%25d\n",+thread_num,+i);
++++}
++}
}

int+main()+{
++omp_set_num_threads(2);
++doloop(10);
++return+0;
}|code-block|syntax|javascript|721383|输出|721384|0+0
0+1
0+2
0+3
0+4
1+5
1+6
1+7
1+8
1+9|721385|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/5605620/openmp-dynamic-loop-decomposition-in-chunks/5606608#5606608^0|L|O|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

If you don't want to use builtin openmp scheduling options as <a href="https://stackoverflow.com/questions/5605620/openmp-dynamic-loop-decomposition-in-chunks/5606608#5606608">@Jonathan Dursi's answer</a> shows then you could implement required options yourself:

<pre><code>#include &lt;stdio.h&gt;
#include &lt;omp.h&gt;
/* $ gcc -O3 -fopenmp -Wall *.c &amp;&amp; ./a.out */

static void doloop(int n) {
 int thread_num, num_threads, start, end, i;
#pragma omp parallel private(i,thread_num,num_threads,start,end)
 {
 thread_num = omp_get_thread_num();
 num_threads = omp_get_num_threads();
 start = thread_num * n / num_threads;
 end = (thread_num + 1) * n / num_threads;

 for (i = start; i != end; ++i) {
 printf("%d %d\n", thread_num, i);
 }
 }
}

int main() {
 omp_set_num_threads(2);
 doloop(10);
 return 0;
}
</code></pre>

<h3>Output</h3>

<pre><code>0 0
0 1
0 2
0 3
0 4
1 5
1 6
1 7
1 8
1 9
</code></pre>

I am using OpenMP to go through a large loop in parallel. Let's say the array I'm working on has N entries in total. I would like one thread to do the first N/2 entries and the other thread the last N/2. 

I have to avoid that the threads work on entries that are next to each other. The size N is always much bigger than the number of threads, so I don't need to worry about locks if I can get OpenMP to distribute the work the way I outlined above. 

If the size N is known at compiletime, I can use <code>#pragma omp parallel for schedule(static,N/2)</code>. Unfortunately it isn't. So, how do I define the chunk size dynamically?

OpenMP dynamic loop decomposition in chunks

我正在使用OpenMP并行执行一个大的循环。假设我正在处理的数组总共有N个条目。我希望一个线程做前N/2个条目，另一个线程做最后的N/2。我必须避免线程在相邻的条目上工作。大小N总是比线程的数量大得多，所以如果我能让OpenMP按照我上面概述的方式分发工作，我就不需要担心锁。如果在编译时大小N是已知的，我可以使用#pr...

问块中的OpenMP动态循环分解
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问块中的OpenMP动态循环分解EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问块中的OpenMP动态循环分解
EN