AllGather和AlltoAll的算子结构分析说明

最新推荐文章于 2025-03-04 19:50:41 发布
最新推荐文章于 2025-03-04 19:50:41 发布
阅读量1.7k 收藏 7
点赞数 4
分类专栏： 金融和量化 文章标签： 网络 服务器 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengidea/article/details/143360647
版权

AllGather 和 AllToAll 算子的 Ring 与 Pairwise 算法实现分析

在分布式计算和并行处理领域，AllGather 和 AllToAll 是两种常见的通信算子。它们用于在多个进程或节点之间交换和聚合数据。本文将以 AllGather 和 AllToAll 算子为例，介绍 Ring 和 Pairwise 两种算法的实现，并对其具体含义进行分析说明。

1. 算子的定义

1.1 AllGather 算子

AllGather 算子用于将每个参与进程的数据聚合到所有进程中。具体来说，假设有 P 个进程，每个进程拥有一部分数据，执行 AllGather 后，每个进程都将拥有所有进程的数据的集合。

1.2 AllToAll 算子

AllToAll 算子则更加灵活，它允许每个进程向所有其他进程发送不同的数据。因此，执行 AllToAll 后，每个进程将拥有来自所有其他进程的独特数据集合。

2. Ring 算法实现

Ring 算法是一种基于环形拓扑结构的通信算法，适用于实现 AllGather 和 AllToAll 算子。它通过节点之间的轮流传输数据，确保每个节点最终都能接收到所有其他节点的数据。

2.1 Ring 实现的 AllGather 算法

工作原理
  1. 拓扑结构：所有参与进程按环形排列，每个进程只有两个邻居：左邻和右邻。
  2. 数据传输：每个进程将自己的数据分成 P-1 个部分，分别发送给除自身外的 P-1 个进程。
  3. 轮次：共进行 P-1 轮，每轮每个进程接收来自左邻的数据并将其转发给右邻。
  4. 聚合数据：经过 P-1 轮后，每个进程收集到了所有其他进程的数据。
实现代码
package communication

import (
	"fmt"
	"net"
	"sync"
)

// RingAllGather 实现 AllGather 算子的 Ring 算法
type RingAllGather struct {
	numProcs int
	rank     int
	data     []byte
	recvData [][]byte
	conn     net.Conn
	mu       sync.Mutex
}

// NewRingAllGather 初始化 RingAllGather 实例
func NewRingAllGather(numProcs, rank int, data []byte, conn net.Conn) *RingAllGather {
	return &RingAllGather{
		numProcs: numProcs,
		rank:     rank,
		data:     data,
		recvData: make([][]byte, numProcs),
		conn:     conn,
	}
}

// Execute 执行 AllGather 操作
func (rag *RingAllGather) Execute() {
	var wg sync.WaitGroup
	wg.Add(rag.numProcs - 1)

	for i := 0; i < rag.numProcs-1; i++ {
		go func(step int) {
			defer wg.Done()
			// 发送数据到右邻
			rag.sendToRight(rag.data)
			// 接收来自左邻的数据
			received := rag.receiveFromLeft()
			// 存储接收到的数据
			rag.mu.Lock()
			rag.recvData[(rag.rank-step-1+rag.numProcs)%rag.numProcs] = received
			rag.mu.Unlock()
		}(i)
	}

	wg.Wait()

	// 聚合所有数据
	aggregatedData := rag.data
	for _, d := range rag.recvData {
		aggregatedData = append(aggregatedData, d...)
	}

	fmt.Printf("Process %d aggregated data: %v\n", rag.rank, aggregatedData)
}

// sendToRight 发送数据到右邻
func (rag *RingAllGather) sendToRight(data []byte) {
	// 假设右邻的连接已建立
	_, err := rag.conn.Write(data)
	if err != nil {
		fmt.Printf("Process %d failed to send data: %v\n", rag.rank, err)
	}
}

// receiveFromLeft 从左邻接收数据
func (rag *RingAllGather) receiveFromLeft() []byte {
	buffer := make([]byte, len(rag.data))
	_, err := rag.conn.Read(buffer)
	if err != nil {
		fmt.Printf("Process %d failed to receive data: %v\n", rag.rank, err)
	}
	return buffer
}

2.2 Ring 实现的 AllToAll 算法

工作原理
  1. 拓扑结构：与 AllGather 相同，采用环形拓扑。
  2. 数据传输：每个进程拥有与每个其他进程独立的数据。
  3. 轮次：共进行 P-1 轮，每轮每个进程发送指定目标的数据部分，并接收来自相邻进程的数据。
  4. 交换数据：通过轮次的传输，确保每个进程最终拥有来自所有其他进程的独立数据。
