Gunakan cGPU dengan CLI Docker - Elastic GPU Service - Alibaba Cloud Documentation Center

cGPU mengisolasi sumber daya GPU sehingga memungkinkan beberapa kontainer berbagi satu kartu GPU. Fitur ini merupakan komponen dari Container Service for Kubernetes (ACK) yang dirancang untuk beban kerja high performance computing (HPC), seperti machine learning, deep learning, dan scientific computing, serta membantu mempercepat tugas komputasi dengan memanfaatkan sumber daya GPU secara lebih efisien. Topik ini menjelaskan cara menginstal dan menggunakan cGPU .

Catatan

Karena isolasi cGPU tidak mendukung Unified Virtual Memory (UVM), Anda tidak dapat memanggil cudaMallocManaged() untuk mengalokasikan memori GPU. Sebagai gantinya, gunakan cudaMalloc(). Untuk informasi selengkapnya, lihat dokumentasi NVIDIA.

Prasyarat

Pastikan instans yang dipercepat GPU Anda memenuhi persyaratan berikut:

Keluarga instans adalah salah satu dari berikut: gn7i, gn6i, gn6v, gn6e, gn5i, gn5, ebmgn7i, ebmgn6i, ebmgn7e, ebmgn6e.
Sistem operasi adalah salah satu dari berikut: CentOS, Ubuntu, atau Alibaba Cloud Linux.
Driver Tesla 418.87.01 atau versi yang lebih baru telah diinstal.
Docker 19.03.5 atau versi yang lebih baru telah diinstal.

Instal cGPU

Disarankan untuk menginstal dan menggunakan cGPU dalam runtime Docker ACK.

Penting

Menginstal cGPU versi 1.5.7 dapat menyebabkan deadlock (di mana proses konkuren saling memblokir) pada driver kernel cGPU, yang berpotensi memicu Linux Kernel Panic. Untuk menghindari error kernel pada beban kerja baru, disarankan menginstal cGPU versi 1.5.8 atau yang lebih baru, atau melakukan upgrade bertahap dari versi sebelumnya ke 1.5.8 atau yang lebih baru.

Buat kluster.

Untuk informasi selengkapnya, lihat Buat kluster ACK yang dikelola.
Pada halaman Clusters, klik nama kluster Anda. Di panel navigasi kiri, klik Applications > Cloud-native AI Suite.

Pada halaman Cloud-native AI Suite, klik Deploy.

Pada bagian Basic capabilities, pilih Scheduling Policy Extension (Batch Task Scheduling, GPU Sharing, Topology-aware GPU Scheduling).
Di bagian bawah halaman, klik Deploy Cloud-native AI Suite.

Setelah instalasi, komponen ack-ai-installer muncul dalam daftar komponen pada halaman Cloud-native AI Suite.

Gunakan cGPU

Topik ini menunjukkan cara dua kontainer pada instans ecs.gn6i-c4g1.xlarge berbagi satu GPU.

Variabel lingkungan cGPU

Anda dapat mengatur variabel lingkungan saat membuat kontainer untuk mengontrol daya komputasi yang dialokasikan cGPU kepadanya.

