Acelerando o Excel com o Microsoft HPC Pack: criando aplicativos VBA e pastas de trabalho para um Microsoft HPC Pack

Resumo

O HPC Services para Excel dá suporte a uma variedade de novos modelos de programação que permitem executar cálculos do Excel em um cluster HPC. Neste artigo, discutiremos como usar macros do VBA do Excel para criar pastas de trabalho que utilizam um cluster HPC para executar cálculos em paralelo. Para dar suporte aos Serviços HPC para Excel, sua pasta de trabalho precisa incluir um conjunto de macros que implementam as funções assíncronas. Este artigo descreve a estrutura de macro e como definir cálculos dentro da estrutura. Este artigo inclui um exemplo de como criar uma pasta de trabalho do zero e um exemplo de conversão de uma pasta de trabalho existente para execução em um cluster.

Introdução

Você gastaria uma hora para fazer sua pasta de trabalho do Excel ser executada quatro vezes mais rapidamente? Que tal oito vezes mais rápido, ou até mais? Se você tiver pastas de trabalho do Excel longas ou lentas, poderá usar os Serviços HPC para Excel com um cluster do Microsoft HPC para melhorar drasticamente o desempenho do cálculo.

O HPC Services para Excel dá suporte a uma variedade de novos modelos de programação, permitindo que você execute cálculos do Excel em um cluster HPC. Mas você não precisa entender o desenvolvimento de código ou conhecer C#para usar os Serviços HPC para Excel. Neste artigo, discutiremos como criar pastas de trabalho que utilizam um cluster HPC para cálculo, usando apenas o VBA do Excel.

Na realidade, provavelmente levará mais de uma hora para converter uma de suas pastas de trabalho para ser executada no cluster, dependendo de quão complicada é a pasta de trabalho. No entanto, se você passar uma hora trabalhando nos exemplos neste artigo, entenderá os conceitos envolvidos e os requisitos para converter praticamente qualquer pasta de trabalho a ser executada em um cluster HPC. Você também verá os benefícios de desempenho que você pode obter com algumas alterações simples no código do VBA.

Público-alvo pretendido

Este artigo destina-se a desenvolvedores do Excel que estão familiarizados com a gravação de macros do VBA. A familiaridade com o Microsoft HPC Pack é útil, mas não é necessária.

Se você estiver interessado nas possibilidades de desempenho dos Serviços HPC para Excel, mas não quiser percorrer o processo de desenvolvimento completo, os arquivos de download incluem versões concluídas das duas pastas de trabalho discutidas neste artigo. Se você quiser tentar executar essas pastas de trabalho em um Cluster do Microsoft HPC, leia a seção "Antes de Começar" para verificar se você tem todos os requisitos em vigor antes de começar. Para obter exemplos adicionais e documentação, vá para https://github.com/Azure-Samples/hpcpack-samples.

Baixar arquivos

Você pode encontrar alguns arquivos de exemplo usados nas seções a seguir do Repositório github de exemplo do HPC Pack. Os arquivos de exemplo incluem arquivos de macro esqueleto que você pode importar para suas pastas de trabalho para simplificar o processo de desenvolvimento. Há também uma pasta de trabalho básica que usaremos como ponto de partida para desenvolver uma pasta de trabalho para o HPC Services para Excel.

Estrutura e Formatação

As capturas de tela neste artigo são todas provenientes do Excel e do Gerenciador de Cluster de HPC. Nos exemplos práticos incluídos neste artigo, exemplos de código são formatação usando um estilo de código que representa o editor do VBA:

'==========================================================
'
' Section 1: Variables and constants
'
'==========================================================

Dim SentRecords As Integer
Dim RcvRecords As Integer

Quando linhas de código forem adicionadas ou modificadas, elas serão realçadas em verde. Grande parte do código incluído aqui é importada de arquivos existentes ou copiada entre arquivos VBA diferentes. Nesse caso, algumas longas linhas de código podem ser truncadas para caber dentro das margens deste documento. Tente copiar e colar de documentos existentes em vez deste artigo, para evitar incluir acidentalmente os exemplos de código truncado.

Visão geral

O HPC Services para Excel dá suporte a vários modelos de programação para desenvolver e executar cálculos do Excel em um cluster do Microsoft HPC. A solução selecionada deve depender de suas necessidades específicas e suas habilidades de desenvolvimento.

Abordaremos cada um desses modelos de programação em artigos futuros. Hoje, abordaremos o primeiro modelo: calcular pastas de trabalho do Excel em paralelo usando apenas o VBA do Excel. Mesmo que você queira avançar para um desenvolvimento mais complexo com o Excel e o Microsoft HPC Pack, esse pode ser um ótimo lugar para começar: é a maneira mais simples e rápida de fazer com que os aplicativos do Excel sejam executados em um cluster HPC, e isso ajudará você a entender os requisitos e os benefícios do uso dos Serviços HPC para Excel.

Para dar suporte a desenvolvedores do Excel, o HPC Services para Excel inclui um conjunto de bibliotecas que você pode usar diretamente do Excel , em sua área de trabalho, para criar e executar pastas de trabalho do Excel em um cluster do Microsoft HPC. Com essas bibliotecas, você não precisa saber a programação do .NET ou o C#. Todo o trabalho pode ser feito no Excel escrevendo macros do VBA. Com essa estrutura, você pode acelerar drasticamente o cálculo das pastas de trabalho do Excel simplesmente escrevendo código VBA e executando as pastas de trabalho no cluster.

O HPC Services para Excel inclui uma estrutura de cliente/serviço especificamente projetada para ser usada do Excel na área de trabalho. Há duas partes importantes nessa estrutura: uma biblioteca de clientes, que está instalada na área de trabalho; e uma biblioteca de serviços, que é instalada nos nós de computação do cluster. Essas bibliotecas são instaladas por padrão quando você instala o Microsoft HPC Pack, portanto, você não precisará fazer nenhuma configuração personalizada para usá-las.

Depois que o cliente e a biblioteca de serviços forem instalados, você poderá criar e executar pastas de trabalho do Excel para o cluster simplesmente adicionando algumas macros do VBA à sua pasta de trabalho. Descreveremos essas novas macros do VBA como a estrutura de macro. Quando nos referimos à estrutura de macro, estamos descrevendo especificamente as novas macros que você adiciona às pastas de trabalho para dar suporte ao cálculo em um cluster HPC.

Antes de discutirmos as macros específicas, vale destacar alguns conceitos importantes que afetam como as macros são construídas e como elas funcionam.

Cálculo assíncrono

O conceito mais importante a ser entendido no desenvolvimento de pastas de trabalho para o HPC Services para Excel e no uso da estrutura de macro é o cálculo assíncrono.

Um aplicativo típico do Excel é executado de forma síncrona. Ou seja, você pressiona um botão para executar uma macro e a macro executa algum código VBA. Nesse código, você pode fazer alterações na planilha, chamar outras funções do VBA, acessar bancos de dados ou qualquer outra coisa. Mas você espera que as macros sejam executadas do início ao fim e, em seguida, sejam concluídas.

O modelo assíncrono é um pouco diferente. Neste modelo, você escreve funções VBA, mas não as chama diretamente. Em vez disso, uma biblioteca de clientes -- código instalado com o HPC Services para Excel -- chamará suas funções VBA.

Se você estiver familiarizado com eventos do Excel no VBA, já conhece esse modelo. Por exemplo, se você escrever uma função VBA executada no evento Workbook.Open, você saberá que o código será executado sempre que a pasta de trabalho for aberta. Mas você não chama esse código diretamente; Em vez disso, o Excel chama a função que você grava automaticamente quando a pasta de trabalho é aberta.

O modelo de programação assíncrona funciona da mesma maneira. Você escreve funções que serão chamadas durante um cálculo, mas em vez de chamá-las por conta própria, você espera que o Excel -- ou, nesse caso, a biblioteca HPC Services for Excel -- chame as funções.

Cálculo iterativo e cálculo paralelo

Outro conceito importante é o cálculo iterativo. O cálculo iterativo refere-se a um tipo de cálculo que executa as mesmas etapas básicas de cálculo em diferentes conjuntos de dados.

O exemplo mais comum de cálculo iterativo é a simulação de Monte Carlo. Em uma simulação de Monte Carlo, você geralmente tem um cálculo complexo , como a geração de preços de títulos, com base em algum valor de entrada aleatório, como o retorno esperado ao longo de vários anos. Uma simulação de Monte Carlo executa o mesmo cálculo milhares de vezes, cada vez com um valor de entrada aleatório diferente.

Esse é um cálculo iterativo porque cada vez que o preço é calculado, com um valor de entrada aleatório diferente, todo o cálculo é executado novamente. Esses cálculos são independentes; ou seja, em cada cálculo individual não há referência a nenhum cálculo anterior ou subsequente.

Outro exemplo comum envolve a execução de um cálculo em um conjunto de registros de um banco de dados. Neste caso, você pode ter um cálculo complexo , como um seguro ou modelo atuarial - que é baseado em alguns parâmetros, como a idade e o sexo de um detentor de apólice de seguro. O cálculo iterativo executará o mesmo modelo para milhares de titulares de políticas individuais. Cada cálculo é independente de todos os outros cálculos.

A estrutura de macro que estamos discutindo aqui foi projetada para trabalhar com esses tipos de cálculos iterativos. Isso é importante porque, quando executarmos um cálculo em um cluster HPC, executaremos o cálculo em paralelo . Executaremos o mesmo cálculo muitas vezes, mas executaremos várias instâncias do cálculo ao mesmo tempo nos nós de computação do cluster.

Se o cálculo não fosse independente , se os resultados de qualquer cálculo único dependessem dos cálculos anteriores que tínhamos executado , isso não funcionaria. Portanto, a estrutura que estamos discutindo aqui só é aplicável a cálculos iterativos e independentes , cálculos que podem ser paralelizados.

A Estrutura de Macro

Para dar suporte aos Serviços HPC para Excel, sua pasta de trabalho precisa incluir um conjunto de macros que implementam as funções assíncronas. Essa é a estrutura de macro. Há seis macros usadas na estrutura, que você pode adicionar a qualquer pasta de trabalho do Excel. As seis macros, com uma breve descrição do que fazem, são

(Não se preocupe se essas descrições não forem imediatamente claras: descreveremos cada uma dessas funções com mais detalhes abaixo).

As mesmas macros precisam ser adicionadas a qualquer planilha para dar suporte ao cálculo no cluster, mas o que está nas macros , as funções de cálculo específicas, pode ser diferente. Para simplificar o processo, os arquivos de download incluídos neste artigo incluem um arquivo de macro "esqueleto" que você pode importar para sua pasta de trabalho. Depois de ter as macros básicas em vigor, você poderá preenchê-las conforme necessário para dar suporte ao cálculo.

Cada macro tem uma finalidade específica na estrutura de macro e cada uma será chamada pela biblioteca de clientes do HPC Services para Excel durante um cálculo de cluster. Quando um cálculo é executado, cada macro será chamada em um ponto específico. Um cálculo típico é executado desta forma:

Quando um cálculo de cluster é executado, primeiro a biblioteca de clientes chamará a macro HPC_Initialize . Isso é usado para lidar com qualquer inicialização necessária; por exemplo, talvez você queira limpar os resultados antigos da planilha.

Em seguida, o cálculo é executado por três macros: HPC_Partition, HPC_Execute e HPC_Merge. No diagrama acima, eles são mostrados como um loop. Isso não é realmente o que acontece durante um cálculo, mas logicamente você pode pensar nisso como um loop. Primeiro, a biblioteca de clientes chama HPC_Partition. HPC_Partition foi projetado para coletar todos os dados necessários para uma única etapa de cálculo. Por exemplo, se você quiser calcular um conjunto de linhas um por um, HPC_Partition poderá retornar o número da linha para uma única etapa: primeira linha 1, linha 2 e assim por diante.