实现代码
package communication

import (
	"fmt"
	"net"
	"sync"
)

// RingAllToAll 实现 AllToAll 算子的 Ring 算法
type RingAllToAll struct {
	numProcs int
	rank     int
	sendData [][]byte
	recvData [][]byte
	conn     net.Conn
	mu       sync.Mutex
}

// NewRingAllToAll 初始化 RingAllToAll 实例
func NewRingAllToAll(numProcs, rank int, sendData [][]byte, conn net.Conn) *RingAllToAll {
	return &RingAllToAll{
		numProcs: numProcs,
		rank:     rank,
		sendData: sendData,
		recvData: make([][]byte, numProcs),
		conn:     conn,
	}
}

// Execute 执行 AllToAll 操作
func (ra2a *RingAllToAll) Execute() {
	var wg sync.WaitGroup
	wg.Add(ra2a.numProcs - 1)

	for i := 0; i < ra2a.numProcs-1; i++ {
		go func(step int) {
			defer wg.Done()
			target := (ra2a.rank + step + 1) % ra2a.numProcs
			// 发送目标数据到右邻
			ra2a.sendToRight(ra2a.sendData[target])
			// 接收来自左邻的目标数据
			received := ra2a.receiveFromLeft()
			ra2a.mu.Lock()
			ra2a.recvData[(ra2a.rank-step-1+ra2a.numProcs)%ra2a.numProcs] = received
			ra2a.mu.Unlock()
		}(i)
	}

	wg.Wait()

	fmt.Printf("Process %d received data: %v\n", ra2a.rank, ra2a.recvData)
}

// sendToRight 发送数据到右邻
func (ra2a *RingAllToAll) sendToRight(data []byte) {
	_, err := ra2a.conn.Write(data)
	if err != nil {
		fmt.Printf("Process %d failed to send data: %v\n", ra2a.rank, err)
	}
}

// receiveFromLeft 从左邻接收数据
func (ra2a *RingAllToAll) receiveFromLeft() []byte {
	// 假设每次发送的数据大小已知
	buffer := make([]byte, len(ra2a.sendData[0]))
	_, err := ra2a.conn.Read(buffer)
	if err != nil {
		fmt.Printf("Process %d failed to receive data: %v\n", ra2a.rank, err)
	}
	return buffer
}

3. Pairwise 算法实现

Pairwise 算法是一种分组交换的通信方法，通过成对进程之间的直接通信来实现数据的传递和聚合。这种方法适用于 AllGather 和 AllToAll 算子的高效实现，尤其在节点数量较大时表现出色。

3.1 Pairwise 实现的 AllGather 算法

工作原理
  1. 分组通信：将所有进程分为若干对，每对进程之间进行数据交换。
  2. 轮次：共进行 log₂P 轮，每轮每个进程与不同的伙伴进程交换数据。
  3. 数据聚合：经过若干轮的数据交换后，每个进程最终拥有所有其他进程的数据集合。
实现代码
package communication

import (
	"fmt"
	"net"
	"sync"
	"math"
)

// PairwiseAllGather 实现 AllGather 算子的 Pairwise 算法
type PairwiseAllGather struct {
	numProcs int
	rank     int
	data     [][]byte
	connMap  map[int]net.Conn
	mu       sync.Mutex
}

// NewPairwiseAllGather 初始化 PairwiseAllGather 实例
func NewPairwiseAllGather(numProcs, rank int, initialData []byte, connMap map[int]net.Conn) *PairwiseAllGather {
	data := make([][]byte, numProcs)
	data[rank] = initialData
	return &PairwiseAllGather{
		numProcs: numProcs,
		rank:     rank,
		data:     data,
		connMap:  connMap,
	}
}

// Execute 执行 AllGather 操作
func (pag *PairwiseAllGather) Execute() {
	numRounds := int(math.Ceil(math.Log2(float64(pag.numProcs))))
	for s := 0; s < numRounds; s++ {
		partner := pag.rank ^ (1 << s)
		if partner < pag.numProcs {
			go pag.exchangeData(partner)
		}
	}
	// 等待所有轮次完成
	// 这里可以使用同步机制，例如 WaitGroup
	// 简化起见，假设所有通信都是同步完成
	pag.aggregateData()
}

