פיצול (sharding) חכם ב-הרצה במכשיר ב-Developer Device Platform

התכונה "חלוקה חכמה לפלחים" ב-Developer Device Platform הרצה במכשיר מחלקת את בדיקות האינסטרומנטציה של Android ואת בדיקות ה-XCTest של iOS לפלחים מקבילים, על סמך זמני ביצוע בדיקה היסטוריים שמאוחסנים ב-Cloud Storage. בניגוד לחלוקה אחידה, שבה מקרי הבדיקה מחולקים לפי מספר, בלי קשר למשך הזמן של כל בדיקה, בחלוקה חכמה מקרי הבדיקה מחולקים לפי משך הזמן הצפוי, כך שהבדיקות המקבילות מסתיימות בערך באותו זמן.

במסמך הזה מוסבר איך אלגוריתם הפיצול החכם מחשב את מספר הפיצולים ומקצה בדיקות, מתואר הסכימה של רשומת התזמון ב-YAML שמאוחסנת בקטגוריה של Cloud Storage, וניתנות תשובות לשאלות נפוצות לגבי התקורה של תזמור בדיקות ל-Android וחלון הנתונים המתגלגל של 30 יום. כדי להשתמש ב-Google Cloud CLI, קראו את ההוראות להרצת בדיקות Android instrumentation ו-iOS XCTest בשורת הפקודה.

איך פועל אלגוריתם הפיצול החכם

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

