PyTorch 效能分析(第 1 部分):torch.profiler 初學者指南
Profiling in PyTorch (Part 1): A Beginner's Guide to torch.profiler
Hugging Face Blog 發佈 PyTorch 效能分析系列首篇入門指南,示範 torch.profiler 的設定,以及 profiler 表格和 CPU、GPU 軌跡的讀法。
文章以矩陣乘加示範如何結合 profiler 表格與 CPU、GPU 軌跡辨認瓶頸,並區分調度層融合與實際 GPU kernel 融合。
無法剖析的內容,就無法最佳化。
無論你是想提高大型語言模型(LLM)每秒生成的 token 數、把推論時間縮短幾毫秒,還是單純想了解訓練迴圈為何比規格表所述更慢,最終都離不開效能剖析。
難點在於,效能剖析的入門門檻相當高。追蹤內容滿是密密麻麻的彩色長方形,事件名稱也令人望而生畏,大部分教學更假設你已懂得閲讀這些內容。因此,即使我們知道應該進行效能剖析,打開追蹤檔也可能像一件麻煩事,最好留待稍後(或交給別人)處理。這篇文章,以及由此展開的系列,正是我們降低入門門檻的嘗試。
我們會以初學者的角度記錄整個學習歷程。除了基本 PyTorch 知識之外,沒有其他先決條件。請把這篇文章當作輕鬆閲讀,途中可能會有幾個「啊,原來如此!」的時刻。文章刻意以問題帶領內容:我們打開追蹤檔,問「等等,為何會這樣?」然後追查答案,直到豁然開朗。讀完後,你應該會瞭解:
- 如何設定
torch.profiler,以及它實際會提供甚麼資料, - 如何閲讀 profiler 表格和追蹤檔(CPU 軌道、GPU 軌道,以及兩者之間可疑的空隙),
- 從 Python 呼叫一路到 CUDA 核心的事件鏈,
- 套用 不會改變的部分(更有趣的是,哪些部分會改變)
torch.compile後,會有甚麼改變?
開始之前,先介紹兩個概念,有助理解下文:
- GPU 核心是一個在 GPU 多個執行緒上平行運行的程式。
- CPU 負責排程並啟動這些核心。
一般而言,你不必親自編寫 GPU 核心;使用 PyTorch 運算時,系統會自動把它轉換成一個或多個核心,在 GPU 上執行工作。
有了這兩個概念在手,現在就開始發問吧。
本文使用的完整指令碼在此:
01_matmul_add.py。建議你在另一個分頁開啟指令碼,逐步閲讀程式碼。我們使用NVIDIA A100-SXM4-80GBGPU 執行指令碼。在 Hugging Face 基礎設施上設定 GPU 非常簡單,你可以透過 Spaces 開發模式試驗這些指令碼;亦可使用 Hugging Face Jobs pipeline 執行。
(注意:本文的追蹤檔以 PyTorch 2.13 產生。如果你使用其他版本,CompiledFxGraph 等部分追蹤細節可能會不同或不存在。)
矩陣乘法與加法運算
正如 Sara Hooker 博士所言,深度神經網絡主要由矩陣乘法組成,正如人體主要由水組成一樣。矩陣乘法如此基礎,如果不以它來開展效能剖析之旅,未免可惜。
def fn(x, w, b):
return torch.add(torch.matmul(x, w), b)
矩陣加法配合矩陣乘法,模擬了神經元中權重和偏置的互動。這個「加法」(雙關語)亦有助我們瞭解它如何為本文後面介紹的編譯鋪路。
我們會使用 torch.profiler 模組進行效能剖析,步驟如下:
- 準備好要剖析的程式碼(此處是封裝矩陣乘法及矩陣加法的
def fn) - 為演算法加入標記。這完全是可選步驟,但我們建議這樣做。
record_function會把函數標記為matmul_add,方便在追蹤檔中搜尋(稍後會提到)。
def step():
with torch.profiler.record_function("matmul_add"):
return fn(x, w, b)
- 使用
torch.profiler.profile上下文管理器包住程式碼
with torch.profiler.profile(
activities=[
torch.profiler.ProfilerActivity.CPU, # the cpu activities
torch.profiler.ProfilerActivity.CUDA, # the gpu activities
],
) as prof:
# it is recommended to run events multiple times to warm up the GPUs
for _ in range(5):
step()
prof.step()
- 匯出效能剖析結果
# the profiler table
prof.key_averages().table(sort_by="cuda_time_total", row_limit=15)
# the profiler trace
prof.export_chrome_trace(trace_path)
Profiler 會匯出兩種不同產物:
- Profiler 表格:提供演算法的統計摘要,回答「哪個部分最花時間?」這有助找出效能熱點。熱點是指耗時最多、可能成為流程瓶頸,或觸發次數很多的事件。
- Profiler 追蹤檔:提供按時間排列的執行視圖,回答「某項操作何時及為何發生?」並呈現 CPU 和 GPU 上進行的活動。當我們想調查啟動了哪些核心、啟動延遲、CPU 和 GPU 活動是否重疊等情況時,這很有用。
讓我們執行第一次測試,看看兩者如何運作。(完整的 01_matmul_add.py 指令碼在此。)
建議在配備 GPU 的電腦上執行這個指令碼。
uv run 01_matmul_add.py --size 64
如果你在 GPU 電腦上執行上述指令碼,便會看到 traces/01_matmul_add 資料夾,當中有兩種產物:
64_bf16_cold_eager.json
64_bf16_cold_eager.txt
![]() |
|---|
| 圖 1:以 64 大小矩陣進行矩陣乘法加法的 profiler 表格 |
.txt 檔案存放 profiler 表格。打開檔案後,如圖 1 所示,你會看到一張大型表格,第一欄列出 profile 範圍內觸發的事件。
其他欄位則列出事件在 CPU、GPU 或 activities(於 torch.profiler.profile 中指定)的其他裝置上所花的時間。留意哪些事件最耗時,並直觀判斷它們是否真的應該花這麼久。亦要查看「# of Calls」欄,瞭解事件觸發了多少次。
順帶一提,我們也談談「Self CPU/CUDA」與「CPU/CUDA total」的分別。「Self」欄只計算事件本身所花的時間,不包括子事件;「total」欄則計算事件連同所有子事件的總時間。因此,matmul_add 的「CPU total」包括其本身所花的時間,以及它觸發的子事件所花的時間。這項細節很重要。
查看錶格最後兩行,你會留意到 profiler 告訴我們:
Self CPU time total: 2.314ms
Self CUDA time total: 23.104us
CPU 時間以 ms 為單位,GPU 時間則以 us 為單位。作為參考,GPU 所花時間(核心 ampere_bf16_s16816gemm...)不到 CPU 時間(matmul_add 運算)的 1%。GPU 大部分時間都閒置,這是明顯警號。原因是 GPU 很快便能完成小型矩陣乘法,因此程式大部分時間都用來準備核心、在 GPU 上啟動核心、傳送待相乘資料和收集結果。這類演算法稱為開銷受限。
要脱離這種情況,最簡單的方法是使用更大型的矩陣乘法。
uv run 01_matmul_add.py --size 4096
![]() |
|---|
| 圖 2:以 4096 大小矩陣進行矩陣乘法加法的 profiler 表格 |
圖 2 最後兩行顯示:
Self CPU time total: 4.908ms
Self CUDA time total: 4.495ms
兩項時間都以 ms 為單位,表示只要增大矩陣乘法的規模,GPU 執行時間便會明顯增加。查看圖 2,你亦會留意到目前大部分 CUDA 時間由 GPU 核心(ampere_bf16_s16816gemm_..)耗用,而不是啟動它的 CPU 運算(matmul_add)。這表示我們確實已從開銷受限轉為運算受限。
現在我們要視覺化派發鏈,相關資料位於 .json 產物中。你可以把它們上載至 Perfetto UI 查看追蹤內容,亦可使用 uvx trace-util -f traces -b <hf_uname>/traces 直接產生 Perfetto 連結。
64x64 追蹤
![]() |
|---|
| 圖 3:以 64 大小矩陣進行矩陣乘法及加法的 profiler 追蹤 |
圖 3 顯示矩陣乘法和加法的 profiler 追蹤。橫條寬度表示事件持續時間,垂直巢狀結構表示呼叫階層,CPU 軌道列出 CPU 上發生的事件,而 GPU 軌道則顯示核心實際執行情況。你亦可能會看到空白區域,即等待或閒置時間。
指令碼使用以下預設設定執行:
- size 64:輸入、權重和偏置的大小均為 (64, 64)
- dtype bf16:資料類型為 bfloat16
- no compile:沒有編譯 torch 運算
- no warmup:進行效能剖析前沒有預熱 GPU
在 Perfetto 中,我們建議使用鍵盤快速瀏覽追蹤內容。你可以使用「W A S D」移動視圖。
![]() |
|---|
| 圖 4:PyTorch profiler 追蹤中的 CPU 和 GPU 軌道 |
圖 4 中有兩條軌道,分別顯示 CPU 和 GPU 活動。在 CPU 軌道上,你會看到三個 profile 步驟(由 ProfilerStep#2 開始)。這是由 schedule 所致。
schedule = torch.profiler.schedule(wait=1, warmup=1, active=3, repeat=1)
wait 會略過嘈雜的初始設定(ProfilerStep#0),warmup 會在不記錄資料的情況下執行 profiler(ProfilerStep#1),而 active 則是會顯示在追蹤檔中的階段。你可以在此處的指令碼查看所用排程。
現在戴上偵探帽,調查追蹤檔並提出一些問題吧。
為何 ProfilerStep#2 花了這麼久?
![]() |
|---|
圖 5:ProfileStep#2 明顯比後續步驟寬 |
查看圖 5,我們發現 ProfileStep#2 比其他步驟耗時;仔細觀察,matmul_add 標記也呈現相似模式。關鍵線索藏在標記內,而不是標記本身:
| 步驟 | matmul_add 開始 |
aten::matmul 開始 |
間隔 |
|---|---|---|---|
| #2 | 138.736 | 366.493 | 227.757 µs |
| #3 | 517.926 | 523.447 | 5.521 µs |
| #4 | 610.039 | 614.527 | 4.488 µs |
![]() |
|---|
圖 6:record_function("matmul_add") 和 aten::matmul 之間約 228 µs 的空等時間 |
圖 6 所示約 228 µs 的時間,是進入 record_function("matmul_add") 到 PyTorch 實際派發 aten::matmul 之間的「空等時間」。可能原因包括工作區配置、cuBLAS(NVIDIA 專有的 GPU 加速基礎線性代數運算程式庫)啟發式策略,或模組延遲載入。我們可以視而不見,也可以在效能剖析前多做幾次預熱(這是標準做法)。
效能剖析中的預熱,是指正式剖析前先執行幾次事件。GPU 事前執行的工作(包括上述指標)只會發生一次,我們不想把它們納入剖析。在本例中,我們有兩個預熱階段:一是在進入 profiler 前先循環執行函數;二是在 profiler 內透過 warmup 參數設定。這一節中,我們同時啟用了正式迭代和排程。
uv run 01_matmul_add.py --warmup
![]() |
|---|
| 圖 7:預熱後,每個 profile 步驟所花時間都相近 |
圖 7 顯示每個 profile 步驟耗時相近,但這不代表我們已最佳化一次性開銷;我們只是透過預熱,令 profiler 不會記錄這些開銷。我們認為,若不提供解決這問題的線索便草草結束本節,對讀者並不公平,因此在此提供延伸閲讀連結,介紹如何進一步降低啟動開銷。
為何 CPU 和 GPU 軌道之間相差約 2.5 ms?
![]() |
|---|
| 圖 8:CPU 和 GPU 軌道之間相差約 2.5 ms |
圖 8 顯示 CPU 和 GPU 軌道之間相差約 2.5 ms:這是 CPU 提交 CUDA 核心後,核心實際開始執行前的延遲。你可能會認為,預熱階段加上排程中的 wait 和 warmup,應該能讓 GPU 忙碌起來,從而縮短這段差距。
要揭開實際情況,讓我們稍微修改排程:
- schedule = torch.profiler.schedule(wait=1, warmup=1, active=3, repeat=1)
+ schedule = torch.profiler.schedule(wait=0, warmup=0, active=3, repeat=1)
![]() |
|---|
圖 9:把 wait=0 和 warmup=0 設為 0 後,追蹤檔顯示出 Activity Buffer Request |
圖 9 顯示,在 GPU 軌道的任何操作之前,都有一個 Activity Buffer Request。讓我們再放大一點查看。
![]() |
|---|
| 圖 10:profile 步驟 1 的矩陣乘法和加法核心之間出現間隔 |
放大 GPU 追蹤檔後,我們看到 ProfileStep#0 的矩陣乘法和加法核心(圖中看不到相應的 CPU 追蹤)接連執行,而 ProfileStep#1 的核心之間則有空檔。最合理的解釋是緩衝區溢出,系統在核心執行期間提出了另一個緩衝區請求(即要求在 GPU VRAM 配置記憶體)。
排除其他可能性的最佳方法,是增加剖析迭代次數,看看追蹤檔其他位置是否也有類似空檔。為此,我們把 active=20 設為 20。
![]() |
|---|
| 圖 11:啟用 20 個步驟後,空檔只出現一次,證實它是緩衝區請求 |
如圖 11 所示,我們在 ProfileStep#1 也看到相同趨勢。這與先前發現一致,因此可以確定那是另一個緩衝區請求。
事件鏈
![]() |
|---|
| 圖 12:派發鏈 |
圖 12 顯示巢狀的 CPU 呼叫。這是一種重要視覺化方式,有助我們瞭解派發鏈的實際樣貌。
我們從封裝效能剖析步驟的 ProfileStep#<id> 開始。由於我們為步驟加上標記,會看到 matmul_add 列。matmul_add 包含兩個 aten 呼叫,分別進行矩陣乘法和矩陣加法。
aten::matmul 是 PyTorch 面向使用者的 matmul 呼叫所進入的 ATen 層級派發。aten::mm 是 2D 矩陣乘法的後端。
有趣的是,若為矩陣加入批次軸,PyTorch 會呼叫 aten::bmm(批次矩陣乘法)。讓我們稍作延伸,看看 aten::bmm 如何運作。
- x = torch.randn(args.size, args.size, device=device, dtype=dtype)
- w = torch.randn( args.size, args.size, device=device, dtype=dtype)
- b = torch.randn(args.size, args.size, device=device, dtype=dtype)
+ # adding a batch size of 8
+ x = torch.randn(8, args.size, args.size, device=device, dtype=dtype)
+ w = torch.randn(8, args.size, args.size, device=device, dtype=dtype)
+ b = torch.randn(8, args.size, args.size, device=device, dtype=dtype)
![]() |
|---|
| 圖 13:批次矩陣乘法 |
圖 13 顯示,為輸入加入批次軸後,aten::matmul 現在會包含一系列先決 CUDA 執行階段呼叫,以及 aten::bmm(取代 aten::mm)。這亦反映 cuBLAS 必須運用啟發式策略,為程式派發最合適的核心。
除非另有説明,本文其餘部分都會使用簡單的 2D 矩陣。
為何 matmul 會多出一次 CUDA 執行階段呼叫?
![]() |
|---|
| 圖 14:matmul 核心啟動前會先查詢 CUDA 佔用率 |
我們留意到,aten::mm 有兩次 CUDA Runtime 呼叫,分別是 cudaOccupancyMaxActiveBlocksPerMultiprocessor(圖 14 方框所示)和 cudaLaunchKernel;而 aten::add 只有一次 cudaLaunchKernel。
cudaOccupancyMaxActiveBlocksPerMultiprocessor 是純粹在 CPU 執行的規劃呼叫。它會詢問:「給定一個核心函數、選定的區塊大小和動態共享記憶體大小,某個 SM(Streaming Multiprocessor)可以同時容納多少個此核心的區塊?」
這就引出一個問題:為何 matmul 需要先規劃,add 卻不需要?
要了解原因,就要檢視核心的資源用量。點擊 GPU 核心後,你可以查看相應核心的資源用量。
![]() |
![]() |
|---|---|
| 圖 15:Matmul 資源用量 | 圖 16:Add 資源用量 |
從圖 15 可見,矩陣乘法的 registers per thread 和 shared memory 用量會動態變化(取決於矩陣大小)。cuBLAS 提供數百種核心變體,每種都有由啟發式策略決定的啟動流程,需要根據硬件容量取得執行階段資訊。佔用率查詢正是這套啟發式策略的一環。從概念上看,GPU 加速矩陣乘法會使用獨立區塊運算:區塊數量和大小視乎矩陣與硬件而定。現代演算法複雜得多,但這仍是實用的參考框架。
從圖 16 可見,加法的資源用量為 32 個暫存器和 0 共享記憶體,完全不成問題。由於硬件資源不會限制佔用率,因此無須查詢。這個核心本來就只消耗少量資源。
你可以把這項觀察用作閲讀任何追蹤檔時的快速診斷方法。在 CPU 軌道搜尋
cudaOccupancyMaxActiveBlocksPerMultiprocessor;每次出現都表示有一個「資源密集、以適應方式啟動」的核心,通常是 GEMM(一般矩陣乘法)、卷積等。沒有預先佔用率查詢的核心,通常是 PyTorch 以固定方式啟動的逐元素或歸約運算。
為何 cudaDeviceSynchronize 這麼長(約 1.78 ms)?
cudaDeviceSynchronize 會令 CPU 暫停,直至這部裝置上的所有 GPU 工作完成。Profiler 會在活動時段結束時插入這項同步操作,以清空事件;否則核心執行時間便會缺失。
一次長達 1.78 ms 的同步只涵蓋 26 µs 的實際 GPU 工作,表示這次執行有 98% 時間處於閒置狀態。這正是教科書所説的開銷受限徵狀。
4096x4096 追蹤
從上文的 profiler 表格分析可知,為演算法提供更大的矩陣,能令它脱離開銷受限區域,轉為運算受限。
讓我們執行指令並深入查看追蹤檔。
uv run 01_matmul_add.py --size 4096 --warmup
為何同一個核心比其他核心耗時更久?
![]() |
|---|
| 圖 17:輸入完全相同,但某個矩陣乘法核心比其他核心執行更久 |
圖 17 顯示,ProfileStep#3 的矩陣乘法核心在 GPU 上比其他步驟耗時更久。值得注意的是,其他啟動的核心完全相同,表示並沒有涉及 cuBLAS 啟發式策略,也沒有排程空隙或 profiler 假象。
圖 17 的追蹤説明一個在理想化範例中容易忽略的重點:即使硬件環境相同、程式碼和資料完全一致,核心執行時間也不是固定不變。
讓我們稍作修改,令這點更具體。我們執行 20 次迭代,並擷取每個步驟。
- schedule = torch.profiler.schedule(wait=1, warmup=1, active=3, repeat=1)
+ schedule = torch.profiler.schedule(wait=0, warmup=0, active=20, repeat=1)
- for _ in range(5):
+ for _ in range(20):
![]() |
|---|
| 圖 18:20 次迭代中,同一個矩陣乘法核心的執行速度各有不同 |
圖 18 顯示相同發現:每個核心都完全相同,但執行時間不一。計算時間不同可能有多種原因:
- GPU 閒置時的時脈與加速時脈
- GPU 温度上升
- GPU 電源管理
- 驅動程式端的背景工作
只看平均值的讀者會認為矩陣乘法約需 1 ms(5 次平均為 1084 µs);查看追蹤檔的讀者則會發現,除非 GPU 突然出現異常,否則矩陣乘法只需約 580 µs。兩者對實際情況的理解截然不同,而只有一種是正確的。
看看 torch.compile 如何運作
我們一直對 torch.compile 的運作方式感到驚嘆。你只需編寫一般的 eager PyTorch 程式碼,PyTorch 就會嘗試擷取大量處理 tensor 的區域、轉換成計算圖、進行最佳化,然後執行生成的程式碼。預設後端通常是 TorchInductor,整體流程如下:
TorchDynamo把 Python 執行流程擷取成 FX 計算圖- 涉及梯度時,
AOTAutograd會準備前向/反向計算圖 Inductor會把計算圖降階成最佳化的 CPU 或 GPU 程式碼。
本節會探討編譯,並查看 profiler 追蹤檔。
uv run 01_matmul_add.py --size 4096 --warmup --compile
args.compile 旗標會觸發以下程式碼:
def fn(x, w, b):
return torch.add(torch.matmul(x, w), b)
fn = torch.compile(fn) if args.compile else fn
![]() |
|---|
| 圖 19:追蹤檔中,已編譯區域會顯示為 TorchDynamo 和 Inductor 框架 |
圖 19 顯示新的 CPU 列名為 Torch-Compiled Region: 0/0,這表示系統使用了已編譯函數。
matmul 和 add 核心有融合成一個嗎?
![]() |
|---|
圖 20:編譯後的執行會派發單一 aten::addmm |
查看圖 20 時,我們會問:乘法和加法運算是否真的融合成一個操作?
這是計算圖層級的運算子融合。Inductor 把我們的 torch.add(torch.matmul(x, w), b) 改寫成單一 aten::addmm(b, x, w) 呼叫。重要的是,它沒有產生新的融合 CUDA 核心。GPU 實際執行的仍是 ampere_bf16_s16816gemm_bf16_128x256_ldg8_f2f_stages_64x3_nn,即 eager 模式使用的同一個 cuBLAS 核心。因此,這裏的「融合」發生在派發器層級,而非核心層級。
PyTorch 提供
torch.addmm函數,可一步完成我們分兩步做的乘法和加法。鼓勵讀者查看此函數的追蹤檔,並在下方留言分享觀察!
torch.compile 的執行階段架構
理論上我們知道編譯函數時會發生甚麼,但親自觀察同樣重要。讓我們檢視反映 torch.compile 執行階段架構的 CPU 呼叫階層。
TorchDynamo Cache Lookup 會檢查目前呼叫的輸入形狀、資料類型、裝置和 tensor 中繼資料,是否仍與已編譯項目相符。只要有任何不符,Dynamo 就會重新編譯。即使完成編譯後,每次呼叫仍要支付這項成本。
Torch-Compiled Region 是進入已編譯版本的包裝器。AOTDispatcher Runtime Wrapper Prologue 是 AOT Autograd 的執行階段包裝器。即使這裏不需要梯度,AOTDispatcher 仍會一直處於呼叫堆疊中,處理 tensor 中繼資料和檢視追蹤;若 requires_grad 為 true,還會設定反向傳播。
## Call CompiledFxGraph 是實際執行生成程式碼的地方。「CompiledFxGraph」後面的字串是 FX 計算圖的內容雜湊。三個活動步驟的雜湊相同,證明命中了快取。
你可以在磁碟的
/tmp/torchinductor_<user>/fxgraph路徑下,按此雜湊找到生成程式碼;若想閲讀 Inductor 實際產生的 Triton/C++,這會很有用。
CUDA 啟動次數有減半嗎?
![]() |
|---|
| 圖 21:每個編譯步驟仍會啟動兩個 GPU 核心:裝置到裝置的 memcpy 和 GEMM |
查看圖 21 的追蹤檔時,我們很高興發現每個步驟只有一次 cudaLaunchKernel。這與 GPU 追蹤檔顯示的情況直接矛盾:每個步驟仍會啟動兩個核心,分別是 Memcpy DtoD (Device -> Device) 和 GEMM。回看 CPU 追蹤檔後,我們發現完全漏看了 cudaMemcpyAsync 派發。
addmm 會計算 out = α·A·B + β·C;cuBLAS 帶偏置加法的 GEMM 後置處理會寫入目標緩衝區,而該緩衝區必須預先包含偏置。後置處理可以理解為 GEMM 之後執行的所有操作。在深度學習領域,我們經常使用 GEMM 後置處理,例如啟動函數、偏置加法、正規化等。這就是 cuBLAS 會提供帶後置處理的 GEMM 核心變體的原因。
如果使用不同的
mode設定,套用於torch.compile後,你會看到不同核心變體被啟動。歡迎親自試試,並在下方留言分享觀察!
因此,Inductor 生成的程式碼會:
out = copy(C)← 即 DtoD memcpy(32 MB,約需 33 µs)out = α·(A·B) + β·out← GEMM,其中α=β=1,把偏置加法融合至回寫操作
結果在數學上仍然相同。偏置加法並非免費:我們要先進行 memcpy,而且 GEMM 後置處理也稍為昂貴。
我們原本希望的融合是把 x·w + b(此處為 out = α·A·B + β·C)合併成單一核心,而且不產生額外記憶體流量,但實際並非如此。Inductor 保留了兩項會存取記憶體的操作,只是把偏置複製重新標記為 memcpy,並把加法併入 GEMM 後置處理。
真正融合的實作會略過 memcpy。FlashAttention 風格的手寫核心正是如此;Inductor 亦可透過 Triton 程式碼生成達成。但對 4096×4096 bf16 matmul 而言,Inductor 顯然認為「使用 cuBLAS,並透過後置處理設定偏置」是最佳路徑。
CPU 開銷不減反增
比較 eager 和編譯後的執行時,最容易忽略的就是這點:
| 步驟 | eager 執行時間(ms) | 編譯執行時間(ms) |
|---|---|---|
| #2 | 0.1 | 0.2 |
| #3 | 0.07 | 0.1 |
| #4 | 0.07 | 0.1 |
每個步驟中,torch.compile 在 CPU 上的開銷約為 2 倍。原因是每次呼叫都要走過完整的 Dynamo > AOTAutograd > Inductor 流程,除此之外還要執行原本就有的 aten::addmm 派發。這套編譯流程是為包含數十個操作的機器學習模型而設,這時每次呼叫的開銷可被攤分;若只編譯單一操作,開銷就像額外税項。
torch.compile有一個mode參數,留給讀者作為課後練習:閲讀文件,找出能降低 CPU 開銷的mode。🤗
閲讀追蹤檔速查表
快速參考文中介紹過的模式。概念是:如果在追蹤檔看到某種情況,通常代表以下意思。
Profiler 表格
| 所見情況 | 通常代表甚麼 |
|---|---|
Self CPU time total ≫ Self CUDA time total(CPU 以 ms 計,GPU 以 µs 計) |
開銷受限。CPU 派發所花時間多於 GPU 計算時間。增加工作量(使用更大的矩陣或批次操作),或融合多個呼叫。 |
Self CPU time total ≈ Self CUDA time total,兩者均以 ms 計 |
運算受限。瓶頸在 GPU,這通常正是我們希望看到的情況。 |
單一事件佔據大部分 CUDA total |
這就是你的效能熱點。從此處開始最佳化。 |
某事件的 # of Calls 數值極大 |
即使每次呼叫成本不高,也可能是瓶頸。檢查是否能融合或批次處理。 |
某一列的 CPU total 遠高於 Self CPU |
大部分成本來自子事件。應深入查看巢狀事件,而非父事件。 |
CPU 軌道
| 所見情況 | 通常代表甚麼 |
|---|---|
第一個 ProfileStep 明顯比其餘步驟寬 |
冷啟動開銷:工作區配置、cuBLAS 啟發式策略、模組延遲載入。增加預熱迭代次數,和/或設定排程的 warmup 參數。 |
record_function("...") 開始到其中第一個 aten::* 之間有很大空隙 |
同樣是冷啟動開銷,只是放大來看。標記已進入,但派發尚未發生。 |
先呼叫 cudaOccupancyMaxActiveBlocksPerMultiprocessor,再執行 cudaLaunchKernel |
重量級、適應性啟動的核心(GEMM、卷積等)。cuBLAS 會詢問驅動程式一個 SM 可容納多少區塊,再選擇核心變體。 |
cudaLaunchKernel 之前沒有佔用率查詢 |
逐元素或歸約核心,資源用量固定而且低。無須事先規劃。 |
活動時段結束時出現長時間的 cudaDeviceSynchronize |
Profiler 正在清空事件。持續時間大部分是 GPU 完成待處理工作所需時間,而非實際 CPU 成本。若同步操作只涵蓋少量 GPU 工作,這是典型的開銷受限徵狀。 |
你沒有寫過的 cudaMemcpyAsync |
通常是隱藏的裝置到裝置複製。當 addmm 在 GEMM 後置處理前以偏置初始化目標緩衝區時,便常會出現。 |
GPU 軌道
| 所見情況 | 通常代表甚麼 |
|---|---|
GPU 軌道出現 Activity Buffer Request |
Profiler 正在配置/補充自己的事件緩衝區。第一次緩衝區請求通常造成 CPU 與 GPU 軌道最初的時間差。 |
| 同一步驟的兩個核心之間有間隙 | 很可能是執行期間再次提出緩衝區請求。增加迭代次數確認:如果只出現一次,問題源自 profiler,而非你的程式碼。 |
| 同一個核心在不同步驟中執行時間不一 | GPU 時脈、温度、電源管理、驅動程式背景工作。應閲讀追蹤檔,而不只看平均值。 |
名稱類似 ampere_bf16_s16816gemm_... 的核心 |
這是執行矩陣乘法時實際由 cuBLAS 執行的 GPU 工作。形狀和資料類型相同時,eager 和編譯模式通常會使用同名核心。 |
GEMM 前立刻出現 Memcpy DtoD |
這是 addmm 後置處理的偏置複製。「融合」發生在派發器層級,而非核心層級。 |
派發鏈
| 所見情況 | 通常代表甚麼 |
|---|---|
ProfileStep#N → <record_function name> → aten::* → aten::mm / aten::bmm / aten::add |
這是標準巢狀呼叫階層。Self time 不包括子事件;Total time 則包括子事件。 |
aten::matmul 解析至 aten::mm |
2D × 2D 矩陣乘法。 |
aten::matmul 解析至 aten::bmm(另有額外 CUDA 執行階段呼叫) |
對 3D 或更高維 tensor 進行批次矩陣乘法。cuBLAS 需要進行更多啟發式處理,才能選擇合適的變體。 |
使用 aten::addmm(b, x, w),而非分開呼叫 aten::add 和 aten::mm |
這是派發器層級的運算子融合。GPU 核心仍是同一個 GEMM,只是把偏置加法併入後置處理。 |
torch.compile
| 所見情況 | 通常代表甚麼 |
|---|---|
CPU 軌道中出現 Torch-Compiled Region: K/M 列 |
你正處於已編譯函數內。 |
每個步驟都出現 TorchDynamo Cache Lookup |
Dynamo 正在確認形狀/資料類型/裝置是否與快取的編譯結果相符。每次呼叫都要支付這項成本,即使已完成編譯也一樣。 |
即使沒有梯度,也出現 AOTDispatcher Runtime Wrapper Prologue |
AOTAutograd 執行階段包裝器一直處於呼叫堆疊中,負責處理 tensor 中繼資料和檢視追蹤。 |
每個步驟的 ## Call CompiledFxGraph <hash> 雜湊相同 |
表示命中生成程式碼的快取。生成的原始碼位於 /tmp/torchinductor_<user>/fxgraph/<hash>。 |
微型操作使用 torch.compile 時,每步 CPU 時間高於 eager 模式 |
這是預期結果。Dynamo → AOTAutograd → Inductor 流程只有在多個操作間攤分成本時才划算。 |
結語
我們從一個小型的 matmul + add 範例開始,藉此學習如何閲讀 PyTorch profiler。過程中,我們也掌握了一些可套用於更大型工作負載的思考模式。這是 PyTorch 效能分析系列的第一站。在後續文章中,我們會逐步告別這個只有兩個操作的玩具範例,循序深入更複雜的組件,最終探討真實模型。
感謝 Noe Flandre、Suvaditya Mukherjee 和 Vidit Ostwal 審閲文章初稿!
這篇網誌經 LLM 潤飾。這並不代表我們讓智能體在背景自動生成文章。團隊中有些成員並非以英語為母語;我們認為 LLM(大多以英語訓練)能修正文法小錯,或把不太易懂的句子改寫得更簡潔清晰。希望這有助回答「如果文章由 LLM 生成,我為何還要讀?」這個疑問。🤗
來源:Hugging Face Blog · huggingface.co




















