3 Estruturas de objetos concorrentes

(1)

PROF. LU´ISFERNANDO DE OLIVEIRA

Introduc

¸˜

ao a Linguagem

Charm++

Programac¸˜

ao paralela e distribu´ıda

Universidade do Estado do Rio de Janeiro Centro de Tecnologia e Ciˆencias

Instituto de F´ısica

(2)

1 Vis˜ao geral sobre a linguagem Charm++ 6

1.1 Orientac¸˜ao a objeto e objetos concorrentes . . . 7

1.2 Universo Paralelo . . . 8

1.3 Processamento no Charm++ . . . 9

1.4 Funções úteis no Charm++ . . . 11

2 Elementos b´asicos da linguagem Charm++ 13 2.1 Objeto sequencial . . . 14

2.2 Objeto concorrente simples . . . 15

2.2.1 mainchare . . . 17

2.2.2 Dados com acessosomente para leitura . . . 18

2.2.3 Passagem de argumentos . . . 20

2.3 Mensagens . . . 25

2.3.1 Mensagem de tamanho fixo . . . 27

2.3.2 Mensagem de tamanho vari´avel . . . 30

2.3.3 Mensagens no modosomente leitura . . . 35

2.3.4 Mensagem de linha de comando . . . 35

3 Estruturas de objetos concorrentes 37 3.1 Lista de objetos concorrentes . . . 37

3.2 Colec¸˜oes de objetos concorrentes . . . 44

3.2.1 Grupos de objetos concorrentes . . . 44

3.2.2 N´os de objetos concorrentes . . . 44

3.3 Callbackereduction. . . 44

(3)

Lista de Figuras

1.1 Caracter´ısticas do Charm++. . . 6 1.2 Troca de mensagens como princ´ıpio de funcionamento do Charm++.. . . 7 1.3 Caracter´ısticas do paradigma da orientação a objeto. . . 8 1.4 Papel do objetoPROXYem relação ao objeto remoto. . . 9 1.5 Noção de grupo de nós. . . 10

(4)

O Charm++ é uma linguagem de programação distribu´ıda baseada no paradigma da orientação a objeto. A sintaxe do Charm++ é idêntica a da linguagem C++. Por vezes, o leitor poderá se perguntar se o Charm++ é realmente uma outra linguagem ou se é uma biblioteca que implementa paralelismo e distribuição de processos dada a semelhança entre ele e o C++. No discurso do grupo1 que desenvolveu o Charm++ encontra-se informações que indicam ambas as opções. O Charm++ é uma linguagem superposta à linguagem C++.

Como poderá ser constatado ao longo deste material de apoio, a semelhança não ´

e mera coincidência. O compiladorcharmc opera como um pré-compilador, isto é, ele pré-processa o código fonte, introduz uma série de instruções no código C++ e depois requisita a compilação do código processado usando o compilador C++ dispon´ıvel.

Independente desta discussão, é fato que o Charm++ hoje é uma linguagem ma-dura com suporte para operar em conjunto com outras ferramentas de paralelismo/dis-tribuição de processos como o MPI. Projetos implementados usando Charm++ foram desenvolvidos e executados em supercomputadores de renome (BlueGene).

Uma caracter´ıstica ´ımpar do Charm++ é a possibilidade de o desenvolvedor (ana-lista/projetista) resgatar a capacidade de organizar sua lógica de programação indepen-dente da arquitetura de processamento paralelo/distribu´ıdo. Tudo se passa como se o projeto estivesse sendo executado no computador do programador.

Outro elemento interessante do Charm++ são as ferramentas de depuração e avaliação de desempenho. A ferramenta de avaliação de desempenho chamada Projec-tionsé capaz de apresentar, entre outras coisas interessantes, a carga de processamento em cada processador. Para o Charm++, um processador como o Phenom II X4 da AMD ou Core I7 da Intel é visto como um pequeno cluster de 4 processadores. Cada núcleo é utilizado independentemente e pode ser explorado em seu potencial de processamento. Então, um programa implementado em Charm++ explora o recurso dispon´ıvel no pro-cessador e exibe isto através da ferramentaProjections.

Por fim, o Charm++ permite que o analista/projetista simule o comportamento do projeto implementado numa arquitetura que ele não possui, ou seja, o desenvolvimento do projeto pode ser implementado num sistema computacional que não possui todas as caracter´ısticas do sistema alvo. Mesmo que o computador utilizado durante o desen-volvimento do projeto possua apenas 4 núcleos, o programa compilado em Charm++

1_{Parallel Programming Laboratory, University of Illinois}

(5)

5

pode ser executado com qualquer número de processos que se deseje. É óbvio que a performance nesta simulação cai, mas não impede que o projeto seja analisado quanto à lógica, ao processo de troca de mensagens, transferências de dados entre processadores e outros aspectos.

Tudo isto torna o Charm++ uma linguagem de destaque. Muitas outras carac-ter´ısticas ser˜ao apresentadas ao longo deste material.

Boa leitura.

(6)

Vis˜

ao geral sobre a linguagem

Charm++

O Charm++ é uma linguagem orientada a objetos concorrentes. A execução de um programa compilado em Charm++ ocorre através da troca de mensagens entre os objetos concorrentes que compõem a lógica da programação (fig. 1.1).

Figura 1.1: Caracter´ısticas do Charm++.

Mas se diferencia das demais ferramentas de paralelismo baseadas em troca de mensagem (fig. 1.2), pois um objeto concorrente só inicia a realização de uma deter-minada tarefa quando este recebe a mensagem enviada. O termo utilizado neste caso é dirigido a mensagem (message-driven). Isso caracteriza umaassincronicidade interes-sante, uma independência temporal na execução das tarefas. É natural que a linguagem Charm++ ofereça instruções para que a distribuição e o recolhimento dos resultados distribu´ıdos no sistema de processamento ocorra de forma organizada. Porém, não ha necessidade de o analista/projetista prever barreiras ou semáforos explicitamente no código fonte.

Por trás do Charm++, existe um elemento operando ativamente que é o geren-ciador de execução (Charm++ kernel). Este agente é ativado automaticamente na

(7)

7

Figura 1.2: Troca de mensagens como princ´ıpio de funcionamento do Charm++.

carga do programa em Charm++. O gerenciador de execução monitora continuamente a emissão de mensagens, intercepta-as e as envia para o objeto concorrente de destino. Fica transparente ao usuário o momento em que o gerenciador realizará esta tarefa. Por este motivo, o processamento através do gerenciador de execuções é ass´ıncrono e exige do desenvolvedor (analista/projetista) a habilidade de compor sua lógica de forma que esta assincronicidade seja aproveitada.

1.1 Orientac

¸˜

ao a objeto e objetos concorrentes

O Charm++ oferece um conjunto de classes de objetos que podem ser utilizados na codificação da lógica distribu´ıda. Essencialmente, as classes de objetos dizem respeito a: objetos concorrentes (chare objects, chare array objects, chare group objetcs, chare nodegroup objects), objetos de comunicação (message objects) e objetos “globais” somente para leitura (readonly objects).

Como o Charm++ se superpõe à linguagem C++, todas as caracter´ısticas da programação orientada a objeto suportada pela linguagem C++ são herdadas pelo Charm++ (fig. 1.3). Logo, os objetos concorrentes do Charm++ são instâncias de classes devidamente programadas para suportar o processamento paralelo/distribu´ıdo.

As classes do Charm++ encapsulam atributos e métodos, assim como no C++, que podem ser públicos e privados. Os métodos públicos das classes de objetos concor-rentes do Charm++ são chamados de métodos de entrada da classe(entry methods) e podem ser invocados remotamente de forma ass´ıncrona. Isto significa que o objeto requerente não espera pela execução do método do objeto remoto e não espera que o método retorne um resultado. Logo, os m´etodos de entrada da classe devem se comportar como procedimentos (procedures,subroutines).

(8)

Figura 1.3: Caracter´ısticas do paradigma da orientac¸˜ao a objeto.

referenciar uma informação através de ponteiros.

1.2 Universo Paralelo

