Smart sharding di Device Run Developer Device Platform

Sharding cerdas di Device Run Developer Device Platform mendistribusikan uji instrumentasi Android dan XCTest iOS di seluruh shard paralel menggunakan pengaturan waktu eksekusi uji historis yang disimpan di Cloud Storage. Tidak seperti sharding seragam, yang membagi kasus pengujian berdasarkan jumlah, terlepas dari durasi setiap uji coba, sharding cerdas menyeimbangkan shard berdasarkan durasi yang diharapkan sehingga shard paralel selesai pada waktu target yang hampir sama.

Dokumen ini menjelaskan cara algoritma sharding cerdas menghitung jumlah shard dan menetapkan pengujian, menjelaskan skema data waktu YAML yang disimpan di bucket Cloud Storage, dan menjawab pertanyaan umum tentang overhead Android Test Orchestrator dan periode data berkelanjutan 30 hari. Untuk petunjuk command line menggunakan Google Cloud CLI, lihat petunjuk instrumentasi Android dan XCTest iOS.

Cara kerja algoritma sharding cerdas

Sharding tidak sama dengan jumlah pengujian yang dapat dijalankan secara serentak. Ada kemungkinan bahwa perangkat yang tersedia kurang dari batas shard pada saat permintaan. Jumlah perangkat serentak yang sebenarnya yang dapat dialokasikan kepada pengguna mungkin lebih rendah daripada jumlah shard yang mereka tentukan.

Saat Anda mengirimkan sesi dengan --sharding-option=smart di gcloud CLI atau mengonfigurasi smartSharding di REST API, Developer Device Platform menjalankan alur kerja enam tahap di seluruh pembuatan sesi, eksekusi pengujian, dan penyelesaian:

  1. Membaca data pengaturan waktu historis dan mencocokkan konteks perangkat. Sebelum menjadwalkan shard, agen layanan Device Run membaca file YAML smart sharding Anda dari Cloud Storage. Fungsi ini menelusuri daftar records untuk menemukan shardingContext yang cocok dengan deviceModel dan osVersion tugas target (tidak peka huruf besar/kecil). Jika tidak ada kecocokan persis untuk kombinasi perangkat dan OS tersebut, Developer Device Platform akan kembali ke entri records pertama yang tersedia dalam file. Jika file YAML belum ada, sesi akan dilanjutkan sebagai cold start dengan histori pengaturan waktu kosong.
  2. Filter sampel ke rolling window 30 hari dan hitung durasi yang diharapkan. Untuk data konteks yang dipilih, Developer Device Platform hanya mempertahankan sampel pengaturan waktu yang recordTime-nya berada dalam 30 hari terakhir dan menghitung durasi rata-rata aritmetika untuk setiap kasus pengujian. Jika Android Test Orchestrator diaktifkan dengan --orchestrator-version, Developer Device Platform juga akan menghitung rata-rata 30 hari dari sampel overhead ANDROID_TEST_ORCHESTRATOR dan menambahkan rata-rata overhead tersebut ke durasi yang diharapkan untuk setiap kasus pengujian.
  3. Temukan pengujian yang dapat dijalankan dan tetapkan estimasi penggantian. Di host worker, Developer Device Platform memeriksa paket pengujian Anda secara statis—membaca file DEX di APK pengujian di Android, atau simbol .xctest dan filter .xctestrun yang dikompilasi di iOS—menerapkan filter --test-targets, dan mengecualikan pengujian yang diabaikan atau disembunyikan (seperti @Ignore atau @Suppress). Setiap unit pengujian yang dapat dijalankan menerima durasi yang diharapkan berdasarkan tiga tingkat:
    • Kasus pengujian yang dicatat: menggunakan durasi rata-rata historis 30 hari (ditambah overhead orchestrator rata-rata saat Android Test Orchestrator diaktifkan). Di Android, class JUnit berparameter (seperti class yang menggunakan @RunWith(Parameterized.class), JUnitParamsRunner, atau TestParameterInjector) dijadwalkan sebagai satu unit tingkat class yang durasi perkiraannya adalah jumlah semua durasi metode yang dicatat untuk class tersebut.
    • Kasus pengujian yang tidak direkam dalam suite yang ada: menggunakan durasi rata-rata yang diharapkan dari semua kasus pengujian yang direkam dan bukan nol dalam kumpulan data yang cocok.
    • Cold start (tidak ada histori yang dicatat): menggunakan estimasi default 30 detik per unit pengujian.
  4. Menghitung jumlah shard. Developer Device Platform menjumlahkan durasi yang diharapkan dari semua unit pengujian yang dapat dijalankan dan membaginya dengan --smart-sharding-target-duration yang Anda konfigurasi (berlaku dari 2m hingga 1h), lalu membulatkannya ke shard utuh terdekat:

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

    Selanjutnya, Developer Device Platform menetapkan jumlah shard akhir antara 1 dan batas terendah berikut:

    • Jumlah total unit pengujian yang dapat dijalankan (mencegah shard kosong).
    • Nilai --smart-sharding-max-shard-count Anda, jika ditetapkan lebih besar dari 0.
    • Batas platform (20 shard untuk perangkat fisik atau 200 shard untuk perangkat virtual Android).
  5. Menetapkan pengujian menggunakan pengemasan bin waktu pemrosesan terlama terlebih dahulu. Developer Device Platform mengurutkan semua unit pengujian yang dapat dijalankan dalam urutan menurun berdasarkan durasi yang diharapkan (paling lambat hingga tercepat) dan menginisialisasi min-heap shard kosong yang diurutkan berdasarkan durasi akumulasi. Dengan mengambil satu unit pengujian pada satu waktu, sharding cerdas menetapkan pengujian tersisa yang paling lambat ke shard mana pun yang memiliki akumulasi durasi terkecil dan memperbarui total shard tersebut. Menjadwalkan pengujian "long-pole" yang lambat terlebih dahulu akan mengisolasinya ke shard terpisah, sementara pengujian yang lebih singkat akan mengisi celah yang tersisa untuk menjaga total durasi shard tetap seimbang.

  6. Mencatat waktu kelulusan dan memperbarui Cloud Storage. Setelah semua shard selesai, Developer Device Platform mengumpulkan durasi startTime hingga endTime yang diukur dari kasus pengujian yang lulus, memangkas sampel yang lebih lama dari 30 hari di semua konteks perangkat dalam file YAML, menghapus data konteks yang tidak memiliki sampel valid yang tersisa, dan menulis file YAML yang diperbarui kembali ke Cloud Storage menggunakan percobaan ulang konkurensi optimis yang cocok dengan generasi.

