是否可以在 Python 中并行化这个程序（辛普森规则）？答案

【问题标题】：Is it possible to parallelize this program (Simpson's Rule) in Python?是否可以在 Python 中并行化这个程序（辛普森规则）？
【发布时间】：2021-03-07 22:46:36
【问题描述】：

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

我四处打听，有人告诉我，我的程序编写方式无法并行化。

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

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)

【问题讨论】：

标签： python serialization parallel-processing simpsons-rule

【解决方案1】：

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

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

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

_{性能调整强制免责声明：

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

a)
我们可能会花更少的时间来生成/存储临时对象并使用勇敢的numpy-code 智能矢量化技巧：

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[:] )

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

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()-ed 以及避免对内存的重复访问-区域，仅由于命令式（非连续）索引跳转而重新访问（numpy 可以优化其自己的一些索引以最大化内存访问模式/缓存命中，但“外部”，编码指数跳跃几乎总是超出这种聪明但硬连线的numpy-优化技术的范围（_{基于硅的思维或千里眼;o）} )

【讨论】：