如何解决OpenMDAO：ParallelGroup 的意外行为
在下面的示例中，两个 ParallelGroup 被设置为需要不同数量的 procs 来计算它们的串行子组件，似乎一个不应填满全局通信的组实际上确实可以，并且执行冗余/重复案例。在以前的版本中，未分配的 proc 不会执行它们的子组件。但它运行没有错误。
from mpi4py import MPI
import openmdao.api as om
class Exec(om.ExplicitComponent):
def __init__(self,val=-10):
super().__init__()
self.val = val
def setup(self):
self.add_output('y',0.)
def compute(self,inputs,outputs):
print('HELLO from Exec1,%s,global rank %i,val=%f' % (self.name,MPI.COMM_WORLD.rank,self.val))
outputs['y'] = self.val
class Exec2(om.ExplicitComponent):
def __init__(self,val):
super().__init__()
self.val = val
def setup(self):
self.add_input('x',0.)
self.add_output('y',outputs):
print('HELLO from Exec2,self.val))
outputs['y'] = self.val * inputs['x']
class Summer(om.ExplicitComponent):
def __init__(self,ncase):
super().__init__()
self.ncase = ncase
def setup(self):
for i in range(self.ncase):
self.add_input('y%i' % i,0.)
self.add_output('sum',outputs):
for i in range(self.ncase):
outputs['sum'] += inputs['y%i' % i]
p = om.Problem()
ncase = 3
par1 = p.model.add_subsystem('par1',om.ParallelGroup())
p.model.add_subsystem('summer1',Summer(ncase))
for i in range(ncase):
par1.add_subsystem('ex_%i' % i,Exec(val=float(i)),min_procs=1)
p.model.connect('par1.ex_%i.y' % i,'summer1.y%i' % i)
ncase2 = 4
par2 = p.model.add_subsystem('par2',om.ParallelGroup())
p.model.add_subsystem('summer2',Summer(ncase2))
for i in range(ncase2):
par2.add_subsystem('ex_%i' % i,Exec2(float(i)),min_procs=1)
p.model.connect('summer1.sum','par2.ex_%i.x' % i)
p.model.connect('par2.ex_%i.y' % i,'summer2.y%i' % i)
p.setup()
p.run_model()
解决方法
根据docs，处理器分配主要基于 proc_weight 使用循环分配方式完成。
用于分配的算法开始，假设进程数大于或等于子系统数，通过为每个子系统分配min_procs。然后，它根据权重将所有剩余进程添加到子系统中，注意不要超过指定的 max_procs（如果有）。
所以行为符合预期。 OpenMDAO 试图分配所有给定的处理器。然后由组件作者明智地使用它们。 如果您真的想这样做，您可以修改该组件，使除 Rank 0 以外的其他任何东西都不做任何事情，但我不建议这样做。
顺便说一句，您不应该这样引用 COMM_WORLD。每个组件都有一个您应该使用的本地通信。这是您示例的修改版本：
from mpi4py import MPI
import openmdao.api as om
class Exec(om.ExplicitComponent):
def __init__(self,val=-10):
super().__init__()
self.val = val
def setup(self):
self.add_output('y',0.)
def compute(self,inputs,outputs):
print('HELLO from Exec1,%s,global rank %i,comm size %i,val=%f' % (self.pathname,self.comm.rank,self.comm.size,self.val))
outputs['y'] = self.val
class Exec2(om.ExplicitComponent):
def __init__(self,val):
super().__init__()
self.val = val
def setup(self):
self.add_input('x',0.)
self.add_output('y',outputs):
print('HELLO from Exec2,self.val))
outputs['y'] = self.val * inputs['x']
class Summer(om.ExplicitComponent):
def __init__(self,ncase):
super().__init__()
self.ncase = ncase
def setup(self):
for i in range(self.ncase):
self.add_input('y%i' % i,0.)
self.add_output('sum',outputs):
for i in range(self.ncase):
outputs['sum'] += inputs['y%i' % i]
p = om.Problem()
ncase = 2
par1 = p.model.add_subsystem('par1',om.ParallelGroup())
p.model.add_subsystem('summer1',Summer(ncase))
for i in range(ncase):
par1.add_subsystem('ex_%i' % i,Exec(val=float(i)),min_procs=1)
p.model.connect('par1.ex_%i.y' % i,'summer1.y%i' % i)
ncase2 = 4
par2 = p.model.add_subsystem('par2',om.ParallelGroup())
p.model.add_subsystem('summer2',Summer(ncase2))
for i in range(ncase2):
par2.add_subsystem('ex_%i' % i,Exec2(float(i)),min_procs=1,max_procs=1)
p.model.connect('summer1.sum','par2.ex_%i.x' % i)
p.model.connect('par2.ex_%i.y' % i,'summer2.y%i' % i)
p.setup()
p.run_model()
在 4 个处理器上运行它给出：
HELLO from Exec1,par1.ex_0,global rank 0,comm size 2,val=0.000000
HELLO from Exec1,global rank 1,par1.ex_1,val=1.000000
HELLO from Exec1,val=1.000000
HELLO from Exec2,par2.ex_3,comm size 1,val=3.000000
HELLO from Exec2,par2.ex_0,val=0.000000
HELLO from Exec2,par2.ex_1,par2.ex_2,val=2.000000
所以你看到在 par1 中，每个组件都被赋予了一个大小为 2 的通信。这是你称之为浪费的重复。我认为这不是浪费，因为你如何设置组件的细节。 Exec 和 Exec2 都是串行组件（即它们没有 self.options['distributed'] = True）。 OpenMDAO 始终在拥有该组件的本地组通信中的所有级别上复制任何串行组件。这种重复的价值是降低 MPI 通信开销。由于该值是在本地计算的，您可以本地传输到该 proc 上的任何其他串行组件（而不必从根进行广播）。
如果您不想使用本地值，您可以选择自己在连接语句中设置 src_indices=[0]。然后，您将强制 OpenMDAO 从该通信的根进行广播。重复计算仍然会发生。它不应该浪费任何时间，因为在根 proc 进行计算时，重复的 proc 会闲置。您可以争辩说，由于额外的计算，它会浪费一些电力。在大多数情况下，这个成本会非常小，但是如果您担心它，您可以更改要分发的组件，并将除根之外的所有等级的变量大小设置为 0。然后，您可以将事情设置为没有重复的计算。
我们的经验是，大多数时候，通信开销是您想要避免的。这就是我们将其设计为复制的原因，但如果您愿意，您可以自由地解决它。
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