A linguagem Charm++ possui uma caracter´ıstica que representa um diferencial perante as demais ferramentas de programação paralela: ela resgata o controle do de-senvolvedor sobre a lógica da programação. A princ´ıpio, isto pode não parecer sig-nificativo, pois toda programação está baseada em lógica, seja usando a linguagem Charm++ ou qualquer outra linguagem. A diferença está no fato de o desenvolvedor olhar para sua lógica de programação de forma praticamente independente da arquite-tura de computação paralela/distribu´ıda. Em momento algum, como será visto ao longo deste material, o desenvolvedor precisa prever ou determinar que trecho de código será executado em um processador espec´ıfico. Mais, a codificação completa não precisa ser clonada em todos os processadores do sistema de computação; somente a tarefa dese-jada é executada remotamente. O efeito final é que o desenvolvedor olha para sua lógica como se tudo se passasse na sua unidade de processamento, no seu computador pessoal, no computador de desenvolvimento, independente dos recursos de arquitetura presen-tes neste (se é monoprocessado ou multiprocessado, se os processadores são simétricos, escalares ou vetoriais).

(9)

ge-9

rada pelogerenciador de execução. Quando o desenvolvedor programa uma troca de mensagens entre dois objetos concorrente no universo virtual, por exemplo a solicitação de execução de um método do objeto remoto (virtual), o gerenciador de execução in-tercepta esta mensagem e replica no universo real, ou seja, o objeto requerente (real) requisita a execução do mesmo método do objeto remoto (real).

Os objetos concorrente virtuais s˜ao chamados tecnicamente dePROXY. Este termo ´

e muito comum nos serviços de internet e de bancos de dados distribu´ıdos. Um elemento PROXY é um simulacro de um elemento real. Ele age como a entidade real, mas não existe realmente. Ele existe na concepção lógica da programação. Cada objeto remoto real possui um objetoPROXY correspondente. O objetoPROXYestá para o n´ıvel lógico assim como o objeto remoto está para o n´ıvel de execução (fig.1.4).

Figura 1.4: Papel do objetoPROXY em relac¸˜ao ao objeto remoto.

1.3 Processamento no Charm++

Um programa em Charm++ consiste de um número de objetos Charm++ dis-tribu´ıdos sobre o número de processadores dispon´ıveis. Portanto, a unidade básica de computação paralela nos programas Charm++ é o chare, um objeto Charm++ que pode ser criado em qualquer processador dispon´ıvel e pode ser acessado de qualquer processador remoto. Chares podem ser criados dinamicamente e vários charespodem ser ativados simultaneamente. Charesenviam mensagens para outros charespara invo-car métodos assincronamente.

Métodos de um chare podem ser invocados remotamente através dos chamados métodos de entrada(entry methods). Métodos de entrada podem receber um ou vários parâmetros passados por valor ou um ponteiro para uma mensagem (message object). Métodos de entrada são completamente não-preemptivos, isto é, o Charm++ nunca irá interromper um método em execução para iniciar um qualquer outro trabalho e as invocações solicitadas são atendidas de foma ass´ıncrona.

(10)

gerenciador de execução irá alocar o objeto remoto no processador menos carregado (realizando a menor quantidade de tarefas ou desocupado). Uma vez que o código não precisa identificar o processador que receberá o objeto remoto, os objetos remotos podem migrar de um processador para outro, ou seja, eles podem ser realocados. Este mecanismo é o fundamento do balanceamento de carga.

Outros objetos Charm++ são coleções de objetos remotos. São eles: listas de objetos remotos (chare arrays), grupos de objetos remotos (chare groups) e grupos de nós de objetos remotos (chare nodegroups).

Uma lista de objetos remotos é uma coleção decharesrealocáveis, indexados por algum tipo de ´ındice. O Charm++ admite uma lista decharesesparsa. Não há necessi-dade de que a indexação seja cont´ınua a partir de um valor inicial. Isto significa que a lista pode ser segmentada em relação ao ´ındice adotado. Só é necessário que o número total de elementos na lista seja finito.

Grupo e grupo de nós de objetos remotos são coleções de chares, assim como a lista, porém estão organizados na forma de membros (ramificações). Um grupo de objetos remotos aloca umchare(um membro do grupo) por processador. Um grupo de nós não enxerga os processadores, mas o agrupamento de processadores num mesmo recurso computacional. Por exemplo, 10 computadores com 6 processadores em cada é visto pelo Charm++ como 10 nós (cada computador é um recurso computacional) de 6 processadores. Neste sentido, um grupo de nós de objetos remotos aloca umchareem um processador por nó, totalizando 10 membros do grupo de nó (fig.1.5).

Figura 1.5: Noção de grupo de nós.

Todo programa Charm++ deve ter, pelo menos, um mainchare, um objeto con-corrente que desempenhe o papel demestre. Cada objeto mestre é criado pelo sistema no processador0_{quando o programa ´}_{e iniciado. ´}_{E o ´}_{unico objeto do Charm++ que ´}_e alocado em um processador conhecido. O gerenciador de execução inicia o programa Charm++ alocando todos osmaincharescodificados e executando os métodos constru-tores correspondentes. Tipicamente, cada construtor é responsável por alocar os demais objetos Charm++ que tenham sido codificados.

(11)

gerenci-11

ador de execução precisa saber os tipos de objetos remotos que o desenvolvedor está implementando em seu código, os métodos que serão invocados, os argumentos destes métodos e assim por diante. Toda esta informação deve estar documentada no código de interfaceamento do Charm++. O gerenciador de execução identifica de forma única e automática cada um destes elementos e gera a definição dos objetos PROXY que o desenvolvedor enxergará e usará no seu n´ıvel lógico de programação. Torna-se, por-tanto, totalmente transparente ao desenvolvedor a alocação dos elementos concorrente, pois a responsabilidade de conhecer, identificar, localizar e acessar cada um deles é do gerenciador de execução. Por isso o gerenciador é okerneldo Charm++.

1.4 Func

¸˜

oes ´

uteis no Charm++

A linguagem Charm++ possui um conjunto de funções intr´ınsecas que cumprem papéis importantes dentro da lógica da programação. Elas serão apresentadas aqui sem o compromisso, neste momento, de inseri-las em um código elaborado. Far-se-á isso em outro momento mais oportuno.

• void CkAssert(int express~ao)

Aborta o programa seexpress~aofor nulo.

• void CkAbort(const char *messagem de erro)

Aborta o programa imprimindo mensagem de erro no terminal de sa´ıda. Esta função não retorna. Isto significa que qualquer instrução após esta invocação nunca será executada.

• void CkExit()

Esta chamada informa okernel que a computação de todos os processos deve ser encerrada. Esta função não retorna. Como a requisição de encerramento é geren-ciada pelokernele okerneltrabalha de forma ass´ıncrona, os processos podem não parar simultaneamente.

• double CkWallTimer()

Retorna o tempo transcorrido em segundos desde o in´ıcio do programa.

• int CkNumPes()

Retorna o n´umero total de elementos de processamento (PEs) global.

• int CkMyPe()

Retorna o ´ındice do PE local.

• int CkNumNodes()

Retorna o número total de nós lógicos.

• int CkMyNode()

(12)

• int CkMyRank()

Retorna o sub´ındice do PE no n´o l´ogico (inicia em 0).

• int CkNodeFirst(int nd)

Retorna o ´ındice do primeiro PE no n´o l´ogicond.

• int CkNodeSize(int nd)

Retorna o número total de PEs no nó lógicond.

• int CkNodeOf(int pe)

Retorna o ´ındice do n´o l´ogico ao qual pertence o PE de ´ındicepe.

• int CkRankOf(int pe)

Retorna o sub´ındice do PE de ´ındicepeno n´o l´ogico local.

• int CkPrintf(format[,arg]*)

Func¸˜ao printf() da linguagem C adaptada para funcionar na rede.

• int CkScanf(format[,arg]*)

(13)

Cap´ıtulo 2

Elementos b´

asicos da linguagem

Charm++

Um programa Charm++ é estruturalmente semelhante a um programa C++ e pode ser distribu´ıdos em vários arquivos de código fonte. A maior parte de um programa Charm++ é código C++ e as principais unidades sintáticas são definições de classe.

Existem cinco categorias de objetos no Charm++:

• objetos sequenciais (como no C++);

• chares- objetos concorrentes simples;

• chare messages - mensagens como organizações de dados heterogêneos trocados

entre objetos concorrente;

• chare arrays- listas de objetos concorrentes (colec¸˜oes de objetos concorrentes

in-dexados);

• chare groups - grupos de objetos concorrentes (colec¸˜oes de objetos concorrentes

clonados por processador);

• chare nodegroups- n´os de grupo de objetos concorrentes.

Para que o gerenciador de execução (Charm++kernel) identifique corretamente cada categoria de objeto concorrente, é necessário o uso de uma interface entre o Charm++ e o C++. Esta interface é codificada em um ou mais arquivos de texto cha-mados de aquivos de interface cuja extensão é “.ci”. Um tradutor é usado para gerar a codificação correta dos objetos concorrentes do Charm++ e que será usada no processo de compilação do código do desenvolvedor.

