草庐IT

c++ - OpenMP 中的 "static"和 "dynamic"调度有什么区别？

coder 2023-05-02 原文

我开始使用 C++ 使用 OpenMP。

我有两个问题:

  • 什么是#pragma omp for schedule ?
  • dynamic有什么区别和 static ?

    • 请举例说明。

    最佳答案

    其他人已经回答了大部分问题，但我想指出一些特定的情况，其中特定的调度类型比其他的更适合。调度控制如何在线程之间划分循环迭代。选择正确的时间表会对应用程序的速度产生很大的影响。
    static调度意味着迭代块以循环方式静态映射到执行线程。静态调度的好处在于，OpenMP 运行时保证如果您有两个具有相同迭代次数的独立循环并使用静态调度以相同数量的线程执行它们，那么每个线程将获得完全相同的迭代范围( s) 在两个平行区域。这在 NUMA 系统上非常重要:如果您在第一个循环中接触一些内存，它将驻留在执行线程所在的 NUMA 节点上。然后在第二个循环中，同一个线程可以更快地访问同一个内存位置，因为它将驻留在同一个 NUMA 节点上。

    假设有两个 NUMA 节点:节点 0 和节点 1，例如双插槽 Intel Nehalem 板，两个插槽均带有 4 核 CPU。然后线程 0、1、2 和 3 将驻留在节点 0 上，线程 4、5、6 和 7 将驻留在节点 1 上:

    |             | core 0 | thread 0 |
| socket 0    | core 1 | thread 1 |
| NUMA node 0 | core 2 | thread 2 |
|             | core 3 | thread 3 |

|             | core 4 | thread 4 |
| socket 1    | core 5 | thread 5 |
| NUMA node 1 | core 6 | thread 6 |
|             | core 7 | thread 7 |

    每个内核都可以从每个 NUMA 节点访问内存，但远程访问比本地节点访问慢(在 Intel 上慢 1.5 到 1.9 倍)。你运行这样的东西:
    char *a = (char *)malloc(8*4096);

#pragma omp parallel for schedule(static,1) num_threads(8)
for (int i = 0; i < 8; i++)
   memset(&a[i*4096], 0, 4096);

    如果不使用大页面，在这种情况下，4096 字节是 x86 上 Linux 上一个内存页面的标准大小。此代码将整个 32 KiB 数组清零 a . malloc() call 只是保留虚拟地址空间，但实际上并没有“触及”物理内存(这是默认行为，除非使用其他版本的 malloc，例如，像 calloc() 那样将内存归零)。现在这个数组是连续的，但只在虚拟内存中。在物理内存中，一半位于连接到插槽 0 的内存中，另一半位于连接到插槽 1 的内存中。 这是因为不同的部分被不同的线程归零，并且这些线程驻留在不同的内核上，并且有一种叫做第一次接触的东西NUMA 策略，这意味着内存页分配在第一个“接触”内存页的线程所在的 NUMA 节点上。
    |             | core 0 | thread 0 | a[0]     ... a[4095]
| socket 0    | core 1 | thread 1 | a[4096]  ... a[8191]
| NUMA node 0 | core 2 | thread 2 | a[8192]  ... a[12287]
|             | core 3 | thread 3 | a[12288] ... a[16383]

|             | core 4 | thread 4 | a[16384] ... a[20479]
| socket 1    | core 5 | thread 5 | a[20480] ... a[24575]
| NUMA node 1 | core 6 | thread 6 | a[24576] ... a[28671]
|             | core 7 | thread 7 | a[28672] ... a[32768]

    现在让我们像这样运行另一个循环:
    #pragma omp parallel for schedule(static,1) num_threads(8)
for (i = 0; i < 8; i++)
   memset(&a[i*4096], 1, 4096);

    每个线程将访问已映射的物理内存，并且它将具有与第一个循环期间相同的线程到内存区域的映射。这意味着线程将只访问位于其本地内存块中的内存，这将是快速的。

    现在想象另一个调度方案用于第二个循环:schedule(static,2) .这会将迭代空间“切割”为两个迭代的块，总共会有 4 个这样的块。将会发生的是，我们将有以下线程到内存位置映射(通过迭代次数):
    |             | core 0 | thread 0 | a[0]     ... a[8191]  <- OK, same memory node
| socket 0    | core 1 | thread 1 | a[8192]  ... a[16383] <- OK, same memory node
| NUMA node 0 | core 2 | thread 2 | a[16384] ... a[24575] <- Not OK, remote memory
|             | core 3 | thread 3 | a[24576] ... a[32768] <- Not OK, remote memory