Em seguida, a macro HPC_Execute é chamada. Essa macro executa o cálculo real. Se estivermos calculando linha por linha, isso calculará uma única linha. HPC_Execute retornará o resultado do cálculo: por exemplo, ele pode retornar a última célula na linha que é o resultado final de um cálculo mais longo.

Após HPC_Execute, a biblioteca de clientes chamará HPC_Merge. O que HPC_Execute tiver calculado será enviado para HPC_Merge. A macro HPC_Merge foi projetada para levar esses resultados e devolvê-los à planilha em execução na área de trabalho. Na macro HPC_Merge , você pode inserir os resultados do cálculo de volta em sua planilha ou gravá-los em um arquivo de log.

Essas três macros -- HPC_Partition, HPC_Execute e HPC_Merge -- serão chamadas várias vezes, uma vez para cada etapa em seu cálculo, até que todo o cálculo seja concluído. Essas macros implementam o modelo de cálculo iterativo discutido acima. As macros podem ser chamadas muitas vezes durante um único cálculo de pasta de trabalho, mas cada vez que são chamadas representa uma única etapa de cálculo ou iteração.

Após a conclusão da última etapa de cálculo, a biblioteca de clientes chamará HPC_Finalize. Você pode usar essa macro para executar qualquer processamento pós-cálculo: por exemplo, talvez você queira encontrar a média de todas as etapas de cálculo anteriores usando outra macro do VBA.

A sexta e última macro, HPC_ExecutionError, só é usada quando o cálculo encontra algum erro. Nesse caso, essa macro é chamada e você pode adicionar algum código de tratamento de erros, por exemplo, você pode mostrar uma caixa de diálogo pop-up para o usuário avisando sobre o erro.

No diagrama acima, a macro HPC_Execute é realçada em laranja. Isso indica que essa macro é um pouco incomum. Todas as outras macros são executadas na área de trabalho, no Excel em sua estação de trabalho. No entanto, quando executamos um cálculo em um cluster HPC, a macro HPC_Execute é executada nos nós de computação do cluster.

É assim que os Serviços HPC para Excel e a estrutura de macro dão suporte ao cálculo do cluster. Embora escrevamos todas as macros na mesma pasta de trabalho , a pasta de trabalho na área de trabalho , quando o cálculo for executado, a pasta de trabalho será copiada para os nós de computação de cluster e a macro HPC_Execute será executada em um dos nós de computação.

É importante entender isso, pois ele tem algumas implicações para como as pastas de trabalho usam e gerenciam dados durante o cálculo. As três principais macros de cálculo – HPC_Partition, HPC_Execute e HPC_Merge – transmitem dados para frente e para trás durante o processo de cálculo. Em um aplicativo VBA típico, há muitas maneiras de compartilhar dados entre macros diferentes. Por exemplo, você pode usar variáveis globais em seu código VBA ou gravar valores em células de planilha. Mas quando estamos executando o cálculo em um cluster HPC, precisamos enviar dados entre as macros em execução na área de trabalho e a macro HPC_Execute em execução nos nós de computação.

Por esse motivo, todos os dados necessários para executar o cálculo devem ser enviados da macro HPC_Partition para a macro HPC_Execute diretamente. Fazemos isso usando o valor retornado da macro HPC_Partition . Esse valor retornado torna-se o argumento (ou parâmetro) para a função HPC_Execute . Portanto, os dados passarão diretamente entre essas duas macros e você poderá passar qualquer valor ou conjunto de valores (como uma Matriz) entre essas macros. Mas, novamente, você não pode usar variáveis globais ou células de planilha para passar informações entre as duas macros porque, quando ela é executada no cluster, na verdade há várias cópias da pasta de trabalho em execução ao mesmo tempo -- uma na área de trabalho e uma (ou mais) nos nós de computação do cluster.

Da mesma forma, quando o cálculo em HPC_Execute for concluído, ele retornará um resultado como o valor retornado da função de macro. Esse resultado se torna o argumento (ou parâmetro) para a próxima macro, HPC_Merge. Mais uma vez, todos os resultados que você deseja retornar , os resultados do cálculo, devem ser enviados dessa forma, como o valor retornado da função.

Criando pastas de trabalho Cluster-Enabled com o Excel e os Serviços HPC para Excel

Nas seções a seguir, vamos percorrer a criação de duas pastas de trabalho que dão suporte ao cálculo em um cluster HPC. Na primeira seção, criaremos uma pasta de trabalho do zero. Isso deve ajudá-lo a entender os conceitos envolvidos e os requisitos para usar os Serviços HPC para Excel. Na segunda seção, pegaremos uma pasta de trabalho existente, uma que foi projetada para ser executada na área de trabalho, e a converteremos para que ela possa ser executada no cluster.

Antes de começar: pré-requisitos e requisitos

O HPC Services para Excel é um conjunto de ferramentas incluídas no Microsoft HPC Pack 2008 R2 Beta 2 e versões posteriores. Você precisará de um cluster do Microsoft HPC Pack instalado e configurado. A instalação de um cluster HPC está fora do escopo deste artigo; Abordaremos apenas a configuração específica necessária para os Serviços HPC para Excel. Para obter mais informações sobre como instalar e configurar o cluster, consulte a documentação incluída no Microsoft HPC Pack. Na área de trabalho, você precisará dos utilitários de cliente do HPC Pack.

No cluster

Depois de ter um cluster HPC em execução, você precisará instalar o Excel nos nós de computação do cluster. Você pode usar o kit de instalação padrão do Office para instalar o Excel ou ver a documentação do HPC Pack para obter mais informações sobre como automatizar a instalação do Excel.

Depois que o Excel for instalado nos nós de computação do cluster, você poderá executar o teste de diagnóstico de HPC para garantir que tudo esteja configurado corretamente. Para executar o teste de diagnóstico, use o Gerenciador de Cluster de HPC (no nó principal do cluster, onde ele está instalado por padrão ou na área de trabalho se você instalou os utilitários do cliente).

Para verificar se o serviço HPC para Excel está configurado corretamente

1. No Gerenciador de Cluster do HPC, clique em Diagnóstico.

2. Em Testes, expanda a Microsoft e selecione o Excel.

3. No painel de exibição, clique duas vezes no Teste de Configuração do Excel Runner.

4. Na caixa de diálogo de configuração, selecione Todos os Nós e clique em Executar.

5. No Painel de Navegação, clique em Resultados de Teste para ver o progresso do teste. O teste que você está executando aparece no painel de exibição.

6. Depois que o teste for concluído, você poderá clicar no teste na janela principal para ver os resultados.

Se o teste mostrar Falha, clique duas vezes no teste e tente corrigir erros na janela pop-up. Os erros comuns que você pode ver são que o Excel não está instalado em um nó de computação ou que o Excel não foi ativado. Faça as alterações necessárias e execute novamente o teste de diagnóstico usando as instruções acima.

Quando o teste mostrar Sucesso, você estará pronto para continuar.

A última coisa que você precisará é de um diretório de compartilhamento. Quando calculamos uma pasta de trabalho em um cluster HPC, cada um dos nós de computação de cluster realmente carrega e executa uma cópia da pasta de trabalho. Para dar suporte a isso, você precisa criar um diretório de compartilhamento visível tanto para os nós de computação de cluster quanto para sua área de trabalho.

Se você tiver acesso ao nó principal do cluster, crie um diretório de compartilhamento no nó principal. Isso é conveniente porque você sabe que os nós de computação de cluster podem acessar o nó principal. Se você não puder criar um diretório de compartilhamento no nó principal, crie o diretório de compartilhamento em qualquer lugar dentro do domínio acessível tanto para sua área de trabalho quanto para os nós de computação de cluster.

Na área de trabalho

Na área de trabalho, você precisará instalar o Excel e os utilitários de cliente do Microsoft HPC Pack (instalar os utilitários do cliente exigirá permissões de Administrador). Para instalar os utilitários do cliente, execute o instalador do HPC Pack em sua área de trabalho. Ele oferecerá uma opção para instalar apenas os utilitários cliente.

Resumo

Agora você deve ter:

1. Um cluster do Microsoft HPC instalado e configurado.

2. Excel 2016 (ou posterior) instalado nos nós de computação do cluster.

3. Um diretório de compartilhamento de rede.

4. Excel 2016 (ou posterior) e os utilitários de cliente do Windows HPC Pack instalados em sua área de trabalho.

Quando tudo estiver pronto, você poderá começar a criar pastas de trabalho que são executadas no cluster com o HPC Services para Excel.

Parte I: Compilando uma pasta de trabalho do zero

Esta parte inclui as seguintes seções:

1. Iniciando uma nova pasta de trabalho

2. Preparando a pasta de trabalho

3. Projetando o cálculo do cluster

4. Executando a pasta de trabalho no cluster

5. Últimas Etapas: Interface do Usuário

Iniciando uma nova pasta de trabalho

Inicie o Excel com uma nova pasta de trabalho. Usaremos o VBA, portanto, verifique se você tem a guia Desenvolvedor disponível na faixa de opções do Excel.

Para ativar a guia Desenvolvedor

1. Clique na guia Arquivo na faixa de opções do Excel.

2. Clique em Opções.

3. Na caixa de diálogo de opções do Excel, selecione Personalizar Faixa de Opções à esquerda.

4. Marque a caixa ao lado do Desenvolvedor e clique em OK para fechar a caixa de diálogo.

Preparando a pasta de trabalho

Para preparar sua pasta de trabalho, você precisa importar os arquivos de macro e adicionar as referências de HPC.

Para criar a pasta de trabalho básica, precisaremos de dois conjuntos de macros. O primeiro conjunto de macros implementa as funções da estrutura (as funções descritas na seção Visão geral acima). Essas macros são usadas pela biblioteca de clientes do HPC Services para Excel durante o cálculo. O segundo conjunto de macros contém as funções de "controle" – essas macros executam o cálculo real.

Os arquivos de exemplo incluem arquivos de macro "esqueleto" básicos para cada um deles que você pode usar para começar. Você não precisa usar esses arquivos , você também pode escrever seus próprios, se preferir - mas as macros em si são genéricas, e você pode descobrir que usar esses arquivos é tudo o que você precisa. Você também pode modificar esses arquivos para fazer as alterações necessárias para sua pasta de trabalho específica.

Precisaremos adicionar duas referências a este projeto para usar os Serviços de HPC: Microsoft_Hpc_Excel e Microsoft_Hpc_Scheduler_Properties. Microsoft_Hpc_Excel é a biblioteca de clientes, que fornece um objeto que podemos usar para controlar um cálculo de cluster. Microsoft_Hpc_Scheduler_Properties tem definições para alguns campos e tipos específicos do cluster que precisaremos.

Observação: na seção Visão geral acima, descrevemos as ferramentas como uma estrutura cliente/servidor; a biblioteca de clientes foi instalada quando você instalou o SDK do HPC Pack e agora estará disponível no VBA.

Para importar os arquivos de macro e adicionar referências

1. Na guia Desenvolvedor da faixa de opções, clique em Visual Basic para abrir o editor do VBA.

2. No editor do VBA, clique com o botão direito do mouse no Projeto VBA na parte superior do modo de exibição de árvore e clique em Importar Arquivo.

3. Na caixa de diálogo, localize os arquivos de projeto que você baixou. Vá para o diretório "Primeira Pasta de Trabalho", selecione o arquivo "HPC Excel Macros.bas" e clique em OK. Isso adiciona o primeiro arquivo de macro ao seu projeto e ele estará disponível na pasta Módulos da janela de projeto do VBA.

4. Repita as etapas 1 a 3 para importar "HPC Control Macros.bas" e clique em OK. Isso adiciona o segundo arquivo de macro ao seu projeto.

