Como otimizar a execução de programas grandes com o Resource Estimator

Neste artigo, aprende como otimizar o tempo de execução de programas grandes com o Azure Quantum Resource Estimator.

Para obter informações sobre como executar o Estimador de Recursos, consulte Diferentes maneiras de executar o Estimador de Recursos.

Pré-requisitos

• A versão mais recente do Visual Studio Code ou abrir o VS Code na Web.
• A versão mais recente da extensão do Quantum Development Kit . Para obter detalhes da instalação, consulte Configurar a extensão QDK.

Se você quiser usar Python no VS Code, você também precisa do seguinte:

• Instale a versão mais recente das extensões Python e Jupyter para VS Code.

• O pacote Python mais recente qdk .

  python -m pip install --upgrade qdk
  

Cache manual com programas Q#

Quando você envia um trabalho de estimativa de recursos para o Estimador de Recursos, o programa quântico é avaliado completamente para extrair as estimativas de recursos. Se quiser estimar os recursos de uma operação Q# que é invocada muitas vezes, por exemplo, num loop com muitas iterações, a execução do trabalho de estimativa de recursos pode levar muito tempo. Uma maneira de reduzir os longos tempos de execução é executar a operação uma vez, calcular e armazenar em cache seus custos e usar os dados em chamadas subsequentes. Essa técnica é chamada de cache manual.

O Estimador de Recursos suporta duas funções para executar cache manual: target e Q#. A função BeginEstimateCaching toma como entradas um name que é o nome exclusivo do fragmento de código para o qual se deseja armazenar em cache os custos, e um número inteiro variant que distingue diferentes variantes de custo para o mesmo fragmento.

Por exemplo, digamos que tenhas uma Q# operação chamada ExpensiveOperation que é chamada muitas vezes numa iteração. Você pode usar o cache para reduzir seu tempo de estimativa:

operation ExpensiveOperation(c: Int, b : Bool): Unit {
    if BeginEstimateCaching("MyNamespace.ExpensiveOperation", SingleVariant()) {
        // Code block to be cached
        EndEstimateCaching();
    }
}

Quando ExpensiveOperation é utilizado repetidamente, BeginEstimateCaching é chamado cada vez. Quando é chamado pela primeira vez, ele retorna e começa a acumulação de dados de custo. Isso faz com que o código prossiga com a execução do fragmento de código caro. Quando EndEstimateCaching é chamado, os dados de custos são armazenados para uso futuro e são incorporados no custo total do programa.

Quando ExpensiveOperation é chamado pela segunda vez (e posteriormente), o Estimador de Recursos encontra os dados de custo armazenados em cache, incorpora-os ao custo geral do programa e retorna false. Isso faz com que o fragmento de código caro seja ignorado, portanto, o Resource Estimator executa o programa mais rapidamente. EndEstimateCaching deve ser colocado no final da condição, e as regiões fechadas em BeginEstimateCaching-EndEstimateCaching podem ser aninhadas.

SingleVariant() indica que os dados de custo coletados na primeira execução podem ser reutilizados em todas as execuções subsequentes do fragmento de código. Pode não ser sempre assim. Por exemplo, se o seu código tiver um custo diferente para valores pares e ímpares de uma variável 'c', pode fornecer um valor variant:

operation ExpensiveOperation(c: Int, b : Bool): Unit {
    if BeginEstimateCaching("MyNamespace.ExpensiveOperation", c % 2) {
        // Some code
        EndEstimateCaching();
    }
}

Nesse caso, o cache é diferente para valores ímpares e pares de c. Por outras palavras, os dados recolhidos para valores pares de c só são reutilizados para valores pares de c, e o mesmo se aplica a valores ímpares de c.

Conteúdos relacionados

• Recuperar os resultados do Estimador de Recursos
• Diferentes maneiras de executar o Estimador de Recursos
• Personalizar os parâmetros target do Resource Estimator