Struktur file YAML sharding cerdas

Saat Anda menjalankan sesi dengan gcloud CLI, --smart-sharding-record-name menentukan nama file dasar (tidak termasuk ekstensi YAML) dari data pengaturan waktu yang disimpan di bucket Cloud Storage project Google Cloud Anda:

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

Ganti placeholder berikut:

  • BUCKET_NAME: nama bucket Cloud Storage yang ditentukan dengan --bucket-name, atau <var>PROJECT_ID</var>-devicerun secara default (dengan PROJECT_ID adalah project ID Google CloudAnda).
  • RECORD_NAME: ID data yang diteruskan ke --smart-sharding-record-name tanpa ekstensi file YAML (misalnya, checkout-suite dipetakan ke automation/smart-sharding/checkout-suite.yaml).

Contoh data pengaturan waktu YAML

Contoh berikut menunjukkan file YAML sharding cerdas (checkout-suite.yaml) yang berisi data pengaturan waktu untuk dua konteks perangkat—perangkat Android yang berjalan dengan Android Test Orchestrator dan perangkat 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'

Referensi kolom YAML

File YAML smart sharding melakukan serialisasi skema SuiteTiming menggunakan nama kolom camelCase. Tabel berikut menjelaskan setiap kolom dalam file:

Kolom Jenis Deskripsi
metadata Peta (string hingga string) Metadata nilai kunci tingkat suite opsional yang dipertahankan di seluruh update agregasi.
records Daftar objek Entri pengaturan waktu per perangkat (SuiteTimingWithContext), yang dipartisi berdasarkan model hardware dan versi OS.
records[].shardingContext Objek Dimensi hardware dan OS yang mencakup serangkaian pengukuran pengaturan waktu.
records[].shardingContext.deviceModel string ID model perangkat tempat pengaturan waktu dicatat (misalnya, shiba di Android atau iphonese3 di iOS).
records[].shardingContext.osVersion string Versi OS atau SDK perangkat (misalnya, Android level API '34' atau iOS versi '18.4').
records[].testCaseTimingRecords Daftar objek Durasi eksekusi historis untuk setiap kasus pengujian yang lulus dalam konteks ini.
records[].testCaseTimingRecords[].testCaseName string ID pengujian yang sepenuhnya memenuhi syarat dalam format package.ClassName#methodName (atau package.ClassName jika metadata metode tidak ada).
records[].testCaseTimingRecords[].timingSamples Daftar objek Daftar durasi terukur selama 30 hari berjalan untuk kasus pengujian, yang ditambahkan setelah pengujian berhasil.
timingSamples[].duration String durasi Durasi terukur yang diformat dalam detik dengan presisi pecahan opsional (misalnya, 10s atau 42.180s).
timingSamples[].recordTime String stempel waktu Stempel waktu UTC RFC 3339 yang menunjukkan kapan Developer Device Platform mencatat sampel (misalnya, '2026-11-09T16:45:03Z').
records[].conditionalOverheads Daftar objek Overhead eksekusi opsional yang diukur dalam mode runner tertentu, yang dicakup ke shardingContext. Dihilangkan jika tidak ada overhead bersyarat yang berlaku.
records[].conditionalOverheads[].condition string ID untuk kondisi eksekusi. Nilai yang didukung: ANDROID_TEST_ORCHESTRATOR.
records[].conditionalOverheads[].timingSamples Daftar objek Daftar sampel overhead per transisi selama 30 hari yang dicatat dari shard yang memenuhi syarat.