Cada objeto concorrente deve estar declarado em um arquivo de interface e inse-rido em ummódulo(module) que deve se identificado por um nome. Um programa em Charm++ pode conter diversos módulos sendo que um deles deve ser identificado como omódulo principal(mainmodule). Os demais módulos agregados ao módulo principal devem estar identificados pela chaveextern.

(14)

Exemplo: se o m´odulo principal se chamarABC, a interface dever´a ser codificada como

// arquivo ABC . ci m a i n m o d u l e ABC {

// corpo do modulo

};

O processo de tradução dos arquivos de interface gera dois outros arquivos com sufixos “.decl.h” e “.def.h” para cada módulo declarado na interface. Estes arquivos contêm, respectivamente, declarações e definições dos objetos concorrentes declarados em cada módulo.

Exemplo: se a interface contém um módulo identificado pelo rótulo ABC, então, após o processo de tradução da interface, dois arquivos serão criados, um chamado “ABC.decl.h” e outro chamado “ABC.def.h”. Como são arquivos de cabeçalho da lingua-gem C/C++, recomenda-se que o arquivo de declarações seja inclu´ıdo no in´ıcio da codificação do arquivo de cabeçalho do módulo correspondente, por exemplo, “ABC.h” e o arquivo de definições seja inserido no final do arquivo de codificação em C++ do módulo, exemplo, “ABC.cpp”.

Como a codificação da interface do Charm++ é próprio para cada tipo de objeto concorrente, deixar-se-á para cada seção que os descreve para apresentar a interface correspondente.

Ser˜ao apresentados, a seguir, cada um dos objetos concorrentes do Charm++.

2.1 Objeto sequencial

Objetos sequenciais são todos os objetos padrão da linguagem C++. Esta cate-goria de objetos é conhecido e acessado localmente, isto é, os objetos sequenciais não são reconhecidos pelo gerenciador de execução e seus métodos não podem ser invoca-dos remotamente. Não há codificação de classes de objetos sequenciais na interface do Charm++.

Exemplo de declarac¸˜ao de uma classe de um objeto sequencial chamadoPonto3D:

// d e f i n i c a o do objeto s e q u e n c i a l class Ponto3D {

p r o t e c t e d:

double x , y , z ;

public:

Ponto3D (void) { x = y = z = 0; }

Ponto3D (double ix ,double iy ,double iz ) { x = ix ; y = iy ; z = iz ;

(15)

15

void X (double ix ) { x = ix ; }

void Y (double iy ) { y = iy ; }

void Z (double iz ) { z = iz ; }

double X (void) { return x ; }

double Y (void) { return y ; }

double Z (void) { return z ; } };

2.2 Objeto concorrente simples

Os objetos concorrentes simples (chares) são os elementos mais importantes em um programa Charm++. São codificados de forma semelhante aos objetos sequenciais em C++, porém são filiados a uma superclasse do Charm++ chamada CBase que as modela.

Enquanto objetos concorrentes, precisam ser declaradas na interface do Charm++ comochare. Os métodos dispon´ıveis para invocação remota devem ser definidos como métodos de entrada e identificados na interface do Charm++ com a palavra chave

entry. Estes métodos de entrada podem receber argumentos, mas não retornam qual-quer tipo de informação. Logo, são declarados em C++ comovoid.

Umcharedeve possuir pelo menos um m´etodo de entrada que ´e o seu construtor. ´

E natural que o construtor dochareseja um método de entrada, pois a criação do objeto remoto implica na invocação de seu construtor.

No exemplo a seguir, vê-se a declaração e a implementação de umcharechamado

chareTipo. No arquivo de interface, indica-se a natureza de chareTipo como chare e lista-se os métodos de entrada previstos: o construtor de chareTipo e um método chamado NomeMetodoEntrada. Se os métodos de entrada possuem argumentos, estes devem constar dos protótipos dos métodos de entrada na interfaces.

// . ci

// -// i n t e r f a c e do chare c h a r e T i p o

// -chare c h a r e T i p o {

// -// i n t e r f a c e do c o n s t r u t o r

// -entry c h a r e T i p o ( args1 );

// -// i n t e r f a c e do metodo de entrada N o m e M e t o d o E n t r a d a // -entry void N o m e M e t o d o E n t r a d a ( args2 );

(16)

A implementação da classe chareTipo deve ser descendente de uma classe pri-mitiva chamadaCBase chareTipo. Esta classe primitiva é gerada no processamento do arquivo de interface a partir da superclasseCBase. O desenvolvedor não deve editar a codificação de CBase chareTipo (não há necessidade disto). Qualquer demanda deve ser codificada na classe descendentechareTipoque está sendo implementada.

// . h

// -// d e f i n i c a o da classe do chare c h a r e T i p o

// -class c h a r e T i p o : public C B a s e _ c h a r e T i p o {

public:

// -// p r o t o t i p o do c o n s t r u t o r

//

-c h a r e T i p o ( args1 );

// -// p r o t o t i p o do metodo de entrada N o m e M e t o d o E n t r a d a // -void N o m e M e t o d o E n t r a d a ( args2 );

};

Além da geração da classe primitiva CBase chareTipo, o processamento do ar-quivo de interface produz a classePROXYcorrespondente:CProxy chareTipo. O instan-ciamento da classechareTipoocorre a n´ıvel dePROXYatravés de um método intr´ınseco da classeCProxy chareTipo chamado ckNew. Este método admite os argumentos de-clarados no construtor dechareTipo. Na terminologia do Charm++,chareNome é um objetoPROXYassociado à classechareTipo.

// . cpp

// -// i n s t a n c i a m e n t o da classe c h a r e T i p o

//

-C P r o x y _ c h a r e T i p o c h a r e N o m e ;

c h a r e N o m e = C P r o x y _ c h a r e T i p o :: ckNew ( args1 );

A execução de qualquer método de entrada é ass´ıncrona e não-preemptiva. No n´ıvel lógico, a invocação de um método de entrada é realizada através do objetoPROXY associado ao chare. O gerenciador de execução é responsável pela invocação real do método de entrada dochare.

(17)

17

2.2.1 mainchare

Toda programação em Charm++ deve possuir um objeto principal (o objeto mes-tre) que cumpre um papel similar aointmain()da linguagem C/C++. Ele é um objeto concorrente simples, umchare, identificado na interface do Charm++ comomainchare. ´

E o único objeto a ser instanciado e invocado pelo gerenciador de execução. É referen-ciado na codificação através de seu objeto PROXY associado: CProxy mainchareTipo mainchareNome.

// . ci

// -// d e s c r i c a o da i n t e r f a c e do charm ++

// -m a i n -m o d u l e m o d u l e N o m e {

// -// i n t e r f a c e do m a i n c h a r e m a i n c h a r e T i p o

// -m a i n c h a r e m a i n c h a r e T i p o {

// -// i n t e r f a c e do c o n s t r u t o r

// -entry m a i n c h a r e T i p o ( args1 );

// -// i n t e r f a c e do metodo de entrada

// N o m e M e t o d o E n t r a d a

// -entry void N o m e M e t o d o E n t r a d a ( args2 );

}; };

// . h

// -// d e f i n i c a o da classe do m a i n c h a r e m a i n c h a r e T i p o // -class m a i n c h a r e T i p o : public C B a s e _ m a i n c h a r e T i p o {

public:

//

-m a i n c h a r e T i p o ( args1 );

// -// p r o t o t i p o do metodo de entrada

// -void N o m e M e t o d o E n t r a d a ( args2 );

(18)

// . cpp

// -// i m p l e m e n t a c a o do c o n s t r u t o r

//

-m a i n c h a r e T i p o :: -m a i n c h a r e T i p o ( args1 ) {

// codigo C ++

}

// -// i m p l e m e n t a c a o do metodo de entrada

// -void m a i n c h a r e T i p o :: N o m e M e t o d o E n t r a d a ( args2 ) {

// codigo C ++

}

2.2.2 Dados com acesso somente para leitura

Por conta da natureza distribu´ıda da execução em Charm++, não faz sentido a declaração de variáveis/objetos globais em sentido estrito. Para cumprir um efeito semelhante ao da declaração de dados globais, o Charm++ disponibiliza um mecanismo particular para que dados possam ser compartilhados por todos os objetos concorrentes. Para que este compartilhamento funcione, os objetos concorrentes devem enxergar os “dados globais” comosomente para leitura(read-only access). Para isto, os referidos “dados globais” devem ser declarados na interface do Charm++ com o modificador

readonly.