|             | core 4 | thread 4 | <idle>
| socket 1    | core 5 | thread 5 | <idle>
| NUMA node 1 | core 6 | thread 6 | <idle>
|             | core 7 | thread 7 | <idle>

    这里发生了两件坏事:
  • 线程 4 到 7 保持空闲，一半的计算能力丢失；
  • 线程 2 和 3 访问非本地内存，在线程 0 和 1 将保持空闲状态期间，它们将花费大约两倍的时间来完成。

    • 所以使用静态调度的优点之一是它提高了内存访问的局部性。缺点是调度参数选择不当会破坏性能。
    dynamic调度工作以“先到先得”为基础。具有相同线程数的两次运行可能(并且很可能会)产生完全不同的“迭代空间”->“线程”映射，因为可以轻松验证:
    $ cat dyn.c
#include <stdio.h>
#include <omp.h>

int main (void)
{
  int i;

  #pragma omp parallel num_threads(8)
  {
    #pragma omp for schedule(dynamic,1)
    for (i = 0; i < 8; i++)
      printf("[1] iter %0d, tid %0d\n", i, omp_get_thread_num());

    #pragma omp for schedule(dynamic,1)
    for (i = 0; i < 8; i++)
      printf("[2] iter %0d, tid %0d\n", i, omp_get_thread_num());
  }

  return 0;
}

$ icc -openmp -o dyn.x dyn.c

