הגדלת רוחב הפס של רשת ה-GPU באשכולות במצב Autopilot

בדף הזה מוסבר איך להשתמש ב-GPUDirect-TCPXO, ב-GPUDirect-TCPX, ב-gVNIC ובריבוי רשתות כדי להגדיל את רוחב הפס ואת קצב העברת הנתונים ברשת עבור עומסי עבודה של GPU עם ביצועים גבוהים באשכולות Autopilot של Google Kubernetes Engine ‏ (GKE). אם אתם משתמשים באשכולות רגילים, כדאי לעיין במאמר בנושא הגדלת רוחב הפס של רשת ה-GPU באשכולות במצב רגיל.

הדף הזה מיועד למהנדסי למידת מכונה (ML) ולאדמינים של פלטפורמות שמסייעים בעומסי עבודה של ML. כדי לקבל מידע נוסף על תפקידים נפוצים ומשימות לדוגמה שאנחנו מתייחסים אליהם ב Cloud de Confiance by S3NS תוכן, אפשר לעיין במאמר תפקידים נפוצים של משתמשים ב-GKE ומשימות.

אפליקציות של בינה מלאכותית (AI), למידת מכונה (ML) ומחשוב עתיר ביצועים (HPC) דורשות האצה חזקה כדי לשפר את הביצועים על ידי קיצור הזמן שנדרש להשלמת העבודה. לדוגמה, מודלים של ML שמתמקדים ב-AI בממשק שיחה וביצירת תמונות דורשים יכולת הרחבה גבוהה וכוח מחשוב.

לפני שקוראים את הדף הזה, חשוב לוודא שמכירים טכנולוגיות רשת, כמו כרטיסי ממשק רשת (NIC) ו-TCP, וטכנולוגיות האצה כמו NVIDIA Collective Communications Library‏ (NCCL).

מידע על Cloud de Confiance מחשבי-על עם GPU

Cloud de Confiance יש לו מחשבי-על שעברו אופטימיזציה למאיצים, והם מיועדים למודלים גדולים וניתנים להרחבה. סוגי המכונות עם GPU האלה יכולים לקבל רוחב פס ברשת של עד ‎3,600 Gbps.

עומס העבודה שלכם ב-GKE צריך להשתמש בכל ה-GPU הזמינים ובכל כרטיסי ה-NIC המשניים הזמינים בצומת יחיד, וגם להשתמש בחלק משמעותי מרוחב הפס הזמין. הפתרון שמתואר במסמך הזה מתאים לעומסי עבודה שדורשים ביצועים גבוהים, תפוקה גבוהה וזמן אחזור נמוך.

תכונות ויכולות נדרשות למיקסום רוחב הפס

כדי למקסם את רוחב הפס של הרשת בצמתים של מחשבי-על עם GPU, צריך להשתמש בכל התכונות הבאות:

  • חבילת פרוטוקולים לרשת GPUDirect: סדרת מכונות A3 תומכת בשלוש חבילות פרוטוקולים לרשת לגישה ישירה לזיכרון (RDMA) מרחוק בהתאמה אישית:
    • בסוגי מכונות A3 High ו-A3 Edge וב-GPU מסוג NVIDIA H100, אפשר להשתמש ב-GPUDirect-TCPX כדי לצמצם את התקורה שנדרשת להעברת מטענים ייעודיים (payloads) של מנות אל ה-GPU וממנו. כך משפרים באופן משמעותי את קצב העברת הנתונים בהשוואה ל-GPU שלא משתמש ב-GPUDirect.
    • במכונות מסוג A3 Mega ובמעבדי GPU מסוג NVIDIA H100 Mega, אפשר להשתמש ב-GPUDirect-TCPXO כדי לשפר עוד יותר את התקשורת בין ה-GPU לבין המכונה הווירטואלית.
    • בסוגי מכונות A3 Ultra וב-GPU מסוג NVIDIA H200, ובסוגי מכונות A4 וב-GPU מסוג NVIDIA B200, אפשר להשתמש ב-GPUDirect RDMA כדי להריץ עומסי עבודה מבוססי-AI מבוזרים עם שיפורים נוספים ברוחב הפס. כדי להתחיל, יוצרים אשכול GKE מותאם אישית שעבר אופטימיזציה ל-AI.
  • ‫gVNIC: הפעלה של יכולות GPUDirect כמו פיצול של כותרות מנות, ניהול זרימה וניהול מאגרים. נדרש gVNIC כדי להשתמש ב-GPUDirect-TCPX או ב-GPUDirect-TCPXO. פרטים על gVNIC זמינים במאמר הגדלת מהירות תעבורת הרשת בצמתי GPU.
  • רישות מרובה: הוספת כרטיסי רשת משניים למכונה שעברה אופטימיזציה למאיץ. כל כרטיס NIC משויך לרשת משנה נפרדת ב-VPC שלו כדי למנוע התנגשויות. פרטים על תמיכה בריבוי רשתות זמינים במאמר בנושא הגדרת תמיכה בריבוי רשתות עבור Pods.
  • מדיניות מיקום: אפשר להשתמש במדיניות מיקום משאבים כדי למקם את כל צמתי ה-GPU של עומס עבודה ספציפי בשרתים שקרובים פיזית זה לזה, כדי לצמצם את זמן האחזור. פרטים נוספים מופיעים במאמר בנושא הגדרת מיקום קומפקטי לצמתי GKE.

ראשי פרקים של התהליך

כדי להשתמש בכל היכולות האלה יחד, צריך לבצע את הפעולות הבאות:

  1. יצירת עננים וירטואליים פרטיים (VPC) ותת-רשתות
  2. יוצרים את סביבת GKE.
  3. התקנת קובץ הבינארי של GPUDirect והפלאגין של NCCL
  4. פריסת הפלאגין NRI device injector
  5. פריסת עומס עבודה לבדיקה כדי לוודא שההגדרה של GPUDirect תקינה
  6. הטמעה של GPUDirect בעומסי העבודה שלכם

