Gunakan layanan cGPU melalui command line Docker - Elastic GPU Service

cGPU memungkinkan beberapa container berbagi satu GPU dengan mengisolasi sumber daya GPU per container. Layanan ini disediakan sebagai komponen dari Container Service for Kubernetes (ACK) dan dirancang untuk beban kerja yang memerlukan kapasitas high performance computing (HPC), termasuk machine learning, deep learning, dan scientific computing.

Saat cGPU mengisolasi sumber daya GPU, permintaan memori GPU melalui Unified Virtual Memory (UVM) tidak didukung. Panggilan ke cudaMallocManaged() dari CUDA API akan gagal. Gunakan cudaMalloc() sebagai gantinya. Untuk latar belakang tentang UVM, lihat Unified Memory for CUDA Beginners.

Prasyarat

Sebelum memulai, pastikan instans yang dipercepat GPU Anda memenuhi semua persyaratan berikut:

Famili instans: gn7i, gn6i, gn6v, gn6e, gn5i, gn5, ebmgn7i, ebmgn6i, ebmgn7e, atau ebmgn6e
Sistem operasi: CentOS, Ubuntu, atau Alibaba Cloud Linux (Alinux)
Driver Tesla: versi 418.87.01 atau lebih baru
Docker: versi 19.03.5 atau lebih baru

Instal cGPU

Instal dan gunakan cGPU melalui lingkungan runtime Docker ACK, baik untuk deployment proyek enterprise maupun pribadi.

Penting

Versi cGPU 1.5.7 memiliki isu yang diketahui di mana proses paralel dapat menyebabkan driver kernel cGPU terkunci, sehingga memicu Linux Kernel Panic. Instal cGPU versi 1.5.8 atau lebih baru untuk menghindari masalah ini.

Buat kluster ACK yang dikelola. Untuk petunjuknya, lihat Buat kluster ACK yang dikelola.
Pada halaman Clusters, klik nama kluster tersebut. Di panel kiri, pilih Applications > Cloud-native AI Suite, lalu klik Deploy.
Pada bagian Basic Capabilities, pilih Scheduling Policy Extension (Batch Task Scheduling, GPU Sharing, Topology-aware GPU Scheduling).
Klik Deploy Cloud-native AI Suite.

Setelah instalasi selesai, komponen ack-ai-installer menampilkan status Deployed pada halaman Cloud-native AI Suite.

Gunakan cGPU

Contoh berikut menunjukkan dua container yang berbagi satu GPU pada instans ecs.gn6i-c4g1.xlarge yang dilengkapi GPU NVIDIA Tesla T4 (total memori GPU: 15.109 MiB, dibulatkan menjadi 15 GiB).

Variabel lingkungan

Tetapkan variabel lingkungan saat membuat container untuk mengontrol cara cGPU mengalokasikan sumber daya GPU.

Penting

Menyetel ALIYUN_COM_GPU_MEM_CONTAINER ke 0 atau membiarkannya kosong akan menonaktifkan cGPU dan beralih ke layanan container NVIDIA default.

Variabel	Tipe	Default	Deskripsi	Contoh
`CGPU_DISABLE`	Boolean	`false`	Menonaktifkan cGPU jika disetel ke `true`, beralih ke layanan container NVIDIA default.	`true`
`ALIYUN_COM_GPU_MEM_DEV`	Integer	—	Total memori GPU setiap GPU pada instans, dalam satuan GiB. Jalankan `nvidia-smi` pada instans untuk mendapatkan nilai ini.	`15`
`ALIYUN_COM_GPU_MEM_CONTAINER`	Integer	—	Memori GPU yang dialokasikan ke container, dalam satuan GiB. Gunakan bersama `ALIYUN_COM_GPU_MEM_DEV`. Menyetel ke `0` atau membiarkan kosong akan menonaktifkan cGPU.	`6`
`ALIYUN_COM_GPU_VISIBLE_DEVICES`	Integer atau UUID	—	GPU yang dialokasikan ke container. Tentukan nomor perangkat (misalnya, `0,1`) atau UUID dari output `nvidia-smi -L`.	`0,1`
`ALIYUN_COM_GPU_SCHD_WEIGHT`	Integer	—	Bobot penjadwalan relatif untuk container ini. Nilai valid: 1 hingga `max_inst`. Digunakan dengan penjadwalan preemptive berbasis bobot (kebijakan 2).	`2`
`ALIYUN_COM_GPU_HIGH_PRIO`	Integer	`0`	Prioritas container. `0` = biasa; `1` = prioritas tinggi. Container berprioritas tinggi dapat melakukan preemption daya komputasi GPU hingga batas `prio_ratio`. Konfigurasikan minimal satu container berprioritas tinggi per GPU saat menggunakan colocation workload campuran. Jika tugas GPU dijalankan dalam container berprioritas tinggi, container tersebut tidak dibatasi oleh kebijakan penjadwalan dan dapat melakukan preemption daya komputasi GPU. Jika tidak ada tugas GPU yang dijalankan dalam container berprioritas tinggi, container tersebut tidak terlibat dalam proses penjadwalan dan tidak dapat dialokasikan daya komputasi GPU.	`1`