כששולחים סשן עם --sharding-option=smart ב-CLI של gcloud או מגדירים את smartSharding ב-API בארכיטקטורת REST, פלטפורמת Developer Device Platform מריצה תהליך עבודה של שישה שלבים שכולל יצירת סשן, ביצוע בדיקה והשלמה:

  1. קוראים נתונים היסטוריים של תזמון ומתאימים את ההקשר של המכשיר. לפני תזמון הפיצולים, סוכן השירות של "הרצה במכשיר" קורא את קובץ ה-YAML של הפיצול החכם מ-Cloud Storage. היא מחפשת ברשימה records ערך shardingContext שתואם לערכים deviceModel ו-osVersion של משימת היעד (לא תלוי-רישיות). אם אין התאמה מדויקת לשילוב הזה של המכשיר ומערכת ההפעלה, פלטפורמת Developer Device Platform חוזרת לרשומה הראשונה של records שזמינה בקובץ. אם קובץ ה-YAML עדיין לא קיים, הסשן ממשיך כהפעלה במצב התחלתי (cold start) עם היסטוריית תזמון ריקה.
  2. מסננים את הדגימות לחלון זמן דינמי של 30 יום ומחשבים את משכי הזמן הצפויים. ברשומת ההקשר שנבחרה, Developer Device Platform שומרת רק דגימות תזמון שהערך של recordTime שלהן הוא ב-30 הימים האחרונים, ומחשבת את משך הזמן הממוצע האריתמטי של כל מקרה בדיקה. אם תזמור בדיקות ל-Android מופעל עם --orchestrator-version, ‏Developer Device Platform מחשבת גם את הממוצע של 30 יום של דגימות התקורה של ANDROID_TEST_ORCHESTRATOR ומוסיפה את התקורה הממוצעת הזו למשך הזמן הצפוי של כל מקרה בדיקה.
  3. מגלים בדיקות שאפשר להריץ ומקצים אומדנים חלופיים. במארח של ה-worker, פלטפורמת Developer Device Platform בודקת באופן סטטי את חבילת הבדיקה – קוראת קובצי DEX ב-APK של הבדיקה ב-Android, או סמלי .xctest ומסנני .xctestrun שעברו הידור ב-iOS – מחילה מסנני --test-targets ומוציאה בדיקות שהמערכת מתעלמת מהן או מדכאת אותן (כמו @Ignore או @Suppress). כל יחידת בדיקה שאפשר להריץ מקבלת משך זמן צפוי על סמך שלוש רמות:
    • מקרה בדיקה מתועד: משתמש במשך הזמן הממוצע ההיסטורי של 30 יום (בתוספת התקורה הממוצעת של התזמור כשמופעל תזמור בדיקות ל-Android). ב-Android, מחלקות JUnit עם פרמטרים (כמו מחלקות שמשתמשות ב-@RunWith(Parameterized.class), ב-JUnitParamsRunner או ב-TestParameterInjector) מתוזמנות כיחידה אחת ברמת המחלקה, ומשך הזמן הצפוי שלהן הוא הסכום של כל משכי הזמן המתועדים של השיטות באותה מחלקה.
    • מקרה בדיקה שלא תועד בחבילה קיימת: משתמש במשך הזמן הממוצע הצפוי של כל מקרי הבדיקה המתועדים שאינם אפס ברשומה התואמת.
    • הפעלה קרה (אין היסטוריה מתועדת): המערכת משתמשת בהערכה של 30 שניות כברירת מחדל לכל יחידת בדיקה.
  4. חישוב מספר השארדים פלטפורמת Developer Device Platform מסכמת את משכי הזמן הצפויים של כל יחידות הבדיקה שאפשר להריץ, ומחלקת אותם בערך של --smart-sharding-target-duration שהגדרתם (תקף מ-2m עד 1h). לאחר מכן היא מעגלת את התוצאה כלפי מעלה למספר השלם הקרוב ביותר של שאשאים:

    optimal_shards = max(1, ceil(total_expected_duration / target_duration))
    

    לאחר מכן, Developer Device Platform מגדירה את מספר השארדים הסופי בין 1 לבין המגבלה הנמוכה ביותר מבין המגבלות הבאות:

    • המספר הכולל של יחידות בדיקה שאפשר להריץ (כדי למנוע פיצולים ריקים).
    • הערך של --smart-sharding-max-shard-count, אם הוא גדול מ-0.
    • מגבלת הפלטפורמה (20 פיצולים למכשירים פיזיים או 200 פיצולים למכשירים וירטואליים של Android).
  5. הקצאת בדיקות באמצעות סידור בקונטיינרים (bin packing) לפי זמן העיבוד הארוך ביותר. ‫Developer Device Platform ממיינת את כל יחידות הבדיקה שאפשר להריץ בסדר יורד של משך הזמן הצפוי (מהאיטי ביותר למהיר ביותר) ומאתחלת ערימת מינימום של שאילתות ריקות שממוינות לפי משך הזמן המצטבר. הוא לוקח יחידת בדיקה אחת בכל פעם, מקצה את הבדיקה האיטית ביותר שנותרה למקטע עם משך הזמן המצטבר הקצר ביותר, ומעדכן את הסך הכול של המקטע הזה. אם מתזמנים קודם בדיקות ארוכות ואיטיות, הן מבודדות לשארדים נפרדים, ובדיקות קצרות יותר ממלאות את הפערים שנותרו כדי לשמור על איזון במשך הזמן הכולל של השארדים.

  6. מתעדים את זמני המעבר ומעדכנים את Cloud Storage. אחרי שכל השארדים מסתיימים, Developer Device Platform אוספת את משכי הזמן שנמדדו מ-startTime עד endTime של מקרי הבדיקה שעברו, מסירה את כל הדגימות שנוצרו לפני יותר מ-30 יום בכל ההקשרים של המכשירים בקובץ ה-YAML, מסירה את כל רשומות ההקשרים שלא נותרו בהן דגימות תקינות וכותבת את קובץ ה-YAML המעודכן בחזרה ב-Cloud Storage באמצעות ניסיונות חוזרים של בקרת בו-זמניות אופטימית עם התאמה לפי דור.

מבנה קובץ YAML של חלוקה חכמה לפלחים

כשמריצים סשן באמצעות ה-CLI של gcloud, הערך --smart-sharding-record-name מציין את שם הקובץ הבסיסי (לא כולל הסיומת YAML) של רשומת התזמון שמאוחסנת בקטגוריה של Cloud Storage בפרויקט Google Cloud :

gs://BUCKET_NAME/automation/smart-sharding/RECORD_NAME.yaml

מחליפים את ה-placeholders הבאים:

  • ‫BUCKET_NAME: השם של הקטגוריה ב-Cloud Storage שצוין באמצעות --bucket-name, או <var>PROJECT_ID</var>-devicerun כברירת מחדל (כאשר PROJECT_ID הוא מזהה הפרויקט ב- Google Cloud).
  • ‫RECORD_NAME: מזהה הרשומה שמועבר אל --smart-sharding-record-name בלי סיומת הקובץ YAML (לדוגמה, checkout-suite ממופה אל automation/smart-sharding/checkout-suite.yaml).

רשומת תזמון לדוגמה ב-YAML