לפני שמתחילים

לפני שמתחילים, חשוב לוודא שביצעתם את הפעולות הבאות:

  • מפעילים את ממשק Google Kubernetes Engine API.
    • הפעלת Google Kubernetes Engine API
  • כדי להשתמש ב-CLI של Google Cloud למשימה הזו, צריך להתקין ואז להפעיל את gcloud CLI. אם התקנתם בעבר את ה-CLI של gcloud, מריצים את הפקודה gcloud components update כדי לקבל את הגרסה העדכנית. יכול להיות שגרסאות קודמות של ה-CLI של gcloud לא יתמכו בהרצת הפקודות שמופיעות במסמך הזה.
  • מוודאים שיש לכם קיבולת למכונות וירטואליות מסוג A3 Mega או A3 High. כדי לקבל את הקיבולת הזו, קודם בוחרים מתוך אפשרויות הצריכה. כדי לפעול לפי ההוראות בדף הזה, אפשר להשתמש בקיבולת לפי דרישה, בהזמנות לפי דרישה, בהזמנות עתידיות או בהזמנות עתידיות לפרק זמן של עד 90 ימים (במצב לוח שנה). אחרי שבוחרים אפשרות צריכה, פועלים לפי ההוראות המתאימות כדי לקבל קיבולת באמצעות אפשרות הצריכה שבחרתם.
  • מוודאים שיש לכם מספיק מכסה לשימוש ב-GPU מסוג H100. לפרטים על הגדלת המכסות, ראו מכסות של GPU.

דרישות

הדרישות הבאות חלות על GPUDirect-TCPX ועל GPUDirect-TCPXO, אלא אם צוין אחרת.

  • האשכול צריך להשתמש ב-GKE בגרסה 1.31.1-gke.1621000 ואילך.
  • בצמתי ה-GPU צריך להשתמש בדרייבר NVIDIA בגרסה 535 ואילך.
  • חובה להשתמש ב-GKE Dataplane V2.
  • בעומסי עבודה של GPUDirect-TCPX או GPUDirect-TCPXO שפועלים בכמה מאגרי צמתים, כל מאגרי הצמתים צריכים להיות באותם אזורים של Compute Engine ולהשתמש באותם מערכי רשת, כמו VPC ותתי-רשתות.

מגבלות

ההגבלות הבאות חלות:

  • אין תמיכה ב-GPUDirect-TCPX וב-GPUDirect-TCPXO עם מעבדי GPU מרובי-מופעים, שיתוף זמן של GPU או NVIDIA MPS.
  • אי אפשר להשתמש ב-NCCL FastSocket עם GPUDirect-TCPX או GPUDirect-TCPXO.
  • עומס העבודה ב-GKE חייב להשתמש בכל ה-GPU הזמינים ובכל כרטיסי ה-NIC המשניים הזמינים בצומת יחיד. אי אפשר להשתמש בכמה תרמילים ב-GPUDirect-TCPX או ב-GPUDirect-TCPXO בצומת יחיד.
  • אפשר להשתמש רק בסוגי המכונות a3-highgpu-8g, a3-megagpu-8g ו-a3-edgegpu-8g. אין תמיכה בסוגים אחרים של מכונות A3.

יצירת רשתות VPC ורשתות משנה

יוצרים רשתות VPC נפרדות בפרויקט לכל כרטיס רשת וירטואלי שמוסיפים לצמתים. לכל רשת VPC צריכה להיות תת-רשת וכלל חומת אש שמאפשר תעבורת נתונים פנימית ברשת.

  1. יוצרים את רשתות ה-VPC ל-GPUDirect בפרויקט, כל אחת עם תת-רשת וכלל חומת אש. בוחרים בכרטיסייה GPUDirect-TCPX לסוגי מכונות A3 High, או בכרטיסייה GPUDirect-TCPXO לסוגי מכונות A3 Mega, ואז מבצעים את ההוראות הבאות:

    GPUDirect-TCPXO

    כדי למקסם את רוחב הפס, מומלץ ליצור שמונה רשתות חדשות.

    for N in $(seq 1 8); do
gcloud compute networks create PREFIX-net-$N \
    --subnet-mode=custom \
    --mtu=8244

gcloud compute networks subnets create PREFIX-sub-$N \
    --network=PREFIX-net-$N \
    --region=REGION \
    --range=SUBNET_RANGE

gcloud compute firewall-rules create PREFIX-internal-$N \
  --network=PREFIX-net-$N \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=SOURCE_RANGE
done

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫PROJECT_ID: מזהה הפרויקט ב- Cloud de Confiance .
    • ‫REGION: האזור ב-Compute Engine של כל רשת משנה.
    • ‫SUBNET_RANGE: טווח כתובות ה-IP של כל רשת משנה בסימון CIDR. בפקודה לדוגמה הזו יש איטרציה של שמונה רשתות משנה, ולכן כדאי להשתמש במשתנה כדי לשנות את כתובת ה-IP של כל רשת משנה. לדוגמה, אפשר לציין 192.168.$N.0/24 כדי שתת-הרשת הראשונה תשתמש ב-192.168.1.0/24, תת-הרשת השנייה תשתמש ב-192.168.2.0/24 וכן הלאה.
    • ‫SOURCE_RANGE: טווח כתובות ה-IP של המקור שכלל חומת האש יאפשר לו תעבורת נתונים נכנסת, בסימון CIDR. לדוגמה, 192.168.0.0/16.

    GPUDirect-TCPX

    כדי למקסם את רוחב הפס, מומלץ ליצור ארבע רשתות חדשות.

    for N in $(seq 1 4); do
gcloud compute networks create PREFIX-net-$N \
    --subnet-mode=custom \
    --mtu=8244

gcloud compute networks subnets create PREFIX-sub-$N \
    --network=PREFIX-net-$N \
    --region=REGION \
    --range=SUBNET_RANGE