Cara kerja `ALIYUN_COM_GPU_VISIBLE_DEVICES`

Jalankan nvidia-smi -L pada instans 4-GPU untuk menampilkan daftar nomor perangkat dan UUID:

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****)

Setel ke 0,1 untuk mengalokasikan GPU 0 dan GPU 1.
Setel ke GPU-b084ae33-e244-0959-cd97-83**,GPU-3eb465ad-407c-4a23-0c5f-bb,GPU-2fce61ea-2424-27ec-a2f1-8b** untuk mengalokasikan tiga GPU spesifik berdasarkan UUID.

Jalankan cGPU

Buat dua container dengan alokasi memori GPU terpisah. gpu_test1 — dialokasikan memori GPU 6 GiB:

Contoh-contoh ini menggunakan image TensorFlow nvcr.io/nvidia/tensorflow:19.10-py3. Ganti dengan image container Anda sendiri. Untuk petunjuk penggunaan image TensorFlow dalam menyiapkan lingkungan deep learning, lihat Deploy lingkungan NGC untuk pengembangan deep learning.

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 — dialokasikan memori GPU 8 GiB:

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

Verifikasi alokasi memori GPU di dalam container:
```
sudo docker exec -i gpu_test1 nvidia-smi
```
Output menunjukkan memori GPU container sebesar 6.043 MiB, yang mengonfirmasi alokasi tersebut.

Lihat status cGPU dengan node procfs

Runtime cGPU secara otomatis membuat dan mengelola node filesystem proc (procfs) di bawah /proc/cgpu_km/. Gunakan node ini untuk memeriksa dan menyesuaikan pengaturan cGPU saat runtime.

Daftar node tingkat atas:

Node	Akses	Deskripsi
`0`, `1`, `2`, ...	Baca/Tulis	Satu direktori per GPU. Pada contoh GPU tunggal ini, direktorinya bernama `0`.
`default_memsize`	Baca/Tulis	Memori GPU default yang dialokasikan saat `ALIYUN_COM_GPU_MEM_CONTAINER` tidak disetel.
`inst_ctl`	Baca/Tulis	Node kontrol.
`upgrade`	Baca/Tulis	Mengontrol pembaruan panas (hot update) cGPU.
`version`	Hanya baca	Versi cGPU.

ls /proc/cgpu_km/

Daftar parameter dalam direktori GPU (menggunakan GPU 0 sebagai contoh):

Parameter	Akses	Deskripsi
`012b2edccd7a`, `0852a381c0cf`, ...	Baca/Tulis	Satu direktori per container, dinamai berdasarkan ID container. Jalankan `docker ps` untuk menampilkan daftar ID container.
`free_weight`	Hanya baca	Bobot penjadwalan yang tersedia pada GPU ini. Saat `free_weight` bernilai `0`, container baru mendapatkan bobot nol dan tidak dapat memperoleh daya komputasi GPU.
`major`	Hanya baca	Nomor perangkat utama cGPU.
`max_inst`	Baca/Tulis	Jumlah maksimum container. Nilai valid: 1 hingga 25.
`policy`	Baca/Tulis	Kebijakan penjadwalan. Lihat Pilih kebijakan penjadwalan untuk detailnya.
`prio_ratio`	Baca/Tulis	Daya komputasi maksimum yang dapat dipreempt oleh container berprioritas tinggi. Nilai valid: 20 hingga 99.

