2 Arquitetura Paralela

Transcrição

1 1 Resumo Esta monografia tem como objetivo o desenvolvimento de uma ferramenta para auxiliar no desenvolvimento de programa que utilizam a biblioteca MPI Esta ferramenta mostra ao usuário qual a carga de dados passada entre os processos MPI na rede do cluster, e também quais computadores estão realizando a troca de dados É tomada como base para a medição da carga da rede o protocolo TCP/IP utilizando uma placa FastEhternet de 100Mbits por segundo Este protocolo foi escolhido por ser o protocolo utilizado para a ligação das estações do cluster do Departamento de Informática da UFES A biblioteca MPI utilizada foi a LAM-MPI 656

2 2 1 Introdução As grandes preocupações na implementação de um programa que será executado em um cluster de computadores são: garantir que nenhum nó ficará sobrecarregado, executando uma tarefa maior que os outros nós do cluster, e garantir que a comunicação entre os computadores não causará uma perda de desempenho, ocorrida devido a algum gargalo na rede Um das soluções para esse problema é o acompanhamento do andamento do programa durante a sua execução Uma informação muito importante para o usuário é o tamanho dos dados passados entre os computadores do cluster Se essa informação fosse passada ao usuário, seria instantânea a detecção de que um determinado nó do cluster está sobrecarregado, pois se ele estiver recebendo muito mais dados a serem processados que os outros nós do cluster estará realizando um processamento muito maior, ou se receber uma quantidade muito pequena de dados estará realizando um processamento muito menor Neste contexto, o objetivo deste trabalho é o desenvolvimento de uma ferramenta capaz de proporcionar um ambiente no qual o usuário poderá visualizar as chamadas das funções da biblioteca MPI para troca de dados entre os nós do cluster O usuário irá visualizar o momento em que um nó no cluster está passando algum dado a outro computador do cluster, e qual o tamanho desse dado em relação a capacidade da rede Esta informação é tomada com base na capacidade da rede, para ser possível ao programador identificar qual a utilização da rede para a comunicação entre os computadores do cluster, caso algum computador esteja utilizando mais a rede que os outros, isto significa que ele está recebendo mais dados que os demais Com estas informações o programador poderá otimizar o desempenho do programa para que todos os computadores possam realizar um processamento uniforme, não havendo sobrecarga nem falta de carga em alguma máquina do cluster Esta monografia irá descrever a criação e funcionamento da ferramenta MPI_SPY nos próximos capítulos No capítulo 2 são mostrados o modelo de cluster beowulf, e algumas ferramentas adicionais Este modelo foi escolhido por ser o modelo utilizado na construção do cluster do Departamento de Informática da UFES O capítulo 3 apresenta a biblioteca MPI, como é o seu funcionamento e algumas de suas funções Também são mostradas neste capítulo quais dados referentes a biblioteca MPI poderão ser aproveitados pelo usuário para fazer o acompanhamento do programa no cluster No capítulo 4 é mostrado o funcionamento do MPI_SPY, quais alterações foram feitas na biblioteca MPI, e como essas alterações se comportarão No capítulo 5 é apresentado como foi feita a implementação do MPI_SPY para que ele pudesse funcionar em conjunto com a biblioteca MPI O capítulo 6 mostra as conclusões obtidas e propostas de trabalhos futuros

3 3 2 Arquitetura Paralela Máquinas para computação paralela estão se tornando populares nos dias atuais, devido a crescente necessidade de maior capacidade computacional Mas algumas destas máquinas têm um custo muito elevado, ou são difíceis de programar [1] 21 Modelos de Arquitetura A tabela 21 abaixo ilustra a classificação de Flyn para máquinas paralelas: SD (Single Data) SISD MD (Multiple Data) SIMD SI (Single Instruction) Máquinas VonNeumman convencionais Máquinas Vetoriais (CM-2, MasPar) MI (Multiple Instruction) MISD Não existe atualmente Tabela 21: Classificação de Flyn MIMD Multiprocessadores e multicomputadores (ncube, Intel Paragon) A classe SISD (Single Instruction Single Data), representa as classes das máquinas convencionais, existe apenas um único fluxo de dados que é manipulado por um único fluxo de instruções [1] A classe MISD (Multiple Instruction Single Data) assume um múltiplo fluxo de instruções sobre um único fluxo de dados, o que na prática quer dizer que várias instruções manipulam um mesmo dado, o que não acontece em qualquer máquina projetada até hoje A classe SIMD (Single Instruction Multiple Data) corresponde à classe de equipamentos com processamento vetorial, onde um conjunto de processadores irá processar uma massa de dados Neste caso cada processador executa a mesma instrução, mas operam sobre partes diferentes da massa de dados A classe MIMD (Multiple Instruction Multiple Data) abrange o grupo de máquinas que podem executar diferentes instrução em diferentes conjuntos de dados ao mesmo tempo Dessa forma, qualquer grupo de máquinas, executando um processamento distribuído, pode ser considerado uma máquina MIMD Um tipo de máquina que vem tendo uma maior participação no grupo de máquinas paralelas é o cluster, ou agregado, de computadores

4 4 22 Cluster de Computadores Um Cluster é constituído por várias estações de trabalho interligadas, projetadas com o objetivo de executar aplicações paralelas [1] Sendo assim, cada máquina que compõem o cluster deverá ser modificada para esse fim, recebendo uma configuração adequada São retirados o monitor, o teclado e mouse, mas as principais modificações são realizadas no software que será instalado em cada computador O sistema operacional é reduzido, contendo apenas um conjunto básico de programas para poder ativar o computador no cluster Outro ponto que merece atenção em um cluster é a rede de conexão Dependendo do tipo de cluster que se está construindo, pode-se ter um tipo de rede Quando o mais importante é o poder de processamento do cluster, podese fazer a opção por uma rede padrão, por exemplo Ethernet, que não pesará no custo final do cluster, podendo ter uma considerável quantidade de máquinas, superior a 1000 Se for dada uma maior importância na comunicação entre os computadores, deverá ser utilizada uma rede de baixa latência, oferecida por empresas que fornecem placas de conexão de alto desempenho Neste caso, o custo da rede será elevado, e o cluster não contará com uma grande quantidade de máquinas As vantagens na utilização de um cluster de computadores em relação a uma única máquina com vários processadores são: Custo x Benefício: apresenta uma ótima relação MFlops/$ em comparação à uma máquina com igual quantidade de processadores Configuração: por se tratar de uma arquitetura aberta, formada por estações de trabalho, a definição de seus componentes ( computadores e placas de rede ) possibilitam várias configurações Manutenção: os componentes necessários a sua manutenção são facilmente encontrados, pois em sua construção são utilizados produtos de prateleira [1] 23 Cluster Beowulf Um modelo de cluster que vem sendo utilizado hoje em dia é o Cluster Beowulf, pois esta máquina além de ser formada por equipamentos de baixo custo utiliza versões do Unix e programas de domínio público [4] O princípio é: Nenhuma máquina paralela comercial pode competir com um Beowulf, em relação ao custo O cluster é formado por uma rede Ethernet e estações constituídos por PCs padrão A quantidade de máquinas na rede, incluindo computador e placa de rede, irá definir o preço final do cluster, pois como foi dito, o software instalado nas máquinas é gratuito

5 5 Figura 21: Cluster Beowulf Na figura 21 pode ser visto um cluster formado por 16 máquinas O padrão Beowulf define a configuração mínima de um cluster Pode-se partir de um cluster Beowulf para uma configuração mais segura, ou mais otimizada, dependendo da necessidade que se tem 24 Configuração de um Cluster No caso de se ter um número reduzido de computadores não há nenhuma necessidade maior que não possa ser sanada com um mínimo de recursos Mas quando se possui um cluster com uma quantidade maior de máquinas, ou que será utilizado intensamente, outros equipamentos devem ser levados em consideração 241 Monitor de Funcionamento Este equipamento é utilizado para verificar o funcionamento de cada máquina no cluster, e do cluster como um todo Caso alguma máquina falhe, seja danificada fisicamente e deixe de funcionar, o Monitor deverá informar qual máquina está danificada, para que o Gerenciador de Processos não venha alocar algum programa na máquina danificada

6 6 242 Controlador de Temperatura Pelo fato de um cluster reunir um conjunto de computadores, que irão executar uma carga de processamento que os leve ao máximo de sua capacidade, alguns cuidados devem ser levados em relação a temperatura das máquinas, e do cluster O controlador de temperatura é um equipamento que vem embutido em todos os processadores hoje em dia, e que ao entrar em funcionamento ( a temperatura atingiu o ponto crítico ) irá desligar o computador Como os processadores dos computadores em m cluster estarão operando em capacidade máxima, a temperatura interna da CPU irá se elevar rapidamente, atingindo o ponto crítico e dependendo do caso, queimar a CPU antes de ativar o controle interno O Controlador de Temperatura do cluster irá atuar como um mecanismo de resfriamento do cluster, assim que for detectado um aumento de temperatura, já que muitos computadores fazem parte do cluster, ou até mesmo desligando o cluster caso a temperatura não abaixe 243 Gerenciador de Processos Esta máquina ficará responsável em distribuir os processos no cluster, de tal forma que nenhuma máquina fique sobrecarregada em relação às outras Este equipamento é muito importante, pois em determinados momentos podese ter uma série de pequenos programas sendo executados no cluster, que se não forem bem distribuídos podem ter sua execução, e a dos outros, prejudicada Um exemplo de programa que pode ser utilizado para realizar esta tarefa é o SGE, Sun Grid Engine O SGE é um ambiente para a execução remota de programas UNIX em um grupo de computadores que operam em um cluster [9] Os programas são enfileirados e executados remotamente nos computadores no momento em que esses computadores estão disponíveis, se não houver um número suficiente de computadores disponíveis para executar o programa, ele ficará esperando até que a quantidade de computadores necessária para o programa esteja disponível O número de computadores utilizados no cluster é igual ao número de computadores que foram requeridos pelo programa, os outros computadores do cluster que não forem utilizados estarão disponíveis para um outro programa Os comandos utilizados para trabalhar com o SGE são: qacct: extrai informações de controle a partir do arquivo de log do cluster; qalter: modifica as características do programa submetido; qconf: possibilita ao usuário a configuração, modificação, deleção e consulta as filas de programas e a configuração do cluster; qdel: este comando possibilita um meio para o usuário ou administrador do cluster cancelar algum programa; qhold: guarda os programas submetidos que seriam executados;

7 qhost: exibe as informações sobre o estado de execução dos computadores no cluster; qlogin: inicia um terminal telnet ou uma sessão de login similar; qmake: é um comando similar ao make do UNIX Este comando adiciona ao make a possibilidade de distribuir os passos pelos computadores do cluster; qmod: permite ao proprietário de uma fila suspender e ativar todas as filas associadas a uma máquina ( todos os programas ativos associados a máquina são sinalizados ), ou suspender e ativar todos os programas em execução daquela fila; qmon: este comando é uma interface para os comandos Motif para todas as funções do SGE; qresub: cria um novo programa através de uma cópia do processo atual em execução ou de algum processo na fila; qrls: libera os programas que foram guardados pelo qhold; qrsh: este comando pode ser utilizado para vários propósitos, como providenciar a execução remota de aplicações a partir do SGE, comparável ao comando rsh do UNIX; qselect: exibe uma lista com os nomes das filas que obedecem a um critério específico; qsh: abre um terminal de comando em um computador do cluster, similar ao xterm Qualquer tipo de programa pode ser executado neste terminal; qstat: exibe uma lista com todos os programas e filas associadas ao cluster; qtcsh: este comando cria um ambiente totalmente compatível com o conhecido tcsh Ele providencia um terminal com as extensões de execução distribuída de aplicações; qsub: este comando é utilizado para se submeter um programa ao cluster pelo SGE 7

8 8 244 Monitor de Rede Este programa será responsável por realizar a medição da carga de operação da rede do cluster Ele irá informar qual a taxa de utilização de rede, e quais os computadores que estão realizando alguma transferência de dados pela rede Este acompanhamento deve ser feito de tal forma que não interfira na comunicação dos computadores, e ao mesmo tempo deve ser feito em tempo real, no instante em que houver algum tráfego de dados na rede Um dado relevante do monitor de rede é que ele irá informar qual a carga de dados total passada em um determinado instante entre dois computadores Em um cluster de computadores que tem como objetivo realizar um processamento em uma base de dados, seria mais relevante se o monitor de rede informasse ao usuário apenas a carga de dados pertencente a massa que será utilizada para efetuar o processamento entre os computadores do cluster, sem incluir os dados referentes ao controle feito pelo protocolo de rede Para que isso ocorresse o monitor de rede deveria fazer a separação entre os dados referentes a aplicação do usuário e os dados referentes ao gerenciamento efetuado pelo protocolo de rede Isso pode ser feito de duas formas: através de um sistema que fosse capaz de capturar um bloco de dados e reconhecer a parte referente ao protocolo de rede e a parte referente aos dados do usuário e contabilizar apenas a parte de dados do usuário, ou através de um sistema que ao detectar um envio de dados feito pelo programa do usuário para a rede, capturasse as informações referentes a esses dados e as exibisse ao usuário A segunda maneira, a principio parece ser impraticável, pois como o monitor de rede irá detectar o instante do envio de dados para a rede? Para contornar esse problema seria necessário que a aplicação que estiver sendo executada no cluster informasse ao monitor de rede que irá fazer uso da rede antes de enviar dados para a rede Mas isso também é, a princípio, uma tarefa complicada para ser feita pela aplicação do usuário, já que o objetivo da aplicação é realizar um processamento programado pelo usuário e não o de ser um auxiliar do monitor de rede Como uma aplicação executada em um cluster deve utilizar uma biblioteca para realizar o processamento, a solução para esse problema pode ser uma modificação na biblioteca de processamento para que essa biblioteca possa interagir com o monitor de rede Dessa forma, a aplicação do usuário irá continuar da mesma forma, não necessitando de alteração para que o monitor de rede possa trabalhar Esta é a proposta desta monografia, o desenvolvimento de uma ferramenta que irá trabalhar como um monitor de rede para uma aplicação MPI O monitor de rede, na verdade, é dividido em duas partes principais: uma biblioteca para execução de programas no cluster, e um aplicativo de visualização da carga da rede Uma das bibliotecas utilizadas em aplicações paralelas é a biblioteca MPI A biblioteca MPI é um padrão para passagem de mensagens em ambientes com computadores distribuídos interligados por uma rede [10]