gcloud compute firewall-rules create PREFIX-internal-$N \
  --network=PREFIX-net-$N \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=SOURCE_RANGE
done

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫PROJECT_ID: מזהה הפרויקט ב- Cloud de Confiance .
    • ‫REGION: האזור ב-Compute Engine של כל רשת משנה.
    • ‫SUBNET_RANGE: טווח כתובות ה-IP של כל רשת משנה בסימון CIDR. בפקודה לדוגמה הזו יש איטרציה לארבע רשתות משנה, ולכן צריך להשתמש במשתנה כדי לשנות את כתובת ה-IP לכל רשת משנה. לדוגמה, מציינים 192.168.$N.0/24 כדי שרשת המשנה הראשונה תשתמש ב-192.168.1.0/24, רשת המשנה השנייה תשתמש ב-192.168.2.0/24 וכו'.
    • ‫SOURCE_RANGE: טווח כתובות ה-IP של המקור שכלל חומת האש יאפשר לו תעבורת נתונים נכנסת, בסימון CIDR. לדוגמה, 192.168.0.0/16.

  2. בודקים שהרשתות נוצרו:

    gcloud compute networks list

יצירת סביבת GKE

יוצרים אשכול GKE חדש שמשתמש בריבוי רשתות (גרסת Preview). אי אפשר לעדכן אשכול קיים כדי להשתמש בריבוי רשתות.

GPUDirect-TCPXO

  1. בוחרים גרסה זמינה של GKE שתומכת ב-GPUDirect-TCPXO. כדי להציג את הגרסאות, מריצים את הפקודה הבאה:

    gcloud container get-server-config \
    --format="yaml(validMasterVersions)" \
    --region=REGION \
    --project=PROJECT_ID

    מחליפים את מה שכתוב בשדות הבאים:

  2. יצירת אשכול:

    gcloud beta container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --cluster-version=VERSION \
    --enable-multi-networking \
    --workload-policies=allow-net-admin

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫CLUSTER_NAME: השם של האשכול החדש.
    • ‫CONTROL_PLANE_LOCATION: האזור של Compute Engine במישור הבקרה של האשכול.
    • ‫VERSION: גרסת GKE שתומכת ב-GPUDirect-TCPXO, כמו שמתואר בדרישות.

  3. יוצרים משאבים מסוג Network ו-GKENetworkParamSet באשכול שתואמים לרשתות ה-VPC ולתת-רשתות שיצרתם:

    kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc1
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc1
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc2
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc2
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc3
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc3
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc4
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc4
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc5
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc5
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc6
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc6
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc7
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc7
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc8
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc8
  type: Device
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc1
spec:
  vpc: PREFIX-net-1
  vpcSubnet: PREFIX-sub-1
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc2
spec:
  vpc: PREFIX-net-2
  vpcSubnet: PREFIX-sub-2
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc3
spec:
  vpc: PREFIX-net-3
  vpcSubnet: PREFIX-sub-3
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc4
spec:
  vpc: PREFIX-net-4
  vpcSubnet: PREFIX-sub-4
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc5
spec:
  vpc: PREFIX-net-5
  vpcSubnet: PREFIX-sub-5
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc6
spec:
  vpc: PREFIX-net-6
  vpcSubnet: PREFIX-sub-6
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc7
spec:
  vpc: PREFIX-net-7
  vpcSubnet: PREFIX-sub-7
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc8
spec:
  vpc: PREFIX-net-8
  vpcSubnet: PREFIX-sub-8
  deviceMode: NetDevice
EOF

    המשאבים האלה מנחים את GKE להגדיר את כרטיסי ה-NIC לתעבורת GPU במצב העברה (passthrough). ‫GKE לא מחיל על התנועה הזו תכנות רשת מובנה באמצעות eBPF.

GPUDirect-TCPX

  1. יצירת אשכול:

    gcloud beta container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --cluster-version=VERSION \
    --enable-multi-networking \
    --workload-policies=allow-net-admin

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫CLUSTER_NAME: השם של האשכול החדש.
    • ‫CONTROL_PLANE_LOCATION: האזור של Compute Engine במישור הבקרה של האשכול.
    • ‫VERSION: גרסת GKE שתומכת ב-GPUDirect-TCPX, כמו שמתואר בדרישות.

  2. יוצרים משאבים מסוג Network ו-GKENetworkParamSet באשכול שתואמים לרשתות ה-VPC ולתת-רשתות שיצרתם:

    kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc1
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc1
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc2
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc2
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc3
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc3
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc4
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc4
  type: Device
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc1
spec:
  vpc: PREFIX-net-1
  vpcSubnet: PREFIX-sub-1
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc2
spec:
  vpc: PREFIX-net-2
  vpcSubnet: PREFIX-sub-2
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc3
spec:
  vpc: PREFIX-net-3
  vpcSubnet: PREFIX-sub-3
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc4
spec:
  vpc: PREFIX-net-4
  vpcSubnet: PREFIX-sub-4
  deviceMode: NetDevice
EOF

    המשאבים האלה מנחים את GKE להגדיר את כרטיסי ה-NIC לתעבורת GPU במצב העברה (passthrough). ‫GKE לא מחיל על התנועה הזו תכנות רשת מובנה באמצעות eBPF.

התקנה של קובץ הבינארי של GPUDirect והגדרה של NCCL

בקטע הזה נסביר איך להתקין את הקובץ הבינארי של GPUDirect, בהתאם לסוג המכונה A3 (GPUDirect-TCPX ל-A3 High, ‏ GPUDirect-TCPXO ל-A3 Mega) ולגרסה ספציפית של ספריית NCCL באמצעות DaemonSet.

GPUDirect-TCPXO