Variabel lingkungan	Tipe nilai	Deskripsi	Contoh
CGPU_DISABLE	Boolean	Menentukan apakah cGPU dinonaktifkan. Nilai yang valid: false: Mengaktifkan cGPU. true: Menonaktifkan cGPU dan menggunakan layanan kontainer NVIDIA default. Nilai default: false.	true
ALIYUN_COM_GPU_MEM_DEV	Integer	Mengatur total memori GPU setiap GPU pada instans yang dipercepat GPU dalam satuan GiB. Untuk instans ecs.gn6i-c4g1.xlarge yang dilengkapi satu GPU NVIDIA Tesla T4, Anda dapat menjalankan perintah nvidia-smi pada instans tersebut untuk melihat total memori GPU.	Untuk total memori GPU sebesar 15.109 MiB, atur nilainya menjadi 15 (15 GiB).
ALIYUN_COM_GPU_MEM_CONTAINER	Integer	Mengatur jumlah memori GPU yang terlihat oleh kontainer dalam satuan GiB. Variabel ini digunakan bersama dengan `ALIYUN_COM_GPU_MEM_DEV`. Contohnya: Pada GPU dengan memori total 15 GiB, mengatur `ALIYUN_COM_GPU_MEM_DEV=15` dan `ALIYUN_COM_GPU_MEM_CONTAINER=1` mengalokasikan 1 GiB memori GPU ke kontainer. Catatan Jika variabel ini tidak diatur atau diatur ke 0, cGPU dinonaktifkan, dan layanan kontainer NVIDIA default digunakan sebagai gantinya.	1
ALIYUN_COM_GPU_VISIBLE_DEVICES	Integer atau UUID	Pada instans yang dipercepat GPU dengan empat GPU, jalankan nvidia-smi -L untuk melihat nomor perangkat dan UUID GPU. Berikut contoh outputnya: `GPU 0: Tesla T4 (UUID: GPU-b084ae33-e244-0959-cd97-83**) GPU 1: Tesla T4 (UUID: GPU-3eb465ad-407c-4a23-0c5f-bb) GPU 2: Tesla T4 (UUID: GPU-2fce61ea-2424-27ec-a2f1-8b) GPU 3: Tesla T4 (UUID: GPU-22401369-db12-c6ce-fc48-d7)` Anda kemudian dapat mengatur variabel ini ke salah satu nilai berikut: `ALIYUN_COM_GPU_VISIBLE_DEVICES=0,1`: Mengalokasikan GPU pertama dan kedua ke kontainer. `ALIYUN_COM_GPU_VISIBLE_DEVICES=GPU-b084ae33-e244-0959-cd97-83,GPU-3eb465ad-407c-4a23-0c5f-bb,GPU-2fce61ea-2424-27ec-a2f1-8b**`: Mengalokasikan tiga GPU dengan UUID yang ditentukan ke kontainer.	`0,1`
ALIYUN_COM_GPU_SCHD_WEIGHT	Integer	Bobot daya komputasi kontainer. Nilainya harus berupa bilangan bulat dari 1 hingga `max_inst`.	None
ALIYUN_COM_GPU_HIGH_PRIO	Integer	Menentukan apakah akan mengonfigurasi prioritas tinggi untuk kontainer. Nilai yang valid: 0: Mengonfigurasi prioritas reguler untuk kontainer. 1: Mengonfigurasi prioritas tinggi untuk kontainer. Nilai default: 0. Catatan Untuk performa terbaik, atur hanya satu kontainer prioritas tinggi per GPU. Beberapa kontainer prioritas tinggi mengikuti kebijakan penjadwalan yang ditentukan. Ketika kontainer prioritas tinggi memiliki tugas GPU, ia dapat merebut daya komputasi GPU tanpa memedulikan kebijakan penjadwalan. Ketika kontainer prioritas tinggi menganggur, ia dikecualikan dari penjadwalan dan dialokasikan daya komputasi nol.	0

Menjalankan kontainer dengan cGPU

Jalankan perintah berikut untuk membuat kontainer dan mengatur memori GPU yang terlihat oleh masing-masing kontainer.

