nvshare

`nvshare`：无内存大小限制的实用GPU共享机制

nvshare是一种GPU共享机制，允许多个进程（或在Kubernetes上运行的容器）安全地同时在同一物理GPU上运行，每个进程都能使用全部GPU内存。

您可以在 https://www.youtube.com/watch?v=9n-5sc5AICY 观看简短的解释和演示。

为实现这一点，它透明地启用GPU页面故障，使用系统RAM作为交换空间。为避免抖动，它使用nvshare-scheduler来管理GPU，并在给定的时间量子（TQ）内（默认持续30秒）为单个进程提供独占的GPU访问权限。

此功能仅依赖于NVIDIA内核驱动程序提供的统一内存API。NVIDIA内核驱动程序的更新不太可能影响此项目的可行性，因为这需要禁用统一内存。

在Kubernetes上处理GPU的事实上的标准方式（Nvidia的设备插件）是以1:1的方式将GPU分配给容器。这对于仅在执行过程中偶尔使用GPU的应用程序（如长期运行的交互式开发作业，例如Jupyter笔记本）来说特别低效。

我写了一篇Medium文章，讨论了Kubernetes上GPU共享的挑战，值得一读。

示例用例

在同一GPU上运行2个或更多具有不频繁GPU突发的进程/容器（例如，交互式应用、ML推理）
在同一GPU上运行2个或更多非交互式工作负载（例如，ML训练），以最小化它们的总完成时间并减少排队

功能特性

多个进程/容器共享单个GPU
保证内存和故障隔离，因为共同定位的进程使用不同的CUDA上下文，不像其他方法如NVIDIA MPS
对应用程序完全透明，无需代码更改
每个进程/容器都可以使用全部GPU内存
- 使用统一内存将GPU内存交换到系统RAM
- 调度器可选择性地序列化重叠的GPU工作以避免抖动（每次为一个应用分配TQ秒的独占访问权限）
- 应用程序在TQ结束前完成工作时释放GPU
Kubernetes的设备插件

核心思想

使用cudaMalloc()时，CUDA应用程序的内存分配总和必须小于物理GPU内存大小（Σ(mem_allocs) <= GPU_mem_size）。
通过钩子替换应用程序中所有的cudaMalloc()调用为cudaMallocManaged()，即透明地强制使用CUDA的统一内存API，这不会影响正确性，只会导致约1%的性能下降。
如果我们应用(2)，对于使用cudaMalloc()编写的应用程序，限制(1)不再适用。
当我们过度订阅GPU内存（Σ(mem_allocs) > GPU_mem_size）时，我们必须注意避免在共同定位应用程序的工作集（即它们正在主动使用的数据）不适合GPU内存时（Σ(wss) > GPU_mem_size）发生抖动。我们使用nvshare-scheduler来序列化GPU上的工作以避免抖动。如果我们不序列化工作，NVIDIA黑盒调度器在共同定位应用程序之间频繁（每几毫秒）的上下文切换将导致抖动。
如果我们知道Σ(wss) <= GPU_mem_size，我们可以禁用nvshare-scheduler的反抖动模式。

支持的GPU

nvshare依赖于Pascal微架构中引入的统一内存动态页面故障处理机制。

它支持任何Pascal（2016）或更新的Nvidia GPU。

它仅在Linux系统上进行过测试。

概述

`nvshare`组件

nvshare-scheduler，负责管理单个Nvidia GPU。它在想要在GPU上提交工作的共同定位客户端之间调度GPU"锁"。它以先来先服务的方式为客户端分配GPU的独占访问权限，每次持续TQ秒。
libnvshare.so，我们通过LD_PRELOAD注入到CUDA应用程序中，它：
- 拦截（钩子）应用程序对CUDA API的调用，将普通内存分配调用转换为其统一内存对应项
- 实现nvshare的客户端，与nvshare-scheduler实例通信，以在应用程序每次想要在GPU上进行计算时获得对GPU的独占访问权限。
nvsharectl，一个命令行工具，用于配置nvshare-scheduler实例的状态。

关于`nvshare-scheduler`的一些细节

