Procesos WASM

Una entrada process.wasm ejecuta un módulo WASM bajo un host de procesos de Wippy, con creación, supervisión y apagado supervisado.

Clasificación: referencia de configuración y ciclo de vida de procesos. Los bloques respaldados por binarios presuponen una compilación externa del componente y entradas de sistema de archivos, host de procesos, entorno y políticas que pertenecen a la aplicación. Los hashes de marcador de posición deben sustituirse por el resumen exacto del binario.

Configuración de entrada

entries:
  - name: wasm_binaries
    kind: fs.directory
    directory: ./wasm

  - name: compute_worker
    kind: process.wasm
    fs: myns:wasm_binaries
    path: /worker.wasm
    hash: sha256:292b796376f8b4cc360acf2ea6b82d1084871c3607a079f30b446da8e5c984a4
    method: run
    imports:
      - wippy:actor
      - wasi:io
      - wasi:poll
    options:
      limits:
        memory_bytes: 67108864
      mailbox:
        capacity: 128
        bytes: 8388608
        message_bytes: 1048576

Campos de configuración

Actores WASM con estado

Importa wippy:actor en un guest de componente para acceder al PID actual y su buzón limitado. La interfaz wippy:actor/process@0.1.0 ofrece:

Los mensajes contienen el PID del remitente, un topic y hasta 16 payloads. Los formatos son bytes, text UTF-8 y json UTF-8. El envío se autoriza como process.send contra el PID de destino. Los mensajes malformados, demasiado grandes o que superan la capacidad del buzón se rechazan antes de llegar al guest.

El guest normalmente exporta una función run de larga duración:

package example:worker;

world worker {
  import wippy:actor/process@0.1.0;
  import wasi:io/poll@0.2.8;
  export run: func() -> result<_, string>;
}

En run, llama a receive() en un bucle, actualiza el estado del guest y usa send() para responder a message.from. Al regresar de run, el proceso termina.

Controles del actor

Configura los presupuestos persistentes de recursos y buzón bajo options:

options:
  worker_class: wasm
  limits:
    memory_bytes: 67108864
    host_buffer_bytes: 8388608
    asyncify_stack_bytes: 65536
    max_execution_ms: 0
    max_open_sockets: 16
    socket_timeout_ms: 30000
  mailbox:
    capacity: 128
    bytes: 8388608
    message_bytes: 1048576

mailbox.message_bytes no puede superar mailbox.bytes. La capacidad también debe ajustarse al recuento mínimo de 256 bytes por mensaje en cola. Los campos desconocidos y los valores no válidos hacen que se rechace la entrada.

Comandos CLI

Registra un proceso WASM como un comando con nombre usando meta.command:

  - name: greet
    kind: process.wasm
    meta:
      command:
        name: greet
        short: Greet someone via WASM
    fs: myns:wasm_binaries
    path: /component.wasm
    hash: sha256:...
    method: greet

Ejecútalo con:

wippy run greet

Lista los comandos disponibles:

wippy run list

Se requiere un terminal.host para que los comandos CLI funcionen; es el host de procesos que ejecuta el comando.

Ciclo de Vida del Proceso

Los procesos WASM siguen el modelo de ciclo de vida Init/Step/Close:

1. Init - Se capturan el contexto de llamada, el método y los argumentos de entrada
2. Step - El primer paso crea la instancia e inicia el módulo. Los pasos posteriores hacen avanzar las operaciones enlazadas al dispatcher; una ejecución síncrona puede completarse en el primer paso.
3. Close - Se liberan los recursos de la instancia

Creación desde Lua

Crea un proceso WASM y supervísalo hasta que termine:

local errors = require("errors")

-- Spawn with monitoring
local pid, err = process.spawn_monitored(
    "myns:compute_worker",   -- entry ID
    "myns:processes",        -- process host
    6, 7                     -- arguments passed to the WASM function
)

if err then
    return nil, err
end

-- Wait for the process to complete
local events = process.events()
while true do
    local event, open = events:receive()
    if not open then return nil, errors.new("process event channel closed") end
    if event.kind == process.event.EXIT and event.from == pid then
        local result = event.result.value  -- return value from the WASM function
        return result, event.result.error
    end
end

Ejecución asíncrona

Los actores WASM pueden ceder el control para las operaciones del host que el entorno de ejecución enlaza al dispatcher, incluidos la recepción y el envío del buzón, el sondeo, los relojes, los sockets, DNS, los streams del sistema de archivos y HTTP saliente. El planificador suspende el proceso hasta que termina la operación y después reanuda la misma instancia invitada:

  - name: http_worker
    kind: process.wasm
    fs: myns:wasm_binaries
    path: /http_worker.wasm
    hash: sha256:...
    method: run
    imports:
      - wasi:io
      - wasi:cli
      - wasi:http
    wasi:
      env:
        - id: myns:api_url
          name: API_URL
          required: true

El mecanismo de cesión y reanudación es transparente para un módulo core transformado en asíncrono o un componente que use las interfaces sondeables compatibles.

Configuración WASI

Los procesos admiten la misma configuración WASI que las funciones:

  - name: file_processor
    kind: process.wasm
    fs: myns:wasm_binaries
    path: /processor.wasm
    hash: sha256:...
    method: process
    imports:
      - wasi:cli
      - wasi:io
      - wasi:clocks
      - wasi:filesystem
    wasi:
      args: ["--input", "/data/input.csv"]
      cwd: "/app"
      env:
        - id: myns:output_format
          name: OUTPUT_FORMAT
      mounts:
        - fs: myns:input_data
          guest: /data
          read_only: true
        - fs: myns:output_dir
          guest: /output

Véase también

• Descripción general - Descripción general del entorno de ejecución WebAssembly
• Funciones - Configuración de funciones WASM
• Funciones del host - Interfaces disponibles en el host
• Modelo de procesos - Ciclo de vida de los procesos
• Supervisión - Árboles de supervisión de procesos