9 9 Desta forma a biblioteca MPI proporciona um ambiente onde toda a rede de computadores passa a funcionar como um supercomputador Mas MPI não é um ambiente completo de computação paralela Algumas características, como gerenciamento dos processos e depuração do programa, não estão presentes no MPI O que a biblioteca MPI garante é um ambiente eficiente e seguro para troca de dados entre os computadores em um cluster Seria útil se a biblioteca MPI permitisse a visualização dos dados que são passados entre os processos no cluster, através de um monitor de rede que estivesse conectado ao cluster Esta visualização permitiria ao programador acompanhar a execução do programa e identificar pontos que contenham algum tipo de anormalidade Um depurador poderá realizar esta tarefa para o usuário, pois um depurador é uma ferramenta utilizada para localizar erros lógicos em um programa em execução, esses erros são conhecidos como bugs Apesar de o programa ter sido compilado e linkado corretamente, ele não é executado com sucesso Por exemplo, o programa retorna uma saída incorreta, ou entra em um loop infinito, ou termina de forma prematura [2] Para que a biblioteca MPI possa enviar os dados referentes as mensagens passadas no programa do usuário, deve-se alterar o modo de execução das instruções desta biblioteca As instruções, ao serem executadas, devem também enviar ao visualizador os dados referentes a mensagem que elas estão manipulando No capítulo 3, onde é mostrada a biblioteca MPI serão discutidos quais dados podem ser passados para o visualizador de acordo com a instrução que está sendo executada

10 10 3 A Biblioteca MPI Será mostrado neste capítulo o funcionamento da biblioteca MPI, algumas de suas funções, e como essas funções operam Também será mostrado quais funções poderiam ser alteradas, e que tipo de alteração poderia ser feito, para que a biblioteca MPI possa ser utilizada para operar em conjunto com um monitor de rede 31 A Arquitetura do Sistema MPI Esta seção discute como é a arquitetura de execução de um programa MPI Esta arquitetura consiste de um programa MPI sendo executado em um cluster de máquinas, cada uma com sua própria memória local A figura (31) demonstra a organização da arquitetura de execução MPI: Figura 31: Organização da arquitetura de execução MPI Programa MPI do Usuário: Nesta camada será feita a execução do programa MPI feito pelo usuário; Biblioteca MPI: Esta camada é responsável pelo gerenciamento das mensagens trocadas pelos computadores do cluster; Protocolo de Rede: Esta camada fornece um ambiente de comunicação confiável entre as máquinas do cluster; Rede Física: É nesta camada que a troca de mensagens se efetuará Ela será responsável pelo envio dos dados entre os computadores do cluster Durante a execução de um programa MPI feito pelo usuário, este programa irá realizar uma série de trocas de mensagens entre os computadores do cluster Estas trocas de mensagens são administradas pela biblioteca MPI, que irá, através do protocolo de rede, realizar a comunicação

11 11 entre os vários computadores em um cluster Por sua vez, o protocolo de rede irá interagir com a rede física para que a comunicação entre os computadores possa ser efetivada[5] A dependência entre as camadas ocorre devido ao fato de que as camadas superiores não possuem os meios para realizar a tarefa da camada imediatamente inferior por si só O programa MPI feito pelo usuário, não poderia efetuar a troca de mensagens entre os computadores do cluster se não fosse a biblioteca MPI E a biblioteca MPI da mesma forma depende da camada de protocolo de rede, pois não pode identificar os computadores que compõem o cluster E por sua vez a camada de protocolo de rede ficaria impossibilitada de completar uma transferência de dados se esta não fosse realizada pela rede física 32 Funcionamento do MPI A comunicação realizada entre os processos MPI é baseada em três conceitos básicos: grupos, contextos e comunicadores 321 Grupos de Processos Um processo é um programa em execução A biblioteca MPI proporciona um modo de execução em que um mesmo programa é executado em diversas máquinas, em paralelo Os programas distribuídos em um cluster, apesar de essencialmente serem apenas um programa, são executados de forma independente em cada máquina do cluster, ou iniciados como processos independentes quando se executa o programa em apenas uma máquina, como mostra a figura 32, e sincronizados através das funções oferecidas pela biblioteca MPI Figura 32: Distribuição dos processos MPI em um cluster (a), e em uma máquina (b)

12 12 Um grupo é uma coleção ordenada de processos, onde cada processo é identificado por um rank Para um grupo de N processos, o conjunto de ranks vai de 0 à N-1 O grupo de processos pode ser utilizado sob dois aspectos: comunicação e paralelismo No que diz respeito à comunicação, faz-se uso do grupo para podermos especificar quais processos estarão envolvidos em uma determinada troca de dados E em relação ao paralelismo, pode ser especificado no programa qual grupo irá executar uma determinada seqüência do programa feito pelo usuário Desta forma obtem-se um verdadeiro ambiente MIMD, Múltiplas Instruções e Múltiplos Dados A especificação da biblioteca MPI adota um modelo estático de processo [6], sendo que no momento em que a aplicação é iniciada, um número fixo de processos será designado, desde o início até o fim Não haverá diminuição nem aumento do número de processos durante a execução do programa no cluster 322 Contexto da Comunicação O Contexto da Comunicação foi implementado para se possibilitar a criação de um ambiente distinto e separado para passagem de dados entre os processos, sendo que cada aplicação terá um único contexto [10] Um exemplo típico que sugere o uso de contexto é a necessidade de se garantir que uma mensagem passada em um determinado momento da aplicação, não seja incorretamente interceptada em outro momento da aplicação A principal questão aqui é garantir que uma determinada mensagem possa trafegar corretamente pelo cluster, sem haver perda em seu conteúdo Uma aplicação MPI executada em um cluster possuirá o seu próprio contexto de comunicação, um ambiente fechado para realizar a troca de dados entre os processos desta aplicação, não interferindo em nenhum momento com uma outra aplicação MPI que possa estar sendo executada no mesmo cluster

13 13 Figura 33: Contexto de uma aplicação MPI A figura 33 mostra como é a separação feita pela biblioteca MPI para diferenciar duas aplicações MPI rodando em um mesmo cluster 323 Comunicador Na biblioteca MPI são definidos objetos denominados comunicadores, que irão definir o escopo de comunicação entre os processos MPI [10] Os comunicadores serão utilizados dentro do contexto de um grupo O escopo de uma operação de comunicação é definido pelo contexto de comunicação utilizado, e o grupo envolvido Em uma comunicação ponto-a-ponto a especificação da origem e do destino da mensagem é feita pelo rank dos processos envolvidos nesta tarefa Quando se utiliza mais de um grupo de processos na aplicação, tanto o rank dos processos quanto os grupos necessitam ser especificado A biblioteca MPI automaticamente define um comunicador padrão denominado MPI_COMM_WORLD Este é o comunicador referente a todos os processos [8] Utilizando este comunicador, qualquer par de processos pode realizar uma comunicação O usuário pode definir novos comunicadores como sendo um subconjunto dentro do MPI_COMM_WORLD Para que haja uma execução correta do programa no cluster, isto é, para que ao final da execução de todos os programas no cluster, o resultado obtido seja correspondente ao esperado, assumindo que o programa foi escrito corretamente, as três propriedades descritas anteriormente devem estar trabalhando de forma integrada

14 14 33 Utilização da Biblioteca MPI A biblioteca MPI ao iniciar um programa em um cluster, inicia uma cópia do programa em cada máquina do cluster necessária para a execução do programa Para tal, o programa deve ser passado ao executor de programas da biblioteca MPI, que pode ser denominado mpirun ou mpiprun [8], dependendo do desenvolvedor da biblioteca Ambos os nomes estão de acordo com o padrão definido para a biblioteca MPI Basta digitar o seguinte comando: $ mpirun np 8 aout Neste caso, serão iniciados 8 cópias do programa aout em no máximo 8 computadores do cluster Caso hajam menos que 8 computadores no cluster, haverá uma distribuição uniforme das cópias do programa aout entre os computadores Ao serem iniciadas as 8 cópias do programa, cada uma não é capaz de se comunicar com qualquer outra cópia do programa Isto ocorre porque não houve uma organização das cópias do programa que estão em execução no cluster Para que haja uma organização das cópias do programa, de tal forma que possa existir uma comunicação confiável, são necessárias algumas chamadas a funções da biblioteca MPI Estas funções são descritas nos tópicos a seguir 331 Inicialização A primeira instrução a ser executada em um programa MPI deve ser MPI_Init() [8] Os argumentos passados para esta instrução são: MPI_Init( int *argc, char **argv); Após executar esta instrução todos os processos MPI no cluster têm seu rank definido Seria útil ao programador ter nesse ponto alguma informação sobre a inicialização dos processos no cluster, saber, por exemplo, qual computador está executando um determinado processo Desta forma ele teria um melhor controle sobre o programa 332 Leitura da quantidade de processos e a identificação de cada processo no cluster Duas instruções são fundamentais para uma boa utilização de uma aplicação paralela, e são: a quantidade total de processos em execução e a identificação de cada processo no cluster Estas informações são obtidas a partir do comunicador global MPI_COMM_WORLD [6], utilizando-se a função MPI_Comm_size() e também a função MPI_Comm_rank() Os argumentos para estas funções são: MPI_Comm_size( MPI_COMM_WORLD, int *quant_procs );

15 15 MPI_Comm_rank( MPI_COMM_WORLD, int *rank ); Após a execução destas instruções têm-se os valores da quantidade total de processos e da identificação de cada processo nas variáveis quant_procs e rank, respectivamente É importante observar que cada processo irá executar estas duas instruções, e em todos eles a variável quant_procs possuirá o mesmo valor, mas a variável rank será diferente para cada um, pois ela irá armazenar o valor do identificador de cada processo, que é específico para cada um 333 Finalização Para finalizar a execução de um processo MPI deve-se utilizar o comando MPI_Finalize() Não existem parâmetros a serem passados a essa instrução A finalização de uma aplicação MPI é um processo que não ocorre no instante da chamada da instrução MPI_Finalize, pois a biblioteca MPI deve garantir que a aplicação termine corretamente, isto é, deve ser garantido que não existem pendências a serem atendidas pela biblioteca MPI Para garantir isso é feita a seguinte verificação para o processo que executou a instrução MPI_Finalize: Verificar se existe mensagem no buffer a ser enviada para algum outro processo o Caso existe alguma mensagem a ser enviada, enviar a mensagem antes de finalizar o processo MPI Após a execução da instrução MPI_Finalize, o rank dos processos no cluster é indefinido Os processos só terminam de executar quando chegam ao final do código fonte A depuração desta instrução também é interessante, para permitir ao usuário ter conhecimento de quais processos terminaram, e em que ordem 334 Passagem de Mensagem Um programa sendo executado em um cluster, através da biblioteca MPI, irá necessitar realizar uma série de troca de informações entre os computadores do cluster, para dividir o trabalho de processamento Essa troca de informações é feita utilizando-se uma série de funções da biblioteca MPI que serão descritas nos tópicos a seguir 3341 Categorias de Funções Existem duas categorias de funções para passagem de mensagem: funções bloqueantes e funções não bloqueantes

16 16 Funções Bloqueantes: A função não é concluída até o momento de sua finalização Funções Não Bloqueantes: A função é finalizada imediatamente, apenas sendo iniciada a operação de transferência da mensagem, não esperando o seu término Figura 34: Passagem de Mensagem Bloqueante (a) e Passagem de Mensagem Não Bloqueante (b) Representado na figura 34a está o exemplo de funcionamento de uma função bloqueante Neste caso o processo 1 irá passar uma mensagem ao processo 2 A biblioteca MPI irá realizar esta passagem de mensagem mas só irá liberar o processo 1 quando o processo 2 tiver terminado de receber a mensagem Na figura 34b a biblioteca libera o processo 1 instantaneamente, sem que o processo 2 tenha recebido ainda a mensagem 3342 Funções Bloqueantes na comunicação ponto a ponto entre processos Esta seção irá descrever algumas das funções da biblioteca MPI que são bloqueantes na comunicação ponto a ponto entre processos: MPI_Send: Envia uma mensagem no modo padrão A função termina quando o MPI coloca a mensagem no buffer local ou quando a mensagem é recebida por outro processo MPI_Bsend: Envia a mensagem para o buffer de armazenamento local da aplicação, e finaliza a instrução Caso a mensagem não caiba no buffer o resultado é indefinido O usuário é responsável por alocar um buffer adequado para esta instrução, utilizando as funções MPI_Buffer_Attach e MPI_Buffer_Detach[8] MPI_Ssend: Envia a mensagem em modo síncrono A função termina quando for totalmente recebida por um outro processo MPI_Rsend: Envia a mensagem para o destina sem utilizar o buffer Neste caso deve existir uma instrução para receber a mensagem no destino no exato momento que for executado o

17 17 MPI_RSend, caso contrário o resultado é indefinido Ao enviar a mensagem para o destino, a instrução termina MPI_Recv: Esta instrução é utilizada para receber a mensagem Pode ser utilizada qualquer um dos 4 tipos de instruções para enviar a mensagem Só existe 1 modo de receber Esta função termina quando a mensagem é recebida MPI_Sendrecv: Esta função irá enviar a mensagem no modo padrão, e depois irá receber uma mensagem de outro processo MPI_Probe: Esta função irá checar se existe algum processo tentando enviar uma mensagem Ela só termina quando existir tal processo Os parâmetros utilizados para a execução do MPI_Send, MPI_Bsend, MPI_Ssend e MPI_Rsend são os mesmos: MPI_Send(*buf, count, datatype, dest, tag, comm); *buf refere-se ao endereço do mensagem a ser passada count indica o número de elementos da mensagem, datatype indica o tipo de dado armazenado na mensagem, dest refere-se ao processo que irá receber a mensagem, tag valor utilizado para diferenciar uma mensagem de outra, comm irá informar qual o comunicador utilizado Esse é mais um conjunto de instruções onde haveria um impacto positivo no desenvolvimento do programa, se houvesse a possibilidade de visualização dos parâmetros passados a função Assim o programador saberia qual informação está sendo enviada para um processo, o tamanho dessa informação, o tipo de dado, e qual o rank do processo de destino que irá receber essa informação Com isso ele poderá identificar se algum processo está mandando uma informação incorreta para outro processo, ou se a informação está correta mas o processo de destino não é o correto Quando se utiliza a instrução MPI_BSend deve-se garantir que um buffer com tamanho suficiente exista para armazenar a mensagem a ser passada Para isso utiliza-se as instruções MPI_Buffer_attach() e MPI_Buffer_detach() [3] int MPI_Buffer_attach(void* buffer, int size); int MPI_Buffer_detach(void* buffer, int size); *buffer refere-se ao endereço do buffer, size irá informar qual o tamanho a ser utilizado A instrução MPI_Recv irá utilizar os seguintes parâmetros: MPI_Recv(*buf, count, datatype, source, tag, comm, *status); *buf refere-se ao endereço do local que receberá a mensagem count indica o número de elementos reservado para a mensagem, datatype indica o tipo de dado de cada elemento a ser armazenado,

