【Ray 的单机部署/分布式部署及性能测试 】

已于 2024-06-25 22:52:34 修改
阅读量751 收藏 17
点赞数 12
文章标签： ubuntu github git python
于 2024-06-25 22:50:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60865812/article/details/139971832
版权

Lab 4: Ray 的单机部署/分布式部署及性能测试

实验简介

在本次实验中，我们小组选择了Ray进行部署，基于FFT算法实现了多项式乘法计算，并使用该程序完成了Ray的测试、分析、评价等工作。

测试任务

本次实验选择的测试任务为：计算大样本的方差。

性能指标列表

  • 延迟(Latency): 延迟是指在计算系统中，从发起一个操作或请求到操作完成之间的时间间隔。它是衡量系统响应速度和效率的重要指标之一。延迟通常以时间单位（如毫秒、微秒等）来衡量，较低的延迟意味着系统响应更快、效率更高。

  • 吞吐量(Throughput): 吞吐量是指在单位时间内处理的任务或者操作数量。它是衡量计算机系统或者网络系统性能的重要指标之一，以单位时间内完成的任务数量来衡量。

  • 可靠性(Reliability): 可靠性是指可靠性是指系统在特定时间内能够正常运行而不出现故障的能力。它是衡量系统在各种条件下持续运行的程度，通常包括故障率、可用性、容错能力、可恢复性和持久性等。

  • 可扩展性(Scalability): 可扩展性是指系统能够有效地处理和应对增加的工作负载或者请求量而不降低性能的能力。

  • 资源利用率(Resource Utilization): 资源利用率是指系统中各种资源（如CPU、内存、磁盘、网络带宽等）被有效利用的程度。资源利用率是衡量系统性能和效率的重要指标之一，它直接影响到系统的响应速度、稳定性和成本效益。

为了体现Ray对计算性能的提高作用，我们选取延迟和吞吐量作为后续测试的主要关注点。

测试程序

测试程序使用python完成, 测试时使用指令 python3 test.py arg1 arg2 arg3, 其中参数arg1表示多项式的项数以2为底的对数（默认为16）, arg2表示样本个数（默认为1000）, arg3表示任务的划分个数（默认为50000）。为了更好地使用FFT算法, 样本数据采用列表存储，数据由低位到高位对应列表表项由低位到高位。测试程序 test.py 如下:

import ray
import time
import sys
import math
import numpy as np

ray.init()

if len(sys.argv) < 2:
    vector_length: int = 16 # default value = 16
else:
    vector_length: int = int(sys.argv[1])
if len(sys.argv) < 3:
    sample_num: int = 1000
else:
    sample_num: int = int(sys.argv[2])
if len(sys.argv) < 4:
    pc_num: int = 50000
else:
    pc_num: int = int(sys.argv[3])
vector_size: int = 2 ** vector_length # 2^16-order polynomial

node_task_num: int = sample_num // pc_num

