-sdy-close-shardings

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

-sdy-constant-or-scalar-merger

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

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

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

-sdy-convert-global-to-local

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

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

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

אפשרויות

-per-dim-all-gather                     : Keep per-dimension all-gather without combining them into a single all-gather.
-combine-multi-dimension-reduce-scatter : Combine multi-dimension reduce-scatter into a single reduce-scatter.
-enable-rgv3                            : Use StableHLO ReplicaGroupV3 (mesh-axes based) for collectives.
-replica-count                          : Number of replicas (data parallelism).
-partition-count                        : Number of partitions (model parallelism).

-sdy-drop-sharding-and-mesh

הסרת פעולת הרשת והסימון של חלוקת הנתונים מהתוכנית.

אפשרויות

-keep-module-sharding-metadata : Whether to keep module-level sharding metadata (sdy.parameters_shardings and sdy.output_shardings).

-sdy-drop-sharding-rules

מבטל את OpShardingRuleAttr מכל הפעולות הרשומות.

-sdy-export-named-computations

צור תרשים של שיחות מהמספר NamedComputationOp.

יוצר מעבר שממיר NamedComputationOp ל-CallOp עם פונקציה פרטית חדשה שנקראת name של NamedComputationOp. ה-FuncOp וה-CallOp החדשים כוללים את אותם פיצולים כמו האופרנדים/התוצאות של ה-NamedComputationOp המקורי.

אם יש פונקציה עם אותו שם כמו NamedComputationOp במודול, טבלת הסמלים של MLIR תשנה אותו ל-{name}_#.

-sdy-insert-explicit-reshards

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