18 18 source refere-se ao processo que irá enviar a mensagem, pode-se utilizar a variável MPI_ANY_SOURCE indicando que se deseja receber uma mensagem de qualquer processo, tag valor utilizado para diferenciar uma mensagem de outra, pode-se utilizar a variável MPI_ANY_TAG indicando que se deseja receber uma mensagem com qualquer tag, comm irá informar qual o comunicador utilizado, *status indica o estado da mensagem Se for necessário saber qual o rank do processo que enviou a mensagem, ou qual a tag utilizada, basta ler diretamente de statusmpi_source e statusmpi_tag A instrução MPI_Recv só irá terminar se houver algum processo que enviou uma informação para o processo que a executou Se houvesse uma maneira de o usuário visualizar os parâmetros desta instrução, ele poderia verificar se o valor do rank do processo que irá enviar a mensagem está correto ou não, pois se estiver incorreto poderá ocorrer um erro no processamento da informação, ou um travamento do programa, pois o processo iria ficar esperando por uma mensagem que nunca será enviada A instrução MPI_Sendrecv utiliza os seguintes parâmetros: MPI_Sendrecv(*sendbuf, sendcount, sendtype, dest, sendtag,*recvbuf, recvcount, recvtype, source, recvtag, comm, *status); *sendbuf refere-se ao endereço da mensagem a ser passada, sendcount indica a quantidade de elementos a serem enviados, sendtype indica o tipo de dado de cada elemento armazenado na mensagem, dest refere-se ao processo que irá receber a mensagem, sendtag valor da tag de envio da mensagem, *recvbuf refere-se ao endereço do local que receberá a mensagem, recvcount indica o número de elementos reservado para a mensagem, recvtype indica o tipo de dado de cada elemento a ser armazenado, source refere-se ao processo que irá receber a mensagem, recvtag valor da tag de recebimento da mensagem, comm irá informar qual o comunicador utilizado, *status indica o estado da mensagem Esta instrução também poderia passar por um depurador, para o programador conferir se os parâmetros estão corretos, se não existe conflito entre os ranks de destino e origem, se esses ranks estão com os valores dos ranks dos processos corretos, se a informação a ser enviada está correta, se está ocorrendo deadlock A instrução MPI_Probe utiliza os seguintes parâmetros: MPI_Probe( source, tag, comm, *status);

19 19 source refere-se ao processo que irá enviar a mensagem, pode-se utilizar a variável MPI_ANY_SOURCE tag valor utilizado para diferenciar uma mensagem de outra, pode-se utilizar a variável MPI_ANY_TAG comm irá informar qual o comunicador utilizado *status indica o estado da mensagem Como esta função só termina quando houver um processo tentando enviar uma mensagem para o processo que a executou, o programa corre o risco de entrar em deadlock se for passado um rank errado como parâmetro Um depurador que mostrasse ao usuário os parâmetros passados nesta instrução permitiria ao usuário evitar esse problema 3343 Funções Não Bloqueantes na comunicação ponto a ponto entre processos Esta seção irá descrever algumas das funções da biblioteca MPI que não são bloqueantes na comunicação ponto a ponto entre processos: MPI_Isend: Inicia o envio a mensagem no modo padrão MPI_Ibsend: Inicia o envio da mensagem para o buffer de armazenamento local da aplicação MPI_Issend: Inicia o envio da mensagem em modo síncrono MPI_Irsend: Inicia o envia da mensagem para o destina sem utilizar o buffer MPI_Irecv: Inicia o recebimento da mensagem Estas instruções apenas iniciam o processo de envio ou recebimento de uma mensagem, não garantindo que a mensagem será enviada ou recebida corretamente Para se garantir deve-se verificar se a instrução passada anteriormente foi executada, isso é feito por uma das funções descritas a seguir: MPI_Wait: Esta instrução finaliza uma instrução específica de passagem de mensagem pendente Ela só retorna quando a instrução for concluída MPI_Waitany: Esta instrução finaliza alguma instrução de passagem de mensagem pendente Ela só retorna quando alguma instrução for concluída MPI_Waitall: Esta instrução finaliza todas as instruções de passagem de mensagem pendentes Ela só retorna quando todas as instruções forem concluídas MPI_Waitsome: Esta instrução finaliza pelo menos uma das instruções de passagem de mensagem pendentes Ela só retorna quando pelo menos uma das instruções forem concluídas MPI_Test: Esta instrução verifica se uma determinada instrução de passagem de mensagem pendente foi concluída Seu retorno é imediato

20 20 MPI_Testany: Esta instrução verifica se alguma instrução de passagem de mensagem pendente foi concluída Seu retorno é imediato MPI_Testall: Esta instrução verifica se todas as instruções de passagem de mensagem pendentes foram concluídas Seu retorno é imediato MPI_Testsome: Esta instrução verifica se pelo menos uma instrução de passagem de mensagem pendente foi concluída Seu retorno é imediato Existem ainda as instruções: MPI_IProbe: Verifica se algum processo vai enviar uma mensagem MPI_Cancel: Marca uma instrução de passagem de mensagem que está pendente para ser cancelada MPI_Test_Cancelled: Verifica se a instrução já foi cancelada Os parâmetros utilizados para a execução do MPI_Isend, MPI_Ibsend, MPI_Issend e MPI_Irsend são os mesmos: MPI_Isend( *buf, count, datatype, dest, tag, comm, *request); *buf refere-se ao endereço do mensagem a ser passada count indica o número de elementos da mensagem, datatype indica o tipo de dado armazenado na mensagem, dest refere-se ao processo que irá receber a mensagem, tag valor utilizado para diferenciar uma mensagem de outra, comm irá informar qual o comunicador utilizado *request armazena esta requisição Os parâmetros passados a função MPI_Irecv são: MPI_Irecv(*buf, count, datatype, source, tag, comm, *request); *buf refere-se ao endereço do local que receberá a mensagem count indica o número de elementos reservado para a mensagem, datatype indica o tipo de dado de cada elemento a ser armazenado, source refere-se ao processo que irá enviar a mensagem, pode-se utilizar a variável MPI_ANY_SOURCE indicando que se deseja receber uma mensagem de qualquer processo, tag valor utilizado para diferenciar uma mensagem de outra, pode-se utilizar a variável MPI_ANY_TAG indicando que se deseja receber uma mensagem com qualquer tag, comm irá informar qual o comunicador utilizado, *request armazena esta requisição As instruções MPI_Isend, MPI_Ibsend, MPI_Issend, MPI_Irsend e MPI_Irecv são semelhantes as instruções MPI_Send, MPI_Bsend, MPI_Ssend, MPI_Rsend e MPI_Recv, a diferença é que as primeiras apenas iniciam o processo de envio da mensagem, retornando logo após a sua chamada Um

21 21 depurador para as instruções não bloqueantes funcionaria do mesmo modo que um depurador para as instruções bloqueantes Os parâmetros passados para a instrução MPI_Wait são: MPI_Wait(*request, *status); *request requisição a ser processada *status indica o estado da requisição Um depurador para esta instrução poderia exibir ao usuário as informações sobre a requisição passada para a função Assim o programador poderia verificar se a requisição passada esta correta Os parâmetros passados para a instrução MPI_Waitany são: MPI_Waitany( count, *array_of_requests, *index, *status); count quantidade de elementos na lista de requisições *array_of_requests lista de requisições a serem processadas *index índice da requisição que foi concluída *status indica o estado da requisição Na instrução MPI_Waitany, o depurador poderá exibir ao programador as informações referentes a lista de requisições, para que possa ser feita a verificação de que a requisição desejada corresponde ao valor do índice passado Os parâmetros passados para a instrução MPI_Waitall são: MPI_Waitall( count, *array_of_requests, *array_of_statuses ); count quantidade de elementos na lista de requisições e estados *array_of_requests lista de requisições a serem processadas *array_of_statuses lista de estados da requisições Para esta instrução, o depurador iria permitir a visualização da lista de requisições e da lista de status, para que possa ser feita o acompanhamento das requisições e verificar em que momento todas são concluídas, e se existiu alguma que não foi concluída por algum motivo Os parâmetros passados para a instrução MPI_Waitsome são: MPI_Waitsome( incount, *array_of_requests, *outcount, *array_of_indices, *array_of_statuses); incount quantidade de elementos na lista de requisições, índices e estados *array_of_requests lista de requisições a serem processadas *outcount quantidade de requisições que foram concluídas *array_of_indices lista com os índices das requisições que foram concluídas