הדוגמה הבאה מציגה קובץ YAML של חלוקה חכמה לפלחים (checkout-suite.yaml) שמכיל רשומות תזמון לשני הקשרי מכשירים – מכשיר Android שפועל עם תזמור בדיקות ל-Android ומכשיר iOS:

records:
- shardingContext:
    deviceModel: shiba
    osVersion: '34'
  testCaseTimingRecords:
  - testCaseName: com.example.shop.CheckoutTest#testCompletePurchase
    timingSamples:
    - duration: 42.180s
      recordTime: '2026-11-08T14:20:11Z'
    - duration: 44.050s
      recordTime: '2026-11-09T16:45:03Z'
  - testCaseName: com.example.shop.CartTest#testApplyPromoCode
    timingSamples:
    - duration: 8.600s
      recordTime: '2026-11-08T14:20:11Z'
    - duration: 9.120s
      recordTime: '2026-11-09T16:45:03Z'
  conditionalOverheads:
  - condition: ANDROID_TEST_ORCHESTRATOR
    timingSamples:
    - duration: 2.850s
      recordTime: '2026-11-08T14:20:11Z'
    - duration: 3.150s
      recordTime: '2026-11-09T16:45:03Z'
- shardingContext:
    deviceModel: iphonese3
    osVersion: '18.4'
  testCaseTimingRecords:
  - testCaseName: ShopTests.CheckoutTests#testApplePaySheet
    timingSamples:
    - duration: 19.340s
      recordTime: '2026-11-09T17:10:29Z'

הפניה לשדה YAML

קובץ ה-YAML של חלוקה חכמה ל-shards מבצע סריאליזציה של הסכימה SuiteTiming באמצעות שמות שדות ב-camelCase. בטבלה הבאה מתוארים כל השדות בקובץ:

שדה סוג תיאור
metadata מפה (string עד string) מטא-נתונים אופציונליים של מפתח/ערך ברמת החבילה, שנשמרים בכל עדכוני הצבירה.
records רשימת אובייקטים רשומות תזמון לכל מכשיר (SuiteTimingWithContext), מחולקות לפי דגם החומרה וגרסת מערכת ההפעלה.
records[].shardingContext אובייקט מאפיינים של חומרה ומערכת הפעלה שכוללים קבוצה של מדידות תזמון.
records[].shardingContext.deviceModel string מזהה הדגם של המכשיר שבו תועדו זמני הטעינה (לדוגמה, shiba ב-Android או iphonese3 ב-iOS).
records[].shardingContext.osVersion string גרסת מערכת ההפעלה או ה-SDK של המכשיר (לדוגמה, רמת API של Android '34' או גרסת iOS '18.4').
records[].testCaseTimingRecords רשימת אובייקטים משך הזמן של הרצות היסטוריות של מקרי בדיקה ספציפיים שעברו בהצלחה בהקשר הזה.
records[].testCaseTimingRecords[].testCaseName string מזהה בדיקה מלא בפורמט package.ClassName#methodName (או package.ClassName אם המטא-נתונים של השיטה חסרים).
records[].testCaseTimingRecords[].timingSamples רשימת אובייקטים רשימה של משכי הזמן שנמדדו למקרה הבדיקה ב-30 הימים האחרונים, שנוספה אחרי הרצות מוצלחות.
timingSamples[].duration מחרוזת משך זמן משך הזמן שנמדד, בפורמט של שניות עם דיוק אופציונלי של שברים (לדוגמה, 10s או 42.180s).
timingSamples[].recordTime מחרוזת של חותמת זמן חותמת זמן לפי שעון UTC בפורמט RFC 3339 שמציינת מתי Developer Device Platform תיעדה את הדגימה (לדוגמה, '2026-11-09T16:45:03Z').
records[].conditionalOverheads רשימת אובייקטים תקורה אופציונלית של ביצוע שנמדדה במצבי runner ספציפיים, בהיקף של shardingContext. השדה הזה מושמט אם אין עלויות תקורה מותנות.
records[].conditionalOverheads[].condition string מזהה של תנאי הביצוע. ערך נתמך: ANDROID_TEST_ORCHESTRATOR.
records[].conditionalOverheads[].timingSamples רשימת אובייקטים רשימה מתגלגלת של 30 יום של דגימות תקורה לכל מעבר שתועדו משארדים שעומדים בדרישות.

הסבר על זמני התקורה של ANDROID_TEST_ORCHESTRATOR