5. Verifique se esses dois arquivos de macro aparecem na janela do projeto do VBA:

6. Na janela do editor do VBA, clique em Ferramentas e, em seguida, clique em Referências para abrir a caixa de diálogo referências do projeto.

7. Na lista de referências disponíveis, role para baixo até encontrar assemblies do HPC Pack da Microsoft (R) e marque a caixa de seleção ao lado de cada uma delas. Quando você marcar as caixas, a caixa de diálogo terá esta aparência:

8. Clique em OK para fechar a caixa de diálogo de referências do projeto.

Se você não encontrar essa entrada na lista, clique em Procurar.. e localize o arquivo %CCP_HOME%\Bin\Microsoft.Hpc.Excel.tlb. Se você ainda não conseguir encontrá-lo, verifique se instalou os componentes do cliente do HPC Pack. Se os arquivos estiverem instalados, o painel de controle Adicionar/Remover programas exibirá uma entrada para "Componentes do Cliente do Microsoft HPC Pack". Se você não vir essa entrada, tente reinstalar os componentes do cliente, conforme descrito na seção acima "Antes de iniciar".

Definindo os cálculos na estrutura de macro

Nosso objetivo na criação dessa pasta de trabalho é ilustrar como um cálculo de cluster funciona, portanto, não precisamos criar uma planilha muito complicada. Construiremos um cálculo que executa 100 etapas individuais. Para fazer isso, adicionaremos um contador ao arquivo de macros do HPC Excel e usaremos esse contador nas macros quando o cálculo for executado.

Usaremos o contador para acompanhar quantas etapas de cálculo foram enviadas, para que possamos limitar o cálculo a 100 etapas. HPC_Initialize é chamado sempre que iniciamos um novo cálculo, para que possamos redefinir o contador nessa função. Queremos incrementar o contador para cada etapa de cálculo. Podemos fazer isso na macro HPC_Partition . Lembre-se de que a macro HPC_Partition é usada para coletar todos os dados necessários para uma etapa de cálculo individual; e depois que o cálculo for concluído, a macro HPC_Partition deverá retornar Null. Portanto, para executar um cálculo para 100 etapas, incrementaremos o contador sempre que HPC_Partition for chamado; e quando o contador atingir 100, retornaremos Null.

Para construir um cálculo que execute 100 etapas

1. Na janela do projeto do VBA, na pasta Módulos , clique duas vezes em HPCExcelMacros.

2. Na parte superior do arquivo, na "Seção 1: Variáveis e constantes", adicione uma variável de contador chamada SentRecords, conforme mostrado abaixo:

   '==========================================================
   '
   ' Section 1: Variables and constants
   '
   '==========================================================
   
   Dim SentRecords As Integer
   

3. Role para baixo até encontrar a função HPC_Initialize e adicione uma linha para redefinir a variável de contador:

   '----------------------------------------------------------
   '
   ' HPC_Initialize will be called when the client starts
   ' a calculation. Put any pre-calculation steps in this
   ' function.
   '
   '----------------------------------------------------------
   
   Public Function HPC_Initialize()
   
    SentRecords = 0
   
   End Function
   

4. Role para baixo até encontrar a macro HPC_Partition e modifique-a para que ela fique assim:

   Public Function HPC_Partition() As Variant
   
       If SentRecords = 100 Then
           HPC_Partition = Null
       Else
           SentRecords = SentRecords + 1
           HPC_Partition = SentRecords
       End If
   
   End Function
   

5. Salve a pasta de trabalho.

Observação: como a nova pasta de trabalho inclui macros, você precisará salvá-la como uma pasta de trabalho habilitada para macro (arquivo XLSM) ou uma pasta de trabalho binária (arquivo XLSB). Qualquer um está bem. Normalmente, recomendamos salvar pastas de trabalho como arquivos binários (XLSB), pois elas são menores e um pouco mais eficientes.

Agora temos um cálculo que executará 100 etapas e, em seguida, será concluído. As modificações feitas são tudo o que você precisa fazer para criar um cálculo de cluster do Excel.

Executando a pasta de trabalho localmente e explorando as macros

Agora que temos um cálculo, podemos adicionar um botão para executar a pasta de trabalho e, em seguida, executar a pasta de trabalho na área de trabalho. Para ver como as macros funcionam, adicionaremos algumas novas partes de código ao nosso esqueleto de macro e executaremos novamente a pasta de trabalho para ver o que as alterações fizeram. Testaremos a pasta de trabalho localmente (na área de trabalho) antes de executarmos a pasta de trabalho no cluster.

Adicionando um botão que executa a pasta de trabalho localmente

Para adicionar um botão que executa a pasta de trabalho localmente

1. Com a pasta de trabalho do Excel aberta, clique na guia Desenvolvedor na faixa de opções.

2. Na guia Desenvolvedor , clique em Inserir e, em seguida, selecione o controle de botão – o primeiro controle na lista.

3. Depois de clicar no botão, desenhe um retângulo em algum lugar na planilha para inserir o botão nesse local. Depois de posicionar o botão, a caixa de diálogo Atribuir Macro será exibida.

4. Na caixa de diálogo, selecione a macro CalculateWorkbookOnDesktop na lista e clique em OK. Selecione a macro da área de trabalho– queremos testar a pasta de trabalho primeiro e encontrar erros antes de executá-la no cluster.

5. Clique com o botão direito do mouse no novo botão e selecione Editar Texto para alterar o rótulo.

6. Nomeie o rótulo "Desktop" ou algo semelhante.

7. Opcionalmente, você pode verificar se atribuiu a macro correta clicando com o botão direito do mouse e selecionando Atribuir Macro. Na caixa de diálogo, verifique se CalculateWorkbookOnDesktop está selecionado.

8. Salve a pasta de trabalho.

9. Clique no botão para executar a pasta de trabalho na área de trabalho.

Se houver erros, você verá uma caixa de diálogo de erro e a parte do código VBA com o erro será realçada. Volte para as seções acima e verifique se tudo parece correto.

Se tudo estiver funcionando, nada acontecerá porque nossa pasta de trabalho não faz nada. Isso é um pouco insatisfatório, então vamos fazer mais algumas alterações para que possamos ver o cálculo.

Modificando o HPC_Excecute e as macros de HPC_Merge

Lembre-se de que o fluxo de informações vai de HPC_Partition (que coleta os parâmetros necessários para o cálculo), para HPC_Execute (que executa o cálculo) e, em seguida, para HPC_Merge (que processa o resultado). Quando um cálculo é executado, o que for retornado da macro HPC_Partition será usado como entrada para a macro HPC_Execute . A macro HPC_Execute foi projetada para usar esses dados de entrada, executar algumas etapas de cálculo e retornar um resultado. Em seguida, o resultado passa para HPC_Merge, que pode inserir os resultados na planilha.

Em uma etapa anterior, você adicionou código à macro HPC_Partition para atualizar uma variável de contador. Portanto, em nosso exemplo, HPC_Partition retorna o valor da variável de contador e passa esse valor para HPC_Execute. Para ilustrar o fluxo de informações e fazer com que nossa pasta de trabalho retorne alguns resultados, simplesmente passaremos esse valor de contador pelas macros. Adicionaremos uma linha de código à macro HPC_Execute para que ela use a entrada e a passe como o valor retornado. O valor de nossa variável de contador passa para a macro HPC_Merge , que modificaremos para que insira o valor do contador em nossa planilha.

Para modificar HPC_Execute e HPC_Merge

1. Na guia Desenvolvedor da faixa de opções, clique em Visual Basic para abrir o editor do VBA.

2. No editor do VBA, na árvore de projeto, clique duas vezes no módulo HPCExcelMacros para abrir o arquivo de macro.

3. . Role até a macro HPC_Execute e adicione uma linha de código que passe o valor de entrada como o valor retornado. A macro deve ter esta aparência:

   Public Function HPC_Execute(data As Variant) As Variant
   
       HPC_Execute = data
   
   End Function
   

4. Role até a macro HPC_Merge e adicione uma linha de código para inserir o valor de entrada na planilha. A macro deve ter esta aparência:

   Public Function HPC_Merge(data As Variant)
   
       Cells(data, 1).Value = data
   
   End Function
   
   

   Observação: o valor "dados" é o contador, que foi retornado de HPC_Execute. Então, aqui na macro HPC_Merge , estamos preenchendo uma célula na planilha usando o contador como o número da linha e definindo o valor como o contador. A expressão "Células" do VBA significa criar uma referência na planilha com os números de linha e coluna especificados. Portanto, sempre que a macro HPC_Merge for chamada, ela inserirá um valor na coluna 1 (coluna A na planilha), com um número de linha diferente.

5. Agora volte para a planilha e clique no botão "Área de Trabalho" para executar o cálculo.

Você verá a primeira coluna preenchida com números de 1 a 100, que são os valores do contador. Toda vez que você clicar no botão, ele preencherá os mesmos números, portanto, é difícil dizer que ele está em execução; podemos fazer mais uma pequena alteração para ver os números que estão preenchendo.

Modificando a macro HPC_Initialize

A macro HPC_Initialize é chamada quando executamos a pasta de trabalho pela primeira vez. Em uma etapa anterior, adicionamos uma linha de código para redefinir a variável de contador. Também podemos usar essa macro para apagar os valores que foram inseridos na planilha durante a execução anterior.

Para modificar a macro HPC_Initialize

1. Na guia Desenvolvedor da faixa de opções, clique em Visual Basic para abrir o editor do VBA.

2. No editor do VBA, na árvore de projeto, clique duas vezes no módulo HPCExcelMacros para abrir o arquivo de macro.

3. Role até a macro HPC_Initialize **.** Adicione uma linha de código que esvazia a primeira coluna. A macro deve ter esta aparência:

   Public Function HPC_Initialize()
   
       Range("A:A").Value = ""
       SentRecords = 0
   
   End Function
   

4. Agora volte para a planilha e clique no botão "Área de Trabalho" para executar o cálculo.

Agora deve ser óbvio que a macro está preenchendo a coluna com números sempre que você clicar nela. Se houver erros, você verá uma mensagem de erro e o código VBA com o erro será realçado. Verifique se ele corresponde ao código listado acima e tente novamente.

Executando a pasta de trabalho no cluster

Agora temos um cálculo muito simples do Excel usando a estrutura de macro HPC e podemos executá-la no cluster. Para fazer isso, primeiro precisaremos definir alguns valores para informar ao Excel como contatar o cluster. Esses valores são definidos no módulo HPCControlMacros **.** Na parte superior desse arquivo, há dois valores que você precisará preencher: o agendador de cluster e o diretório de compartilhamento. Lembre-se de que você (o usuário da área de trabalho) deve ter acesso de gravação a este diretório de compartilhamento; e os nós de computação de cluster devem ter acesso de leitura ao diretório. Na maioria dos casos, os cálculos do cluster serão executados em sua conta de usuário, mas é possível usar uma conta de usuário diferente quando você se conectar à sessão do cluster (mais sobre isso em um momento).

Para especificar o nó principal e o diretório de compartilhamento

1. Na guia Desenvolvedor da faixa de opções, clique em Visual Basic para abrir o editor do VBA.

2. No editor do VBA, na árvore de projeto, clique duas vezes no módulo HPCControlMacros para abrir o arquivo de macro.

3. Para o agendador de cluster, use o nome do nó principal do cluster. Esse é o nome do computador que você usaria na rede. Você pode usar um nome totalmente qualificado (por exemplo, headnode.mynetwork.com), mas isso não é necessário se você estiver no mesmo domínio.

4. Para o diretório de compartilhamento, use o caminho completo para o diretório de compartilhamento que você criou anteriormente (na seção "Antes de Começar").

Por exemplo, no meu cluster, o nome do agendador é "HN01"; e criei um diretório de compartilhamento no nó principal chamado "HPCTemp". Portanto, minhas configurações são semelhantes a esta:

'----------------------------------------------------------
'
' This is the cluster scheduler, or head node.  Fill in
' the hostname of your cluster scheduler.
'
'----------------------------------------------------------
Private Const HPC_ClusterScheduler = "HN01"

'----------------------------------------------------------
'
' This is a network share used to store a temporary copy
' of the workbook.  Make sure that the directory exists,
' that you have write access to the directory, and that
' the compute nodes in the cluster have read access.
'
'----------------------------------------------------------
Private Const HPC_NetworkShare = "\\HN01\HPCTemp"

Agora volte para a planilha do Excel. Adicionaremos outro botão, desta vez para executar o cálculo no cluster.

Para adicionar um botão que executa a pasta de trabalho no cluster

1. Na guia Desenvolvedor , clique em Inserir e, em seguida, selecione o controle de botão – o primeiro controle na lista.

2. Depois de clicar no botão, desenhe um retângulo em algum lugar na planilha para inserir o botão nesse local. Depois de posicionar o botão, a caixa de diálogo Atribuir Macro será exibida.

3. Na caixa de diálogo, selecione a macro CalculateWorkbookOnCluster na lista e clique em OK.

4. Clique com o botão direito do mouse no novo botão e selecione Editar Texto para alterar o rótulo.

5. Nomeie o rótulo "Cluster" ou algo semelhante.

6. Salve a pasta de trabalho.

7. Clique no botão para executar a pasta de trabalho no cluster.

8. Se esta for a primeira vez que você executar qualquer trabalho de cluster, usando o Excel ou usando qualquer outro aplicativo, você verá uma caixa de diálogo de autenticação do usuário. Digite seu nome de usuário e senha e (se desejar) marque a caixa para salvar suas credenciais. Se você quiser executar cálculos no cluster como um usuário diferente, poderá inserir diferentes configurações de conta de usuário.

Observação: certifique-se de que sua conta de usuário - sua conta de usuário padrão ou o que você deseja usar - seja designada como um usuário de cluster no Gerenciador de Cluster do HPC.

Se houver erros, você verá uma caixa de mensagem descrevendo o erro. Se o cálculo funcionou na área de trabalho, os erros mais prováveis que você receberá agora terão a ver com as configurações do cluster: o nó principal ou o diretório de compartilhamento. Se a caixa de mensagem descrever um desses erros, marque duas vezes as configurações que você alterou na última etapa. Verifique se você tem o nome correto para o nó principal do cluster e se o diretório de compartilhamento é gravável por sua conta de usuário.

O que acontece quando uma pasta de trabalho é executada no cluster

Vamos examinar o que acontece quando você executa o cálculo do cluster. Quando você clica no botão, ele chama a macro CalculateWorkbookOnCluster. Essa macro usa a biblioteca de clientes para iniciar um cálculo de cluster com as configurações fornecidas para o nó principal do cluster e o diretório de compartilhamento.

Quando o cálculo é iniciado, o código do cliente HPC Services para Excel assume o comando. Lembre-se de que você adicionou uma referência à biblioteca HPC no editor do VBA no início desta parte, que é a biblioteca de clientes. Primeiro, a biblioteca de clientes criará uma "sessão" de cluster, usada para gerenciar o cálculo. Isso leva alguns segundos e, depois de clicar no botão, você observará alguns segundos de atraso.

Em seguida, a biblioteca de clientes chamará a macro HPC_Initialize . Isso acontece na área de trabalho. Nesta pasta de trabalho, essa macro (1) redefine o contador interno; e (2) esvazia a coluna A na planilha. Portanto, ao clicar no botão, primeiro você verá o atraso à medida que a sessão for criada; e, em seguida, você verá que a coluna A está desmarcada. Essa é a macro HPC_Initialize .

Em seguida, a biblioteca de clientes começará a chamar a macro HPC_Partition . Isso também acontece na área de trabalho. Em nosso código, a macro HPC_Partition incrementa o contador e retorna o valor do contador. Sempre que essa macro retornar um valor , até retornar Null, na última chamada, a biblioteca de clientes enviará uma solicitação para o agendador de HPC.

Quando o agendador receber uma dessas solicitações, ele encaminhará a solicitação para um dos nós de computação do cluster para processamento. Quando o nó de computação receber a solicitação, ele iniciará o Excel, carregará a pasta de trabalho e chamará a macro HPC_Execute .

Essa é a macro HPC_Execute que temos em nossa pasta de trabalho, mas quando o cálculo é executado no cluster, a macro HPC_Execute é realmente executada nos nós de computação, ao contrário de todas as outras macros. É por isso que estamos passando dados de uma macro para outra. As informações fluem de uma macro para a próxima, mas à medida que os dados são passados da macro HPC_Partition para a macro HPC_Execute , ela é enviada da área de trabalho, por meio do agendador HPC e para um dos nós de computação.

Depois que um dos nós de computação executa a macro HPC_Execute , quando a macro é concluída, o resultado do cálculo , o valor retornado da macro HPC_Execute , é enviado de volta para o agendador e, em seguida, retornado para a biblioteca de clientes na área de trabalho. Quando a biblioteca de clientes receber o resultado do cálculo, ela chamará a macro HPC_Merge na área de trabalho. Então, mais uma vez, você pode pensar em informações que fluem de uma macro (HPC_Execute) para a próxima (HPC_Merge), mas isso está acontecendo pela rede: da pasta de trabalho em execução no nó de computação à pasta de trabalho em execução na área de trabalho.

É importante entender que essas chamadas de função de macro – cada uma das chamadas para HPC_Partition, à medida que enviamos dados para o cluster e cada uma das chamadas para HPC_Merge, à medida que os dados são recebidos – ocorrem de forma assíncrona. Ou seja, quando um cálculo é enviado para o cluster, a biblioteca de clientes não aguardará (ou bloqueará) até que esse cálculo específico seja concluído antes de enviar o próximo. Se a macro HPC_Partition for muito rápida, como é nesse caso, é possível que todas as 100 solicitações de cálculo sejam enviadas antes que qualquer uma dessas solicitações seja concluída.

Também vale a pena observar que, como os resultados voltam do cluster e a macro HPC_Merge é chamada em nossa pasta de trabalho, eles podem não voltar na mesma ordem que os enviamos. Isso porque, como cada solicitação é enviada para o cluster, o agendador o encaminhará para um nó de computação específico. O nó de computação calculará a solicitação usando a macro HPC_Execute na pasta de trabalho e, em seguida, enviará de volta o resultado. Porém, por vários motivos, um nó de computação pode ser executado mais lentamente ou mais rapidamente do que outro nó de computação; e se isso acontecer, os resultados poderão ser retornados em uma ordem diferente.

Você provavelmente não observará isso nesta pasta de trabalho, pois as macros são tão simples. Mas é algo para o qual teremos que nos preparar em pastas de trabalho mais complicadas, pois temos funções de cálculo mais longas e abordaremos isso abaixo quando criarmos uma pasta de trabalho "real".

Comunicando o progresso do cálculo

Neste ponto, você criou uma pasta de trabalho completa que é executada no cluster HPC; agora você deve entender o que as várias macros fazem e por que elas foram projetadas da maneira como são. Você deve ter uma noção de como os dados se movem entre as macros e quais partes são executadas na área de trabalho e no cluster.

Antes de terminarmos com a pasta de trabalho simples, podemos fazer algumas alterações finais para adicionar alguns comentários visuais, basicamente uma interface do usuário simples. Quando você executou a pasta de trabalho no cluster, os únicos comentários que você tinha de que ele estava funcionando eram os números preenchidos na planilha. Isso é um começo, mas podemos fazer algumas mudanças que tornarão mais óbvio o que a pasta de trabalho está fazendo. O que vamos fazer é adicionar mais algumas variáveis para acompanhar o cálculo e exibi-las na barra de status do Excel.

Nosso código incluirá os seguintes contadores:

• Já temos uma variável de contador que controla o número de vezes que HPC_Partition macro foi chamada. Isso representa o número de vezes que os dados foram enviados da área de trabalho para o cluster.

• Podemos adicionar outro contador incrementado sempre que a macro HPC_Merge for chamada, que representa quantas vezes os dados voltaram do cluster para a área de trabalho.

• Também podemos adicionar algumas variáveis para acompanhar o tempo – quanto tempo o cálculo leva. Isso pode ser realmente útil para verificar se o cálculo do cluster é de fato mais rápido do que a área de trabalho (e, em caso afirmativo, quanto mais rápido).

Usando esses primeiros dois contadores, podemos ver o número de solicitações pendentes e ter uma noção do progresso geral do cálculo. Adicionaremos uma nova função VBA que pode relatar o status do cálculo. Essa função tem três partes:

• Ele cria uma cadeia de caracteres mostrando o número de cálculos enviados (o número de vezes HPC_Partition foi chamado) e o número de resultados recebidos novamente (o número de vezes HPC_Merge foi chamado).

• Se a variável "CalculationComplete" for verdadeira, ela atualizará a cadeia de caracteres para mostrar o tempo total de cálculo.

• Ele usa Application.StatusBar para definir a mensagem da barra de status do Excel com as informações que acabamos de criar.

Podemos usar as macros HPC que já estão em vigor para atualizar esses valores e atualizar a mensagem da barra de status com a nova função.

O procedimento a seguir descreve como incorporar esses novos elementos em nosso exemplo.

Para adicionar variáveis de progresso às macros e atualizar a barra de status do Excel

1. Volte para o editor do VBA e clique duas vezes no módulo HPCExcelMacros para abrir o código de macro. Na parte superior do código VBA, após o contador original, adicione estas novas variáveis:

   '==========================================================
   '
   ' Section 1: Variables and constants
   '
   '==========================================================
   
   Dim SentRecords As Integer
   Dim RcvRecords As Integer
   Dim CalculationComplete As Boolean
   Dim StartTime As Double
   Dim FinishTime As Double
   

2. Em seguida, adicionaremos uma nova função VBA chamada "UpdateStatus" que pode relatar o status do cálculo. Role para baixo até a parte inferior do arquivo e adicione o código da seguinte maneira:

   Sub UpdateStatus()
   
       Dim statusMessage As String
       statusMessage = "Calculated " & RcvRecords & "/" & SentRecords
   
       If CalculationComplete Then
           statusMessage = statusMessage & "; Completed in " & _
              FormatNumber(FinishTime - StartTime) & "s"
       End If
   
       Application.StatusBar = statusMessage
   
   End Sub
   

3. Precisamos inicializar as variáveis. Assim como acontece com o contador original, faremos isso na macro HPC_Initialize . Role até essa macro e adicione algumas linhas:

   Public Function HPC_Initialize()
   
       Range("A:A").Value = ""
       SentRecords = 0
       RcvRecords = 0
       StartTime = Timer
       CalculationComplete = False
       UpdateStatus
   
   End Function
   

   Observação: o que estamos fazendo aqui é (1) limpar os dois contadores, definindo-os como zero; (2) definir o valor "StartTime" como a hora atual (a chamada "Temporizador" no VBA retorna a hora atual, em segundos); e (3) definir o sinalizador "CalculationComplete" como false, o que significa que ele ainda não foi concluído. Depois que esses valores são definidos, chamamos a nova macro "UpdateStatus" para gravar a mensagem na barra de status.

4. Role para baixo até a macro HPC_Partition . Nesta macro, já estamos definindo o primeiro contador, portanto, só precisamos fazer uma alteração: depois de atualizar o contador, adicionamos uma linha para chamar a nova macro e atualizar a barra de status.

   Public Function HPC_Partition() As Variant
   
       If SentRecords = 100 Then
           HPC_Partition = Null
       Else
           SentRecords = SentRecords + 1
           UpdateStatus
           HPC_Partition = SentRecords
       End If
   
   End Function
   

