Menggunakan AI Profiling melalui baris perintah - Container Service for Kubernetes

Kemunculan Large Language Models (LLM) telah mendorong permintaan akan analisis dan optimasi kinerja detail halus dalam pelatihan AI dan inferensi. Organisasi yang menjalankan node berakselerasi GPU memerlukan analisis kinerja online untuk kontainer GPU. Di lingkungan Kubernetes, AI Profiling berfungsi sebagai alat analisis kinerja non-intrusif yang memanfaatkan Berkeley Packet Filter (eBPF) yang diperluas dan injeksi proses dinamis. Alat ini mendukung deteksi online tugas GPU terkontainerisasi melalui lima area utama: eksekusi proses Python, pemanggilan fungsi CPU, pemanggilan sistem, interaksi pustaka CUDA, dan operasi kernel CUDA. Dengan menganalisis data yang dikumpulkan, Anda dapat secara tepat mengidentifikasi hambatan kinerja pada aplikasi kontainer serta memahami tingkat pemanfaatan sumber daya guna mengoptimalkan aplikasi. Untuk aplikasi online, alat profiling yang dapat dipasang dan dilepas secara dinamis ini memungkinkan analisis real-time mendetail tanpa modifikasi kode. Topik ini menjelaskan cara menggunakan AI Profiling melalui baris perintah.

Persiapan

Kemampuan profiling Python pada versi AI Profiling saat ini bergantung pada fitur User Statically-Defined Tracing (USDT) dari interpreter Python. Untuk menggunakan profiling Python, jalankan perintah berikut di kontainer beban kerja Anda guna memverifikasi ketersediaan USDT:
```
python -c "import sysconfig; print(sysconfig.get_config_var('WITH_DTRACE'))"
```
Keluaran harus bernilai 1 agar profiling Python tersedia. Jika tidak, profiling Python tidak tersedia.
Catatan
Tugas profiling hanya didukung untuk berjalan pada kluster ACK dengan node Elastic Compute Service (ECS) atau Lingjun.
Untuk menggunakan fitur ini, Kirim tiket untuk menghubungi tim Container Service guna mendapatkan tautan unduh kubectl-plugin terbaru dan alamat citra profiling terbaru.

Prosedur

Langkah 1: Men-deploy plugin kubectl

AI Profiling dideploy menggunakan kubectl-plugin. Prosedurnya adalah sebagai berikut:

Jalankan perintah berikut untuk menginstal plugin. Contoh ini menggunakan Linux_amd64.

wget https://xxxxxxxxxxxxxxxxx.aliyuncs.com/kubectl_prof_linux_amd64
mv kubectl_prof_linux_amd64 /usr/local/bin/kubectl-prof
chmod +x /usr/local/bin/kubectl-prof

Jalankan perintah berikut untuk memeriksa apakah plugin berhasil diinstal:

kubectl prof deploy -h

Keluaran yang diharapkan:

deploy the profiling tool pod

Usage:
  kubectl-profile deploy [flags]

Aliases:
  deploy, run

Flags:
      --container string        Specify the target container name
  -d, --duration uint           Specify the profiling duration in seconds (default 60)
  -h, --help                    help for deploy
      --image string            Specify the profiling tool image
      --kubeconfig string       Specify the kubeconfig file
      --memory-limit string     Specify the memory limit (default "1Gi")
      --memory-request string   Specify the memory request (default "128Mi")
      --namespace string        Specify the target pod namespace (default "default")
      --node string             Specify the node name
      --pod string              Specify the target pod name
      --region-id string        Specify the region-id
      --ttl uint                Specify the ttl (default 60)

Langkah 2: Memilih kontainer aplikasi target dan membuat tugas profiling

Pilih sebuah pod aplikasi dan peroleh parameter Namespace, Name, dan Node-nya. Contoh ini menggunakan pekerjaan pelatihan PyTorch.

NAME                              READY   STATUS    RESTARTS   AGE   IP               NODE
pytorch-train-worker-sample   	  1/1     Running   0          82s   172.23.224.197   cn-beijing.10.0.17.XXX

Jalankan perintah berikut untuk mengirimkan pekerjaan profiling dengan parameter yang telah diperoleh. Tentukan pod dan kontainer yang akan diprofil. Pekerjaan profiling akan membuat pod profiling pada node tempat kontainer target dari pod aplikasi berada.