כשמריצים בדיקות אינסטרומנטציה של Android באמצעות --orchestrator-version, קובץ ה-YAML של חלוקה חכמה לפלחים כולל רשומת conditionalOverheads עם condition: ANDROID_TEST_ORCHESTRATOR. בניגוד ל-testCaseTimingRecords, דגימות התקורה האלה לא מצורפות לשיטת בדיקה ספציפית או למאגר נתונים ממוספר.

מה מייצגת דגימה אחת של משך זמן התקורה

כשהכלי תזמור בדיקות ל-Android מופעל, הוא מריץ כל שיטת בדיקה בתהליך Instrumentation מבודד משלה. חותמות הזמן של הבדיקות הנפרדות startTime ו-endTime מתעדות רק את הזמן שנדרש בתוך כל שיטת בדיקה – הן לא כוללות את הפער בין הבדיקות שנדרש כדי לעצור את תהליך האפליקציה הקודם, לנקות את נתוני החבילה (clearPackageData) ולהתחיל תהליך Instrumentation חדש לבדיקה הבאה.

כדי למדוד את עלות המעבר בין הבדיקות, פלטפורמת Developer Device Platform בודקת כל שאילתה שעוברת ומריצה שני מקרי בדיקה או יותר (N > 1) ומחשבת:

  1. משך ההרצה הכולל של המקטע: הזמן שחלף מהבדיקה המוקדמת ביותר startTime במקטע ועד לבדיקה האחרונה endTime במקטע.
  2. משך הזמן הכולל של מקרי הבדיקה: הסכום של (endTime - startTime) בכל N מקרי הבדיקה באותו שאשאד.
  3. תקורה ממוצעת לכל מעבר: מכיוון שב-N בדיקות רציפות יש N - 1 מעברים בין בדיקות, פלטפורמת Developer Device Platform מחסירה את משכי הזמן הכוללים של הבדיקות מטווח השארד ומחלקת ב-N - 1:

    overhead_sample = max(0, total_span - total_test_duration) / (N - 1)
    

כל מקטע של בדיקה מרובה שעובר בהצלחה במשימה מוסיף אחד (TimingSample) ל-ANDROID_TEST_ORCHESTRATOR. לדוגמה, אם סשן פועל בשלושה חלקים וכל חלק עובר עם לפחות שני מקרי בדיקה, הסשן הזה מוסיף שלוש דגימות תקורה עם ה-recordTime של הסשן. במקטעים שמריצים רק מקרה בדיקה אחד (N = 1) אין מעברים בין בדיקות, והם לא פולטים דגימת תקורה.

למה התקורה לא מקושרת למקרה בדיקה או למאגר נתונים (shard)

ב-Developer Device Platform, דגימות של ANDROID_TEST_ORCHESTRATOR נשמרות ברמת shardingContext (deviceModel ו-osVersion) ולא לכל בדיקה או לכל פיצול, משתי סיבות:

  • התקורה תלויה במכשיר ובמערכת ההפעלה, ולא בלוגיקה של הבדיקה. הפעלת התהליך, אתחול ה-binder וניקוי נתוני החבילה נמשכים בערך אותו זמן, בלי קשר לשיטת JUnit שמופעלת לאחר מכן, ואילו קבוצות השארדים משתנות באופן דינמי בכל פעם שזמני הבדיקה או מספר השארדים משתנים.
  • הפרדת התקורה שומרת על זמני בדיקה נקיים של תרחיש הבסיס. העובדה שהתקורה של בידוד התהליכים לא נכללת ב-testCaseTimingRecords מאפשרת להפעיל או להשבית את --orchestrator-version בהרצות שחולקות את אותה רשומת YAML, בלי לעוות את משכי הזמן הבסיסיים של ביצוע הבדיקות.

איך פלטפורמת Developer Device Platform משתמשת בתקורה במהלך הקצאת המקטעים

כשמגדירים את --orchestrator-version בסשן חדש, Developer Device Platform מחשבת את הממוצע של דגימות ANDROID_TEST_ORCHESTRATOR תקינות (avg_overhead) ב-30 ימים ומוסיפה אותו למשך הממוצע של כל מקרה בדיקה ב-30 ימים לפני חישוב מספר המקטעים או אריזת המקטעים:

expected_test_duration = avg_test_duration + avg_overhead