5. Agora role para baixo até a macro HPC_Merge . Aqui, queremos atualizar o novo contador , aquele que representa as mensagens retornadas para a área de trabalho , e atualizar novamente a barra de status. Portanto, modifique a macro HPC_Merge :

   Public Function HPC_Merge(data As Variant)
   
       Cells(data, 1).Value = data
       RcvRecords = RcvRecords + 1
       UpdateStatus
   
   End Function
   

6. Role para baixo até a macro HPC_Finalize . Essa macro é chamada quando todo o cálculo é concluído; para que possamos usar isso para definir o sinalizador "CalculationComplete", bem como para descobrir quanto tempo o cálculo total levou:

   Public Function HPC_Finalize()
   
       CalculationComplete = True
       FinishTime = Timer
       UpdateStatus
   
       ' Clean up the calculation.  It's a good idea to
       ' leave this here, even if you make changes to
       ' this function.  The function we call here is in
       ' the "HPCControlMacros" module.
   
       CleanUpClusterCalculation
   
   End Function
   

   Observação: quando definimos o campo "FinishTime" como Temporizador, estamos definindo-o com o tempo atual, em segundos. Na macro UpdateStatus, estamos usando "StartTime" e "FinishTime" para descobrir o tempo total de cálculo.

7. Salvar a pasta de trabalho

8. Volte para a planilha do Excel e clique no botão "Cluster".

Você verá a atualização da barra de status com números conforme o cálculo é executado; primeiro, você verá o número de cálculos enviados (o segundo número) saltar para 100 e, depois de um breve atraso, verá o número de resultados recebidos (o primeiro número) subir até 100.

O que você está vendo aqui é a mensagem assíncrona que discutimos acima. Como a macro HPC_Partition é tão rápida, a biblioteca de clientes é capaz de enviar todas as 100 solicitações antes que qualquer um dos cálculos seja concluído. Há um breve atraso -- esse atraso são os nós de computação iniciando o Excel e carregando a pasta de trabalho. Depois que cada nó de computação tiver iniciado o Excel, calcular os resultados será muito rápido e o primeiro número obterá até 100 rapidamente.

Se você clicar no botão "Área de Trabalho", verá que os números se movem de uma maneira diferente. Na área de trabalho, a biblioteca de clientes está chamando as mesmas macros, mas está fazendo isso de forma síncrona (ou seja, não de forma assíncrona). Para executar o cálculo da área de trabalho, a biblioteca de clientes chamará cada macro por sua vez – primeiro HPC_Partition, depois HPC_Execute e, em seguida, HPC_Merge – mas, nesse caso, aguardará a conclusão de cada macro antes de chamar a próxima. É por isso que, ao executar na área de trabalho, você verá os dois números se movendo juntos.

Parte 2: Converter uma pasta de trabalho "desktop" para ser executada no cluster HPC

Na última seção, criamos uma pasta de trabalho do zero para calcular em um cluster HPC. Nesta seção, pegaremos uma pasta de trabalho existente e a modificaremos para serem executadas no cluster. Se você seguiu a última parte, você deve ter uma compreensão do que é necessário - embora houvesse um monte de etapas individuais, o trabalho real envolvido era muito simples. Em resumo, nós:

• Adicionados dois arquivos de macro.

• Adicionadas duas referências ao projeto do VBA.

• Fez algumas modificações nas macros.

• Botões adicionados para executar a planilha.

A conversão de uma pasta de trabalho existente é quase a mesma quantidade de trabalho. Não há muito código VBA novo a ser adicionado e a maioria se ele puder reutilize os mesmos arquivos de macro esqueleto. Na maioria das vezes, a conversão de uma pasta de trabalho existente envolve a movimentação de código , copiando código de macros existentes para as macros HPC.

A parte difícil de converter uma pasta de trabalho existente é descobrir qual código mover e para onde ela deve ir. O VBA do Excel é um ambiente de desenvolvimento abrangente e há muitas maneiras de criar aplicativos do Excel: desenvolvedores diferentes podem escrever o mesmo aplicativo de várias maneiras diferentes.

Nesta seção, vamos pegar uma pasta de trabalho existente e convertê-la para ser executada no cluster. Você deve ler esta seção como um guia ou como exemplo e, em seguida, tentar aplicar os conceitos às suas próprias pastas de trabalho. Temos um exemplo bastante simples nesse caso (embora seja baseado em uma pasta de trabalho real que foi usada para resolver um problema de negócios real). Para praticamente qualquer pasta de trabalho, o processo será o mesmo, mas os detalhes específicos serão diferentes.

Analisando a pasta de trabalho

No Excel, abra a pasta de trabalho "ConversívelPricing.xlsb" no diretório "Segunda Pasta de Trabalho". Você pode receber um aviso sobre macros; em caso afirmativo, clique em "habilitar macros" para continuar.

Esta pasta de trabalho calcula os preços dos títulos conversíveis, com base nos valores na seção "Parâmetros de Modelo" à esquerda. A tabela à direita é usada para entender o efeito que pequenas alterações nos parâmetros -- alterações no preço de conversão e na taxa de cupom -- terão no preço final.

Clique no botão "Calcular Tabela" na planilha. Você verá a tabela preencher, lentamente, conforme cada preço é calculado. Em uma estação de trabalho típica, o preenchimento da tabela completa levará entre 1 e 2 minutos.

Para descobrir o que essa pasta de trabalho faz quando clicamos no botão, podemos percorrer o código VBA.

Para identificar a macro e ver o código

1. Clique com o botão direito do mouse no botão "Calcular Tabela" e selecione Atribuir Macro.

2. A caixa de diálogo macro mostra qual macro é usada no momento pelo botão. Na caixa de diálogo, clique em Editar para entrar no código. Você deve ver o código para a macro "CalculateTable". Esse é o código executado quando você clica no botão na planilha.

Olhando para essa macro, você pode ver algumas seções distintas. Primeiro, há algumas declarações variáveis. Em seguida, há algum código de inicialização. Por fim, há uma seção que calcula a tabela– podemos identificar onde ela faz loops sobre as linhas e colunas na tabela e preenche os valores.

Essa macro é bastante curta, mas se você olhar para o loop, verá que ela chama algumas outras funções: as funções "FullDiscountModel" e "BondPlusOptionModel". Essas são as rotinas de cálculo reais, a lógica de negócios que alimenta essa pasta de trabalho.

No editor do VBA, você pode ir para a origem de qualquer função clicando com o botão direito do mouse no nome e selecionando "Definição". Se você clicar com o botão direito do mouse em "FullDiscountModel" e selecionar "Definição", verá que o cálculo real é bastante complexo. Mas, para converter a pasta de trabalho a ser executada no cluster, não precisamos modificar nem mesmo entender esse cálculo. Só precisamos nos preocupar com o código de controle, ou seja, a função que contém o loop.

Esta pasta de trabalho foi projetada de forma muito limpa, na qual a lógica de negócios está contida em funções separadas. Em outros casos, todo esse código pode estar em uma única macro, o que tornaria a pasta de trabalho mais difícil de entender. Mas, em ambos os casos, o que teremos que fazer para converter essa pasta de trabalho é pegar o código de controle , as rotinas de inicialização e as funções de loop, e movê-los para as macros HPC.

Também sabemos que, nesta pasta de trabalho, os cálculos são independentes. Ou seja, cada célula da tabela é calculada sem referência a nenhuma outra célula na tabela. Isso significa que a pasta de trabalho é iterativa e dará suporte à paralelização (conforme discutido na seção Visão geral, acima). Pode nem sempre ser óbvio que os cálculos são independentes. Uma maneira de descobrir isso é escrever algumas funções de teste , por exemplo, poderíamos gravar novamente a macro "CalculateTable" (a macro que é chamada quando você pressiona o botão na planilha) -- para executar apenas um único cálculo ou uma célula na tabela. Dessa forma, poderíamos identificar se os resultados eram consistentes e, nesse caso, poderíamos determinar se os cálculos eram de fato independentes.

Para resumir, os recursos mais importantes para qualquer pasta de trabalho dar suporte à execução em um Cluster do Microsoft HPC são os seguintes:

• A pasta de trabalho é iterativa: ela executa o mesmo cálculo muitas vezes, com diferentes conjuntos de dados de entrada; ou executa muitos cálculos individuais, como linhas ou células em uma tabela, um de cada vez.

• Os cálculos individuais são independentes: ou seja, os resultados de um único cálculo não afetam nenhum dos outros cálculos.

Ambos são verdadeiros para esta pasta de trabalho, portanto, é um bom candidato para a execução no cluster.

Preparando a pasta de trabalho

Como na última pasta de trabalho, as primeiras alterações que faremos terão a ver com a configuração do ambiente do VBA. Podemos usar arquivos de macro esqueleto para economizar algum tempo . Isso incluirá as macros HPC que precisaremos para o cálculo.

Na última pasta de trabalho, fizemos algumas alterações nos arquivos de macro esqueleto para adicionar alguns comentários do usuário (exibindo o progresso do cálculo na barra de status do Excel). Nesta segunda pasta de trabalho, os arquivos de macro esqueleto já incluem esse código de barra de status.

Para importar os arquivos de macro e adicionar referências

1. Na guia Desenvolvedor da faixa de opções, clique em Visual Basic para abrir o editor do VBA.

2. No editor do VBA, clique com o botão direito do mouse no Projeto VBA na parte superior do modo de exibição de árvore e clique em Importar Arquivo.

3. Na caixa de diálogo, localize os arquivos de projeto que você baixou. Vá para o diretório "Segunda Pasta de Trabalho", selecione o arquivo "HPCExcelMacros.bas" e clique em OK.

   

4. Repita as etapas 1 a 3 para importar "HPCControlMacros.bas" e clique em OK. Isso adiciona o segundo arquivo de macro ao seu projeto.

5. Verifique se esses dois arquivos de macro aparecem na janela do projeto do VBA:

6. Na janela do editor do VBA, clique em Ferramentas e, em seguida, clique em Referências para abrir a caixa de diálogo referências do projeto.

7. Na lista de referências disponíveis, role para baixo até encontrar assemblies do HPC Pack da Microsoft (R) e marque a caixa de seleção ao lado dela. Quando você marcar a caixa, a caixa de diálogo terá esta aparência:

8. Clique em OK para fechar a caixa de diálogo de referências do projeto.

Definindo os cálculos na estrutura de macro

Com o ambiente do VBA configurado, podemos passar para a próxima etapa: modificar as macros para executar o cálculo. O módulo HPCExcelMacros inclui as mesmas macros da primeira pasta de trabalho, só que desta vez eles já incluem os contadores e o código para atualizar a barra de status.

Definindo variáveis e copiando código de inicialização da macro original

As primeiras coisas que precisaremos são contadores para a linha e a coluna. Nesta pasta de trabalho, estamos dividindo o cálculo para que cada célula na tabela seja calculada separadamente. A macro original usava loops para executar cada célula na tabela, mas nas funções de macro HPC estamos usando a estrutura assíncrona, portanto, precisamos acompanhar os números de linha e coluna à medida que enviamos cada cálculo individual. Usaremos variáveis de linha e coluna nas macros para percorrer cada célula da tabela; eles refletem a linha e a coluna que estamos calculando em cada etapa.

Voltaremos à macro original para ver o que ela fez quando começou e, em seguida, movê-la para a macro HPC_Initialize .

Para definir variáveis e modificar HPC_Initialize

1. Na guia Desenvolvedor da faixa de opções, clique em Visual Basic para abrir o editor do VBA.

2. No editor do VBA, na árvore de projeto, clique duas vezes no módulo HPCExcelMacros para abrir o arquivo de macro.