Memahami waktu overhead ANDROID_TEST_ORCHESTRATOR

Saat Anda menjalankan uji instrumentasi Android dengan --orchestrator-version, file YAML smart sharding Anda menyertakan entri conditionalOverheads dengan condition: ANDROID_TEST_ORCHESTRATOR. Tidak seperti testCaseTimingRecords, sampel overhead ini tidak dilampirkan ke metode pengujian individual atau shard bernomor.

Yang diwakili oleh satu sampel durasi overhead

Jika Android Test Orchestrator diaktifkan, setiap metode pengujian akan dijalankan dalam proses Instrumentation terisolasi miliknya sendiri. Stempel waktu startTime dan endTime pengujian individual hanya mencatat waktu yang dihabiskan di dalam setiap metode pengujian—stempel waktu tersebut tidak menyertakan jeda antar-pengujian yang dihabiskan untuk menghentikan proses aplikasi sebelumnya, secara opsional menghapus data paket (clearPackageData), dan memulai proses Instrumentation baru untuk pengujian berikutnya.

Untuk mengukur biaya transisi antar-pengujian tersebut, Developer Device Platform memeriksa setiap shard lulus yang menjalankan dua atau beberapa kasus pengujian (N > 1) dan menghitung:

  1. Total rentang eksekusi shard: waktu aktual yang berlalu dari pengujian paling awal startTime di shard hingga pengujian terbaru endTime di shard.
  2. Total durasi kasus pengujian: jumlah (endTime - startTime) di semua kasus pengujian N dalam shard tersebut.
  3. Overhead rata-rata per transisi: karena N pengujian berurutan memiliki N - 1 transisi di antara pengujian, Developer Device Platform mengurangi durasi pengujian yang dijumlahkan dari rentang shard dan membaginya dengan N - 1:

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

Setiap shard multi-pengujian yang lulus dalam tugas Anda menyumbangkan satu TimingSample ke ANDROID_TEST_ORCHESTRATOR. Misalnya, jika sesi berjalan di tiga shard dan setiap shard lulus dengan setidaknya dua kasus pengujian, sesi tersebut akan menambahkan tiga sampel overhead dengan recordTime sesi. Shard yang hanya menjalankan satu kasus pengujian (N = 1) tidak memiliki transisi antar-pengujian dan tidak memunculkan sampel overhead.

Alasan overhead tidak ditautkan ke kasus pengujian atau shard

Developer Device Platform menyimpan sampel ANDROID_TEST_ORCHESTRATOR di level shardingContext (deviceModel dan osVersion), bukan per pengujian atau per shard karena dua alasan:

  • Overhead bergantung pada perangkat dan OS, bukan logika pengujian. Startup proses, inisialisasi binder, dan penghapusan data paket memerlukan waktu yang kurang lebih sama, terlepas dari metode JUnit mana yang dijalankan berikutnya, sedangkan pengelompokan shard berubah secara dinamis setiap kali pengaturan waktu pengujian atau jumlah shard berubah.
  • Memisahkan overhead akan mempertahankan waktu pengujian dasar pengukuran yang bersih. Dengan tidak menyertakan overhead isolasi proses dari testCaseTimingRecords, Anda dapat mengaktifkan atau menonaktifkan --orchestrator-version di seluruh operasi yang menggunakan data YAML yang sama tanpa mendistorsi durasi eksekusi per pengujian yang mendasarinya.