Por exemplo, o objeto principal (instância do mainchare) no código Charm++ é instanciado a partir da classe CProxyassociada (conforme mencionado na seção ante-rior). Para que os objetos concorrente acessem os métodos do objeto principal, o objeto principal deve ser declarado como na interface comoreadonly. No arquivo.hda classe

mainchareTipo, o objeto principal ´e referenciado com o modificadorextern.

// . ci

// -// d e s c r i c a o da i n t e r f a c e do charm ++

// -m a i n -m o d u l e m o d u l e N o m e {

// -// i n t e r f a c e para o objeto p r i n c i p a l

// -r e a d o n l y C P r o x y _ m a i n c h a r e T i p o m a i n c h a r e N o m e ;

// -// i n t e r f a c e do m a i n c h a r e m a i n c h a r e T i p o

(19)

-19

// i n t e r f a c e do c o n s t r u t o r

// -entry m a i n c h a r e T i p o ( args1 );

// -// i n t e r f a c e do metodo de entrada

// -entry void N o m e M e t o d o E n t r a d a ( args2 );

}; };

// . h

// -// r e f e r e n c i a m e n t o externo do objeto p r i n c i p a l

// -extern C P r o x y _ m a i n c h a r e T i p o m a i n c h a r e N o m e ;

// -// d e f i n i c a o da classe do m a i n c h a r e m a i n c h a r e T i p o // -class m a i n c h a r e T i p o : public C B a s e _ m a i n c h a r e T i p o {

public:

//

-m a i n c h a r e T i p o ( args1 );

// -// p r o t o t i p o do metodo de entrada

// -void N o m e M e t o d o E n t r a d a ( args2 );

};

// . cpp

// -// i n s t a n c i a m e n t o do objeto PROXY p r i n c i p a l

// -/* r e a d o n l y */ C P r o x y _ m a i n c h a r e T i p o m a i n c h a r e N o m e ;

// -// i m p l e m e n t a c a o do c o n s t r u t o r

//

-m a i n c h a r e T i p o :: -m a i n c h a r e T i p o ( args1 ) {

// codigo C ++

}

// -// i m p l e m e n t a c a o do metodo de entrada

(20)

-void m a i n c h a r e T i p o :: N o m e M e t o d o E n t r a d a ( args2 ) {

// codigo C ++

}

Al´em do objeto principal, outros dados podem ser identificados comoreadonly, tais como mensagens e dados homogˆeneos (dados indexados).

O fato do dado ser identificado comoreadonlyimpõe que ele seja instanciado e inicializado assim que o programa é executado e que seu conteúdo não seja alterado durante toda a execução.

Este assunto será retomado posteriormente na seção sobre mensagens.

2.2.3 Passagem de argumentos

Em Charm++, objetos concorrentes se comunicam através da invocação de métodos de entrada. Os métodos podem requerer diversos parâmetros apresentados como argu-mentos ou agrupá-los manualmente em uma única estrutura de comunicação. Indepen-dente da forma como os parâmetros sejam transferidos, a comunicação entre objetos remotos sempre se dá por meio da troca de mensagens.

No modelo tradicionalde passagem de parâmetros da linguagem C/C++, cada dado é declarado no escopo de argumentos do método correspondente. Como o método pode ser de um objeto remoto, não é poss´ıvel utilizar-se ponteiros entre os argumentos, ou seja, não há passagem de parâmetros por referência, somente por cópia.

O outro modelo de passagem de argumentos é a passagem de mensagens propri-amente dita. Neste caso, os dados são organizados em um objeto próprio (derivado da classe primitiva CMessage, como será apresentado futuramente) e enviados para o objeto remoto. Neste caso, o envio das mensagens é de responsabilidade do kernel do Charm++. O kernel utiliza um buffer de mensagens e, para isso, ele precisa de re-ferências das mensagens (ponteiros).

Vejamos um exemplo de passagem de argumentos no modelo tradicional.

// pgm . ci

// -m a i n -m o d u l e pgm

{

// -// objeto PROXY p r i n c i p a l r e f e r e n c i a d o

// " g l o b a l m e n t e "

// -r e a d o n l y C P r o x y _ m a i n m a i n P r o x y ;

m a i n c h a r e main {

// c o n s t r u t o r

(21)

21

// metodo

entry void r e s u l t a d o (int pe ); };

chare remoto {

entry remoto (void);

// metodo remoto

entry void metodo (int val ); };

};

// pgm . h

// -# ifndef PGM_H

# define PGM_H

// -// r e f e r e n c i a a classe p r i n c i p a l ( mestre )

// -extern C P r o x y _ m a i n m a i n P r o x y ;

// -// classe p r i n c i p a l ( mestre )

// -class main : public C B a s e _ m a i n

{

private:

int cont ;

public:

main ( C k A r g M s g * m );

// metodos da classe ( acesso remoto ) void r e s u l t a d o (int pe );

};

//

// -// classe c o n c o r r e n t e ( escravo )

// -class remoto : public C B a s e _ r e m o t o

{

private:

public:

(22)

// metodos da classe ( acesso local ) void metodo (int val );

};

// -# endif

// pgm . C

// -# include " pgm . decl . h "

//

-# include < math .h >

# include " pgm . h "

//

-C P r o x y _ m a i n m a i n P r o x y ;

// -// c o n s t r u t o r da classe p r i n c i p a l ( mestre )

//

-main :: -main ( C k A r g M s g * m ) {

int npes = C k N u m P e s ();

int i ;

C P r o x y _ r e m o t o p r o c e s s o ;

// -// r e f e r e n c i a ao objeto m a i n P r o x y no p r o c e s s a d o r // ’ mestre ’

//

-m a i n P r o x y = t h i s h a n d l e ;

cont = npes ;

C k P r i n t f (" \ nTotal de PEs : % d \ n ", npes );

C k P r i n t f (" P a r t i n d o do mestre ( PE % d ).\ n ", CkMyPe ());

for ( i =0; i < npes ; i ++) {

p r o c e s s o = C P r o x y _ r e m o t o :: ckNew (); p r o c e s s o . metodo ( i );

} }

//

(23)

23

// -void main :: r e s u l t a d o (int pe )

{

cont - -;

C k P r i n t f (" \ t C o n t a t o do PE % d \ n ", pe );

if (! cont ) {

C k P r i n t f (" V o l t a m o s para o mestre ( PE % d ).\ n \ n ", CkMyPe ()); CkExit ();

} }

//

// -// metodo de entrada do objeto c o n c o r r e n t e

// -void remoto :: metodo (int val )

{

int pe = CkMyPe ();

C k P r i n t f (" \ t \ tRecebi % d .\ n ", val ); m a i n P r o x y . r e s u l t a d o ( pe );

}

//

// -# include " pgm . def . h "

//

-$ < caminho para o compilador >/ charmc -c pgm . ci $ < caminho para o compilador >/ charmc -o pgm pgm . cc $ ./ c h a r m r u n ./ pgm + p4 ++ local

Uma an´alise deste exemplo.

A classe principal (mainchare) se chama main, conforme arquivo de interface pgm.ci. Deriva da classe baseCBase main, como pode ser visto no arquivo de cabeçalho pgm.h. Seu objetoPROXYse chamaCProxy main mainProxy. Isso pode ser reconhecido na codificação em C++ (pgm.C) e pela referência na interface (comoreadonly).

Existe um objeto concorrente instanciado da classe remoto, derivada da classe baseCBase remoto. O instanciamento ocorre no construtor domain, cujo objetoPROXY correspondente se chamaCProxy remoto processo. Este objeto n˜ao ´e “global”.

Os dois construtores (domain e doremoto) são definidos como métodos de en-trada (como devem ser). Além dos construtores, as classes preveem dois outros métodos de entrada: resultado(int pe)nomainemetodo(int val)noremoto.

(24)

método de entradaprocesso.metodo, passando, como argumento, um número inteiro que indica a ordem de instanciamento. Por conseguinte, os objetos remotos recebem estes números inteiros e, cada um, imprime o valor recebido. O passo seguinte dos objetos remotos é invocar o método de entradamainProxy.resultadopassando, como argumento, o ´ındice do PE correspondente (o ´ındice do processador onde o objeto con-corrente foi alocado). O método mainProxy.resultado imprime o ´ındice do PE que enviou a mensagem e só encerra o programa quando tiver recebido os dados de todos.

Algumas coisas importantes para serem observadas.

• A função CkPrintf(...) é invocada no objeto principal e nos remotos. Repare