אם לא הוגדר --orchestrator-version בסשן, הערך של avg_overhead הוא 0s וכל רשומות ANDROID_TEST_ORCHESTRATOR הקיימות בקובץ ה-YAML לא נכללות בהרצה הזו.

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

  • מספר מדויק של פיצולים לחבילות עם הרבה בדיקות מהירות. נניח שיש לכם חבילה של 60 בדיקות אינסטרומנטציה בסגנון יחידה, שכל אחת מהן פועלת ב-1s, עם תקורה ממוצעת של מעבר בין תזמורים של 3s ומשך זמן יעד של פיצול של 2m (120s). בלי התקורה, משך הזמן הכולל הצפוי נראה כמו 60s, כך שכל 60 הבדיקות נארזות ב-shard אחד (1) שלמעשה לוקח כמעט ארבע דקות לסיום (60s של ביצוע הבדיקה פלוס 59 * 3s = 177s של מעברי orchestrator). אם מוסיפים את התקורה של 3s לכל בדיקה (משך זמן צפוי של 4s לכל בדיקה, או 240s בסך הכול), פלטפורמת Developer Device Platform מקצה 2 פיצולים (ceil(240s / 120s)) כך שכל פיצול מסתיים קרוב ליעד של שתי דקות.
  • אריזה מאוזנת של מקטעים כשמספרי הבדיקות שונים. במהלך סידור בקונטיינרים (bin packing) לפי זמן העיבוד הארוך ביותר, על שאשא שמוקצה לה בדיקת ממשק משתמש אחת של 40s חלה עלות צפויה של 43s (40s + 3s), ואילו על שאשא שמוקצות לה 10 בדיקות של 4s חלה עלות צפויה של 70s (10 * (4s + 3s)). הכללת התקורה לכל בדיקה מונעת משאשות עם הרבה בדיקות קצרות לצבור דקות של זמן אחזור לא נספר של הפעלה מחדש של התהליך.
  • הערכות ריאליות לבדיקות שנוספו לאחרונה. בדיקות שלא תועדו בחבילה קיימת יורשות את משך הזמן הממוצע הצפוי של בדיקות ידועות, שכבר כולל את avg_overhead, ולכן בדיקות חדשות מביאות בחשבון באופן אוטומטי את התקורה של התזמור בהרצה הראשונה שלהן.

הסבר על חלון הנתונים של 30 הימים ועל ההתנהגות של ההרצה הראשונית

כדי להתחיל לבצע אופטימיזציה של הרצות הבדיקה, לא צריך 30 ימים של נתונים היסטוריים. אפילו דגימה אחת שתתועד תפעיל את חישוב השארדים לפי משך הזמן ואת הסידור בקונטיינרים בסשן הבא. במקום זאת, 30 ימים הם חלון המבט לאחור והשמירה המתמשכת שבהם Developer Device Platform משתמשת כשהיא קוראת ומעדכנת את רשומת התזמון של YAML.

למה בפיצול חכם משתמשים בחלון זמן דינמי של 30 יום

בכל פעם ש-Developer Device Platform קוראת או מעדכנת קובץ YAML של חלוקה חכמה ל-shards, היא מסננת את כל ה-TimingSample שה-recordTime שלהם ישן יותר מ-30 ימים. חלון הזמן הזה של 30 יום מאזן בין שני יעדים של צוות מהנדסי התוכנה:

  • התאמה לשינויים בבסיס הקוד והגבלת גודל הקובץ. התכונות של האפליקציה, תהליכי ממשק המשתמש והטמעות הבדיקה משתנים עם הזמן. הסרה אוטומטית של דגימות שנוצרו לפני יותר מ-30 יום מונעת מתזמונים מיושנים (למשל, תזמונים מלפני עיצוב מחדש של המסך או שכתוב של שכבת הרשת) להטות את ההקצאות הנוכחיות של המקטעים. הסרת רשומות שפג תוקפן (והסרת הקשרי מכשירים שאין להם יותר דגימות תקינות) גם שומרת על קובץ YAML קומפקטי וקטן בהרבה מהמגבלה של 32MB.
  • הפחתת השונות בין הרצות שונות תוך תמיכה בחבילות שבועיות. הרצת בדיקה בודדת יכולה להיות מושפעת מרעש חולף שנובע מאיסוף אשפה, משירותי מערכת שפועלים ברקע או מתזמון של אמולטור. ממוצע הדגימות בחלון של 30 יום מחליק קפיצות חד-פעמיות, תוך שמירה על היסטוריה מספקת כדי שצינורות עיבוד נתונים של שילוב רציף (CI) ליליים, שבועיים או בקצב של ספרינט ישמרו רשומות תזמון חמות בין הרצות.