Cara Developer Device Platform menggunakan overhead selama penetapan shard

Saat --orchestrator-version ditetapkan pada sesi baru, Developer Device Platform menghitung rata-rata 30 hari sampel ANDROID_TEST_ORCHESTRATOR yang valid (avg_overhead) dan menambahkannya ke durasi rata-rata 30 hari setiap kasus pengujian sebelum menghitung jumlah shard atau mengemas shard:

expected_test_duration = avg_test_duration + avg_overhead

Jika --orchestrator-version tidak ditetapkan pada sesi, avg_overhead adalah 0s dan entri ANDROID_TEST_ORCHESTRATOR yang ada dalam file YAML akan diabaikan untuk operasi tersebut.

Menambahkan avg_overhead ke setiap kasus pengujian akan memengaruhi sharding dalam tiga cara:

  • Jumlah shard yang akurat untuk suite dengan banyak pengujian cepat. Pertimbangkan rangkaian 60 uji instrumentasi bergaya unit yang masing-masing berjalan dalam 1s, dengan overhead transisi orchestrator rata-rata 3s dan durasi shard target 2m (120s). Tanpa overhead, total durasi yang diharapkan terlihat seperti 60s, sehingga ke-60 pengujian dikemas ke dalam 1 shard yang sebenarnya memerlukan waktu hampir empat menit untuk diselesaikan (60s eksekusi uji ditambah 59 * 3s = 177s transisi orchestrator). Dengan menambahkan overhead 3s ke setiap pengujian (durasi yang diharapkan 4s per pengujian, atau total 240s), Developer Device Platform mengalokasikan 2 shard (ceil(240s / 120s)) sehingga setiap shard selesai mendekati target dua menit.
  • Pengemasan shard yang seimbang saat jumlah pengujian berbeda. Selama pengemasan bin waktu pemrosesan terlama, shard yang ditetapkan satu pengujian UI 40s akan dikenai biaya yang diharapkan sebesar 43s (40s + 3s), sedangkan shard yang ditetapkan 10 pengujian 4s akan dikenai biaya yang diharapkan sebesar 70s (10 * (4s + 3s)). Menyertakan overhead per pengujian akan mencegah shard dengan banyak pengujian singkat mengakumulasi latensi mulai ulang proses yang tidak dihitung secara diam-diam.
  • Estimasi realistis untuk pengujian yang baru ditambahkan. Karena pengujian yang tidak direkam dalam suite yang ada mewarisi durasi rata-rata yang diharapkan dari pengujian yang diketahui—yang sudah menyertakan avg_overhead—pengujian baru secara otomatis memperhitungkan overhead orchestrator pada pengujian pertama.

Memahami periode data 30 hari dan perilaku operasi awal

Sharding cerdas tidak memerlukan data historis selama 30 hari sebelum mulai mengoptimalkan uji coba Anda. Bahkan satu sampel yang direkam akan mengaktifkan penghitungan shard berbasis durasi dan pengemasan bin pada sesi berikutnya. Sebagai gantinya, 30 hari adalah retensi berkelanjutan dan periode lihat balik yang digunakan Developer Device Platform saat membaca dan memperbarui data pengaturan waktu YAML.

Alasan smart sharding menggunakan rolling window 30 hari

Setiap kali Developer Device Platform membaca atau memperbarui file YAML smart sharding, file tersebut akan memfilter TimingSample yang recordTime-nya berusia lebih dari 30 hari. Periode 30 hari ini menyeimbangkan dua sasaran engineering:

  • Menyesuaikan dengan perubahan codebase dan membatasi ukuran file. Fitur aplikasi, alur UI, dan implementasi pengujian berkembang seiring waktu. Menghapus otomatis sampel yang berusia lebih dari 30 hari akan mencegah pengaturan waktu yang sudah tidak berlaku—misalnya, pengaturan waktu dari sebelum desain ulang layar atau refaktorisasi lapisan jaringan—agar tidak memengaruhi penetapan shard saat ini. Menghapus entri yang sudah tidak berlaku (dan menghapus konteks perangkat yang tidak lagi memiliki sampel yang valid) juga membuat file YAML tetap ringkas dan jauh di bawah batas 32 MB.
  • Memperhalus varians dari satu pengujian ke pengujian berikutnya sekaligus mendukung rangkaian pengujian mingguan. Satu uji coba dapat mengalami derau sementara dari pembersihan sampah memori, layanan sistem latar belakang, atau penjadwalan emulator. Menghitung rata-rata sampel dalam periode 30 hari akan memperhalus lonjakan yang terjadi sekali saja, sekaligus mempertahankan histori yang cukup sehingga pipeline continuous integration malam, mingguan, atau sprint-cadence mempertahankan catatan waktu yang hangat di antara operasi.