que a impressão sempre se dá na tela do computador que aloca o objeto princi-pal. Segundo, as impressões são ass´ıncronas porque cada objeto remoto “roda” independentemente. Vários motivos podem interferir na ordem de chegada das mensagens (o que será impresso também é tratado como mensagem).

• Pela lógica do programa, não há necessidade de se manter as referências de cada

objeto concorrente alocado. Como eles são invocados apenas uma única vez, a referênciaprocessopode ser reutilizada. Nem sempre é este o caso. Mas aqui dá para fazer isso. Este exemplo simples permite. Além disso, os objetos concorrente não se falam entre si. Se fosse este o caso, a referênciaprocesso precisaria ser “global” e única para cada objeto concorrente. As opções seriam usar uma lista (chare array) ou um grupo (chare group) de objetos concorrente.

• A referência do objeto PROXY principal é efetivamente realizada na instrução:

mainProxy = thishandle, onde thishandle cumpre um papel semelhante ao

this do C++. thishandle não é um ponteiro (assim como mainProxy), mas “carrega” todas as informações necessárias para o completo referenciamento do objeto em questão.

Em relação à passagem de argumentos, repare o modo tradicional de passagem de dados por cópia.

No entanto, é comum a passagem de ponteiros para estruturas homogêneas como listas e matrizes. Mas como o Charm++ não permite a passagem de ponteiros (pelo fato de os PEs estarem em segmentos de memórias não compartilhadas), o mecanismo teve que ser adaptado. A linguagem Charm++ substitui a passagem por ponteiros (passa-gem de parâmetros por referência) pela declaração da estrutura acompanhada do total de elementos que ela suporta. Por exemplo, o desenvolvedor precisa passar uma lista de valoresdoublecomnelementos como argumento de um método de entrada chamada

misc. A inserção do método na interface do Charm++ será:

(25)

25

onde arr é o nome da estrutura homogênea a ser utilizado no escopo do método de entrada. O protótipo do método em C++ será:

void misc (int n, double *arr);

Pronto, est´a feita a confus˜ao...

— Mas o Charm++ n˜ao tem problemas com ponteiros?

Pois ´e. O Charm++ tem problemas com ponteiro sim. Problemas no sentido de n˜ao se poder utilizar ponteiros entre objetos concorrentes.

Bem, a linguagem C/C++ não reconhece a sintaxe que é utilizada na interface do Charm++ e não pode passar ponteiros. Então como a “coisa” funciona?

Quem intercepta a referência à lista (ponteiro) é okerneldo Charm++. A presença do ponteiro no protótipo do método de entrada é utilizada por umbufferque armazena os valores da estrutura referenciada e monta uma mensagem. Esta mensagem é transmi-tida para o destinatário. Okerneldesmonta a mensagem e coloca os dados da estrutura (que foram transmitidos pela mensagem) em umbuffer alocado na memória do objeto remoto. Obufferé acessado pelo ponteiro presente no argumento do método de entrada do objeto remoto.

Isto produz implicações. Tradicionalmente, em linguagem C/C++, quando um dado é passado por referência através de ponteiro, se o dado original for alterado, quem tem acesso via referência “vê” o dado alterado. Mas isso acontece porque a referência é o endereço do dado e não o dado em si. No caso do Charm++, existe umbufferno meio do caminho. Isso desvinculará a referência do dado original (que pode estar em um pro-cessador) do endereço do dado original em si (que pode estar em outro propro-cessador). Então, apesar de se usar ponteiros na sintaxe do protótipo do método de entrada, estes existem por conta dobufferlocal que é usado pelokernelpara receber os dados. Depois, os dados copiados nobuffersão transmitidos para obufferdo objeto remoto. Lá, obuffer ´

e acessado via ponteiro no m´etodo de entrada do objeto remoto.

— E por que colocar o n´umero (quantidade) de valores?

Osbuffers locais (no remetente e no destinatário) são alocados dinamicamente. Para se acertar o tamanho dobuffer, se faz necessário informar a quantidade de valores e sua natureza. Tudo isso é registrado pela compilação da interface do Charm++.

2.3 Mensagens

(26)

As mensagens são objetos que compactam diferentes tipos de dados em uma única estrutura e que podem ser trocados entre objetos remotos. Elas são transmitidas e rece-bidas de forma ass´ıncrona, ou seja, são enviadas para o gerenciador de execução que irá despachá-las para seus destinatários em algum instante de tempo após a recepção das mesmas. Para controlar a recepção e o envio de mensagens, o gerenciador de execução trabalha com um depósito (workpool) onde as mensagens vão sendo enfileiradas ( queu-eing) e retransmitidas segundo a disponibilidade dos destinatários.

Enquanto objetos, as mensagens também encapsulam métodos. Porém, estes não precisam ser identificados como métodos de entrada, pois este tipo de identificação se refere somente aos métodos que serão invocados remotamente. Como as mensagens são literalmente transmitidas de um processador para outro, seus métodos podem ser acessados localmente tanto pelo objeto remetente antes da transmissão como pelo objeto destinatário após a transmissão.

A classe primitiva que modela toda mensagem se chamaCMessage. Esta classe é genérica e deve ser adequada à codificação da mensagem elaborada pelo desenvolvedor. Esta tarefa não precisa ser realizada pelo desenvolvedor, pois o processo de tradução da interface (arquivos.ci) gera as adaptações necessárias e registra o resultado nos arquivos de declarações e definições (“.decl.h” e “.def.h”). A classe derivada da classe primitiva recebe um nome que é o nome da classe primitiva CMessage conjugado ao nome da classe do desenvolvedor. A classe do desenvolvedor deve ser descendente desta classe derivada para ser reconhecida pelo Charm++. Por exemplo, se a classe do desenvolve-dor se chamamsg, então o nome da classe derivada gerada pela tradução da interface seráCMessage msg.

// classe msg d e s c e n d e n t e de C M e s s a g e _ m s g // que deriva de C M e s s a g e

class msg : public C M e s s a g e _ m s g {

// a t r i b u t o s // c o n s t r u t o r

};

Na interface do Charm++, a mensagem ´e identificada pela chavemessageseguida do nome da classe do desenvolvedor.

Seguindo o exemplo anterior, se a classe elaborada se chamamsg, ent˜ao, na inter-face, esta mensagem ser´a identificada como “message msg”.

m a i n m o d u l e m o d u l e N o m e {

// d e c l a r a c a o de msg message msg ;

// demais d e c l a r a c o e s do modulo m a i n c h a r e m a i n c h a r e N o m e {

(27)

27

};

O Charm++ reconhece dois tipos diferentes de mensagem: amensagem de ta-manho fixo, composto por atributos de tata-manho fixo, e a mensagem de tamanho variável, indicando, normalmente, atributos na forma de lista indexada (vetores e ma-trizes) declaradas através de ponteiros. Na forma fixa, o Charm++ não exige maiores codificações na declaração da mensagem na interface. Já no caso da mensagem de ta-manho variável, como o atributo é um ponteiro, o Charm++ impõe ao desenvolvedor a alocação de memória necessária para acomodar os dados.

2.3.1 Mensagem de tamanho fixo

Exemplo de mensagem com tamanho fixo:

// arquivo . h

class mgs : public C M e s s a g e _ m g s {

public:

// a t r i b u t o s que compoem a m e n s a g e m u n s i g n e d int a ; // 4 bytes

double b ; // 8 bytes

// total 12 bytes

mgs (void) { } };

Na interface, a declaração da mensagem é idêntica ao exemplo anterior.

// arquivo : . ci

m a i n m o d u l e m a i n m o d u l e N o m e {

// d e c l a r a c a o de msg message msg ;

// demais d e c l a r a c o e s do modulo m a i n c h a r e m a i n c h a r e N o m e {

entry m a i n c h a r e N o m e (void); };

};

(28)

programa Charm++. A flexibilidade do Charm++ reside justamente na possibilidade de se alocar memória para uma mensagem somente quando esta é realmente necessária. A operação de alocação é realizada através do operadornew, tradicional da linguagem C++. O processo de transmissão é responsável pela desalocação da memória no lado do remetente e da alocação de memória do lado do destinatário.

Exemplo completo de troca de mensagem de tamanho fixo:

// arquivo : E x M e s s a g e . ci m a i n m o d u l e E x M e s s a g e {

r e a d o n l y C P r o x y _ M e s t r e P r o x y M e s t r e ;

// i n t e r f a c e da m e n s a g e m Msg message Msg ;