למה לצפות בשבוע הראשון והשני

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

  1. הפעלה ראשונה (הפעלה במצב התחלתי). קובץ ה-YAML עדיין לא קיים ב-Cloud Storage, ולכן Developer Device Platform מקצה לכל יחידת בדיקה שניתן להריץ את ההערכה שמוגדרת כברירת מחדל – 30 שניות. הוא מחשב את מספר המקטעים בתור ceil(num_tests * 30s / target_duration) (מוגבל על ידי מספר המקטעים המקסימלי ומגבלות הפלטפורמה) ומחלק את הבדיקות בין המקטעים – בדומה לחלוקה אחידה למקטעים. בהפעלה הראשונה:
    • אם הבדיקות נמשכות בממוצע הרבה פחות מ-30 שניות, יכול להיות שבהרצה הראשונה יוקצו יותר פיצולים מהנדרש (עד --smart-sharding-max-shard-count).
    • אם חבילת הבדיקות מכילה כמה בדיקות של ממשק המשתמש שנמשכות כמה דקות, יכול להיות ששתי בדיקות איטיות יגיעו לאותו פיצול במקרה, והפיצול הזה יהפוך לצוואר הבקבוק של זמן ההשלמה בפועל.
    • כשההרצה הראשונה מסתיימת, פלטפורמת Developer Device Platform יוצרת את קובץ ה-YAML ב-Cloud Storage עם משך הזמן שנמדד לבדיקות שעברו.
  2. הפעלה שנייה (מיד אחרי שההפעלה הראשונה מסתיימת). התכונה "חלוקה חכמה לפלחים" כבר פעילה. פלטפורמת Developer Device Platform קוראת את משכי הזמן שתועדו בהרצה הראשונה, מחשבת מחדש את מספר המקטעים לפי זמן הביצוע בפועל של חבילת הבדיקות, ומבודדת קודם את הבדיקות האיטיות ביותר למקטעים נפרדים. בדרך כלל, ההפחתה העיקרית במשך הסשן לפי שעון הקיר ובמספר השארדים מתחילה בהרצה השנייה – אפילו באותו יום שבו מפעילים את חלוקת השארדים החכמה.
  3. שאר השבוע הראשון והשבוע השני. במהלך כמה הרצות נוספות, איזון השארדים ממשיך להשתפר בשלושה מקרים ספציפיים:
    • החלקה של שונות בהרצה בודדת. בכל הרצה נוספת, מתווסף עוד TimingSample, והתנודות הזמניות מההרצה הראשונה מתאזנות. כך מצטמצם מספר השארדים שמתעכבים ומסיימים קצת אחרי --smart-sharding-target-duration.
    • השלמת בדיקות מהרצות שנכשלו בהתחלה. כדי למנוע מצב שבו קריסות מהירות או זמן קצוב לתפוגה של בדיקות ישבשו את הממוצעים ההיסטוריים, פלטפורמת Developer Device Platform מתעדת את התזמונים רק של בדיקות שעברו (וב-Android, רק של פיצולים שהסטטוס הכולל של חבילת הבדיקות שלהם הוא PASSED). כל בדיקה שלא תועד בה תזמון בהרצה הראשונה משתמשת במשך הזמן הממוצע של חבילת הבדיקות בהרצה השנייה, ואז עוברת לתזמון שנמדד לה ברגע שהיא עוברת.
    • הוספת בדיקות חדשות או דגמי מכשירים חדשים. כל מקרה בדיקה חדש שנוסף במהלך השבועות הראשון והשני משתמש באופן אוטומטי במשך הזמן הממוצע הצפוי של חבילת הבדיקות, במקום לחזור לברירת המחדל של 30 שניות. אם מוסיפים לסשן מודל --device שני עם אותו שם רשומה, בהפעלה הראשונה שלו נעשה שימוש בתזמונים של המכשיר הקיים כברירת מחדל ראשונית, ואז מתועדת רשומת shardingContext ייעודית להפעלות הבאות.

שאלות נפוצות

השאלות הבאות עוסקות בתרחישים תפעוליים נפוצים כשמריצים חלוקה חכמה לפלחים בצינורות עיבוד נתונים של CI/CD.

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