Dalam contoh ini, variabel lingkungan ALIYUN_COM_GPU_MEM_CONTAINER dan ALIYUN_COM_GPU_MEM_DEV diatur untuk menentukan memori GPU yang terlihat oleh kontainer dan total memori GPU perangkat.
- gpu_test1: mengalokasikan 6 GiB memori GPU.
```
sudo docker run -d -t --gpus all --shm-size=1g --ulimit memlock=-1 --ulimit stack=67108864 --name gpu_test1 -v /mnt:/mnt -e ALIYUN_COM_GPU_MEM_CONTAINER=6 -e ALIYUN_COM_GPU_MEM_DEV=15 nvcr.io/nvidia/tensorflow:19.10-py3
```
- gpu_test2: mengalokasikan 8 GiB memori GPU.
```
sudo docker run -d -t --gpus all --shm-size=1g --ulimit memlock=-1 --ulimit stack=67108864 --name gpu_test2 -v /mnt:/mnt -e ALIYUN_COM_GPU_MEM_CONTAINER=8 -e ALIYUN_COM_GPU_MEM_DEV=15 nvcr.io/nvidia/tensorflow:19.10-py3
```
Catatan
Perintah-perintah tersebut menggunakan gambar kontainer TensorFlow nvcr.io/nvidia/tensorflow:19.10-py3 sebagai contoh. Gantilah dengan gambar kontainer Anda sendiri. Untuk informasi selengkapnya tentang cara menggunakan gambar TensorFlow untuk membangun framework deep learning TensorFlow, lihat Deploy lingkungan NGC untuk pengembangan deep learning.

Jalankan perintah berikut untuk melihat informasi GPU kontainer, seperti memori GPU.

sudo docker exec -i gpu_test1 nvidia-smi

Sebagai contoh, memori GPU yang terlihat oleh kontainer gpu_test1 adalah 6.043 MiB, seperti yang ditunjukkan pada output berikut:

NVIDIA-SMI 440.33.01    Driver Version: 440.33.01    CUDA Version: 10.2
+-----------------------------------------------------------------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|=============================================================================|
|   0  Tesla T4            On   | 00000000:00:08.0 Off |                    0 |
| N/A   29C    P8     9W /  70W |      0MiB /  6043MiB |      0%      Default |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID   Type   Process name                             Usage      |
|=============================================================================|
|  No running processes found                                                 |
+-----------------------------------------------------------------------------+

Menampilkan informasi cGPU dengan node procfs

Saat cGPU berjalan, sistem secara otomatis menghasilkan dan mengelola beberapa node filesystem proc (procfs) dalam direktori /proc/cgpu_km. Anda dapat menggunakan node procfs ini untuk melihat dan mengonfigurasi informasi cGPU.

Jalankan perintah berikut untuk melihat informasi tentang node procfs.

ls /proc/cgpu_km/

Output berikut dikembalikan:

0  default_memsize  inst_ctl  upgrade  version

Node procfs

Node	Tipe akses	Deskripsi
`0`	Baca/Tulis	cGPU menghasilkan direktori untuk setiap GPU pada instans yang dipercepat GPU. Direktori tersebut diberi nama angka, seperti 0, 1, atau 2. Dalam contoh ini, hanya satu GPU yang digunakan, dan direktori yang sesuai adalah `0`.
`default_memsize`	Baca/Tulis	Jumlah default memori GPU yang dialokasikan ke kontainer baru jika variabel `ALIYUN_COM_GPU_MEM_CONTAINER` tidak diatur.
inst_ctl	Baca/Tulis	Node kontrol.
upgrade	Baca/Tulis	Mengontrol pembaruan panas (hot update) cGPU.
version	Hanya baca	Versi cGPU.

Jalankan perintah berikut untuk melihat isi direktori GPU.

Contoh ini menggunakan GPU 0.

ls /proc/cgpu_km/0

Output berikut dikembalikan:

012b2edccd7a    0852a381c0cf    free_weight    major    max_inst    policy    prio_ratio

Isi direktori GPU