m a i n c h a r e Mestre {

// c o n s t r u t o r do m a i n c h a r e entry Mestre ( C k A r g M s g * marg );

// metodo de entrada do m a i n c h a r e entry void M e t o d o M e s t r e (void); };

chare Remoto {

// c o n s t r u t o r do objeto remoto entry Remoto (void);

// metodo de entrada do objeto remoto entry void M e t o d o R e m o t o ( Msg * m ); };

};

// arquivo : E x M e s s a g e . cc # include " charm ++. h "

# include " E x M e s s a g e . decl . h "

// objeto proxy do m a i n c h a r e Mestre // d e c l a r a d o como somente leitura // papel s e m e n h a n t e ao de uma // v a r i a v e l global

C P r o x y _ M e s t r e P r o x y M e s t r e ;

// d e f i n i c a o da m e n s a g e m Msg class Msg : public C M e s s a g e _ M s g {

public:

// dados de tamanho fixo

u n s i g n e d int a ; // 4 bytes

double b ; // 8 bytes

char str [32]; // 32 bytes

// total : 44 bytes

(29)

29

};

// m a i n c h a r e Mestre

class Mestre : public C B a s e _ M e s t r e {

public:

// c o n s t r u t o r do m a i n c h a r e Mestre

Mestre ( C k A r g M s g * marg ) {

// objeto proxy do chare Remoto

C P r o x y _ R e m o t o P r o x y R e m o t o ;

// objeto m e n s a g e m de dado

Msg * m ;

// d e s a l o c a c a o da m e n s a g e m de a r g u m e n t o s delete marg ;

// i d e n t i f i c a d o r deste objeto proxy

P r o x y M e s t r e = t h i s h a n d l e ;

// i n s t a n c i a m e n t o do objeto proxy

C k P r i n t f (" I n s t a n c i a n d o chare P r o x y R e m o t o ...\ n "); P r o x y R e m o t o = C P r o x y _ R e m o t o :: ckNew ();

// i n s t a n c i a m e n t o da m e n s a g e m

C k P r i n t f (" I n s t a n c i a n d o m e n s a g e m m ...\ n "); m = new Msg ;

// a t r i b u i c a o dos dados

m - > a = 10; m - > b = 29.9;

strcpy (m - > str ," string copiada ... ");

// r e q u i s i c a o do metodo remoto com // a t r a n s m i s s a o da mensgem de dado

C k P r i n t f (" E n v i a n d o m e n s a g e m m para chare " " P r o x y R e m o t o ...\ n ");

P r o x y R e m o t o . M e t o d o R e m o t o ( m ); }

// metodo de entrada do m a i n c h a r e Mestre void M e t o d o M e s t r e (void) {

// e n c e r r a m e n t o do p r o c e s s a m e n t o // c o n c o r r e n t e

C k P r i n t f (" E n c e r r a n d o p r o g r a m a " " ( m a i n c h a r e )...\ n "); CkExit ();

} };

// chare Remoto

class Remoto : public C B a s e _ R e m o t o {

private:

(30)

u n s i g n e d int x ;

double y ;

char s [48];

public:

// c o n t r u t o r do chare Remoto

Remoto (void) {

x = 0; y = 0; strcpy (s ," "); }

// metodo de entrada da classe Remoto void M e t o d o R e m o t o ( Msg * m ) {

C k P r i n t f (" R e c e b e n d o m e n s a g e m em " " P r o x y R e m o t o ...\ n ");

// leitura dos dados t r a n s m i t i d o s

x = m - > a ; y = m - > b ;

strcpy (s ,m - > str );

// d e s a l o c a c a o da m e n s a g e m de dados delete m ;

C k P r i n t f (" x = % d \ ty = % lf \ n ",x , y ); C k P r i n t f (" s = % s \ n ",s );

// r e q u i s i c a o do metodo de entrada // do objeto Mestre

C k P r i n t f (" C o n t a c t a n d o m a i n c h a r e ...\ n "); P r o x y M e s t r e . M e t o d o M e s t r e ();

} };

# include " E x M e s s a g e . def . h "

$ < caminho do compilador >/ charmc -c E x M e s s a g e . ci

$ < caminho do compilador >/ charmc -o E x M e s s a g e E x M e s s a g e . cc $ ./ c h a r m r u n ./ E x M e s s a g e ++ local

2.3.2 Mensagem de tamanho vari´avel

No caso da mensagem de tamanho variável, os atributos que precisão ser alocados dinamicamente devem constar da declaração na interface do Charm++. Se a mensa-gem prevê atributos de tamanho fixo, estes não precisam ser declarados na interface, mas devem, naturalmente, ser definidos na codificação da mensagem em si.

// arquivo . h

(31)

31

public:

// -// a t r i b u t o s de tamanho v a r i a v e l

// p r e c i s a m ser d e c l a r a d o s na i n t e r f a c e // -u n s i g n e d char * atrb1 ;

int * atrb2 ;

// -// a t r i b u t o s de tamanho fixo

// nao sao d e c l a r a d o s na i n t e r f a c e

// -u n s i g n e d int atrb3 ; // 4 bytes

double atrb4 ; // 8 bytes

// total 12 bytes fixos

varmsg ( params ) { } };

// arquivo : . ci

m a i n m o d u l e m a i n m o d u l e N o m e {

// -// d e c l a r a c a o de varmsg

// -message varmsg {

// -// a t r i b u t o s de tamanho v a r i a v e l // -u n s i g n e d char atrb1 [];

int atrb2 []; };

// -// demais d e c l a r a c o e s do modulo

entry m a i n c h a r e T i p o (); };

};

A alocação de memória para os atributos de tamanho variável pode ser realizada tanto no construtor da mensagem quanto através do comando de alocação de memória

new modificado pelo Charm++. Neste caso, os comprimentos dos atributos variáveis são inseridos entre o comandonewe o nome da classe de mensagem e o construtor não deve alocar memória (isso é realizado pelokernel).

(32)

// arquivo : E x V a r M s g . ci m a i n m o d u l e E x V a r M s g {

r e a d o n l y C P r o x y _ M e s t r e P r o x y M e s t r e ;

// i n t e r f a c e da m e n s a g e m VarMsg message VarMsg {

char varstr []; // a t r i b u t o s de

float seq []; // c o m p r i m e n t o v a r i a v e l

};

m a i n c h a r e Mestre {

// c o n s t r u t o r do m a i n c h a r e entry Mestre ( C k A r g M s g * marg );

// metodo de entrada do m a i n c h a r e entry void M e t o d o M e s t r e (void); };

chare Remoto {

// c o n s t r u t o r do objeto remoto entry Remoto (void);

// metodo de entrada do objeto remoto entry void M e t o d o R e m o t o ( VarMsg * m ); };

};

// arquivo : E x V a r M s g . C # include " charm ++. h "

# include " E x V a r M s g . decl . h "

// -// objeto proxy do m a i n c h a r e Mestre //

-C P r o x y _ M e s t r e P r o x y M e s t r e ;

// -// d e f i n i c a o da m e n s a g e m VarMsg

// -class VarMsg : public C M e s s a g e _ V a r M s g {

public:

// -// dados de tamanho fixo

// nao devem estar na i n t e r f a c e // -u n s i g n e d int n , m ;

(33)

33

// -char * varstr ;

float * seq ;

// -// c o n s t r u t o r da m e n s a g e m

//

-VarMsg (int p , int q ) { n = p ; m = q ;

// a l o c a c a o manual de memoria

varstr = new char[ n ]; seq = new float[ m ]; }

// -// d e s t r u t o r da m e n s a g e m

//

-~ VarMsg (void) { n = m = 0;

delete[] varstr ; delete[] seq ; varstr = NULL ; seq = NULL ; }

};

// -// m a i n c h a r e Mestre

// -class Mestre : public C B a s e _ M e s t r e {

public:

// -// c o n s t r u t o r do m a i n c h a r e Mestre //

-Mestre ( C k A r g M s g * marg ) {

// objeto proxy do chare Remoto

C P r o x y _ R e m o t o P r o x y R e m o t o ;

// objeto m e n s a g e m de dado

VarMsg * m ;

// d e s a l o c a c a o da m e n s a g e m de a r g u m e n t o s delete marg ;

// i d e n t i f i c a d o r deste objeto proxy

P r o x y M e s t r e = t h i s h a n d l e ;

// i n s t a n c i a m e n t o do objeto proxy

C k P r i n t f (" I n s t a n c i a n d o chare P r o x y R e m o t o ...\ n "); P r o x y R e m o t o = C P r o x y _ R e m o t o :: ckNew ();

// i n s t a n c i a m e n t o da m e n s a g e m

(34)

// c o m p r i m e n t o s de varstr e seq , // r e s p e c t i v a m e n t e : (10 ,20)

m = new VarMsg (10 ,20);

// a t r i b u i c a o dos dados

strcpy (m - > varstr ," string ... "); memset (m - > seq ,0 ,20);

// r e q u i s i c a o do metodo remoto com // a t r a n s m i s s a o da mensgem de dado

C k P r i n t f (" E n v i a n d o m e n s a g e m m para chare " " P r o x y R e m o t o ...\ n ");

P r o x y R e m o t o . M e t o d o R e m o t o ( m ); }

