-sdy-close-shardings

סוגר את חלוקת הטנסור ומסיר צירים משוכפלים.

-sdy-constant-or-scalar-merger

מיזוג של קבועים זהים והרחבות סקלריות עם פיצולים תואמים.

מבצע CSE קל משקל על קבועים עם חלוקות זהות.

פייפליין הייבוא מפצל ומשכפל את הקבועים ואת ההרחבות הסקלריות, כך שהפיצול (sharding) לא מועבר בין שימושים שונים של חישוב משנה קבוע. אם לקבועי הערך יש אותם פיצולים אחרי ההפצה, המעבר הזה ממזג אותם כדי לחסוך זמן קומפילציה. מידע נוסף זמין במאמר בנושא -sdy-constant-or-scalar-splitter.

-sdy-convert-global-to-local

הפונקציה ממירה תוכנית SDY מצורות גלובליות לצורות מקומיות.

ממירה תוכנית SDY מצורות גלובליות לצורות מקומיות על ידי חלוקה של מימדים לוגיים על סמך מאפייני שרדינג.

ההעברה הזו מסתמכת על ממיר סוגים כדי למפות RankedTensorType מצורות לוגיות גלובליות לצורות פיזיות מקומיות במכשיר.

-sdy-drop-sharding-rules

השקות של מוצרים OpShardingRuleAttr מכל הפעולות הרשומות.

-sdy-insert-explicit-reshards

מוסיף פיצולים מחדש מפורשים כדי שכל הפעולות יתאימו לפיצולים.

פיצול תואם לשברים בעצם אומר שהפעולה יכולה לקבל את האופרנדים המפוצלים לשברים ולהפיק תוצאה מפוצלת לשברים בלי לדרוש תקשורת של פיצול מחדש לשברים (שימו לב שהפעולה עדיין עשויה לדרוש תקשורת כמו all-reduce או halo-swaps).

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

שימו לב: אם ציר (או ציר משנה) משמש לפיצול מאפיינים לא תואמים (למשל, מאפיינים לא מתכווצים ב-matmul) בין כמה טנסורים, או אם ציר מפצל מאפיין בטנסור אחד אבל לא את המאפיין התואם בטנסור השני, אומרים שלפעולה יש קונפליקט פיצול. לכן, אחרי המעבר הזה, הפעולות לא יגרמו יותר לקונפליקטים.

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

דוגמה:

קלט:

mesh = <"x"=4, "y"=2>
%lhs : tensor<8x32xf32> {sdy.sharding=<@mesh, \[{"x"}, {"y"}\]>}
%rhs : tensor<32x16xf32> {sdy.sharding=<@mesh, \[{"y"}, {"x"}\]>}
stablehlo.dot %lhs, %rhs {sdy.sharding_per_value=<[<@mesh, \[{"x"}, {}\]>]>}
  : (tensor<8x32xf32>, tensor<32x16xf32>) -> tensor<8x16xf32>

פלט:

sdy.mesh = <"x"=4, "y"=2>
%lhs : tensor<8x32xf32> {sdy.sharding=<@mesh, \[{"x"}, {"y"}\]>}
%rhs : tensor<32x16xf32> {sdy.sharding=<@mesh, \[{"y"}, {"x"}\]>}
%0 = sdy.reshard %rhs <@mesh, \[{"y"}, {}\]> : tensor<32x16xf32>
stablehlo.dot %lhs, %0 {sdy.sharding_per_value=<[<@mesh, \[{"x"}, {}\]>]>}
  : (tensor<8x32xf32>, tensor<32x16xf32>) -> tensor<8x16xf32>

בדוגמה שלמעלה, גם lhs וגם rhs מפולחים על ציר x במאפיינים שלהם שלא מתכווצים, וזה לא תואם. המעבר מוסיף חלוקה מחדש מפורשת ב-rhs לפני פעולת הנקודה, כדי שלפעולת הנקודה תהיה חלוקה תואמת.

אפשרויות

-enable-full-version                  : Enable full version.
-avoid-reshards-on-named-computations : Avoid explicit reshards/collectives on named computations.

-sdy-remove-all-gather-reduce-scatter-for-cmv1

‫_Removes sdy.all_gather and sdy.reducescatter for CMV1.