$ OMP_NUM_THREADS=8 ./dyn.x | sort
[1] iter 0, tid 2
[1] iter 1, tid 0
[1] iter 2, tid 7
[1] iter 3, tid 3
[1] iter 4, tid 4
[1] iter 5, tid 1
[1] iter 6, tid 6
[1] iter 7, tid 5
[2] iter 0, tid 0
[2] iter 1, tid 2
[2] iter 2, tid 7
[2] iter 3, tid 3
[2] iter 4, tid 6
[2] iter 5, tid 1
[2] iter 6, tid 5
[2] iter 7, tid 4

    (当使用 gcc 时观察到相同的行为)

    如果示例代码来自 static部分使用 dynamic 运行相反，调度将只有 1/70 (1.4%) 的机会保留原始位置，而 69/70 (98.6%) 的机会发生远程访问。这个事实经常被忽视，因此实现了次优的性能。

    在 static 之间选择还有另一个原因和 dynamic调度 - 工作负载平衡。如果每次迭代花费的时间与完成的平均时间有很大不同，那么在静态情况下可能会出现高度的工作不平衡。以完成一次迭代的时间随迭代次数线性增长的情况为例。如果迭代空间在两个线程之间静态划分，则第二个线程的工作量将是第一个线程的三倍，因此在 2/3 的计算时间中，第一个线程将处于空闲状态。动态调度引入了一些额外的开销，但在这种特殊情况下会导致更好的工作负载分配。一种特殊的 dynamic调度是 guided随着工作的进行，每个任务被赋予越来越小的迭代块。

    由于预编译的代码可以在各种平台上运行，如果最终用户可以控制调度，那就太好了。这就是为什么 OpenMP 提供了特殊的 schedule(runtime)条款。与 runtime调度类型取自环境变量OMP_SCHEDULE的内容.这允许在不重新编译应用程序的情况下测试不同的调度类型，还允许最终用户针对他或她的平台进行微调。

    关于c++ - OpenMP 中的 "static"和 "dynamic"调度有什么区别？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/10850155/

    amp34codethreadcorec++multithreadingopenmp

    有关c++ - OpenMP 中的 "static"和 "dynamic"调度有什么区别？的更多相关文章

    1. ruby - 如何从 ruby​​ 中的字符串运行任意对象方法？ - 2

      总的来说，我对ruby​​还比较陌生，我正在为我正在创建的对象编写一些rspec测试用例。许多测试用例都非常基础，我只是想确保正确填充和返回值。我想知道是否有办法使用循环结构来执行此操作。不必为我要测试的每个方法都设置一个assertEquals。例如:describeitem,"TestingtheItem"doit"willhaveanullvaluetostart"doitem=Item.new#HereIcoulddotheitem.name.shouldbe_nil#thenIcoulddoitem.category.shouldbe_nilendend但我想要一些方法来使用

    2. ruby - 为什么我可以在 Ruby 中使用 Object#send 访问私有(private)/ protected 方法？ - 2

      类classAprivatedeffooputs:fooendpublicdefbarputs:barendprivatedefzimputs:zimendprotecteddefdibputs:dibendendA的实例a=A.new测试a.foorescueputs:faila.barrescueputs:faila.zimrescueputs:faila.dibrescueputs:faila.gazrescueputs:fail测试输出failbarfailfailfail.发送测试[:foo,:bar,:zim,:dib,:gaz].each{|m|a.send(m)resc

    3. ruby - 其他文件中的 Rake 任务 - 2

      我试图在一个项目中使用rake，如果我把所有东西都放到Rakefile中，它会很大并且很难读取/找到东西，所以我试着将每个命名空间放在lib/rake中它自己的文件中，我添加了这个到我的rake文件的顶部:Dir['#{File.dirname(__FILE__)}/lib/rake/*.rake'].map{|f|requiref}它加载文件没问题，但没有任务。我现在只有一个.rake文件作为测试，名为“servers.rake”，它看起来像这样:namespace:serverdotask:testdoputs"test"endend所以当我运行rakeserver:testid时

    4. ruby-on-rails - Ruby net/ldap 模块中的内存泄漏 - 2

      作为我的Rails应用程序的一部分，我编写了一个小导入程序，它从我们的LDAP系统中吸取数据并将其塞入一个用户表中。不幸的是，与LDAP相关的代码在遍历我们的32K用户时泄漏了大量内存，我一直无法弄清楚如何解决这个问题。这个问题似乎在某种程度上与LDAP库有关，因为当我删除对LDAP内容的调用时，内存使用情况会很好地稳定下来。此外，不断增加的对象是Net::BER::BerIdentifiedString和Net::BER::BerIdentifiedArray，它们都是LDAP库的一部分。当我运行导入时，内存使用量最终达到超过1GB的峰值。如果问题存在，我需要找到一些方法来更正我的代

    5. ruby-on-rails - rails : "missing partial" when calling 'render' in RSpec test - 2

      我正在尝试测试是否存在表单。我是Rails新手。我的new.html.erb_spec.rb文件的内容是:require'spec_helper'describe"messages/new.html.erb"doit"shouldrendertheform"dorender'/messages/new.html.erb'reponse.shouldhave_form_putting_to(@message)with_submit_buttonendendView本身，new.html.erb，有代码:当我运行rspec时，它失败了:1)messages/new.html.erbshou

    6. ruby-on-rails - 由于 "wkhtmltopdf"，PDFKIT 显然无法正常工作 - 2

      我在从html页面生成PDF时遇到问题。我正在使用PDFkit。在安装它的过程中，我注意到我需要wkhtmltopdf。所以我也安装了它。我做了PDFkit的文档所说的一切......现在我在尝试加载PDF时遇到了这个错误。这里是错误:commandfailed:"/usr/local/bin/wkhtmltopdf""--margin-right""0.75in""--page-size""Letter""--margin-top""0.75in""--margin-bottom""0.75in""--encoding""UTF-8""--margin-left""0.75in""-

    7. ruby-on-rails - Rails 3 中的多个路由文件 - 2

      Rails2.3可以选择随时使用RouteSet#add_configuration_file添加更多路由。是否可以在Rails3项目中做同样的事情？ 最佳答案 在config/application.rb中:config.paths.config.routes在Rails3.2(也可能是Rails3.1)中，使用:config.paths["config/routes"] 关于ruby-on-rails-Rails3中的多个路由文件，我们在StackOverflow上找到一个类似的问题

    8. ruby-on-rails - Rails - 子类化模型的设计模式是什么？ - 2

      我有一个模型:classItem项目有一个属性“商店”基于存储的值，我希望Item对象对特定方法具有不同的行为。Rails中是否有针对此的通用设计模式？如果方法中没有大的if-else语句，这是如何干净利落地完成的？ 最佳答案 通常通过Single-TableInheritance. 关于ruby-on-rails-Rails-子类化模型的设计模式是什么？，我们在StackOverflow上找到一个类似的问题： https://stackoverflow.co

    9. ruby - 什么是填充的 Base64 编码字符串以及如何在 ruby​​ 中生成它们？ - 2

      我正在使用的第三方API的文档状态:"[O]urAPIonlyacceptspaddedBase64encodedstrings."什么是“填充的Base64编码字符串”以及如何在Ruby中生成它们。下面的代码是我第一次尝试创建转换为Base64的JSON格式数据。xa=Base64.encode64(a.to_json) 最佳答案 他们说的padding其实就是Base64本身的一部分。它是末尾的“=”和“==”。Base64将3个字节的数据包编码为4个编码字符。所以如果你的输入数据有长度n和n%3=1=>"=="末尾用于填充n%

    10. ruby - 解析 RDFa、微数据等的最佳方式是什么，使用统一的模式/词汇(例如 schema.org)存储和显示信息 - 2

      我主要使用Ruby来执行此操作，但到目前为止我的攻击计划如下:使用gemsrdf、rdf-rdfa和rdf-microdata或mida来解析给定任何URI的数据。我认为最好映射到像schema.org这样的统一模式，例如使用这个yaml文件，它试图描述数据词汇表和opengraph到schema.org之间的转换:#SchemaXtoschema.orgconversion#data-vocabularyDV:name:namestreet-address:streetAddressregion:addressRegionlocality:addressLocalityphoto:i

    随机推荐