0

我是并行范式的新手。我已经让算法以串行形式工作，但我无法并行化它。

我四处询问，有人告诉我，我的程序编写方式不能并行化。

这是我的序列号，任何帮助或建议将不胜感激。

import numpy as np  #Importar la librería de numpy para usar sus funciones

if __name__ == "__main__":

  #Numero de elementos debe ser par
  N = 1_000_000_000#int(input("Número de iteraciones/intervalos (número par): "))
  
  #Declara la funcion a integrar
  f = lambda x : x*0.5
  
  #Limites
  a = 3#int(input("Dame el limite inferior: "))
  b = 10#int(input("Dame el limite superior: "))
  
  #delta de x
  dx = (b-a)/N
  
  #División de intervalos
  x = np.linspace(a,b,N+1) 
  
  y = f(x)
  
  #Suma de cada uno de los intervalos
  resultado = dx/3 * np.sum(y[0:-1:2] + 4*y[1::2] + y[2::2])
  
  print("N = " + str(N))
  print("El valor de la integral es: ")
  print(resultado)
4

1 回答 1

0

问：“是否可以在 Python 中并行化这个程序（辛普森规则）？”

同一枚硬币更重要的一面不是如何并行化程序（或其部分），而是实际发生的附加成本惩罚。从如何并行化的几个选项中，应该选择最好的一个。在这里，由于大数据/内存占用空间（SpaceDOMAIN 中不利的O( n )V * 8 * 1E9 [B]缩放，由于上述大小（所有使用的对象的内存占用空间之和，包括临时存储变量），接下来间接地增加由于内存-I/O 容量和所有可用 RAM-I/O 通道的瓶颈，TimeDOMAIN（持续时间）中的O(n)缩放）一种称为矢量化的细粒度并行性似乎最适合，因为它增加了几乎零附加成本，但有助于降低 RAM-I/O 成本，实现极低的复杂性f(x)-lambda，它使不连续块的内存预取（由于索引跳跃）几乎不可能被延迟屏蔽。

至少有两个地方，代码转换将有所帮助，大多数在 CPU 微架构上，它们的本地向量指令可以在最新版本中得到利用，以实现向numpy量化代码的 HPC 级并行执行。

性能调整强制免责声明：
详细的分析将向您展示每个特定目标代码执行平台 { x86 | 臂 | ... } 及其实际的 UMA / NUMA 内存 I/O 和 CPU 核心缓存层次结构，您的代码大部分时间都会丢失（以及实际处理器缓存层次结构掩盖实际成本的成功程度或差值）访问巨大的 RAM 占用空间以及物理 RAM 内存 I/O 成本的所有不利影响，因为对于 1E9 大小，这些不适合 CPU 核心缓存/寄存器）。

a )
我们可以在生成/存储临时对象上花费更少的时间，并使用勇敢的numpy代码智能矢量化技巧：

y = f( np.linspace( a,       # lo-bound
                    b,       # hi-bound
                    N + 1    #   steps
                    )        # no storage of a temporary, yet HUGE object x ~ 8[GB] in RAM
       )                     # +ask lambda to in-flight compute & create just y = f( x[:] )

如果有疑问，请随时阅读有关各种计算/存储相关访问延迟的成本的更多信息。

b）
我们可以减少，至少部分重复的内存访问模式，（如上所述，由于大小约为~1E9，不能保留在缓存中，必须重新执行并重新从物理 RAM ）仍然满足计算：

# proper fusing of the code against non-even N is left for clarity of vectorised
#                  and left to the kind user
#_________________________________________________________________ double steps
resultado = ( 4 * np.sum( f( np.linspace( a + dx,       # lo-bound
                                          b - dx,       # hi-bound
                                          ( N / 2 ) + 1 #    inner double steps
                                          )
                             ) #--------- lambda on a smaller, RAM/cache-compact object
                          )  #----------- numpy-controls the summation over contiguous RAM
            + 2 * np.sum( f( np.linspace( a + dx + dx,  # lo-bound
                                          b - dx - dx,  # hi-bound
                                          ( N / 2 ) + 1 #    inner double steps
                                          )
                             ) #--------- lambda on a smaller, RAM/cache-compact object
                          )  #----------- numpy-controls the summation overcontiguous RAM
            + f( a )
            + f( b )
              ) * dx / 3

虽然模型代码并不希望解决所有极端情况，但核心优势来自使用非常有效的 RAM 连续内存布局，numpy.sum()以及避免对内存区域的重复访问、重新访问仅仅由于命令式（非连续）索引跳转（numpy可以优化它自己的一些索引以最大化内存访问模式/缓存命中，但是“外部”编码索引跳转几乎总是超出这种聪明但硬连线的numpy优化技术的影响力（基于硅的思维或千里眼;o））

于 2020-11-25T10:10:17.673 回答