Pular para o conteúdo principal

Introdução aos modos de execução do Qiskit Runtime

Quando o Qiskit Runtime foi introduzido, os usuários só podiam executar circuitos como jobs individuais. À medida que diferentes tipos de cargas de trabalho quânticas surgiram, ficou evidente a necessidade de diferentes estratégias de agendamento. Os modos de execução determinam como seus jobs são agendados, e escolher o modo correto permite que sua carga de trabalho seja executada de forma eficiente dentro do seu orçamento. Existem três modos de execução: job, sessão e lote.

Modo job​

Uma única requisição primitiva do estimador ou do sampler feita sem um gerenciador de contexto. Os circuitos e entradas são empacotados como blocos unificados primitivos (PUBs) e submetidos como uma tarefa de execução no computador quântico. Para executar no modo job, especifique mode=backend ao instanciar uma primitiva. Veja Exemplos de primitivas para uso.

Modo lote​

Um gerenciador de múltiplos jobs para executar experimentos com eficiência, compostos por cargas de trabalho de múltiplos jobs. Essas cargas de trabalho são compostas por jobs executáveis de forma independente, sem relação condicional entre si. Com o modo lote, os usuários submetem todos os seus jobs de uma vez.

O sistema paraleliza ou divide em threads a etapa de pré-processamento (computação clássica) de cada job primitivo para agrupar de forma mais eficiente a execução quântica entre os jobs e, em seguida, executa a etapa de execução quântica de cada job em rápida sucessão para entregar os resultados mais eficientes. Para mais detalhes sobre threading, veja a página de perguntas frequentes sobre modos de execução.

Um conjunto de jobs sendo executados no modo lote. A parte de computação clássica de cada job acontece simultaneamente, depois todos os jobs são enviados ao QPU. O QPU fica reservado para o seu uso desde que o primeiro job chega ao QPU até que o último job termine de ser processado. Não há intervalo entre os jobs em que o QPU fica ocioso.

Notas
  • Ao usar lotes, não há garantia de que os jobs serão executados na ordem em que foram submetidos. Além disso, embora seus jobs em lote sejam executados o mais próximos possível uns dos outros, eles não têm acesso exclusivo ao backend. Portanto, seus jobs em lote podem ser executados em paralelo com os jobs de outros usuários se houver capacidade de processamento suficiente no QPU. Adicionalmente, jobs de calibração do QPU podem ser executados entre os jobs em lote.
  • O tempo de fila não diminui para o primeiro job submetido em um lote. Portanto, lotes não oferecem nenhum benefício ao executar um único job.

Para executar no modo lote, especifique mode=batch ao instanciar uma primitiva ou execute o job em um gerenciador de contexto de lote. Veja Executar jobs em um lote para exemplos.

Modo sessão​

Uma janela dedicada para executar uma carga de trabalho com múltiplos jobs. Durante essa janela, o usuário tem acesso exclusivo ao sistema e nenhum outro job pode ser executado — incluindo jobs de calibração. Isso permite que os usuários experimentem algoritmos variacionais de forma mais previsível e até executem múltiplos experimentos simultaneamente, aproveitando o paralelismo da pilha. O uso de sessões ajuda a evitar atrasos causados pelo enfileiramento de cada job separadamente, o que pode ser particularmente útil para tarefas iterativas que exigem comunicação frequente entre recursos clássicos e quânticos.

Um conjunto de jobs sendo executados no modo sessão e outro sendo executado no modo lote. Entre cada job está o TTL interativo (tempo de vida interativo). A janela ativa começa quando o primeiro job inicia e termina após o último job ser concluído. Após o último job do primeiro conjunto ser concluído, a janela ativa termina e a sessão é pausada (mas não encerrada). Um novo conjunto de jobs então começa e os jobs continuam de maneira semelhante. O QPU fica reservado para o seu uso durante toda a sessão.

Para executar no modo sessão, especifique mode=session ao instanciar uma primitiva, ou execute o job em um gerenciador de contexto de sessão. Veja Executar jobs em uma sessão para exemplos.

Notas
  • O tempo de fila não diminui para o primeiro job submetido em uma sessão. Portanto, sessões não oferecem nenhum benefício ao executar um único job.
  • Usuários do Plano Open não podem submeter jobs de sessão.

Fluxo de trabalho básico​

O fluxo de trabalho básico para lotes e sessões é semelhante:

  1. O primeiro job em um lote ou sessão entra na fila normal. Para lotes, todo o conjunto de jobs é agendado em conjunto.
  2. Quando o primeiro job começa a ser executado, o temporizador do tempo de vida máximo (TTL) é iniciado e não para nem pausa até que o fim seja atingido.
  3. O temporizador do TTL interativo é iniciado após a conclusão de cada job. Se não houver jobs de carga de trabalho prontos dentro da janela do TTL interativo, a carga de trabalho é temporariamente desativada e a seleção normal de jobs é retomada. Um job pode reativar a carga de trabalho desativada se o lote ou a sessão não tiver atingido seu valor máximo de TTL.
    nota

    O job deve passar pela fila normal para reativar a carga de trabalho.

  4. Se o valor máximo de TTL for atingido, a carga de trabalho é encerrada e todos os jobs em fila restantes falham. Qualquer job em execução no momento não será concluído se isso exceder o limite de custo da instância.

O vídeo a seguir ilustra o fluxo de trabalho básico, usando sessões como exemplo:

Para detalhes completos sobre os temporizadores de TTL, veja o guia Tempo máximo de execução.

Próximos passos​

Recomendações