# 第四章(上)-并行程序性能分析

渐入佳境

# 加速比 & 效率

加速比的定义为:S(p)=TsTpS(p) = \frac{T_s}{T_p}

TsT_s:最优串行算法的执行时间

TpT_p:使用 p 个处理器的执行时间

串行

# 加速比

  • Linear speedup: S(p)=pS(p) = p

    • 理论上理想的加速比
  • Superlinear speedup: S(p)>pS(p) > p

    • 偶尔在实践中发生
    • 额外的硬件资源(例如:memory)
    • 软件或硬件的优化(例如:caching)
  • Maximum Speedup

    • 达到理想的最大加速比 S(p)=pS(p) = p 很困难
      • 程序不是每个不都能并行化(导致处理器空闲
      • 在并行计算中需要额外的计算量(例如:同步的开销)
      • 多个程序之间需要通信(通常是主要因素)
    • 使 ff 表示程序中无法并行的部分
      • S(p)=tsfts+(1f)ts/pS(p) = \frac{t_s}{ft_s + (1-f)t_s/p}
      • 假如处理器的数量趋向于无限大:S(p)p=p1+(p1)f=1fS(p)_{p \to \infty} = \frac{p}{1+(p-1)f} = \frac{1}{f}
串行

# 系统效率

System efficiency: E(p)=TsTp×p=S(p)p×100%E(p) = \frac{T_s}{T_p \times p} = \frac{S(p)}{p} \times 100\%

# 强扩展性 & 弱扩展性

# 强扩展性 strong scalability

  • 针对一个问题,负载不变,处理器个数增加
  • 旨在更快的解决一个问题
  • 如果加速比等于处理器个数,就能实现线性规模的增加
串行

# 弱扩展性 weak scalability

  • 分配给每个处理器的负载保持固定,增加处理器的数量能够解决更大规模的问题
  • 旨在用相同的时间解决更大规模的问题
  • 运行时间不变,工作能够不断增加,可实现线性规模的增长
串行

# 两者对比

Strong scaling Weak scaling
线性规模难以实现,因为随着问题规模增加,通信开销也会同比例增加 线性规模增加容易实现,因为不管使用多少进程,通信开销相对固定
通信使用 nearest-neighbor communication patterns

# 时间复杂度 & Cost optimality

本节的时间复杂度代价优化不仅考虑了并行算法的设计,还考虑了并行部分的通信

# Time Complexity Analysis

  • Tp=Tcomp+TcommT_p = T_{comp} + T_{comm}

    • TpT_p: 并行算法的执行时间
    • TcompT_{comp}: 计算部分的消耗
    • TcommT_{comm}: 同步部分的消耗
  • Tcomm=q(Tstartup+nTdata)T_{comm} = q(T_{startup} + nT_{data})

    • TstartupT_{startup}: 消息延迟(假设固定)
    • TdataT_{data}: 一条数据的传输时间
    • nn: 在一个消息中的数据的条数
    • qq: 消息的数量
串行

累加 NN 个数字的并行算法设计:

算法1

2个计算机来并行计算:

  • step-1. 电脑1把 n/2n/2 个数发送给 电脑2
  • step-2. 两台电脑同时加 n/2n/2 个数
  • step-3. 电脑2把部分和发送回电脑1
  • step-4. 电脑1把两个部分和加起来得到最终结果

复杂度分析:

  • Computation: (step-2 和 step-4)
    • Tcomp=n/2+1=O(n)T_{comp} = n/2 + 1 = O(n)
  • Communication: (step-1 和 step-3)
    • Tcomm=(Tstartup+n/2×Tdata)+(Tstartup+Tdata)=2Tstartup+(n/2+1)Tdata=O(n)T_{comm} = (T_{startup} + n/2 \times T_{data}) + (T_{startup} + T_{data}) = 2T_{startup} + (n/2 + 1)T_{data} = O(n)
  • 总体的时间复杂度:Tp=Tcomp+Tcomm=T_p = T_{comp} + T_{comm}= O(n)O(n)

算法2

m个处理器来并行计算:

(1)把 n 个数字平均的分给 m 个处理器
(2)m 个处理器同时相加 n/m 个数字
(3) 把 m 个部分和返回到一个处理器,相加得到最终结果

并行处理流程:

  • Phase1: 把 n 个数字发送给 m 个 slaves
    • tcomm1=m(tstartup+(n/m)tdata)t_{comm1} = m(t_{startup} + (n/m)t_{data})
  • Phase2: 累加部分和
    • tcomp1=n/m1t_{comp1} = n/m - 1
  • Phase3: 把结果发送给 master
    • tcomm2=m(tstartup+tdata)t_{comm2} = m(t_{startup} + t_{data})
  • Phase4: 计算最终结果
    • tcomp2=m1t_{comp2} = m - 1
  • Overall: 时间复杂度
    • tp=2mtstartup+(n+m)tdata+m+nm2t_p = 2mt_{startup} + (n + m)t_{data} + m + \frac{n}{m} - 2

由上述两个算法例子可知:
◇ 处理器个数少,通信开销少,计算的时间复杂度更高
◇ 处理器个数多,通信开销大,计算的时间复杂度更少

所以设计并行算法需要在 computationcommunication 之间做权衡


# Cost Optimal Algorithm

  • 定义
    • 解决问题的代价随着在单个处理器上的执行时间成正比例关系
    • O(Tp)×N=O(Ts)O(T_p) \times N = O(T_s)
      • O(Ts)O(T_s): 执行串行算法的时间复杂度
      • O(Tp)O(T_p): 执行并行算法的时间复杂度
  • 例子
    • Sequential algorithm: O(NlogN)O(N\log{N})
    • Parallel algorithm 1: uses NN processor with O(logN)O(\log{N})
    • Parallel algorithm 2: uses N2N^2 processor with O(1)O(1)

# 参考资料

Introduction parallel computing tutorial (opens new window)

台湾新竹清华大学 平行程式 (opens new window)

最近更新: 5/9/2022, 22:53:17