Modos de execução de fluxo de trabalho

Ao executar um fluxo de trabalho no .NET, o modo de execução controla como as superetapas são processadas e como os eventos são entregues ao consumidor. A InProcessExecution classe expõe dois modos de execução: OffThread e Lockstep.

Visão geral

OffThread

OffThread é o modo de execução padrão . Os supersteps são executados em um thread em segundo plano e os eventos são transmitidos imediatamente à medida que são gerados por meio de uma implementação baseada em canal.

// OffThread is the default — these are equivalent:
await using StreamingRun run = await InProcessExecution.RunStreamingAsync(workflow, input);
await using StreamingRun run = await InProcessExecution.OffThread.RunStreamingAsync(workflow, input);

Como funciona

1. Uma tarefa em segundo plano executa superpassos continuamente enquanto as mensagens estão pendentes.
2. Conforme os executores produzem saídas ou eventos, os objetos resultantes WorkflowEvent são gravados em um Channel<WorkflowEvent> ilimitado.
3. O consumidor lê os eventos do canal, WatchStreamAsyncrecebendo-os em tempo real conforme são produzidos.
4. Quando todos os superpassos são concluídos e nenhuma mensagem permanece, a execução é parada com um Idle ou PendingRequests status.

Como o loop superstep e o consumidor são executados simultaneamente, os eventos aparecem assim que são gerados – não há nenhum atraso no buffer. Isso torna OffThread ideal para cenários de streaming em que a entrega de eventos de baixa latência importa, como exibir atualizações de token por token em uma interface do usuário.

Execuções simultâneas

O OffThread também dá suporte a uma variante simultânea que permite que várias execuções compartilhem a mesma instância de fluxo de trabalho simultaneamente:

await using StreamingRun run = await InProcessExecution.Concurrent.RunStreamingAsync(workflow, input);

Coordenação Estrita

No modo Lockstep, os superpassos são executados na thread do consumidor em vez de em uma tarefa em segundo plano. Os eventos são acumulados durante cada superstep e emitidos como um lote após a conclusão do superstep.

await using StreamingRun run = await InProcessExecution.Lockstep.RunStreamingAsync(workflow, input);

Como funciona

1. O consumidor chama WatchStreamAsync, o que impulsiona o loop de execução.
2. O superpasso é executado até a sua conclusão, e os eventos são acumulados em fila.
3. Após a conclusão do superstep, todos os eventos na fila serão entregues ao consumidor.
4. A próxima superetapa começa somente depois que o consumidor tiver recebido todos os eventos da superetapa anterior.

Esse padrão alternado significa que o consumidor e o motor de fluxo de trabalho nunca operam simultaneamente. A entrega de eventos é determinística– todos os eventos de um superstep têm a garantia de chegar antes de qualquer evento do próximo superstep.

Quando usar o Lockstep

Lockstep é útil quando:

• Teste – a ordenação de eventos determinísticos torna as declarações simples.
• Depuração – a depuração passo a passo é mais fácil quando a execução permanece no thread do consumidor.
• Processamento ordenado – cenários em que você precisa processar totalmente os eventos de um superstep antes que o próximo superstep comece.

Escolhendo um modo de execução

Para a maioria dos cenários de produção, o modo OffThread padrão é recomendado. Ele fornece a melhor capacidade de resposta e permite que o fluxo de trabalho continue processando enquanto o consumidor lida com eventos.

Use Lockstep quando o comportamento determinístico for mais importante do que o desempenho, como em testes de unidade ou sessões de depuração.

// Production: OffThread (default)
await using StreamingRun run = await InProcessExecution.RunStreamingAsync(workflow, input);

// Testing: Lockstep for deterministic behavior
await using StreamingRun run = await InProcessExecution.Lockstep.RunStreamingAsync(workflow, input);

Execução sem streaming

Ambos os modos de execução dão suporte à execução sem streaming por meio de RunAsync. No modo de não streaming, o fluxo de trabalho é executado até a conclusão e coleta todos os eventos em um Run objeto em vez de transmiti-los incrementalmente:

Run run = await InProcessExecution.RunAsync(workflow, input);

// Access all emitted events
foreach (WorkflowEvent evt in run.OutgoingEvents)
{
    // Process events
}