File/Direktori	Tipe akses	Deskripsi
`012b2edccd7a` atau `0852a381c0cf`	Baca/Tulis	Direktori yang sesuai dengan kontainer. cGPU membuat direktori untuk setiap kontainer yang berjalan pada instans yang dipercepat GPU dan menggunakan ID kontainer sebagai nama direktori. Catatan Anda dapat menjalankan docker ps untuk melihat kontainer yang telah dibuat.
free_weight	Hanya baca	Menanyakan bobot yang tersedia pada GPU. Jika `free_weight=0`, kontainer yang baru dibuat diberi bobot 0. Kontainer tersebut tidak dapat memperoleh daya komputasi GPU.
major	Hanya baca	Nomor mayor cGPU, yang menunjukkan tipe perangkat.
max_inst	Baca/Tulis	Menentukan jumlah maksimum kontainer. Nilainya dapat berupa bilangan bulat dari 1 hingga 25.
policy	Baca/Tulis	Kebijakan penjadwalan daya komputasi. cGPU mendukung kebijakan berikut: 0: Penjadwalan fair-share. Setiap kontainer menempati time slice tetap. Proporsi time slice-nya adalah `1/max_inst`. 1: Penjadwalan preemptive. Setiap kontainer menempati sebanyak mungkin time slice. Proporsi time slice-nya adalah `1/Jumlah kontainer saat ini`. 2: Penjadwalan preemptive berbasis bobot. Kebijakan ini diaktifkan secara otomatis ketika `ALIYUN_COM_GPU_SCHD_WEIGHT` diatur ke nilai lebih besar dari 1. 3: Penjadwalan tetap. Digunakan untuk mengalokasikan persentase tetap daya komputasi. 4: Penjadwalan soft. Memberikan isolasi yang lebih lemah daripada penjadwalan preemptive. 5: Penjadwalan native. Kebijakan penjadwalan bawaan driver GPU. Anda dapat mengubah nilai `policy` untuk menyesuaikan kebijakan penjadwalan secara real time. Untuk informasi selengkapnya tentang kebijakan penjadwalan, lihat contoh penggunaan cGPU.
prio_ratio	Baca/Tulis	Dalam skenario colocation beban kerja, pengaturan ini menentukan daya komputasi maksimum, dalam persentase dari 20 hingga 99, yang dapat direbut oleh kontainer prioritas tinggi.

Jalankan perintah berikut untuk melihat isi direktori kontainer.

Contoh ini menggunakan kontainer 012b2edccd7a.

ls /proc/cgpu_km/0/012b2edccd7a

Output berikut dikembalikan:

highprio    id  meminfo  memsize  weight

Isi direktori kontainer

File	Tipe akses	Deskripsi
highprio	Baca/Tulis	Mengatur prioritas kontainer. Nilai default: 0. Ketika variabel `ALIYUN_COM_GPU_HIGH_PRIO` diatur ke 1, kontainer dapat merebut daya komputasi maksimum yang ditentukan oleh parameter `prio_ratio`. Catatan Fitur ini ditujukan untuk skenario colocation beban kerja.
id	Hanya baca	ID kontainer.
memsize	Baca/Tulis	Menentukan ukuran memori GPU dalam kontainer. cGPU secara otomatis mengatur nilai ini berdasarkan variabel `ALIYUN_COM_GPU_MEM_DEV`.
meminfo	Hanya baca	Memberikan informasi tentang memori GPU, termasuk memori GPU yang tersisa, ID proses (PID) proses yang menggunakan GPU, dan penggunaan memori GPU-nya. Berikut contoh outputnya: `Free: 6730809344 PID: 19772 Mem: 200278016`
weight	Baca/Tulis	Menentukan bobot kontainer untuk alokasi daya komputasi. Nilai default: 1. Jumlah bobot semua kontainer yang berjalan harus kurang dari atau sama dengan `max_inst`.

(Opsional) Jalankan perintah berikut untuk mengonfigurasi cGPU.

Anda dapat menggunakan node procfs untuk menjalankan perintah pada instans yang dipercepat GPU guna mengganti kebijakan penjadwalan, mengubah bobot, dan melakukan operasi lainnya. Tabel berikut memberikan contoh perintah.

Perintah	Efek
echo 2 > /proc/cgpu_km/0/policy	Mengganti kebijakan penjadwalan ke penjadwalan preemptive berbasis bobot.
cat /proc/cgpu_km/0/free_weight	Menampilkan bobot yang tersedia pada GPU. Jika `free_weight=0`, kontainer yang baru dibuat diberi bobot 0. Kontainer tersebut tidak dapat memperoleh daya komputasi GPU.
cat /proc/cgpu_km/0/$dockerid/weight	Menampilkan bobot kontainer tertentu.
echo 4 > /proc/cgpu_km/0/$dockerid/weight	Memodifikasi bobot daya komputasi untuk kontainer.

