部分和任务OpenMP之间的区别
OpenMP的区别是什么：
#pragma omp parallel sections
{
#pragma omp section
{
fct1();
}
#pragma omp section
{
fct2();
}
}
和：
#pragma omp parallel
{
#pragma omp single
{
#pragma omp task
fct1();
#pragma omp task
fct2();
}
}
我不确定第二个代码是否正确...
What is the difference in OpenMP between :
#pragma omp parallel sections
{
#pragma omp section
{
fct1();
}
#pragma omp section
{
fct2();
}
}
and :
#pragma omp parallel
{
#pragma omp single
{
#pragma omp task
fct1();
#pragma omp task
fct2();
}
}
I'm not sure that the second code is correct...
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（2）
任务和部分之间的区别在于代码执行的时间范围。部分包含在
章节构造中，并且（除非指定了Nowait子句）线程将在执行所有章节之前不会离开它：此处
n线程遇到一个部分带有两个部分的构造，第二部分花费的时间比第一个花费更多。前两个线程每个执行一个部分。另一个n-2线程只需在各节构造末尾的隐式障碍物上等待（在此处显示为*）。在可能的任务调度点上尽可能将任务排队和执行。在某些情况下，即使在一生的中期，也可以允许运行时在线程之间移动任务。此类任务称为UNIDINE，并且可能会在一个线程中开始执行一个未接触的任务，然后在某些调度点可以将其迁移到另一个线程。
尽管如此，任务和部分在许多方面都相似。例如，以下两个代码片段实现了基本相同的结果：
task Wait非常像障碍，但对于任务 - 它可确保当前的执行流将被暂停，直到所有排队的任务都排队已执行。这是一个调度点，即允许线程处理任务。需要单个构造，以便仅一个线程创建任务。如果没有单个构造，则每个任务都将被创建num_threads次，这可能不是一个人想要的。NowAit单一construct中的子句指示其他线程不要等到执行单个construct执行（即在末尾删除了隐式障碍物单构造的）。因此，他们立即击中taskwait并开始处理任务。taskwait是此处显示的明确调度点。也有隐式调度点，最著名的是在屏障同步内部，无论是明确还是隐式。因此，上述代码也可以简单地写成：以下是有三个线程可能发生的情况：
在
|中显示的情况。 ... |是调度点的操作（task Wait指令或隐式障碍）。基本上是线程1和2暂停了他们在那时的工作，并从队列开始处理任务。处理所有任务后，线程将恢复其正常执行流。请注意，线程1和2可能会在线程0之前到达调度点左|s不需要对齐（上图上表示）。可能会碰到线程
1能够完成处理foo（）任务，甚至在其他线程能够请求任务之前请求另一个。因此，这两个foo（）和bar（）可能会由同一线程执行：如果TREED 2也出现，则可能会执行单调的线程可能执行第二个任务迟到：
在某些情况下，编译器或OpenMP运行时甚至可能会完全绕过任务队列并串行执行任务：
如果该区域代码中没有任务调度点，则OpenMP运行时可能会在认为合适的情况下启动任务。例如，可能会推迟所有任务，直到达到
并行区域结束时的屏障为止。The difference between tasks and sections is in the time frame in which the code will execute. Sections are enclosed within the
sectionsconstruct and (unless thenowaitclause was specified) threads will not leave it until all sections have been executed:Here
Nthreads encounter asectionsconstruct with two sections, the second taking more time than the first. The first two threads execute one section each. The otherN-2threads simply wait at the implicit barrier at the end of the sections construct (show here as*).Tasks are queued and executed whenever possible at the so-called task scheduling points. Under some conditions, the runtime could be allowed to move task between threads, even in the mid of their lifetime. Such tasks are called untied and an untied task might start executing in one thread, then at some scheduling point it might be migrated by the runtime to another thread.
Still, tasks and sections are in many ways similar. For example, the following two code fragments achieve essentially the same result:
taskwaitworks very likebarrierbut for tasks - it ensures that current execution flow will get paused until all queued tasks have been executed. It is a scheduling point, i.e. it allows threads to process tasks. Thesingleconstruct is needed so that tasks will be created by one thread only. If there was nosingleconstruct, each task would get creatednum_threadstimes, which might not be what one wants. Thenowaitclause in thesingleconstruct instructs the other threads to not wait until thesingleconstruct was executed (i.e. removes the implicit barrier at the end of thesingleconstruct). So they hit thetaskwaitimmediately and start processing tasks.taskwaitis an explicit scheduling point shown here for clarity. There are also implicit scheduling points, most notably inside the barrier synchronisation, no matter if explicit or implicit. Therefore, the above code could also be written simply as:Here is one possible scenario of what might happen if there are three threads:
Show here within the
| ... |is the action of the scheduling point (either thetaskwaitdirective or the implicit barrier). Basically thread1and2suspend what they are doing at that point and start processing tasks from the queue. Once all tasks have been processed, threads resume their normal execution flow. Note that threads1and2might reach the scheduling point before thread0has exited thesingleconstruct, so the left|s need not necessary be aligned (this is represented on the diagram above).It might also happen that thread
1is able to finish processing thefoo()task and request another one even before the other threads are able to request tasks. So bothfoo()andbar()might get executed by the same thread:It is also possible that the singled out thread might execute the second task if thread 2 comes too late:
In some cases the compiler or the OpenMP runtime might even bypass the task queue completely and execute the tasks serially:
If no task scheduling points are present inside the region's code, the OpenMP runtime might start the tasks whenever it deems appropriate. For example it is possible that all tasks are deferred until the barrier at the end of the
parallelregion is reached.我不是OpenMP的专家，但试图使用
task和e节pection 任务 poction
poction task
章节的结果：
任务结果：
在分发计算资源时，任务似乎比部分明智得多
-------------------------------------------------------------------- -Edit ----------------------------------
对于为此问题寻找答案的人，请参阅本文下的评论。
I am not an expert in OpenMP but tried to test fib sequence on my machine using both
taskandsectionssections
task
Result for sections:
Result for task:
It seems that task is much wiser than sections while distributing computing resources
-----------------------------EDIT-----------------------------
For people who looking for answers for this question, please see the comment under this post.