Tareas de compilación

elide build deriva las tareas de los conjuntos de fuentes y los artefactos de elide.pkl y las ejecuta en orden de dependencias. Las tareas cuyas entradas no cambiaron se omiten o se restauran desde la caché.

Ejecutar una compilación

elide build                   # run the default group
elide build compile-java-main # run one task
elide build compile           # run a group
elide build clean             # the clean target
elide build --inspect         # list tasks and their options without running

Un argumento nombra una tarea o un grupo; los dos puntos iniciales (:compile-java-main) son opcionales. Un objetivo que no coincide con nada hace fallar la compilación.

Algunas tareas aceptan opciones, que --inspect enumera:

elide build test --select=class:com.example.SomeTest
elide build run --args="a b c"

En un espacio de trabajo, anteponga el proyecto: core:compile-kotlin-main, core:compile, o core para sus tareas predeterminadas. Los objetivos sin prefijo se resuelven en el proyecto actual y luego en la raíz. --inspect agrupa las tareas por proyecto, y las filas de progreso lo nombran ([core] Compiling Kotlin sources).

Opciones

Las opciones son --name o --name=value, en cualquier posición entre los objetivos. Los argumentos después de -- van al proceso que lanza una tarea.

Las opciones se comprueban frente a las tareas antes de ejecutar nada. Una opción desconocida, un valor que falta o sobra, o una opción repetida hacen fallar la compilación:

Unknown option '--worker', did you mean '--workers'?
Option '--workers' requires a value, as '--workers=<value>'

Las opciones globales (-p, -v, --debug y las demás) quedan excluidas. Opciones de las tareas: Dependencias, Pruebas.

Caché de compilación

El nivel local está siempre activo: ~/.elide/cache/entries-v2, un directorio por clave con un registro y un tar de las salidas. Las restauraciones se comprueban frente a la huella registrada. Las entradas en un formato antiguo cuentan como fallos.

El nivel compartido es una caché HTTP que se configura con variables de entorno:

• Primero se consulta la caché local; los aciertos remotos se guardan localmente.
• Configuración típica: CI sube; los desarrolladores definen ELIDE_REMOTE_CACHE_PUSH=false.
• Las entradas remotas inalcanzables, lentas o ilegibles cuentan como fallos. Tres errores de transporte seguidos desactivan el nivel durante el resto de la compilación. Los errores HTTP como 404 no son errores de transporte; una credencial rechazada produce una sola advertencia.
• La compilación falla con una URL que no sea http/https, una contraseña sin nombre de usuario, un PUSH/PULL que no sea booleano, o credenciales por http sin cifrar hacia un host que no sea de loopback.
• La caché sirve salidas ejecutables: use https, exija autenticación para las escrituras y limite quién puede escribir.
• --offline desactiva el nivel compartido durante una ejecución; --no-cache desactiva la caché.

.eliderc y la política smart

Con smart, una entrada se descarga solo cuando es más barato que recompilar, y se sube solo cuando la subida cuesta menos que el trabajo que ahorra. Los costos vienen de .eliderc (sintaxis de java.util.Properties): ~/.eliderc y, encima, <project>/.eliderc. Describe la máquina, así que no lo incluya en el repositorio.

# ~/.eliderc
network.downlink = 200mbps
network.uplink = 20mbps
network.latency = 250ms
network.stability = good        # good | fair | poor
machine.compute = fast          # slow | normal | fast, or a multiplier such as 1.5

cache.remote.policy = smart     # smart | eager (default)
cache.remote.upload-budget = 2.0
cache.remote.min-build = 500ms  # work cheaper than this is never published

Mb/s y mbps son megabits; MB/s son megabytes. Los valores ilegibles producen una advertencia y se usa el valor predeterminado. ELIDE_REMOTE_CACHE_POLICY prevalece sobre cache.remote.policy. Con eager, el archivo no tiene efecto.

Estado de compilación

• Archivos binarios; no los edite.
• No hay un archivo de bloqueo de dependencias para todos los ecosistemas; npm escribe aube-lock.yaml.
• En un espacio de trabajo, el estado de todos los miembros se guarda en el .dev/ de la raíz; las salidas permanecen en el .dev/ de cada proyecto.
• --no-cache ignora el archivo de estado local, pero sigue leyendo el compartido.
• elide install reutiliza la resolución mientras la lista de dependencias no cambie; --fresh vuelve a descargar todas las dependencias y actualiza la caché global.
• Los argumentos de cada compilador se escriben junto a su salida como <tool>.args, uno por línea.

Medir el tiempo de una compilación

Cada tarea imprime su duración. Para más detalle:

elide build -v                                                # everything, at debug
ELIDE_LOG=dev.elide.tooling.build.telemetry=debug elide build # only the timings

[debug] dev.elide.tooling.build.telemetry stage graph took 590us
[debug] dev.elide.tooling.build.telemetry op compile-kotlin-main · up-to-date (up-to-date) took 420us
[debug] dev.elide.tooling.build.telemetry task compile-kotlin-main (skipped: up-to-date) took 12.6ms

Las regiones son una etapa (configuración, grafo, ejecución, guardado del estado), una tarea o una operación de una tarea (prepare, fingerprint, up-to-date, execute, consultas y escrituras en la caché). El trabajo dentro de execute no se desglosa.

ELIDE_BUILD_TELEMETRY escribe una traza de Chrome local al terminar la compilación; no se sube nada:

ELIDE_BUILD_TELEMETRY=1 elide build             # .dev/telemetry/build-<stamp>.trace.json
ELIDE_BUILD_TELEMETRY=profile.json elide build  # a file you name
ELIDE_BUILD_TELEMETRY=/tmp/traces elide build   # a directory you name

Ábrala en Perfetto, chrome://tracing o speedscope, o bien:

jq -r '.traceEvents[] | select(.ph=="X") | "\(.dur/1000 | floor)ms \(.cat) \(.name)"' \
  .dev/telemetry/build-*.trace.json | sort -rn | head