La fragmentación inteligente en Device Run de Developer Device Platform distribuye las pruebas de instrumentación de Android y las XCTest de iOS en fragmentos paralelos con los tiempos históricos de ejecución de pruebas almacenados en Cloud Storage. A diferencia de la fragmentación uniforme, que divide los casos de prueba por recuento, independientemente de cuánto tiempo se ejecute cada prueba, la fragmentación inteligente equilibra los fragmentos según la duración esperada para que los fragmentos paralelos finalicen aproximadamente al mismo tiempo objetivo.
En este documento, se explica cómo el algoritmo de fragmentación inteligente calcula los recuentos de fragmentos y asigna pruebas, se describe el esquema del registro de tiempo de YAML almacenado en tu bucket de Cloud Storage y se responden preguntas frecuentes sobre la sobrecarga de Android Test Orchestrator y el período de datos de 30 días. Para obtener instrucciones de línea de comandos con Google Cloud CLI, consulta las instrucciones de instrumentación de Android y de XCTest de iOS.
Cómo funciona el algoritmo de fragmentación inteligente
La fragmentación no equivale a la cantidad de pruebas que se pueden ejecutar de forma simultánea. Es posible que los dispositivos disponibles sean menos que el límite de fragmentos en el momento de su solicitud. La cantidad real de dispositivos simultáneos que se pueden asignar a un usuario puede ser menor que la cantidad de fragmentos que especificó.
Cuando envías una sesión con --sharding-option=smart en la
gcloud CLI o configuras smartSharding en la API de REST,
Developer Device Platform ejecuta un flujo de trabajo de seis etapas que abarca la creación de la sesión, la ejecución de la prueba
y la finalización:
- Lee los datos históricos de tiempos y haz coincidir el contexto del dispositivo. Antes de
programar los fragmentos, el agente de servicio de Device Run lee tu
archivo YAML de fragmentación inteligente desde Cloud Storage. Busca en la lista
recordsunshardingContextque coincida con eldeviceModely elosVersiondel trabajo de destino (no distingue mayúsculas de minúsculas). Si no existe una coincidencia exacta para esa combinación de dispositivo y SO, Developer Device Platform recurre a la primera entradarecordsdisponible en el archivo. Si el archivo YAML aún no existe, la sesión continúa como un inicio en frío con un historial de tiempos vacío. - Filtra las muestras para la ventana móvil de 30 días y calcula las duraciones
esperadas. Para el registro de contexto seleccionado, Developer Device Platform conserva
solo las muestras de tiempo cuyo
recordTimese encuentra dentro de los últimos 30 días y calcula la duración media aritmética de cada caso de prueba. Si Android Test Orchestrator está habilitado con--orchestrator-version, Developer Device Platform también calcula la media de 30 días de las muestras de sobrecarga deANDROID_TEST_ORCHESTRATORy agrega esa sobrecarga media a la duración esperada de cada caso de prueba. - Descubre pruebas ejecutables y asigna estimaciones de resguardo. En el host
del trabajador, Developer Device Platform inspecciona de forma estática tu paquete de prueba: lee
los archivos DEX en el APK de prueba en Android o los símbolos
.xctesty los filtros.xctestruncompilados en iOS, aplica los filtros--test-targetsy excluye las pruebas ignoradas o suprimidas (como@Ignoreo@Suppress). Cada unidad de prueba ejecutable recibe una duración esperada según tres niveles:- Caso de prueba registrado: Usa su duración media histórica de 30 días (más
la sobrecarga media de Orchestrator cuando Android Test Orchestrator está habilitado).
En Android, las clases de JUnit parametrizadas (como las que usan
@RunWith(Parameterized.class),JUnitParamsRunneroTestParameterInjector) se programan como una sola unidad a nivel de clase cuya duración esperada es la suma de todas las duraciones de los métodos registradas para esa clase. - Caso de prueba no registrado en un paquete existente: Usa la duración esperada promedio de todos los casos de prueba registrados que no sean cero en el registro coincidente.
- Inicio en frío (sin historial registrado): Usa una estimación predeterminada de 30 segundos por unidad de prueba.
- Caso de prueba registrado: Usa su duración media histórica de 30 días (más
la sobrecarga media de Orchestrator cuando Android Test Orchestrator está habilitado).
En Android, las clases de JUnit parametrizadas (como las que usan
Calcula el recuento de fragmentos. Developer Device Platform suma las duraciones esperadas de todas las unidades de prueba ejecutables y las divide por el valor de
--smart-sharding-target-durationque configuraste (válido de2ma1h), redondeando hacia arriba al fragmento entero más cercano:optimal_shards = max(1, ceil(total_expected_duration / target_duration))Luego, Developer Device Platform establece el recuento final de fragmentos entre
1y el más bajo de los siguientes límites:- La cantidad total de unidades de prueba ejecutables (para evitar fragmentos vacíos)
- Tu valor de
--smart-sharding-max-shard-count, si se establece en un valor mayor que0. - El límite de la plataforma (
20fragmentos para dispositivos físicos o200fragmentos para dispositivos virtuales de Android)
Asigna pruebas con el empaquetado en contenedores de tiempo de procesamiento más largo primero. Developer Device Platform ordena todas las unidades de prueba ejecutables en orden descendente de duración esperada (de la más lenta a la más rápida) y, luego, inicializa un montón mínimo de fragmentos vacíos ordenados por duración acumulada. Toma una unidad de prueba a la vez, asigna la prueba restante más lenta al fragmento que tenga la duración acumulada más pequeña y actualiza el total de ese fragmento. Si se programan primero las pruebas lentas de "polo largo", se aíslan en fragmentos separados, mientras que las pruebas más cortas llenan los espacios restantes para mantener equilibradas las duraciones totales de los fragmentos.
Registra los tiempos de paso y actualiza Cloud Storage. Después de que finalizan todos los fragmentos, Developer Device Platform recopila las duraciones medidas de
startTimeaendTimede los casos de prueba exitosos, descarta las muestras que tengan más de 30 días en todos los contextos de dispositivos del archivo YAML, quita los registros de contexto que no tengan muestras válidas restantes y vuelve a escribir el archivo YAML actualizado en Cloud Storage con reintentos de simultaneidad optimista que coincidan con la generación.
Estructura del archivo YAML de fragmentación inteligente
Cuando ejecutas una sesión con gcloud CLI,
--smart-sharding-record-name especifica el nombre de archivo base (sin incluir la extensión
YAML) del registro de tiempo almacenado en el bucket de Cloud Storage
de tu proyecto de Google Cloud :
gs://BUCKET_NAME/automation/smart-sharding/RECORD_NAME.yaml
Reemplaza los marcadores de posición que se indican más abajo:
BUCKET_NAME: Es el nombre del bucket de Cloud Storage especificado con--bucket-nameo<var>PROJECT_ID</var>-devicerunde forma predeterminada (dondePROJECT_IDes el ID del proyecto de Google Cloud).RECORD_NAME: Es el identificador de registro que se pasa a--smart-sharding-record-namesin la extensión de archivo YAML (por ejemplo,checkout-suitese asigna aautomation/smart-sharding/checkout-suite.yaml).
Ejemplo de registro de tiempo en YAML
En el siguiente ejemplo, se muestra un archivo YAML de fragmentación inteligente (checkout-suite.yaml)
que contiene registros de tiempo para dos contextos de dispositivos: un dispositivo Android que se ejecuta con
Android Test Orchestrator y un dispositivo 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'
Referencia de campos de YAML
El archivo YAML de fragmentación inteligente serializa el esquema SuiteTiming con nombres de campo en mayúsculas y minúsculas. En la siguiente tabla, se describe cada campo del archivo:
| Campo | Tipo | Descripción |
|---|---|---|
metadata |
Mapa (de string a string) |
Metadatos opcionales de par clave-valor a nivel del paquete que se conservan en las actualizaciones de agregación. |
records |
Lista de objetos | Entradas de tiempo por dispositivo (SuiteTimingWithContext), particionadas por modelo de hardware y versión del SO. |
records[].shardingContext |
Objeto | Son las dimensiones de hardware y SO que abarcan un conjunto de mediciones de tiempo. |
records[].shardingContext.deviceModel |
string |
Es el identificador del modelo del dispositivo en el que se registraron los tiempos (por ejemplo, shiba en Android o iphonese3 en iOS). |
records[].shardingContext.osVersion |
string |
La versión del SO o del SDK del dispositivo (por ejemplo, el nivel de API de Android '34' o la versión de iOS '18.4') |
records[].testCaseTimingRecords |
Lista de objetos | Duraciones de ejecución históricas de los casos de prueba individuales que se aprobaron en este contexto. |
records[].testCaseTimingRecords[].testCaseName |
string |
Identificador de prueba completamente calificado en formato package.ClassName#methodName (o package.ClassName si no hay metadatos del método). |
records[].testCaseTimingRecords[].timingSamples |
Lista de objetos | Es una lista móvil de 30 días de las duraciones medidas para el caso de prueba, que se agrega después de las ejecuciones exitosas. |
timingSamples[].duration |
Cadena de duración | Es la duración medida con formato en segundos con precisión fraccionaria opcional (por ejemplo, 10s o 42.180s). |
timingSamples[].recordTime |
Cadena de marca de tiempo | Es la marca de tiempo UTC RFC 3339 que indica cuándo Developer Device Platform registró la muestra (por ejemplo, '2026-11-09T16:45:03Z'). |
records[].conditionalOverheads |
Lista de objetos | Sobrecargas de ejecución opcionales medidas en modos de ejecución específicos, con alcance para shardingContext. Se omite cuando no se aplican gastos generales condicionales. |
records[].conditionalOverheads[].condition |
string |
Es el identificador de la condición de ejecución. Valor admitido: ANDROID_TEST_ORCHESTRATOR. |
records[].conditionalOverheads[].timingSamples |
Lista de objetos | Es una lista de 30 días de muestras de sobrecarga por transición registradas de los fragmentos que cumplen con los requisitos. |
Comprende los tiempos de sobrecarga de ANDROID_TEST_ORCHESTRATOR
Cuando ejecutas pruebas de instrumentación de Android con --orchestrator-version, tu
archivo YAML de fragmentación inteligente incluye una entrada conditionalOverheads con
condition: ANDROID_TEST_ORCHESTRATOR. A diferencia de testCaseTimingRecords, estas muestras de sobrecarga no se adjuntan a un método de prueba individual ni a un fragmento numerado.
Qué representa una muestra de duración de sobrecarga
Cuando se habilita Android Test Orchestrator, se ejecuta cada método de prueba en su propio proceso de Instrumentation aislado. Las marcas de tiempo individuales de startTime y endTime de la prueba solo capturan el tiempo que se pasa dentro de cada método de prueba. No incluyen el intervalo entre pruebas que se pasa deteniendo el proceso de la app anterior, borrando opcionalmente los datos del paquete (clearPackageData) y comenzando un proceso de Instrumentation nuevo para la siguiente prueba.
Para medir ese costo de transición entre pruebas, Developer Device Platform inspecciona cada
fragmento aprobado que ejecuta dos o más casos de prueba (N > 1) y calcula lo siguiente:
- Intervalo total de ejecución de fragmentos: Es el tiempo real transcurrido desde la
prueba
startTimemás temprana en el fragmento hasta la pruebaendTimemás reciente en el fragmento. - Duración total de los casos de prueba: Es la suma de
(endTime - startTime)en todos los casos de prueba deNen ese fragmento. Sobrecarga promedio por transición: Debido a que las pruebas secuenciales de
Ntienen transiciones deN - 1entre pruebas, Developer Device Platform resta las duraciones de las pruebas sumadas del intervalo de fragmentos y las divide porN - 1:overhead_sample = max(0, total_span - total_test_duration) / (N - 1)
Cada fragmento de prueba múltiple que se aprueba en tu trabajo aporta un TimingSample a
ANDROID_TEST_ORCHESTRATOR. Por ejemplo, si una sesión se ejecuta en tres fragmentos
y cada uno de ellos se aprueba con al menos dos casos de prueba, esa sesión agrega tres
muestras de sobrecarga con el recordTime de la sesión. Los fragmentos que ejecutan solo un caso de prueba (N = 1) tienen cero transiciones entre pruebas y no emiten una muestra de sobrecarga.
Por qué la sobrecarga no está vinculada a un caso de prueba o fragmento
Developer Device Platform almacena muestras de ANDROID_TEST_ORCHESTRATOR en el nivel de
shardingContext (deviceModel y osVersion) en lugar de por prueba o
por fragmento por dos motivos:
- La sobrecarga depende del dispositivo y del SO, no de la lógica de prueba. El inicio del proceso, la inicialización de Binder y el borrado de datos de paquetes tardan aproximadamente el mismo tiempo, independientemente del método JUnit que se ejecute a continuación, mientras que las agrupaciones de fragmentos cambian de forma dinámica cada vez que cambian los tiempos de prueba o los recuentos de fragmentos.
- Separar la sobrecarga preserva los tiempos de prueba de referencia limpios. Mantener
la sobrecarga de aislamiento de procesos fuera de
testCaseTimingRecordssignifica que puedes habilitar o desactivar--orchestrator-versionen las ejecuciones que comparten el mismo registro YAML sin distorsionar las duraciones de ejecución subyacentes por prueba.
Cómo Developer Device Platform usa la sobrecarga durante la asignación de fragmentos
Cuando se establece --orchestrator-version en una sesión nueva, Developer Device Platform
calcula el promedio de 30 días de muestras de ANDROID_TEST_ORCHESTRATOR válidas
(avg_overhead) y lo agrega a la duración promedio de 30 días de cada caso de prueba
antes de calcular los recuentos de fragmentos o empaquetar fragmentos:
expected_test_duration = avg_test_duration + avg_overhead
Si no se establece --orchestrator-version en la sesión, avg_overhead es 0s y
se ignoran las entradas ANDROID_TEST_ORCHESTRATOR existentes en el archivo YAML
para esa ejecución.
Agregar avg_overhead a cada caso de prueba afecta la fragmentación de tres maneras:
- Recuento preciso de fragmentos para conjuntos con muchas pruebas rápidas. Considera un paquete
de 60 pruebas de instrumentación de estilo de unidades que se ejecutan en
1s, con una sobrecarga de transición promedio de Orchestrator de3sy una duración de fragmento objetivo de2m(120s). Sin sobrecarga, la duración total esperada parece ser de60s, por lo que las 60 pruebas se empaquetan en1fragmento que, en realidad, tarda casi cuatro minutos en finalizar (60sde ejecución de prueba más59 * 3s = 177sde transiciones de Orchestrator). Si se agrega la sobrecarga de3sa cada prueba (duración esperada de4spor prueba o240sen total), Developer Device Platform asigna2fragmentos (ceil(240s / 120s)) para que cada fragmento finalice cerca del objetivo de dos minutos. - Empaquetado de fragmentos equilibrado cuando los recuentos de pruebas difieren. Durante
el empaquetado en contenedores con el tiempo de procesamiento más largo primero, un fragmento al que se le asigna una prueba de IU de
40sgenera un costo esperado de43s(40s + 3s), mientras que un fragmento al que se le asignan 10 pruebas de4sgenera un costo esperado de70s(10 * (4s + 3s)). Incluir la sobrecarga por prueba evita que los fragmentos con muchas pruebas cortas acumulen silenciosamente minutos de latencia de reinicio del proceso no contabilizados. - Estimaciones realistas para las pruebas que se agregaron recientemente Debido a que las pruebas no registradas en
un paquete existente heredan la duración esperada promedio de las pruebas conocidas, que
ya incluye
avg_overhead, las pruebas nuevas tienen en cuenta automáticamente la sobrecarga del organizador en su primera ejecución.
Comprende la ventana de datos de 30 días y el comportamiento de la ejecución inicial
La fragmentación inteligente no requiere 30 días de datos históricos antes de comenzar a optimizar tus ejecuciones de prueba. Incluso una sola muestra registrada activa el cálculo de fragmentos basado en la duración y el empaquetado en contenedores en la siguiente sesión. En cambio, 30 días es la ventana de visualización y retención progresiva que Developer Device Platform usa cuando lee y actualiza el registro de tiempo de YAML.
Por qué la fragmentación inteligente usa una ventana móvil de 30 días
Cada vez que Developer Device Platform lee o actualiza un archivo YAML de fragmentación inteligente,
filtra cualquier TimingSample cuyo recordTime tenga más de 30 días.
Esta ventana de 30 días equilibra dos objetivos de ingeniería:
- Adaptación a los cambios en la base de código y limitación del tamaño de los archivos Las funciones de la app, los flujos de la IU y las implementaciones de pruebas evolucionan con el tiempo. La expulsión automática de las muestras con más de 30 días de antigüedad evita que los tiempos obsoletos, por ejemplo, los tiempos anteriores a un rediseño de pantalla o a una refactorización de la capa de red, sesguen las asignaciones de fragmentos actuales. Expulsar las entradas vencidas (y descartar los contextos de dispositivos que ya no tienen muestras válidas) también mantiene el archivo YAML compacto y muy por debajo del límite de 32 MB.
- Suaviza la variación entre ejecuciones y, al mismo tiempo, admite conjuntos de pruebas semanales. Una sola ejecución de prueba puede experimentar ruido transitorio de la recolección de elementos no utilizados, los servicios del sistema en segundo plano o la programación del emulador. Promediar las muestras en un período de 30 días suaviza los picos únicos y, al mismo tiempo, conserva suficiente historial para que las canalizaciones de integración continua nocturnas, semanales o de cadencia de sprint mantengan registros de tiempo de preparación entre ejecuciones.
Qué esperar en las semanas uno y dos
Si habilitas la fragmentación inteligente en un paquete de pruebas existente hoy, los tiempos de ejecución siguen una curva de preparación rápida en lugar de esperar semanas para mejorar:
- Primera ejecución (inicio en frío). Como el archivo YAML aún no existe en
Cloud Storage, Developer Device Platform asigna a cada unidad de prueba
ejecutable la estimación predeterminada de 30 segundos. Calcula el recuento de fragmentos
como
ceil(num_tests * 30s / target_duration)(limitado por el recuento máximo de fragmentos y los límites de la plataforma) y distribuye las pruebas entre los fragmentos, de manera similar a la fragmentación uniforme. En esta primera ejecución, ocurrirá lo siguiente:- Si tus pruebas tardan mucho menos de 30 segundos en promedio, es posible que la ejecución 1 asigne
más fragmentos de los necesarios (hasta
--smart-sharding-max-shard-count). - Si tu paquete contiene varias pruebas de IU de varios minutos, es posible que dos pruebas lentas lleguen al mismo fragmento por casualidad, lo que lo convierte en el cuello de botella para el tiempo de finalización real.
- Cuando finaliza la ejecución 1, Developer Device Platform crea el archivo YAML en Cloud Storage con las duraciones medidas de las pruebas exitosas.
- Si tus pruebas tardan mucho menos de 30 segundos en promedio, es posible que la ejecución 1 asigne
más fragmentos de los necesarios (hasta
- Segunda ejecución (inmediatamente después de que se complete la ejecución 1). La fragmentación inteligente ya está activa. Developer Device Platform lee las duraciones registradas por la ejecución 1, vuelve a calcular el recuento de fragmentos a partir del tiempo de ejecución real del paquete y aísla primero las pruebas más lentas en fragmentos separados. Por lo general, verás la reducción principal en la duración de la sesión de tiempo real y el ajuste de tamaño correcto del recuento de fragmentos a partir de la ejecución 2, incluso el mismo día en que habilites la fragmentación inteligente.
- Resto de la semana uno y semana dos. En las siguientes ejecuciones, el balance de fragmentos
se sigue ajustando en tres casos específicos:
- Suavizar la varianza de una sola ejecución A medida que cada ejecución agrega otra
TimingSample, las fluctuaciones transitorias de la ejecución 1 se promedian, lo que reduce los fragmentos rezagados que terminan un poco después de--smart-sharding-target-duration. - Se completan las pruebas de las ejecuciones que fallaron inicialmente. Para evitar que las fallas rápidas
o los tiempos de espera de las pruebas dañen los promedios históricos,
Developer Device Platform registra los tiempos solo para las pruebas que se aprueban (y, en
Android, solo de los fragmentos cuyo estado general del paquete es
PASSED). Cualquier prueba que no haya registrado un tiempo en la ejecución 1 usa la duración promedio del paquete en la ejecución 2 y, luego, cambia a su propio tiempo medido una vez que se aprueba. - Agregar pruebas o modelos de dispositivos nuevos Cualquier caso de prueba nuevo que se confirme
durante las semanas uno y dos usará automáticamente la duración esperada promedio del paquete
en lugar de volver al valor predeterminado de 30 segundos. Si agregas un segundo modelo
--devicea la sesión con el mismo nombre de registro, su primera ejecución usará los tiempos del dispositivo existente como resguardo inicial y, luego, registrará una entradashardingContextdedicada para las ejecuciones posteriores.
- Suavizar la varianza de una sola ejecución A medida que cada ejecución agrega otra
Preguntas frecuentes
En las siguientes preguntas, se abordan situaciones operativas comunes cuando se ejecuta la fragmentación inteligente en canalizaciones de CI/CD.
¿Qué sigue?
- Obtén más información sobre el ejecutor de pruebas TestParameterInjector.
- Configura marcas de fragmentación inteligente en Cómo ejecutar una prueba de instrumentación de Android.
- Configura las ejecuciones de pruebas de iOS en Ejecuta una XCTest de iOS.
- Verifica los permisos del bucket entre proyectos para el agente de servicio en Comparte tus buckets de Cloud Storage con Developer Device Platform.
- Inspecciona los artefactos de registro y
junit.xmlpor fragmento en Busca los resultados de las pruebas de Developer Device Platform.