Menampilkan kontainer cGPU dengan cgpu-smi

Anda dapat menggunakan cgpu-smi untuk melihat informasi tentang kontainer cGPU, termasuk ID kontainer, pemanfaatan GPU, batas daya komputasi, memori GPU yang digunakan, dan total memori GPU yang dialokasikan.

Catatan

cgpu-smi adalah contoh alat pemantauan untuk cGPU. Saat Anda mendeploy aplikasi di Kubernetes (k8s), Anda dapat menggunakan atau menyesuaikan alat cgpu-smi untuk integrasi kustom.

|  Alibaba Cloud cGPU1.0                cGPU Version:  1.0.2
+---+----------------+----------+----------------+-----------------------+
|GPU|       pod      | highprio | GPU-Util/Limit | GPU Memory Usage/Total|
+===+================+==========+================+=======================+
|  0| 7db8fff70a0d   |    0     |     41/ 50     |           9459/11463  |
|  0| 91b1e19795ee   |    0     |     30/ 50     |           9457/11463  |
+---+----------------+----------+----------------+-----------------------+

Upgrade atau uninstal cGPU

Upgrade cGPU

cGPU mendukung pembaruan dingin (cold update) dan pembaruan panas (hot update).

Cold update

Untuk melakukan cold update ketika Docker tidak menggunakan cGPU:
1. Hentikan semua kontainer yang sedang berjalan:
```
sudo docker stop $(docker ps -a | awk '{ print $1}' | tail -n +2) 
```
2. Upgrade cGPU ke versi terbaru:
```
sudo sh upgrade.sh
```
Hot update

Jika Docker sedang menggunakan cGPU, Anda dapat melakukan hot update pada driver kernel cGPU. Namun, metode pembaruan ini tunduk pada batasan versi. Hubungi tim dukungan purnajual Alibaba Cloud untuk bantuan.

Uninstal cGPU

Untuk menguninstal versi cGPU sebelumnya dari sebuah node, lihat Upgrade versi cGPU node.

Contoh penggunaan cGPU

Penjadwalan daya komputasi

Saat cGPU memuat modul cgpu_km, sistem mengatur time slice (dalam milidetik) untuk setiap GPU berdasarkan jumlah maksimum kontainer (max_inst). Time slice ini—disebut Slice 1, Slice 2, hingga Slice N dalam topik ini—digunakan untuk mengalokasikan daya komputasi GPU ke kontainer. Contoh berikut menunjukkan berbagai kebijakan penjadwalan.

Penjadwalan fair-share (policy=0)

Saat membuat kontainer, cGPU mengalokasikan time slice untuk masing-masing. Penjadwal dimulai dengan Slice 1, mengirimkan tugas ke GPU fisik selama satu time slice, lalu beralih ke time slice berikutnya. Setiap kontainer menerima bagian daya komputasi yang sama, yaitu 1/max_inst, seperti yang ditunjukkan pada gambar berikut.
Penjadwalan preemptive (policy=1)

Saat membuat kontainer, cGPU mengalokasikan time slice kepada mereka. Penjadwal dimulai dengan Slice 1. Namun, jika tidak ada proses dalam kontainer yang mengakses GPU, penjadwal melewati time slice kontainer tersebut dan beralih ke berikutnya.
Contoh:
1. Anda membuat satu kontainer, Docker 1, yang dialokasikan Slice 1. Jika Anda menjalankan dua proses TensorFlow di Docker 1, kontainer tersebut dapat menggunakan daya komputasi seluruh GPU fisik.
2. Kemudian Anda membuat kontainer kedua, Docker 2, yang dialokasikan Slice 2. Jika tidak ada proses di Docker 2 yang mengakses GPU, penjadwal melewati time slice-nya (Slice 2).
3. Ketika proses di Docker 2 mulai mengakses GPU, Slice 1 dan Slice 2 keduanya dimasukkan dalam siklus penjadwalan. Docker 1 dan Docker 2 masing-masing dapat menerima hingga separuh daya komputasi GPU fisik, seperti yang ditunjukkan pada gambar berikut.
Penjadwalan preemptive berbasis bobot (policy=2)