ה-DaemonSet הזה מבצע את הפעולות הבאות:

  1. לפני ההתקנה כדי להגדיר הגדרות שקשורות ל-GPUDirect-TCPXO.
  2. הפקודה מתקינה את ספריית NCCL ואת הקובץ הבינארי GPUDirect-TCPXO בצומת.
  3. הספרייה והקובץ הבינארי מאוחסנים בספרייה /home/kubernetes/bin/nvidia/lib64 במכונה הווירטואלית. כברירת מחדל, GKE מטמיע את הספרייה הזו בנתיב /usr/local/nvidia/lib64 במאגרי GPU שצריכים להשתמש ב-NCCL וב-GPUDirect-TCPXO.

כדי להתקין את הקובץ הבינארי ולהגדיר את NCCL, מבצעים את השלבים הבאים:

  1. מעיינים במניפסט של Daemonset‏ nccl-tcpxo-installer-autopilot.yaml ב-GitHub.

  2. יוצרים מרחב שמות ייעודי:

    kubectl create ns gpudirect-system

  3. פורסים את DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpxo/nccl-tcpxo-installer-autopilot.yaml

    הפעלת הפלאגין NCCL נמשכת כשתי דקות.

GPUDirect-TCPX

ה-DaemonSet הזה מבצע את הפעולות הבאות:

  1. הפקודה מתקינה את ספריית NCCL ואת הקובץ הבינארי GPUDirect-TCPX בצומת.
  2. הספרייה והקובץ הבינארי מאוחסנים בספרייה /home/kubernetes/bin/nvidia/lib64 במכונה הווירטואלית. כברירת מחדל, GKE מטמיע את הספרייה הזו בנתיב /usr/local/nvidia/lib64 בקונטיינרים של GPU שצריכים להשתמש ב-NCCL וב-GPUDirect-TCPX.

כדי להתקין את הקובץ הבינארי ולהגדיר את NCCL:

  1. מעיינים במניפסט של Daemonset‏ nccl-tcpx-installer-autopilot.yaml ב-GitHub.

  2. יוצרים מרחב שמות ייעודי:

    kubectl create ns gpudirect-system

  3. פורסים את DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-tcpx-installer-autopilot.yaml

    הפעלת הפלאגין NCCL נמשכת כשתי דקות.

פריסת הפלאגין NRI device injector

בקטע הזה נסביר איך להתקין את כלי ההזרקה של מכשיר NRI באמצעות DaemonSet. בשני סוגי המכונות עם GPU מדגם H100 מותקן אותו פלאגין של NRI device injector. הפלאגין הזה מבצע את הפעולות הבאות:

  1. הפעלת Node Resource Interface ‏ (NRI) בצומת עם GPU מסוג H100. התכונה NRI מופעלת כברירת מחדל ב-GKE מגרסה 1.29 ואילך.
  2. פריסת קונטיינר של תוסף להזרקת מכשירי NRI שמזריק מכשירי GPU לקונטיינרים שצוינו בהערות של Pod.

כדי להתקין את הפלאגין:

  1. בודקים את מניפסט הפריסה nri-device-injector-autopilot.yaml ב-GitHub.

  2. פורסים את DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nri_device_injector/nri-device-injector-autopilot.yaml

    הפעלת הפלאגין NCCL נמשכת כשתי דקות.

פריסת עומס עבודה לבדיקה

בקטע הזה תפרסו עומס עבודה לדוגמה כדי לוודא ש-NCCL ו-GPUDirect-TCPX או GPUDirect-TCPXO פועלים כמצופה. עומס העבודה לדוגמה הזה מבצע את הפעולות הבאות:

  1. פריסת שני פודים, שכל אחד מהם פועל בצומת עם מעבדי GPU מסוג H100.
  2. פריסת קונטיינר sidecar בכל Pod כדי לאפשר ל-Pods האלה להשתמש ב-GPUDirect-TCPXO או ב-GPUDirect-TCPX.

כדי לפרוס את עומס העבודה לדוגמה:

GPUDirect-TCPXO

עומס העבודה הזה כולל קונטיינר sidecar בשם tcpxo-daemon, שמריץ שירות שמאפשר ל-Pod להשתמש ב-GPUDirect-TCPXO. צריך להוסיף את קובץ ה-sidecar הזה לכל ה-Pods בסביבה שלכם שצריכים להשתמש ב-GPUDirect-TCPXO. קטע קוד עם השדות הנדרשים להוספה למניפסטים זמין במאמר הוספת GPUDirect למניפסט.

  1. מעיינים במניפסט nccl-test-latest-autopilot.yaml ב-GitHub.

  2. פורסים שני פודים עם עומס העבודה של הבדיקה:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpxo/nccl-test-latest-autopilot.yaml

  3. מוודאים שה-Pods פועלים ומוכנים. הערה: התמונות גדולות (כ-5 GB) וההורדה שלהן עשויה להימשך כמה דקות.

    kubectl get pods -w

    הפקודה עוקבת אחרי עדכונים ומדפיסה שורה חדשה כשסטטוס ה-Pod משתנה. הפלט אמור להיראות כך:

    NAME               READY   STATUS              RESTARTS   AGE
nccl-test-host-1   0/2     ContainerCreating   0          23s
nccl-test-host-2   2/2     Running             0          23s
nccl-test-host-1   2/2     Running             0          46s

    מחכים עד שההודעה STATUS של כל ה-Pods תהיה Running והערך של READY יהיה 2/2 לפני שעוברים לשלב הבא.

  4. אחרי פריסת ה-Pods, מפעילים בדיקה של all-gather:

    kubectl exec --stdin --tty --container=nccl-test nccl-test-host-1 -- /scripts/allgather.sh nccl-host-1 nccl-host-2

    הפלט אמור להיראות כך:

    ‫
    #                                                              out-of-place                       in-place