הסרה של all-gather בתבנית all-gather + dot. הסרה של reduce-scatter בדוגמה dot + reduce-scatter. המעבר הזה נועד לתאימות ל-collective matmul V1 ‏ (CMV1). זהו פתרון זמני לבעיה b/432019089.

-sdy-remove-propagation-debug-info

הסרת מידע לניפוי באגים על הפצה (קצוות הפצה וחלוקת מקור) במהלך הייצוא.

-sdy-remove-sharding-groups

מסיר את ShardingGroupOps אחרי ההפצה.

-sdy-remove-sub-axes-in-input-output-shardings

מסיר צירים משניים בחלוקת קלט/פלט.

חלק מהמשתמשים ב-Shardy מצפים שהקלט והפלט של הפונקציה יכללו פיצולים ללא צירים משניים. השלב הזה מסיר צירים משניים ואת הצירים הבאים שלהם מפיצולי הקלט/פלט. המעבר הזה מתבצע בדרך כלל אחרי sdy-update-non-divisible-input-output-shardings כדי לוודא שהסרת צירים משניים לא תגרום לפיצול לא שווה של הנתונים.

-sdy-reshard-to-collectives

ממיר ReshardOp לפעולות שונות של Shardy collective.

הוא מתאים פעולות של חלוקה מחדש של נתונים ומבצע עליהן כתיבה מחדש לפעולות שונות של Shardy collective. אחרי המעבר הזה, לא נשארו פעולות של חלוקה מחדש של נתונים במודול.

אופציונלי: אם keepRedundantReshards הוא True, הפעולות היחידות שנותרות הן פעולות מיותרות. כברירת מחדל, המערכת מניחה שפירטינג מפורש כבר הוכנס (sdy-insert-explicit-reshards) ולא שומרת על פירטינג מיותר. הוא צריך לשמור על חלוקות מיותרות אם יכול להיות שחלוקות מחדש מפורשות עדיין לא הוכנסו.

דוגמה:

קלט:

mesh = <"x"=2, "y"=2, "z"=2>
%0 : tensor<16x2xf32> {sdy.sharding<@mesh, \[{"x", "y", "z"}, {}\]>
%1 = sdy.reshard %arg0 <@mesh, \[{"x"}, {}\]> : tensor<16x2xf32>

פלט:

mesh = <"x"=2, "y"=2, "z"=2>
%0 : tensor<16x2xf32> {sdy.sharding<@mesh, \[{"x", "y", "z"}, {}\]>
%1 = sdy.all_gather \[{"y", "z"}, {}\] %arg0 out_sharding=<@mesh, \[{"x"}, {}\]> : tensor<16x2xf32>

בדוגמה שלמעלה, הטנזור %0 : tensor<16x2xf32> מפולח כך: \[{"x", "y", "z"}, {}\]. לאחר מכן, יש reshard אפשרות לשנות את מספר הרסיסים ל-\[{"x"}, {}\]. בצירים הראשונים, מאחר שהסיומת {"y", "z"} מוסרת אחרי החלוקה מחדש, אנחנו מסיקים שאספנו את כל הנתונים של {"y", "z"}. המאפיין השני לא משתנה.

אפשרויות

-keep-redundant-reshards : Whether it keeps redundant reshards or removes.

-sdy-sharding-constraint-to-reshard

ממיר ShardingConstraintOp ל-ReshardOp.

-sdy-sink-data-flow-edges

כל DataFlowEdgeOp מוזן לקלט שלו.

הפעולה מעבירה את הפיצול של כל DataFlowEdgeOp לקלט שלו (יעד הבסיס של הקצה), ומחליפה את הפעולה בקלט שלה.

אפשרויות

-sink-debug-sharding-origins          : Whether to sink the debug sharding origins info. See `debug-sharding-origins` option in propagation for more info.
-sink-debug-propagation-edge-sharding : Whether to sink the debug propagation edge sharding info. See `debug-propagation-edge-sharding` option in propagation for more info.

-sdy-update-non-divisible-input-output-shardings

הפונקציה הזו מחלקת את הקלט והפלט של FuncOp באופן שווה, כך שלא צריך להוסיף ריפוד בגלל חלוקה לא שווה.

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