How to support multi-devices in our new framework

[QiJune]

1. 首先定义问题，这里的multi-devices仅仅指的是在单机上，一个网络的不同层可以被拆分到不同设备上执行

net = ['op1', 'op2', 'op3', 'op4']

如上述所示，op1在CPU上执行，op2在0号GPU上执行，op3在1号GPU上执行，op4在FPGA上执行

对于多机情况，限定多机是单机的简单复制，仅考虑数据并行，不支持模型跨多机执行。

2. 目前Paddle中有两个概念与设备紧密相关，分别是Place和DeviceContext.

Place定义如下：

typedef boost::variant<GPUPlace, CPUPlace, FPGAPlace> Place;

DeviceContext定义如下：

class DeviceContext {};
class CPUDeviceContext : public DeviceContext {};
class CUDADeviceContext : public DeviceContext {};
class FPGADeviceContext : public DeviceContext {};

这里的FPGAPlace和FPGADeviceContext是为了举例说明怎么向Paddle添加一个新设备的支持。

3. Operator是描述一个操作的，真正的计算发生在OpKernel里面。一个Operator可以对应于多个OpKernel。我们可以针对不同的设备实现不同的OpKernel，注册到一个map中。

而OpKernel的选择，是运行时根据传入DeviceContext所包含的Place信息决定的。

virtual void OperatorBase::Run(const Scope& scope, const platform::DeviceContext& dev_ctx) const = 0;

4. 考虑怎么根据用户的配置，执行一个multi-devices的网络：

• 首先VarDesc和OpDesc必须包含device信息，这样才能知道Op执行在什么设备上
• 需要实现copy operator，用于不同设备之间数据的拷贝。当用户配置跨设备网络时，必须显式添加copy operator（以后可以由Paddle来自动添加，减轻用户负担）
• 需要实现DeviceContextManager，可以根据网络配置中的device信息，预先创建出对应的DeviceContext。然后在执行每一个Operator时，可以从从DeviceContextManager里面去拿DeviceContext参数。
• 所以还是需要有一个Executor/Scheduler/etc，这样一个概念，来根据用户配置的device信息，从DeviceContextManager中拿到对应的DeviceContext，然后执行每一个Operator

[QiJune]

看了一下dynet对multi-devices的支持，贴在这里了，供大家参考

dynet multi-devices支持

dynet一个鲜明的特点是Graph的构造和执行是同时进行的。

Device定义

dynet中Device可以对应于Paddle中的Place和DeviceContext，同时包括了device id信息以及CUDA stream等相关资源。

class Device {};
class Device_GPU : public Device {};
class Device_CPU : public Device {};

相关全局变量

std::vector<Device*> devices; // 存储Device_GPU
std::unordered_map<std::string, Device*> devices_map // 存储所有device;

在初始化的时候，每个GPU构造一个对应的Device_GPU；同时会构造一个Device_CPU.

用户可以使用get_global_device接口拿对应的Device

// 接口声明如下：
Device* get_global_device(const std::string& name);

// 接口使用如下：
Device* cpu_device = get_global_device("CPU");
Device* gpu_device = get_global_device("GPU:0");

使用样例

可以参考这个例子

一些重点是

// 初始化的时候创建全局的device
dynet::initialize(argc, argv);

// 获取已创建的device
Device* cpu_device = get_global_device("CPU");
Device* gpu_device = get_global_device("GPU:0");

// 模型添加参数时需要指定device
Parameter p_W = m.add_parameters({HIDDEN_SIZE, 2}, gpu_device);


// 定义输入时，需要指定device
Expression x = input(cg, {2}, &x_values, gpu_device);

// 当需要跨设备计算时，需要显式调用to_device操作，实际上相当于一个copy operator
Expression h = tanh(W * x + b);
Expression h_cpu = to_device(h, cpu_device);

[Superjomn]

想到的一个简单且灵活的方案，需要

1. 添加类似 mxnet 中的 dependency_engine 实现解依赖并行
2. op 可以单独设置 device 信息（类似 tf.device)

第一点可以实现高效并行，并且不限制计算的表示（是图还是block），对当前框架的修改最小

第二点可以方便地实现模型并行和数据并行（可以在python端写）

如上图的模型，具体执行时

• block 存储了一个 array of operators
  • slice (a)
  • A
  • slice (b)
  • B
  • slice (c)
  • C
  • average
• dependency engine 通过对Variable 的 Read/Write 分析解开依赖，如下执行

slice(a) > A 
                     \
slice(b) > B    -  average
                     /
slice(c) > C

为每个 device 的分配一个线程，CPU分配一个线程，4线程并行可以实现多device并行

在这种设计里

• 计算的存储方式无所谓（不需要纠结graph/block) (参照 mxnet engine
• block无需考虑多线程/多device，现有设计无需复杂化
• 更灵活，表现力可以支持任意复杂的数据并行/模型并行（参照 tf.device)
• 兼容了 tf 和 mxnet 比较核心的优势

dependency engine 本身工作量不算大，已经复刻了一个简单版本 simple dependency engine

[helinwang]

谢谢@QiJune，写得非常清晰。

首先VarDesc和OpDesc必须包含device信息，这样才能知道Op执行在什么设备上

op 可以单独设置 device 信息（类似 tf.device)。第二点可以方便地实现模型并行和数据并行（可以在python端写）

Device信息我认为应该让Paddle自动添加，不必暴露给用户。模型并行和数据并行咱们都可以自己改图，不需要用户参与。

[helinwang]

接着春伟说的“dependency engine”：

我觉得Block需要改的地方有：

1. 删除Block::Run，只有OP能够Run，Block只是OP依赖关系图和数据流的表示，不能够被Run。

需要增加的模块：

1. 改图以及Placement模块：
   1. 根据用户eval的target，找子图。
   2. 按照单机多卡或者多机，自动扩充图（先支持数据并行，以后支持模型并行）。
   3. 自动做Placement的工作，给图中的OP加上Place（包含单机多卡和多机的情况）。按机器切分图，加上send／recv OP。
   4. 发送给对应的engine运行。（单机只有一个engine，多机每个机器一个engine）
2. engine（叫dependency engine或者scheduler）拿到图之后不用做任何其他操作可以运行给定的图（Block）。

[QiJune]

@helinwang

Device信息我认为应该让Paddle自动添加，不必暴露给用户。模型并行和数据并行咱们都可以自己改图，不需要用户参与。

这里的multi-devices主要是指模型并行，即一个网络有些op由CPU执行，有些op由FPGA执行。那么就必须由用户来指定每个op在哪个具体的设备上执行。
即使用户不需要添加copy operator，由Paddle负责来改图，那么device信息还是要有的。至少copy operator得知道自己的src device和dst device是什么。

[QiJune]

@Superjom
赞同有dependency engine的相关设计，以及需要有tf.device的设计。

block 存储了一个 array of operators

block中的operator能不能在不同的device设备上？即前一个operator在CPU上，后一个operator在FPGA上。

[shijiaxin]

如果由Paddle添加Copy operator，是不是应该也由Paddle处理不同设备上同一个variable的命名问题？
比如用户写的是如下代码：
Operator("mul", X="A", Y="B", Out="C", device = "CPU")
Operator("softmax", X="C", Y="hidden", device = "GPU0")
那么Paddle会改写成：
Operator("mul", X="A", Y="B", Out="C", device = "CPU")
Operator("copy", X="C", Y="C-gpu0", src_device = "CPU", dst_device = "GPU0")
Operator("softmax", X="C-gpu0", Y="hidden", device = "GPU0")