Le partitionnement intelligent dans Device Run de Developer Device Platform distribue les tests d'instrumentation Android et les tests XCTest iOS sur des segments parallèles à l'aide des temps d'exécution des tests historiques stockés dans Cloud Storage. Contrairement à la segmentation uniforme, qui divise les scénarios de test par nombre, quelle que soit la durée d'exécution de chaque test, la segmentation intelligente équilibre les segments en fonction de la durée attendue, de sorte que les segments parallèles se terminent à peu près au même moment.
Ce document explique comment l'algorithme de segmentation intelligente calcule le nombre de segments et attribue les tests, décrit le schéma de l'enregistrement de temps YAML stocké dans votre bucket Cloud Storage, et répond aux questions courantes sur la surcharge d'Android Test Orchestrator et la fenêtre de données glissante de 30 jours. Pour obtenir des instructions de ligne de commande à l'aide de Google Cloud CLI, consultez les instructions pour l'instrumentation Android et iOS XCTest.
Fonctionnement de l'algorithme de segmentation intelligente
Le partitionnement n'est pas équivalent au nombre de tests pouvant être exécutés simultanément. Il est possible que le nombre d'appareils disponibles soit inférieur à la limite de segments au moment de la requête. Le nombre réel d'appareils simultanés pouvant être alloués à un utilisateur peut être inférieur au nombre de segments qu'il a spécifié.
Lorsque vous envoyez une session avec --sharding-option=smart dans la gcloud CLI ou que vous configurez smartSharding dans l'API REST, Developer Device Platform exécute un workflow en six étapes pour la création de la session, l'exécution du test et la finalisation :
- Lire les données temporelles historiques et les faire correspondre au contexte de l'appareil Avant de planifier les segments, l'agent de service Device Run lit votre fichier YAML de segmentation intelligente depuis Cloud Storage. Il recherche dans la liste
recordsunshardingContextqui correspond auxdeviceModeletosVersiondu job cible (non sensible à la casse). Si aucune correspondance exacte n'existe pour cette combinaison d'appareil et d'OS, Developer Device Platform utilise la première entréerecordsdisponible dans le fichier. Si le fichier YAML n'existe pas encore, la session se poursuit par un démarrage à froid avec un historique de codes temporels vide. - Filtrez les échantillons sur la fenêtre glissante de 30 jours et calculez les durées attendues. Pour l'enregistrement de contexte sélectionné, Developer Device Platform ne conserve que les échantillons de temps dont le
recordTimese situe dans les 30 derniers jours et calcule la durée moyenne arithmétique pour chaque scénario de test. Si Android Test Orchestrator est activé avec--orchestrator-version, Developer Device Platform calcule également la moyenne sur 30 jours des échantillons de surchargeANDROID_TEST_ORCHESTRATORet ajoute cette surcharge moyenne à la durée attendue de chaque scénario de test. - Découvrez les tests exécutables et attribuez des estimations de remplacement. Sur l'hôte de l'outil de calcul, Developer Device Platform inspecte de manière statique votre package de test (en lisant les fichiers DEX dans l'APK de test sur Android, ou les symboles
.xctestet les filtres.xctestruncompilés sur iOS), applique les filtres--test-targetset exclut les tests ignorés ou supprimés (comme@Ignoreou@Suppress). Chaque unité de test exécutable reçoit une durée attendue en fonction de trois niveaux :- Scénario de test enregistré : utilise sa durée moyenne historique sur 30 jours (plus la surcharge moyenne de l'orchestrateur lorsque Android Test Orchestrator est activé).
Sur Android, les classes JUnit paramétrées (telles que les classes utilisant
@RunWith(Parameterized.class),JUnitParamsRunnerouTestParameterInjector) sont planifiées en tant qu'unité unique au niveau de la classe, dont la durée attendue est la somme de toutes les durées de méthode enregistrées pour cette classe. - Scénario de test non enregistré dans une suite existante : utilise la durée moyenne attendue de tous les scénarios de test non nuls enregistrés dans l'enregistrement correspondant.
- Démarrage à froid (aucun historique enregistré) : utilise une estimation par défaut de 30 secondes par unité de test.
- Scénario de test enregistré : utilise sa durée moyenne historique sur 30 jours (plus la surcharge moyenne de l'orchestrateur lorsque Android Test Orchestrator est activé).
Sur Android, les classes JUnit paramétrées (telles que les classes utilisant
Calculez le nombre de segments. Developer Device Platform additionne les durées attendues de toutes les unités de test exécutables et les divise par la valeur
--smart-sharding-target-durationconfigurée (valide de2mà1h), en arrondissant au fragment entier le plus proche :optimal_shards = max(1, ceil(total_expected_duration / target_duration))Ensuite, Developer Device Platform définit le nombre final de segments entre
1et la plus basse des limites suivantes :- Nombre total d'unités de test exécutables (empêchant les segments vides).
- Votre valeur
--smart-sharding-max-shard-count, si elle est supérieure à0. - La limite de la plate-forme (
20segments pour les appareils physiques ou200segments pour les appareils virtuels Android).
Attribuez des tests à l'aide de l'algorithme de bin packing "longest-processing-time-first". Developer Device Platform trie toutes les unités de test exécutables par ordre décroissant de durée attendue (du plus lent au plus rapide) et initialise un min-heap de segments vides classés par durée cumulée. En prenant une unité de test à la fois, il attribue le test restant le plus lent au segment dont la durée cumulée est la plus faible et met à jour le total de ce segment. La planification des tests lents "long-pole" les isole d'abord sur des segments distincts, tandis que les tests plus courts comblent les écarts restants pour équilibrer la durée totale des segments.
Enregistrez les temps de passage et mettez à jour Cloud Storage. Une fois tous les segments terminés, Developer Device Platform collecte les durées mesurées de
startTimeàendTimedes scénarios de test réussis, supprime tous les échantillons datant de plus de 30 jours dans tous les contextes d'appareil du fichier YAML, supprime tous les enregistrements de contexte qui n'ont plus d'échantillons valides et réécrit le fichier YAML mis à jour dans Cloud Storage à l'aide de nouvelles tentatives de simultanéité optimiste correspondant à la génération.
Structure du fichier YAML de segmentation intelligente
Lorsque vous exécutez une session avec la gcloud CLI, --smart-sharding-record-name spécifie le nom de fichier de base (sans l'extension YAML) de l'enregistrement de chronométrage stocké dans le bucket Cloud Storage de votre projet Google Cloud :
gs://BUCKET_NAME/automation/smart-sharding/RECORD_NAME.yaml
Remplacez les espaces réservés suivants :
BUCKET_NAME: nom du bucket Cloud Storage spécifié avec--bucket-name, ou<var>PROJECT_ID</var>-devicerunpar défaut (oùPROJECT_IDest l'ID de votre projet Google Cloud).RECORD_NAME: identifiant d'enregistrement transmis à--smart-sharding-record-namesans l'extension de fichier YAML (par exemple,checkout-suitecorrespond àautomation/smart-sharding/checkout-suite.yaml).
Exemple d'enregistrement de chronométrage YAML
L'exemple suivant montre un fichier YAML de segmentation intelligente (checkout-suite.yaml) contenant des enregistrements de temps pour deux contextes d'appareil : un appareil Android exécutant Android Test Orchestrator et un appareil 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'
Documentation de référence sur les champs YAML
Le fichier YAML de segmentation intelligente sérialise le schéma SuiteTiming à l'aide de noms de champs camelCase. Le tableau suivant décrit chaque champ du fichier :
| Champ | Type | Description |
|---|---|---|
metadata |
Carte (string à string) |
Métadonnées clé-valeur facultatives au niveau de la suite, conservées lors des mises à jour d'agrégation. |
records |
Liste d'objets | Entrées de chronométrage par appareil (SuiteTimingWithContext), partitionnées par modèle de matériel et version d'OS. |
records[].shardingContext |
Objet | Dimensions du matériel et de l'OS qui définissent un ensemble de mesures temporelles. |
records[].shardingContext.deviceModel |
string |
Identifiant du modèle de l'appareil sur lequel les temps ont été enregistrés (par exemple, shiba sur Android ou iphonese3 sur iOS). |
records[].shardingContext.osVersion |
string |
Version de l'OS ou du SDK de l'appareil (par exemple, niveau d'API Android '34' ou version iOS '18.4'). |
records[].testCaseTimingRecords |
Liste d'objets | Durées d'exécution historiques des scénarios de test individuels réussis dans ce contexte. |
records[].testCaseTimingRecords[].testCaseName |
string |
Identifiant de test complet au format package.ClassName#methodName (ou package.ClassName si les métadonnées de la méthode sont absentes). |
records[].testCaseTimingRecords[].timingSamples |
Liste d'objets | Liste glissante sur 30 jours des durées mesurées pour le scénario de test, ajoutée après les exécutions réussies. |
timingSamples[].duration |
Chaîne de durée | Durée mesurée formatée en secondes avec une précision fractionnaire facultative (par exemple, 10s ou 42.180s). |
timingSamples[].recordTime |
Chaîne d'horodatage | Code temporel RFC 3339 UTC indiquant quand Developer Device Platform a enregistré l'échantillon (par exemple, '2026-11-09T16:45:03Z'). |
records[].conditionalOverheads |
Liste d'objets | Frais d'exécution facultatifs mesurés dans des modes d'exécuteur spécifiques, limités à shardingContext. Omis lorsqu'aucun frais général conditionnel ne s'applique. |
records[].conditionalOverheads[].condition |
string |
Identifiant de la condition d'exécution. Valeur acceptée : ANDROID_TEST_ORCHESTRATOR. |
records[].conditionalOverheads[].timingSamples |
Liste d'objets | Liste glissante sur 30 jours d'échantillons de frais généraux par transition enregistrés à partir de segments éligibles. |
Comprendre les temps de traitement de ANDROID_TEST_ORCHESTRATOR
Lorsque vous exécutez des tests d'instrumentation Android avec --orchestrator-version, votre fichier YAML de segmentation intelligente inclut une entrée conditionalOverheads avec condition: ANDROID_TEST_ORCHESTRATOR. Contrairement à testCaseTimingRecords, ces échantillons de surcharge ne sont pas associés à une méthode de test individuelle ni à un segment numéroté.
Ce que représente un échantillon de durée de surcharge
Lorsque Android Test Orchestrator est activé, il exécute chaque méthode de test dans son propre processus Instrumentation isolé. Les codes temporels de test individuels startTime et endTime ne capturent que le temps passé dans chaque méthode de test. Ils n'incluent pas l'intervalle entre les tests consacré à l'arrêt du processus d'application précédent, à l'effacement éventuel des données du package (clearPackageData) et au démarrage d'un nouveau processus Instrumentation pour le test suivant.
Pour mesurer ce coût de transition entre les tests, Developer Device Platform inspecte chaque segment réussi qui exécute au moins deux scénarios de test (N > 1) et calcule :
- Durée totale d'exécution du segment : temps écoulé entre le premier test
startTimedu segment et le dernier testendTimedu segment. - Durée totale des scénarios de test : somme de
(endTime - startTime)pour tous les scénarios de testNde ce segment. Surcharge moyenne par transition : étant donné que
Ntests séquentiels comportentN - 1transitions entre les tests, Developer Device Platform soustrait la somme des durées des tests de la durée du segment et divise parN - 1:overhead_sample = max(0, total_span - total_test_duration) / (N - 1)
Chaque segment multitest réussi de votre job contribue à un TimingSample à ANDROID_TEST_ORCHESTRATOR. Par exemple, si une session s'exécute sur trois segments et que chaque segment réussit avec au moins deux scénarios de test, cette session ajoute trois exemples de surcharge avec le recordTime de la session. Les segments qui n'exécutent qu'un seul scénario de test (N = 1) n'ont aucune transition entre les tests et n'émettent pas d'échantillon de surcharge.
Pourquoi les frais généraux ne sont pas associés à un scénario de test ou à un segment
Developer Device Platform stocke les exemples ANDROID_TEST_ORCHESTRATOR au niveau de shardingContext (deviceModel et osVersion) plutôt que par test ou par segment pour deux raisons :
- La surcharge dépend de l'appareil et de l'OS, et non de la logique de test. Le démarrage du processus, l'initialisation du binder et l'effacement des données du package prennent à peu près le même temps, quelle que soit la méthode JUnit exécutée ensuite, tandis que les regroupements de segments changent de manière dynamique chaque fois que les codes temporels des tests ou le nombre de segments changent.
- La séparation des frais généraux permet de conserver des temps de test de référence propres. En excluant la surcharge d'isolation des processus de
testCaseTimingRecords, vous pouvez activer ou désactiver--orchestrator-versionpour les exécutions qui partagent le même enregistrement YAML sans fausser les durées d'exécution de test sous-jacentes par test.
Comment Developer Device Platform utilise la surcharge lors de l'attribution de segments
Lorsque --orchestrator-version est défini sur une nouvelle session, Developer Device Platform calcule la moyenne sur 30 jours des échantillons ANDROID_TEST_ORCHESTRATOR valides (avg_overhead) et l'ajoute à la durée moyenne sur 30 jours de chaque scénario de test avant de calculer le nombre de segments ou de regrouper les segments :
expected_test_duration = avg_test_duration + avg_overhead
Si --orchestrator-version n'est pas défini sur la session, avg_overhead est 0s et toutes les entrées ANDROID_TEST_ORCHESTRATOR existantes dans le fichier YAML sont ignorées pour cette exécution.
L'ajout de avg_overhead à chaque scénario de test affecte la segmentation de trois manières :
- Nombre de segments précis pour les suites comportant de nombreux tests rapides. Prenons l'exemple d'une suite de 60 tests d'instrumentation de type unitaire qui s'exécutent chacun en
1s, avec un temps de transition moyen de l'orchestrateur de3set une durée de segment cible de2m(120s). Sans surcharge, la durée totale attendue est de60s. Les 60 tests sont donc regroupés dans1segment qui prend en réalité près de quatre minutes (60sd'exécution de test plus59 * 3s = 177sde transitions d'orchestrateur). En ajoutant la surcharge de3sà chaque test (durée attendue de4spar test, soit240sau total), Developer Device Platform alloue2segments (ceil(240s / 120s)) afin que chaque segment se termine près de l'objectif de deux minutes. - Empaqueter les segments de manière équilibrée lorsque le nombre de tests diffère. Lors de la répartition des tâches selon l'algorithme "longest-processing-time-first" (bin packing), un segment auquel est attribué un test d'UI
40sentraîne un coût attendu de43s(40s + 3s), tandis qu'un segment auquel sont attribués 10 tests4sentraîne un coût attendu de70s(10 * (4s + 3s)). L'inclusion de la surcharge par test empêche les segments comportant de nombreux tests courts d'accumuler silencieusement des minutes de latence de redémarrage du processus non comptabilisées. - Estimations réalistes pour les tests récemment ajoutés Étant donné que les tests non enregistrés d'une suite existante héritent de la durée moyenne attendue des tests connus (qui inclut déjà
avg_overhead), les nouveaux tests tiennent automatiquement compte de la surcharge de l'orchestrateur dès leur première exécution.
Comprendre la période de données de 30 jours et le comportement d'exécution initial
La segmentation intelligente ne nécessite pas 30 jours de données historiques avant de commencer à optimiser vos exécutions de test. Un seul échantillon enregistré suffit à activer le calcul de segment basé sur la durée et le bin packing lors de la session suivante. En réalité, 30 jours est la période d'analyse et de conservation glissante que Developer Device Platform utilise pour lire et mettre à jour l'enregistrement de temps YAML.
Pourquoi le partitionnement intelligent utilise une fenêtre glissante de 30 jours
Chaque fois que Developer Device Platform lit ou met à jour un fichier YAML de segmentation intelligente, il filtre les TimingSample dont la valeur recordTime date de plus de 30 jours.
Cette période de 30 jours permet d'équilibrer deux objectifs d'ingénierie :
- S'adapter aux modifications du codebase et limiter la taille des fichiers Les fonctionnalités de l'application, les flux d'interface utilisateur et les implémentations de test évoluent au fil du temps. L'éviction automatique des échantillons datant de plus de 30 jours empêche les codes temporels obsolètes (par exemple, ceux antérieurs à une refonte de l'écran ou à une refactorisation de la couche réseau) de fausser les attributions de segments actuelles. L'éviction des entrées expirées (et la suppression des contextes d'appareil qui ne disposent plus d'échantillons valides) permet également de conserver le fichier YAML compact et bien en dessous de la limite de 32 Mo.
- Lissage de la variance d'une exécution à l'autre tout en prenant en charge les suites hebdomadaires. Une seule exécution de test peut subir des bruits temporaires provenant de la récupération de mémoire, des services système en arrière-plan ou de la planification de l'émulateur. La moyenne des échantillons sur une période de 30 jours permet de lisser les pics ponctuels tout en conservant un historique suffisant pour que les pipelines d'intégration continue nocturnes, hebdomadaires ou de sprint conservent des enregistrements de temps de préchauffage entre les exécutions.
À quoi s'attendre au cours des semaines 1 et 2
Si vous activez le partitionnement intelligent sur une suite de tests existante aujourd'hui, les temps d'exécution suivent une courbe de préchauffage rapide au lieu d'attendre des semaines pour s'améliorer :
- Première exécution (démarrage à froid). Comme le fichier YAML n'existe pas encore dans Cloud Storage, Developer Device Platform attribue à chaque unité de test exécutable l'estimation par défaut de 30 secondes. Il calcule le nombre de segments comme
ceil(num_tests * 30s / target_duration)(limité par le nombre maximal de segments et les limites de la plate-forme) et répartit les tests sur les segments, comme pour la segmentation uniforme. Lors de cette première exécution :- Si vos tests durent en moyenne beaucoup moins de 30 secondes, l'exécution 1 peut allouer plus de segments que nécessaire (jusqu'à
--smart-sharding-max-shard-count). - Si votre suite contient plusieurs tests d'UI de plusieurs minutes, deux tests lents peuvent se retrouver dans le même segment par hasard, ce qui fait de ce segment le goulot d'étranglement pour le temps d'exécution réel.
- Une fois l'exécution 1 terminée, Developer Device Platform crée le fichier YAML dans Cloud Storage avec les durées mesurées de vos tests réussis.
- Si vos tests durent en moyenne beaucoup moins de 30 secondes, l'exécution 1 peut allouer plus de segments que nécessaire (jusqu'à
- Deuxième exécution (immédiatement après la fin de l'exécution 1). Le partitionnement intelligent est déjà actif. Developer Device Platform lit les durées enregistrées par l'exécution 1, recalcule le nombre de segments à partir du temps d'exécution réel de votre suite et isole d'abord vos tests les plus lents sur des segments distincts. En général, vous constaterez une réduction de la durée de session en temps réel et un redimensionnement du nombre de segments à partir de l'exécution 2, même le jour où vous activez la segmentation intelligente.
- Reste de la semaine 1 et semaine 2 Au cours des exécutions suivantes, l'équilibrage des segments continue de s'affiner dans trois cas spécifiques :
- Lissage de la variance d'une seule exécution. Comme chaque exécution ajoute un autre
TimingSample, les fluctuations temporaires de l'exécution 1 sont lissées, ce qui réduit le nombre de segments retardataires qui se terminent légèrement après--smart-sharding-target-duration. - Remplissage des tests à partir des exécutions initialement échouées. Pour éviter que des plantages rapides ou des délais avant expiration des tests ne corrompent les moyennes historiques, Developer Device Platform n'enregistre les temps que pour les tests réussis (et, sur Android, uniquement à partir des segments dont l'état global de la suite est
PASSED). Tout test n'ayant pas enregistré de temps lors de l'exécution 1 utilise la durée moyenne de la suite lors de l'exécution 2, puis passe à son propre temps mesuré une fois qu'il a réussi. - Ajout de tests ou de modèles d'appareils Tous les nouveaux scénarios de test validés au cours des semaines 1 et 2 utilisent automatiquement la durée moyenne attendue de la suite au lieu de revenir à la valeur par défaut de 30 secondes. Si vous ajoutez un deuxième modèle
--deviceà la session en utilisant le même nom d'enregistrement, sa première exécution utilise les codes temporels de l'appareil existant comme solution de remplacement initiale, puis enregistre une entréeshardingContextdédiée pour les exécutions suivantes.
- Lissage de la variance d'une seule exécution. Comme chaque exécution ajoute un autre
Questions fréquentes
Les questions suivantes couvrent les scénarios opérationnels courants lors de l'exécution du partitionnement intelligent dans les pipelines CI/CD.
Étapes suivantes
- Découvrez l'exécuteur de test TestParameterInjector.
- Configurez les options de segmentation intelligente dans Exécuter un test d'instrumentation Android.
- Configurez les exécutions de tests iOS dans Exécuter un test XCTest iOS.
- Vérifiez les autorisations de bucket multiprojets pour l'agent de service dans Partager vos buckets Cloud Storage avec Developer Device Platform.
- Inspectez les artefacts
junit.xmlet les journaux par segment dans Rechercher les résultats de vos tests Developer Device Platform.