Límite del trabajo concurrente

parallel(limit: 2) [for id in ids => await load_profile(id)] procesa un array con un máximo de dos trabajos activos y devuelve los resultados en el orden de entrada. El ejemplo cuenta los trabajos activos para comprobar el límite y después verifica una entrada vacía y la copia de los elementos de la fuente.

var active = 0
var peak = 0
async fn load_profile(id: int) -> int {
    active += 1
    if active > peak { peak = active }
    defer { active -= 1 }
    sleep 2ms
    return id * 10
}
let profiles = parallel(limit: 2) [for id in [1, 2, 3, 4] => await load_profile(id)]
assert_eq(peak, 2)
assert_eq(active, 0)
assert_eq(profiles.len(), 4)
assert_eq(profiles[0], 10)
assert_eq(profiles[3], 40)
print(peak)
print(profiles[0])
print(profiles[3])
let no_ids: [int] = []
let empty = parallel(limit: 4) [for id in no_ids => id]
assert_eq(empty.len(), 0)

// The pool snapshots source items before evaluating any mapper.

let mut ids = [1, 2, 3]
let original = parallel(limit: 1) [for id in ids => { ids[1] = 99; id }]
assert_eq(original[1], 2)
assert_eq(ids[1], 99)

El límite entero positivo y la fuente se evalúan una vez, en ese orden. Un grupo fijo de trabajadores toma el siguiente elemento al terminar el actual; no se crea una tarea por entrada. La copia de la fuente protege los elementos pendientes frente a cambios posteriores. Un fallo cancela los otros trabajos y espera la limpieza antes de propagar el error. La concurrencia es cooperativa; los cálculos sin suspensión no reciben threads del sistema. Disponible en VM, nativo y LLVM; wasm-aot informa de la limitación del planificador.