Yang akan terjadi pada minggu pertama dan kedua

Jika Anda mengaktifkan sharding cerdas pada suite pengujian yang ada saat ini, waktu eksekusi akan mengikuti kurva pemanasan yang cepat, bukan menunggu berminggu-minggu untuk meningkat:

  1. Operasi pertama (cold start). Karena file YAML belum ada di Cloud Storage, Developer Device Platform menetapkan perkiraan default 30 detik untuk setiap unit pengujian yang dapat dijalankan. Sharding cerdas menghitung jumlah shard sebagai ceil(num_tests * 30s / target_duration) (dibatasi oleh jumlah shard maksimum dan batas platform) dan mendistribusikan pengujian ke seluruh shard—mirip dengan sharding seragam. Pada operasi pertama ini:
    • Jika pengujian Anda rata-rata jauh lebih singkat dari 30 detik, Run 1 mungkin mengalokasikan lebih banyak shard daripada yang diperlukan (hingga --smart-sharding-max-shard-count).
    • Jika suite Anda berisi beberapa pengujian UI berdurasi beberapa menit, dua pengujian lambat mungkin secara kebetulan berada di shard yang sama, sehingga shard tersebut menjadi bottleneck untuk waktu penyelesaian wall-clock.
    • Setelah Run 1 selesai, Developer Device Platform akan membuat file YAML di Cloud Storage dengan durasi pengujian yang lulus yang diukur.
  2. Operasi kedua (segera setelah Operasi 1 selesai). Smart sharding sudah aktif. Developer Device Platform membaca durasi yang dicatat oleh Run 1, menghitung ulang jumlah shard dari waktu eksekusi sebenarnya suite Anda, dan mengisolasi pengujian paling lambat ke shard terpisah terlebih dahulu. Anda biasanya akan melihat pengurangan utama dalam durasi sesi wall-clock dan penyesuaian ukuran jumlah shard mulai dari Run 2—bahkan pada hari yang sama saat Anda mengaktifkan sharding smart.
  3. Sisa minggu pertama dan minggu kedua. Selama beberapa operasi berikutnya, keseimbangan shard terus diperketat dalam tiga kasus tertentu:
    • Menghaluskan varians satu operasi. Karena setiap operasi yang berjalan menambahkan TimingSample lain, fluktuasi sementara dari Run 1 akan dirata-ratakan, sehingga mengurangi shard yang tertinggal yang selesai sedikit melewati --smart-sharding-target-duration.
    • Mengisi pengujian dari pengujian yang awalnya gagal. Untuk mencegah error cepat atau waktu tunggu pengujian yang merusak rata-rata historis, Developer Device Platform hanya mencatat waktu untuk pengujian yang lulus (dan, di Android, hanya dari shard yang status suite keseluruhannya adalah PASSED). Setiap pengujian yang tidak mencatat waktu pada Run 1 akan menggunakan durasi rata-rata suite pada Run 2, lalu beralih ke waktunya sendiri yang diukur setelah lulus.
    • Menambahkan pengujian atau model perangkat baru. Setiap kasus pengujian baru yang di-commit selama minggu pertama dan kedua akan otomatis menggunakan durasi yang diharapkan rata-rata suite, bukan kembali ke default 30 detik. Jika Anda menambahkan model --device kedua ke sesi menggunakan nama data yang sama, operasi pertamanya akan menggunakan pengaturan waktu perangkat yang ada sebagai penggantian awal, lalu mencatat entri shardingContext khusus untuk operasi berikutnya.

Pertanyaan umum (FAQ)

Pertanyaan berikut membahas skenario operasional umum saat menjalankan sharding cerdas di pipeline CI/CD.

Langkah berikutnya