#        size         count      type   redop    root     time   algbw   busbw #wrong     time   algbw   busbw #wrong
#         (B)    (elements)                               (us)  (GB/s)  (GB/s)            (us)  (GB/s)  (GB/s)
            0             0     float    none      -1     0.24    0.00    0.00      0     0.18    0.00    0.00      0
            0             0     float    none      -1     0.19    0.00    0.00      0     0.17    0.00    0.00      0
            0             0     float    none      -1     0.17    0.00    0.00      0     0.17    0.00    0.00      0
            0             0     float    none      -1     0.17    0.00    0.00      0     0.17    0.00    0.00      0
            0             0     float    none      -1     0.17    0.00    0.00      0     0.17    0.00    0.00      0
          256             4     float    none      -1    235.2    0.00    0.00      0    235.1    0.00    0.00      0
          512             8     float    none      -1    241.0    0.00    0.00      0    236.1    0.00    0.00      0
         1024            16     float    none      -1    236.3    0.00    0.00      0    233.3    0.00    0.00      0
         2048            32     float    none      -1    234.1    0.01    0.01      0    233.4    0.01    0.01      0
         4096            64     float    none      -1    237.1    0.02    0.02      0    235.3    0.02    0.02      0
         8192           128     float    none      -1    236.2    0.03    0.03      0    235.2    0.03    0.03      0
        16384           256     float    none      -1    236.6    0.07    0.06      0    238.5    0.07    0.06      0
        32768           512     float    none      -1    237.9    0.14    0.13      0    238.8    0.14    0.13      0
        65536          1024     float    none      -1    242.3    0.27    0.25      0    239.4    0.27    0.26      0
       131072          2048     float    none      -1    263.0    0.50    0.47      0    275.1    0.48    0.45      0
       262144          4096     float    none      -1    279.2    0.94    0.88      0    269.9    0.97    0.91      0
       524288          8192     float    none      -1    273.5    1.92    1.80      0    273.5    1.92    1.80      0
      1048576         16384     float    none      -1    315.1    3.33    3.12      0    314.1    3.34    3.13      0
      2097152         32768     float    none      -1    319.2    6.57    6.16      0    311.5    6.73    6.31      0
      4194304         65536     float    none      -1    331.8   12.64   11.85      0    331.3   12.66   11.87      0
      8388608        131072     float    none      -1    356.3   23.54   22.07      0    353.8   23.71   22.23      0
     16777216        262144     float    none      -1    409.1   41.01   38.45      0    405.2   41.40   38.81      0
     33554432        524288     float    none      -1    451.4   74.34   69.69      0    447.7   74.94   70.26      0
     67108864       1048576     float    none      -1    713.4   94.07   88.19      0    713.8   94.01   88.13      0
    134217728       2097152     float    none      -1   1122.1  119.62  112.14      0   1116.3  120.23  112.72      0
    268435456       4194304     float    none      -1   1785.8  150.32  140.92      0   1769.2  151.72  142.24      0
    536870912       8388608     float    none      -1   2859.7  187.74  176.00      0   2852.6  188.20  176.44      0
   1073741824      16777216     float    none      -1   5494.1  195.44  183.22      0   5568.2  192.83  180.78      0
   2147483648      33554432     float    none      -1    10841  198.09  185.71      0    10798  198.88  186.45      0
   4294967296      67108864     float    none      -1    21453  200.21  187.70      0    21490  199.86  187.37      0
   8589934592     134217728     float    none      -1    42603  201.63  189.03      0    42670  201.31  188.73      0
# Out of bounds values : 0 OK
# Avg bus bandwidth    : 45.7587
#

GPUDirect-TCPX

עומס העבודה הזה כולל קונטיינר sidecar בשם tcpx-daemon, שמריץ שירות שמאפשר ל-Pod להשתמש ב-GPUDirect-TCPX. צריך להוסיף את קובץ ה-sidecar הזה לכל ה-Pods בסביבה שלכם שצריכים להשתמש ב-GPUDirect-TCPX. קטע קוד עם השדות הנדרשים להוספה למניפסטים זמין במאמר הוספת GPUDirect למניפסט.

  1. בודקים את nccl-config.yaml מניפסט ConfigMap ב-GitHub. קובץ המניפסט הזה פורס סקריפטים שמאתחלים בדיקה של NCCL all-gather ומגדירים הגדרות ספציפיות ל-NCCL.

  2. בודקים את מניפסט הפריסה nccl-test-latest-autopilot.yaml ב-GitHub.

  3. פורסים את ConfigMap ואת עומס העבודה של הבדיקה:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-config.yaml
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-test-latest-autopilot.yaml

  4. מוודאים שה-Pods פועלים ומוכנים. הערה: התמונות גדולות (כ-5 GB) וההורדה שלהן עשויה להימשך כמה דקות.

    kubectl get pods -w

    הפקודה עוקבת אחרי עדכונים ומדפיסה שורה חדשה כשסטטוס ה-Pod משתנה. הפלט אמור להיראות כך:

    NAME               READY   STATUS              RESTARTS   AGE
nccl-test-host-1   0/2     ContainerCreating   0          23s
nccl-test-host-2   2/2     Running             0          23s
nccl-test-host-1   2/2     Running             0          46s

    מחכים עד שההודעה STATUS של כל ה-Pods תהיה Running והערך של READY יהיה 2/2 לפני שעוברים לשלב הבא.

  5. מריצים את הפקודות הבאות כדי להפעיל בדיקת NCCL all-gather עבור הצמתים:

    kubectl exec \
  --stdin --tty --container=nccl-test nccl-test-host-1 \
  -- /configs/allgather.sh nccl-host-1 nccl-host-2

    הפלט אמור להיראות כך:

    #                                                              out-of-place                       in-place