kubectl prof deploy \
    --image xxxxxxxxxx \                # Ganti dengan alamat citra profiling yang disediakan oleh Alibaba Cloud
    --duration 100000 \ 		# Durasi lingkungan pod profiling
    --namespace default \ 		# Namespace pod aplikasi 
    --region-id cn-beijing \		# ID Wilayah Alibaba Cloud dari lingkungan
    --pod pytorch-train-worker-sample \ # Nama pod aplikasi
    --container pytorch \		# Nama kontainer pod aplikasi
    --memory-limit 10G \		# Batas memori pod profiling
    --memory-request 1G			# Permintaan memori pod profiling

Langkah 3: Memicu profiling

Jalankan perintah berikut untuk melihat informasi pod profiling:

kubectl get pod

Keluaran yang diharapkan:

NAME                                                   READY   STATUS    RESTARTS   AGE
ai-profiler-89bf5b305acf2ec-xxxxx                      2/2     Running   0          1m

Jalankan perintah berikut untuk masuk ke pod profiling:

kubectl exec -ti ai-profiler-89bf5b305acf2ec-xxxxx -c debugger -- bash

Jalankan perintah berikut untuk mencantumkan semua proses GPU dan menghasilkan templat perintah profiling:

llmtracker generateCommand

Keluaran yang diharapkan:

I0314 11:42:42.389890 2948136 generate.go:51] GPU PIDs in container:

I0314 11:42:42.389997 2948136 generate.go:53] PID: xxxxx, Name: {"pid":xxxxx}
I0314 11:42:42.390008 2948136 generate.go:69] The profiling command is:

llmtracker profile\
-p <ProcessID-To-Profiling>\
-t <Profiling-Type(python,cuda,syscall,cpu or all)>\
-o /tmp/data.json\
-v 5\
--cpu-buffer-size <CPU-Buffer-Size, recommand to 20>\
--probe-file <Enable-CUDA-Lib-Profile-File>\
-d <Duration-To-Profiling>\
--delay <Delay-Time>\
--enable-cuda-kernel <Enable-CUDA-Kenrel-Profile(true or none)>

I0314 14:37:12.436071 3083714 generate.go:86] Profiling Python Path is: /usr/bin/python3.10. If you want to profiling Python, please ser the environment variable:
export EBPF_USDT_PYTHON_PATH=/usr/bin/python3.10

Catatan

Jika Anda perlu mengaktifkan profiling tingkat Python, Anda harus terlebih dahulu menyetel variabel lingkungan yang ditampilkan dalam keluaran di lingkungan profiling.

Parameter dan deskripsinya adalah sebagai berikut:

Parameter	Deskripsi
`-p`	Menentukan PID yang akan diprofil. Parameter ini dapat digunakan beberapa kali untuk mendukung beberapa PID.
`-t`	Menentukan jenis profiling. Opsi yang tersedia adalah python, cuda, syscall, cpu. Gunakan `all` untuk mengaktifkan semua jenis profiling.
`-o`	Menentukan path dan nama file keluaran profiling. Default: `/tmp/data.json`.
`-v`	Menentukan tingkat keluaran log.
`--cpu-buffer-size`	Menentukan ukuran buffer CPU untuk pengumpulan data eBPF. Default: 20.
`--probe-file`	Menentukan file templat yang diperlukan untuk Profiling CUDA Lib. Lihat spesifikasi penulisannya, atau langsung gunakan templat default.
`-d`	Menyetel durasi tugas profiling dalam detik. Kami merekomendasikan nilai ini di bawah 60 detik, karena durasi profiling yang terlalu lama dapat menghasilkan data berlebihan, sehingga meningkatkan konsumsi memori dan beban penyimpanan.
`--delay`	Menyetel waktu tunda sebelum profiling dimulai dalam detik. Jika Anda mengaktifkan profiling CUDA Kernel, kami merekomendasikan nilai ini di atas 2.
`--enable-cuda-kernel`	Menentukan apakah profiling CUDA Kernel diaktifkan. Setel parameter ini ke true untuk mengaktifkan.

Perbedaan antara -t cuda dan --enable-cuda-kernel:

-t cuda menggunakan eBPF untuk mengumpulkan pemanggilan simbol pustaka CUDA, termasuk waktu pemanggilan dan parameter setiap fungsi API, guna menganalisis situasi pemanggilan aktual dalam proses.
--enable-cuda-kernel menggunakan teknologi injeksi proses untuk mengumpulkan informasi eksekusi spesifik fungsi kernel CUDA, memungkinkan pemeriksaan mendetail terhadap status alur tugas di sisi GPU.

Untuk informasi parameter lengkap, jalankan perintah llmtracker profile -h.