3. Na parte superior do arquivo, na "Seção 1: Variáveis e constantes", adicione variáveis de linha e coluna, conforme mostrado abaixo:

   '==========================================================
   '
   ' Section 1: Variables and constants
   '
   '==========================================================
   
   Dim CurrentRow As Integer
   Dim CurrentCol As Integer
   
   Dim SentRecords As Integer
   Dim RcvRecords As Integer
   Dim CalculationComplete As Boolean
   Dim StartTime As Double
   Dim FinishTime As Double
   

4. Role até a macro HPC_Initialize e inicialize os contadores de linha e coluna que acabamos de configurar:

   Public Function HPC_Initialize()
   
       CurrentRow = 1
       CurrentCol = 1
   
       ' clear counters, capture starting time and update status bar
   
       SentRecords = 0
       RcvRecords = 0
       StartTime = Timer
       CalculationComplete = False
       UpdateStatus
   
   End Function
   
   

5. No editor do VBA, clique duas vezes no módulo "ScenarioAnalysis" na janela do projeto do VBA. Esse era o arquivo que contém o código de macro original. A parte de inicialização é a primeira seção, que calcula o tamanho da tabela e define algumas variáveis (NumRows e NumCols):

       ' clear values, then figure out the size of the table
   
       Range("cashtable").ClearContents
   
       NumCols = 1
       While NumCols < MaxSensTblSize And CDbl(Range("table1").Offset(0, NumCols …
           NumCols = NumCols + 1
       Wend
       NumRows = 1
       While NumRows < MaxSensTblSize And _
          CDbl(Range("table1").Offset(NumRows + 1, 0).Value) <> 0 And _
          CDbl(Range("table1").Offset(NumRows + 1, 0).Value) <> …
           NumRows = NumRows + 1
       Wend
   

6. Copie o código da macro original e volte para o módulo HPCExcelMacros (clique duas vezes em HPCExcelMacros na janela do projeto do VBA) e cole-o na macro HPC_Initialize .

O código final no HPC_Initialize agora tem esta aparência:

Public Function HPC_Initialize()
    
    ' clear values, then figure out the size of the table
    
    Range("cashtable").ClearContents
    
    NumCols = 1
    While NumCols < MaxSensTblSize And CDbl(Range("table1").Offset(0, NumCols + …
        NumCols = NumCols + 1
    Wend
    NumRows = 1
    While NumRows < MaxSensTblSize And _
       CDbl(Range("table1").Offset(NumRows + 1, 0).Value) <> 0 And _
       CDbl(Range("table1").Offset(NumRows + 1, 0).Value) <> …
        NumRows = NumRows + 1
    Wend
    
    CurrentRow = 1
    CurrentCol = 1
    
    ' clear counters, capture starting time and update status bar
    
    SentRecords = 0
    RcvRecords = 0
    StartTime = Timer
    CalculationComplete = False
    UpdateStatus
    
End Function

Modificando a macro HPC_Partition

A próxima macro a ser modificada é a macro HPC_Partition . Lembre-se de que essa macro coleta todos os dados necessários para executar um único cálculo. Nesse caso, esse será o número da linha e da coluna. Para esta pasta de trabalho, queremos calcular cada célula de tabela individual no cluster separadamente; e, para fazer isso, usaremos a linha e o número da coluna.

Todas as macros na estrutura HPC usam o tipo de dados Variant para entradas e saídas. O tipo Variant pode ser qualquer tipo primitivo (inteiro, longo, duplo, cadeia de caracteres) ou uma Matriz desses tipos. Precisamos incluir a linha e a coluna, para que possamos usar uma Matriz.

A outra coisa que precisamos fazer na macro HPC_Partition é descobrir quando o cálculo é concluído. Nesse caso, o cálculo será concluído quando chegarmos ao final da tabela. Podemos fazer isso incrementando os números de linha e coluna à medida que nos movemos pela tabela. Sempre que chegarmos ao final de uma coluna, vamos para a próxima coluna. Quando passarmos a última coluna, a tabela será concluída e queremos que a função retorne Null.

Para modificar a macro HPC_Partition

1. No código HPCExcelMacros , role até a seção HPC_Partition e adicione código para declarar uma matriz para a linha e a coluna:

   Public Function HPC_Partition() As Variant
   
       Dim data(3) As Variant
   
       ' update the status bar with the counters
   
       SentRecords = SentRecords + 1
       UpdateStatus
   
   End Function
   

2. Adicione código para verificar o final da tabela. Isso encerrará o cálculo quando terminarmos a tabela.

   Public Function HPC_Partition() As Variant
   
       Dim data(3) As Variant
   
       ' first check the row; if we're past the bottom
       ' of the table, increment the column and set the
       ' row back to the top
   
       If CurrentRow > NumRows Then
           CurrentRow = 1
           CurrentCol = CurrentCol + 1
       End If
   
       ' next check the column; if we're past the last
       ' column, then we're done
   
       If CurrentCol > NumCols Then
   
           ' return null to indicate the end of the calculation
           HPC_Partition = Null
   
           ' and exit the function now, we can skip the rest
           Exit Function
       End If
   
       ' update the status bar with the counters
   
       SentRecords = SentRecords + 1
       UpdateStatus
   
   End Function
   

3. Se ainda não terminarmos a tabela, a última parte da função armazenará os valores de linha e coluna e os usará como o valor retornado para a função; e, em seguida, mova para a próxima linha:

   Public Function HPC_Partition() As Variant
   
       Dim data(3) As Variant
   
       ' first check the row; if we're past the bottom
       ' of the table, increment the column and set the
       ' row back to the top
   
       If CurrentRow > NumRows Then
           CurrentRow = 1
           CurrentCol = CurrentCol + 1
       End If
   
       ' next check the column; if we're past the last
       ' column, then we're done
   
       If CurrentCol > NumCols Then
   
           ' return null to indicate the end of the calculation
           HPC_Partition = Null
   
           ' and exit the function now, we can skip the rest
           Exit Function
       End If
   
       data(0) = CurrentRow
       data(1) = CurrentCol
       HPC_Partition = data
   
       ' move to the next row
   
       CurrentRow = CurrentRow + 1
   
       ' update the status bar with the counters
   
       SentRecords = SentRecords + 1
       UpdateStatus
   
   End Function
   

Portanto, para revisar, a macro HPC_Partition tem duas finalidades: coleta os parâmetros necessários para um único cálculo (aqui está o número da linha e da coluna); e quando o cálculo for concluído, ele sinalizará isso retornando Null. Na função que criamos, ele faz isso percorrendo a tabela, primeiro por linha e depois por coluna, e quando ela é passada pela última coluna, ela retorna Null para indicar que a tabela está concluída.

Modificando a macro HPC_Execute

A próxima macro é HPC_Execute. Lembre-se de que essa macro foi projetada para executar o cálculo real ou a lógica de negócios. As entradas para essa função serão o que retornarmos da macro HPC_Partition na última etapa. Como acabamos de escrever a macro HPC_Partition , sabemos que as entradas para a macro HPC_Execute serão o número de linha e coluna da célula da tabela que queremos calcular.

O corpo da macro HPC_Execute será copiado de código da macro de cálculo original. Precisaremos de duas partes desse código: as declarações de variável na parte superior e o código que executa o loop. Já usamos a seção que lida com o tamanho da tabela na macro HPC_Initialize , portanto, não precisamos disso novamente, mas será mais fácil copiar todo o bloco de código e remover as partes de que não precisamos. Em seguida, faremos algumas alterações para dar suporte à estrutura assíncrona.

Para modificar a macro HPC_Execute

1. Volte para a macro original clicando duas vezes no módulo "ScenarioAnalysis" na janela do projeto do VBA.

2. Copie o código da primeira linha:

   Dim Prem as double
   

   Até a última linha:

   Next cols
   

3. Volte para o módulo HPCExcelMacros (clicando duas vezes na janela do projeto do VBA) e cole o código na macro HPC_Execute .

4. Na macro HPC_Execute , exclua as linhas que já usamos, começando de:

   ' clear values, then figure out the table size
   

   Até a linha pouco antes:

   ' set up and run through the table
   

5. Verifique se a macro HPC_Execute tem esta aparência:

   Public Function HPC_Execute(data As Variant) As Variant
   
       Dim Prem As Double
       Dim TempPIKdate As Date
       Dim TempPIKfreq As Double
       Dim rws As Integer
       Dim cols As Integer
       Dim Model As Integer
   
       ' set up and run through the table
   
       Call ReadSheetVariables
       TempPIKdate = PIKdate 'Save this value!
       TempPIKfreq = PIKfreq 'Save this value!
   
       Model = 1
       If Range("PricingModel").Value2 = "Bond plus Option" Then
           Model = 2
       End If
   
       For cols = 1 To NumCols
           For rws = 1 To NumRows
   
               Call ReadSheetVariables
               PIKdate = TempPIKdate
               PIKfreq = TempPIKfreq
               PIKrate = CDbl(Range("table1").Offset(rws, 0).Value)
               Prem = CDbl(Range("table1").Offset(0, cols).Value)
               If Prem = 0 Then End
               Ratio = CDbl(Face / Underlying / (1 + Prem))
   
               Select Case Model
               Case 1
                   Range("cashtable").Cells(rws, cols).Value = … 
               Case Else
                   Range("cashtable").Cells(rws, cols).Value = … 
               End Select
   
           Next rws
       Next cols
   
   End Function
   
   

   Observação: na macro, agora temos a parte de cálculo da função, incluindo o loop executado por cada célula da tabela. Para a estrutura assíncrona, não queremos usar um loop aqui; só queremos calcular uma única célula. Lembre-se de que a macro HPC_Execute é um código que será executado nos nós de computação e estamos dando a ele o número de linha e coluna que queremos calcular.

6. Remova as linhas que compõem o loop (as linhas realçadas abaixo):

   Public Function HPC_Execute(data As Variant) As Variant
   
       Dim Prem As Double
       Dim TempPIKdate As Date
       Dim TempPIKfreq As Double
       Dim rws As Integer
       Dim cols As Integer
       Dim Model As Integer
   
       ' set up and run through the table
   
       Call ReadSheetVariables
       TempPIKdate = PIKdate 'Save this value!
       TempPIKfreq = PIKfreq 'Save this value!
   
       Model = 1
       If Range("PricingModel").Value2 = "Bond plus Option" Then
           Model = 2
       End If
   
       For cols = 1 To NumCols
           For rws = 1 To NumRows
   
               Call ReadSheetVariables
               PIKdate = TempPIKdate
               PIKfreq = TempPIKfreq
               PIKrate = CDbl(Range("table1").Offset(rws, 0).Value)
               Prem = CDbl(Range("table1").Offset(0, cols).Value)
               If Prem = 0 Then End
               Ratio = CDbl(Face / Underlying / (1 + Prem))
   
               Select Case Model
               Case 1
                   Range("cashtable").Cells(rws, cols).Value = … 
               Case Else
                   Range("cashtable").Cells(rws, cols).Value = … 
               End Select
   
           Next rws
       Next cols
   
   End Function
   

7. Substituindo o loop pelo número de linha e coluna que são passados para a função. O código modificado deve ter esta aparência:

       rws = data(0)
       cols = data(1)
   
       Call ReadSheetVariables
       PIKdate = TempPIKdate
       PIKfreq = TempPIKfreq
       PIKrate = CDbl(Range("table1").Offset(rws, 0).Value)
       Prem = CDbl(Range("table1").Offset(0, cols).Value)
       If Prem = 0 Then End
       Ratio = CDbl(Face / Underlying / (1 + Prem))
   
       Select Case Model
       Case 1
           Range("cashtable").Cells(rws, cols).Value = FullDiscountModel(360) / Face
       Case Else
           Range("cashtable").Cells(rws, cols).Value = BondPlusOptionModel(360) … 
       End Select
   
   

Em vez do loop, agora estamos usando os valores de nossa matriz de dados, a Matriz que retornamos da macro HPC_Partition , que contém a linha e a coluna da célula que queremos calcular. Então, para examinar a última etapa, removemos as duas linhas de loop,

    For cols = 1 To NumCols
        For rws = 1 To NumRows

bem como as linhas "Avançar" no final do loop,

        Next rws
    Next cols

e adição de linhas logo acima do loop para usar a variável de matriz de dados:

    rws = data(0)
    cols = data(1)

A última alteração que queremos fazer na função HPC_Execute tem a ver com o retorno dos dados. Lembre-se de que os dados passam pelas macros, cada macro passando resultados para a próxima. O código VBA original dessa pasta de trabalho foi projetado para ser executado na área de trabalho, de modo que, como cada célula foi calculada, o resultado foi colado na planilha. Como essa pasta de trabalho será executada no cluster, em vez de colar resultados na planilha, precisamos coletar o resultado do cálculo e devolvê-lo da função.

E há outra coisa que precisamos considerar: quando a função HPC_Execute é executada em um nó de computação, ela calculará o resultado de uma célula específica na tabela. Esse resultado será retornado para a área de trabalho e enviado para a macro HPC_Merge . Mas lembre-se de que, na estrutura assíncrona, os resultados podem ser enviados de volta em qualquer ordem, não necessariamente na mesma ordem que os enviamos. Portanto, precisamos informar à macro HPC_Merge qual célula na tabela calculamos.

Podemos fazer isso incluindo o número de linha e coluna nos dados de resultados. Assim como acontece com a macro HPC_Partition , podemos retornar uma Matriz da macro HPC_Excecute. Fazer isso permitirá que a função retorne não apenas o resultado, mas também qual célula foi calculada.

Na verdade, podemos simplesmente reutilize a mesma Matriz que foi passada para a função para retornar o resultado, pois essa Matriz já contém o número de linha e coluna.

Para armazenar o resultado, altere o código para que ele leia da seguinte maneira:

    Select Case Model
    Case 1
        data(2) = FullDiscountModel(360) / Face
    Case Else
        data(2) = BondPlusOptionModel(360) / Face
    End Select
                
    HPC_Execute = data

Alteramos o código que inseriu valores na planilha para armazenar os valores de resultado na matriz de dados. E a última linha usa a matriz de dados como o valor retornado da função, de modo que os resultados -- e os números de linha e coluna -- serão enviados para a próxima macro.

Portanto, o código final completo para a macro HPC_Execute deve ter esta aparência:

Public Function HPC_Execute(data As Variant) As Variant

    Dim Prem As Double
    Dim TempPIKdate As Date
    Dim TempPIKfreq As Double
    Dim rws As Integer
    Dim cols As Integer
    Dim Model As Integer
    
    ' set up and run through the table
    
    Call ReadSheetVariables
    TempPIKdate = PIKdate 'Save this value!
    TempPIKfreq = PIKfreq 'Save this value!
    
    Model = 1
    If Range("PricingModel").Value2 = "Bond plus Option" Then
        Model = 2
    End If
    
    rws = data(0)
    cols = data(1)
        
    Call ReadSheetVariables
    PIKdate = TempPIKdate
    PIKfreq = TempPIKfreq
    PIKrate = CDbl(Range("table1").Offset(rws, 0).Value)
    Prem = CDbl(Range("table1").Offset(0, cols).Value)
    If Prem = 0 Then End
    Ratio = CDbl(Face / Underlying / (1 + Prem))
    
    Select Case Model
    Case 1
        data(2) = FullDiscountModel(360) / Face
    Case Else
        data(2) = BondPlusOptionModel(360) / Face
    End Select
                
    HPC_Execute = data
                
End Function

Modificando a macro HPC_Merge

A última macro que precisamos modificar é a macro HPC_Merge . Lembre-se de que essa macro recebe um único resultado de cálculo do cluster. Queremos usá-lo para inserir o resultado na tabela.

A entrada para HPC_Merge será o que retornarmos de HPC_Execute. Como acabamos de escrever a macro HPC_Execute , sabemos que o valor retornado será uma Matriz que contém o número de linha e coluna e o resultado do cálculo. Para atualizar a tabela, podemos usar o código da macro original (esse é o código que acabamos de alterar na função HPC_Execute ).

A linha de código original, no módulo ScenarioAnalysis, tinha esta aparência:

        Range("cashtable").Cells(rws, cols).Value = FullDiscountModel(360) / Face

Reescreveremos essa linha para usar os valores passados para a macro no parâmetro de dados. A macro de HPC_Merge concluída deve ter esta aparência:

Public Function HPC_Merge(data As Variant)

    Range("cashtable").Cells(data(0), data(1)).Value = data(2)

    ' update the status bar with the counters

    RcvRecords = RcvRecords + 1
    UpdateStatus

End Function

Essa é a mesma linha de código que acabou de ser removida da macro HPC_Execute . Substituímos os valores de linha e coluna (rws e cols na linha original) pela linha e coluna da Matriz. Também substituímos a chamada de função pelo resultado, que é armazenado na mesma Matriz.

Essas são todas as modificações que temos que fazer para executar essa pasta de trabalho no cluster. Embora possa parecer muitas etapas, especialmente se esta for a primeira vez que você usa os Serviços HPC para Excel, examine as macros para ver o código total que foi alterado. Não é muito. Na maioria das vezes, isso envolvia copiar e colar da macro original para as macros HPC. Para dar suporte ao cálculo assíncrono, fizemos várias alterações no código , mas mesmo isso era relativamente simples. Não fizemos nenhuma alteração na lógica de negócios real nesta pasta de trabalho e você nem precisa entender as funções lógicas de negócios para converter a pasta de trabalho. Mais importante, se os usuários fizerem alterações na lógica de negócios no futuro, isso não exigirá a alteração do cálculo do cluster.

Executando a pasta de trabalho

Para testar as alterações no código, primeiro o executaremos na área de trabalho. Como na primeira pasta de trabalho, adicionaremos um novo botão à planilha e o usaremos para executar o cálculo. Em seguida, especificaremos o nó principal e o compartilhamento de arquivos, adicionaremos um botão que executa a pasta de trabalho no cluster e, em seguida, executaremos a pasta de trabalho no cluster.

Adicionando um botão que executa a pasta de trabalho localmente

Para adicionar um botão que executa a pasta de trabalho localmente

(1) Com a pasta de trabalho do Excel aberta, clique na guia Desenvolvedor na faixa de opções.

(2) Na guia Desenvolvedor , clique em Inserir e selecione o controle de botão – o primeiro controle na lista.

(3) Depois de clicar no botão, desenhe um retângulo em algum lugar da planilha para inserir o botão nesse local. Depois de posicionar o botão, a caixa de diálogo Atribuir Macro será exibida. !

(4) Na caixa de diálogo, selecione a macro CalculateWorkbookOnDesktop na lista e clique em OK. Selecione a macro da área de trabalho– queremos testar a pasta de trabalho primeiro e encontrar erros antes de executá-la no cluster.

(5) Clique com o botão direito do mouse no novo botão e selecione Editar Texto para alterar o rótulo.

(6) Nomeie o rótulo "Desktop" ou algo semelhante.

(7) Salve a pasta de trabalho.

(8) Clique no botão para executar a pasta de trabalho na área de trabalho.

Se houver erros, você verá uma caixa de diálogo de erro e a parte do código VBA com o erro será realçada. Verifique duas vezes o código listado acima para resolver erros.

Se não houver erros, você verá a tabela sendo preenchida. Os valores devem ser os mesmos de quando você clicou no botão original na planilha. Novamente, isso está em execução na área de trabalho, portanto, ele deve ser executado na mesma velocidade que o botão original , em algum lugar entre 1 e 2 minutos na maioria das estações de trabalho.

Como estamos executando com o código da estrutura de macro, você também verá o progresso do cálculo exibido na barra de status do Excel. Assim como acontece com a primeira pasta de trabalho, em execução na área de trabalho, você verá os números se moverem juntos, pois na área de trabalho a pasta de trabalho é executada de forma síncrona.

Executando a pasta de trabalho no cluster

Em seguida, tentaremos executar a pasta de trabalho no cluster. Para fazer isso, primeiro precisaremos definir alguns valores para informar ao Excel como contatar o cluster. Esses valores são definidos no módulo HPCControlMacros **.** Na parte superior desse arquivo, há dois valores que você precisará preencher: o agendador de cluster e o diretório de compartilhamento. Lembre-se de que você (o usuário da área de trabalho) deve ter acesso de gravação a este diretório de compartilhamento; e os nós de computação de cluster devem ter acesso de leitura ao diretório. Na maioria dos casos, os cálculos do cluster serão executados em sua conta de usuário, mas é possível usar uma conta de usuário diferente quando você se conectar à sessão do cluster (mais sobre isso em um momento).

Para especificar o nó principal e o diretório de compartilhamento

1. Na guia Desenvolvedor da faixa de opções, clique em Visual Basic para abrir o editor do VBA.

2. No editor do VBA, na árvore de projeto, clique duas vezes no módulo HPCControlMacros para abrir o arquivo de macro.

3. Para o agendador de cluster, use o nome do nó principal do cluster. Esse é o nome do computador que você usaria na rede. Você pode usar um nome totalmente qualificado (por exemplo, headnode.mynetwork.com), mas isso não é necessário se você estiver no mesmo domínio.

4. Para o diretório de compartilhamento, use o caminho completo para o diretório de compartilhamento que você criou anteriormente (na seção "Antes de Começar").

Agora volte para a planilha do Excel. Adicionaremos outro botão, desta vez para executar o cálculo no cluster.

Para adicionar um botão que executa a pasta de trabalho no cluster

1. Na guia Desenvolvedor , clique em Inserir e, em seguida, selecione o controle de botão – o primeiro controle na lista.

2. Depois de clicar no botão, desenhe um retângulo em algum lugar na planilha para inserir o botão nesse local. Depois de posicionar o botão, a caixa de diálogo Atribuir Macro será exibida.

3. Na caixa de diálogo, selecione a macro CalculateWorkbookOnCluster na lista e clique em OK.

4. Clique com o botão direito do mouse no novo botão e selecione Editar Texto para alterar o rótulo.

5. Nomeie o rótulo "Cluster" ou algo semelhante.

6. Salve a pasta de trabalho.

7. Clique no botão para executar a pasta de trabalho no cluster.

8. Se esta for a primeira vez que você executar qualquer trabalho de cluster, usando o Excel ou usando qualquer outro aplicativo, você verá uma caixa de diálogo de autenticação do usuário. Digite seu nome de usuário e senha e (se desejar) marque a caixa para salvar suas credenciais. Se você quiser executar cálculos no cluster como um usuário diferente, poderá inserir diferentes configurações de conta de usuário.

Observação: certifique-se de que sua conta de usuário - sua conta de usuário padrão ou o que você deseja usar - seja designada como um usuário de cluster no Gerenciador de Cluster do HPC.

Se houver erros, você verá uma caixa de diálogo pop-up. Se o cálculo da área de trabalho funcionar, os erros mais prováveis neste ponto terão a ver com as configurações criadas para o nó principal do cluster e o diretório de compartilhamento. Verifique essas configurações duas vezes e tente novamente.

Se não houver erros, você verá o início do cálculo do cluster. Primeiro, haverá uma breve pausa, pois a biblioteca de clientes cria uma sessão de HPC para cálculo. Em seguida, a biblioteca de clientes chamará a macro HPC_Initialize e você verá que a tabela está apagada. Se você examinar a barra de status do Excel, verá que primeiro todos os registros são enviados para o cluster; o segundo número saltará para 105 (há 105 células na tabela). Depois disso, você verá outra breve pausa antes que os resultados sejam retornados. Essa pausa ocorre quando cada nó de computação inicia o Excel e carrega a pasta de trabalho.

Após essa pausa, você verá os resultados começarem a preencher a tabela e a barra de status começará a mostrar o número de resultados retornados. Como este é um cálculo longo, é muito provável que você veja os resultados retornados fora de ordem; haverá espaços em branco na tabela, que serão preenchidos. Mais uma vez isso ocorre porque o cálculo é assíncrono e alguns nós de computação calculam mais rápido do que outros. Eventualmente, a tabela será preenchida completamente e a barra de status mostrará o tempo de cálculo.

Mesmo que você tenha apenas dois nós de computação em seu cluster HPC, o cálculo deve ser muito mais rápido do que ser executado na área de trabalho. Se você tiver quatro nós, oito nós ou mais, o cálculo deverá ser extremamente rápido. Você sempre pode clicar no botão "Área de Trabalho" novamente para comparar o desempenho do cálculo da área de trabalho com o cálculo do cluster.

Práticas recomendadas para Cluster-Enabled pastas de trabalho do Excel

A nota a seguir descreve algumas considerações importantes a serem consideradas ao criar pastas de trabalho do Excel para uso com os Serviços HPC para Excel. Esta observação se aplica a pastas de trabalho usando a estrutura de macros do HPC/Excel em execução no VBA ou com a biblioteca do ExcelClient do .NET.

Desempenho do aplicativo de cluster

Ao criar um aplicativo para cálculo em um cluster HPC, normalmente você divide o trabalho necessário em tarefas individuais e envia essas tarefas para o cluster para cálculo. Os benefícios de desempenho do uso do HPC vêm da paralelização , tendo muitos Nós de Computação funcionando ao mesmo tempo.

É responsabilidade do Agendador de HPC (o Nó Principal) distribuir essas tarefas para os Nós de Computação para processamento. No entanto, para garantir que os Nós de Computação nunca estejam aguardando trabalho, você deve tentar garantir que o Agendador de HPC sempre tenha uma lista de tarefas a serem processadas. Se o Agendador precisar aguardar a próxima tarefa de processamento, um ou mais Nós de Computação ficarão ociosos , não fazendo nada, e você não obterá a melhor utilização do cluster HPC.

Você pode garantir que o Agendador e os Nós de Computação sempre tenham trabalho suficiente para fazer enviando solicitações de computação o mais rápido possível. Na estrutura de macros do HPC/Excel, as solicitações são enviadas com a macro HPC_Partition. Portanto, é importante garantir que a macro de partição seja o mais rápida possível. Se você puder projetar a macro de partição para enviar tarefas rapidamente, você garantirá que o cluster seja totalmente utilizado e obterá o melhor desempenho possível do HPC.

Quando os cálculos individuais nos Nós de Computação do cluster são concluídos, os resultados são enviados de volta para seu aplicativo da área de trabalho. Na estrutura de macros do HPC/Excel, os resultados são processados usando a macro HPC_Merge. Você também deseja fazer essa macro o mais rápido possível, por dois motivos. Primeiro, se a macro Mesclagem for lenta para processar os resultados, isso poderá desnecessariamente vincular os recursos do cluster. Em segundo lugar, o processamento lento de resultados reduzirá seu cálculo geral, reduzindo os benefícios do uso do HPC. Se você garantir que a macro mesclagem processe os resultados rapidamente, você liberará todos os recursos de cluster para outro uso e melhorará a experiência geral do usuário.

Aprimorando o desempenho da macro do HPC/Excel

Nesta seção, descreveremos algumas etapas que você pode tomar para ajudar a garantir que suas pastas de trabalho do Excel habilitadas para HPC sejam o mais eficientes possível, para que você possa obter o melhor desempenho possível ao executar cálculos em um cluster HPC.

Essa lista não é abrangente, mas você pode encontrar algumas dicas que se aplicam à sua pasta de trabalho. E lembre-se de que essas são otimizações – a melhor abordagem ao criar pastas de trabalho do Excel habilitadas para HPC é projetar o cálculo primeiro e mantê-lo o mais simples possível; depois de executar a pasta de trabalho corretamente no cluster, faça o tipo de alterações que descrevemos aqui para melhorar o desempenho geral.

Evite abrir e fechar recursos nas macros Partição e Mesclagem

Abrir e fechar recursos externos, como arquivos de log ou conexões de banco de dados, pode levar muito tempo e pode diminuir a velocidade das macros Partição e Mesclagem. Além disso, você deve evitar ler grandes conjuntos de dados nessas macros, se possível. Por exemplo, você não deseja abrir uma conexão de banco de dados, pesquisar os registros e localizar um único registro para cada chamada para a macro de partição.

Uma abordagem melhor é abrir esses recursos uma vez, na macro Inicializar e executar todas as etapas de processamento iniciais. Por exemplo, se você precisar carregar um conjunto de dados grande de um banco de dados, crie a conexão de banco de dados e execute a consulta na macro Inicializar. Em seguida, na macro Partição, você pode apenas passar para o próximo registro. Você pode fechar a conexão de banco de dados na macro Finalize.

Da mesma forma, se você estiver gravando em um arquivo de log na macro Merge, considere abrir o arquivo na macro Initialize. Na macro Mesclagem, você pode gravar resultados um de cada vez e, em seguida, pode fechar o arquivo de log na macro Finalizar.

Evite recalcular a planilha na macro Mesclagem

Se você estiver inserindo resultados na planilha na macro Mesclagem, poderá recalcular inadvertidamente a planilha. Se a planilha for muito complicada, isso poderá diminuir o processamento.

Por padrão, o Excel recalculará a planilha sempre que você alterar o valor de uma célula, incluindo se você atualizar a célula de uma macro VBA. O Excel recalculará apenas as partes da planilha que são afetadas pela alteração. Portanto, se a célula se sentar sozinha, isso não será significativo. Mas se a célula for usada como parte de um cálculo maior ou como dados do gráfico, o recálculo poderá ser lento.

Se você estiver atualizando as células de planilha na macro Mesclagem, considere desabilitar o recálculo automático. Você pode desabilitar o recálculo automático na macro Inicializar. Em seguida, na macro Finalizar, você pode recalcular a planilha inteira e habilitar novamente o cálculo automático.

Na macro Inicializar, você pode desativar o cálculo automático com

Application.Calculation = xlCalculationManual

Em seguida, você pode recalcular a planilha e habilitar novamente o cálculo automático na macro Finalizar com

Application.Calculate
Application.Calculation = xlCalculationAutomatic

Inserir blocos de dados em vez de valores individuais

Quando você atualiza células de planilha do VBA, isso envolve várias etapas internas e pode ser mais lento do que você espera. É quase sempre melhor alterar várias células como um único bloco, em vez de uma de cada vez.

Se a macro Executar retornar um grande número de valores , uma Matriz de 100 números, por exemplo, há duas maneiras de inserir esses dados na planilha. Você pode inseri-las uma de cada vez, em um loop:

For i = 1 To 100 Step 1
   Cells(1, i).Value2 = v(i)
Next i

Ou você pode inserir o intervalo completo como uma matriz:

Range(Cells(2, 1), Cells(2, 100)).Value2 = v

A inserção de uma célula leva quase o mesmo tempo que inserir um bloco de células. Portanto, se você tiver uma matriz de 100 valores, a primeira maneira de fazer isso , inserindo células uma de cada vez em um loop, poderá levar até 100 vezes mais do que a segunda abordagem, inserindo o bloco de células como uma matriz.

Desativar atualizações de tela

Se você estiver fazendo alterações na planilha na macro Mesclagem , se estiver atualizando células ou alterando dados do gráfico, desativar as atualizações de tela poderá reduzir o tempo de processamento. Isso funciona porque o Excel consome algum tempo atualizando a tela e a interface do usuário.

Você pode desabilitar atualizações de tela na macro Inicializar e habilitar novamente as atualizações de tela na macro Finalizar. Na macro Inicializar, use

Application.ScreenUpdating = False

Na macro Finalizar, use

Application.ScreenUpdating = True

Isso desabilitará as atualizações de tela durante o cálculo e habilitará novamente as atualizações após a conclusão do cálculo. Quando você habilitar novamente as atualizações de tela na macro Finalizar, o Excel atualizará automaticamente a tela.

Usar estruturas de dados para armazenar temporariamente informações na memória

Se a coleta de informações para processamento -- o que você faz na macro de partição -- for muito demorada ou se você precisar fazer um pós-processamento muito complexo de resultados -- na macro Mesclagem -- considere o uso de estruturas de dados para armazenar informações na memória durante o cálculo.

Por exemplo, se cada uma das suas solicitações de cálculo na macro de partição exigir uma consulta de banco de dados muito complicada, isso poderá diminuir o processamento e resultar em um desempenho ruim. Nesse caso, pode ser uma boa ideia executar esse processamento complexo na macro Inicializar antes do início do cálculo.

Se você executar esse processamento complexo na macro Inicializar, poderá armazenar cada uma das solicitações de cálculo em uma estrutura de dados no VBA, como uma Matriz de Variantes. Em seguida, na macro Partição, você pode simplesmente retornar a próxima entrada na Matriz. Isso ajudará a garantir que a macro de partição seja o mais rápida possível.

Da mesma forma, se você precisar executar um pós-processamento muito complexo nos resultados conforme eles chegam, talvez seja aconselhável armazenar os resultados em uma estrutura de dados na macro Mesclagem e processar os resultados na macro Finalizar após a conclusão do cálculo.

Por exemplo, se você estiver armazenando resultados em um banco de dados, mas cada gravação de banco de dados exigir uma instrução de inserção complexa, talvez seja melhor mover esse processamento para a macro Finalize. Você pode criar uma estrutura de dados , como uma Matriz de Variantes, e na macro Mesclagem, basta inserir cada resultado na Matriz. Em seguida, na macro Finalizar, você pode fazer loop pela Matriz e executar as operações de gravação de banco de dados necessárias de uma só vez.

Notas finais

Converter uma pasta de trabalho existente para usar o HPC Services para Excel é mais uma arte do que uma ciência. Os detalhes específicos , que código mover e para onde movê-lo - sempre dependerão da pasta de trabalho específica.

No entanto, agora você deve entender os conceitos envolvidos e entender por que usamos a estrutura de macro assíncrona. Para converter qualquer pasta de trabalho para usar o HPC Services para Excel, é necessário criar um cálculo paralelo essencialmente da mesma maneira: adicionar as funções da estrutura de macro à sua pasta de trabalho e preencher o código apropriado.

Você pode usar os arquivos de macro "esqueleto" incluídos neste artigo em suas próprias pastas de trabalho. Siga as etapas usadas nos exemplos acima para identificar o código iterativo em sua pasta de trabalho e movê-lo para as macros apropriadas. E lembre-se de testar o cálculo em sua área de trabalho para identificar erros antes de executar cálculos no cluster.

Você também deve ter uma noção dos benefícios de desempenho que você pode obter ao executar pastas de trabalho do Excel em um cluster HPC com o HPC Services para Excel. Neste artigo, começamos com uma pasta de trabalho que já era razoavelmente rápida– para calcular a pasta de trabalho inteira levou apenas cerca de 1 a 2 minutos na área de trabalho. Mas mesmo essa pasta de trabalho pode ser executada duas vezes mais rápido, quatro vezes mais rápido ou mais rápido em um cluster HPC. O desempenho real depende do número de nós de computação disponíveis em seu cluster e você sempre pode melhorar o desempenho adicionando mais nós de computação ao cluster.

Com uma quantidade relativamente pequena de trabalho, é possível converter muitas pastas de trabalho longas do Excel para serem executadas em um cluster do Microsoft HPC com os Serviços HPC para Excel. E para pastas de trabalho de execução muito longas, pastas de trabalho que levam horas ou até dias para serem calculadas, o uso dos Serviços HPC para Excel pode resultar em uma melhoria de desempenho realmente dramática.