Académique Documents
Professionnel Documents
Culture Documents
So Paulo
2012
So Paulo
2012
rea de Concentrao:
Sistemas Digitais
Orientadora:
Prof Dr Liria Matsumoto Sato
So Paulo
2012
AGRADECIMENTOS
Deus por ter me presenteado com esta oportunidade nica em minha vida.
professora Liria Matsumoto Sato pela sua ajuda e sugestes que foram
valiosssimas para o direcionamento deste trabalho. Tambm agradeo a sua
amizade e o seu lado humano. A senhora uma pessoa incrvel e agradeo muito a
oportunidade de ser orientado pela senhora.
Aos meus familiares que foram o meu porto seguro: minha me, Margarida
Paiva de Oliveira, meu pai, Augusto Mendes Gomes e minha irm, Mariana Vilha
Gomes, e a todos os familiares que estiveram ao meu lado nesta batalha de cinco
anos.
minha esposa, Jessika de Oliveira Barbosa Gomes, que foi a pessoa que
mais teve pacincia comigo, sendo uma parceira maravilhosa. Ter uma pessoa to
especial ao meu lado me tornou uma pessoa mais forte e mais perseverante na
busca dos meus objetivos. Obrigado por fazer parte da minha vida.
Aos
colegas de
laboratrio
que
me proporcionaram
momentos de
RESUMO
A execuo de uma aplicao paralela, utilizando grades computacionais, necessita
de um ambiente que permita a sua execuo, alm de realizar o seu gerenciamento,
escalonamento e monitoramento. O ambiente de execuo deve prover um modelo
de processamento, composto pelos modelos de programao e de execuo, no
qual o objetivo a explorao adequada das caractersticas das grades
computacionais. Este trabalho objetiva a proposta de um modelo de processamento
paralelo, baseado em variveis compartilhadas, para grades computacionais, sendo
composto por um modelo de execuo apropriado para grades e pelo modelo de
programao da linguagem paralela CPAR. O ambiente CPAR-Grid foi desenvolvido
para executar aplicaes paralelas em grades computacionais, abstraindo do
usurio todas as caractersticas presentes em uma grade computacional. Os
resultados obtidos mostram que este ambiente uma soluo eficiente para a
execuo de aplicaes paralelas.
ABSTRACT
The execution of parallel applications, using grid computing, requires an environment
that enables them to be executed, managed, scheduled and monitored. The
execution environment must provide a processing model, consisting of programming
and execution models, with the objective appropriately exploiting grid computing
characteristics. This paper proposes a parallel processing model, based on shared
variables for grid computing, consisting of an execution model that is appropriate for
the grid and a CPAR parallel language programming model. The CPAR-Grid
environment is designed to execute parallel applications in grid computing, where all
the characteristics present in grid computing are transparent to users. The results
show that this environment is an efficient solution for the execution of parallel
applications.
LISTA DE ILUSTRAES
Figura 2.1 Decomposio da multiplicao de matrizes: (a) Granularidade fina (b)
Granularidade grossa (baseado em [32]) .................................................................. 24
Figura 2.2 Grafo de dependncia de tarefas .......................................................... 25
Figura 2.3 - Abstrao da memria compartilhada distribuda (baseado em [8]) ...... 28
Figura 2.4 Tipos de algoritmos de escalonamento de tarefas para grades
computacionais (baseado em [15]) ........................................................................... 35
Figura 3.1 Modelo do espao de endereamento do ABACUS (extrado de [63]) . 42
Figura 3.2 Compilao e execuo de uma aplicao SATIN (extrado de [51]) ... 48
Figura 3.3 Arquitetura de disparo no MPICH-G2 (extrado de [36]) ....................... 51
Figura 3.4 Grade computacional composta por 2 domnios e 12 processos
(extrado de [36]) ....................................................................................................... 52
Figura 4.1 Modelo de um ambiente de grades computacionais ............................. 57
Figura 4.2 Infraestrutura do sistema....................................................................... 58
Figura 4.3 Exemplo de arquivo de submisso........................................................ 60
Figura 4.4 Arquitetura do LIMA (extrado de [54]) .................................................. 64
Figura 4.5 Arquitetura de funcionamento do Servio de Mensagem ...................... 69
Figura 4.6 Exemplo de arquivo de submisso........................................................ 70
Figura 4.7 Submisso de um Arquivo .................................................................... 70
Figura 5.1 Elementos de construo da linguagem CPAR .................................... 72
Figura 5.2 Sintaxe da Declarao de uma Varivel Compartilhada ....................... 72
Figura 5.3 Sintaxe do Bloco Paralelo ..................................................................... 73
Figura 5.4 Sintaxe: Especificao (a), Corpo (b) e Chamada (c) de uma
Macrotarefa (extrado de [28]) ................................................................................... 74
Figura 5.5 Sintaxe do Comando Forall ................................................................... 75
Figura 5.6 Sintaxe da Construo Parbegin ........................................................... 75
Figura 5.7 Sintaxe de um Macrobloco .................................................................... 75
Figura 5.8 Sintaxe dos Comandos do Semforo (baseado em [28]) ...................... 76
Figura 5.9 Sintaxe dos Comandos do Evento (baseado em [28]) .......................... 77
Figura 5.10 Sintaxe de um Monitor ........................................................................ 78
Figura 6.1 Gerao do cdigo executvel no ambiente ......................................... 81
Figura 6.2 Exemplo de aplicao CPAR ................................................................ 84
Figura 6.3 Exemplo de alocao de processos para uma aplicao exemplo ....... 85
Figura 6.4 Modelo de execuo para grades computacionais ............................... 91
Figura 6.5 Mapeamento das variveis compartilhadas em endereos de memria
.................................................................................................................................. 95
Figura 7.1 Unificao dos processos em um n multiprocessador ...................... 101
Figura 7.2 Primeiro fluxo para o controle do trmino de uma tarefa ou bloco ...... 103
Figura 7.3 Segundo fluxo para o controle do trmino de uma macrotarefa ou
macrobloco .............................................................................................................. 105
Figura 7.4 Regio que compartilha o dado entre o emissor e o executor ............ 106
Figura 7.5 Escrita pelo coordenador na rea compartilhada com o executor ...... 106
Figura 7.6 Pontos de sincronizao do CPAR-Grid ............................................. 109
Figura 7.7 Primeiro acesso a uma varivel compartilhada ................................... 110
Figura 7.8 Atualizao das variveis compartilhadas........................................... 111
Figura 7.9 Fluxograma da estratgia de escalonamento dos macroblocos ......... 113
Figura 7.10 Mensagens enviadas para o escalonamento de um macrobloco ...... 114
Figura 7.11 Fluxograma da estratgia de escalonamento das macrotarefas ....... 116
Figura 7.12 Mensagens enviadas para o escalonamento de uma macrotarefa ... 118
Figura 8.1 Estrutura do algoritmo sinttico ........................................................... 125
Figura 8.2 Estrutura do algoritmo das matrizes utilizando a verso com variveis
locais e a verso completa ...................................................................................... 127
Figura 8.3 Estrutura do algoritmo das matrizes utilizando a verso somente com
macrotarefas ........................................................................................................... 128
Figura 8.4 Grafo com o tempo de comunicao entre os domnios (universidades)
................................................................................................................................ 130
Figura 8.5 Grfico de mensagens internas e externas para o gerenciamento da
aplicao ................................................................................................................. 135
Figura 8.6 Grfico de desempenho da verso com variveis locais .................... 136
Figura 8.7 Grfico com a quantidade de mensagens enviadas internas e externas
................................................................................................................................ 139
Figura 8.8 Grfico com o tempo de execuo das verses somente com tarefas e
completa .................................................................................................................. 140
Figura 8.9 Grfico de desempenho da verso completa ...................................... 143
LISTA DE TABELAS
Tabela 3.1 Anlise comparativa dos ambientes de programao .......................... 55
Tabela 8.1 Tempo de comunicao entre os domnios (universidades) .............. 130
Tabela 8.2 Detalhes das mensagens enviadas na verso com variveis locais .. 134
Tabela 8.3 Tempo de processamento da verso com variveis locais ................ 136
Tabela 8.4 Quantidade de mensagens enviadas na mdia da soma das matrizes
multiplicadas............................................................................................................ 138
Tabela 8.5 Tempo de processamento da verso completa .................................. 142
BNF
CM
Collector Module
CPAR
CRS
DR
Data Repository
DRMAA
DSM
DUROC
FTP
GASS
GCSE
GFS
GRAM
GridRPC
GridCPR
GSI
HTTPS
JVM
LAHPC
LIMA
MDS
MPI
PRMM
PVM
SOAP
SPMD
TCP
WAN
WSDD
XML
SUMRIO
1. INTRODUO .................................................................................................... 15
1.1 Objetivos .................................................................................................... 16
1.2 Justificativa ................................................................................................ 17
1.3 Metodologia ............................................................................................... 19
1.4 Estrutura do Texto ..................................................................................... 21
2. COMPUTAO PARALELA ............................................................................... 22
2.1 Conceitos de programao paralela .......................................................... 22
2.1.1 Modelos de comunicao .................................................................... 22
2.1.2 Granularidade ...................................................................................... 24
2.1.3 Sincronizao ...................................................................................... 25
2.1.4 Modelos de algoritmos paralelos ......................................................... 26
2.2 Memria compartilhada distribuda ............................................................ 28
2.2.1 Estrutura .............................................................................................. 30
2.2.2 Modelo de consistncia ....................................................................... 31
2.3 Escalonamento de tarefas para grades computacionais ........................... 34
2.3.1 Escalonamento de tarefas independentes ........................................... 35
2.3.2 Escalonamento de tarefas dependentes.............................................. 37
2.4 Consideraes finais .................................................................................. 39
3. AMBIENTES DE PROGRAMAO PARA GRADES COMPUTACIONAIS ........ 40
3.1 ABACUS .................................................................................................... 41
3.2 SAGA ......................................................................................................... 43
3.3 SATIN ........................................................................................................ 46
3.4 MPICH-G2 ................................................................................................. 50
3.5 Anlise Comparativa .................................................................................. 54
3.6 Consideraes Finais ................................................................................ 56
4. INFRAESTRUTURA DA GRADE COMPUTACIONAL DO CPAR-GRID............. 57
4.1 Condor ....................................................................................................... 59
4.1.1 Preparao do Cdigo ......................................................................... 60
4.1.2 Submisso do Job ............................................................................... 60
4.2 Globus........................................................................................................ 61
4.2.1 Gerenciamento e Alocao dos Recursos da Grade (GRAM) ............. 62
DE
PROCESSAMENTO
PARALELO
PARA
GRADES
COMPUTACIONAIS .................................................................................................. 79
6.1 Caractersticas de grades computacionais ................................................ 80
6.2 Ambiente de programao ......................................................................... 80
6.3 Modelo de programao ............................................................................ 82
6.4 Modelo de execuo .................................................................................. 89
6.4.1 Coordenador Mestre ............................................................................ 91
6.4.2 Coordenador Local .............................................................................. 92
6.4.3 Executor ............................................................................................... 93
6.4.4 Emissor ................................................................................................ 94
6.4.5 Fila de execuo .................................................................................. 94
6.4.6 Gerenciador de variveis compartilhadas ............................................ 95
6.4.7 Escalonador ......................................................................................... 96
6.5 Consideraes Finais ................................................................................ 97
7. O AMBIENTE DE EXECUO CPAR-GRID ...................................................... 99
7.1 Modelo do CPAR-Grid ............................................................................... 99
7.2 Controle de finalizao das macrotarefas e dos macroblocos ................. 102
7.3 Buffer ....................................................................................................... 105
7.4 Atualizao das variveis compartilhadas ............................................... 108
15
1. INTRODUO
Algumas
linguagens
paralelas
foram
desenvolvidas
para
cluster
de
16
1.1 Objetivos
O objetivo deste trabalho apresentar a proposta e o desenvolvimento de um
modelo de processamento paralelo, baseado em variveis compartilhadas, para
grades computacionais. Ele composto por um modelo de execuo apropriado
para grades e pelo modelo de programao da linguagem paralela CPAR [56].
O ponto fundamental do modelo, visando a otimizao de desempenho, a
utilizao de estratgias que minimizem a troca de mensagens e apliquem um
mecanismo de escalonamento que privilegie os ns do domnio, objetivando a
diminuio da distncia entre os ns que se comunicam e a utilizao adequada da
estrutura hierrquica das grades computacionais.
A linguagem CPAR foi escolhida devido a prover mltiplos nveis de
paralelismo, atravs de uma estrutura hierrquica, facilitando a explorao da
arquitetura, em geral, hierrquica das grades computacionais.
A utilizao de variveis compartilhadas para a comunicao entre os
processos que so executados por uma aplicao facilita o seu desenvolvimento,
pois no necessrio explicitar a comunicao atravs da troca de mensagens.
Foi implementado o ambiente CPAR-Grid para a execuo de aplicaes
paralelas nas grades computacionais, analisando o comportamento do modelo de
processamento proposto.
O ambiente de execuo deve prover uma infraestrutura que realize as
seguintes tarefas:
17
Submeter a aplicao;
Explorao
da
rea
de
memria
compartilhada
em
ns
1.2 Justificativa
Hoje em dia, as aplicaes com alta demanda de processamento esto
utilizando as grades computacionais para a sua execuo [68]. Porm, grande parte
das aplicaes que so executadas em uma grade so aplicaes de workflow [12],
no qual o compartilhamento de informaes ocorre atravs de arquivos, ao invs da
utilizao de memria compartilhada ou troca de mensagens.
As aplicaes paralelas, que so executadas nas grades computacionais
atravs de workflows, so formadas por um conjunto de tarefas, no qual cada tarefa
um programa e a comunicao entre as tarefas ocorre atravs de arquivos de
entrada e sada. Caso duas tarefas estejam executando de maneira simultnea, elas
no se comunicam durante a execuo. Ao final da execuo, uma tarefa gera um
18
arquivo de sada e este arquivo pode servir de entrada para outra tarefa. Atravs dos
arquivos, forma-se a dependncia entre as tarefas, j que uma tarefa que dependa
de alguns arquivos de entrada somente iniciar a sua execuo quando estes
arquivos estiverem disponveis.
A
utilizao
de
uma
linguagem
de
programao
paralela
para
desenvolvimento
de
aplicaes
para
ambiente
de
grades
computacionais [68], alm de permitir que a comunicao entre duas ou mais tarefas
ocorra durante a sua execuo.
Para a execuo de linguagens paralelas que utilizam rea de memria
compartilhada ou troca de mensagens para o compartilhamento de informaes,
necessrio que exista um ambiente de programao para o gerenciamento das
aplicaes, que seja responsvel pela submisso, escalonamento, monitoramento e
execuo da aplicao.
H poucos ambientes de programao para grades computacionais que no
so baseados em workflow. Os ambientes encontrados na literatura foram: SATIN
[51], SAGA [30] e ABACUS [63]. Estes possuem uma infraestrutura para a execuo
de aplicaes paralelas. Tambm h a biblioteca de passagem de mensagens
MPICH-G2 [36] que utilizada para a comunicao de processos em domnios
distintos. Porm, utilizando MPICH-G2, todos os ns de processamento na grade
computacional precisam ter endereamento pblico. Os ns internos de clusters de
computadores, geralmente, possuem endereamento privado, o que inviabiliza a
execuo de aplicaes paralelas em grades computacionais em que estes estejam
presentes.
O paradigma de programao [58] oferecido pelo SATIN, ABACUS e SAGA
orientado a objetos e com relao ao compartilhamento das informaes, os
ambientes estudados utilizam arquivos [30], servios [63] ou objetos [51].
19
1.3 Metodologia
O modelo de processamento do ambiente de execuo teve como base os
trabalhos desenvolvidos por Craveiro [9] e Gomes Jr. [28]. Nestes trabalhos, foram
desenvolvidos
um
ambiente
para
programao
paralela
com
variveis
20
ambientes
existentes
para
grades
computacionais
as
suas
21
distribuda
algoritmos
de
escalonamento
para
grades
computacionais.
O captulo 3 faz uma reviso sobre os principais ambientes de programao
para grades computacionais, mostrando as caractersticas de todos os ambientes.
Alm disso, feita uma comparao entre os ambientes, mostrando as suas
vantagens e desvantagens.
O captulo 4 explica a caracterstica e o funcionamento de todas as
ferramentas utilizadas para o desenvolvimento da infraestrutura do ambiente
proposto nesta tese. O captulo tambm mostra como a juno destas ferramentas
para a elaborao do ambiente.
A linguagem CPAR detalhada no captulo 5, pois esta a linguagem na qual
o programador desenvolve aplicaes para serem executadas no ambiente CPARGrid.
O modelo de processamento proposto para a execuo de aplicaes
paralelas em grades computacionais descrito no captulo 6, no qual detalhado o
seu modelo de programao e de execuo. O captulo 7 detalha a implementao
do ambiente CPAR-Grid, mostrando a sua arquitetura e as suas funcionalidades.
O captulo 8 apresenta os testes realizados para analisar o funcionamento do
ambiente de acordo com as estratgias implementadas e o seu desempenho. O
captulo 9 conclui o trabalho, ressaltando as contribuies da tese e trazendo
sugestes de trabalhos futuros.
22
2. COMPUTAO PARALELA
23
24
2.1.2 Granularidade
O tamanho de uma tarefa est relacionado quantidade de processamento.
Quando uma tarefa pequena significa que ela possui pouco processamento. O
oposto ocorre para as tarefas grandes.
O nmero e o tamanho das tarefas nos quais um problema decomposto,
determina a granularidade da decomposio, sendo que a decomposio em um
grande nmero de pequenas tarefas chamada de granularidade fina. Por outro
lado, a decomposio em um pequeno nmero de grandes tarefas chamada de
granularidade grossa. A decomposio do problema de multiplicao de matrizes
ilustrado na Figura 2.1-a um exemplo de granularidade fina porque h um grande
nmero de tarefas, no qual cada uma executa o clculo de uma clula da matriz
resultante [32].
A Figura 2.1-b ilustra um exemplo de decomposio em granularidade grossa,
no qual o mesmo problema dividido em trs tarefas, sendo que cada uma
processa um tero da matriz resultante.
Um conceito relacionado a granularidade o grau de paralelismo. O nmero
mximo de tarefas que podem ser executadas simultaneamente em um programa
paralelo, em determinado momento conhecido como seu grau mximo de
paralelismo. Na maioria dos casos, o grau mximo menor que o nmero total de
tarefas, devido s dependncias existentes entre as tarefas.
25
2.1.3 Sincronizao
Em uma aplicao paralela, dois ou mais processos podem, praticamente no
mesmo momento, acessar um dado compartilhado. Neste caso, o resultado final do
processamento depende da ordem em que os acessos ocorreram em uma
execuo. Esta situao, na qual os processos disputam o acesso a um dado
compartilhado, chamada de condio de corrida.
Para evitar a condio de corrida, necessrio implementar a excluso
mtua durante a execuo, ou seja, um mecanismo que garante que no ocorrer
acessos simultneos a um recurso compartilhado. Em uma aplicao paralela,
apenas alguns trechos de cdigo fazem acesso a recursos compartilhados. Desta
forma, utiliza-se um mecanismo de excluso mtua somente nos trechos que
acessam recursos compartilhados, os quais so chamados de regio crtica.
26
27
Modelo mestre-escravo
Modelo pipeline
28
29
que
aplicaes
projetadas
para
executar
em
um
computador
30
2.2.1 Estrutura
Um sistema DSM se assemelha muito a um sistema de replicao. Cada
processo visualiza uma abstrao de um conjunto de objetos, sendo que este
conjunto se assemelha a memria. A DSM pode variar de acordo com o que
considerado como objeto e no modo como eles so endereados. H trs estruturas
que podem ser utilizadas em uma DSM: orientada a bytes, orientada a objetos e
dados imutveis [8].
Orientada a bytes
Este tipo de DSM acessado como a memria virtual normal, ou seja, atravs
de um array de bytes adjacentes. Esta estrutura possibilita que as aplicaes
coloquem quaisquer estruturas de dados na memria compartilhada. Os objetos
compartilhados so posies de memria endereveis diretamente. As nicas
operaes possveis sobre estes objetos so a leitura (read) e a escrita (write). Se x
uma posio de memria, ento denota-se as instncias dessas operaes da
seguinte maneira:
Orientada a objetos
31
Dados imutveis
32
Consistncia sequencial
Consistncia fraca
33
saia da seo crtica, j que enquanto o processo estiver na seo crtica, os demais
processos no utilizaro estes dados simultaneamente.
Desta forma, no escopo da seo crtica, a memria est em um estado
inconsistente, mas para o desenvolvedor isso imperceptvel. Neste modelo, a
garantia dos dados atualizados ocorre antes e depois do acesso a uma regio
crtica.
Consistncia relaxada
34
35
caso, as tarefas podem ser vistas como uma Bag-of-Tasks [3]. A Figura 2.4 mostra
os tipos de algoritmos de escalonamento que podem ser utilizados, de acordo com a
dependncia das tarefas, no qual elas podem ser dependentes ou independentes.
Os algoritmos podem realizar o escalonamento estaticamente ou dinamicamente. As
prximas sees detalham os algoritmos utilizados para o escalonamento de tarefas
dependentes e independentes.
36
37
38
ou
computadores
que
estejam
prximos
geograficamente.
39
Entre
os
elementos
de
uma
aplicao,
geralmente,
40
41
variveis/objetos
compartilhados
para
que
os
processos
possam
ter
compartilhamento de dados.
As sees a seguir detalham os ambientes de programao para grades
computacionais estudados.
3.1 ABACUS
ABACUS [63] um ambiente de programao orientado a servios para
aplicaes em grades computacionais. Ele abstrai um servio como um elemento de
construo da linguagem, assim como a declarao de um objeto em Java. Desta
forma, ele permite que o usurio se concentre na lgica da aplicao, ao invs de se
preocupar com os detalhes da infraestrutura. O ambiente ABACUS foi desenvolvido
em Java e a sua utilizao ocorre atravs de Web Services.
No ambiente ABACUS, uma grade computacional vista como um
supercomputador, e todos os recursos na grade constituem um espao de
endereamento lgico unificado [42]. Neste espao, cada clula de memria contm
um recurso na forma de servio, sendo que as operaes de escrita e execuo so
permitidas em cada clula.
A Figura 3.1 mostra o modelo do espao de endereamento da grade
computacional [16, 17] utilizada como base para o ambiente do ABACUS. Neste
modelo, uma grade construda em um espao de memria, no qual cada servio
da grade associado a uma clula de memria.
O espao de servio virtual (Virtual Service Space) o local em que os
servios compartilhados so alocados. Em cada n realizado o mapeamento da
rea de um servio virtual para uma rea de armazenamento local, chamada de
espao de servio fsico (Physical Service Space). Cada rea de armazenamento
local exclusiva para o armazenamento de um servio compartilhado.
42
43
de
um
cluster,
havendo
necessidade
destes
ns
possurem
endereamento pblico.
Um compilador baseado neste sistema foi implementado para o ABACUS. A
principal caracterstica do Vega GOS, para o ambiente ABACUS, a traduo de
um servio virtual para um servio fsico e o gerenciamento do seu ciclo de vida.
Uma aplicao de grade feita no ABACUS atravs de um ou mais arquivos
de definio de servios. Todos estes arquivos so traduzidos pelo compilador do
ABACUS nos seus respectivos arquivos de execuo (arquivos jar e arquivos
WSDD). Estes arquivos so executados no ambiente do Vega GOS. A infraestrutura
disponibilizada pelo Vega GOS feita atravs de Web Services.
3.2 SAGA
SAGA [30] um ambiente de programao orientado a objetos para grades
computacionais, implementado em C++. Ele abstrai as caractersticas do ambiente
para o usurio, fornecendo uma interface de alto nvel que facilita o desenvolvimento
44
de aplicaes para grades computacionais. Esta interface prov uma sintaxe concisa
para expressar os principais objetivos dos desenvolvedores, como mudar um
arquivo de um ponto para outro, ou acessar arquivos remotos.
O desenvolvimento da API do SAGA foi baseado em uma especificao
independente da linguagem. Tambm foi elaborado um conjunto de vnculos que
abrange as principais linguagens utilizadas no desenvolvimento de aplicaes
cientficas (Fortran, C, C++, Java, Perl e Python).
O ambiente SAGA foi modelado e desenvolvido com o princpio de cobrir as
principais funcionalidades necessrias para as grades computacionais. Ou seja, h
funcionalidades que no so cobertas, porm estas so utilizadas com menor
freqncia. As funcionalidades foram listadas por um grupo de pesquisadores do
Reino Unido, dos Estados Unidos, da Holanda e do Japo.
As principais funcionalidades listadas pelos pesquisadores foram:
45
GFS-WG: O GFS (Grid File System) [25] define uma arquitetura que
integra os sistemas de arquivos fsicos em um sistema nico global, com
um espao de nomes uniforme. O ambiente SAGA utiliza as definies
dos espaos de nomes definidos pelo GFS, alm de suas estruturas de
arquivos e diretrios.
46
3.3 SATIN
SATIN [51] um ambiente de programao orientado a objetos para grades
computacionais, implementado em Java, incluindo o sistema e o protocolo de
comunicao. A linguagem de programao utilizada neste ambiente uma
extenso da linguagem Java. O ambiente utiliza, principalmente, o modelo de
diviso e conquista [7], ou seja, este ambiente procura explorar a estrutura
hierrquica das grades computacionais, realizando a diviso do processamento
entre os diversos domnios que compem a grade. Em cada diviso efetuada, h um
n responsvel por retornar a resposta, aps a juno dos resultados. Esta
estratgia auxilia na distribuio de processamento, explorando as caractersticas
das grades computacionais.
O usurio do SATIN no precisa se preocupar com os mecanismos de
comunicao e sincronizao, com as threads, com o balanceamento de cargas e
com tolerncia a falhas, pois estes so abstrados pelo ambiente.
47
48
49
comunicao eficaz combinada com qualquer JVM. Ela um sistema flexvel que
pode fornecer suporte de comunicao para qualquer aplicao de grade, desde
transmisso de vdeo at computao massivamente paralela. A plataforma IBIS
fornece uma estrutura unificada para comunicao confivel e no confivel, unicast
e multicast de dados. Devido a ela ser baseada em Java, possui as vantagens
oriundas do Java, como a portabilidade, o apoio heterogeneidade e segurana.
A plataforma IBIS realiza a comunicao entre ns internos de um cluster com
ns externos, no havendo a necessidade dos ns internos possurem
endereamento pblico.
Aps a reescrita do bytecode da aplicao Java, gera-se o bytecode SATIN e
ele compilado pelo compilador da plataforma IBIS para gerar o cdigo serializado
dos objetos que sero utilizados para a comunicao entre os processos.
O ambiente SATIN utiliza objetos para o compartilhamento das informaes.
A atualizao dos objetos compartilhados realizada atravs do modelo de
consistncia relaxada [26], permitindo uma replicao eficiente dos dados
compartilhados [65].
Todos os dados compartilhados entre processos de uma aplicao so
encapsulados em objetos compartilhados. O ambiente utiliza um protocolo de
replicao baseado em atualizao, uma vez que tem se mostrado eficiente para
linguagens baseadas em objetos [2]. Em tempo de execuo, o SATIN
automaticamente cria cpias dos objetos compartilhados nos processos que podem
acess-los. Com isso, as operaes locais podem utilizar a sua cpia local, sem a
necessidade de troca de mensagens. As operaes globais so aplicadas a todas as
cpias.
Neste modelo de consistncia, o programador pode definir os requisitos de
consistncia das aplicaes, atravs da utilizao de funes especiais associadas
com tarefas de diviso e conquista. Uma funo especial executada antes de cada
tarefa, sendo que ela verifica o estado dos objetos compartilhados acessados pela
tarefa, e retorna "true" se os objetos esto em um estado correto, ou "false", caso
contrrio.
Caso o estado seja avaliado como "false", o ambiente tem que fazer a cpia
local mais consistente. Isso feito atravs da espera por atualizaes, ou pela
busca de uma cpia mais recente.
50
O ambiente SATIN prov tolerncia a falhas, sendo que a idia bsica para
implement-la recalcular o trabalho feito por um processo que est saindo do
ambiente, o que possvel desde que os jobs no tenham dependncias com outros
jobs. O principal problema em executar novamente tarefas no modelo de diviso e
conquista, a possibilidade de rfos [61]: se o trabalho retirado de um n que
deu problema, ele torna-se rfo e, consequentemente, o ambiente no saber o
que deve ser feito com o resultado deste processamento. Para resolver esses
problemas, o ambiente utiliza uma combinao de duas tcnicas: o armazenamento
do trabalho rfo e o checkpoint [61]. Desta forma, o ambiente pode continuar a
execuo das aplicaes, mesmo com a falha inesperada de algum n/processo.
3.4 MPICH-G2
A interface de passagem de mensagem MPICH-G2 [36] no um ambiente
de programao como a proposta deste trabalho, mas uma implementao do
padro MPI [48] para grades computacionais. Esta interface torna possvel a
execuo de aplicaes em C ou em Fortran com MPI em um ambiente distribudo.
A interface oculta aspectos de heterogeneidade utilizando os servios do
Globus [18], como autenticao, autorizao, criao, monitoramento, execuo e
controle de processos, comunicao, redirecionamento de entrada e sada e acesso
remoto a arquivos. Dessa forma, possvel executar programas MPI em diferentes
localidades da mesma maneira e utilizando os mesmos comandos que seriam
utilizados em um computador paralelo.
Para a comunicao entre os ns de um cluster, no qual a verso do MPI a
mesma, a interface MPICH-G2 consegue utilizar as primitivas nativas da verso
MPICH instalada para realizar a comunicao. Caso a comunicao seja externa a
esse cluster, ele realiza a comunicao atravs de primitivas de TCP/IP. Para que
esta comunicao utilizando TCP/IP ocorra, a interface MPICH-G2 obriga que os
ns tenham endereamento pblico.
A interface MPICH-G2 utiliza componentes do Globus que no so
WebServices, como o DUROC e o GRAM, porm tambm faz acesso a servios
web, como o MDS. A Figura 3.3 apresenta o ciclo de submisso e execuo de uma
aplicao MPI.
51
52
53
54
mais eficiente (MPI nativo). Cada implementao MPI utiliza seu prprio algoritmo de
difuso para propagar a mensagem dentro do cluster.
A interface MPICH-G2 no foi projetada para clusters com n front-end, alm
de garantir somente a interoperabilidade entre diferentes implementaes MPICH, e
no qualquer implementao MPI.
de
passagem
de
mensagens
para
grades
computacionais.
55
Caractersticas
ABACUS
SAGA
SATIN
MPICH-G2
Possui infraestrutura
Sim
Sim
Sim
Sim
Servios
Arquivos
Objetos
No possui
No
No
Sim
No
Mecanismo de
compartilhamento
Acesso a ns internos do
cluster
Linguagem de
programao
Tolerncia a falhas
C, C++,
Abacus
Java, Perl,
Java
C, C++ e
Fortran
etc
No
Sim
Sim
No
internos
dos
clusters,
sem
haver
necessidade
deles
possurem
56
57
58
59
4.1 Condor
Condor uma ferramenta, desenvolvida pelo Condor Team na Universidade
de Wisconsin-Madison, especializada em sistemas batch para gerenciamento de
jobs de computao intensiva [5]. O Condor prov um mecanismo de fila, uma
poltica de escalonamento com ou sem prioridades, e um esquema de classificao
de recursos.
Para a utilizao do Condor, o usurio submete seu job, o Condor o coloca
em uma fila, posteriormente o executa, e depois informa ao usurio o resultado final.
60
Executable
Universe
input
output
error
Log
=
=
=
=
=
=
exemplo_grid
standard
test.data
loop.out
loop.error
loop.log
Queue
Figura 4.3 Exemplo de arquivo de submisso
61
4.2 Globus
Globus [19] uma infraestrutura de software que permite as aplicaes
visualizarem recursos computacionais heterogneos e distribudos como um nico
n. Seu elemento central o Globus Toolkit (GT), o qual oferece servios
necessrios para a construo de uma grade computacional [20]. Esse toolkit um
conjunto de componentes organizados em camadas e orientados a servios,
oferecendo servios bsicos como descoberta e gerenciamento de recursos,
movimentao de dados, segurana, entre outros [18].
Todos os servios disponibilizados pelo Globus foram desenvolvidos em
linguagem de programao C, com seu cdigo fonte aberto, possibilitando que
colaboradores reparem erros ou faam qualquer tipo de implementao. Para o
usurio, estes servios acabam se tornando transparentes, pois uma vez instalados
e configurados, so chamados automaticamente com o uso de comandos
especficos do Globus.
A infraestrutura do Globus composta por cinco grupos de servios:
segurana, gerenciamento dos dados, gerenciamento da execuo, informao de
servios e compilao (momento da execuo).
Todos os servios existentes no Globus podem ser utilizados em uma grade
computacional. Mas, para a elaborao do sistema proposto neste trabalho, os
servios mais relevantes so: o gerenciamento da execuo e a informao de
servios. Pois, durante a execuo de uma aplicao, fundamental haver uma
ferramenta que realize o seu gerenciamento, e uma ferramenta que faa o
monitoramento dos servios da grade.
62
63
um
computador
que
instancia
um
mdulo
de
gerenciamento
chamados
de
CM
(Collector
Module)
DR
(Data
Repository),
64
O sistema est organizado em dois nveis: (i) rede hierrquica composta pelos
PRMMs e (ii) pool composto por um PRMM, vrios CMs e um DR. Esta organizao
em dois nveis facilita o gerenciamento da dinamicidade em uma grade
computacional, uma vez que o controle de entrada e sada dos recursos pode ser
tratado internamente em cada pool pelo PRMM.
O sistema GCSE um escalonador com uma estratgia cooperativa [54] de
alocao de recursos distribudos na grade. Ele permite que aplicaes paralelas
(SPMD) possam ser alocadas em diferentes recursos de uma grade, ou seja,
realizada a alocao em diversos aglomerados de computadores. Alm disso, o
GCSE oferece um conjunto de primitivas para serem integradas em ferramentas
para a construo de aplicaes paralelas SPMD, tais como interfaces MPI e
sistemas Java.
O suporte s informaes necessrias para o GCSE escolher os recursos
realizado pelo sistema LIMA. O uso deste sistema tem como finalidade oferecer
facilidade para monitorar os recursos distribudos.
65
Comunicao
ponto-a-ponto
(MPI_Recv,
MPI_Irecv,
MPI_Send,
Comunicao
coletiva
(MPI_Barrier,
MPI_Bcast,
MPI_Reduce,
MPI_Scatter e MPI_Gather);
Manipulao
do
buffer
(MPI_Pack,
MPI_Unpack,
MPI_Pack_size,
MPI_Buffer_attach e MPI_Buffer_detach);
Utilitrias
(MPI_Wtime,
MPI_Get_count,
MPI_Get_processor_name,
MPI_Get_elements e MPI_Probe).
66
Instante 3: o processo com rank 1 envia uma mensagem com o seu valor
encontrado para o processo com rank 0. O processo que recebe a
mensagem efetua a operao de reduo e armazena o valor. Neste
momento, o processo com rank 0 possui o valor correto, pois todos os
processos j enviaram o seu valor armazenado.
67
4.5.1 Funcionamento
O Servio de Mensagem resolve o problema de comunicao entre ns de
domnios distintos. Durante a fase inicial da execuo (startup dos processos), todos
os
processos
so
carregados
nos
ns
escolhidos
pelo
mecanismo
de
68
pode
aumentar
consideravelmente,
comprometendo
4.5.2 Arquitetura
A arquitetura do Servio de Mensagem [44] foi definida para suportar
conexes simultneas. Essa deciso foi tomada porque o mecanismo de
encaminhamento da mensagem realizado em 3 passos:
1. O Servio de Mensagem recebe um envelope de solicitao de mensagem
(que contm, entre outras informaes, o tipo de dado e a quantidade de
elementos que sero transmitidos).
2. criado dinamicamente um buffer de memria para receber a mensagem
do processo emissor.
3. O buffer , ento, encaminhado ao processo receptor ou a outro Servio
de Mensagem, dependendo da localizao do processo receptor.
69
70
A submisso ocorre atravs do GCSE, sendo que a partir deste ponto, tudo
realizado de maneira automtica. Ou seja, o ambiente escolhe os ns para a
execuo, faz o disparo, a execuo, o gerenciamento, e por fim, realiza a
finalizao da aplicao gerando os arquivos de sada, de log e de erro. A Figura 4.7
mostra um exemplo de submisso do arquivo app.gcse. O Gcse_submit um script
utilizado pelo GCSE para realizar a submisso de uma aplicao.
nilton@hepgrid00:/tmp/myGridSystems>gcse_submit app.gcse
Submitting job.
1 job submitted with Id: 1.
nilton@hepgrid00:/tmp/myGridSystems>
Figura 4.7 Submisso de um Arquivo
71
5. A LINGUAGEM CPAR
A linguagem CPAR [56] foi desenvolvida na livre docncia de Liria Matsumoto
Sato, e permite a programao de aplicaes paralelas para computadores com
vrios ncleos de processamento. Esta linguagem utilizada como referncia neste
trabalho e as construes e rotinas desenvolvidas neste trabalho esto baseadas na
CPAR.
A linguagem CPAR uma extenso paralela da linguagem C que utilizou
alguns elementos das linguagens Concurrent C e Ada, tal como um modelo de
programao de multitarefas. Ela foi projetada visando oferecer construes simples
para a explorao do paralelismo em mltiplos nveis, permitindo uma melhor
utilizao da localidade de memria. A linguagem CPAR oferece variveis
compartilhadas para o compartilhamento das informaes entre os processos. A
comunicao entre os diversos elementos de processamento ocorre atravs das
variveis compartilhadas.
Uma biblioteca de rotinas e um pr-compilador constituem o sistema de
programao para a linguagem CPAR que foi desenvolvida para computadores
multiprocessadores que possuam uma rea de memria compartilhada. A definio
da sua gramtica est no Apndice B, e a definio dos tokens da linguagem est
no Apndice A [1].
Este modelo de paralelismo oferece suporte para vrios nveis de paralelismo,
que vo desde a granularidade mais grossa at a mais fina. Os elementos
apresentados nas sees a seguir descrevem este modelo.
A Figura 5.1 mostra uma figura com os elementos de construo da
linguagem CPAR. Nesta figura, pode-se visualizar a independncia de cdigo entre
os macroblocos. Isso facilita a explorao da estrutura hierrquica das grades
computacionais, j que cada macrobloco pode ser executado em um domnio
distinto. As microtarefas so a parte paralela das macrotarefas, ou seja, elas so
utilizadas somente no escopo de uma macrotarefa, sendo o trecho de cdigo
paralelo da macrotarefa. Os blocos paralelos possibilitam a gerao de fluxos
paralelos, porm eles so executados no mesmo n.
72
73
cobegin
<comandos>
also
. . .
also
<comandos>
coend
Figura 5.3 Sintaxe do Bloco Paralelo
5.3 Macrotarefas
Uma macrotarefa apresenta uma granularidade de paralelismo no nvel de
sub-rotina. As macrotarefas so trechos de execuo paralelos, geralmente,
dependentes do escopo em que foi instanciada. Dentro de uma macrotarefa pode
haver comandos seqenciais, chamadas de microtarefas e declarao de variveis.
Caso haja a declarao de uma varivel compartilhada dentro de uma macrotarefa,
o seu escopo ser local a esta tarefa.
A chamada de uma macrotarefa pode ser feita dentro da funo principal de
um programa, em um bloco paralelo ou no corpo de um macrobloco. As Figuras
74
Figura 5.4 Sintaxe: Especificao (a), Corpo (b) e Chamada (c) de uma Macrotarefa
(extrado de [28])
5.4 Microtarefas
Uma microtarefa a granularidade mais fina de paralelismo da linguagem
CPAR. Este paralelismo pode ser homogneo, no qual instrues iguais so
executadas sobre dados distintos, ou pode ser heterogneo, no qual instrues
diferentes so executadas. Somente dentro das macrotarefas possvel criar uma
microtarefa, seja homognea ou heterognea. A microtarefa a parte paralela da
macrotarefa.
O paralelismo homogneo feito atravs do comando forall, no qual as
instrues pertencentes ao lao paralelo so executadas pelos processadores
presentes na macrotarefa. As iteraes deste lao so divididas de maneira
uniforme entre os processadores. A Figura 5.5 mostra a sintaxe do forall.
75
parbegin
<comandos>
also
. . .
also
<comandos>
parend
5.5 Macroblocos
Esta estrutura apresenta o nvel de paralelismo mais grosso dentro de um
programa. Os macroblocos so trechos de execuo, geralmente, independentes do
restante da aplicao. Dentro de um macrobloco pode haver outros macroblocos,
blocos paralelos, macrotarefas, comandos seqenciais e declaraes de variveis.
Um macrobloco pode ser referenciado somente no escopo da funo principal do
programa ou em outros macroblocos. A Figura 5.7 ilustra a sintaxe de um
macrobloco.
block <nome_bloco>
{
<declaracao_variaveis>
<comandos>
. . .
}
76
Semforos
lock(&<nome_sem>); // acesso
unlock(&<nome_sem>); // liberao
rem_sem(&<nome_sem>); // remoo
Figura 5.8 Sintaxe dos Comandos do Semforo (baseado em [28])
77
Eventos
Funes para
manipulao
Monitores
78
monitor <nome_monitor>
<declaracao_variaveis>
{
<funcao 1 do monitor>
. . .
<funcao N do monitor>
}
{
<inicializacao_variaveis>
}
Figura 5.10 Sintaxe de um Monitor
79
caractersticas
das
grades
computacionais,
abstraindo
do
usurio
as
80
Localizao dos ns: os ns, entre si, podem estar prximos ou distantes
geograficamente. A sua localidade deve ser considerada para escalonar
os elementos de execuo de uma aplicao, com o objetivo de minimizar
o tempo gasto com o trfego de mensagens.
81
82
ser balanceada para que o tempo de execuo no seja elevado devido a um n ter
mais carga para processar do que os demais.
O ambiente possui dois escalonadores, sendo eles:
83
84
85
O macrobloco 1 (m1 da Figura 6.2) foi atribudo ao domnio A, sendo que ele
possui quatro macrotarefas. A macrotarefa 1 (t1) foi atribuda ao cluster 1, a t2 foi
atribuda ao cluster 2, a t3 tem alguns processos no cluster 1 e alguns no cluster 2, e
a t4 foi atribuda ao cluster 1 e ao cluster 2.
O macrobloco 2 (m2 da Figura 6.2) foi atribudo ao domnio B, sendo que ele
possui seis macrotarefas. A t5 foi atribuda ao cluster 4, a t6 foi atribuda ao cluster
3, a t7 foi atribuda ao cluster 3, a t8 foi atribuda ao cluster 3 e ao servidor do
86
Macrotarefas
87
Microtarefas
Blocos paralelos
88
Se
este
for
multiprocessado,
os
fluxos
sero
executados
Macroblocos
Variveis compartilhadas
89
Mecanismo
de
escalonamento:
responsvel
por
realizar
90
Gerenciador
das
variveis
compartilhadas:
responsvel
pelo
91
92
93
6.4.3 Executor
O executor no n mestre iniciado pelo coordenador mestre, sendo
responsvel pelas seguintes atribuies:
94
6.4.4 Emissor
O emissor o responsvel pelo empacotamento e envio das mensagens para
os coordenadores dos outros ns. Este processo foi inserido no modelo de execuo
porque se o executor fizesse o empacotamento e envio, ele perderia tempo de
processamento e, alm disso, ficaria esperando pela confirmao da chegada da
mensagem no destinatrio. Neste perodo de tempo, o executor poderia continuar a
execuo de outras tarefas. Por este motivo, houve a necessidade da insero do
emissor no modelo.
Para a comunicao entre o emissor e o executor existe uma rea de
memria compartilhada. Nesta rea de memria, o executor armazena as
informaes referentes s atualizaes das variveis. O emissor retira as
informaes desta rea e faz o envio para os coordenadores dos ns que precisam
das informaes atualizadas.
95
96
6.4.7 Escalonador
Geralmente, as macrotarefas e os macroblocos so executados por ns
diferentes daqueles que os instanciaram. Desta forma, necessrio escolher os ns
em que eles sero executados, sendo que este escalonamento realizado pelo n
mestre. Caso a macrotarefa ou o macrobloco seja instanciado no escopo de outro
macrobloco, o coordenador local envia uma mensagem ao coordenador mestre,
solicitando o escalonamento.
O escalonador escolhe os ns para a execuo da macrotarefa ou do
macrobloco em questo e informa o coordenador mestre. Caso a macrotarefa ou o
macrobloco esteja no escopo do bloco principal, o coordenador mestre faz a sua
submisso aos ns selecionados. Caso contrrio, o coordenador mestre envia uma
mensagem ao coordenador local responsvel pelo gerenciamento do bloco,
informando os ns selecionados. Nesse caso, o coordenador local o responsvel
pela submisso da macrotarefa ou do macrobloco aos ns selecionados.
O escalonador precisa conhecer a configurao do ambiente e ter as
informaes atualizadas sobre a situao dos ns, pois o seu escalonamento tem
um impacto grande no desempenho do ambiente. Caso ele faa uma m escolha, o
desempenho da aplicao ficar comprometido. Por este motivo, o escalonador est
somente no n mestre. Se todos os ns pudessem realizar diretamente o
escalonamento, seria necessria uma troca grande de mensagens para todos
manterem as informaes atualizadas, impactando no desempenho da aplicao.
O tempo total de execuo de uma aplicao formado pelo tempo de
processamento e pelo tempo gasto em comunicao. A Equao 6.1 mostra a
frmula que calcula o tempo de execuo. Para a troca de mensagens, entre
processos no mesmo domnio, foi adotado o tempo de X segundos, e para a
comunicao entre processos de domnios distintos, de Y segundos.
Como X refere-se ao tempo para a comunicao entre dois processos no
mesmo domnio, e Y a dois processos em domnios distintos, o ideal que o nmero
multiplicado por X seja maior do que o nmero multiplicado por Y, j que, com
certeza, o valor de X menor do que Y. Portanto, para o impacto da comunicao
97
Onde:
modelo
de
programao
explora
as
caractersticas
das
grades
98
99
Tais
elementos
so
implementados
atravs
do
modelo
de
100
101
102
103
Figura 7.2 Primeiro fluxo para o controle do trmino de uma tarefa ou bloco
104
esta
informao,
executor
pode
retirar
outras
105
7.3 Buffer
No CPAR-Grid, buffers foram utilizados para evitar que ocorresse uma
sobrecarga no sistema com o envio de mensagens de atualizao. Pois, se a cada
atualizao de uma varivel compartilhada fosse enviada uma mensagem para os
demais ns, o tempo gasto com a atualizao das informaes seria muito grande.
Com a utilizao dos buffers, as atualizaes so enviadas somente quando
houver a necessidade de disponibilizar estes valores aos outros ns. Um
detalhamento sobre as atualizaes de variveis apresentado na seo 7.4. Cada
buffer uma rea de memria compartilhada entre o executor e o emissor de cada
n, e possui um papel importante para a atualizao das variveis no sistema.
Quando um executor atualiza uma varivel compartilhada do sistema, ele
escreve o valor na varivel mantida em memria local, e tambm armazena estas
informaes no buffer de armazenamento. No momento apropriado, o emissor
empacotar o buffer e o transmitir para todos os ns que j tiverem utilizado esta
106
107
108
109
110
111
112
113
114
domnio, sendo que ele ser o responsvel pelo encaminhamento das mensagens
entre os domnios.
115
116
117
118
119
120
121
122
Minimizao
das
mensagens
enviadas
para
gerenciamento
123
Escalonamento
comparao
da
de
macrotarefas
verso
completa
macroblocos:
com
verso
foi
realizada
somente
com
124
125
Figura 8.1 ilustra a estrutura deste algoritmo sinttico e o cdigo fonte CPAR deste
algoritmo est no Apndice C.1.
126
Verso sequencial
processamento
referncia,
pode-se
paralelo/distribudo.
calcular
ganho
Utilizando-se
de
esta
desempenho
verso
das
como
verses
paralelas/distribudas.
127
Figura 8.2 Estrutura do algoritmo das matrizes utilizando a verso com variveis
locais e a verso completa
Verso completa
128
globais. Desta forma, esta verso utiliza variveis compartilhadas globais, locais
macrotarefa e locais ao macrobloco. O objetivo desta verso analisar o
desempenho de uma aplicao paralela que possui variveis compartilhadas e o
impacto da atualizao das suas variveis, alm de analisar a utilizao de
macroblocos
para
realizar
diviso
do
processamento
entre
domnios
hierarquicamente.
Figura 8.3 Estrutura do algoritmo das matrizes utilizando a verso somente com
macrotarefas
129
130
Universidades
Tempo
Desvio
Origem
Destino
mdio (ms)
padro
USP
UNESP
2,29
0,10
UNESP
USP
2,29
0,10
USP
UFABC
2,08
0,24
UFABC
USP
2,08
0,24
UNESP
UFABC
6,18
0,93
UFABC
UNESP
6,18
0,93
131
132
133
134
Tabela 8.2 Detalhes das mensagens enviadas na verso com variveis locais
Origem
Coordenador
Mestre
Destino
Emissor
Coordenador
Coordenador
Mestre
Escravo
Coordenador
Coordenador
Mestre
Escravo
Coordenador
Coordenador
Mestre
Escravo
Coordenador
Escravo
Emissor
Coordenador
Coordenador
Escravo
Escravo
Coordenador
Coordenador
Escravo
Escravo
Coordenador
Coordenador
Escravo
Mestre
Coordenador
Coordenador
Escravo
Mestre
Coordenador
Coordenador
Escravo
Mestre
Emissor
Emissor
Coordenador
Escravo
Coordenador
Escravo
Motivo
Tarefa: 2
Tarefa: 4
Tarefa: 6
processado
processado
processado
res
res
res
Int
Ext
Int
Ext
Int
Ext
11
11
11
77
77
77
12
12
12
10
12
36
60
11
118
33
142
33
166
33
135
136
Tamanho
da matriz
Tempo
Sequencial
(seg)
Quatro
Seis
Tempo
Desvio
Tempo
Desvio
Tempo
Desvio
(seg)
Padro
(seg)
Padro
(seg)
Padro
1000x1000
33,623
4,795
0,101
2,713
0,048
2,251
0,073
1200x1200
57,859
8,232
0,163
4,138
0,098
3,131
0,176
1500x1500
124,015
17,723
0,111
8,773
0,136
6,467
0,175
2000x2000
325,483
45,685
0,267
23,284
0,065
17,537
0,189
137
que
simultaneamente,
efetuam
utilizando
multiplicao
oito
das
processadores.
matrizes
so
Posteriormente,
executadas
as
duas
138
Tamanho da
Matriz
Verso Completa
Internas
Externas
Internas
Externas
1000 x 1000
464
303
288
1062
1200x 1200
578
419
301
1504
1500 x 1500
794
635
340
2332
2000 x 2000
1262
1103
420
4126
139
140
Figura 8.8 Grfico com o tempo de execuo das verses somente com tarefas e
completa
141
pois a macrotarefa
executada
os
142
Tamanho
Tempo
da Matriz
Sequencial
Dois
Quatro
Seis
1000x1000
33,626
8,038
6,529
5,074
1200x1200
57,859
13,899
9,497
8,145
1500x1500
124,015
24,664
17,009
13,843
2000x2000
325,483
62,794
38,294
29,739
143
de
mensagens
tambm
aumenta,
impactando
no
tempo
de
144
145
9. CONCLUSO
Hoje em dia, a maioria das aplicaes paralelas so executadas em grades
computacionais atravs de workflows. H poucos ambientes que do suporte
execuo de aplicaes paralelas escritas atravs de uma linguagem de
programao que possua elementos de processamento paralelos. Isso ocorre
devido necessidade de uma infraestrutura que consiga realizar o escalonamento
dos ns, a submisso e o monitoramento da aplicao, alm de um modelo de
processamento que consiga explorar a estrutura hierrquica presente nas grades
computacionais.
O modelo de processamento, proposto neste trabalho, utilizou os elementos
de construo da linguagem paralela CPAR para explicitar os trechos de cdigo que
so executados de maneira paralela, sendo que estes elementos podem ser
executados hierarquicamente.
A linguagem CPAR utiliza variveis compartilhadas para a comunicao entre
processos no mesmo n. O modelo de execuo utiliza memria compartilhada
distribuda para o armazenamento das variveis compartilhadas na grade
computacional. Para manter a consistncia das variveis, o modelo de execuo
realiza a atualizao das variveis compartilhadas atravs de um mecanismo de
consistncia relaxada.
Para minimizar a quantidade de mensagens enviadas, quando ocorre a
atualizao de uma varivel compartilhada, a estratgia de atualizao faz com que
este n envie mensagens de atualizao da varivel somente para os ns que j a
utilizaram.
A execuo de uma aplicao paralela em um ambiente de grades
computacionais exige que o ambiente possua um escalonador de tarefas que
selecione os melhores ns para a sua execuo. O escalonador possui um impacto
muito grande no desempenho da aplicao, pois caso ele escolha ns ruins para a
execuo, a aplicao provavelmente enviar muitas mensagens de atualizao de
variveis entre ns distantes.
O escalonador desenvolvido neste trabalho procurou selecionar os ns para a
execuo das tarefas de acordo com a carga de processamento de cada n e com
146
9.1 Contribuies
No
desenvolvimento
deste
trabalho,
algumas
contribuies
foram
compartilhadas
possibilita
uma
alternativa
para
Desenvolvimento do ambiente CPAR-Grid que consiste de um prcompilador, de bibliotecas do sistema e da biblioteca MPI para grades
147
baseados
na
estrutura
hierrquica
das
grades
Implementao
de
estratgias
de
atualizao
das
variveis
Finalizao da construo do pr-compilador: atualmente, o prcompilador consegue gerar o cdigo da linguagem C dos seguintes
elementos de construo: macrotarefas, microtarefas, macroblocos e
blocos paralelos. Porm, a gerao do cdigo para as variveis
compartilhadas no est concluda, principalmente para a atualizao das
variveis compartilhadas. No momento, para a execuo, no CPAR-Grid,
de aplicaes desenvolvidas para testes na linguagem CPAR
necessrio incluir manualmente chamadas do CPAR-Grid na aplicao.
148
Testes com uma aplicao real: os testes realizados nesta tese foram
baseados em uma aplicao sinttica e em uma aplicao cientfica. No
foram realizados testes com aplicaes reais ou de mercado. A utilizao
de aplicaes deste nvel poderia demonstrar a eficincia do ambiente
CPAR-Grid.
149
Referncias
[1]
[2]
[3]
[4]
[5]
[6]
CONSORTIUM,
P.
C.
PC
cluster
consortium.
Disponvel
em
[8]
[9]
[10]
DAGMan.
Projeto
Condor
DAGMan.
Disponvel
em
150
[12]
[13]
[14]
computacionais.
paralelas,
em
Dissertao
sistemas
de
heterogneos
Mestrado.
Escola
de
grades
Politcnica
da
[16]
[17]
FOSTER,
I.
Globus
Primer.
Disponvel
em
<http://www.globus.org/toolkit/docs/4.0/key/GT4_Primer_0.6.pdf> . Acesso em
outubro, 2009.
[18]
[19]
[20]
scalable
virtual
organizations.
International
Journal
of
GEIST, A. et al. PVM: Parallel Virtual Machine. A Users Guide and Tutorial
for Networked Parallel Computing. The MIT Press. 1994.
[22]
GGF.
Data
Replication
Research
Group.
2004.
Disponvel
em
151
[23]
[24]
GGF. Grid Checkpoint Recovery Working Group. 2003. Global Grid Forum.
Disponvel em <http://forge.gridforum.org/projects/gridcpr-wg/>. Acesso em
maro, 2010.
[25]
GGF. Grid File Systems Working Group. 2004. Global Grid Forum.
Disponvel
em
<http://forge.gridforum.org/projects/gfs-wg/>.
Acesso
em
maro, 2010.
[26]
[27]
[28]
[29]
[30]
[31]
GRAM.
GRAM
Globus
Toolkit.
Disponvel
em
[33]
IGUMA,
D.
Aspectos
de
implementao
de
um
ambiente
para
152
INTELLIGENCE,
E.
CxC
Engineered
Intelligence.
Disponvel
em
[36]
[37]
[38]
[39]
[40]
[41]
LI, W. et al. A Service Management Scheme for Grid Systems. The Second
International Workshop on Grid and Cooperative Computing. Springer-Verlag.
Berlin. 2003. p. 541-548.
[42]
LI, W., XU, Z. Model of grid address space with applications. Journal of
Computer Research and Development. Science Press. Beijing, 2003, p. 17561770.
[43]
153
[44]
[45]
[46]
MDS.
MDS
Globus
Toolkit.
Disponvel
em
[48]
[49]
Vrije
Universiteit
Amsterdam.
Disponvel
em
<http://www.cs.vu.nl/~rob/>. 2003.
[50]
[51]
[52]
Estados Unidos.
2007.
[53]
[54]
cooperativo
de
aplicaes
paralelas
em
grades
154
[55]
[56]
[57]
[58]
[59]
[60]
[61]
[62]
[63]
[64]
[65]
155
[66]
[67]
[68]
156
[0-9]
[a-zA-Z_]
[a-fA-F0-9]
[Ee][+-]?{D}+
FS
(f|F|l|L)
IS
(u|U|l|L)*
%{
#include <stdio.h>
#include <stdlib.h>
#include "grammar.tab.h"
void count();
%}
%%
"/*"
{ comment(); }
"#include"
{ count(); return(INCLUDE); }
"#define"
{ count(); return(DEFINE); }
"auto"
{ count(); return(AUTO); }
"body"
{ count(); return(BODY); }
"break"
{ count(); return(BREAK); }
"case"
{ count(); return(CASE); }
"char"
{ count(); return(CHAR); }
"const"
{ count(); return(CONST); }
"continue"
{ count(); return(CONTINUE); }
157
"default"
{ count(); return(DEFAULT); }
"do"
{ count(); return(DO); }
"double"
{ count(); return(DOUBLE); }
"else"
{ count(); return(ELSE); }
"enum"
{ count(); return(ENUM); }
"extern"
{ count(); return(EXTERN); }
"float"
{ count(); return(FLOAT); }
"for"
{ count(); return(FOR); }
"goto"
{ count(); return(GOTO); }
"if"
{ count(); return(IF); }
"int"
{ count(); return(INT); }
"long"
{ count(); return(LONG); }
"register"
{ count(); return(REGISTER); }
"return"
{ count(); return(RETURN); }
"short"
{ count(); return(SHORT); }
"signed"
{ count(); return(SIGNED); }
"sizeof"
{ count(); return(SIZEOF); }
"static"
{ count(); return(STATIC); }
"struct"
{ count(); return(STRUCT); }
"switch"
{ count(); return(SWITCH); }
"typedef"
{ count(); return(TYPEDEF); }
"union"
{ count(); return(UNION); }
"unsigned"
{ count(); return(UNSIGNED); }
"void"
{ count(); return(VOID); }
"volatile"
{ count(); return(VOLATILE); }
"while"
{ count(); return(WHILE); }
"also"
{ count(); return(ALSO);}
"block"
{ count(); return(BLOCK);}
"cobegin"
{ count(); return(COBEGIN);}
"coend"
{ count(); return(COEND);}
"create"
{ count(); return(CREATE);}
"create_sem"
{ count(); return(CREATE_SEM); }
"end"
{ count(); return(END); }
"event"
{ count(); return(EVENT);}
158
"forall"
{ count(); return(FORALL);}
"lock"
{ count(); return(LOCK); }
"monitor"
{ count(); return(MONITOR);}
"par"
{ count(); return(PAR);}
"parbegin"
{ count(); return(PARBEGIN);}
"parend"
{ count(); return(PAREND);}
"remove_sem"
{ count(); return(REMOVE_SEM); }
"sch"
{ count(); return(SCH); }
"semaph"
{ count(); return(SEMAPH);}
"shared"
{ count(); return(SHARED);}
"spar"
{ count(); return(SPAR);}
"spec"
{ count(); return(SPEC);}
"task"
{ count(); return(TASK);}
"task_shared"
{ count(); return(TASK_SHARED);}
"to"
{ count(); return(TO);}
"unlock"
{ count(); return(UNLOCK);}
"var"
{ count(); return(VAR);}
"wait_all"
{ count(); return(WAIT_ALL);}
"wait_task"
{ count(); return(WAIT_TASK);}
"when"
{ count(); return(WHEN);}
{L}({L}|{D})*
0[xX]{H}+{IS}?
0{D}+{IS}?
{D}+{IS}?
L?'(\\.|[^\\'])+'
{D}+{E}{FS}?
{D}*"."{D}+({E})?{FS}?
{D}+"."{D}*({E})?{FS}?
L?\"(\\.|[^\\"])*\"
"..."
">>="
{ count(); return(RIGHT_ASSIGN); }
"<<="
{ count(); return(LEFT_ASSIGN); }
159
"+="
{ count(); return(ADD_ASSIGN); }
"-="
{ count(); return(SUB_ASSIGN); }
"*="
{ count(); return(MUL_ASSIGN); }
"/="
{ count(); return(DIV_ASSIGN); }
"%="
{ count(); return(MOD_ASSIGN); }
"&="
{ count(); return(AND_ASSIGN); }
"^="
{ count(); return(XOR_ASSIGN); }
"|="
{ count(); return(OR_ASSIGN); }
">>"
{ count(); return(RIGHT_OP); }
"<<"
{ count(); return(LEFT_OP); }
"++"
{ count(); return(INC_OP); }
"--"
{ count(); return(DEC_OP); }
"->"
{ count(); return(PTR_OP); }
"&&"
{ count(); return(AND_OP); }
"||"
{ count(); return(OR_OP); }
"<="
{ count(); return(LE_OP); }
">="
{ count(); return(GE_OP); }
"=="
{ count(); return(EQ_OP); }
"!="
{ count(); return(NE_OP); }
";"
{ count(); return(';'); }
("{"|"<%")
{ count(); return('{'); }
("}"|"%>")
{ count(); return('}'); }
","
{ count(); return(','); }
":"
{ count(); return(':'); }
"="
{ count(); return('='); }
"("
{ count(); return('('); }
")"
{ count(); return(')'); }
("["|"<:")
{ count(); return('['); }
("]"|":>")
{ count(); return(']'); }
"."
{ count(); return('.'); }
"&"
{ count(); return('&'); }
"!"
{ count(); return('!'); }
"~"
{ count(); return('~'); }
"-"
{ count(); return('-'); }
160
"+"
{ count(); return('+'); }
"*"
{ count(); return('*'); }
"/"
{ count(); return('/'); }
"%"
{ count(); return('%'); }
"<"
{ count(); return('<'); }
">"
{ count(); return('>'); }
"^"
{ count(); return('^'); }
"|"
{ count(); return('|'); }
"?"
{ count(); return('?'); }
[ \t\v\n\f]
%%
yywrap()
{
return(1);
}
comment()
{
char c, c1;
loop:
c = input();
while (c != '*')
{
if(c == '\n')
{
linhas++;
}
c = input();
}
161
int column = 0;
int linha = 1;
void count()
{
int i;
int check_type()
{
return(IDENTIFIER);
}
162
AND_OP
OR_OP
MUL_ASSIGN
DIV_ASSIGN
MOD_ASSIGN
ADD_ASSIGN
%token SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN
%token XOR_ASSIGN OR_ASSIGN TYPE_NAME
%token TYPEDEF EXTERN STATIC AUTO REGISTER
%token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST
VOLATILE VOID VAR END
%token STRUCT UNION ENUM ELLIPSIS INCLUDE DEFINE
%token CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE
BREAK RETURN
%start start_program
%%
primary_expression
: IDENTIFIER
| CONSTANT
| STRING_LITERAL
| '(' expression ')'
163
postfix_expression
: primary_expression
| postfix_expression '[' expression ']'
| postfix_expression '(' ')'
| postfix_expression '(' argument_expression_list ')'
| postfix_expression '.' IDENTIFIER
| postfix_expression PTR_OP IDENTIFIER
| postfix_expression INC_OP
| postfix_expression DEC_OP
;
argument_expression_list
: assignment_expression
| argument_expression_list ',' assignment_expression
;
unary_expression
: postfix_expression
| INC_OP unary_expression
| DEC_OP unary_expression
| unary_operator cast_expression
| SIZEOF sufixo_sizeof
;
sufixo_sizeof
: unary_expression
| '(' type_name ')'
;
unary_operator
: '&'
| '*'
164
| '+'
| '-'
| '~'
| '!'
;
cast_expression
: unary_expression
| '(' type_name ')' cast_expression
;
multiplicative_expression
: cast_expression
| multiplicative_expression '*' cast_expression
| multiplicative_expression '/' cast_expression
| multiplicative_expression '%' cast_expression
;
additive_expression
: multiplicative_expression
| additive_expression '+' multiplicative_expression
| additive_expression '-' multiplicative_expression
;
shift_expression
: additive_expression
| shift_expression LEFT_OP additive_expression
| shift_expression RIGHT_OP additive_expression
;
relational_expression
: shift_expression
| relational_expression '<' shift_expression
| relational_expression '>' shift_expression
165
equality_expression
: relational_expression
| equality_expression EQ_OP relational_expression
| equality_expression NE_OP relational_expression
;
and_expression
: equality_expression
| and_expression '&' equality_expression
;
exclusive_or_expression
: and_expression
| exclusive_or_expression '^' and_expression
;
inclusive_or_expression
: exclusive_or_expression
| inclusive_or_expression '|' exclusive_or_expression
;
logical_and_expression
: inclusive_or_expression
| logical_and_expression AND_OP inclusive_or_expression
;
logical_or_expression
: logical_and_expression
| logical_or_expression OR_OP logical_and_expression
;
166
conditional_expression
: logical_or_expression
| logical_or_expression '?' expression ':' conditional_expression
;
assignment_expression
: conditional_expression
| unary_expression assignment_operator assignment_expression
;
assignment_operator
: '='
| MUL_ASSIGN
| DIV_ASSIGN
| MOD_ASSIGN
| ADD_ASSIGN
| SUB_ASSIGN
| LEFT_ASSIGN
| RIGHT_ASSIGN
| AND_ASSIGN
| XOR_ASSIGN
| OR_ASSIGN
;
expression
: assignment_expression
| expression ',' assignment_expression
;
constant_expression
: conditional_expression
;
167
declaration
: declaration_specifiers ';'
| declaration_specifiers init_declarator_list ';'
| IDENTIFIER init_declarator_list ';'
| SHARED specifier_tipo_shared declarator_shared_var ';'
| DEFINE IDENTIFIER CONSTANT
| TASK SPEC IDENTIFIER '(' ')'';'
| SEMAPH declarator_semaph ';'
;
declaration_specifiers
: storage_class_specifier
| storage_class_specifier declaration_specifiers
| type_specifier
| type_specifier declaration_specifiers
| type_qualifier
| type_qualifier declaration_specifiers
;
specifier_tipo_shared
: CHAR
| SHORT
| INT
| LONG
| FLOAT
| DOUBLE
| SIGNED
| UNSIGNED
;
declarator_shared_var
: IDENTIFIER
| declarator_shared_var '[' CONSTANT ']'
| declarator_shared_var ',' declarator_shared_var
168
declarator_semaph
: IDENTIFIER
| declarator_semaph '['CONSTANT']'
| declarator_semaph ',' declarator_semaph
;
init_declarator_list
: init_declarator
| init_declarator_list ',' init_declarator
;
init_declarator
: declarator
| declarator '=' initializer
;
storage_class_specifier
: TYPEDEF
| EXTERN
| STATIC
| AUTO
| REGISTER
;
type_specifier
: VOID
| CHAR
| SHORT
| INT
| LONG
| FLOAT
| DOUBLE
169
| SIGNED
| UNSIGNED
| struct_or_union_specifier
| enum_specifier
| TYPE_NAME
;
struct_or_union_specifier
: struct_or_union IDENTIFIER '{' struct_declaration_list '}'
| struct_or_union '{' struct_declaration_list '}'
| struct_or_union IDENTIFIER
;
struct_or_union
: STRUCT
| UNION
;
struct_declaration_list
: struct_declaration
| struct_declaration_list struct_declaration
;
struct_declaration
: specifier_qualifier_list struct_declarator_list ';'
;
specifier_qualifier_list
: type_specifier specifier_qualifier_list
| type_specifier
| type_qualifier specifier_qualifier_list
| type_qualifier
;
170
struct_declarator_list
: struct_declarator
| struct_declarator_list ',' struct_declarator
;
struct_declarator
: declarator
| ':' constant_expression
| declarator ':' constant_expression
;
enum_specifier
: ENUM '{' enumerator_list '}'
| ENUM IDENTIFIER '{' enumerator_list '}'
| ENUM IDENTIFIER
;
enumerator_list
: enumerator
| enumerator_list ',' enumerator
;
enumerator
: IDENTIFIER
| IDENTIFIER '=' constant_expression
;
type_qualifier
: CONST
| VOLATILE
;
declarator
: pointer direct_declarator
171
| direct_declarator
;
direct_declarator
: IDENTIFIER
| '(' declarator ')'
| direct_declarator '[' constant_expression ']'
| direct_declarator '[' ']'
| direct_declarator '(' parameter_type_list ')'
| direct_declarator '(' identifier_list ')'
| direct_declarator '(' ')'
;
pointer
: '*'
| '*' sufixo_pointer
;
sufixo_pointer
: type_qualifier_list
| pointer
| type_qualifier_list pointer
;
type_qualifier_list
: type_qualifier
| type_qualifier_list type_qualifier
;
parameter_type_list
: parameter_list
| parameter_list ',' ELLIPSIS
;
172
parameter_list
: parameter_declaration
| parameter_list ',' parameter_declaration
;
parameter_declaration
: declaration_specifiers declarator
| declaration_specifiers abstract_declarator
| declaration_specifiers
;
task_parameters
: '(' ')'
| '(' identifier_list ')' task_declaration
;
task_declaration
: type_specifier IDENTIFIER ';'
| task_declaration type_specifier IDENTIFIER ';'
;
identifier_list
: IDENTIFIER
| identifier_list ',' IDENTIFIER
;
type_name
: specifier_qualifier_list
| specifier_qualifier_list abstract_declarator
;
abstract_declarator
: pointer
| direct_abstract_declarator
173
| pointer direct_abstract_declarator
;
direct_abstract_declarator
: '(' abstract_declarator ')'
| '[' ']'
| '[' constant_expression ']'
| direct_abstract_declarator '[' ']'
| direct_abstract_declarator '[' constant_expression ']'
| '(' ')'
| '(' parameter_type_list ')'
| direct_abstract_declarator '(' ')'
| direct_abstract_declarator '(' parameter_type_list ')'
;
initializer
: assignment_expression
| '{' initializer_list sufixo_initializer
;
sufixo_initializer
: '}'
| ',' '}'
;
initializer_list
: initializer
| initializer_list ',' initializer
;
cob_statement
: statement_list
| cob_statement ALSO statement_list
;
174
statement
: labeled_statement
| compound_statement
| expression_statement
| selection_statement
| iteration_statement
| jump_statement
| DEFINE IDENTIFIER CONSTANT
| CREATE CONSTANT ',' IDENTIFIER '(' ')' ';'
| COBEGIN cob_statement COEND
| CREATE_SEM '(' IDENTIFIER ',' CONSTANT ')' ';'
| REMOVE_SEM '(' IDENTIFIER ')' ';'
| LOCK '(' IDENTIFIER ')' ';'
| UNLOCK '(' IDENTIFIER ')'
| IDENTIFIER ';'
;
labeled_statement
: IDENTIFIER ':' statement
| CASE constant_expression ':' statement
| DEFAULT ':' statement
;
par_statement
: statement_list
| par_statement ALSO statement_list
;
sufixo_compound_statement
: '}'
| statement_list '}'
;
sufixo_forall
175
declaration_list
: declaration
| declaration_list declaration
;
statement_list
: statement
| statement_list statement
;
expression_statement
: ';'
| expression ';'
;
selection_statement
: IF '(' expression ')' sufixo_if
| SWITCH '(' expression ')' statement
;
sufixo_if
: statement
TO
primary_expression
176
iteration_statement
: WHILE '(' expression ')' statement
| DO statement WHILE '(' expression ')' ';'
| FOR '(' expression_statement expression_statement sufixo_for
;
sufixo_for
: ')' statement
| expression ')' statement
;
jump_statement
: GOTO IDENTIFIER ';'
| CONTINUE ';'
| BREAK ';'
| RETURN ';'
| RETURN expression ';'
;
start_program
: declaration_include translation_unit
| translation_unit
;
declaration_include
: declaration_include INCLUDE '<' IDENTIFIER '.' IDENTIFIER '>'
| INCLUDE '<' IDENTIFIER '.' IDENTIFIER '>'
;
translation_unit
: declaration_include external_declaration
177
| translation_unit external_declaration
;
external_declaration
: function_definition
| declaration
;
function_definition
: declaration_specifiers declarator declaration_list compound_statement
| declaration_specifiers declarator compound_statement
| declarator declaration_list compound_statement
| declarator compound_statement
| TASK BODY IDENTIFIER task_parameters compound_statement
| BLOCK IDENTIFIER compound_statement
;
178
179
block macrobloco1() {
printf("Antes da criao do Macrobloco 3!\n");
fflush(stdout);
block macrobloco3;
printf("Macrobloco 3 foi criado!\n");
fflush(stdout);
WaitBlock(macrobloco3);
} // fim do macrobloco 1
block macrobloco2() {
shared double X[SIZE][SIZE];
printf("Antes da criao da macrotarefa 2!\n");
fflush(stdout);
create 4, macrotarefa2();
printf("Macrotarefa 2 foi criada!\n");
fflush(stdout);
WaitTask(macrotarefa2); // espera o fim da task macrotarefa2
} // fim do macrobloco 2
block macrobloco3() {
printf("Antes da criao da macrotarefa 1!\n");
fflush(stdout);
create 4, macrotarefa1();
printf("Macrotarefa 1 foi criada!\n");
fflush(stdout);
WaitTask(macrotarefa1); // espera o fim da task macrotarefa1
} // fim do macrobloco 3
/* Bloco Principal*/
void main()
{
int i, j;
double media[SIZE][SIZE], media1[SIZE][SIZE],
media2[SIZE][SIZE];
cobegin
block macrobloco1;
WaitBlock(macrobloco1);
also
180
block macrobloco2;
WaitBlock(macrobloco2);
also
create 6, macrotarefa3();
WaitTask(macrotarefa3); // espera o fim da task macrotarefa3
coend
for(i=0; i<SIZE; i++){
for(j=0; j<SIZE; j++){
printf("Z[%d][%d] = %f\n",i, j, Z[i][j]);
printf("W[%d][%d] = %f\n",i, j, W[i][j]);
fflush(stdout);
}
}
}
181
}
}/*end multAB*/
182
183
}/*end mediaXY*/
}/*end mediaZW*/
create 6, multAB();
create 6, multCD();
} // fim do macrobloco 1
184
block macrobloco2() {
int i, j;
double soma_local;
create 6, multEF();
create 6, multGH();
} // fim do macrobloco 2
/* Bloco Principal*/
void main()
{
int i, j;
double
media[SIZE][SIZE],
media1[SIZE][SIZE],
media2[SIZE][SIZE];
block macrobloco1;
block macrobloco2;
WaitBlock(macrobloco1);
WaitBlock(macrobloco2);
185
shared
double
media[SIZE][SIZE],
media1[SIZE][SIZE],
media2[SIZE][SIZE];
186
187
}
}/*end multEF*/
}/*end mediaXY*/
188
}/*end mediaZW*/
create 6, multAB();
create 6, multCD();
} // fim do macrobloco 1
create 6, multEF();
create 6, multGH();
189
} // fim do macrobloco 2
/* Bloco Principal*/
void main()
{
int i, j;
double
media[SIZE][SIZE],
media1[SIZE][SIZE],
media2[SIZE][SIZE];
block macrobloco1;
block macrobloco2;
WaitBlock(macrobloco1);
WaitBlock(macrobloco2);
shared
double
X[SIZE][SIZE],
Y[SIZE][SIZE],
Z[SIZE][SIZE],
W[SIZE][SIZE];
shared
double
media2[SIZE][SIZE];
media[SIZE][SIZE],
media1[SIZE][SIZE],
190
191
192
}/*end mediaXY*/
193
}//end forall
}/*end mediaZW*/
/* Bloco Principal*/
void main()
{
int i, j;
create 6, multAB();
create 6, multCD();
create 6, multEF();
create 6, multGH();