def FFT(p): # Fast Fourier Transform, p the polyminial
    n = int(len(p))
    if n == 1 :
        return p
    w = math.e ** (2 * math.pi * 1j / n)
    pe = p[::2]
    po = p[1::2]
    ye = FFT(pe)
    yo = FFT(po)
    y = np.empty(n, dtype= complex)
    for i in range(0, n // 2):
        y[i] = ye[i] + (w**i) * yo[i]
        y[i + n // 2] = ye[i] - w**i * yo[i]
    return y

def IFFT(p): # Inverse Fast Fourier Transform, p the polyminial
    n = int(len(p))
    if n == 1 :
        return p
    w = math.e ** (-2 * math.pi * 1j / n)
    pe = p[::2]
    po = p[1::2]
    ye = IFFT(pe)
    yo = IFFT(po)
    y = np.empty(n, dtype= complex)
    
    for i in range(0, n // 2):
        
        y[i] = ye[i] + (w**i) * yo[i]
        y[i + n // 2] = ye[i] - w**i * yo[i]
    return y

def polyminial_mul(p1, p2): # coeffs -> FFT, calculate and inverse the result by IFFT
    coeff1 = FFT(p1)
    coeff2 = FFT(p2)
    coeff = np.empty(len(p1) * 2, dtype= complex)
    
    for i in range (len(coeff2)):
        coeff[i] = coeff1[i] * coeff2[i]
    res = IFFT(coeff)
    for i in range (len(res)):
        res[i] = np.divide(res[i] , len(res))
    return res

@ray.remote
class Worker(object):
    def __init__(self):
        self.size = vector_size
        self.poly = self.poly_init()
        self.res = self.poly.copy()
        self.all_times = sample_num

    def poly_init(self):
        vector = np.random.randint(0, high = 10, size = vector_size, dtype= int)
        res = np.empty(vector_size, dtype= complex)
        for i in range(vector_size):
            res[i] += vector[i]
        return res

    # 计算 p^2
    def calculate(self, times):
        cur_time = time.time()
        task_res = []
        square_sum = np.empty(vector_size * 2, dtype= complex)
        sum = np.empty(vector_size, dtype= int)
        for k in range(times): 
            task = self.poly_init()
            task_copy = task.copy()
            for i in range(len(task)):
                sum[i] += task[i]
            task = polyminial_mul(task, task_copy)
            for i in range(len(task)):
                square_sum[i] += task[i]
        task_res.append(sum, square_sum)
        return task_res

if __name__ == '__main__':
    cur_time=time.time()
    worker = Worker.remote()
    temps=[]
    for i in range(pc_num):
        temp = worker.calculate.remote(node_task_num)
        temps.append(temp)

    result_list = ray.get(temps)

    rsquare_sum = np.empty(vector_size * 2, dtype= complex)
    rsum = np.empty(vector_size * 2, dtype= complex)
    result = 0
    for m in result_list:
        for i in range(len(m[0])):  
            rsum[i] += m[0][i] 
        for i in range(len(m[1])):  
            rsquare_sum[i] += m[1][i] 
            result += m[1][i] * (10 ** i)
    result /= sample_num
    ex = 0
    for i in range(len(rsum)):  
        ex += rsum[i] 
    ex /= sample_num
    result -= ex ** 2
    print("total duration: ", time.time() - cur_time)

单机版部署

测试机为USTC Vlab虚拟机，其操作系统为Ubuntu 22.04.4 LTS。

测试流程

  • 按照以下步骤安装Ray:

    • 安装python:
    sudo apt-get install python
    • 使用包管理器安装pip:
    sudo apt update
sudo apt install python3-pip

    如果你希望手动安装最新版本的 pip, 可以使用官方提供的 get-pip.py 脚本。以下是安装步骤:

    curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py # 使用 curl, 或者使用 wget 方法
wget https://bootstrap.pypa.io/get-pip.py               # 使用 wget
sudo python3 get-pip.py   # 对于 Python 3
sudo python get-pip.py    # 对于 Python 2

    最后使用pip --version命令验证是否安装成功

    • 安装Ray
    pip install -U ray
pip install 'ray[default]'

  • 使用 ray start --head 命令创建head节点

  • 如果测试程序命名为 test.py 且位于当前工作目录下, 使用python test.py 或 python3 test.py命令运行测试程序

  • 运行创建节点命令之后，会出现如下内容:

To monitor and debug Ray, view the dashboard at 
    127.0.0.1:8265

在浏览器中输入该ip地址，即可打开Dashboard查看运行结果

  • 输入ray stop命令结束测试
测试结果

测试结果截图见result.md。

多项式项数样本数量总吞吐量pc_num = 1pc_num = 10pc_num = 100pc_num = 1000pc_num = 10000pc_num = 50000
256100000204800000611.6088615.0404622.7523617.4893673.1099704.8914
1650000032000000151.6565158.4516156.1609153.4860161.6348171.9120

由于 FFT 算法的时间复杂度为 O(nlogn), 表中总吞吐量满足N = n * plogp, 式中p为多项式项数。由上表可得，当任务划分数小于1000时，其对程序延迟的影响很小，而当任务划分数大于10000时，程序延迟明显增大，我们认为任务数量的增加导致进程间开销增大，显著降低了运行效率，因此需要取一个较小的任务划分数。

使用 no_ray.py 测试不使用Ray进行部署时, 总吞吐量为 500000 的程序延迟, 并与上表数据作对比统计如下:

样本数量pc_num = 1pc_num = 10pc_num = 100pc_num = 1000pc_num = 10000pc_num = 50000
不使用 Ray 部署500000152.3679152.1764152.4549149.3331153.9519156.5193
Ray 的单机部署500000151.6565158.4516156.1609153.4860161.6348171.9120

使用 VMWare 虚拟机重新完成该部分实验，得到实验结果如下:

样本数量总吞吐量pc_num = 10pc_num = 100pc_num = 1000pc_num = 10000pc_num = 50000
不使用 Ray 部署5000004000000230.1585225.1164202.3590208.3154231.7103
Ray 的单机部署5000004000000245.4086224.2734258.8042274.7173389.0983

由上表可得，Ray 的单机部署在一定程度上增大了程序的运行时间，产生了额外的开销; 任务划分数取 100 时程序延迟较小，相较于默认的 pc_num = 50000时提高了 73.49% 的运行效率，因此选定 pc_num = 100 作为后续测试的参数值。

计算以上测试数据的吞吐量（单位: 任务数量/秒）如下:

多项式项数总吞吐量pc_num = 1pc_num = 10pc_num = 100pc_num = 1000pc_num = 10000pc_num = 50000
不使用 Ray 部署1632000000210017.92210282.24209898.24214286.08207.857.28204447.36
使用 Ray 部署256204800000669696665968.64657735.68663347.2608.501.76581099.52
使用 Ray 部署1632000000211002.88201954.56204917.12208488.32197976.96186141.44

从表格看出, 多项式项数的增加对于吞吐量的提升是巨大的，任务划分数为1000时，性能提升达到 218.17%，但是考虑到多项式项数较大时, 程序延迟过长, 不利于后续实验的数据统计, 因此选定多项式项数为8作为后续测试的对应参数值。

分布式部署

考虑到网络问题，Vlab虚拟机、Ubuntu 子系统、VMWare虚拟机之间无法通过 Ray 进行分布式部署，且组员的 Vlab 虚拟机之间也无法完成互联，我们选择在同一设备上的3台VMWare虚拟机上进行后续的实验。

实验环境

Ray 的分布式部署要求所有机器的 Python 版本相同，经过一系列调整，最终实验环境配置如下。

系统版本：Ubuntu 22.04

Python版本: 3.10.12

Numpy版本: 2.0.0

测试流程

  • 按照以下步骤安装Ray:

    • 安装python:
    sudo apt-get install python
    • 使用包管理器安装pip:
    sudo apt update
sudo apt install python3-pip

    如果你希望手动安装最新版本的 pip, 可以使用官方提供的 get-pip.py 脚本。以下是安装步骤:

    curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py # 使用 curl, 或者使用 wget 方法
wget https://bootstrap.pypa.io/get-pip.py               # 使用 wget
sudo python3 get-pip.py   # 对于 Python 3
sudo python get-pip.py    # 对于 Python 2

    最后使用pip --version命令验证是否安装成功

    • 安装Ray
    pip install -U ray
pip install 'ray[default]'

  • 在主节点使用 ray start --head --port=6379 --include-dashboard=true --dashboard-host=0.0.0.0 --dashboard-port=8265 命令创建 head 节点, 此时会出现以下信息:

    To monitor and debug Ray, view the dashboard at 
        127.0.0.1:8265
    To add another node to this Ray cluster, run
        ray start --address='192.168.112.242:6379'

在浏览器中输入该ip地址，即可打开Dashboard查看运行结果。

  • 根据主节点处出现的信息，在从节点使用 ray start --address='192.168.112.242:6379' 命令加入 Ray 集群

  • 如果测试程序命名为 test.py 且位于当前工作目录下, 使用python test.py 或 python3 test.py命令运行测试程序

  • 输入ray stop命令结束测试

运行截图

工作列表
机器工作状态

测试结果

测试结果截图见result.md。

样本数量总吞吐量pc_num = 10pc_num = 100pc_num = 1000pc_num = 10000pc_num = 50000
不使用 Ray 部署50000012000000230.1585225.1164202.3590208.3154231.7103
Ray 的单机部署50000012000000245.4086224.2734258.8042274.7173389.0983
Ray 的双机部署50000012000000243.8166247.4581242.2816279.8488330.9344
Ray 的三机部署50000012000000201.4612251.2634241.3002275.0589329.7947

由以上数据可以得出，当任务数量增多时，创建任务的大量开销和通信开销导致程序的工作效率极大降低，这与单机部署得到的结论是相同的。除此之外，当分布式部署的机器数量增多时，程序的运行时间逐渐下降，证明了分布式部署在大规模任务中的实践价值。

在实验过程中，我们发现局域网的网络延迟对 Ray 分布式计算产生了重要的影响，如图所示:

网络延迟对 Ray 工作的影响

如图，我们分别使用校园网和手机热点测试了两个相同的任务，在手机热点的局域网下程序的运行时间明显快于校园网下，展示了局域网网速对 Ray 分布式部署的影响。

基于Docker的分布式部署

测试流程

  • 按照以下步骤安装 Docker:

    • 安装 Docker:
    sudo apt-get install docker.io
    • 使用如下命令下载Docker镜像
    sudo docker pull rayproject/ray
    • 在Docker中运行rayproject/ray, 进入 Ray 环境
    sudo docker run -it rayproject/ray

  • 在主节点使用 ray start --head --port=6379 --include-dashboard=true --dashboard-host=0.0.0.0 --dashboard-port=8265 命令创建 head 节点, 此时会出现以下信息:

    To monitor and debug Ray, view the dashboard at 
        127.0.0.1:8265
    To add another node to this Ray cluster, run
        ray start --address='192.168.112.242:6379'

在浏览器中输入该ip地址，即可打开Dashboard查看运行结果。

  • 根据主节点处出现的信息，在从节点使用 ray start --address='192.168.112.242:6379' 命令加入 Ray 集群

  • 如果测试程序命名为 test.py 且位于当前工作目录下, 使用python test.py 或 python3 test.py命令运行测试程序

  • 输入ray stop命令结束测试

运行截图

分布式部署成功

测试结果

由于上文提及的网络原因，基于Docker的分布式部署未能实现，以下仅展示基于Docker的单机部署实验结果，如图所示。
任务划分数为100
任务划分数为1000

C3H6O908
关注
Ray 部署及性能测试
qwjsjwje的博客
07-03 2491
分布式计算框架 Ray 的部署和性能测试。
Ray的部署及测试
m0_69940860的博客
06-13 1151
本文为中科大OSH实验报告，阐述了Ray的部署及测试过程
部署说明文档（ray）
weixin_48279400的博客
07-01 453
ray的部署说明文档
Ray的单机、多机部署及性能优化
m0_73251643的博客
06-25 1774
Ray 是伯克利大学 RISELab 研发的分布式计算系统，本篇文章将进行ray的单机部署、多机部署以及性能测试等工作。实验环境为ustc的vlab虚拟机。
Ray 单机部署&多机部署&docker部署
m0_62162986的博客
06-20 4936
本次选择的测试任务为转移概率矩阵的近似极限分布。
机器学习分布式框架Ray
Python中文社区
09-09 1412
1.什么是Ray分布式计算框架大家一定都耳熟能详，诸如离线计算的Hadoop（map-reduce），spark， 流式计算的strom,Flink等。相对而言，这些计算框架都依赖于其他大...
——对小车最佳路径计算算法的ray部署和测试
mnluzimu的博客
07-01 303
我们组的选题是ros-RT-thread系统，实现PC端ros负责复杂计算，stm32端ros负责控制电机等实时性任务，而PC端的复杂计算就可以用到本次实验中ray部署的分布式并行计算。
Python分布式计算
01-02
- **Ray**：一个高性能的分布式执行框架，支持复杂的并行和分布式应用程序。 #### 四、异步编程 异步编程是一种编程范式，允许程序在等待某些操作（如I/O操作或网络请求）完成的同时继续执行其他任务。在Python中...
ray-3.0.0.dev0-cp39-cp39-win-amd64.zip
05-09
Ray的核心设计理念是提供一个统一的平台，用于简化分布式系统的开发，它允许用户在单机或集群上并行执行任务，而无需深入理解底层分布式系统的复杂性。通过Ray，你可以编写简单的Python代码来实现并行化和分布式计算...
Ray 部署与测试
FunnyCrafter的博客
06-25 1026
环境：# 注：不加default安装后没有dashboard显示进入该网址即可查看 dashboard。
Ray K8s 集群部署
Github_Lee的博客
05-23 4138
使用Kuberay Operator是官方推荐的方式，operator 提供了一种k8s原生方式的管理ray集群的方法。可以在本地 通过 Ray job submit 的方式将本地的 scripts 项目提交至 Ray 集群中执行。注意事项：我之前部署Ray 的时候有可能用的就是较早版本的 Kuberay operator。2）首先部署 kuberay operator：一个用来创建以及管理ray集群的 pod。kuberay operator已成功执行，现在可以通过它来部署一个简单的 ray集群。
【python】Ray集群搭建
qq_35061334的博客
10-27 8215
准备条件 python https://ray.readthedocs.io/en/latest/index.html
Ray入门指南——分布式框架（待更新）
weixin_43585712的博客
03-22 8027
win10+python3.7.3安装ray库 pip install -i https://mirrors.aliyun.com/pypi/simple/pytest-runner pip install -i https://mirrors.aliyun.com/pypi/simple/ray 使用ray库计算100次的延迟1秒 import ray import time import numpy as np # 启动Ray. ray.init() #定义remote函数 @ray.remote
Ray 环境搭建和示例
热门推荐
BerMaker
06-29 3万+
Ray 环境搭建和示例 文章目录Ray 环境搭建和示例Ray 环境设置安装 Python 3安装 Python 虚拟环境安装 Ray以 Cluster 模式运行 Ray示例参考 Ray 环境设置 本次实验采用 2 台 Mac，系统 macOS Mojave Version 10.14.3。 安装 Python 3 brew install python 安装 Python 虚拟环境 pip3 i...
深度学习&&scpray部署到django
qq_29507011的博客
04-13 362
1、scrapy 部署到django http://www.manongjc.com/detail/7-ckqevfsrbxpivoc.html 配置系统环境 ——部署到项目前 https://www.cnblogs.com/lutt/p/10895317.html 部署到项目后 2、深度学习 1 目标检测 fasterRCNN复现 https://blog.csdn.net/hu...
分布式执行框架——Ray简单使用
weixin_43255962的博客
11-24 8766
Ray是UC Berkeley RISELab新推出的高性能分布式执行框架，它使用了和传统分布式计算系统不一样的架构和对分布式计算的抽象方式，具有比Spark更优异的计算性能。 Ray目前还处于实验室阶段，最新版本为0.5版本。虽然Ray自称是面向AI应用的分布式计算框架，但是它的架构具有通用的分布式计算抽象。本文对Ray进行简单的介绍. 适合Linux和MacOS系统 安装pip install...
ray 集群概述
小那的博客
01-14 3362
ray 集群概述 ray的长处之一就是能够在一个程序中利用多个机器运行，在多机器的集群中才能发挥ray的真正能力。 关键的概念 ray node: ray 的集群是有一个head node和多个 worker node组成的。head node需要先启动，然后worker node使用head node的地址启动以形成集群。ray 集群自己可以做到自动缩放，可以与Cloud Provider交互，根据应用的工作负载来释放或者申请instances. ports: ray的进程是通过tcp端口号进行交流的。无
ubuntu无密码用SCP复制文件到windows
11-16 152
3. 在windows系统中创建一个administrators_authorized_keys文件，并复制id_ed25519.pub文件中的内容到administrators_authorized_keys文件中。4.移动administrators_authorized_keys文件到C:\ProgramData\ssh文件夹中。5.回到ubuntu系统中，再次使用scp复制文件到windows系统中，此时已不需要输入windows系统密码了。2.使用scp复制公钥到windows系统。
Cursor安装Windows / Ubuntu
最新发布
qq_43309940的博客
11-17 194
登入后按照引导将vscode中的扩展迁移至cursor中即可，很多扩展需要重新安装一下才能生效，如果扩展不生效请重新安装。之后和vscode同样的使用方式即可。第一次使用需要登入，首次登入有半个月的免费版，但是半个月后也可以轻度使用，重度使用需要氪金。至此ubuntu下的cursor安装完成。Windows按照引导自行安装使用即可。Icon的图片如下，自行下载到。在编辑器中添加下面内容。
Ray：高性能分布式执行框架解析
"高性能分布式执行框架——Ray" Ray是一个由UC Berkeley RISELab开发的高性能分布式执行框架，其设计目标是提供比现有系统如Spark更高的计算效率。尽管最初定位为面向人工智能应用的框架，但Ray的架构其实具备通用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值