ls /proc/cgpu_km/0

Daftar parameter dalam direktori container (menggunakan container 012b2edccd7a sebagai contoh):

Parameter	Akses	Deskripsi
`highprio`	Baca/Tulis	Flag prioritas tinggi. Default: `0`. Setel ke `1` (melalui `ALIYUN_COM_GPU_HIGH_PRIO`) untuk mengizinkan container ini melakukan preemption hingga `prio_ratio` daya komputasi GPU. Digunakan dalam colocation workload campuran.
`id`	Hanya baca	ID container.
`memsize`	Baca/Tulis	Memori GPU yang dialokasikan ke container ini, diturunkan dari `ALIYUN_COM_GPU_MEM_DEV`.
`meminfo`	Hanya baca	Detail memori GPU: memori tersisa, ID proses, dan penggunaan per proses. Contoh output: `Free: 6730809344` / `PID: 19772 Mem: 200278016`
`weight`	Baca/Tulis	Bobot penjadwalan untuk container ini. Default: `1`. Jumlah total bobot semua container yang berjalan tidak boleh melebihi `max_inst`.

ls /proc/cgpu_km/0/012b2edccd7a

(Opsional) Sesuaikan konfigurasi cGPU saat runtime:

Perintah	Efek
`echo 2 > /proc/cgpu_km/0/policy`	Beralih ke penjadwalan preemptive berbasis bobot.
`cat /proc/cgpu_km/0/free_weight`	Periksa bobot penjadwalan yang tersedia pada GPU 0.
`cat /proc/cgpu_km/0/$dockerid/weight`	Periksa bobot container tertentu.
`echo 4 > /proc/cgpu_km/0/$dockerid/weight`	Setel bobot container tertentu menjadi 4.

Monitor container dengan cgpu-smi

cgpu-smi menyediakan pemantauan GPU per container, termasuk ID container, pemanfaatan GPU, batas daya komputasi, penggunaan memori GPU, dan total memori yang dialokasikan.

cgpu-smi menyediakan data pemantauan contoh. Saat menerapkan workload Kubernetes, gunakan sebagai referensi untuk integrasi pemantauan kustom.

Pilih kebijakan penjadwalan

cGPU mendukung enam kebijakan penjadwalan, yang dikontrol oleh parameter policy di /proc/cgpu_km/<gpu>/policy. Tabel berikut membantu Anda memilih kebijakan yang tepat untuk workload Anda.

Kebijakan penjadwalan berlaku untuk daya komputasi GPU, bukan memori GPU. Batas memori selalu diberlakukan oleh ALIYUN_COM_GPU_MEM_CONTAINER, terlepas dari kebijakan yang digunakan.

Kebijakan	Nilai	Cara kerja	Paling cocok untuk
Fair-share	`0`	Membagi waktu GPU menjadi irisan tetap. Setiap container mendapatkan `1/max_inst` dari total daya komputasi, terlepas dari aktivitasnya.	Berbagi resource yang dapat diprediksi dan merata di semua container
Preemptive	`1`	Melewati container yang idle. Container aktif menyerap irisan waktu yang tidak terpakai, sehingga satu container aktif dapat menggunakan GPU penuh. Saat beberapa container menjadi aktif, masing-masing mendapatkan `1/N` di mana N adalah jumlah container aktif.	Workload variabel di mana tidak semua container aktif secara bersamaan
Weight-based preemptive	`2`	Mendistribusikan daya komputasi secara proporsional berdasarkan `ALIYUN_COM_GPU_SCHD_WEIGHT`. Docker 1 (bobot m) dan Docker 2 (bobot n) berbagi daya komputasi dengan rasio m:n. Berbeda dengan kebijakan 1, container idle tetap mengonsumsi irisan waktunya.	Workload yang memerlukan rasio komputasi berbeda namun tidak dibatasi secara ketat
Fixed	`3`	Menetapkan daya komputasi pada persentase tetap menggunakan `ALIYUN_COM_GPU_SCHD_WEIGHT` bersama dengan `max_inst`.	Alokasi komputasi yang ketat dan dapat diprediksi
Soft	`4`	Mirip dengan penjadwalan preemptive tetapi dengan batas isolasi yang lebih lunak.	Workload yang mendapat manfaat dari peminjaman resource fleksibel
Native	`5`	Hanya mengisolasi memori GPU. Daya komputasi mengikuti penjadwal GPU driver NVIDIA bawaan tanpa time slicing tingkat cGPU.	Workload yang hanya memerlukan isolasi memori dan lebih memilih penjadwalan komputasi native NVIDIA