重要提示：nvshare目前仅支持每个节点一个GPU，因为nvshare-scheduler硬编码使用ID为0的Nvidia GPU。 nvshare-scheduler的任务是防止内存颠簸。它以先来先服务的方式处理应用程序的请求，每次将整个GPU及其物理内存的独占使用权分配给单个应用程序。每个应用程序最多使用GPU TQ秒。如果应用程序处于空闲状态，它会提前释放GPU。当它稍后想要在GPU上进行计算时，会再次向调度器请求GPU访问权限。当调度器授予它GPU访问权限时，应用程序会通过页面错误逐步将数据获取到GPU。

如果共存应用程序的GPU内存使用总和适合可用的GPU内存，它们可以无缝地并行运行。

然而，当总内存使用超过GPU总内存时，nvshare-scheduler必须将不同进程的GPU工作序列化，以避免内存颠簸。

nvshare-scheduler的反颠簸模式默认是启用的。你可以使用nvsharectl进行配置。目前我们没有自动检测颠簸的方法，因此必须手动开关调度器。

单个进程的内存过度订阅

nvshare允许每个共存进程使用整个物理GPU内存。默认情况下，它不允许单个进程分配超过GPU容量的内存，因为这可能导致进程内部颠簸，无论同一GPU上是否存在其他进程。

如果你收到CUDA_ERROR_OUT_OF_MEMORY错误，意味着你的应用程序试图分配超过GPU总容量的内存。

你可以设置NVSHARE_ENABLE_SINGLE_OVERSUB=1环境变量，允许单个进程使用超过GPU物理可用内存的内存。这可能导致性能下降。

调度器的时间量子(TQ)

TQ仅在启用调度器的反颠簸模式时生效。

较大的时间量子会牺牲交互性(响应性)来换取吞吐量(利用率)。

调度器的TQ决定了调度器分配GPU给客户端的时间长度。较大的时间量子会牺牲交互性(延迟)来换取吞吐量(利用率)，反之亦然。

不应将时间量子设置得太小(< 10)，因为刚获得GPU锁的应用程序获取页面所花费的时间需要几秒钟，因此它没有足够的时间进行实际计算。

为了最小化一组连续(批处理)作业的总完成时间，你可以将TQ设置为很大的值。

没有nvshare时，你会耗尽内存，不得不一个接一个地运行作业。

使用nvshare时：

只有作业的GPU部分会在GPU上序列化运行，CPU部分将并行运行
每个应用程序只有在运行GPU代码时才会持有GPU(由于提前释放机制)

进一步阅读

nvshare基于我的学位论文"交互式机器学习开发中图形处理单元高效利用的动态内存管理"，该论文于2021年7月发表，可在http://dx.doi.org/10.26240/heal.ntua.21988 获取。

论文：

标题和第一部分是希腊语，但第二部分是完整的英文论文。你也可以在此仓库根目录下的grgalex-thesis.pdf中找到它。

演示：

查看关于nvshare的演示：

在本地系统上部署

安装(本地)

为了兼容性考虑，最好在安装前为你的系统从源代码构建`nvshare`。

(可选)从Releases标签下载最新发布的tarball，或通过命令行：

wget https://github.com/grgalex/nvshare/releases/download/v0.1.1/nvshare-v0.1.1.tar.gz -O nvshare.tar.gz

解压tarball：
```
tar -xzvf nvshare.tar.gz
```

安装libnvshare.so并更新动态链接器的缓存：

sudo mv libnvshare.so /usr/local/lib/libnvshare.so && \
sudo ldconfig /usr/local/lib

安装nvshare-scheduler：

nvshare使用UNIX套接字进行通信，并将它们存储在/var/run/nvshare下，所以必须以root身份运行。
```
sudo mv nvshare-scheduler /usr/local/sbin/nvshare-scheduler
```

安装nvsharectl：

sudo mv nvsharectl /usr/local/bin/nvsharectl

删除tarball：
```
rm nvshare.tar.gz
```

使用(本地)

启动nvshare-scheduler：

必须以root身份运行，所以我们必须使用sudo。