22 22 *array_of_statuses lista de estados da requisições Na instrução MPI_Waitsome, o depurador poderia permitir ao programador visualizar o conteúdo das listas de requisição, índice e status As funções MPI_Test, MPI_Testany, MPI_Testall e MPI_Testsome poderiam ser utilizadas no depurador da mesma forma que as funções MPI_Wait, MPI_Waitany, MPI_Waitall e MPI_Waitsome Os parâmetros passados para a instrução MPI_Test são: MPI_Test(*request, *flag, *status); *request requisição a ser processada *flag indica se a operação foi concluída Se a operação foi concluída retorna TRUE senão retorna FALSE *status indica o estado da requisição Os parâmetros passados para a instrução MPI_Testany são: MPI_Testany( count, *array_of_requests, *index, *flag, *status); count quantidade de elementos na lista de requisições *array_of_requests lista de requisições a serem processadas *index índice da requisição que foi concluída Se nenhuma requisição foi concluída assume o valor MPI_UNDEFINED *flag se a operação foi concluída retorna TRUE senão retorna FALSE *status indica o estado da requisição Os parâmetros passados para a instrução MPI_Testall são: ); MPI_Testall(count, *array_of_requests, *flag, *array_of_statuses count quantidade de elementos na lista de requisições e estados *array_of_requests lista de requisições a serem processadas *flag se todas as operações foram concluídas retorna TRUE senão retorna FALSE *array_of_statuses lista de estados da requisições Os parâmetros passados para a instrução MPI_Testsome são: MPI_Testsome( incount, *array_of_requests, *outcount, *array_of_indices, *array_of_statuses); incount quantidade de elementos na lista de requisições, índices e estados *array_of_requests lista de requisições a serem processadas *outcount quantidade de requisições que foram concluídas *array_of_indices lista com os índices das requisições que foram concluídas *array_of_statuses lista de estados da requisições

23 23 Os parâmetros passados à função MPI_Iprobe são: MPI_Iprobe( source, tag, comm, *flag, *status); source refere-se ao processo que irá enviar a mensagem, pode-se utilizar a variável MPI_ANY_SOURCE tag valor utilizado para diferenciar uma mensagem de outra, pode-se utilizar a variável MPI_ANY_TAG comm irá informar qual o comunicador utilizado comm comunicador utilizado *flag retorna TRUE se existir alguma mensagem a ser enviada, senão retorna FALSE *status indica o estado da mensagem Para a instrução MPI_Iprobe, um depurador iria exibir o conteúdo dos parâmetros passados a instrução, para o programador verificar se todos estão corretos, pois caso algum deles esteja errado o resultado final do programa estará incorreto Os parâmetros passados à instrução MPI_Cancel são: MPI_Cancel( *request ); *request requisição a ser processada No caso da instrução MPI_Cancel, o valor da requisição poderia ser mostrado ao usuário pelo depurador, assim seria fácil identificar um provável erro dentro do programa, caso se verificasse que a requisição não é a correta, ou que não havia necessidade de ser cancelada Os parâmetros passados à instrução MPI_Test_Cancelled são: MPI_Test_cancelled( status, *flag ); status refere-se estado de uma mensagem *flag retorna TRUE se a mensagem associada a variável status foi cancelada com sucesso, senão retorna FALSE Nesta instrução, o depurador seria utilizado para exibir o conteúdo de status e flag, para que o programador verificasse se a variável status se refere a requisição que ele quer verificar se foi cancelada 3344 Funções Bloqueantes na Comunicação Coletiva Esta seção irá descrever algumas das funções da biblioteca MPI que são bloqueantes na comunicação coletiva: MPI_Barrier: Esta função paralisa o processo que a executou até que todos os processos do grupo executem esta mesma função, e então continua

24 24 MPI_Bcast: Esta função envia uma mensagem a todos os processos de um determinado grupo Figura 35: Exemplo do funcionamento da instrução MPI_Bcast MPI_Gather: Esta função é utilizada para receber uma mensagem de todos os processos e concatená-las no processo destino Figura 36: Exemplo do funcionamento da instrução MPI_Gather MPI_Allgather: Esta função realiza o MPI_Gather e depois o MPI_Bcast Figura 37: Exemplo de funcionamento da instrução MPI_Allgather MPI_Scatter: Esta função separa uma mensagem e então a distribui para todos os processos do grupo

25 25 Figura 38: Exemplo de funcionamento da instrução MPI_Scatter MPI_Alltoall: Esta função executa a instrução MPI_Gather e depois executa a instrução MPI_Scatter MPI_Reduce: Combina as mensagens dos processos obedecendo uma determinada função Figura 39: Exemplo da função MPI_Reduce realizando uma soma MPI_Allreduce: Esta função realiza um MPI_Reduce e depois realiza um MPI_Bcast MPI_Reduce_scatter: Esta função realiza um MPI_Reduce e depois realiza um MPI_Scatter Os parâmetros passados a função MPI_Barrier são: MPI_Barrier( comm); comm comunicador utilizado pelo grupo Para a instrução MPI_Barrier, um depurador seria útil na verificação do comunicador, isso permitiria ao usuário checar se o comunicador passado como parâmetro é o comunicador correto

26 26 Os parâmetros passados a função MPI_Bcast são: MPI_Bcast( *buffer, count, datatype, root, comm); *buf refere-se ao endereço da mensagem a ser passada count indica o número de elementos da mensagem, datatype indica o tipo de dado armazenado na mensagem, root refere-se ao processo que irá enviar a mensagem, comm comunicador utilizado pelo grupo Na instrução MPI_Bcast, um depurador seria utilizado para mostrar o conteúdo da variável buffer, para que o usuário verificasse se a informação que será passada está correta, e também poderia ser visualizado o valor de root, para verificar se seu valor corresponde ao processo que será utilizado para enviar a mensagem Os parâmetros passados a função MPI_Gather são: MPI_Gather( *sendbuf, sendcount, sendtype, *recvbuf, recvcount, recvtype, root, comm); *sendbuf refere-se ao endereço da mensagem a ser enviada sendcount indica o número de elementos da mensagem a ser enviada sendtype indica o tipo de dado armazenado na mensagem a ser enviada *recvbuf refere-se ao endereço do local que receberá a mensagem recvcount indica o número de elementos a serem recebidos recvtype indica o tipo de dado a ser armazenado root refere-se ao processo que irá enviar a mensagem comm comunicador utilizado pelo grupo Nessa instrução, o programador poderia utilizar um depurador para verificar o conteúdo da variável root, para checar se o processo onde se quer ter o resultado final realmente receberá esse resultado, também poderia ser exibido ao usuário o conteúdo da variável sendbuf, para checar se os dados dentro dela estão corretos, e também verificar o conteúdo da variável recvbuf, para verificar se o seu conteúdo está preenchido com os valores corretos Isso se aplica também a instrução MPI_Allgather Os parâmetros passados a função MPI_Allgather são: MPI_Allgather( *sendbuf, sendcount, sendtype, *recvbuf, recvcount, recvtype, comm); *sendbuf refere-se ao endereço da mensagem a ser enviada sendcount indica o número de elementos da mensagem a ser enviada sendtype indica o tipo de dado armazenado na mensagem a ser enviada *recvbuf refere-se ao endereço do local que receberá a mensagem recvcount indica o número de elementos a serem recebidos

27 27 recvtype indica o tipo de dado a ser armazenado comm comunicador utilizado pelo grupo Os parâmetros passados a função MPI_Scatter são: MPI_Scatter( *sendbuf, sendcount, sendtype, *recvbuf, recvcount, recvtype, root, comm); *sendbuf refere-se ao endereço da mensagem a ser enviada sendcount indica o número de elementos da mensagem a ser enviada sendtype indica o tipo de dado armazenado na mensagem a ser enviada *recvbuf refere-se ao endereço do local que receberá a mensagem recvcount indica o número de elementos a serem recebidos recvtype indica o tipo de dado a ser armazenado root refere-se ao processo que irá enviar a mensagem comm comunicador utilizado pelo grupo Os parâmetros passados a função MPI_Alltoall são: MPI_Alltoall( *sendbuf, sendcount, sendtype, *recvbuf, recvcount, recvtype, comm); *sendbuf refere-se ao endereço da mensagem a ser enviada sendcount indica o número de elementos da mensagem a ser enviada sendtype indica o tipo de dado armazenado na mensagem a ser enviada *recvbuf refere-se ao endereço do local que receberá a mensagem recvcount indica o número de elementos a serem recebidos recvtype indica o tipo de dado a ser armazenado comm comunicador utilizado pelo grupo As funções MPI_Scatter e MPI_Alltoall seriam utilizadas no depurador de uma forma semelhante, o depurador poderia mostrar ao programador o conteúdo das variáveis sendbuf e recvbuf em ambas as instruções, e no caso da instrução MPI_Scatter, também seria interessante visualizar o conteúdo da variável root Os parâmetros passados a função MPI_Reduce são: MPI_Reduce( *sendbuf, *recvbuf, count, datatype, op, root, comm); *sendbuf refere-se ao endereço da mensagem a ser enviada *recvbuf refere-se ao endereço do local que receberá a mensagem count indica o número de elementos a serem recebidos datatype indica o tipo de dado a ser armazenado op indica a operação a ser realizada entre as mensagens dos processos

28 28 root indica o processo que receberá a mensagem final depois de combinada comm comunicador utilizado pelo grupo As operações predefinidas que podem ser utilizadas para combinas a mensagem são: Operação Descrição Operação Descrição MAX Máximo MIN Mínimo SUM Soma PROD Produto LAND AND Lógico BAND AND Binário LOR OR Lógico BOR OR Binário LXOR XOR Lógico BXOR XOR Binário MINLOC Calcula o mínimo e o índice do processo que contém o menor valor MAXLOC Tabela 31: Operações padrão para a instrução MPI_Reduce Calcula o máximo e o índice do processo que contém o maior valor Os parâmetros passados a função MPI_Allreduce são: MPI_Allreduce(*sendbuf, *recvbuf, count, datatype, op, root, comm); *sendbuf refere-se ao endereço da mensagem a ser enviada *recvbuf refere-se ao endereço do local que receberá a mensagem count indica o número de elementos a serem recebidos datatype indica o tipo de dado a ser armazenado op indica a operação a ser realizada entre as mensagens dos processos root indica o processo que receberá a mensagem final depois de combinada comm comunicador utilizado pelo grupo Nessas duas instruções, MPI_Reduce e MPI_Allreduce, o programador utilizaria o depurador para visualizar o conteúdo dos parâmetros dessas funções, checando qualquer conflito que possa ocorrer, seja um deadlock ou uma informação incorreta Os parâmetros passados a função MPI_Reduce_scatter são: m); MPI_Reduce_scatter(*sendbuf,*recvbuf,*recvcounts,datatype,op,com *sendbuf refere-se ao endereço da mensagem a ser enviada *recvbuf refere-se ao endereço do local que receberá a mensagem *recvcount indica o número de elementos no resultado que serão distribuídos para cada processo Deve ser igual ao número de processos no grupo

29 29 datatype indica o tipo de dado a ser armazenado op indica a operação a ser realizada entre as mensagens dos processos comm comunicador utilizado pelo grupo O depurador poderia, na instrução MPI_Reduce_scatter, mostrar ao programador, o conteúdo das variáveis sendbuf e recvbuf, para que se faça a checagem dos seus conteúdos, e também da variável recvcount para verificar se a quantidade está correta

30 30 4 Funcionamento do MPI_SPY O MPI_SPY é dividido em dois programas: SPY_View e SPY_Server O SPY_View é o visualizador propriamente dito, é a interface vista pelo usuário O SPY_Server é um servidor de mensagens, que recebe as mensagens vindas do programa MPI e as repassa para o SPY_View, como pode ser visto na Figura 41 Foi feito isto devido às características que um servidor de mensagens possui, que inviabilizam a criação de um servidor no próprio SPY_View Figura 41: Funcionamento do SPY_View Tanto o programa MPI, quanto o SPY_Server e o SPY_View, poderão estar sendo executados em uma mesma máquina, ou em máquinas diferentes Durante a execução do SPY_View é feita a interceptação de algumas instruções de uma aplicação MPI para se ter um acompanhamento de sua execução, e também para se ter uma visualização da transferência de mensagens entre os computadores do cluster, tendo assim uma visualização do uso da rede

31 31 41 Alterações feitas na biblioteca MPI Para tornar possível o desenvolvimento do SPY_View a biblioteca MPI foi alterada, para permitir que as instruções referentes a inicialização de uma aplicação MPI e as transferências de dados entre os computadores do cluster fossem interceptadas de uma maneira mais fácil Essas instruções foram alteradas, para que, quando fossem executadas, o SPY_Server fosse acionado, e conseqüentemente o SPY_View fosse capaz de mostrar ao programador alguma informação referente a instrução que foi executada O comando da biblioteca MPI alterado foi: mpirun: comando utilizado para executar o programa do usuário no cluster As instruções que foram modificadas são: MPI_Init: função utilizada para inicializar o processo MPI; MPI_Send: função utilizada para enviar uma mensagem de um processo para outro processo; MPI_Recv: função utilizada para que um processo possa receber uma mensagem vinda de outro processo; MPI_Finalize: função utilizada para finalizar um processo MPI Quando um programa MPI executa alguma dessas instruções, uma mensagem é enviada ao SPY_Server com os dados da instrução, e do computador que executou esta instrução Ao passar uma mensagem para o SPY_Server, uma nova instância do SPY_Server é criada para atender esta requisição, como pode ser visto na Figura 42 Figura 42: Atendimento de uma conexão pelo SPY_Server Um servidor de mensagens, representado por SPY_Server (p) está sendo executado em uma determinada máquina da rede aguardando o envio de uma mensagem por um programa MPI Quando um programa MPI executar uma das instruções que serão interceptadas, ele envia uma mensagem ao SPY_Server (p) O SPY_Server (p) então cria uma nova instância do servidor, representada por SPY_Server (f) para atender esta requisição e libera o programa MPI para continuar, isto é, o programa MPI não irá ficar esperando o envio da mensagem do SPY_Server para o SPY_View A nova instância do SPY_Server (p), que está representado como SPY_Server (f) ficará

32 32 responsável por realizar o envio da mensagem do programa MPI para o SPY_View, liberando assim o SPY_Server (p) para atender outras requisições 411 Definição da Mensagem a ser enviada A mensagem a ser enviada a partir da execução de uma das instruções da biblioteca MPI que foram alteradas, possuirá algumas informações que serão tratadas pelo SPY_View Cada instrução terá um conjunto de dados que serão interpretados pelo SPY_View e exibidos ao usuário A instrução mpirun é a primeira instrução da biblioteca MPI a ser executada, pois é esta instrução que será responsável em carregar o programa do usuário no cluster As informações passadas por esta instrução ao SPY_Server são: Nome da Instrução; Número de computadores utilizados; Nome da aplicação MPI O nome da instrução é a informação básica a ser passada para o SPY_View, pois será ela que irá identificar cada instrução, para que cada uma possa ser interpretada corretamente Na instrução mpirun foi necessário a inclusão de dois identificadores, pois nessa instrução ocorrerá o envio da mensagem ao SPY_Server em dois pontos distintos, como pode ser visto na Tabela 41 Instrução Nome mpirun MPI_RUN MPI_END Tabela 41: Instrução mpirun As outras instruções que serão interceptadas pelo SPY_Server são descritas na Tabela 42 Instrução Nome MPI_Init MPI_Init MPI_Send MPI_Send MPI_Recv MPI_Recv MPI_Finalize MPI_Finalize Tabela 42: Nome das instruções da biblioteca MPI O nome das instruções MPI_Init, MPI_Send, MPI_Recv e MPI_Finalize são idênticos aos nomes verdadeiros das funções na biblioteca MPI Existe um conjunto básico de dados a ser passado por cada instrução, que são: Nome da instrução; Nome do computador onde a instrução foi executada;

33 33 Rank do processo que executou a instrução; O nome do computador é uma informação que irá identificar qual computador no cluster executou alguma das instruções da Tabela 42, dessa forma será possível distinguir mais claramente qual computador está executando uma determinada instrução E acompanhado a execução do programa no cluster, poderá ser verificado qual computador está mais sobrecarregado dentre os que estão sendo utilizados pelo programa O rank do processo que executou a instrução é uma informação que irá diferenciar os processos MPI que estiverem sendo executados em um mesmo computador Todas as instruções irão passar pelo menos essas informações ao SPY_Server Informações adicionais são necessárias quando se executa uma instrução MPI_Send ou MPI_Recv Nessas duas instruções são necessários os dados: 1 O tamanho da mensagem que está sendo executada pelo cluster 2 O tipo de cada elemento no vetor de mensagens 412 Momento do Envio da Mensagem do Programa MPI para o SPY_Server Devido a algumas características das funções que são interceptadas pelo SPY_Server, elas não são interceptadas em um mesmo ponto de execução, isto é, no início de cada instrução ou antes do término 4121 Interceptando a Instrução mpirun A instrução mpirun é utilizada para se iniciar a execução de um programa no cluster, e ela é interceptada em dois pontos durante a sua execução: no início da instrução e no fim da instrução A interceptação no início é feita para se saber o instante em que a aplicação começou a ser executada Na verdade a mensagem é passada ao SPY_Server é a primeira operação dessa instrução Por ser a primeira requisição feita ao SPY_Server, esta ocorre sem problemas, pois no início não haverá qualquer outra requisição sendo atendida E ao final da instrução é feita uma nova interceptação, para se saber se houve a conclusão da aplicação MPI, como pode ser visto na Figura 43

34 34 Figura 43: Interceptação da instrução MPI_RUN A mensagem MPI_END, por ser enviada ao final da aplicação MPI, poderá encontrar o SPY_Server sobrecarregado atendendo outras instruções MPI Nesse caso, a mensagem só será recebida pelo SPY_Server, quando este não estiver mais sobrecarregado E ao receber a mensagem contendo o MPI_END, o SPY_Server só poderá enviar esta mensagem ao SPY_View, quando já tiver enviado todas as outras que estavam sendo enviadas, para garantir que a mensagem MPI_END realmente indique o fim da aplicação MPI Ao se executar o comando: $ mpirun v 4 progmpi Será iniciado o processo de execução do programa progmpi pela biblioteca MPI Antes de realizar qualquer procedimento da biblioteca MPI para administrar o programa progmpi, será enviada uma mensagem ao SPY_Server sinalizando o início da execução do programa progmpi, correspondente a passo 1 da Figura 43 Após isso são iniciados 4 processos referentes ao progmpi no cluster, e ao terminarem de executar será enviada uma nova mensagem ao SPY_Server indicando o fim da execução do programa progmpi, que está indicado na Figura 43 como passo 2

35 Interceptando a Instrução MPI_Init A instrução MPI_Init é a primeira a ser executada em um programa MPI Sendo assim durante a sua execução algumas variáveis que serão incluídas na mensagem ainda não foram inicializadas, portanto a mensagem não pode ser interceptada logo no início da execução desta instrução O ponto onde a mensagem é enviada ao SPY_Server fica próximo da metade da execução do MPI_Init Caso o SPY_Server não esteja tratando alguma outra mensagem, a operação de interceptação ocorre normalmente, e a instrução MPI_Init continua sendo executada Caso não haja uma disponibilidade do SPY_Server em atender esta requisição no instante que foi solicitado, a instrução MPI_Init ficará temporariamente paralisada, esperando o atendimento ser feito pelo SPY_Server 4123 Interceptando a Instrução MPI_Send A instrução MPI_Send é utilizada para se enviar uma mensagem de um processo a outro em uma aplicação MPI Nesta instrução, a interceptação da mensagem ocorre no início da instrução, sendo a primeira operação realizada durante sua execução Apesar de se utilizar uma instrução bloqueante, não é feita uma checagem verificando se os dados da instrução foram passados corretamente, e também não é feita uma verificação de quando a instrução é concluída, pois estas duas verificações são feitas e garantidas pela biblioteca MPI O SPY_Server recebe apenas uma mensagem indicando que a instrução MPI_Send foi utilizada pela aplicação MPI As condições para o atendimento desta mensagem pelo SPY_Server se mantêm, ou seja, a mensagem só é passada da aplicação MPI para o SPY_Server se houver menos de 5 requisições sendo atendidas, caso contrário, a instrução MPI_Send ficará aguardando o SPY_Server Quando houver uma disponibilidade do SPY_Server para o atendimento desta instrução, a mensagem será enviada da aplicação MPI para o SPY_Server e então o a biblioteca MPI seguirá normalmente com o procedimento de envio dos dados de um processo MPI para outro 4124 Interceptando a Instrução MPI_Recv A instrução MPI_Recv é utilizada para se receber uma mensagem em um processo vinda de outro em uma aplicação MPI A interceptação da instrução é análoga a interceptação do MPI_Send, ou seja, ocorre no início da instrução As regras para o atendimento desta mensagem pelo SPY_Server também são os mesmos

36 36 Da mesma forma que acontece com a instrução MPI_Send, existem mecanismos de controle que garantem o funcionamento adequado da instrução MPI_Recv, não havendo necessidade de existir uma verificação do conteúdo da mensagem pelo SPY_Server Também não existe uma verificação checando se para cada instrução MPI_Send houve a execução de uma instrução MPI_Recv, pois isto será uma verificação visual do próprio usuário ao visualizar a interface do SPY_View 4125 Interceptando a Instrução MPI_Finalize A instrução MPI_Finalize é executada ao final da execução da aplicação MPI A interceptação desta mensagem é feita no início de sua execução As regras para o atendimento desta requisição pelo SPY_Server são as mesmas regras válidas para as instruções MPI_Init, MPI_Send e MPI_Recv, ou seja, caso o limite de 5 conexões ao SPY_Server não tenha sido atingido, a mensagem será enviada ao SPY_View, caso contrário, o processo MPI ficará aguardando a disponibilidade do SPY_Server em receber essa conexão para enviar a mensagem informando a execução da instrução MPI_Finalize ao SPY_View Não existe um controle feito pelo SPY_Server para verificar se existe alguma mensagem pendente, esta verificação pe feita pela biblioteca MPI A finalização da aplicação MPI é verificada quando a instrução mpirun envia a mensagem MPI_END ao SPY_Server 413 Comportamento da aplicação MPI durante o envio da instrução Uma aplicação MPI é um conjunto de processos sendo executados em um cluster de computadores, ou em uma única máquina Como cada processo é uma aplicação independente, a ordem de execução das instruções poderá ser diferente, pois cada processo poderá estar executando uma parte diferente do código da aplicação, portanto a ordem em que as mensagens são enviadas ao SPY_Server não obedecerão a uma ordem, nem critério pré-estabelecidos, serão encaminhadas ao SPY_Server e enviadas ao SPY_View à medida que forem sendo executadas pelos processos MPI Durante o envio da instrução MPI para o SPY_Server, o processo MPI ficará temporariamente paralisado neste ponto, caso o SPY_Server esteja em execução na máquina que irá receber os dados da instrução Caso contrário, se o SPY_Server não estiver sendo executado nesta máquina, a instrução MPI irá prosseguir normalmente, como pode ser visto na Figura 44 Na Figura 44a o processo MPI esta executando uma parte do código que em determinado momento utiliza a instrução MPI_Send da biblioteca MPI Como esta instrução foi modificada para enviar uma mensagem ao SPY_Server, no instante de sua execução uma mensagem será enviada ao

37 37 SPY_Server com os dados desta instrução Após o SPY_Server ter recebido os dados referentes a instrução MPI_Send, o processo MPI continuará a executar o código da aplicação MPI, como está demonstrado na Figura 44b Figura 44: Envio da mensagem de execução da instrução MPI_Send Na Figura 44c é mostrado o caso onde não existe o SPY_Server em execução na máquina para onde a aplicação MPI tentou se conectar para enviar a mensagem com os dados da instrução MPI_Send Nesse caso, será detectada a ausência do SPY_Server e o processo MPI irá continuar a sua execução sem paralisar Mesmo sendo detectado em um determinado momento que não existe o SPY_Server em execução, a cada chamada de uma instrução da biblioteca MPI que foi alterada para enviar uma mensagem ao

38 38 SPY_Server, será feita a tentativa de conexão com o computador onde o SPY_Server deveria estar sendo executado O processo MPI ficará paralisado pelo tempo necessário para o envio da mensagem com os dados da instrução para o SPY_Server Caso não se tenha chegado no limite das 5 conexões simultâneas, a mensagem será imediatamente recebida pelo SPY_Server, e a aplicação MPI continuará sua execução normal 42 Funcionamento do SPY_Server O SPY_Server é um servidor de mensagens que ficará em execução em uma determinada máquina Esta máquina deve ter uma conexão com a rede do cluster para se ter uma comunicação entre os computadores do cluster e o SPY_Server O SPY_Server possui as seguintes características: 1 Deve estar ativo no instante em que uma conexão for solicitada; 2 Suporta o atendimento simultâneo de até 5 conexões O limite de 5 conexões foi definido a partir de testes realizados na máquina utilizada para o desenvolvimento da aplicação Com 5 conexões não havia uma sobrecarga do computador Um número maior de conexões causava uma sobrecarga do sistema, pois além dos processos referentes ao SPY_Server em execução, haviam os processos MPI para serem gerenciados pelo sistema operacional Pode ser ampliado de acordo com a capacidade do computador onde será executado o SPY_Server A cada nova requisição vinda do programa MPI, uma nova instância do SPY_Server será criada para atender esta requisição, respeitando o limite máximo de 5 conexões atendidas simultaneamente Caso haja mais de cinco processos MPI sendo executados no cluster que estejam executando alguma das instruções que são interceptadas pelo SPY_Server, os cinco primeiros processos que conseguirem se conectar ao SPY_Server são atendidos primeiro, os outros ficaram tentando ser atendidos pelo SPY_Server até conseguirem Depois que um processo passar a mensagem ao SPY_Server, e o SPY_Server passar esta mensagem ao SPY_View, um novo processo será atendido Neste caso os processos que ficarem esperando o atendimento do SPY_Server ficarão com a sua execução paralisada, pois como estão executando uma instrução que deve ser interceptada pelo SPY_Server, só poderão continuar se esta instrução for interceptada A Figura 45 demonstra esse procedimento Os processos 0, 1, 2, 3 acabaram de executar alguma das instruções que são interceptadas pelo SPY_Server(p) Ao executarem estas instruções o SPY_Server(p) criou 4 novas instâncias, representadas por SPY_Server(f0), SPY_Server(f1), SPY_Server(f2) e SPY_Server(f3), que ficarão responsáveis em enviar os

39 39 dados das instruções para o SPY_View Em um segundo momento os processos 4, 5, 6, 7 e 8 também executam alguma das instruções que são interceptadas pelo SPY_Server(p) Figura 45: Atendimento de requisições feitas pelo SPY_Server No exemplo demonstrado na Figura 45 o primeiro a conseguir se comunicar com o SPY_Server(p) foi o processo 4, mas não existe uma ordem pré-estabelecida a ser obedecida, qualquer um dos outros processos poderia ter conseguido se comunicar com o SPY_Server(p) Nesse caso o processo 4 será atendido pelo SPY_Server(p) que criará uma nova instância, representadas por SPY_Server(f4), que ficará responsável por enviar os dados da instrução executada pelo processo 3 Os processos 5, 6, 7 e 8, ficarão esperando o SPY_Server(p) aceitar uma requisição de comunicação, pois como existem 5 instâncias do SPY_Server(p) em execução, o SPY_Server(p)

40 40 irá esperar até que alguma instância SPY_Server(f) tenha conseguido enviar os dados da instrução que havia recebido para o SPY_View Assim que um SPY_Server(f) tiver conseguido enviar os dados da instrução, ele irá terminar, liberando o SPY_Server(p) para atender uma nova requisição de comunicação Os processos 5, 6, 7 e 8 ficarão com sua execução temporariamente paralisada, aguardando o atendimento do SPY_Server(p) para o pedido de comunicação Como a cada requisição o SPY_Server irá criar uma nova instância para atender esta requisição, dependendo do computador em que ele estiver sendo executado poderá haver uma sobrecarga do número de processos em execução, não permitindo que se tenha o atendimento de 5 conexões simultâneas ao SPY_Server, ou então, caso haja a possibilidade de se ter 5 conexões simultâneas ocorra uma perda de desempenho do processamento do computador, prejudicando o funcionamento do SPY_Server 421 Momento do Envio da Mensagem do SPY_Server para o SPY_View Ao receber a mensagem da aplicação MPI o SPY_Server irá automaticamente tentar enviar esta mensagem para o SPY_View Como o SPY_View é uma única aplicação em execução, só poderá atender a uma requisição de cada vez, e o SPY_Server, isto é, as instâncias do SPY_Server que receberam uma mensagem da aplicação MPI deverão esperar a sua vez para serem atendida Não existe uma ordem pré-estabelecida de atendimento, as instâncias do SPY_Server trabalham de forma concorrente para conseguir o atendimento do SPY_View Figura 46: SPY_Server passando mensagem para o SPY_View A Figura 46 mostra uma configuração que pode acontecer durante a execução do SPY_View Neste caso a instância SPY_Server (f1) conseguiu ser atendida pelo SPY_View Assim que consegue a comunicação com o SPY_View, a instância SPY_Server(f1) irá enviar os dados da mensagem para o SPY_View As outras instâncias estão esperando o atendimento do SPY_View, pois o programa SPY_View só pode atender 1 conexão de cada

41 41 vez Após o envio dos dados Ao terminar de enviar os dados para o SPY_View, a instância SPY_Server(f1) irá finalizar, liberando o SPY_View para atender uma outra instância do SPY_Server 43 Modo de Funcionamento do SPY_View O SPY_View é a interface com o usuário Nele serão exibidos os dados referentes as mensagens vindas do programa MPI através do SPY_Server Diferentemente do SPY_Server, o SPY_View não é um programa servidor Não existem outras instâncias em execução do SPY_View, sendo assim apenas uma conexão estará disponível para atender as requisições das múltiplas instâncias do SPY_Server que estiverem em execução Como o SPY_View irá receber as mensagens do SPY_Server, e o SPY_Server receberá as mensagens dos processos MPI, deve-se obedecer a uma certa ordem para se ter a execução destes programas: 1 SPY_View no computador que receberá as mensagens do SPY_View; 2 SPY_Server no computador que receberá as mensagens dos processos MPI; 3 Aplicação MPI Os itens 1 e 2 podem ocorrer em uma ordem diferente, mas o item 3 só pode ser iniciado depois de se ter iniciado o SPY_View e o SPY_Server 431 Recebendo uma mensagem do SPY_Server Ao receber uma mensagem o SPY_View irá processar essa mensagem e verificar qual o seu conteúdo Como são seis mensagens interceptadas pelo SPY_Server e enviadas ao SPY_View, o conteúdo de cada uma delas será diferente O atendimento das instâncias do SPY_Server é feito da seguinte forma: ao receber uma primeira requisição, o SPY_View irá atender esta requisição Quando obtiver o conteúdo da mensagem passada pelo SPY_Server, o SPY_View irá processar essa mensagem e verificar qual instrução foi interceptada pelo SPY_Server, para realizar a leitura dos dados da mensagem Se neste ponto alguma outra instância do SPY_Server tentar se comunicar com o SPY_View para enviar alguma mensagem interceptada da aplicação MPI, esta nova instância não será atendida imediatamente, pois o SPY_View estará ocupado realizando o processamento da mensagem anterior Após realizar o processamento desta mensagem o SPY_View estará liberado para ler uma outra mensagem enviada por outro SPY_Server Como mostra a Figura 47a, duas instâncias do SPY_Server estão tentando se comunicar com o SPY_View, a instância SPY_Server(1) e SPY_Server(2) O SPY_View irá atender primeiro a instância SPY_Server(1),

42 42 lendo a mensagem passada da aplicação MPI Da mesma forma como acontece com o SPY_Server ao interceptar uma aplicação MPI, o SPY_View não possui um critério para selecionar qual mensagem será processada primeiro, ele fica apenas aguardando algum pedido de comunicação, e atende a primeira requisição que for solicitada Ao se comunicar com o SPY_View, e enviar a mensagem que foi interceptada, o SPY_Server(1) irá finalizar, mas o SPY_View ainda deve processar a mensagem enviada pelo SPY_Server(1) antes de atender uma nova comunicação e receber uma nova chamada O processamento da mensagem é feito de forma diferente para cada instrução, pois os dados passados em cada uma delas são diferentes Durante o processamento da mensagem no SPY_View, o SPY_Server(2) ficará aguardando até que o SPY_View atenda a sua requisição, como está representado na Figura 47b Após realizar o processamento da mensagem recebida do SPY_Server(1), o SPY_View estará apto a atender uma nova requisição, e então o SPY_Server(2) irá enviar sua mensagem contendo os dados da instrução interceptada da aplicação MPI para o SPY_View, que pode ser visto na Figura 47c Figura 47: Atendimento de uma mensagem

43 Processamento da Mensagem no SPY_View Ao receber uma mensagem do SPY_Server, o SPY_View irá fazer o processamento desta mensagem, primeiro verificando qual a instrução que foi executada para gerar aquela mensagem, e a partir disso, processar os outros dados da mensagem Na Figura 47 tem-se um exemplo de como é feito o processamento da instrução Primeiramente o SPY_Server envia a mensagem com os dados da instrução para o SPY_View Então o SPY_View irá verificar qual a instrução que foi executada, e a partir da identificação da instrução, o SPY_View irá fazer a leitura dos dados da instrução Foi identificado que a instrução executada foi a MPI_Send, sendo assim será feita a leitura do conteúdo da mensagem de acordo com o que é passado na instrução MPI_Send A leitura dos dados pode ser feita em apenas uma etapa ou é dividida em duas etapas O comando mpirun, que gera as mensagens MPI_RUN e MPI_END, e as instruções MPI_Init e MPI_Finalize geram uma mensagem lida em apenas uma etapa Já as outras instruções, MPI_Send e MPI_Recv geram mensagens que devem ser lidas em duas etapas Na Figura 48 são apresentadas algumas instruções contendo apenas um campo Parte 1, e outras instruções contendo dois campos: Parte 1 e Parte 2 Esses campos contêm mais de uma informação Figura 48: Processamento da instrução da biblioteca MPI

44 44 Para as instruções MPI_RUN e MPI_END a Parte 1 contêm o número de computadores utilizados pela aplicação e o nome da aplicação a ser executada As instruções MPI_Init e MPI_Finalize contêm em Parte 1 o nome do computador que executou a instrução e o rank do processo MPI As instruções MPI_Send e MPI_Recv têm a mesma informação na Parte 1, e na Parte 2 foram adicionadas as seguintes informações: tipo do dado na mensagem que será enviada na instrução MPI_Send, ou recebida pela instrução MPI_Recv, quantidade de elementos que serão enviados, o número do processo que está executando a instrução, e o número de processo para onde será enviada a mensagem para o caso da instrução MPI_Send, ou o número do processo de onde se receberá a mensagem no caso da instrução MPI_Recv Durante o processamento da mensagem, uma das tarefas realizadas pelo SPY_View é atualizar a interface, para que o usuário possa acompanhar o andamento da aplicação MPI A interface não é atualizada simultaneamente a cada nova mensagem recebida A interface obedecerá a um certo intervalo de tempo para poder realizar a atualização das informações exibidas ao usuário Durante esse intervalo o SPY_View irá atender as requisições feitas pelo SPY_Server armazenando os dados referentes as mensagens que irão sendo enviadas A outra tarefa feita pelo SPY_View é a criação de um log de instruções Cada processo MPI que executar uma das instruções que será enviada para o SPY_View, terá um registro do momento da execução desta instrução armazenado em um log específico para o processo MPI

45 45 5 Implementação do MPI_SPY A implementação do MPI_SPY é dividida em três partes: 1 Implementação das alterações necessárias na biblioteca MPI 2 Implementação do SPY_Server 3 Implementação do SPY_View 51 Implementação das alterações na biblioteca MPI A biblioteca MPI foi alterada para que pudesse haver a identificação das chamadas às funções que serão interceptadas pelo SPY_View A alteração não ocorreu na mudança de alguma funcionalidade em cada função, mas na inclusão de uma funcionalidade, que não irá interferir no processamento da função da biblioteca O que será feito é o envio de uma mensagem ao SPY_Server contendo alguns dados referentes a função da biblioteca MPI Foram alterados um comando da biblioteca MPI e quatro funções Comando alterado: mpirun Funções alteradas: MPI_Init MPI_Send MPI_Recv MPI_Finalize Para enviar as mensagens do programa MPI para o SPY_View foi criada a função spy_puts(), que tem os seguintes parâmetros: spy_puts( *MPI_Instr, myrank, *hostname, size, dest, tag ); *MPI_Instr contém o nome do comando ou função da biblioteca MPI; myrank rank do processo MPI que está executando a função MPI; *hostname nome do computador que está executando a função MPI; size tamanho do buffer da mensagem da função MPI; dest rank do processo que receberá o buffer de dados, no caso da instrução MPI_Send, ou que enviará o buffer no caso da instrução MPI_Recv; tag tag utilizada na instrução MPI A mensagem será enviada do programa MPI para o SPY_Server, e depois encaminhada do SPY_Server para o SPY_View A rotina com o código da função spy_puts é mostrado a seguir:

46 46 int spy_puts( char mpi_msg[256], int rank, char hostname[256], int count, int dest, int tag ) { // Declaracao de Variaveis: int sock, i, j, k; char msg[256], sspyserver[256], nome_spyserver[256], porta_spyserver[16]; FILE *fspyserver; // Inicio do Programa: printf("spy_puts:%s\n", mpi_msg); fspyserver = fopen( "/etc/spyserverconf", "rt" ); fgets( sspyserver, 256, fspyserver ); fclose( fspyserver ); i = j = k = 0; while ( sspyserver[i]!= ' ' ) nome_spyserver[j++] = sspyserver[i++]; nome_spyserver[j] = '\0'; i++; while ( sspyserver[i]!= '\n' ) porta_spyserver[k++] = sspyserver[i++]; porta_spyserver[k] = '\0'; ignore_pipe(); sock = make_connection(porta_spyserver, SOCK_STREAM, nome_spyserver); sprintf(msg,"%s:comm:%i HOST:%s COUNT:%i DST:%i TAG:%i!\n", mpi_msg, rank, hostname, count, dest, tag ); sock_puts(sock,msg); sock_puts(sock,"\n\0"); close_connection(sock); } // Fim de spy_puts A primeira parte da rotina é a leitura do arquivo /etc/spy_serverconf, para que a função obtenha o nome do servidor onde está o SPY_Server Depois é feita a conexão com este servidor, os dados referentes a instrução executada pela aplicação MPI são colocados na mensagem que será enviada ao SPY_Server, e ao final a mensagem é enviada e a conexão fechada 511 Alteração do comando mpirun O comando mpirun é utilizado para se executar um programa no cluster, e quando isso ocorre, uma mensagem deve ser enviada ao SPY_View Uma outra mensagem também é passada ao SPY_View quanto o programa termina 5111 Mensagem indicando o início do programa MPI no cluster A mensagem indicando o início da execução do programa no cluster é a primeira tarefa executada dentro da rotina do comando mpirun, através da função spy_puts() que irá enviar a mensagem para o SPY_Server, demonstrado na rotina a seguir:

47 47 Int main(int argc, char **argv, char **envp) { LIST *app; int status; int errno_save; char **env = 0; #if LAM_WANT_IMPI char *impi_server = 0; int impi_argc = 0; char **impi_argv = 0; LIST *impi_server_app; struct _gps *impi_server_gps; #endif /////////////////////////////////////////////////////////////// char hostname[256]; // Inicio do Programa: /***************** Conexao com MPI_SPY *********************/ spy_puts( "MPI_RUN", -1, argv[3], -1, -1, -1 ); /////////////////////////////////////////////////////////////// /* * Ensure that we are not root */ if (getuid() == 0 geteuid() == 0) { show_help(null, "deny-root", NULL); exit(eacces); } /* * Parse the command line */ ad = ao_init(); if (ad == 0) { perror("mpirun (ao_init)"); exit(errno); } ao_setopt1(ad, "fhtvdo", 0, 0, 0); ao_setopt(ad, "client", 0, 2, 0); A função spy_puts tem como argumentos para o comando mpirun: MPI_Instr = MPI_RUN : indicando que o comando mpirun está sendo executado; myrank = -1: neste caso o programa MPI ainda será carregado no cluster, não existem processos MPI em execução, sendo assim o rank é considerado -1; hostname = argv[3]: o parâmetro hostname indica o nome do computador que executou a instrução MPI, mas neste caso o valor de hostname irá armazenar o nome do

48 48 programa MPI que será executado no cluster, que deve ser o 3º parâmetro do comando mpirun: $ mpirun np 16 <prog_mpi> size = -1: como não existe uma mensagem sendo passada de um processo para outro no cluster, o tamanho da mensagem é considerado igual a -1; dest = -1: dest também é considerado igual a -1 por não ser uma instrução de comunicação entre processos no cluster; tag = -1: tag também é considerada -1 pela mesma razão Ao ser executada a função spy_puts, uma mensagem será enviada do programa MPI para o SPY_Server, e caso possa ser processada pelo SPY_Server nesse instante, será encaminhada ao SPY_View 5112 Mensagem indicando o fim do programa MPI no cluster Quando um programa MPI chega ao fim de sua execução, uma nova mensagem é enviada ao SPY_View, indicando o término do programa no cluster Logo a seguir é mostrado o trecho do código que mostra como essa mensagem é enviada ao SPY_View antes do término do comando mpirun /* * If needed, wait for the application to terminate */ status = 0; if (fl_wait) { if (pwait(world_n, &status)) { app_doom(world_n, mpiworld, SIGUDIE); app_doom(world_n, world, -15); #if LAM_WANT_IMPI app_doom(world_n, impi_server_gps, -15); #endif error_cleanup(); } } microsleep(500000); /* 1/2 sec */ /////////////////////////////////////////////////////////////// /********************* Conexao com MPI_SPY *******************/ spy_puts( "MPI_END", -1, argv[3], -1, -1, -1 ); /////////////////////////////////////////////////////////////// ao_free(ad); kexit(status);

49 49 return(0); } A função spy_puts tem como argumentos para o comando mpirun: MPI_Instr = MPI_END : indicando que o programa MPI terminou de executar no cluster; Os outros parâmetros da função têm o mesmo valor: myrank = -1; hostname = argv[3]; size = -1; dest = -1; tag = -1 Ao ser enviada a mensagem para o SPY_View indicando o fim do programa no cluster, o SPY_View finaliza o processo de leitura das mensagens do SPY_Server 512 Alteração da função MPI_Init A instrução MPI_Init é utilizada para inicializar o processo MPI no cluster É nesta instrução que as variáveis globais da biblioteca MPI têm o seu valor definido, e desta forma os processos serão organizados Isto impede que a mensagem a ser enviada para o SPY_View seja a primeira tarefa a ser feita por esta instrução, pois os parâmetros da instrução spy_puts não seriam aproveitados Colocando a instrução spy_puts em um ponto onde se tenha os valores das variáveis globais da biblioteca MPI os parâmetros poderão ser preenchidos com dados mais concretos A rotina a seguir mostra o ponto de execução da função spy_puts #if LAM_WANT_IMPI /* Check if it is an IMPI job */ if (_kioki_rtf & RTF_IMPI) if (IMPI_Init(&mpi_nprocs, &mpi_cid, &mpi_procs)) { terror("impi_init: LAM error"); kexit(errno); } #endif /* * Now that MPI_COMM_WORLD has been finalized (haha), we can

50 50 * put in the trace for it, and the parent (if it exists) */ //////////////////////////////////////////////////////////////// /****************** Conexao com MPI_SPY ***********************/ gethostname( hostname, sizeof(hostname) ); spy_puts( "MPI_INIT", MPI_COMM_WORLD->c_group->g_myrank, hostname, -1, -1, -1 ); //////////////////////////////////////////////////////////////// if (lam_tr_comm(mpi_comm_world)) return(lamerror); if (mpi_nparent > 0) if (lam_tr_comm(lam_comm_parent)) return(lamerror); Os parâmetros passados a função spy_puts nessa caso são: MPI_Instr = MPI_Init : indicando que a instrução MPI_Init foi executada por algum processo MPI no cluster; myrank = MPI_COMM_WORLD->c_group->g_myrank: o valor do rank do processo MPI que executou a instrução; hostname = hostname: é enviado o nome do computador onde a instrução MPI_Init foi executada; Como a instrução MPI_Init não está passando uma mensagem para outro computador no cluster, os valores dos parâmetros size, dest e tag são: size = -1; dest = -1; tag = Alteração da função MPI_Send A instrução MPI_Send é utilizada para enviar uma informação de um computador a outro no cluster A função spy_puts é a primeira tarefa a ser executada dentro da função MPI_Send, não interferindo no processamento da informação a ser comunicada entre os computadores do cluster, como pode ser visto a seguir: int MPI_Send(void *buf, int count, MPI_Datatype dtype, int dest,int tag, MPI_Comm comm) { int err; /////////////////////////////////////////////////////////////// char hostname[256]; MPI_Datatype subtype /******************** Conexao com MPI_SPY ********************/

51 51 gethostname( hostname, sizeof(hostname) ); spy_puts( "MPI_SEND", comm->c_group->g_myrank, hostname, dtype->dt_length*subtype->dt_size, dest, tag ); /////////////////////////////////////////////////////////////// lam_initerr_m(); lam_setfunc_m(blkmpisend); Os parâmetros passados a função spy_puts são: MPI_Instr = MPI_Send : indicando que a instrução MPI_Send foi executada; myrank = MPI_COMM_WORLD->c_group->g_myrank: o valor do rank do processo MPI que executou a instrução; hostname = hostname: é enviado o nome do computador onde a instrução MPI_Init foi executada; size = dtype->dt_length*subtype->dt_size: é armazenado o produto entre o tamanho do buffer de dados e o tipo do elemento armazenado no buffer; dest = dest: rank do computador que receberá a mensagem; tag = tag: valor da tag utilizada na comunicação 514 Alteração da função MPI_Recv A instrução MPI_Recv é utilizada para receber os dados provenientes de um outro computador no cluster Como as variáveis globais da biblioteca MPI já estão inicializadas, a função spy_puts pode ser a primeira tarefa executada dentro da instrução MPI_Recv, como mostra o trecho de código a seguir: int MPI_Recv(void *buf, int count, MPI_Datatype dtype, int src, int tag, MPI_Comm comm, MPI_Status *stat) { int err; int staterr; /* error in status */ struct _req req_storage; MPI_Request req; int fl_trace; /* do tracing? */ double startt = 00; /* start time */ double finisht; /* finish time */ ///////////////////////////////////////////////////////////////// char hostname[256]; MPI_Datatype subtype // Inicio do Programa: /****************** Conexao com MPI_SPY ******************/ gethostname( hostname, sizeof(hostname) ); spy_puts( "MPI_RECV", comm->c_group->g_myrank, hostname, dtype->dt_length*subtype->dt_size, src, tag );

52 52 ///////////////////////////////////////////////////////////////// lam_initerr_m(); lam_setfunc_m(blkmpirecv); Os parâmetros passados a função spy_puts são: MPI_Instr = MPI_Recv : indicando que a instrução MPI_Recv foi executada; myrank = MPI_COMM_WORLD->c_group->g_myrank: o valor do rank do processo MPI que executou a instrução; hostname = hostname: é enviado o nome do computador onde a instrução MPI_Init foi executada; size = dtype->dt_length*subtype->dt_size: é armazenado o produto entre o tamanho do buffer de dados e o tipo do elemento armazenado no buffer; dest = src: neste caso será enviado o rank do computador que enviará a mensagem; tag = tag: valor da tag utilizada na comunicação 515 Alteração da função MPI_Finalize A instrução MPI_Finalize é utilizada para finalizar um processo no cluster Por ser a instrução da biblioteca MPI executada para terminar um processo MPI a função spy_puts deve ser a primeira tarefa a ser executada dentro da instrução MPI_Finalize, pois os valores das variáveis globais da biblioteca MPI terão seus valores indefinidos durante o processo de finalização do processo MPI A rotina a seguir mostra a chamada da função spy_puts : int MPI_Finalize(void) { int err; /* error code */ ////////////////////////////////////////////////////////////// char hostname[256]; // Inicio do Programa: /****************** Conexao com MPI_SPY *********************/ gethostname( hostname, sizeof(hostname) ); spy_puts( "MPI_FINALIZE", MPI_COMM_WORLD->c_group->g_myrank, hostname, -1, -1, -1 ); ////////////////////////////////////////////////////////////// lam_initerr(); lam_setfunc(blkmpifinal); if (lam_thread_level > MPI_THREAD_SINGLE &&!lam_thread_compare(lam_thread_self(), lam_main_thread)) { return(lam_errfunc(mpi_comm_world, BLKMPIFINAL, lam_mkerr(mpi_err_arg, 0))); }

53 53 Os parâmetros passados a função spy_puts são: MPI_Instr = MPI_Finalize : indicando que a instrução MPI_Finalize foi executada; myrank = MPI_COMM_WORLD->c_group->g_myrank: o valor do rank do processo MPI que executou a instrução; hostname = hostname: é enviado o nome do computador onde a instrução MPI_Init foi executada; size = -1; dest = -1; tag = Implementação do SPY_Server O SPY_Server é um intermediário entre o programa MPI e o SPY_View Ele foi criado para ser um servidor de mensagens que irá receber as mensagens do programa MPI em execução no cluster, e encaminhá-las ao SPY_View 521 Recebimento da mensagem do programa MPI O SPY_Server ao iniciar faz a leitura do arquivo spy_serverconf para poder carregar o servidor na porta de comunicação que receberá as mensagens vindas do programa MPI, como pode ser visto no código a seguir: control = fopen( "/etc/spyserverconf", "rt" ); fgets( spyserver, 256,control ); fclose( control ); i = j = k = 0; while ( spyserver[i]!= ' ' ) nome_spyserver[j++] = spyserver[i++]; nome_spyserver[j] = '\0'; i++; while ( spyserver[i]!= '\n' ) porta_spyserver[k++] = spyserver[i++]; porta_spyserver[k] = '\0';

54 54 O valor que será utilizado para a porta de comunicação ficará armazenado na variável porta_spyserver Este valor será convertido em uma porta compatível com o protocolo TCP, e será armazenado na variável port_mpi Após ler a porta que será utilizada para efetuar a conexão, o SPY_Server criará uma porta de comunicação e ficará aguardando uma mensagem, como pode ser visto na rotina a seguir: port_mpi = atoport( porta_spyserver, "tcp" ); sock_mpi = get_plus_connection(sock_stream, port_mpi, &listensock); strcpy( buffer, "\n\0"); sock_view = 0; while ( connected ) { strcpy( buffer, "\n\0" ); strcpy( end, "\n\0" ); if ( sock_gets( sock_mpi, buffer, 1024 ) < 0 ) 522 Controle do limite de conexões Existe um limite para o número de conexões simultâneas que são atendidas pelo SPY_Server Apesar de a função listen() também ter um limite de conexões, este limite pode não ser obedecido em determinados sistemas operacionais que aceitem reconexão automática Nesses casos a conexão pode ser aceita, ser ignorada, ou retornar um erro [7] Para se ter uma garantia de que não existirão mais de cinco conexões simultâneas, foi criada uma rotina que irá checar o número de conexões feitas ao SPY_Server a cada nova conexão Quando o programa MPI executa uma das instruções que serão enviadas ao SPY_Server, ele utiliza a função spy_puts() Esta função irá primeiro fazer uma conexão com o SPY_Server para depois enviar a mensagem Quando o SPY_Server aceita a conexão, a rotina apresentada logo a seguir é executada, e o número de conexões ativas do SPY_Server é atualizado

55 55 */ if (new_process == 0) { /* This is the new process */ close(listening_socket); /* Close our copy of this socket } else { if (listener!= NULL) { *listener = -1; /* Closed in this process We are not responsible for it */ } /* This is the main loop Close copy of connected socket, and continue */ max_accept++; Save_NumCon( max_accept ); } close(connected_socket); connected_socket = -1; Esse número é gravado no arquivo socketnumcon, que se encontra no mesmo diretório do SPY_Server Mas antes de aceitar a conexão vinda do programa MPI, o SPY_Server irá checar o número de conexões que estão ativas no MPI, essas conexões ativas são conexões que estarão tentando se comunicar com o SPY_View para poder enviar uma mensagem para ser exibida ao usuário Essa checagem é feita mediante a leitura do arquivo socketnumcon Caso o número de conexões seja inferior a 5, uma nova conexão será feita, senão, o SPY_Server ficará esperando alguma conexão ativa finalizar para então atender a uma nova conexão Esta checagem pode ser vista no trecho de código mostrado a seguir: if (socket_type == SOCK_STREAM) { listen(listening_socket, MAX_CON); Save_NumCon( 0 ); while(connected_socket < 0) { do { max_accept=load_numcon(); } while ( max_accept >= MAX_CON ); connected_socket = accept(listening_socket, NULL, NULL);

56 56 A função Load_NumCon() irá ler o número de conexões em uso no SPY_Server O limite de 5 conexões simultâneas pode ser aumentado Para isso deve ser atualizado o valor de MAX_CON 523 Envio do mensagem para o SPY_View Ao aceitar uma nova conexão, o SPY_Server irá encaminhar a mensagem vinda do programa MPI para o SPY_View Como o SPY_View aceita 1 conexão a cada comento, o SPY_Server só poderá enviar a mensagem ao SPY_View quando ele estiver disponível, caso contrário, o SPY_Server ficará tentando se comunicar com o SPY_View, como pode ser visto em destaque na rotina a seguir: if ( strlen( buffer ) > 10 ) { do { ignore_pipe(); sock_view = make_connection( porta_spyview, SOCK_STREAM, nome_spyview ); } while ( sock_view < 0 ); } strcat( buffer, "\n\0" ); sock_puts( sock_view, buffer ); //< 0) close( sock_view ); sock_view = 0;

57 57 53 Implementação do SPY_View O SPY_View é a interface do programa vista pelo usuário É nele que serão visualizados os eventos ocorridos no programa MPI A tela exibida ao usuário pode ser vista na figura 51: Figura 51: Tela do SPY_View A tela do SPY_View é dividida em: Células do Cluster: conjunto de controles que irão representar os nós do cluster Na figura 52 está representada uma das células, que serão utilizados para exibir o andamento do programa MPI Ao todo são 64 controles, tendo como base o cluster utilizado pelo Laboratório de Computação Avançada do Departamento de Informática da UFES que é formado por 64 computadores Serão utilizados os controles necessários para cada aplicação, se em uma aplicação forem necessários 8 controles, apenas os 8 primeiros serão utilizados Figura 52: Célula do Cluster Campo de Log: controle localizado na parte inferior esquerda da janela do SPY_View, irá mostrar os dados referentes a mensagem recebida pelo SPY_View

58 58 Botões de início, salvamento e saída do programa: são os botões localizados na parte inferior ao lado do campo de log, mostrados na figura 53: Figura 53: Botões de início, salvamento e saída Controle da taxa de atualização da tela: este controle, mostrado na figura 54, é responsável por especificar de quanto será o tempo para a atualização da tela do SPY_View Figura 54: Controle da taxa de atualização da tela Lista de computadores: este controle, que pode ser visto na figura 55, irá exibir a lista com os nomes dos computadores que estão atualmente em uso pelo programa MPI Ao selecionar um computador desta lista, o campo de log irá exibir as mensagens executadas apenas por este computador Figura 55: Lista de computadores 531 Recebimento da Mensagem do SPY_Server Para iniciar o processo de leitura das mensagens vindas do SPY_Server SPY_View deve-se pressionar o botão Iniciar Será iniciado um procedimento que irá criar uma porta de comunicação para ser utilizada pelo SPY_Server O SPY_View ao iniciar faz a leitura do arquivo spy_viewconf para poder carregar o servidor na porta de comunicação que irá ser utilizada para receber as mensagens vindas do SPY_Server, e também é feita a leitura do arquivo spy_serverconf para se saber em qual máquina está executando o SPY_Server, como pode ser visto no código a seguir: // Lendo servidor SPY_View

59 59 control = fopen( "/etc/spy_viewconf", "rt" ); fgets( spyview, 256,control ); fclose( control ); i = j = k = 0; while ( spyview[i]!= ' ' ) nome_spyview[j++] = spyview[i++]; nome_spyview[j] = '\0'; i++; while ( spyview[i]!= '\n' ) porta_spyview[k++] = spyview[i++]; porta_spyview[k] = '\0'; // Lendo servidor SPY_Server control = fopen( "/etc/spy_serverconf", "rt" ); fgets( spyserver, 256, control ); fclose( control ); i = j = k = 0; while ( spyserver[i]!= ' ' ) nome_spyserver[j++] = spyserver[i++]; nome_spyserver[j] = '\0'; i++; while ( spyserver[i]!= '\n' ) porta_spyserver[k++] = spyserver[i++]; porta_spyserver[k] = '\0'; O valor que será definido para a porta de comunicação será armazenado na variável porta_spyview Esse valor será convertido para uma porta TCP, e a porta criada será armazenada na variável port_view O SPY_View cria uma porta de comunicação da mesma forma que o SPY_Server, mas esta porta só aceitará uma conexão a cada instante A função que é utilizada para efetuar a conexão do SPY_View com SPY_Server é get_one_connection() Quando o SPY_Server faz uma requisição de comunicação com o SPY_View, está função irá aceitar esta requisição e nenhuma outra requisição será aceita enquanto a primeira não tiver sido processada A rotina logo a seguir mostra a execução destes passos: port_view = atoport(porta_spyview, "tcp"); sock_view = get_one_connection( SOCK_STREAM, port_view, &listensock); connectsock = sock; strcpy( buffer, "\n\0" ); if ( sock_gets(sock_view, buffer, 1024) < 0 ) {

60 60 } else { connected=0; if ( strlen( buffer ) > 4 ) { A conexão com o SPY_Server a partir do SPY_View é feita pois o SPY_View irá pedir ao SPY_Server que seja enviado o número de conexões pendentes a serem atendidas Isto é feito, para que quando o SPY_View receber a mensagem contendo a instrução MPI_END, não finalize antes que todas as conexões sejam atendidas O processo de conexão do SPY_View ao SPY_Server pode ser visto na rotina 514: sock_serv = make_connection( porta_spyserver, SOCK_STREAM, nome_spyserver); while ( connected+inuncon ) { do { inumcon = 0; sock_puts( sock_serv,"spy_ncon" ); sock_gets( sock_serv,snumcon,4 ); inumcon = atoi( snumcon ); } while (( inumcon < 1 ) ( connected )) A cada instante o SPY_View irá solicitar ao SPY_Server a quantidade de instâncias do SPY_Server que estão ativas requerendo uma conexão Quando for detectado que existe pelo menos uma instância do SPY_Server ativa, o SPY_View irá atender a uma requisição de uma instância do SPY_Server e processar a mensagem recebida, e ao terminar o processamento irá executar a checagem novamente verificando se ainda existem requisições pendentes 532 Processamento da mensagem recebida Ao receber a mensagem do SPY_Server, o SPY_View irá fazer o processamento desta mensagem As tarefas principais de processamento são mostradas no trecho de código a seguir:

61 61 if ( sock_gets(sock_view, buffer, 1024) < 0 ) { connected=0; } else { Edt_Log->insertLine( tr( buffer ), -1 ); op = Read_Operation( buffer ); log = Read_Msg( buffer, op ); if ( op == MPI_RUN ) { Make_Dir( buffer ); TotHosts = logcomm; } } if ( logcomm!= -1 ) Manage_Log( op, buffer, log ); if ( op == MPI_END ) { connected = 0; } A primeira tarefa desta rotina é a inclusão da mensagem recebida no campo de log do SPY_View Após a inclusão da mensagem no campo de log, será feita a identificação da mensagem, que é mostrada na rotina logo a seguir, para que se possa fazer a leitura correta dos parâmetros passados na mensagem Como as instruções da biblioteca MPI que serão enviadas ao cluster tem parâmetros diferentes, é necessário se fazer esta identificação cont = 0; while(( msg[cont]!= ':' ) && ( cont < MAX_VCHAR )) { op[cont] = msg[cont]; cont++; } op[cont] = 0; if ( strcmp( op, "MPI_RUN" ) == 0 ) { return MPI_RUN; } if ( strcmp( op, "MPI_END" ) == 0 ) { return MPI_END; } if ( strcmp( op, "MPI_INIT") == 0 ) { return MPI_INIT; } if ( strcmp( op, "MPI_FINALIZE" ) == 0 ) { return MPI_FINALIZE; } if ( strcmp( op, "MPI_SEND" ) == 0 ) { return MPI_SEND; } if ( strcmp( op, "MPI_SEND_INIT" ) == 0 ) { return MPI_SEND_INIT; } if ( strcmp( op, "MPI_RECV" ) == 0 ) { return MPI_RECV; } if ( strcmp( op, "MPI_RECV_INIT" ) == 0 ) { return MPI_RECV_INIT; }

62 62 Ao se identificar a instrução que está na mensagem enviada pelo SPY_Server, será feita a leitura dos parâmetros da instrução Os dados da mensagem serão armazenados na variável log, Esta variável irá conter os seguintes campos: rank irá armazenar o rank do processo que executou a instrução; target irá armazenar o rank do processo alvo da instrução, no caso da instrução MPI_Send target será o rank do processo que irá receber o buffer, na instrução MPI_Recv target será o rank do processo que irá enviar o buffer; tag irá armazenar a tag utilizada na instrução; size irá armazenar o tamanho do buffer em bytes; host irá armazenar o nome do computador que executou a instrução MPI Se a instrução executada foi a instrução mpirun, será criado um diretório com o nome do programa que será executado no cluster Esse diretório será utilizado para armazenar os arquivos de log que serão gerados durante a execução do programa MPI Para cada processo MPI em execução no cluster será criado um arquivo de log A próxima tarefa nessa rotina é a o processamento da mensagem Na etapa de processamento será feita a sinalização da execução de alguma instrução MPI no cluster para o usuário É no processamento da mensagem que as células do cluster no SPY_View irão ser ativadas de acordo com as mensagens vindas do SPY_Server, como mostra o código a seguir: switch( op ) { case MPI_INIT : cluster[rank]->a_init( log_msghost ); CBx_Hosts- >insertitem(log_msghost,rank); break; case MPI_FINALIZE : cluster[rank]->a_finalize(); break; case MPI_SEND : cluster[rank]->a_send( tam ); cluster[rank]->d_recv(); TotMesg++; break; case MPI_RECV : cluster[rank]->a_recv( tam ); cluster[rank]->d_send(); TotMesg++; break; } default : cluster[rank]->d_all(); break;

63 63 Cada célula do SPY_View corresponde a uma máquina no cluster, e internamente estas células são manipuladas por um vetor chamado cluster, que possui 64 elementos, correspondestes as 64 células do cluster no SPY_View Desse modo, quando se faz uma referência ao elemento x dentro da variável cluster ( cluster[x] ), faz-se uma referência a célula de posição x no SPY_View As células do SPY_View são controles que possuem algumas funções que são utilizadas para tornar os dados da mensagem recebida visíveis ao usuário Estas funções serão discutidas na próxima seção 533 Atualização da tela do SPY_View Para que o usuário possa ter um controle do momento em que a tela do SPY_View será atualizada, foi criado o campo para que ele possa indicar o tempo de atualização da tela, esse tempo é em segundos A atualização dos dados na tela do SPY_View ocorrerá a cada ciclo de tempo definido pelo usuário, como pode ser visto na rotina a seguir: tempo = time(null); while ( connected+inuncon ) { do { if ( time(null)-tempo > Edt_TempoText ) { Refresh(); tempo += time(null); } inumcon = 0; sock_puts( sock_serv,"spy_ncon" ); sock_gets( sock_serv,snumcon,4 ); inumcon = atoi( snumcon ); } while ( inumcon < 1 ) A função Refresh() irá fazer a atualização dos dados na tela, mostrando ao usuário o estágio atual do programa MPI 534 Funcionamento da célula do SPY_View A composição da célula do SPY_View é mostrada na figura 56 Na figura 56a é apresentada a célula completa Na figura 56b é mostrado o conjunto de sinalizadores de instrução Estes sinalizadores irão mostrar ao usuário qual instrução MPI foi executada pela aplicação MPI, posteriormente será mostrado qual sinalizador é utilizado para representar uma determinada instrução MPI Na figura 56c está o identificador do host, que é utilizado para mostrar ao usuário o nome do computador que será representado naquela célula A figura 56d representa as barras indicadoras do tamanho da mensagem, a barra superior indica o tamanho da mensagem da instrução

64 64 MPI_Send, a barra inferior indica o tamanho da mensagem na instrução MPI_Recv A figura 56e mostra os campos de quantidade de mensagens passadas pelo host O campo azul exibe a quantidade de vezes que a instrução MPI_Send foi executada, o campo amarelo exibe a quantidade de vezes que a instrução MPI_Recv foi executada Figura 56: Composição da célula do SPY_View As barras indicadoras, figura 56d, são a componente principal do SPY_View, pois são elas que irão mostrar ao usuário, qual a taxa de utilização da rede em um determinado instante Se o programa MPI passar uma mensagem contendo 400 Kbytes de dados, a barra de progressão irá indicar 4% de utilização da rede para aquela instrução Como a interface é atualizada de acordo com um tempo informado para o usuário, durante o período em que a interface estiver parada, o programa MPI pode passar várias mensagens entre os computadores do cluster Nesse caso, o que a barra indicadora irá mostrar é o tamanho total das mensagens no período compreendido entre a última atualização da interface e a atualização corrente Se foram passadas 10 mensagens de 400 Kbytes, a barra de progressão irá exibir 40% Para realizar a tarefa de exibir os dados das mensagens vindas da aplicação MPI para o usuário, este controle possui algumas funções que irão modificar o estado do controle para permitir a identificação do estágio corrente da aplicação MPI pelo usuário Estas funções são: A_Init: ativa o sinalizador indicando a execução da instrução MPI_Init; A_Send: ativa o sinalizador indicando a execução da instrução MPI_Send; A_Recv: ativa o sinalizador indicando a execução da instrução MPI_Recv; A_Finalize: ativa o sinalizador indicando a execução da instrução MPI_Finalize; WorkSend: atualiza a barra indicadora do tamanho da mensagem na instrução MPI_Send; WorkRecv: atualiza a barra indicadora do tamanho da mensagem na instrução MPI_Recv;

65 Ativação da célula ao receber a instrução MPI_Init Quando a aplicação MPI executa a instrução MPI_Init, uma mensagem é enviada para o SPY_Server, e o SPY_Server encaminha esta mensagem ao SPY_View Ao chegar ao SPY_View, esta mensagem será processada, e o controle correspondente na célula será ativado A ativação do controle, mostrada na figura 57, é feita através da instrução A_Init(), e é passado como parâmetro para esta instrução o nome do computador que executou a instrução MPI_Init, sendo alterado o identificador do host da célula para o novo nome Figura 57: Ativação da célula ao receber a instrução MPI_Init Ao ativar o controle referente a instrução MPI_Init, este controle não será mais alterado, permanecendo sinalizado até o fim da aplicação MPI Isto é feito para facilitar a visualização de quais células foram ativadas, e como cada célula corresponde a um processo MPI, o usuário irá verificar quais processos executaram a instrução MPI_Init 5342 Ativação da célula ao receber a instrução MPI_Send Como pode ser visto na figura 58, ao receber a mensagem referente a execução da instrução MPI_Send, o SPY_View irá ativar o controle correspondente a instrução MPI_Send na célula, isto é feito pela instrução A_Send() Será passado como parâmetro para essa instrução o tamanho do buffer da mensagem da instrução MPI, que será utilizado para fazer a atualização da barra de progressão, indicando o tamanho do buffer na mensagem A informação que será exibida ao usuário referente ao tamanho da mensagem, não é o tamanho do buffer, mas sim a proporção do tamanho do buffer em relação a capacidade de transmissão da rede, pois o objetivo do SPY_View é verificar qual a taxa de utilização da rede por uma aplicação MPI, e a partir dessa informação o usuário irá verificar em quais instantes da aplicação está sendo feita uma maior utilização da rede, e em quais momentos está sendo feita uma baixa utilização da rede, podendo dessa forma alterar o programa para ter uma utilização adequada da rede de comunicação Figura 58: Ativação da célula ao receber a instrução MPI_Send

66 66 Esta modificação no controle ficará sinalizada até que a instrução MPI_Recv seja executada pela aplicação MPI Quando a aplicação MPI executar a instrução MPI_Recv, o controle referente a instrução MPI_Send voltará ao estado inicial 5343 Ativação da célula ao receber a instrução MPI_Recv Ao receber uma mensagem do SPY_Server indicando que a instrução MPI_Recv foi executada, o SPY_View irá ativar o controle correspondente na célula, como pode ser visto na figura 59 A ativação deste controle é feito pela instrução A_Recv(), que também terá como parâmetro o tamanho do buffer da instrução MPI, este valor será utilizado para atualizar a barra de progressão referente a instrução MPI_Recv na célula Figura 59: Ativação da célula ao receber a instrução MPI_Recv Este controle só será modificado se uma instrução MPI_Send for recebida pelo SPY_View 5344 Ativação da célula ao receber a instrução MPI_Finalize Ao receber a mensagem indicando a execução da instrução MPI_Finalize, o SPY_View irá ativar o controle correspondente na célula indicando ao usuário que a instrução foi executada, como pode ser visto na figura 510 Esta sinalização é feita pela instrução A_Finalize(), e não é passado um parâmetro para esta instrução Figura 510: Ativação da célula ao receber a instrução MPI_Finalize O estado anterior do controle não será modificado ao ser feita a sinalização para a instrução MPI_Finalize 535 Geração do Log Durante o procedimento de leitura das mensagens vindas da aplicação MPI, o SPY_View gera um arquivo de log para os processos MPI Para cada processo MPI em execução no cluster será gerado um arquivo de log com os

67 67 dados referentes a execução das instruções MPI, sendo também considerado o instante em que a instrução foi executada em relação a todas as outras instruções executadas pelos outros processos, como pode ser visto na tabela 51 MPI_INIT: RANK: 0 HOST: phoenixinfufesbr! #1 #2 #3 #4 MPI_SEND: RANK: 0 HOST: phoenixinfufesbr SIZE: 1 DST: 1 TAG: 1! #5 MPI_SEND: RANK: 0 HOST: phoenixinfufesbr SIZE: 1 DST: 2 TAG: 1! #6 MPI_SEND: RANK: 0 HOST: phoenixinfufesbr SIZE: 1 DST: 3 TAG: 1! #7 #8 #9 MPI_RECV: RANK: 0 HOST: phoenixinfufesbr SIZE: 1 SRC: 1 TAG: -1! #10 #11 #12 MPI_RECV: RANK: 0 HOST: phoenixinfufesbr SIZE: 1 SRC: 2 TAG: -1! #13 #14 #15 MPI_RECV: RANK: 0 HOST: phoenixinfufesbr SIZE: 1 SRC: 3 TAG: -1! #16 MPI_SEND: RANK: 0 HOST: phoenixinfufesbr SIZE: 1 DST: 1 TAG: 0! #17 #18 MPI_SEND: RANK: 0 HOST: phoenixinfufesbr SIZE: 1 DST: 2 TAG: 0! #19 MPI_SEND: RANK: 0 HOST: phoenixinfufesbr SIZE: 1 DST: 3 TAG: 0! #20 #21 #22 MPI_FINALIZE: RANK: 0 HOST: phoenixinfufesbr! #23 #24 #25 #26 Tabela 51: Conteúdo do arquivo de log de um processo MPI O exemplo mostrado na tabela 51 refere-se a uma aplicação que iniciou 4 processos MPI em um cluster Como pode ser visto na tabela 51, o processo tem rank igual a zero, e no caso mostrado, foi o primeiro a executar a instrução MPI_Init Os outros processos executaram a instrução MPI_Init, e ao todo foram executadas 4 instruções da biblioteca MPI que foram interceptadas pelo SPY_View A próxima instrução a ser executada pela aplicação MPI foi a instrução MPI_Send dentro do processo de rank 0, sendo assim no arquivo de log do processo 0, a instrução MPI_Send será colocada na quinta linha do arquivo, pois foi a quinta instrução executada pela aplicação MPI As próximas instruções, a sexta e sétima, também foram executadas pelo processo 0, aparecendo em seqüência no arquivo de log, mas a oitava e nona instruções foram executadas por outro processo MPI pertencente a aplicação, assim essas linhas ficarão apenas com o número indicando que a enésima instrução, no caso a oitava e nona, foi executada pela aplicação, e como a próxima instrução executada pelo processo 0, MPI_Recv, foi a décima instrução executada pela aplicação essa instrução ficará na décima linha do arquivo de log do processo zero, e assim sucessivamente até o fim da aplicação MPI

68 Finalização da leitura das mensagens vindas do SPY_Server Quando o SPY_View receber a mensagem referente ao término do comando mpirun, ou seja, quando a aplicação tiver terminado de executar e for enviada a mensagem contendo o código MPI_END, a conexão com o SPY_Server só será concluída para as conexões ainda pendentes Assim que não houver conexões pendentes, o SPY_View encerrará o procedimento de leitura das mensagens vindas do SPY_Server, como pode ser visto no código a seguir: while ( connected+inuncon ) { do { inumcon = 0; sock_puts( sock_serv, "SPY_NCON" ); sock_gets( sock_serv,snumcon,4 ); inumcon = atoi( snumcon ); } while ( (connected+inumcon) < 2 ) if ( connected+inumcon ) { } } if ( op == MPI_END ) { connected = 0; } } close_connection(sock_serv); Com a finalização do programa, os botões de controle serão ativados para permitir ao usuário poder reiniciar o SPY_View para uma nova aplicação MPI, ou visualizar o log de mensagens de cada processo MPI da aplicação executada 537 Visualização do log de mensagens de cada processo O arquivo de log gerado para cada processo MPI pode ser visto na tela do SPY_View utilizando-se o controle da lista de computadores, como pode ser visto na figura 511 Ao selecionar um dos computadores da lista, o campo de log das mensagens será preenchido com o arquivo de log correspondente àquele computador

69 69 Figura 511: Visualizando o log de um computador do cluster Ao pressionar o botão Salvar, será criado um arquivo com o nome e local especificado pelo usuário contendo os dados exibidos no campo de log

70 70 6 Conclusão e trabalhos futuros Como foi visto, a implementação de uma ferramenta para realizar o acompanhamento da execução de um programa em um cluster de computadores, verificando a taxa de transferência de dados entre esses computadores, é viável As alterações realizadas na biblioteca MPI não interferem no programa feito pelo usuário, nem necessitam que alguma modificação seja feita no mesmo, sendo assim qualquer programa já feito utilizando a biblioteca MPI pode fazer uso desta ferramenta As informações que podem ser obtidas com esta ferramenta são de grande ajuda para o programador, pois o auxiliam na identificação de possíveis erros de implementação do programa, ou da lógica utilizada Quando houver qualquer anomalia na execução do programa MPI, o programador irá identificar esta anomalia e realizar as alterações necessárias no programa Os testes mostraram que o acompanhamento de uma aplicação MPI é feito de forma sincronizada, as chamadas às funções da biblioteca são identificadas, e a informação exibida pelo SPY_View corresponde ao esperado Nos casos onde o programa de teste utilizado apresentava uma execução normal, onde todos os computadores recebiam dados de um mesmo tamanho, o SPY_View indicava isso ao programador Quando o programa de teste apresentava uma execução anormal, nesse caso um computador do cluster recebia mais dados que os outros, também era possível identificar isso, e também era possível identificar qual computador estava sobrecarregado Futuramente podem ser feitas algumas melhorias nessa ferramenta, como por exemplo, a ativação do SPY_Server de uma forma automática, podendo ser inclusive através do comando mpirun Outra modificação seria uma junção dos programas SPY_Server e SPY_View em apenas um executável Essa ferramenta também pode ser ampliada com novas funcionalidades, como a possibilidade de incluir um mecanismo de breakpoint na aplicação do usuário, que poderia ser feito através da inclusão da instrução MPI_Breakpoint que iria paralisar o processo do usuário e exibir essa paralisação na interface, e a interface seria capaz de reativar o processo, a partir de um comando do usuário, e também a possibilidade de se ver o conteúdo dos dados que são passados entre os computadores, não apenas o tamanho destes dados Durante o desenvolvimento dos programas SPY_View, SPY_Server, e da alteração na biblioteca MPI foram utilizados os conhecimentos aprendidos nas disciplinas: Estrutura de Dados, na organização dos dados do programa, Linguagem de Programação, pois nesta matéria aprendi algumas técnicas de programação da linguagem C, Computação Gráfica, esta matéria foi essencial para o aprendizado da biblioteca Qt, Teleprocessamento e Redes, onde foi explicado como é o funcionamento de uma rede de computadores

71 71 7 Referências bibliográficas [1] César de Rose, Philippe Navaux: Fundamentos de Processamento de Alto Desempenho ERAD [2] Compaq Computer Corporation OpenVMS Debugger Manual [3] International Business Machine z/os UNIX System Services PE: MPI Reference" 1ª Edição, 2001 [4] Jan Lindheim "Beowulf Tutorial: Building a Beowulf System" California Institute of Technology, 2000 [5] Jehoshua Bruck, Danny Dolev, Ching-Tien Ho, Marcel-Catalin Rosu, Ray Strong: Efficient Message Passing Interface (MPI) for Parallel Computing on Cluster of Workstations ACM /95/07, 1995 [6] Ohio Supercomputer Center MPI Primer: Developing with LAM, Ohio State University, 1996 [7] Panagiotis Christias "Man-cgi 111" 1994 Disponível no endereço: acessado em 06/2003 [8] PCAS Training Group University of Illinois Introduction to MPI NCSA, 2001 [9] Sun Microsystems, Inc "SUN Grid Engine 53 Reference Manual" 1ª Edição, 2002 [10] The MPI Forum MPI A Message Passing Interface ACM /93/0011, 1993

72 72 Apêndice A - Instalação Para se efetuar a instalação do MPI_SPY deve-se seguir os seguintes passos: 1 Instalação do LAM-MPI 2 Instalação do MPI_SPY No desenvolvimento do MPI_SPY foi utilizada a biblioteca LAM-MPI 656, obtida em O processo de instalação deve ser feito no modo padrão, executando-se o script configure e os comandos make e make install Após a instalação da biblioteca LAM-MPI, pode-se efetuar a instalação do MPI_SPY Para isso deve-se executar o script mpi_spyinstall, localizado no diretório dos arquivos fontes do MPI_SPY, e depois ir ao diretório onde estão os fontes da biblioteca LAM-MPI, normalmente /usr/local/lam-656, e executar os comandos make e make install A princípio a instalação da versão atual do MPI_SPY pode ser feita em qualquer versão da biblioteca LAM-MPI que obedeça os seguintes critérios: 1 Arquivo mpirunc em lam-xyz/otb/mpirun/mpirunc 2 Arquivo initc em lam-xyz/share/mpi/initc 3 Arquivo sendc em lam-xyz/share/mpi/sendc 4 Arquivo recvc em lam-xyz/share/mpi/recvc 5 Arquivo finalizec em lam-xyz/share/mpi/finalizec Onde lam-xyz representa o diretório da biblioteca LAM-MPI utilizada A indicação desse diretório deve ser feita no arquivo mpi_spyinstall Não foram feitos testes com outras versões da biblioteca MPI, como por exemplo a MPICH, e nesses casos a instalação e execução do MPI_SPY não é garantida Após a instalação do MPI_SPY, deve-se instalar uma cópia do programa SPY_Server no computador que será utilizado para receber as mensagens vindas da aplicação MPI É importante ressaltar que este computador deverá pertencer a mesma rede que todos os nós do cluster, para que os mesmos possam enviar as mensagens à ele E também deve ser instalada uma cópia do programa SPY_View no computado que será utilizado para visualização dos dados da aplicação MPI Deve ser criado o arquivo spy_serverconf no diretório /etc de todos os nós do cluster, e spy_viewconf no diretório /etc do computador onde estiver em execução o SPY_Server Estes arquivos indicam qual é o computador que está executando o SPY_Server e qual está executando o SPY_View, respectivamente O conteúdo desses arquivos deve ser preenchido com o nome do comutador onde está o programa, e a porta de comunicação a ser utilizada Por exemplo, pode ser preenchido com os seguintes dados: spy_serverconf: phoenixinfufesbr 5000 spy_viewconf: camburiinfufesbr 9000

73 73 Apêndice B - Utilização Para se utilizar o MPI_SPY para visualizar a execução de um aplicativo MPI deve-se realizar as seguintes etapas: 1 Instalação do MPI_SPY 2 Compilação da aplicação MPI do usuário 3 Ativação dos programas SPY_Server e SPY_View O processo de instalação do MPI_SPY pode ser visto no apêndice A Para que os dados possam ser enviados e visualizados pelo usuário, a aplicação MPI deve ser recompilada a partir do MPI_SPY Não é necessário nenhuma alteração na aplicação do usuário, e a compilação pode ser feita normalmente, e inclusive, todas as compilações feitas em uma máquina onde esteja instalado o MPI_SPY estarão prontas para trabalhar com o SPY_Server e SPY_View Para ser possível a visualização dos dados da aplicação pelo usuário durante sua execução, deve-se ter o programa SPY_Server iniciado no computador que receberá as mensagens da aplicação MPI, e também deve ser iniciado o programa SPY_View no computador utilizado para exibir os dados da aplicação para o usuário, e na tela do SPY_View, pressionar o botão Iniciar, para que a partir de então, o SPY_View possa criar uma porta de conexão para receber as mensagens do SPY_Server Ao final destes procedimentos pode-se executar a aplicação MPI com o comando: $ mpirun -c 16 progmpi Deve-se incluir os itens -c, 16 (que refere-se a número de processos) e progmpi (correspondente ao nome da aplicação) na ordem indicada A partir deste instante a aplicação MPI já estará enviado as primeiras informações sobre a aplicação para o SPY_View