Batasan penjadwalan preemptive berbasis bobot (kebijakan 2)

Rasio bobot bersifat maksimum teoretis, bukan jaminan mutlak. Pada GPU berkinerja tinggi seperti NVIDIA Tesla V100, tugas kecil dapat selesai dalam satu irisan waktu. Dalam kasus tersebut, sisa irisan waktu menganggur, sehingga batas komputasi teoretis menjadi tidak efektif. Sebagai contoh, pada rasio bobot 8:4, granularitas efektif lebih kasar daripada rasio 2:1 — jumlah irisan waktu per detik empat kali lebih sedikit — yang dapat mengurangi responsivitas untuk tugas-tugas pendek.

Contoh kebijakan penjadwalan

Semua kebijakan berlaku untuk instans GPU-accelerated Alibaba Cloud dan GPU NVIDIA yang digunakan, termasuk Tesla P4, Tesla P100, Tesla T4, Tesla V100, dan Tesla A10.

Contoh berikut menggunakan dua container yang berbagi GPU Tesla A10, dengan rasio daya komputasi 1:2 dan memori GPU masing-masing 12 GiB.

Data kinerja berikut hanya untuk referensi.

TensorFlow — ResNet50, FP16:

Ukuran batch	Docker 1 (img/s)	Docker 2 (img/s)
16	151	307
32	204	418
64	247	503
128	257	516

TensorRT — ResNet50, FP16:

Ukuran batch	Docker 1 (img/s)	Docker 2 (img/s)
1	568,05	1.132,08
2	940,36	1.884,12
4	1.304,03	2.571,91
8	1.586,87	3.055,66
16	1.783,91	3.381,72
32	1.989,28	3.695,88
64	2.105,81	3.889,35
128	2.205,25	3.901,94

Alokasikan memori di beberapa GPU

Gunakan ALIYUN_COM_GPU_MEM_CONTAINER dengan daftar yang dipisahkan koma untuk menetapkan batas memori berbeda untuk setiap GPU.

Contoh berikut mengalokasikan memori GPU di empat GPU: GPU 0 mendapat 3 GiB, GPU 1 mendapat 4 GiB, GPU 2 mendapat 5 GiB, dan GPU 3 mendapat 6 GiB.

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 nvidia-smi menunjukkan detail memori GPU.

Aturan nilai `ALIYUN_COM_GPU_MEM_CONTAINER` untuk beberapa GPU:

Nilai	Efek
`=3`	Menetapkan keempat GPU masing-masing 3 GiB.
`=3,1`	Menetapkan GPU 0 sebesar 3 GiB; GPU sisanya (1, 2, 3) masing-masing default 1 GiB.
`=3,4,5,6`	Menetapkan GPU 0 sebesar 3 GiB, GPU 1 sebesar 4 GiB, GPU 2 sebesar 5 GiB, GPU 3 sebesar 6 GiB.
Tidak disetel, `=0`, atau `=1,0,0`	Menonaktifkan cGPU.

Perbarui atau uninstal cGPU

Perbarui cGPU

cGPU mendukung dua mode pembaruan:

Pembaruan dingin (cold update) — gunakan saat cGPU tidak sedang melayani container Docker:
1. Hentikan semua container yang berjalan: ``bash sudo docker stop $(docker ps -a | awk '{ print $1}' | tail -n +2) ``
2. Jalankan skrip upgrade: ``bash sudo sh upgrade.sh ``
Pembaruan panas (hot update) — memperbarui driver kernel cGPU saat container sedang berjalan. Berlaku batasan kompatibilitas versi. Hubungi dukungan Alibaba Cloud untuk bantuan.

Uninstal cGPU

Untuk menguninstal cGPU dari sebuah node, lihat Upgrade versi cGPU pada node menggunakan CLI.