#       size         count      type   redop    root     time   algbw   busbw #wrong     time   algbw   busbw #wrong
#        (B)    (elements)                               (us)  (GB/s)  (GB/s)            (us)  (GB/s)  (GB/s)
    1048576         16384     float    none      -1    696.8    1.50    1.41      0    729.0    1.44    1.35      0
    2097152         32768     float    none      -1    776.4    2.70    2.53      0    726.7    2.89    2.71      0
    4194304         65536     float    none      -1    774.3    5.42    5.08      0    805.1    5.21    4.88      0
    8388608        131072     float    none      -1    812.1   10.33    9.68      0    817.6   10.26    9.62      0
   16777216        262144     float    none      -1   1035.2   16.21   15.19      0   1067.8   15.71   14.73      0
   33554432        524288     float    none      -1   1183.3   28.36   26.59      0   1211.8   27.69   25.96      0
   67108864       1048576     float    none      -1   1593.4   42.12   39.49      0   1510.5   44.43   41.65      0
  134217728       2097152     float    none      -1   2127.8   63.08   59.13      0   2312.7   58.03   54.41      0
  268435456       4194304     float    none      -1   3603.0   74.50   69.85      0   3586.2   74.85   70.17      0
  536870912       8388608     float    none      -1   7101.7   75.60   70.87      0   7060.9   76.03   71.28      0
# Out of bounds values : 0 OK
# Avg bus bandwidth    : 29.8293

איך משתמשים ב-GPUDirect בעומסי עבודה

אחרי שמוודאים שהרשת של האשכול פועלת בצורה תקינה עם עומס העבודה לדוגמה, השלב הבא הוא להטמיע את GPUDirect בעומסי העבודה בפועל. כדי לעשות את זה, צריך לעדכן את הגדרות ה-NCCL ואת קובצי המניפסט של Kubernetes Pod.

שימוש בהגדרות החובה של NCCL לשיפור הביצועים

צמדי המפתח/ערך הבאים הם הגדרות התצורה הנדרשות של NCCL עבור GPUDirect-TCPX ו-GPUDirect-TCPXO. כשפורסים את עומסי העבודה שמשתמשים ב-NCCL, צריך להגדיר אותם כמשתני סביבה כדי לשפר את הביצועים.

GPUDirect-TCPXO


"NCCL_FASTRAK_CTRL_DEV=eth0",
"NCCL_FASTRAK_IFNAME=eth1,eth2,eth3,eth4,eth5,eth6,eth7,eth8",
"NCCL_SOCKET_IFNAME=eth0",
"NCCL_CROSS_NIC=0",
"NCCL_ALGO=Ring,Tree",
"NCCL_PROTO=Simple,LL128",
"NCCL_MIN_NCHANNELS=4",
"NCCL_TUNER_PLUGIN=libnccl-tuner.so",
"NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config.textproto",
"NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_guest_config.textproto",
"NCCL_DYNAMIC_CHUNK_SIZE=524288",
"NCCL_P2P_NET_CHUNKSIZE=524288",
"NCCL_P2P_PCI_CHUNKSIZE=524288",
"NCCL_P2P_NVL_CHUNKSIZE=1048576",
"NCCL_FASTRAK_NUM_FLOWS=2",
"NCCL_FASTRAK_USE_SNAP=1",
"NCCL_FASTRAK_PLUGIN_ACCEPT_TIMEOUT_MS=600000",
"NCCL_FASTRAK_ENABLE_CONTROL_CHANNEL=0",
"NCCL_BUFFSIZE=8388608",
"CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7",
"NCCL_NET_GDR_LEVEL=PIX",
"NCCL_FASTRAK_ENABLE_HOTPATH_LOGGING=0",
"NCCL_FASTRAK_USE_LLCM=1",
"NCCL_NVLS_ENABLE=0"

אפשר גם להגדיר את כל ההגדרות בבת אחת. כך עושים את זה:

  1. במניפסט של קונטיינר עומס העבודה, מוסיפים את צמד המפתח/ערך הבא כמשתנה סביבה:

    NCCL_LIB_DIR="/usr/local/nvidia/lib64"

  2. מוודאים שהסקריפט nccl-env-profile.sh מופעל כשקונטיינר של עומס העבודה מתחיל. לדוגמה, אפשר לעשות את זה במפרט של ה-Pod על ידי שינוי הפקודה של הקונטיינר כך שתכלול את הפקודה הבאה:

    source ${NCCL_LIB_DIR}/nccl-env-profile.sh

תמיכה ב-LL128

פרוטוקול התקשורת NVIDIA LL128 (זמן אחזור נמוך 128) NCCL יכול לשפר באופן משמעותי את הביצועים של קולקטיבים קטנים עד בינוניים. ‫GPUDirect-TCPXO תומך בפרוטוקול LL128.

כדי להשתמש ב-LL128, צריך לוודא שבקובץ nccl-tcpxo-installer.yaml שבקטע Install the GPUDirect binary and configure NCCL נעשה שימוש בגרסה הבאה של קובץ האימג' בקונטיינר או בגרסה מאוחרת יותר:

us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx-
dev:v1.0.8-1

כדי להגדיר LL128:

  • לגרסת הפלאגין us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx- dev:v1.0.8-1NCCL, מבצעים את השלבים הבאים:

    1. במניפסט של עומס העבודה, מגדירים את משתנה הסביבה הבא:

      NCCL_LIB_DIR="/usr/local/nvidia/lib64

    2. מגדירים את עומס העבודה כך שיפעיל את הסקריפט nccl-env-profile-ll128.sh כשהקונטיינר מתחיל. במניפסט של עומס העבודה, מגדירים את הפקודה הבאה:

      source ${NCCL_LIB_DIR}/nccl-env-profile-ll128.sh

      לסקריפט nccl-env-profile-ll128.sh יש את משתני הסביבה הבאים:

      NCCL_PROTO=Simple,LL128
NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config_ll128.textproto
NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_guest_config_ll128.textproto

  • בגרסה של תוסף NCCL‏ us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx-dev:v1.0.9-1 ואילך, LL128 הופך לפרמטר ברירת מחדל, כך שהשימוש בסקריפט nccl-env-profile.sh או בסקריפט nccl-env-profile-ll128.sh מפעיל את LL128. כדי להשבית את LL128:

    1. במניפסט של עומס העבודה, מגדירים את משתנה הסביבה הבא:

      NCCL_LIB_DIR="/usr/local/nvidia/lib64

    2. מגדירים את עומס העבודה כך שיפעיל את הסקריפט nccl-env-profile-ll128.sh כשהקונטיינר מתחיל. במניפסט של עומס העבודה, מגדירים את הפקודה הבאה:

      source ${NCCL_LIB_DIR}/nccl-env-profile-simple.sh

      לסקריפט nccl-env-profile-simple.sh יש את משתני הסביבה הבאים:

      NCCL_PROTO=Simple
NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config_simple.textproto
NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_tuner_config_simple.textproto

GPUDirect-TCPX


"NCCL_SOCKET_IFNAME=\"eth0\"",
"NCCL_ALGO=Ring",
"NCCL_PROTO=Simple",
"NCCL_CROSS_NIC=0",
"NCCL_NET_GDR_LEVEL=PIX",
"NCCL_P2P_PXN_LEVEL=0",
"NCCL_GPUDIRECTTCPX_SOCKET_IFNAME=eth1,eth2,eth3,eth4",
"NCCL_GPUDIRECTTCPX_CTRL_DEV=eth0",
"NCCL_DYNAMIC_CHUNK_SIZE=524288",
"NCCL_P2P_NET_CHUNKSIZE=524288",
"NCCL_P2P_PCI_CHUNKSIZE=524288",
"NCCL_P2P_NVL_CHUNKSIZE=1048576",
"NCCL_BUFFSIZE=4194304",
"NCCL_NSOCKS_PERTHREAD=4",
"NCCL_SOCKET_NTHREADS=1",
"NCCL_GPUDIRECTTCPX_TX_BINDINGS=\"eth1:8-21,112-125;eth2:8-21,112-125;eth3:60-73,164-177;eth4:60-73,164-177\"",
"NCCL_GPUDIRECTTCPX_RX_BINDINGS=\"eth1:22-35,126-139;eth2:22-35,126-139;eth3:74-87,178-191;eth4:74-87,178-191\"",
"NCCL_GPUDIRECTTCPX_PROGRAM_FLOW_STEERING_WAIT_MICROS=500000"

הוספת GPUDirect למניפסטים

בקטע הזה מפורטים השדות הנדרשים שצריך להוסיף למניפסטים של Kubernetes כדי שה-Pods יוכלו להשתמש ב-GPUDirect.

במצב טייס אוטומטי, צריך גם לבחור את יחידות ה-GPU המתאימות במניפסטים של ה-Pod כדי ש-GKE יקצה את החומרה. ל-GPU מסוג H100 Mega, משתמשים ב-GPUDirect-TCPXO. במקרים של יחידות GPU מדגם H100, צריך להשתמש ב-GPUDirect-TCPX.

מוסיפים את בוררי הצמתים הבאים ל-Pod:

nodeSelector:
  cloud.google.com/gke-accelerator: GPU_NAME
  cloud.google.com/gke-gpu-driver-version: latest

מחליפים את GPU_NAME בשם של ה-GPU. הערכים הנתמכים הם:

  • nvidia-h100-mega-80gb
  • nvidia-h100-80gb

בנוסף, אם רוצים להשתמש בקיבולת מוזמנת, אפשר לספק מידע על ההזמנה, כולל השם, ואם רוצים, גם הבלוק ותת-הבלוק. מידע נוסף זמין בקטעי המשנה בנושא שימוש בהזמנות בשימוש בהזמנות של קיבולת באשכולות של Autopilot.

בהתאם לסוג ה-GPUDirect, מבצעים את הפעולות הבאות:

GPUDirect-TCPXO

  1. מוסיפים את ההערות הבאות למטא-נתונים של ה-Pod. 

    metadata:
  annotations:
    devices.gke.io/container.tcpxo-daemon: |+
      - path: /dev/nvidia0
      - path: /dev/nvidia1
      - path: /dev/nvidia2
      - path: /dev/nvidia3
      - path: /dev/nvidia4
      - path: /dev/nvidia5
      - path: /dev/nvidia6
      - path: /dev/nvidia7
      - path: /dev/nvidiactl
      - path: /dev/nvidia-uvm
      - path: /dev/dmabuf_import_helper
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth1","network":"vpc1"},
        {"interfaceName":"eth2","network":"vpc2"},
        {"interfaceName":"eth3","network":"vpc3"},
        {"interfaceName":"eth4","network":"vpc4"},
        {"interfaceName":"eth5","network":"vpc5"},
        {"interfaceName":"eth6","network":"vpc6"},
        {"interfaceName":"eth7","network":"vpc7"},
        {"interfaceName":"eth8","network":"vpc8"}
      ]

  2. מוסיפים את השדות הבאים למפרט של ה-Pod:

    spec:
  volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia/lib64
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys
  - name: aperture-devices
    hostPath:
      path: /dev/aperture_devices

  3. כדי להפעיל את השירות tcpxo-daemon, מוסיפים את הקונטיינר הבא למניפסט. מחליפים את (TCPXO_DAEMON_IMAGE) בתמונה האחרונה – לדוגמה, us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/tcpgpudmarxd-dev:v1.0.17:

    - name: tcpxo-daemon
  image: TCPXO_DAEMON_IMAGE
  imagePullPolicy: Always
  command: ["/bin/sh", "-c"]
  args:
    - |
      set -ex
      chmod 755 /fts/entrypoint_rxdm_container.sh
      /fts/entrypoint_rxdm_container.sh --num_hops=2 --num_nics=8 --uid= --alsologtostderr
  securityContext:
    capabilities:
      add:
        - NET_ADMIN
        - NET_BIND_SERVICE
  volumeMounts:
    - name: libraries
      mountPath: /usr/local/nvidia/lib64
    - name: sys
      mountPath: /hostsysfs
    - name: proc-sys
      mountPath: /hostprocsysfs

  4. מוסיפים את משתנה הסביבה הבא לכל קונטיינר GPU:

    env:

- name: NCCL_FASTRAK_LLCM_DEVICE_DIRECTORY
  value: /dev/aperture_devices

  5. מוסיפים את ה-volumeMounts הבאים לכל קונטיינר GPU. אם לא משתמשים בהגדרות aperture_devices, צריך להשתמש ב-privileged:true לקונטיינרים של GPU:

    volumeMounts:
  - name: aperture-devices
    mountPath: /dev/aperture_devices

  6. מוסיפים משתני סביבה כדי להגדיר את האפשרויות של NCCL. פרטים נוספים מופיעים במאמר שימוש בהגדרות מומלצות של NCCL לשיפור הביצועים.

דוגמה למפרט Pod מלא מופיעה במניפסט nccl-test-latest-autopilot.yaml ב-GitHub.

GPUDirect-TCPX

  1. מוסיפים את ההערות הבאות למטא-נתונים של ה-Pod. 

    metadata:
  annotations:
    devices.gke.io/container.tcpx-daemon: |+
      - path: /dev/nvidia0
      - path: /dev/nvidia1
      - path: /dev/nvidia2
      - path: /dev/nvidia3
      - path: /dev/nvidia4
      - path: /dev/nvidia5
      - path: /dev/nvidia6
      - path: /dev/nvidia7
      - path: /dev/nvidiactl
      - path: /dev/nvidia-uvm
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth1","network":"vpc1"},
        {"interfaceName":"eth2","network":"vpc2"},
        {"interfaceName":"eth3","network":"vpc3"},
        {"interfaceName":"eth4","network":"vpc4"},
      ]

  2. מוסיפים את השדות הבאים למפרט של ה-Pod:

    spec:
  volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia/lib64
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys

  3. מוסיפים את הקונטיינר הבא למניפסט כדי להריץ את השירות tcpx-daemon:

    - name: tcpx-daemon
  image: us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/tcpgpudmarxd-dev:v2.0.12
  command:
    - /tcpgpudmarxd/build/app/tcpgpudmarxd
    - --gpu_nic_preset
    - a3vm
    - --gpu_shmem_type
    - fd
    - --uds_path
    - /run/tcpx
    - --setup_param
    - \"--verbose 128 2 0 \"
  securityContext:
    capabilities:
        add:
          - NET_ADMIN
  volumeMounts:
    - name: libraries
      mountPath: /usr/local/nvidia/lib64
    - name: tcpx-socket
      mountPath: /run/tcpx
    - name: sys
      mountPath: /hostsysfs
    - name: proc-sys
      mountPath: /hostprocsysfs

  4. מוסיפים את נקודות הגישה הבאות לנפח אחסון לכל קונטיינר שמבקש יחידות GPU:

    volumeMounts:
- name: tcpx-socket
  mountPath: /tmp
- name: libraries
  mountPath: /usr/local/nvidia/lib64

  5. מוסיפים משתני סביבה כדי להגדיר את האפשרויות של NCCL. פרטים נוספים מופיעים בקטע שימוש בהגדרות מומלצות של NCCL לשיפור הביצועים במאמר הזה.

דוגמה למפרט Pod מלא מופיעה במניפסט nccl-test-latest-autopilot.yaml ב-GitHub.

איסוף יומני ניפוי באגים של NCCL

כדי לרשום ביומן שגיאות של NCCL, מומלץ להוסיף את הגדרת ה-NCCL הבאה:

NCCL_DEBUG=INFO
NCCL_DEBUG_SUBSYS=INIT,NET,ENV,COLL,GRAPH
NCCL_DEBUG_FILE=/DIRECTORY/FILE_NAME.%h.%p
  • ‫NCCL_DEBUG=INFO: מדפיס מידע על תוצאות ניפוי הבאגים.
    • בעומסי עבודה גדולים (64 צמתים או יותר), יכולה להתרחש כמות גדולה של רישום ביומן. כדי להימנע מהתרחיש הזה – אלא אם ציינתם NCCL_DEBUG_FILE – מומלץ להגדיר את NCCL_DEBUG=WARN כך שהיומנים יכללו רק שגיאות.

  • ‫NCCL_DEBUG_SUBSYS: מסנן את מערכות המשנה ש-NCCL אוסף לגביהן מידע לניפוי באגים. מומלץ לאסוף יומנים עבור מערכות המשנה הבאות:

    • ‫INIT: שלב האתחול של NCCL.
    • ‫NET: רשת NCCL.
    • ‫ENV: משתני הסביבה ש-NCCL משתמש בהם.
    • ‫COLL: פעולות קולקטיביות.
    • ‫GRAPH: זיהוי טופולוגיה וחיפוש גרפים.

    אם רוצים לאסוף יומנים עבור מערכות משנה שונות, אפשר לעיין בNCCL_DEBUG_SUBSYS במסמכי התיעוד של NCCL כדי לראות רשימה של ערכים קבילים.

  • ‫NCCL_DEBUG_FILE (אופציונלי): מכוון את פלט הרישום של ניפוי הבאגים של NCCL לקובץ שאתם מציינים. המשתנה הזה כותב יומנים של NCCL לקבצים רגילים, וכך מונע ערבוב של פלט היומן עם פלט האפליקציה. המשתנה הזה גם כותב יומנים מדרגות שונות של NCCL לקבצים שונים, וכך מונע ערבוב של היומנים.

    צריך להשתמש בפורמט הבא לשם הקובץ:

    /DIRECTORY/FILE_NAME.%h.%p

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫DIRECTORY: הספרייה שבה רוצים לאחסן את קובצי היומן.
    • ‫FILE_NAME: השם של קובצי היומן.

    ה-placeholder ‏%h מומר לשם המארח של הצומת, ואילו %p מומר למזהה התהליך (PID) של התהליך שיוצר את היומן.

למידע נוסף על ניפוי באגים ביומני NCCL, ראו פתרון בעיות ב-GPU ב-GKE.

המאמרים הבאים