// -// metodo de entrada do m a i n c h a r e Mestre // -void M e t o d o M e s t r e (void) {

// e n c e r r a m e n t o do p r o c e s s a m e n t o // c o n c o r r e n t e

C k P r i n t f (" E n c e r r a n d o p r o g r a m a " " ( m a i n c h a r e )...\ n "); CkExit ();

} };

// -// chare Remoto

// -class Remoto : public C B a s e _ R e m o t o {

private:

// a t r i b u t o s da classe Remoto int l1 , l2 ;

char * s ;

float * f ;

public:

// -// c o n t r u t o r do chare Remoto

//

-Remoto (void) { l1 = l2 = 0; }

// -// metodo de entrada da classe Remoto // -void M e t o d o R e m o t o ( VarMsg * m ) {

(35)

35

// leitura dos dados t r a n s m i t i d o s

l1 = m - > n ; s = new char[ l1 ]; l2 = m - > m ; f = new float[ l2 ];

strcpy (s ,m - > varstr );

memcpy (f ,m - > seq ,sizeof(float)* l2 );

// d e s a l o c a c a o da m e n s a g e m de dados delete m ;

C k P r i n t f (" l1 = % d \ n \ tvarstr = % s \ n ", l1 , s ); C k P r i n t f (" l2 = % d \ n ", l2 );

for ( int i =0; i < l2 ; i ++ )

C k P r i n t f (" \ tf [% d ] = % f \ n ", i , f [ i ]);

// r e q u i s i c a o do metodo de entrada // do objeto Mestre

C k P r i n t f (" C o n t a c t a n d o m a i n c h a r e ...\ n "); P r o x y M e s t r e . M e t o d o M e s t r e ();

} };

# include " E x V a r M s g . def . h "

$ < caminho do compilador >/ charmc -c E x V a r M s g . ci

$ < caminho do compilador >/ charmc -o E x V a r M s g E x V a r M s g . C $ ./ c h a r m r u n ./ E x V a r M s g ++ local

2.3.3 Mensagens no modosomente leitura

Além de viabilizar a passagem de parâmetros entre objetos remotos, as mensagens podem cumprir um papel importante quando se faz necessário o compartilhamento de dados – como em um banco de dados. Imaginando dados que deverão ser consultados por todos os objetos concorrentes, estes poderiam ser acomodados em uma mensagem e disponibilizados através da mesma como somente leitura(readonly). O Charm++ tratará esta mensagem como se fosse global e terá visibilidade para todos os objetos concorrentes.

2.3.4 Mensagem de linha de comando

Vocˆe deve ter percebido que o construtor do mainchare declara uma mensagem como argumento: CkArgMsg* marg. Que mensagem ´e esta?

(36)

de parâmetros passados em linha de comando (incluindo o nome do programa) echar* argv[]são os parâmetros propriamente ditos na forma destrings.

No Charm++, os parâmetros de linha de comando são passados ao construtor do mainchareatravés da mensagem instanciada a partir da classeCkArgMsg. Ela deve ser declarada como ponteiro pelo mesmo motivo apresentado anteriormente; quem trata da mensagem é okerneldo Charm++. Esta mensagem possui dois campos principais que são os mesmos da funçãomain:int argcechar* argv[].

O desenvolvedor pode criar outros construtores paramainchare, mas um constru-tor obrigatório é o construtor que recebe uma mensagem da classeCkArgMsg. Esse não pode faltar.

(37)

Cap´ıtulo 3

Estruturas de objetos concorrentes

3.1 Lista de objetos concorrentes

A lista de objetos concorrentes é uma coleção decharesreferenciados por meio de ´ındices. Pode ter qualquer quantidade de PEs (não está restrita ao número de

processa-dores do recurso computacional utilizado – hardware, rede,cluster,grid.

Sendo cada elemento da lista umchare, todas as caracter´ısticas apresentadas para objetos concorrentes simples se aplicam aos elementos da lista. A lista decharesé decla-rada na interface do Charm++ usando a palavra chavearray[nD], ondené um inteiro (1..6), e a classe do objeto em C++ é filiada a classe primitivaCBase arrayTipocomo em umchare.

// . ci

array[1 D ] a r r a y 1 D T i p o { /* metodos de entrada ... */ }

// . h

class a r r a y 1 D T i p o : public C B a s e _ a r r a y 1 D T i p o {...}

A lista é referenciada e alocada a partir do objeto CProxy arrayTipo no PE de ´ındice 0. Por outro lado, os elementos reais da lista são criados e destru´ıdos dinamica-mente em qualquer PE e podem ser movidos (migrarem) de um PE para outro em função de estratégias de balanceamento de carga.

(38)

Para alocar a lista com a dimensão desejada, utiliza-se o métodockNew(params,lista de número de elementos). A partir da dimensão 3, a lista de número de elementos deve ser inserida usando um objeto espec´ıfico chamadoCkArrayOptions. No quadro a seguir, vê-se as formas de alocação para cada dimensão.

// . c . cc . C . cpp

C P r o x y _ a r r a y 1 D T i p o a r r 1 D N o m e ;

a r r 1 D N o m e = C P r o x y _ a r r a y 1 D T i p o :: ckNew ( args , dim1 );

a r r 2 D N o m e = C P r o x y _ a r r a y 2 D T i p o :: ckNew ( args , dim1 , dim2 );

a r r 3 D N o m e = C P r o x y _ a r r a y 3 D T i p o :: ckNew ( args , dim1 , dim2 , dim3 );

C k A r r a y O p t i o n s opts = C k A r r a y O p t i o n s ( dim1 ,... , dim4 ); a r r 4 D N o m e = C P r o x y _ a r r a y 4 D T i p o :: ckNew ( args , opts );

Os m´etodos de entrada dos elementos da lista podem ser invocados individual-mente ou de forma conjunta (todos os elementos da lista).

Para a invocação individual, são necessários os ´ındices do elemento e o nome do método de entrada de interesse.

// . c . cc . C . cpp

// i n v o c a n d o M e t o d o E n t r a d a do e l e m e n t o ( i )

a r r 1 D N o m e ( i ). M e t o d o E n t r a d a A ( params );

// i n v o c a n d o M e t o d o E n t r a d a do e l e m e n t o (i , j )

a r r 2 D N o m e (i , j ). M e t o d o E n t r a d a B ( params );

// i n v o c a n d o M e t o d o E n t r a d a do e l e m e n t o (i ,j , k )

a r r 3 D N o m e (i ,j , k ). M e t o d o E n t r a d a C ( params );

// i n v o c a n d o M e t o d o E n t r a d a do e l e m e n t o (i ,j ,k , l )

a r r 4 D N o m e (i ,j ,k , l ). M e t o d o E n t r a d a D ( params );

(39)

39

a r r 5 D N o m e (i ,j ,k ,l , m ). M e t o d o E n t r a d a E ( params );

// i n v o c a n d o M e t o d o E n t r a d a do e l e m e n t o (i ,j ,k ,l ,m , n )

a r r 6 D N o m e (i ,j ,k ,l ,m , n ). M e t o d o E n t r a d a F ( params );

A linguagem Charm++ também implementa um mecanismo para invocação de métodos de entrada por difusão (broadcast) de forma que, em apenas uma instrução, o mesmo método de entrada é invocado simultaneamente em todos os elementos da lista. Para isto, basta retirar-se os ´ındices do elemento da lista1.

// . c . cc . C . cpp

// i n v o c a n d o metodo de entrada na lista toda ( b r o a d c a s t )

a r r 1 D N o m e . M e t o d o E n t r a d a A ( params ); a r r 2 D N o m e . M e t o d o E n t r a d a B ( params ); a r r 3 D N o m e . M e t o d o E n t r a d a C ( params ); a r r 4 D N o m e . M e t o d o E n t r a d a D ( params ); a r r 5 D N o m e . M e t o d o E n t r a d a E ( params ); a r r 6 D N o m e . M e t o d o E n t r a d a F ( params );

Uma vez dentro de um método de entrada remoto, o elemento da lista pode recu-perar seus ´ındices através do atributothisIndex. Este atributo se adapta à dimensão da lista:

lista 1 D : t h i s I n d e x

lista 2 D (x , y ) : t h i s I n d e x .x , t h i s I n d e x . y

lista 3 D (x ,y , z ): t h i s I n d e x .x , t h i s I n d e x .y , t h i s I n d e x . z

lista 4 D (w ,x ,y , z ): t h i s I n d e x .w , t h i s I n d e x .x , t h i s I n d e x .y , t h i s I n d e x . z

lista 5 D (v ,w ,x ,y , z ): t h i s I n d e x .v , t h i s I n d e x .w , t h i s I n d e x .x , t h i s I n d e x .y , t h i s I n d e x .z ,

lista 6 D ( x1 , y1 , z1 , x2 , y2 , z2 ): t h i s I n d e x . x1 , t h i s I n d e x . y1 , t h i s I n d e x . z1 , t h i s I n d e x . x2 , t h i s I n d e x . y2 , t h i s I n d e x . z2

O Charm++ permite a criação de listas vazias e a inserção individual de elemen-tos que se realiza através do método primitivoarrayNome(´ındices).insert(params).

1_{Deve-se ter em mente, sempre, que entre os objetos}_PROXY_{’s e os objetos concorrentes reais existe o}

(40)

Após a inserção de todos os elementos necessários, deve-se invocar o método primi-tivo arrayNome.doneInserting() (invocação em broadcast). Somente a partir desta invocação é que os objetos inseridos poderão “entrar em ação”.

Veja um exemplo para o caso de uma lista unidimensional. Será criada uma lista vazia e depois serão inseridos dois elementos de ´ındices 2 e 10. Veja que não há neces-sidade de se utilizar ´ındices em um intervalo fechado.

// . ci

array[1 D ] a r r a y 1 D e x { /* metodos de entrada ... */ }

// . h

class a r r a y 1 D e x : public C B a s e _ a r r a y 1 D e x {...}

// . c . cc . C . cpp

C P r o x y _ a r r a y 1 D e x p r o x y _ a r r ;

// criando lista vazia

p r o x y _ a r r = C P r o x y _ a r r a y 1 D e x :: ckNew ();

// i n s e r i n d o ( criando ) os e l e m e n t o s de indice 2 e 10

p r o x y _ a r r (2). insert ( params ); p r o x y _ a r r (10). insert ( params );

// e n c e r r a n d o as i n s e r c o e s ( b r o a d c a s t )

p r o x y _ a r r . d o n e I s e r t i n g ();

Por fim, os elementos da lista podem ser destru´ıdos individualmente através do método primitivo arrayNome(´ındices).ckDestroy(). Após a destruição de um ele-mento, este pode ser novamente inserido usando o método primitivoarrayNome(´ ındi-ces).insert(params).

Apresenta-se, a seguir, um exemplo de uso simples de uma lista de 3 dimens˜oes.

// . ci

m a i n m o d u l e pgm {

// -// objeto PROXY p r i n c i p a l r e f e r e n c i a d o " g l o b a l m e n t e " // -r e a d o n l y C P r o x y _ m a i n m a i n P r o x y ;

// -// chare p r i n c i p a l

// -m a i n c h a r e main

{

(41)

41

entry main ( C k A r g M s g * m );

// metodo

entry void r e s u l t a d o (int pe ); };

// -// chare array 3 D remoto

// -array [3 D ] remoto

{

entry remoto (void);

// metodo remoto

entry void metodo (void); };

};

// . h

# ifndef PGM_H

# define PGM_H

// -extern C P r o x y _ m a i n m a i n P r o x y ;

// -// classe p r i n c i p a l ( mestre )

// -class main : public C B a s e _ m a i n

{

private:

int cont ;

public:

// -// c o n s t r u t o r

//

-main ( C k A r g M s g * m );

// -// metodo de entrada da classe p r i n c i p a l

// -void r e s u l t a d o (int pe ) {

cont - -;

C k P r i n t f (" \ t C o n t a t o do PE % d \ n ", pe );

if (! cont ) {

C k P r i n t f (" V o l t a m o s para o mestre ( PE % d ).\ n \ n ", CkMyPe ());

(42)

} } };