Gunakan contoh berikut untuk menjalankan profiling, sesuaikan perintah profiling yang dihasilkan sesuai kebutuhan:
Catatan
Contoh ini mengaktifkan semua item profiling (termasuk Profiling CUDA Kernel), mengonfigurasi CUDA Lib sebagai probe.json, menyetel path file keluaran ke /tmp/data.json, dan menambahkan --delay 3 -d 5 untuk menunjukkan penundaan 3 detik sebelum mulai dan durasi profiling selama 5 detik.
```
export EBPF_USDT_PYTHON_PATH=/usr/bin/python3.10
llmtracker profile -p xxxxx -t all -o /tmp/data.json -v 5 --enable-cuda-kernel true --cpu-buffer-size 20 --probe-file probe.json --delay 3 -d 5
```
Jalankan perintah berikut untuk memformat file hasil dan mengekspornya:
Catatan
- Langkah ini mengonversi file hasil menjadi format standar untuk ditampilkan di TimeLine.
- Jika file hasil berisi data profiling CUDA Kernel, Anda harus menambahkan parameter --cupti-dir dan menyetelnya ke path tetap /tmp.
```
llmtracker export -i /tmp/data.json -o /output/out.json --cupti-dir /tmp
```

Langkah 4: Menampilkan hasil profiling

Menggunakan TensorBoard untuk tampilan dan analisis

Jika Anda menggunakan penyimpanan seperti OSS atau NAS, Anda dapat merujuk ke Melihat TensorBoard untuk metode melihat data hasil. Mulai Pod TensorBoard di kluster yang memasang PVC berisi data hasil profiling, lalu buka TensorBoard untuk melihat data terkait.

Menggunakan Chrome Tracing untuk tampilan dan analisis

Jika Anda menggunakan penyimpanan lokal, Anda perlu menyalin file hasil profiling yang dihasilkan ke mesin lokal Anda, lalu melihat file tersebut menggunakan Chrome Tracing (Perfetto).

Efek tampilan

Tampilan TensorBoard

TimeLine yang ditampilkan menggunakan TensorBoard adalah sebagai berikut:

Tampilan Chrome Tracing

TimeLine yang ditampilkan secara lokal menggunakan Chrome Tracing adalah sebagai berikut:

Lampiran AI Profiling

Berkas konfigurasi CUDA Lib

Peroleh dependensi rekursif pustaka target dan filter lebih lanjut file pustaka tersebut. Setelah memfilter atau mengonfirmasi file pustaka yang ingin dilacak, Anda dapat menggunakan perintah ldd untuk memperoleh dependensi tautan file pustaka target, sehingga menentukan cakupan file pustaka dari mana data efektif dapat dikumpulkan.

Setelah menentukan file pustaka target, Anda perlu mengonfirmasi simbol templat dalam pustaka tersebut. Langkah ini menggunakan libnccl.so sebagai contoh. Jalankan perintah berikut untuk memperoleh semua informasi simbol dalam pustaka:

 readelf -Ws libnccl.so.2 | grep pnccl

Keluaran yang diharapkan:

...
   223: 00000000000557d0   650 FUNC    GLOBAL DEFAULT   11 pncclGroupStart
   224: 0000000000050200   243 FUNC    GLOBAL DEFAULT   11 pncclRedOpDestroy
   225: 0000000000062081   656 FUNC    GLOBAL DEFAULT   11 pncclCommAbort
   227: 000000000006320c   721 FUNC    GLOBAL DEFAULT   11 pncclCommUserRank
   228: 0000000000064ee0    20 FUNC    GLOBAL DEFAULT   11 pncclGetVersion
   231: 0000000000045f60  1778 FUNC    GLOBAL DEFAULT   11 pncclAllGather
   232: 00000000000604f8  1578 FUNC    GLOBAL DEFAULT   11 pncclCommInitAll
   233: 000000000004ff20   728 FUNC    GLOBAL DEFAULT   11 pncclRedOpCreatePreMulSum
   238: 0000000000074520   653 FUNC    GLOBAL DEFAULT   11 pncclCommDeregister
   240: 00000000000474b0    30 FUNC    GLOBAL DEFAULT   11 pncclBcast
   243: 000000000006173d   789 FUNC    GLOBAL DEFAULT   11 pncclCommFinalize
   244: 00000000000483d0  2019 FUNC    GLOBAL DEFAULT   11 pncclSend
...

