Segmentation intelligente dans Developer Device Platform Device Run

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 :

  1. 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 records un shardingContext qui correspond aux deviceModel et osVersion du 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ée records disponible 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.
  2. 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 recordTime se 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 surcharge ANDROID_TEST_ORCHESTRATOR et ajoute cette surcharge moyenne à la durée attendue de chaque scénario de test.
  3. 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 .xctest et les filtres .xctestrun compilés sur iOS), applique les filtres --test-targets et exclut les tests ignorés ou supprimés (comme @Ignore ou @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), JUnitParamsRunner ou TestParameterInjector) 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.
  4. 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-duration configurée (valide de 2m à 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 1 et 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 (20 segments pour les appareils physiques ou 200 segments pour les appareils virtuels Android).
  5. 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.

  6. 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 à endTime des 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>-devicerun par défaut (où PROJECT_ID est l'ID de votre projet Google Cloud).
  • RECORD_NAME : identifiant d'enregistrement transmis à --smart-sharding-record-name sans l'extension de fichier YAML (par exemple, checkout-suite correspond à 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 :

  1. Durée totale d'exécution du segment : temps écoulé entre le premier test startTime du segment et le dernier test endTime du segment.
  2. Durée totale des scénarios de test : somme de (endTime - startTime) pour tous les scénarios de test N de ce segment.
  3. Surcharge moyenne par transition : étant donné que N tests séquentiels comportent N - 1 transitions entre les tests, Developer Device Platform soustrait la somme des durées des tests de la durée du segment et divise par N - 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-version pour 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 de 3s et une durée de segment cible de 2m (120s). Sans surcharge, la durée totale attendue est de 60s. Les 60 tests sont donc regroupés dans 1 segment qui prend en réalité près de quatre minutes (60s d'exécution de test plus 59 * 3s = 177s de transitions d'orchestrateur). En ajoutant la surcharge de 3s à chaque test (durée attendue de 4s par test, soit 240s au total), Developer Device Platform alloue 2 segments (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 40s entraîne un coût attendu de 43s (40s + 3s), tandis qu'un segment auquel sont attribués 10 tests 4s entraîne un coût attendu de 70s (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 :

  1. 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.
  2. 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.
  3. 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ée shardingContext dédiée pour les exécutions suivantes.

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