// exchangeData 与伙伴进程交换数据
func (pag *PairwiseAllGather) exchangeData(partner int) {
	conn, exists := pag.connMap[partner]
	if !exists {
		fmt.Printf("Process %d 无法连接到伙伴 %d\n", pag.rank, partner)
		return
	}
	// 发送当前数据
	for _, d := range pag.data {
		_, err := conn.Write(d)
		if err != nil {
			fmt.Printf("Process %d 发送数据给 %d 失败: %v\n", pag.rank, partner, err)
			return
		}
	}
	// 接收伙伴的数据
	buffer := make([]byte, 1024) // 假设每次接收的数据大小
	n, err := conn.Read(buffer)
	if err != nil {
		fmt.Printf("Process %d 从 %d 接收数据失败: %v\n", pag.rank, partner, err)
		return
	}
	received := buffer[:n]
	pag.mu.Lock()
	pag.data = append(pag.data, received)
	pag.mu.Unlock()
}

// aggregateData 聚合所有接收到的数据
func (pag *PairwiseAllGather) aggregateData() {
	aggregated := []byte{}
	for _, d := range pag.data {
		aggregated = append(aggregated, d...)
	}
	fmt.Printf("Process %d 聚合后的数据: %v\n", pag.rank, aggregated)
}

3.2 Pairwise 实现的 AllToAll 算法

工作原理
  1. 分组通信：每个进程与所有其他进程成对进行数据交换。
  2. 轮次：共进行 P-1 轮，每轮每个进程与一个特定的伙伴进程交换数据。
  3. 数据分发：通过轮次的数据交换，实现每个进程向所有其他进程发送不同的数据。
实现代码
package communication

import (
	"fmt"
	"net"
	"sync"
	"math"
)

// PairwiseAllToAll 实现 AllToAll 算子的 Pairwise 算法
type PairwiseAllToAll struct {
	numProcs int
	rank     int
	sendData [][]byte
	recvData [][]byte
	connMap  map[int]net.Conn
	mu       sync.Mutex
}

// NewPairwiseAllToAll 初始化 PairwiseAllToAll 实例
func NewPairwiseAllToAll(numProcs, rank int, sendData [][]byte, connMap map[int]net.Conn) *PairwiseAllToAll {
	recvData := make([][]byte, numProcs)
	return &PairwiseAllToAll{
		numProcs: numProcs,
		rank:     rank,
		sendData: sendData,
		recvData: recvData,
		connMap:  connMap,
	}
}

// Execute 执行 AllToAll 操作
func (paat *PairwiseAllToAll) Execute() {
	var wg sync.WaitGroup
	wg.Add(paat.numProcs - 1)

	for i := 0; i < paat.numProcs; i++ {
		if i == paat.rank {
			continue
		}
		go func(dest int) {
			defer wg.Done()
			conn, exists := paat.connMap[dest]
			if !exists {
				fmt.Printf("Process %d 无法连接到目标 %d\n", paat.rank, dest)
				return
			}
			// 发送数据到目标进程
			_, err := conn.Write(paat.sendData[dest])
			if err != nil {
				fmt.Printf("Process %d 发送数据到 %d 失败: %v\n", paat.rank, dest, err)
				return
			}
			// 接收来自目标进程的数据
			buffer := make([]byte, len(paat.sendData[dest]))
			_, err = conn.Read(buffer)
			if err != nil {
				fmt.Printf("Process %d 从 %d 接收数据失败: %v\n", paat.rank, dest, err)
				return
			}
			paat.mu.Lock()
			paat.recvData[dest] = buffer
			paat.mu.Unlock()
		}(i)
	}

	wg.Wait()
	fmt.Printf("Process %d 接收到的数据: %v\n", paat.rank, paat.recvData)
}

4. 分析与说明

4.1 Ring 与 Pairwise 算法的对比

  • 通信模式：

    • Ring 算法采用环形拓扑，每个进程与其左右邻居进行数据交换，适用于 AllGather 和 AllToAll 的实现。
    • Pairwise 算法则采用点对点通信，每个进程与所有其他进程成对通信，适用于 AllGather 和 AllToAll 的高效实现。

  • 复杂度：

    • Ring 算法的通信复杂度较低，适合节点数量较少的场景。
    • Pairwise 算法的通信复杂度较高，但在节点数量较大时依然保持高效。

  • 适用场景：

    • Ring 算法适用于需要简单实现且节点数量有限的 AllGather 和 AllToAll 操作。
    • Pairwise 算法适用于需要高效数据交换且节点数量较多的 AllGather 和 AllToAll 操作。