nvshare-scheduler可执行文件将：
- 创建/var/run/nvshare目录
- 创建/var/run/nvshare/scheduler.sock UNIX套接字
- 监听来自nvshare客户端的请求。
选项A：以正常日志启动nvshare-scheduler：
```
sudo bash -c 'nvshare-scheduler'
```
选项B：以调试日志启动nvshare-scheduler：
```
sudo bash -c 'NVSHARE_DEBUG=1 nvshare-scheduler'
```
[故障排除]：如果你收到以下错误：
```
nvshare-scheduler: /lib/x86_64-linux-gnu/libc.so.6: version `GLIBC_2.34' not found (required by nvshare-scheduler)
```
那么你必须为你的系统从源代码构建nvshare并重新安装。
使用LD_PRELOAD启动你的应用程序：

我们使用LD_PRELOAD将自定义nvshare逻辑注入到CUDA应用程序中。libnvshare自动检测它是否在CUDA应用程序中运行，只有在这种情况下才与nvshare-scheduler通信。

选项A：导出LD_PRELOAD变量：

export LD_PRELOAD=libnvshare.so

然后您可以像平常一样启动您的CUDA应用程序。

选项B：为单个程序设置LD_PRELOAD环境变量：

在程序前加上LD_PRELOAD指令，然后像平常一样启动您的程序。

LD_PRELOAD=libnvshare.so <您的程序> <您的参数>

选项C：在/etc/ld.so.preload中为libnvshare.so添加一个条目：

在某些情况下，例如使用Jupyter Notebook服务器时，可能很难为其启动后生成的Notebook设置环境变量。在这些情况下，您可以选择使用ld.so.preload文件。

sudo bash -c 'echo -ne "\n/usr/local/lib/libnvshare.so" >> /etc/ld.so.preload'

(可选) 使用nvsharectl配置nvshare-scheduler：

默认情况下，nvshare-scheduler是开启的。这意味着在TQ秒内，只有一个进程在GPU上运行计算。

用法: nvsharectl [选项]

一个用于配置nvshare调度器的命令行工具。

-T, --set-tq=n               将调度器的时间量子设置为TQ秒。仅接受正整数。
-S, --anti-thrash=s          设置调度器的所需状态。仅接受"on"或"off"值。
-h, --help                   显示此帮助信息

您可以通过设置NVSHARE_DEBUG=1环境变量为任何启用nvshare的应用程序启用调试日志。

测试（本地）

如果您不想使用docker，您可以通过克隆仓库，进入tests/目录，并使用LD_PRELOAD=libnvshare.so手动运行Python程序来进行测试。下面的默认测试每个使用约10 GB GPU内存。如果您的GPU至少有10 GB内存，请使用这些测试。

安装docker（https://docs.docker.com/engine/install/）
按照使用（本地）部分的说明启动nvshare-scheduler。
在终端窗口中，持续监视GPU状态：
```
watch nvidia-smi
```
从可用的Docker镜像中选择您的测试工作负载：
- 使用10 GB GPU内存的变体：
  - docker.io/grgalex/nvshare:tf-matmul-v0.1-f654c296
  - docker.io/grgalex/nvshare:pytorch-add-v0.1-f654c296
- 使用2 GB GPU内存的变体：
  - docker.io/grgalex/nvshare:tf-matmul-small-v0.1-f654c296
  - docker.io/grgalex/nvshare:pytorch-add-small-v0.1-f654c296
```
export WORKLOAD_IMAGE=docker.io/grgalex/nvshare:tf-matmul-v0.1-f654c296
```

在新的终端窗口中，启动运行测试工作负载的容器：

docker run -it --gpus all \
--entrypoint=/usr/bin/env \
-v /usr/local/lib/libnvshare.so:/libnvshare.so \
-v /var/run/nvshare:/var/run/nvshare \
${WORKLOAD_IMAGE?} \
bash -c "LD_PRELOAD=/libnvshare.so python /tf-matmul.py"

等待第一个容器开始在GPU上计算，然后：
- 查看nvshare-scheduler日志，观察神奇的过程。
- 查看nvidia-smi输出，根据https://forums.developer.nvidia.com/t/unified-memory-nvidia-smi-memory-usage-interpretation/177372解释内存使用情况。

在另一个终端窗口中，从您在步骤(4)中选择的相同镜像启动另一个容器：

export WORKLOAD_IMAGE=docker.io/grgalex/nvshare:tf-matmul-v0.1-f654c296

docker run -it --gpus all \
--entrypoint=/usr/bin/env \
-v /usr/local/lib/libnvshare.so:/libnvshare.so \
-v /var/run/nvshare:/var/run/nvshare \
${WORKLOAD_IMAGE?} \
bash -c "LD_PRELOAD=/libnvshare.so python /tf-matmul.py"

观察以下情况：
- 在给定时间点，只有两个应用程序中的一个在取得进展
- 与nvshare-scheduler日志进行交叉检查，查找REQ_LOCK、LOCK_OK、DROP_LOCK消息
- 与GPU空闲时相比，GPU功率较高
- 使用nvsharectl关闭调度器的反抖动模式
  - nvsharectl -S off
- 现在两个应用程序同时自由运行，发生抖动！
根据您的GPU内存容量，工作集可能仍然适合GPU内存，不会发生抖动。运行更多容器以引起抖动。
- 注意GPU的吞吐量，尤其是功率下降，因为计算单元处于空闲状态，页面错误占主导地位。
- 使用nvsharectl重新打开反抖动模式
  - nvsharectl -S on
- 抖动很快停止，应用程序开始再次取得进展。GPU功率也随之上升。
(可选) 重新运行，在LD_PRELOAD之前添加NVSHARE_DEBUG=1以查看调试日志，其中包括其他有趣的内容，显示了早期释放机制的运作。

在Kubernetes上部署

安装（Kubernetes）

要求：

NVIDIA的设备插件（https://github.com/NVIDIA/k8s-device-plugin）

部署nvshare Kubernetes组件：

nvshare-system命名空间
nvshare-system资源配额
nvshare-device-plugin DaemonSet
nvshare-scheduler DaemonSet

kubectl apply -f https://raw.githubusercontent.com/grgalex/nvshare/main/kubernetes/manifests/nvshare-system.yaml && \
kubectl apply -f https://raw.githubusercontent.com/grgalex/nvshare/main/kubernetes/manifests/nvshare-system-quotas.yaml && \
kubectl apply -f https://raw.githubusercontent.com/grgalex/nvshare/main/kubernetes/manifests/device-plugin.yaml && \
kubectl apply -f https://raw.githubusercontent.com/grgalex/nvshare/main/kubernetes/manifests/scheduler.yaml

设备插件在Kubernetes集群中的每个启用GPU的节点上运行（目前在非GPU节点上会失败，但这没关系），并管理每个节点上的单个GPU。它消耗一个nvidia.com/gpu设备，并将其作为多个（默认为10个）nvshare.com/gpu设备进行广告。这意味着最多10个容器可以在同一物理GPU上同时运行。

使用方法（Kubernetes）

在容器中使用`nvshare.com/gpu`设备

要使用nvshare虚拟GPU，你需要在容器的resources的limits部分请求一个'nvshare.com/gpu'设备。

实际上，你可以在容器规格中用nvshare.com/gpu替换nvidia.com/gpu。

你可以通过设置NVSHARE_DEBUG: "1"环境变量为任何启用nvshare的应用程序选择性地启用调试日志。你可以按照https://kubernetes.io/docs/tasks/inject-data-application/define-environment-variable-container/的说明来执行此操作。

要做到这一点，请在容器规格中添加以下行：

resources:
  limits:
    nvshare.com/gpu: 1

（可选）使用`nvsharectl`配置`nvshare-scheduler`实例

由于调度器是一个DaemonSet，每个节点上都有一个nvshare-scheduler实例。

将你想要更改的实例的Pod名称存储在一个变量中：

你可以使用kubectl get pods -n nvshare-system来查找名称。
```
NVSHARE_SCHEDULER_POD_NAME=<pod-name>
```

进入容器并使用nvsharectl重新配置调度器：

kubectl exec -ti ${NVSHARE_SCHEDULER_POD_NAME?} -n nvshare-system -- nvsharectl ...

测试（Kubernetes）

部署测试工作负载：

以下默认测试每个使用约10 GB的GPU内存。如果你的GPU至少有10 GB内存，请使用这些。或者，你可以选择tests/manifests目录中的任何一个。*-small变体使用较少的GPU内存。你可以克隆仓库或复制原始文件的链接并传递给kubectl。
```
kubectl apply -f https://raw.githubusercontent.com/grgalex/nvshare/main/tests/kubernetes/manifests/nvshare-tf-pod-1.yaml && \
kubectl apply -f https://raw.githubusercontent.com/grgalex/nvshare/main/tests/kubernetes/manifests/nvshare-tf-pod-2.yaml
```
在一个终端窗口中，观察第一个Pod的日志：
```
kubectl logs nvshare-tf-matmul-1 -f
```
在另一个窗口中，观察第二个Pod的日志：
```
kubectl logs nvshare-tf-matmul-2 -f
```
（可选）找到Pod运行的节点，观察该节点的nvshare-scheduler日志

删除测试工作负载：

kubectl delete -f https://raw.githubusercontent.com/grgalex/nvshare/main/tests/kubernetes/manifests/nvshare-tf-pod-1.yaml && \
kubectl delete -f https://raw.githubusercontent.com/grgalex/nvshare/main/tests/kubernetes/manifests/nvshare-tf-pod-2.yaml

卸载（Kubernetes）

从集群中删除所有nvshare组件：

kubectl delete -f https://raw.githubusercontent.com/grgalex/nvshare/main/kubernetes/manifests/scheduler.yaml
kubectl delete -f https://raw.githubusercontent.com/grgalex/nvshare/main/kubernetes/manifests/device-plugin.yaml && \
kubectl delete -f https://raw.githubusercontent.com/grgalex/nvshare/main/kubernetes/manifests/nvshare-system-quotas.yaml && \
kubectl delete -f https://raw.githubusercontent.com/grgalex/nvshare/main/kubernetes/manifests/nvshare-system.yaml && \

为本地使用构建

这些说明假设在基于Debian的系统上构建。

你可以在任何支持ELF二进制格式并具有glibc的机器上使用这些构建物。

安装要求：

sudo apt update && \
sudo apt install gcc make libc6-dev

克隆此仓库：

git clone https://github.com/grgalex/nvshare.git

进入源代码目录并构建nvshare：
```
cd nvshare/src/ && make
```
使用构建的nvshare-XXXX.tar.gz来本地部署nvshare，从步骤（2）开始，使用新的tarball名称。
删除构建产物：
```
make clean
```

构建Docker镜像

安装docker（https://docs.docker.com/engine/install/）

克隆此仓库：

git clone https://github.com/grgalex/nvshare.git

进入源代码目录：
```
cd nvshare/
```
（可选）编辑Makefile，更改镜像仓库。
构建核心Docker镜像：
```
make build
```
（可选）推送核心Docker镜像，并更新kubernetes/manifests下的Kubernetes清单以使用新镜像。
```
make push
```
构建测试工作负载Docker镜像：
```
cd tests/ && make build
```
（可选）推送测试工作负载Docker镜像，并更新tests/kubernetes/manifests下的Kubernetes清单以使用新镜像。
```
make push
```

<a name="future_improves"/> ## 未来改进 - `nvshare`目前仅支持每个节点使用一个GPU，因为`nvshare-scheduler`被硬编码为使用ID为0的Nvidia GPU。支持每个节点/机器使用多个GPU。 - 自动检测内存颠簸，最佳地开启/关闭`nvshare-scheduler`。 - 节点内GPU迁移。 - 节点间GPU迁移。 <a name="feedbk"/>

反馈

对于任何问题/缺陷/建议，请在此仓库中提出Github issue。
如果您的组织正在使用nvshare，您可以给我发消息/邮件，我可以将您添加到USERS.md中。

引用本工作

如果您觉得本工作有用，可以按以下方式引用：

Georgios Alexopoulos and Dimitris Mitropoulos. 2024. nvshare: 实用的
GPU共享方案，无内存大小限制。发表于2024年IEEE/ACM第46届
国际软件工程会议：配套论文集
(ICSE-Companion '24)，2024年4月14日至20日，葡萄牙里斯本。ACM，纽约，
纽约，美国，共5页。https://doi.org/10.1145/3639478.3640034