Jika Anda mengatur ALIYUN_COM_GPU_SCHD_WEIGHT ke nilai lebih besar dari 1 saat membuat kontainer, cGPU secara otomatis menggunakan kebijakan ini. cGPU membagi daya komputasi GPU fisik menjadi max_inst bagian. Jika ALIYUN_COM_GPU_SCHD_WEIGHT lebih besar dari 1, cGPU menggabungkan beberapa time slice menjadi satu slice yang lebih besar untuk kontainer tersebut.
Konfigurasi contoh:
- Docker 1: ALIYUN_COM_GPU_SCHD_WEIGHT=m
- Docker 2: ALIYUN_COM_GPU_SCHD_WEIGHT=n
Perilaku penjadwalan:
- Jika hanya Docker 1 yang berjalan, ia merebut daya komputasi seluruh GPU fisik.
- Jika Docker 1 dan Docker 2 keduanya berjalan, mereka menerima daya komputasi dengan rasio teoretis m:n. Berbeda dengan penjadwalan preemptive, Docker 2 mengonsumsi n time slice meskipun tidak ada proses di dalamnya yang menggunakan GPU.
  
  Catatan
  Performa berbeda ketika rasio m:n diatur ke 2:1 dibandingkan dengan 8:4. Dalam kasus 2:1, jumlah pergantian time slice per detik empat kali lebih tinggi daripada kasus 8:4.
Penjadwalan preemptive berbasis bobot menetapkan batas maksimum teoretis pada daya komputasi GPU yang dapat digunakan kontainer. Namun, untuk GPU yang kuat seperti NVIDIA V100, tugas komputasi singkat mungkin selesai dalam satu time slice. Dalam skenario ini, jika rasio m:n adalah 8:4, GPU menganggur selama time slice yang tersisa, sehingga batas tersebut menjadi tidak efektif.
Penjadwalan tetap (policy=3)

Anda dapat mengalokasikan persentase tetap daya komputasi dengan menentukan rasio antara ALIYUN_COM_GPU_SCHD_WEIGHT dan max_inst.
Penjadwalan soft (policy=4)

Saat membuat kontainer, cGPU mengalokasikan time slice kepada mereka. Kebijakan ini memberikan isolasi yang lebih lemah dibandingkan penjadwalan preemptive. Untuk informasi selengkapnya, lihat Penjadwalan preemptive (policy=1).
Penjadwalan native (policy=5)

Kebijakan ini hanya mengisolasi memori GPU dan mengandalkan metode penjadwalan native dari driver GPU NVIDIA.

Kebijakan penjadwalan daya komputasi mendukung semua instans GPU-accelerated heterogen Alibaba Cloud dan GPU NVIDIA-nya, termasuk Tesla P4, Tesla P100, Tesla T4, Tesla V100, Tesla A10, . Pengujian berikut menggunakan dua kontainer yang berbagi satu instans GPU tunggal dengan GPU Tesla A10. Rasio daya komputasi antara kontainer adalah 1:2, dan memori GPU dibagi rata, masing-masing kontainer menerima 12 GB.

Catatan

Hasil pengujian performa berikut berasal dari lingkungan laboratorium dan hanya untuk referensi.

Uji 1: Membandingkan performa model ResNet50 yang dilatih pada framework TensorFlow dengan presisi FP16 pada berbagai nilai batch_size. Hasilnya ditunjukkan di bawah ini:

Framework	Model	batch_size	Presisi	Images/sec (Docker 1)	Images/sec (Docker 2)
TensorFlow	ResNet50	16	FP16	151	307
TensorFlow	ResNet50	32	FP16	204	418
TensorFlow	ResNet50	64	FP16	247	503
TensorFlow	ResNet50	128	FP16	257	516

111

Uji 2: Membandingkan performa model ResNet50 yang dilatih pada framework TensorRT dengan presisi FP16 pada berbagai nilai batch_size. Hasilnya ditunjukkan di bawah ini:

Framework	Model	batch_size	Presisi	Images/sec (Docker 1)	Images/sec (Docker 2)
TensorRT	ResNet50	1	FP16	568,05	1132,08
TensorRT	ResNet50	2	FP16	940,36	1884,12
TensorRT	ResNet50	4	FP16	1304,03	2571,91
TensorRT	ResNet50	8	FP16	1586,87	3055,66
TensorRT	ResNet50	16	FP16	1783,91	3381,72
TensorRT	ResNet50	32	FP16	1989,28	3695,88
TensorRT	ResNet50	64	FP16	2105,81	3889,35
TensorRT	ResNet50	128	FP16	2205,25	3901,94

2021-11-26_10-53-29

Pemartisian memori multi-GPU

Contoh ini menunjukkan cara mempartisi memori di empat GPU, mengalokasikan 3 GB ke GPU 0, 4 GB ke GPU 1, 5 GB ke GPU 2, dan 6 GB ke GPU 3. Kode contohnya sebagai berikut:

docker run -d -t --runtime=nvidia  --name gpu_test0123 --shm-size=1g --ulimit memlock=-1 --ulimit stack=67108864 -v /mnt:/mnt -e ALIYUN_COM_GPU_MEM_CONTAINER=3,4,5,6 -e ALIYUN_COM_GPU_MEM_DEV=23 -e NVIDIA_VISIBLE_DEVICES=0,1,2,3 nvcr.io/nvidia/tensorflow:21.03-tf1-py3
docker exec -i gpu_test0123   nvidia-smi

Output perintah menunjukkan detail memori keempat GPU.

NVIDIA-SMI 510.39        Driver Version: 510.39       CUDA Version: 11.6
-------------------------------+----------------------+----------------------+
 GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
 Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
                               |                      |               MIG M. |
===============================+======================+======================+
   0  NVIDIA A10           On  | 00000000:61:00.0 Off |                    0 |
  0%   31C    P8    15W / 150W |      0MiB /  3003MiB |      0%      Default |
                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
   1  NVIDIA A10           On  | 00000000:6B:00.0 Off |                    0 |
  0%   31C    P8    16W / 150W |      0MiB /  4004MiB |      0%      Default |
                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
   2  NVIDIA A10           On  | 00000000:CA:00.0 Off |                    0 |
  0%   30C    P8    15W / 150W |      0MiB /  5006MiB |      0%      Default |
                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
   3  NVIDIA A10           On  | 00000000:E3:00.0 Off |                    0 |
  0%   31C    P8    16W / 150W |      0MiB /  6007MiB |      0%      Default |
                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+

Tabel berikut menjelaskan parameter ALIYUN_COM_GPU_MEM_CONTAINER untuk konfigurasi multi-GPU.

Nilai	Deskripsi
ALIYUN_COM_GPU_MEM_CONTAINER=3	Mengatur memori GPU keempat GPU menjadi 3 GB.
ALIYUN_COM_GPU_MEM_CONTAINER=3,1	Mengatur memori GPU keempat GPU menjadi 3 GB, 1 GB, 1 GB, dan 1 GB, masing-masing.
ALIYUN_COM_GPU_MEM_CONTAINER=3,4,5,6	Mengatur memori GPU keempat GPU menjadi 3 GB, 4 GB, 5 GB, dan 6 GB, masing-masing.
ALIYUN_COM_GPU_MEM_CONTAINER tidak ditentukan	Menonaktifkan cGPU.
ALIYUN_COM_GPU_MEM_CONTAINER=0
ALIYUN_COM_GPU_MEM_CONTAINER=1,0,0