4.2 实现注意事项

  • 同步机制：在实现过程中，需要确保数据交换的同步性，避免数据丢失或重复接收。可以通过使用 WaitGroup 等同步工具实现。
  • 错误处理：在网络通信中，需处理连接失败、数据传输错误等异常情况，确保算法的健壮性。
  • 数据一致性：确保所有进程最终接收到的数据是一致且完整的，避免数据错位或丢失。

4.3 性能优化

  • 并行通信：通过并行发送和接收数据，可以提高通信效率，减少总的通信时间。
  • 缓冲区管理：合理管理数据缓冲区，避免内存浪费和数据拷贝，提高数据传输速度。
  • 拓扑优化：根据具体的网络拓扑，优化通信路径，减少网络延迟和瓶颈。

5. 结论

通过对 AllGather 和 AllToAll 算子的 Ring 与 Pairwise 算法的实现分析，可以看出这两种算法各有优势，适用于不同的应用场景。在实际应用中，可以根据具体需求和系统架构选择合适的算法，以实现高效的数据通信和聚合。

MPI中的all_to_all集合操作详解
TechNovaX的博客
08-24 907
该函数的第一个参数指定发送数据的起始地址，第二个参数指定每个进程要发送的数据量，第三个参数指定接收数据的起始地址。最终，每个进程将收到所有进程所发送的数据，因此接收数组的长度应该为4 * 进程数。它可以将每个进程所拥有的一组数据分发到其余所有进程中，并收集所有进程所发送的数据。首先，我们需要准备好一些数据，假设我们有4个进程，每个进程分别拥有一个长度为4的整型数组。从输出结果可以看出，每个进程都成功地将自己的数据发送给了其他所有进程，并正确地收到了所有进程发来的数据。
【有啥问啥】All-to-All 通信：原理、实现与应用
Chauvin的博客
02-26 1835
All-to-All 通信是一种多对多的通信模式，其中每个参与进程都向所有其他进程发送不同的数据，同时接收来自所有其他进程的数据。这种通信模式允许每个进程与其他所有进程进行数据交换，从而实现全局数据的共享和分发。All-to-All 通信作为一种高效的多对多通信模式，在分布式计算和并行处理领域具有重要的应用价值。通过 Ring 算法和 Pairwise 算法的实现，All-to-All 通信可以有效地提高数据分发和收集的效率，为高性能计算和分布式系统提供了强大的支持。
学习笔记：MPI组通信全互换ALLTOALL
10-28 9081
MPI_Alltoall 在使用MPI_Alltoall时，每一个进程都会向任意一个进程发送消息，每一个进程也都会接收到任意一个进程的消息。每个进程的接收缓冲区和发送缓冲区都是一个分为若干个数据块的数组。MPI_Alltoall的具体操作是：将进程i的发送缓冲区中的第j块数据发送给进程j，进程j将接收到的来自进程i的数据块放在自身接收缓冲区的第i块位置。 MPI_Alltoall与MPI_All...
层次化AlltoAll算子
最新发布
百态老人的博客
03-04 1087
层次化AlltoAll算子通过分阶段利用不同网络介质的带宽优势，解决了传统实现中因小数据包频繁跨节点通信导致的效率问题。其在MoE模型和大规模分布式训练中表现突出，是优化通信密集型任务的关键技术之一。
一种新的MPI Allgather算法及其在万亿次机群系统上的实现与性能分析.pdf
09-06
一种新的MPI Allgather算法及其在万亿次机群系统上的实现与性能分析.pdf
MPI之自己实现Alltoall()函数
Talk is cheap,show me the code!
05-31 3611
MPI_ALLTOALL是组内进程之间完全的消息交换，其中每一个进程都向其它所有的进程发送消息，同时，每一个进程都从其它所有的进程接收消息。本质上，它实现的效果就是矩阵的zhu
MPI编程实例（PI、AllGather、排序）
隔壁老王
04-30 1万+
对MPI进行简介，给出了编程实例。
pytorch分布式：all_gather, all_reduce
Hello Word!
04-29 5983
all_gather: 把一个tensor广播到一个list，返回tensor list .chunk: 把一个tensor切分成几块 # 把 features.data广播到list中的元素上，list中的内容是total_features切分成的几个块，最后返回这个list.相当于把features拷贝成了好几份 dist.all_gather(list(total_features.chunk(self.world_size, dim=0)), features.data) htt
分享实录上篇：利用 MegEngine 分布式通信算子实现复杂的并行训练
旷视开发者技术社区
04-29 542
在3月25日的MegEngine Meetup中，旷视研究院周亦庄讲师分享了《利用 MegEngine 分布式通信算子实现复杂的并行训练》。分享内容主要分为四个部分：1、 介绍 MegE...
mpi学习日志(5):mpi4py与多点通信续
ljhandlwt
07-19 2635
在多点通信里我们已经学习了广播bcast,散播scatter,收集gather,规约reduce. 今天我们再来简略看一些可能更为少用的多点通信. 1.allgather 简单来说就是收集+广播. gather中只有根进程会得到收集到的信息,而allgather则是所有进程都会得到收集到的信息,就相当于收集后再广播一次. 2.allredu
论文研究-MPI_ALLGATHER实现算法的改进与性能分析.pdf
09-07
在序信息系统中引入了知识粗糙熵和粗集粗糙熵的概念,得到了它们的有关性质,并证明了二者都随着知识确定程度的增强而单调下降的结论,从而给出了序信息系统的信息解释。进一步通过讨论它们之间的联系说明了粗集的粗糙...
MPI_Alltoallv详细介绍ppt
01-01
详细介绍了MPI_Alltoallv的各个参数使用，并举例说明具体用法
MPI之聚合通信-Scatter，Gather，Allgather
热门推荐
sinat_22336563的博客
04-18 3万+
MPI 一、 MPI_ScatterMPI_Scatter与MPI_Bcast非常相似，都是一对多的通信方式，不同的是后者的0号进程将相同的信息发送给所有的进程，而前者则是将一段array 的不同部分发送给所有的进程，其区别可以用下图概括： 0号进程分发数据的时候是根据进程的编号进行的，array中的第一个元素发送给0号进程，第二个元素则发送给1号进程，以此类推。MPI_Scatter(
ALL TO ALL（网页）
C891212的博客
08-12 6779
首先，打开网站进入到首页就能看见很多的转换类型，有FDF转WORD，视频类的，图片类的，文档类的，表格类的，压缩文件类的等等，共有200+的格式转化工具，实在是太全了，关键还免费，真的好舒服。给大家看下免费格式转化工具列表，简直是哇塞，太多了平时在工作中用得比较多的就是PDF，它转化成其他格式多达28种，真的好齐全。还有图片格式转换和文档格式转换平时都是用得比较频繁的，转化工具都是超多，有需要的可以自己再深入了解下。下载&nbsp;&nbsp;https://www.alltoall.net
深入浅出 pairwise 算法
aassddff261的专栏
01-16 2万+
深入浅出Pairwise 算法   作者：王勇                软件测试是软件开发中很重要的一环，在软件成本中也占着很大的比重。本文在介绍pairwise算法的基础上，提出了针对某一类问题的扩展算法并加以实现。        本文的组织结构如下： 第一，  本文首先简要介绍一下测试界中的著名的pairwise算法（约占文章的50%）。 第二，  然后提出了一种对p
分布式训练的通讯原语
ZOMI酱
02-10 4231
在深度学习框架中，分布式训练的通讯原语和通讯实现方式对AI框架分布式训练起着非常重要的作用，如果想要训练大模型（Foundation Model）肯定离不开进行通讯操作，下面橙色标签的是分布式训练中通讯原语在AI框架中的的位置。
分布式训练硬核技术——通讯原语
朝闻道
02-23 4140
针对分布式训练服务器的集群进行架构设计，是为了更好地解决机器学习中分布式训练中的通讯问题。目前机器学习中主要由两种分布式架构： 参数服务器架构（Parameter Server，PS） 去中心化架构（Decentralized Network） 其中，分布式训练通常在计算集群上进行，集群的每个节点分别执行一部分计算。不同节点的计算之间有数据依赖和共享，需要将数据在不同节点间传输，这就是通信。分布式的通信一般有两大类： 集合通信（Collective communication，CC）：在一组节...
AllGather operator
06-25
AllGather operator是分布式计算中的一种通信操作，它在分布式系统中用于所有进程或节点之间同步地交换数据。在分布式训练框架，如TensorFlow和PyTorch的DistributedDataParallel（DDP）或者其他并行计算库中，AllGather允许每个GPU或机器上的模型参数（或任何用户定义的数据）复制到所有其他节点，以便每个节点都拥有完整的数据集。 举个例子，在训练过程中，每个节点可能只负责一部分样本，AllGather操作会收集所有节点上这部分样本的更新，然后每个节点都可以使用全局的训练数据进行下一步迭代。这有助于保证模型训练的一致性和同步性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值