// -// classe c o n c o r r e n t e ( escravo )

// -class remoto : public C B a s e _ r e m o t o

{

public:

// -// c o n s t r u t o r

//

-remoto (void) {}

// d e c l a r a c a o de c o n s t r u t o r necessaria , pois os

// e l e m e n t o s da lista podem migrar de um PE para outro

remoto ( C k M i g r a t e M e s s a g e * marr ) {}

// -// metodo de entrada do objeto c o n c o r r e n t e

// -void metodo (void) {

int pe = CkMyPe ();

C k P r i n t f (" \ t \ t E l e m e n t o (% d ,% d ,% d ) no PE % d \ n ",

t h i s I n d e x .x , t h i s I n d e x .y , t h i s I n d e x .z , pe ); m a i n P r o x y . r e s u l t a d o ( pe );

} };

# endif

// . C . cc . cpp . c

// -# include " pgm . decl . h "

//

-# include < math .h >

# include " pgm . h "

//

-C P r o x y _ m a i n m a i n P r o x y ;

// -// c o n s t r u t o r da classe p r i n c i p a l ( mestre )

//

-main :: -main ( C k A r g M s g * m ) {

(43)

43

if (m - > argc != 4) { C k P r i n t f (" \ n ");

C k P r i n t f (" linha de comando deve ser :\ n \ n ");

C k P r i n t f (" \ t .\\ c h a r m r u n .\\ pgm < ne1 > < ne2 > < ne3 > " " +p <n > ++ local \ n \ n ");

C k P r i n t f (" \ tonde :\ n ");

C k P r i n t f (" \ t \t < ne1 >: num . de elem . da 1 a d i m e n s a o \ n "); C k P r i n t f (" \ t \t < ne2 >: num . de elem . da 2 a d i m e n s a o \ n "); C k P r i n t f (" \ t \t < ne3 >: num . de elem . da 3 a d i m e n s a o \ n "); C k P r i n t f (" \ t \t <n > : numero de PEs \ n ");

C k P r i n t f (" \ n \ n ");

C k P r i n t f (" \ t e x e m p l o :\ n \ n ");

C k P r i n t f (" \ t .\\ c h a r m r u n .\\ pgm 2 3 2 + p6 ++ local \ n \ n "); CkExit ();

}

ne1 = atoi (m - > argv [1]); ne2 = atoi (m - > argv [2]); ne3 = atoi (m - > argv [3]);

delete m ;

// -// d e c l a r a n d o o PROXY da lista p r o c e s s o da classe remoto //

-C P r o x y _ r e m o t o p r o c e s s o ;

// -// r e f e r e n c i a ao objeto m a i n P r o x y no p r o c e s s a d o r ’ mestre ’ //

-m a i n P r o x y = t h i s h a n d l e ;

// -// total de e l e m e n t o s

//

-cont = ne1 * ne2 * ne3 ;

C k P r i n t f (" \ n ");

C k P r i n t f (" Mestre em PE % d .\ n ", CkMyPe ()); C k P r i n t f (" Total de PEs : % d \ n ", C k N u m P e s ());

C k P r i n t f (" Total de e l e m e n t o s da lista : (% d ,% d ,% d )\ n ", ne1 , ne2 , ne3 );

// -// usando objeto da classe C k A r r a y O p t i o n s

//

(44)

// -// i n v o c a n d o metodo remoto por b r o a d c a s t

//

-p r o c e s s o . metodo (); }

// -# include " pgm . def . h "

//

-$ < caminho do compilador >/ charmc -c pgm . ci $ < caminho do compilador >/ charmc -o pgm pgm . C $ ./ c h a r m r u n ./ pgm 3 3 3 + p4 ++ local

3.2 Colec

¸˜

oes de objetos concorrentes

3.2.1 Grupos de objetos concorrentes

Um grupo de objetos concorrente é um tipo especial de organização de objetos remotos. Cada grupo é uma coleção de objetos, como a lista, com um e apenas um membro do grupo por processador. Todos os membros de grupo partilham uma mesma identificação. Um membro espec´ıfico pode ser acessado identificando-se o processador onde ele reside. Isto fere a caracter´ıstica básica oferecida pelo Charm++ que é não se preocupar onde o objeto está. Mas, em casos espec´ıficos em que um membro em particular precisa ser acessado, será necessário identificar o processador.

Um grupo é declarado na interface do Charm++ usando a palavra chavegroup. Na codificação em C++, o objeto de grupo é filiado à mesma superclasse do chare,