Susun berkas konfigurasi JSON yang dibutuhkan untuk Profiling dengan membuat berkas JSON dalam format serupa berikut. Berkas konfigurasi ini harus mendefinisikan informasi yang dibutuhkan untuk Probe, termasuk path relatif file pustaka target dalam kontainer untuk UProbe, simbol metode yang akan dipantau dalam file pustaka, dan simbol metode sistem yang akan dipantau dalam KProbe. Templat referensi default adalah sebagai berikut.

Perluas untuk melihat templat referensi default

[
    {
        "category": "cuda",
        "uprobes": [
            {
                "type": "cuda",
                "libraries": [
                    {
                        "library": "/usr/lib/x86_64-linux-gnu/libcuda.so.1",
                        "symbols": [
							"cuStreamSynchronize",
                            "cuMemcpyHtoD_v2",
                            "cuMemcpyDtoH_v2",
                            "cuMemcpyDtoD_v2",
                            "cuMemcpyDtoA_v2",
                            "cuMemcpyAtoD_v2",
                            "cuMemcpyHtoA_v2",
                            "cuMemcpyAtoH_v2",
                            "cuMemcpyAtoA_v2",
                            "cuMemcpyHtoAAsync_v2",
                            "cuMemcpyAtoHAsync_v2",
                            "cuMemcpy2D_v2",
                            "cuMemcpy2DUnaligned_v2",
                            "cuMemcpy3D_v2",
                            "cuMemcpyHtoDAsync_v2",
                            "cuMemcpyDtoHAsync_v2",
                            "cuMemcpyDtoDAsync_v2",
                            "cuMemcpy2DAsync_v2",
                            "cuMemcpy3DAsync_v2"
                        ]
                    },
                    {
                        "library": "/usr/local/lib/python3.10/dist-packages/nvidia/cuda_runtime/lib/libcudart.so.12",
                        "symbols": [
                            "cudaLaunchKernel",
                            "cudaLaunchKernelExC"
                        ]
                    }
                ]
            },
            {
                "type": "cuBLAS",
                "libraries": [
                    {
                        "library": "/usr/local/lib/python3.10/dist-packages/nvidia/cublas/lib/libcublasLt.so.12",
                        "symbols": [
                            "cublasLtMatmul",
                            "cublasLtMatrixTransform"
                        ]
                    },
                    {
                        "library": "/usr/local/lib/python3.10/dist-packages/nvidia/cublas/lib/libcublas.so.12",
                        "symbols": [
                            "cublasGemmEx",
                            "cublasGemmBatchedEx",
                            "cublasGemmStridedBatchedEx",
                            "cublasGemmGroupedBatchedEx",
                            "cublasSgemmEx",
                            "cublasCgemmEx"
                        ]
                    }
                ]
            },
            {
                "type": "nccl",
                "libraries": [
                    {
                        "library": "/usr/local/lib/python3.10/dist-packages/nvidia/nccl/lib/libnccl.so.2",
                        "symbols": [
                            "pncclAllReduce",
                            "pncclAllGather",
                            "pncclReduce",
                            "pncclBroadcast",
                            "pncclBcast",
                            "pncclReduceScatter",
                            "pncclSend",
                            "pncclRecv",
                            "pncclGroupStart",
                            "pncclGroupEnd",
                            "_Z20ncclGroupJobCompleteP12ncclGroupJob",
                            "_Z17ncclGroupJobAbortP12ncclGroupJob",
                            "pncclCommInitRank",
                            "pncclCommInitAll",
                            "pncclCommFinalize",
                            "pncclCommDestroy"
                        ]
                    }
                ]
            },
            {
                "type": "torch",
                "libraries": [
                    {
                        "library": "/usr/local/lib/python3.10/dist-packages/torch/lib/libtorch_cuda.so",
                        "symbols": [
                            "_ZN5torch4cuda4nccl4recvERN2at6TensorEPvN3c104cuda10CUDAStreamEi",
                            "_ZN5torch4cuda4nccl4sendERKN2at6TensorEPvN3c104cuda10CUDAStreamEi",
                            "_ZN4c10d16ProcessGroupNCCL8WorkNCCL17synchronizeStreamEv",
                            "_ZN5torch4cuda4nccl7all2allERSt6vectorIN2at6TensorESaIS4_EES7_PvRN3c104cuda10CUDAStreamE",
                            "_ZN5torch4cuda4nccl7scatterERKSt6vectorIN2at6TensorESaIS4_EERS4_PvRN3c104cuda10CUDAStreamEi"
                        ]
                    }
                ]
            }
        ]
    }
]