חלוקה תואמת ל-shards פירושה שהפעולה יכולה לקבל את האופרנדים המחולקים ל-shards ולהפיק תוצאה מחולקת ל-shards בלי לדרוש תקשורת של חלוקה מחדש ל-shards (שימו לב שהפעולה עדיין עשויה לדרוש תקשורת כמו 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.
-mark-partial-result-with-unreduced-axes : Whether to mark partial reduction results with unreduced axes.

-sdy-insert-func-call-reshards

הוספת חלוקה מחדש של פונקציות וקריאות במקרה של התנגשויות בחלוקה.

מוסיף חלוקה מחדש של נתונים לפתרון קונפליקטים של חלוקת נתונים לפי פונקציה וחלוקת נתונים לפי קריאה בתוצאות.

-sdy-optimize-collectives

אופטימיזציה של פעולות תקשורת קולקטיביות.

הפונקציה מבטלת פעולות מיותרות של החלפת מיקום קולקטיבית לפני שרשראות של all-to-all, על ידי פירוק של מאפיינים מפוצלים ומיזוג שלהם ל-all-to-all משולב.

-sdy-pad-for-divisibility

מרפד טנזורים עם חלוקות שלא ניתנות לחלוקה לצורות שניתנות לחלוקה.

-sdy-per-instruction-partitioning

_מחלץ באופן סלקטיבי הוראות יעד, מריץ עליהן את צינור עיבוד הנתונים של החלוקה למחיצות כדי ליצור קוד מקומי במכשיר, ועוטף אותן ב-sdy.manualcomputation.

למטרות ניפוי באגים וחלוקה לשניים, מחלק באופן סלקטיבי הוראות ספציפיות באמצעות צינור עיבוד הנתונים העצמאי של Shardy partitioner‏ (resolve-permutation-factors,‏ reshard-to-collectives, ‏ pad-for-divisibility, ‏ convert-global-to-local), ועוטף את הקוד שנוצר במכשיר המקומי בתוך sdy.manual_computation. כך שאר התוכנית הגלובלית נשארת ללא שינוי, ו-XLA SPMD מחלק רק את ההוראות הגלובליות שלא עטופות.

אפשרויות

-filter                   : Filter string for selective partitioning. Can be empty (all sharded ops), comma-separated op name substrings (e.g. 'dot, pad'), or key-values like 'selectLow=0, selectHigh=10, func=subroutine'.
-enable-halo-exchange     : Implement halo exchange logic for windowed operations inside the sub-pipeline.
-replica-count            : Number of replicas (data parallelism).
-partition-count          : Number of partitions (model parallelism).
-rng-bit-generator-unsafe : Whether to allow unsafe partitioning of stablehlo.rng_bit_generator.

-sdy-propagate-to-func-results

הפצת שברי מידע ממסיימי הפונקציות לתוצאות הפונקציות.

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

-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, &q>uot;y"=<2, ">;z"=2
%0 <: tensor16x2xf32 {sdy.sharding>@mesh, \[{"x",< "y", &quo>t;z"<}, {}\]<>/span>
%1 = sdy.reshard %arg0 @mesh, \[{"x"}, {}\] : tensor16x2xf32

פלט:

mesh = <"x"=2, &q>uot;y"=<2, ">;z"=2
%0 <: tensor16x2xf32 {sdy.sharding>@mesh, \[{"x", "y", "z"}, {}\]<
%1 = sdy.all_gather> \[{&quo<t;y">;, "z"}, {}\] %arg0 out_sharding=@mesh, \[{"x"}, {}\] : tensor16x2xf32

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

אפשרויות

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

-sdy-resolve-permutation-factors

פתרון בעיות של פיצול נתונים (sharding) במאפיינים שממופים לגורמי kPermutation.

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

אם הערך של enableHaloExchange הוא true, הכרטיס ישתמש בלוגיקה זמינה של תקשורת אופטימלית כדי לפתור את גורמי הפרמוטציה. אחרת, המעבר פשוט יוסיף פעולות של sdy.reshard כדי לשכפל את המאפיינים האלה. ערך ברירת המחדל של enableHaloExchange הוא true.

אפשרויות

-enable-halo-exchange     : Implement halo exchange logic for windowed operations.
-replica-count            : Number of replicas (data parallelism).
-partition-count          : Number of partitions (model parallelism).
-rng-bit-generator-unsafe : Whether to allow unsafe partitioning of stablehlo.rng_bit_generator.

-sdy-resolve-single-device-sharding

הורדת פעולות של מכשיר יחיד ל-stablehlo.if, שמוגן על ידי מזהה מכשיר היעד.

אפשרויות

-replica-count   : Number of replicas per partition.
-partition-count : Number of partitions per replica.

-sdy-sharding-constraint-to-reshard

ממיר ShardingConstraintOp ל-ReshardOp.

-sdy-sink-data-flow-edges

מכניס את כל ה-DataFlowEdgeOp לקלט שלהם.

מעבירה את ה-sharding של כל 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-sink-func-data-flow-edges

מכניס את כל ה-FuncDataFlowEdgeOp לקלט שלהם.

העברת הפיצול של כל FuncDataFlowEdgeOp לקלט שלו והחלפת הפעולה בקלט שלה.

-sdy-unflatten-call-graph

הסרת ההשטחה של גרף השיחות.

ביטול השטחת התרשים. הפונקציה מסירה כפילויות של פונקציות עם אותם נתוני קלט/פלט של שברי נתונים ואותו מקור, כפי שמתואר במאפיין original_func_name שצורף לפונקציות.

אפשרויות

-dedup-functions-fully : If true, regardless of the input and output shardings of functions, it keeps one callee function for each caller function. The default is false, meaning it will deduplicate only if the input and output shardings are the same.

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

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

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

-sdy-verify-unreduced-axes

בודק את העקביות של השימוש בציר שלא צומצם.

הבדיקה מוודאת שבכל פעולה, אם לאופרנדים שלה יש צירים לא מצומצמים, הפעולה מצמצמת אותם באופן מפורש (למשל, באמצעות sdy.reshard) או מעבירה אותם לתוצאות שלה (או שהיא פעולה תוחמת כמו func.call).