Partilhar via

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

  • Artigo

Neste artigo, você aprenderá a otimizar o tempo de execução ao executar programas grandes Q# 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

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 mais recente do Azure Quantum qsharp .

    python -m pip install --upgrade qsharp

Como lidar com programas grandes 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 você quiser estimar os recursos de uma Q# operação que é invocada muitas vezes, por exemplo, em um 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.

Cache manual

O Estimador target de Recursos suporta duas Q# funções para executar cache manual: BeginEstimateCaching(name: String, variant: Int): Bool e EndEstimateCaching(): Unit. BeginEstimateCaching function toma como entradas um name que é o nome exclusivo do fragmento de código para o qual você deseja armazenar em cache os custos, e um inteiro variant que distingue diferentes variantes de custo para o mesmo fragmento.

Nota

As duas operações BeginEstimateCaching especiais e EndEstimateCaching são operações intrínsecas para o Estimador de Recursos. Eles não são suportados por outra execução targets.

Por exemplo, digamos que você tenha uma Q# operação chamada ExpensiveOperation que é chamada muitas vezes em uma 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 é usado repetidamente, BeginEstimateCaching é chamado cada vez. Quando BeginEstimateCaching é chamado pela primeira vez, ele retorna true e começa o acúmulo 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 custo são armazenados para uso futuro e são incorporados ao custo geral do programa.

Quando ExpensiveOperation é chamado pela segunda vez (e posteriormente), o Estimador de Recursos encontra os dados de custo armazenados (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 podem BeginEstimateCaching-EndEstimateCaching 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', você pode fornecer um variant valor:

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.

Nota

Se tiver algum problema ao trabalhar com o Estimador de Recursos, consulte a página Resolução de problemas ou contacte AzureQuantumInfo@microsoft.com.

Conteúdos relacionados