Como a execução sem streaming coleta todos os eventos após a conclusão, o benefício de entrega de eventos em tempo real do OffThread não se aplica. A principal diferença entre os modos em cenários que não são de streaming é o threading: o OffThread executa supersteps em um thread em segundo plano, liberando o thread de chamada enquanto aguarda a conclusão, enquanto o Lockstep executa supersteps no thread do chamador, bloqueando-o até que o fluxo de trabalho seja concluído.

A execução sem streaming usa o modo OffThread padrão. Para usar o Lockstep com execução sem streaming:

Run run = await InProcessExecution.Lockstep.RunAsync(workflow, input);

Próximas Etapas 

Os modos de execução não são aplicáveis aos fluxos de trabalho do Python. Os fluxos de trabalho do Python utilizam um único modelo de execução que executa o processamento de superpassos e a entrega de eventos por meio de um gerador assíncrono. Esse modelo é semelhante ao modo .NET Lockstep – as etapas não avançam, a menos que o consumidor esteja puxando ativamente eventos do gerador.

Para obter informações sobre como executar fluxos de trabalho do Python, consulte Workflow Builder &Execution.

Ao executar um fluxo de trabalho em Go, o ambiente de execução controla como as superetapas são processadas e como os eventos são entregues ao consumidor. O workflow/inproc pacote expõe três ambientes: Default/OffThread, Lockstepe .Concurrent

Visão geral

OffThread

OffThread é o modo de execução padrão. Eles são equivalentes:

stream, err := inproc.Default.RunStreaming(ctx, wf, input)
stream, err := inproc.OffThread.RunStreaming(ctx, wf, input)

Como funciona

1. Uma goroutine em segundo plano executa superetapas enquanto houver mensagens pendentes.
2. À medida que os executores geram saídas ou eventos, os eventos do fluxo de trabalho são registrados no fluxo.
3. O consumidor lê os eventos com WatchStream, recebendo-os à medida que são produzidos.
4. Quando todas as superetapas são concluídas e não restam mensagens, a execução é encerrada com status ocioso ou de solicitação pendente.

Execuções simultâneas

Use inproc.Concurrent quando todas as associações de executor no fluxo de trabalho dão suporte à execução compartilhada simultânea:

stream, err := inproc.Concurrent.RunStreaming(ctx, wf, input)
if err != nil {
    return err
}
defer stream.Close(ctx)

Coordenação Estrita

No modo Lockstep, a execução do fluxo de trabalho avança conforme o consumidor lê do fluxo. Isso torna a ordenação de eventos determinística para testes e depuração.

stream, err := inproc.Lockstep.RunStreaming(ctx, wf, input)
if err != nil {
    return err
}
defer stream.Close(ctx)

for evt, err := range stream.WatchStream(ctx) {
    if err != nil {
        return err
    }
    // inspect event
}

Como funciona

1. O consumidor chama WatchStream, o que impulsiona o loop de execução.
2. Um superstep é executado até ser concluído, e os eventos são acumulados.
3. Os eventos acumulados são fornecidos ao consumidor.
4. O próximo superstep começa somente depois que o consumidor recebe os eventos do superstep anterior.

Quando usar o Lockstep

Use Lockstep quando o comportamento determinístico importa mais do que o streaming de baixa latência, como testes de unidade, depuração ou cenários em que você deseja processar totalmente os eventos de um superstep antes do próximo superstep começar.

Escolhendo um modo de execução

Para a maioria dos cenários de produção, use inproc.Default ou inproc.OffThread. Use inproc.Lockstep quando a ordenação de eventos determinística é mais importante do que a latência de streaming, como em testes. Use inproc.Concurrent somente quando cada associação no fluxo de trabalho der suporte à execução compartilhada simultânea.

// Production: OffThread (default)
stream, err := inproc.Default.RunStreaming(ctx, wf, input)
if err != nil {
    return err
}
defer stream.Close(ctx)

// Testing: Lockstep for deterministic behavior
testStream, err := inproc.Lockstep.RunStreaming(ctx, wf, input)
if err != nil {
    return err
}
defer testStream.Close(ctx)

Execução sem streaming

Todos os ambientes de execução também dão suporte ao não streaming Run, que é executado até a próxima parada e armazena eventos emitidos na execução retornada.

run, err := inproc.Default.Run(ctx, wf, input)
if err != nil {
    return err
}

for evt := range run.NewEvents() {
    if output, ok := evt.(workflow.OutputEvent); ok {
        fmt.Printf("Final result: %v\n", output.Output)
    }
}

Próximas Etapas