LUIZ ARTHUR FEITOSA DOS SANTOS

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares

MARING 2005

LUIZ ARTHUR FEITOSA DOS SANTOS

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares

Dissertao apresentada ao Programa de Ps-Graduao em Cincia da Computao da Universidade Estadual de Maring, como requisito parcial para obteno do grau de Mestre em Cincia da Computao. Orientador: Prof. Dr. Joo Angelo Martini

MARING 2005

LUIZ ARTHUR FEITOSA DOS SANTOS

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares

Dissertao apresentada ao Programa de Ps-Graduao em Cincia da Computao da Universidade Estadual de Maring, como requisito parcial para obteno do grau de Mestre em Cincia da Computao.

Aprovado em

BANCA EXAMINADORA

Prof. Dr. Joo Angelo Martini Universidade Estadual de Maring UEM

Prof. Dr. Ronaldo A. L. Gonalves Universidade Estadual de Maring UEM

Profa. Dr. Roberta Spolon Ulson Departamento de Computao UNESP

DEDICATRIA

Dedico este trabalho

Aos meus pais, a minha namorada, aos meus amigos e principalmente a Deus.

AGRADECIMENTOS

Agradeo inicialmente aos meus pais Wanderley Feitosa dos Santos e Enezita M. Verderio dos Santos, que me deram todo o apoio necessrio para concluso de mais esta etapa da minha vida, e principalmente porque so fontes inesgotveis de inspirao para mim. Agradeo ao meu orientador Joo Angelo Martini, pelos conselhos profissionais, amizade e pelo conhecimento compartilhado. Agradeo minha amada namorada Keula Massuda, por todo apoio que est me deu nos momentos fcies e principalmente nos difceis, demonstrando todo seu carinho e considerao. Agradeo aos meus amigos Ricardo Alexandre Lavarias, Edson Jose Tomiazzi Kitio, Igor Wiese, Rogrio Pozza, Andr Pozza, Edson Alves de Oliveira Junior, Aysllan Possebom, Jeber Gonzaga e Leila Massuda, pela amizade e contribuies. Agradeo a todos os professores que compartilharam conhecimento e me ajudaram a concluir este trabalho, dentre eles: Ronaldo A. L. Gonalves, Elisa Hatsue M. Huzita, Itana M. S. Gimenes, Ademir Aparecido Constantino, Munif Gebara Junior, Claudete Werner, Daniela Flor, Yandre Maldonato e Roni Fancis Shigueta. Agradeo ao Departamento de Informtica, principalmente Maria Ins Davano, por toda ateno, respeito, pacincia e amizade.

Penso noventa e nove vezes e nada descubro deixo de pensar, mergulho em profundo silncio e eis que a verdade se revela. Albert Einstein

RESUMO

A necessidade de resolver problemas intensivamente computacionais vem exigindo arquiteturas computacionais com desempenhos cada vez mais elevados. Para atender essa demanda, esforos de pesquisa tm sido desenvolvidos na rea de arquiteturas paralelas. Para se obter resultados satisfatrios com arquiteturas paralelas so necessrios estudos meticulosos de hardware e software. Uma alternativa de apoio a pesquisas em arquiteturas paralelas o uso de simuladores. Neste contexto, diversos grupos de pesquisa tm desenvolvido simuladores de arquiteturas paralelas. O grupo de pesquisa em Arquiteturas de Alto Desempenho da Universidade Estadual de Maring desenvolveu uma ferramenta de simulao denominada Simulador de Multiprocessadores Superescalares. Entretanto somente essa ferramenta de simulao no permite investigar arquiteturas, necessrio tambm o uso de algoritmos desenvolvidos especificamente para este simulador. Assim, este trabalho tem por objetivo o desenvolvimento de algoritmos paralelos a serem utilizados em conjunto com o Simulador de Multiprocessadores Superescalares, fornecendo assim meios de simular e avaliar uma arquitetura paralela. Tais algoritmos visam testar e explorar os diversos aspectos de uma arquitetura paralela. Viabilizando o estudo de arquiteturas paralelas em uma variedade de configuraes de arquiteturas fornecidas pelo simulador, possibilitando tambm que a ferramenta seja usada como apoio ao ensino de arquiteturas paralelas. Aps o desenvolvimento dos algoritmos para simulao no SMS, ficou constatado que os algoritmos em conjunto com a ferramenta de simulao proporcionam um ambiente ideal para o estudo e experimentao de arquiteturas paralelas.

Palavras-chave:Arquitetura de Computadores. Computao Paralela. Simulao. Algoritmos.

ABSTRACT

The need for solving problems intensively related to computers has been demanding computer architectures more and more developed. To attend this demand research efforts have been developing the parallel architecture area. To obtain better results with them, its necessary some, searches on meticulous. hardware and software An alternative to support those search on parallel architectures is the use of simulators. On this context, some research groups have been developing parallel architectures simulators. The high development architectures from Universidade Estadual de Maring developed a simulator tool called Superscalar Multiprocessors Simulator. However only this simulator tool isnt able to investigate architectures, its also necessary the use of algorithms specifically develop for that simulator. This way, this paper has main goal the development of parallel algorithms to be used along with the Superscalar Multiprocessor Simulator offering conditions to simulate and evaluate a parallel architecture. Those algorithms aim to test and explore the diverse aspects of a parallel architecture. Making the study of parallel architectures possible in a variety of architecture configuration given by the simulator, also making possible that the tool be used as a support to the parallel architecture teaching. After the development of those algorithms for simulation on the SMS, it was proved that the algorithms along with the simulation tool permit an ideal environment for the parallel architectures study and experiment.

Keywords: Computer Architectures. Parallel Computation. Simulation. Algorithms.

LISTA DE ILUSTRAES

Figura 1 - Mquina de von Neumann...........................................................................................18 Figura 2 - (a) Memria compartilhada (b) Memria distribuda..................................................23 Figura 3 - Arquitetura do simulador SMS....................................................................................33 Figura 4 - Inicializando a biblioteca de comunicao do SMS ....................................................36 Figura 5 - Usando funes da biblioteca SMS .............................................................................38 Figura 6 - Caractersticas dos Speedups de tamanho fixo e tempo fixo.......................................59 Figura 7 - Speedup Absoluto ........................................................................................................60 Figura 8 - Speedup Relativo .........................................................................................................60 Figura 9 - Eficincia .....................................................................................................................62 Figura 10 - Matriz.........................................................................................................................64 Figura 11 - Algoritmo seqencial para multiplicao de matrizes...............................................65 Figura 12 - Diviso da Matriz em Vetores no Programa Mestre .................................................65 Figura 13 - Multiplicao dos Vetores pelas Colunas da Matriz B nos Processadores Escravos.............................................................................................................................66 Figura 14 - O programa mestre reagrupa os vetores resultantes dos processos escravos ............66 Figura 15 - Algoritmo paralelo de multiplicao de matrizes......................................................68 Figura 16 - Sada reduzida de uma simulao no SMS................................................................69 Figura 17 - Tempo de execuo do algoritmo de multiplicao de matrizes...............................70 Figura 18 - Speedup apresentado pelo algoritmo paralelo de multiplicao de matrizes ............70 Figura 19 - Eficincia apresentada pelo algoritmo paralelo de multiplicao de matrizes ..........71 Figura 20 - Frmula para calcular o valor de ...........................................................................73 Figura 21 - Programa escravo do clculo do ...........................................................................74

Figura 22 - Speedup do algoritmo paralelo do clculo do .......................................................75 Figura 23 - Tempo de execuo do algoritmo do clculo do ...................................................76 Figura 24 - Eficincia apresentada pelo algoritmo do clculo do ............................................76 Figura 25 - Definio de integral de uma funo no negativa....................................................77 Figura 26 - Usando integral para definir trapzio ........................................................................78 Figura 27 - Trapzio .....................................................................................................................78 Figura 28 - Cdigo do algoritmo Trapezoidal rule com MPI.......................................................79 Figura 29 - Cdigo do algoritmo Trapezoidal rule com SMS......................................................81 Figura 30 - Tempo total de execuo do Trapezoidal rule ..........................................................83 Figura 31 - Speedup Trapezoidal rule ..........................................................................................84 Figura 32 - Eficincia do algoritmo Trapezoidal rule frente a arquitetura ..................................84 Figura 33 - Algoritmo de Round-Trip ..........................................................................................86 Figura 34 - Algoritmo Bubble Sort ..............................................................................................88 Figura 35 - Algoritmo de ordenao Odd-Even ...........................................................................89 Figura 36 - Processo de ordenao utilizando algoritmo Odd-even.............................................90 Figura 37 - Ordenao por Odd-Even utilizada no SMS .............................................................91 Figura 38 - Tempo total de execuo do Odd-Even sort..............................................................92 Figura 39 - Speedup do Odd-Even sort ........................................................................................93 Figura 40 - Eficincia do Odd-even sort ......................................................................................93 Figura 41 - Uso da rede de interconexo do algoritmo Odd-Even sort........................................94 Figura 42 - Uso da rede de interconexo do algoritmo de clculo do .......................................94 Figura 43 - Linha de comando para executar o programa de clculo do com cache de dados de tamanho de 4096...........................................................................................................96 Figura 44 - Speedup do com alterao de cache de dados ........................................................97 Figura 45 - Eficincia do com alterao de cache de dados......................................................98

Figura 46 - Linha de comando que dispara o simulador SMS com alteraes no previsor de desvio.................................................................................................................................98 Figura 47 - Speedup e eficincia do algoritmo Trapezoidal rule com previsor de desvio alterado ..............................................................................................................................99 Figura 48 - Elapsed Time do algoritmo Odd-Even com duas redes de interconexo.................100

LISTA DE TABELAS

Tabela 1 - Simuladores do SimpleScalar......................................................................................27 Tabela 2 - Primitivas SMS para passagem de mensagem ............................................................32 Tabela 3 - Taxa de transferncia da rede de interconexo em bytes por segundo........................87

SUMRIO

1 2 2.1 2.2 2.3 2.4 2.4.1 2.4.2 3 3.1 3.2 3.3 3.4 3.5 4 4.1 4.2 5 5.1 5.2 5.3 5.4

INTRODUO .......................................................................................................... ....15 COMPUTAO PARALELA .......................................................................................17 Processamento Seqencial ..............................................................................................17 Classificao de Flynn .....................................................................................................19 Processamento Paralelo ..................................................................................................21 Arquiteturas Paralelas com Memria Compartilhada e Distribuda .........................22 Multiprocessadores com Memria Compartilhada............................................................22 Multiprocessadores com Memria Distribuda .................................................................23 SIMULADOR DE ARQUITETURAS ..........................................................................25 SimpleScalar ....................................................................................................................25 Simulador de Ambientes Paralelos ................................................................................27 Algoritmos para testes e avaliao de desempenho ......................................................29 Simulador de Multiprocessadores Superescalares - SMS ...........................................31 Biblioteca de Passagem de Mensagem do SMS ............................................................35 PROGRAMAO PARALELA E ALGORITMOS PARALELOS .........................39 Aplicaes Paralelas ........................................................................................................41 Passagem de Mensagens..................................................................................................52 AVALIAO DE DESEMPENHO ..............................................................................54 Alguns aspectos quanto a medidas de desempenho......................................................55 Tempo de execuo..........................................................................................................57 Speedup. ...........................................................................................................................57 Eficincia. .........................................................................................................................61

6 6.1 6.2 6.3 6.4 6.5 6.6 7 8

ALGORITMOS PARALELOS PARA O SMS ............................................................63 Algoritmo Paralelo de Multiplicao de Matrizes ........................................................63 Algoritmo Paralelo para Clculo do ..........................................................................72 Algoritmo Trapezoidal Rule ...........................................................................................76 Algoritmo para testes da Rede de Interconexo do Simulador SMS..........................84 Algoritmo de ordenao Odd-Even ...............................................................................87 Simulao de Outras Arquiteturas com o SMS e os Algoritmos ................................94 CONCLUSO................................................................................................................101 TRABALHOS FUTUROS ............................................................................................103 REFERNCIAS ............................................................................................................104 ANEXO A .......................................................................................................................108

15

INTRODUO

A motivao principal para investigao, desenvolvimento e utilizao de arquiteturas paralelas fundamenta-se na necessidade de se resolver problemas intensivamente computacionais. So os chamados Grand Challenges (WOODWARD, 1996; CHANG; EWING, 1999), problemas como previso de tempo e simulao de dinmica molecular, que exigem mquinas com grande capacidade de processamento. Tal poder de processamento pode ser viabilizado por meio de arquiteturas paralelas. Inicialmente a explorao de paralelismo se deu em um nvel mais baixo, como por exemplo, processadores superescalares (SMITH, 1995). Arquiteturas paralelas exploram o paralelismo em um nvel mais alto. Neste modelo o problema a ser resolvido dividido entre os processadores que compem a arquitetura. Idealmente, se um trabalho foi subdivido e est sendo executado por p processadores, espera-se que ele seja concludo p vezes mais rpido do que seria quando executado por um nico processador. Obviamente, esse caso ideal, na prtica no alcanado devido a problemas como tempo de comunicao entre os processadores e trechos de cdigo do programa essencialmente seqenciais. Arquiteturas paralelas so normalmente complexas e apresentam um custo de desenvolvimento elevado. Por isso, a simulao atravs de software se mostra como a melhor tcnica para avaliao dessas arquiteturas quando comparada modelagem analtica e construo de mquinas reais. Em um software simulador, pode-se: modelar toda a complexidade de uma arquitetura; efetuar alteraes e correes durante o processo de desenvolvimento; usar tantas mquinas quanto estiverem disponveis e at simular recursos que ainda no esto disponveis fisicamente. Alm do que em arquiteturas reais, h outros

16

custos relacionados aos problemas de instalao, gerenciamento e manuteno que tambm encarecem as experincias pretendidas. O uso de simuladores tambm reduz esses fatores e facilita o estudo de arquiteturas paralelas. Dada a importncia dos simuladores na pesquisa de computadores, o foco deste trabalho consiste no desenvolvimento um conjunto de algoritmos para testes com o Simulador de Multiprocessadores Superescalares. O SMS permite o desenvolvimento de aplicaes e a anlise de desempenho de arquiteturas paralelas e possibilita a configurao de diferentes modelos arquiteturais. O usurio do SMS pode simular ambientes paralelos de memria distribuda, bem como definir a topologia e o protocolo de rede de interconexo utilizada para comunicao entre os processadores. Em conjunto com os algoritmos a ferramenta pode ser vista como uma alternativa de baixo custo para pesquisa e ensino na rea de Arquitetura de Computadores de Alto Desempenho, pois, viabiliza o desenvolvimento de aplicaes paralelas e anlise de desempenho de diversos modelos de arquiteturas. Este trabalho est organizado conforme segue: o captulo 2 faz uma breve descrio sobre Computao Paralela. O captulo 3 descreve alguns simuladores e trata da ferramenta de simulao SMS. No captulo 4 so tratados os diversos aspectos de programao em ambientes paralelos. J o captulo 5 apresenta medidas de desempenho para auxiliar na anlise das sadas do simulador. Por fim, no captulo 6 so apresentados os algoritmos propostos para o simulador SMS, e nos captulos seguintes so apresentados as concluses finais e os trabalhos futuros.

17

2 COMPUTAO PARALELA

Este captulo discute os fundamentos de computao paralela. Introduz as bases do modelo seqencial que servir de modelo de comparao com o modelo de computao paralela. Apresenta a taxonomia de Flynn, que a mais utilizada nas classificaes de arquiteturas de computadores.

2.1

Processamento Seqencial

O modelo de processamento seqencial, teve dentre seus criadores Blaise Pascal, Charles Babbage e John von Neumann. John von Neumann apresentou um modelo elementar de execuo seqencial, composto basicamente por memria, unidade lgica e aritmtica, unidade de controle e os dispositivos de entrada/sada (Figura 1) (TANENBAUM, 2001). Em computadores estritamente seqenciais, as instrues que compem um programa so executadas de forma seqencial (conforme foram definidas pelo programador) pelo processador. Este modelo proposto serve at hoje como base para a resoluo de problemas atravs de algoritmos seqenciais. Entretanto, atualmente mesmo as arquiteturas seqenciais utilizam algum tipo de paralelismo interno ao processador ou aos dispositivos que compem a arquitetura de forma a conseguirem melhores desempenhos. Grande parte dos processadores modernos explora o paralelismo em nvel de instruo (ILP Instruction-Level Parallelism) para melhora de desempenho. Outra tcnica, denominada pipeline, permite a execuo sobreposta de vrias instrues. Antes do uso do pipeline uma instruo tinha que esperar a instruo anterior completar a execuo para poder ser executada. Por exemplo, para que uma instruo seja

18

completada ela necessita passar por estgios, tal como: busca de instruo, decodificao, leitura de registradores, execuo e escrita de resultado em registrador. Sem o uso do pipeline as instrues tm que passar uma por vez, atravs de todos os estgios. J com o advento do pipeline, enquanto uma instruo est na unidade de decodificao, j existe outra instruo sendo buscada, outra sendo executada e assim por diante. Dessa forma, o pipeline permite que os estgios necessrios para o processamento de instrues fiquem ocupados, de modo que o processador no fique ocioso (HENNESSY, 2003).

Figura 1 - Mquina de von Neumann

Outra melhoria de desempenho foi obtida com o modelo superescalar. Processadores superescalares basicamente buscam e decodificam diversos fluxos de instrues ao mesmo tempo, permitindo que vrias instrues sejam executadas em um nico ciclo de clock (SMITH, 1995). Processadores superescalares possibilitam a execuo de instrues em paralelo, utilizando o paralelismo em nvel de instruo. O funcionamento de um processador superescalar consiste basicamente nos seguintes passos: i. Os fluxos de dados so analisados quanto a dependncias de dados, j que alguns dados

19

podem ter dependncias em relao a outras instrues, necessitando aguardar a execuo dessas, para somente ento poderem ser processadas. ii. Depois deste passo que as instrues so distribudas para as unidades funcionais de acordo com o tipo de instruo. iii. As prximas instrues a serem iniciadas para a execuo em paralelo, so baseadas primeiramente na disponibilidade do operador de dados, que preferencialmente respeita a ordem do programa seqencial, porm o processador superescalar pode permitir a execuo de uma instruo fora de ordem (HENNESSY, 2003), o que uma caracterstica marcante neste tipo de processador. iv. Aps os passos anteriores necessrio que essas instrues sejam reordenadas, tal tarefa permite que as instrues apesar de serem executadas em ordem diferente do programa original voltem ordem original que foi estabelecida no programa seqencial. E desta forma termina-se a execuo de uma instruo no processador superescalar. Assim, processadores superescalares possibilitam que instrues sejam executadas em uma ordem diferente daquela do programa original e de forma paralela, fazendo melhor uso de unidades funcionais atravs do pipeline. Todos esses aspectos de paralelismo em arquiteturas seqenciais j trouxeram inmeros benefcios computao, e uniram de certa forma modelos paralelos e seqenciais, necessitando assim de uma classificao para essas arquiteturas. A seo 2.2 discute a Classificao de Flynn.

2.2

Classificao de Flynn

Michael Flynn, em 1966, classificou os inmeros modelos de arquitetura computacional de acordo com o nmero de instrues executadas e o nmero de conjuntos de

20

dados tratados (FLYNN, 1966), essa caracterizao produziu quatro classes de computadores, que so: Arquitetura SISD - Single Instruction, Single Data: Conjunto nico de instrues, conjunto nico de dados. a identificao mais simples de um computador, cujas instrues so executadas de forma seqencial, ou seja, tal mquina s processa uma nica instruo sobre um nico dado por vez. o modelo de von Neumann. Arquitetura MISD - Multiple Instruction, Single Data: Mltiplas instrues, conjunto nico de dados. So computadores que executam vrias instrues ao mesmo tempo sobre um nico dado. No existe nenhuma mquina implementada neste modelo, e at mesmo Flynn duvidou que algum dia isso pudesse existir. Arquitetura SIMD Single Instruction, Multiple Data: Conjunto nico de instrues, mltiplos conjuntos de dados. o equivalente ao paralelismo de dados, no qual uma instruo executada paralelamente utilizando vrios dados (processadores vetoriais, matriciais se enquadram nesta categoria). Arquitetura MIMD Multiple Instruction, Multiple Data: Mltiplos conjuntos de instrues, mltiplos conjuntos de dados. Este modelo o que faz a melhor referncia computao paralela propriamente dita, pois se refere ao modelo de execuo paralela, no qual cada processador est essencialmente agindo independentemente, havendo, portanto realmente mltiplos fluxos de instrues e mltiplos dados (ZARGHAN, 1995). A taxonomia de Flynn, apesar de elementar est em uso at hoje em funo de sua classificao simples, fcil de entender e por ser muito semelhante aos modelos reais de arquiteturas de computadores. Atualmente existem modelos hbridos que se enquadram em mais de uma categoria, o que levou a outras propostas de taxonomias (GUTZMANN, 1996).

21

2.3

Processamento Paralelo

Existem problemas que requerem um grande poder de processamento, por exemplo, simulaes numricas em sistemas complexos como previso de clima, aplicaes aerodinmicas, programas de explorao ssmica, engenharia gentica, entre inmeras outras aplicaes (WOODWARD, 1996; CHANG; EWING, 1999). Em sistemas com apenas um processador o desempenho do modelo dito seqencial, est intrinsecamente relacionado s restries tecnolgicas de cada poca, sendo que uma aplicao s ter melhoras de desempenho se tal processador tiver uma melhora de hardware. Em geral, os processadores tm melhorado seu desempenho em mais de 50% ao ano, mas um dia essa evoluo pode encontrar algum limite fsico, o que se tornar um empecilho para cientistas que desenvolvem cada vez mais programas que utilizam conjuntos de dados gigantescos e necessitam de computadores que possam processar esta massa de dados a uma velocidade cada vez mais rpida e no podem ficar limitados a esse obstculo. Neste contexto, a computao paralela uma alternativa vivel com potencial para superar esse obstculo. Mas o que computao paralela? A definio clssica dada por (ALMASI, 1989) : Um computador paralelo um conjunto de elementos de processamento que se comunicam e cooperam para resolver rapidamente grandes problemas. Outras definies podem ser obtidas, mas basicamente todas trazem a idia de que possvel empregar vrios processadores para resolver um dado problema de forma paralela e obter-se um menor tempo de processamento (WAHEED, 1993).

22

2.4

Arquiteturas Paralelas com Memria Compartilhada e Distribuda

Dentro da categoria MIMD possvel obter uma subclassificao das arquiteturas em funo do modelo de acesso memria. Neste contexto existem dois modelos bem definidos, que so: computadores com memria compartilhada e computadores com memria distribuda, que so abordados nas subsees subseqentes.

2.4.1 Multiprocessadores com Memria Compartilhada

Neste esquema os processadores acessam uma memria nica, que compartilhada entre todos os processadores, ou mesmo que exista uma memria para cada processador o endereamento global e compartilhado por todos (Figura 2a). A comunicao entre a memria global e processadores feita atravs de instrues load e store que do acesso aos endereos da memria. Neste modelo surge a necessidade de se coordenar os acessos ao meio comum, gerenciando quem pode ler e escrever em um determinado endereo comum da memria, a esta coordenao de acessos se d o nome de sincronizao. Este modelo tambm denominado de fortemente acoplado, e ainda pode ser dividido em dois esquemas distintos que so: Multiprocessadores UMA (Uniform Memory Access) e NUMA (NonUniform Memory Access). No modelo UMA ou SMP (Symmetric MultiProcessor) todos os processadores consomem o mesmo tempo para acessar a memria compartilhada; enquanto que no modelo NUMA alguns acessos memria so mais rpidos que outros. (BADER, 1997; PATTERSON, 2000).

23
Processador 1 Processador 1

Memria

Cache

Cache
Barramento Barramento Processador 2 Cache Disp. Entrada/ Sada Disp Entrada/ Sada

Memria
Processador 2 Cache Memria Processador N Cache Memria

Processador 3 Cache

(a)

(b)

Figura 2 - (a) Memria compartilhada (b) Memria distribuda

2.4.2 Multiprocessadores com memria distribuda

Nesta arquitetura cada processador possui memria prpria que no compartilhada com outro processador, ou seja, o endereamento de memria no compartilhado pelos processadores (figura 2b). Existem funes send e receive, para efetuar trocas de mensagens e assim realizar a comunicao e sincronizao dos processadores que constituem a arquitetura, j que isso no ocorre diretamente via memria compartilhada. A esta classificao pode-se tambm dar o nome de fracamente acoplada ou multicomputadores, j que cada n (unidade constituda por um processador, memria local e dispositivos de entrada e sada) composto por todos os dispositivos que compem um computador completo. Nesta categoria de arquitetura pode-se enquadrar os clusters. Existem inmeras caractersticas a serem observadas no modelo de memria distribuda, sendo uma das principais para este trabalho o fato de que em sistemas multicomputadores ao contrrio do que ocorre na computao seqencial, a programao torna-se mais complexa, pois requer que o programador explore o paralelismo explcito durante a programao. Assim, o programador tem que conhecer bem a arquitetura em que o

24

programa paralelo ser executado, para poder explorar o paralelismo na arquitetura. Outra desvantagem deste modelo a necessidade constante de trocas de mensagens necessrias para sincronizao do programa pela rede. Isso pode levar sobrecarga do subsistema de comunicao, tornando a rede de interconexo um gargalo do sistema. Porm, este tipo de arquitetura est sendo a melhor alternativa para realizao de pesquisas em universidades em funo do custo e pode apresentar melhoras de desempenho comparveis aos supercomputadores.

25

SIMULADOR DE ARQUITETURAS

Simuladores possibilitam que novas arquiteturas sejam projetadas e analisadas em ambientes de software antes de passarem para a linha de produo, reduzindo de certa forma o custo e o tempo de concluso envolvidos na construo das arquiteturas. Tal prtica permite at avaliar projetos arquiteturais de computadores que nem mesmo podem ser construdos, devido s restries tecnolgicas da poca. O uso de simuladores est to consolidado que mesmo empresas de renome, como Intel, utilizam simuladores para analisar seus processadores, como o caso do Pentium 4 (AUSTIN, 2002), proporcionando ao mercado um processador que j passou por uma bateria de testes mesmo antes de ser concebido. Desde o advento do computador uma prtica comum para engenheiros utilizar modelos de simulao para estudar sistemas fsicos de computadores. Entretanto, para obter simulaes realistas principalmente em ambientes paralelos necessrio utilizar cargas de trabalhos muito grandes de forma que os programas a serem simulados trabalhem com bilhes de instrues (EECKHOUT, 2004). O nvel de complexidade de simulao de arquiteturas paralelas bem como a carga de trabalho dos algoritmos a serem testados cresce to rapidamente que j existem trabalhos que utilizam computadores paralelos para realizar simulaes dos prprios ambientes paralelos e desta forma diminuir o tempo consumido com simulaes de tais ambientes (TROPPER, 2002).

3.1

SimpleScalar

Existe um leque muito grande de simuladores (BAGRODIA, 2000) que so

26

utilizados para os mais diversos propsitos, alguns exemplos de simuladores de arquiteturas computacionais so: Neander e Ramss da Universidade Federal do Rio Grande do Sul, baseados no modelo seqencial proposto por John von Neumann; RSIM (Rice Simulation) (PAI, 1997), que faz simulao de arquiteturas superescalares; ABSS (Augmentation-Based SPARC Simulation) (SUNADA, 1998), empregado principalmente em simulaes de memrias e Proteus (BREWER, 1991), que fornece suporte a sistemas multiprocessadores. Um outro simulador que tem sido extensivamente utilizado no meio acadmico e tambm por empresas o simulador SimpleScalar (BURGER, 1997; AUSTIN, 2002). O SimpleScalar foi desenvolvido em 1992 na Universidade de Wisconsin sob a coordenao de Gurindar S. Sohi. E posteriormente Doug Burger disponibilizou uma verso gratuita do simulador para uso no comercial, a qual est disponvel na Internet no endereo eletrnico www.simplescalar.com. O SimpleScalar pode emular diversos conjuntos de instrues, como por exemplo: ARM, MIPS, Alpha, PowerPC e x86, e devido sua arquitetura aberta ele pode ser estendido a outros conjuntos de instrues. Outro fator que influencia a utilizao deste simulador em larga escala o fato dele ser executado em sistemas operacionais gratuitos como o Linux. Os pesquisadores de novas arquiteturas podem utilizar benchmarks pr-compilados ou criar novas aplicaes para serem testadas e analisadas neste simulador, a construo desses programas realizada utilizando-se uma linguagem de programao de alto nvel, que pode ser C ou Fortran. O cdigo fonte depois de pronto compilado especialmente para ser executado no SimpleScalar, possibilitando assim a execuo de programas reais em prottipos virtuais de arquiteturas. A ferramenta de simulao SimpleScalar constituda por um conjunto de vrios simuladores, conforme pode-se observar na tabela 1. Desta forma, o SimpleScalar pode viabilizar simulaes de arquiteturas de forma rpida e concisa atravs do sim-fast ou simulaes mais detalhadas e dinmicas atravs do sim-outorder, possibilitando a simulao

27

de processadores que do suporte a caches non-bloking, execuo especulativa, renomeao de registradores e diversos modos de previso de desvio.
Simulador sim-safe sim-fast sim-profile sim-bpred sim-cache sim-fuzz sim-outorder Descrio Simulador simples Simulador otimizado Programa dinmico para anlise Simulador de previso de desvios Simulador de caches multinvel Testador e analisador de instrues aleatrias Simulador de microarquiteturas detalhado Linhas de cdigo 320 780 1300 1200 1400 2300 3900 Velocidade de Simulao 6 MIPS 7 MIPS 4 MIPS 5 MIPS 4 MIPS 2 MIPS 0.3 MIPS

Tabela 1 - Simuladores do SimpleScalar

3.2

Simuladores de Ambientes Paralelos

Muitos centros de pesquisas em computao de alto desempenho tm desenvolvido pesquisas no sentido de construir simuladores para arquiteturas paralelas servindo como ferramenta para pesquisa e ensino de arquiteturas paralelas. Alguns desses so: MINT (MIPS Interpreter) (VEENSTRA, 1993) que utiliza threads para simular um ambiente multiprocessador, conta com sistema de interconexo e hierarquia de memria. O MINT roda executveis compilados para plataformas MIPS (R3000). RSIM (Rice Simulator) (PAI, 1997) que implementa um modelo de processador detalhado para arquitetura superescalar. Simula um sistema multiprocessador de memria compartilhada. O RSIM roda nas plataformas SPARC e Solaris. ABSS (SPARC Simulator) (SUNADA, 1998) empregado principalmente nas simulaes de memria. O ABSS usa threads para simular multiprocessadores. Ele roda apenas nas plataformas SPARC e possui interface grfica derivada do MINT. Limes (Multiprocessor Simulator for PC Platforms) (MAGDIC, 1999) instrumenta o

28

cdigo em assembler com chamadas kernel call-outs em tempo de compilao. Para isso preciso que as aplicaes utilizem macros do tipo ANL (Argonne National Lab) para expressar o paralelismo. O Limes tambm usa threads para simular um ambiente multiprocessador e roda em plataformas PC. Proteus (BREWER, 1991) permite a simulao de multiprocessadores com interconexes do tipo: bus, k-ary, n-cube e butterfly. Possui biblioteca para passagem de mensagens, gerenciamento de memria e threads, alm de coleta de dados e interface grfica sofisticada para representar as sadas da simulao. Augmint (NGUYEN, 1996) usa threads para simular um sistema multiprocessador com espao de memria compartilhada e privada (para determinadas variveis). Ele roda aplicaes escritas em C e C++ com macros-m4. Ele roda em arquiteturas Intel x86. Tango Lite (HERROD, 1993) simula um ambiente multiprocessador com memria compartilhada. Ao contrrio do seu predecessor o Tango, o Tango Lite usa threads ao invs de Unix Process. As aplicaes podem ser escritas em C ou Fortran e devem fazer uso de macros-m4 para criao e controle de processos, bem como para a comunicao e sincronizao dos processos. O Tango Lite roda em plataforma MIPS (R3000). MulSim (MATLOFF, 2005) um simulador para ambiente multiprocessador com memria compartilhada, dispondo de vrios tipos de interconexo entre memria e processador. Multiprocessor Enhancements of the SimpleScalar Tool Set (MANJIKIAN, 2001). Simulador funcional (no detalhado) e simulador de cache baseados na ferramenta SimpleScalar, usam threads para simular um ambiente multiprocessador. Conta com suporte visualizao grfica do contedo da cache.

29

SMINT ou Superescalar MINT (LU, 1998) um simulador de multiprocessadores superescalares baseado no simulador MINT. A ferramenta de simulao apresentada neste trabalho (nas sees subseqentes)

difere-se dos demais simuladores apresentados por permitir simulaes detalhadas de arquiteturas paralelas de memria distribuda, com processadores superescalares que fazem uso de passagem de mensagem para comunicao entre os processadores. Sendo que a grande maioria dos simuladores existentes permite apenas a simulao de ambientes de memria compartilhada usando threads para a programao. Atualmente muito interessante a simulao de ambientes com memria distribuda que utilizam tcnicas de passagem de mensagem, pois o uso desta tecnologia est bastante difundido no mercado e em universidades. O que torna o simulador SMS muito til, j que tal simulador possibilita o estudo detalhado de tais ambientes de computao.

3.3

Algoritmos para testes e avaliao de desempenho

Os simuladores citados na seo 3.2 so utilizados para reproduzirem ambientes computacionais reais e para isso precisam de algoritmos que possam ser executados nas simulaes. Mesmo abordando melhor o assunto sobre algoritmos e programao paralela no captulo 4, esta seo apresenta uma breve discusso dos programas utilizados com os simuladores de arquiteturas ou mesmo algoritmos utilizados em testes de sistemas computacionais reais. Os algoritmos utilizados para testes de desempenho no meio computacional so normalmente denominados benchmarks, que so programas reais ou apenas partes de programas chamadas de kernels. Estes kernels so as partes mais crticas ou significativas de um programa real utilizado para testar uma arquitetura ou apenas uma parte da arquitetura.

30

Ento, um benchmark um programa que tem por objetivo proporcionar uma carga de trabalho a uma arquitetura computacional, de forma que se possa avaliar o desempenho da arquitetura segundo as caractersticas do benchmark. Existem vrios benchmarks e um dos mais conceituados o System Performance Evaluation Cooperative (SPEC) (DUJMOVIC, 1998), que tem por objetivo melhorar os resultados de testes sobre desempenho em sistemas computacionais. Fundado em 1988 o SPEC iniciou com apenas alguns programas de testes simples que visavam apenas comparar computadores da poca. Porm, atualmente o SPEC est disponvel para vrios tipos de testes com arquiteturas, abrangendo desde testes com computadores pessoais atravs do grupo OSG (Open System Group), passando por testes de desempenhos de dispositivos com funcionalidades grficas com o grupo CPC (Graphics Performance Characterization) e chegando por fim a grupos que criam benchmarks para computao de alto desempenho como o grupo HPG (High-Performance Group). Seguindo a linha de programas para testes de arquiteturas para computao paralela ou de alto desempenho existem dois benchmarks que merecem destaques: NAS Parallel Benchmarks (NPB) (BAILEY, 1993) e SPLASH (Standford Parallel Application for Shared Memory) (WOO, 1995). O NAS um conjunto de programas desenvolvidos pela agncia aeroespacial dos Estados Unidos da Amrica (NASA). Os benchmaks do NAS so derivados de aplicaes envolvendo dinmicas de fludos, consistindo de cinco kernels e trs pseudo-aplicaes. O SPLASH, desenvolvido pela Universidade de Stanford est na verso 2, e constitudo por kernels envolvendo matrizes e vetores tal como (Complex 1D FFT e Integer Radix Sort) e aplicaes completas como o Ocean Simulation e Water Simulation with Spatial Data Structure. Todos esses benchmarks auxiliam a comunidade cientfica a realizar testes com

31

sistemas computacionais. Entretanto, se utilizados para uso acadmico, principalmente com intudo de auxiliar no ensino de arquiteturas paralelas, tais benchmarks deixam a desejar, j que quase todos so muito complexos dificultando a sua compreenso de imediato. Assim esses benchmarks so bons para testes de arquiteturas, mas no para o ensino de aplicaes paralelas (BAGRODIA, 1999). Como o objetivo deste trabalho desenvolver os aplicativos para um simulador de arquiteturas paralelas com fins educacionais, os algoritmos propostos aqui tm de ser o mais simples possvel para que um estudante possa entender o algoritmo e da mesma forma possa utiliz-lo para testar a arquitetura.

3.4

Simulador de Multiprocessadores Superescalares - SMS

Neste contexto, o grupo de pesquisas de arquiteturas de alto desempenho do Departamento de Informtica da Universidade Estadual de Maring tambm tem desenvolvido pesquisas em simulao de arquiteturas paralelas e desenvolveu a ferramenta de simulao SMS. A ferramenta SMS viabiliza o desenvolvimento de aplicaes e anlise de desempenho de computadores paralelos. O SMS tem como base o ncleo do simulador SimpleScalar. Atualmente a ferramenta dispe de memria distribuda, primitivas de comunicao (Send e Receive) para troca de mensagens e uma rede de interconexo com topologia de barramento compartilhado (SANDRI, 2004). Dentre as alteraes realizadas no SimpleScalar para o desenvolvimento do SMS, uma das principais caractersticas implementadas a biblioteca que realiza a comunicao entre os vrios processadores que constituem a arquitetura simulada. As bibliotecas fornecem primitivas (ver tabela 2) de comunicao semelhantes s do MPI

32

(Message-Passing Interface) (PACHECO, 1997). Atravs desta biblioteca pode-se desenvolver aplicativos paralelos e test-los nas mais diversas arquiteturas.
Primitivas Send Sendbc Recv Send_be Sendbc_be Recv_be Recvo_be Recvseto_be Send_bi Sendbc_bi Recv_bi Recvo_bi Recvseto_bi Descrio No bloqueantes Envia Envia para todos os processadores em paralelo (Broadcast) Recebe Bloqueantes por espera ocupada Envia Envia para todos os processadores em paralelo (Broadcast) Recebe Recebe recuperando a origem Recebe passando a origem Bloqueantes por Interrupo Envia Envia para todos os processadores em paralelo (Broadcast) Recebe Recebe recuperando a origem Recebe passando a origem

Tabela 2 - Primitivas SMS para passagem de mensagem

A figura 3 mostra o modelo funcional da ferramenta. Existem 3 mdulos principais: Interface Grfica, Interface do Simulador e Simulador. O mdulo de Interface Grfica usado pelo usurio para definir previamente os parmetros que caracterizam a arquitetura simulada, tais como: o nmero de conjuntos e de associatividade da cache, o modo de previso de desvios, o nmero de unidades funcionais, memria compartilhada ou distribuda, a topologia e o protocolo de comunicao, e os programas que sero simulados. O mdulo de Interface do Simulador responsvel por iniciar o mdulo Simulador, repassando a ele as configuraes realizadas no mdulo de Interface Grfica. Esse mdulo realiza a distribuio dos processos entre os processadores, e faz a coleta de dados disponibilizados pelo mdulo Simulador, repassando-os para o mdulo de Interface Grfica. O mdulo Simulador composto de 4 submdulos principais. Esses submdulos interagem entre si, a fim de promover a execuo de aplicaes paralelas. So eles: Primitivas

33

de Comunicao, Gerenciador de Memria, Protocolo e Topologia.

Interface Grfica Interface Simulador Programas do Usurio

Interface para passagem de parmetros da simulao Disparador e Coletor

Programa 1

Programa 2

Programa 3

...

Programa N

Simulador Paralelo

Bibliotecas Send e Receive Protocolo Topologia Processador Processador 2

Gerenciador de Memria

Processador

...

Processador

Figura 3 - Arquitetura do simulador SMS

O submdulo Primitivas de Comunicao dispe de primitivas Send e Receive que operam de trs maneiras distintas: no bloqueantes, bloqueantes por espera e bloqueantes por interrupo. As primitivas no bloqueantes enviam e recebem mensagens sem realizar nenhum tipo de espera ou bloqueio. As primitivas bloqueantes por espera enviam e recebem mensagens, porm permanecem em espera ocupada aguardando at que uma outra mensagem de confirmao de envio ou recebimento seja transmitida. As primitivas bloqueantes por interrupo so semelhantes s bloqueantes por espera, entretanto, ao invs da espera ocupada, o programa interrompido pelo simulador fazendo com que os ciclos de execuo no sejam computados para esse programa. O submdulo Gerenciador de Memria simula o uso de memria compartilhada e distribuda. Quanto hierarquia de memria, o simulador conta com cache de instrues, cache de dados e opo para cache unificada. O gerenciador de memria conta tambm com protocolo para coerncia de cache e poltica de escrita na cache. A memria distribuda est implementada, e a memria compartilhada est sendo implementada. O simulador

34

possibilitar testar os mesmos algoritmos com arquiteturas paralelas de memria compartilhada e distribuda, melhorando ainda mais o nvel de simulao. O submdulo Protocolo encarregado do gerenciamento da comunicao da rede de interconexo entre os processadores. O protocolo de comunicao dependente da topologia da rede de interconexo escolhida. Esse submdulo emprega desde polticas simples de arbitragem de barramento at protocolos mais complexos de roteamento para redes de interconexo. O submdulo Topologia responsvel pela simulao da topologia da rede de interconexo. Esse submdulo permite a simulao de diversas configuraes de redes de interconexo, como: barramento, redes multiestgio, crossbar, entre outras. A topologia tipo barramento comum j est implementada neste submdulo. Para a implementao da ferramenta foram replicadas as estruturas do simulador sim-outorder do SimpleScalar de maneira que a ferramenta comporta-se como um conjunto de vrios simuladores sim-outorder sendo executados em paralelo. Para permitir a troca de mensagens entre os processadores simulados, desenvolveu-se a biblioteca de primitivas de comunicao que permite troca de mensagens entre os processadores. Essa biblioteca conta com primitivas no bloqueantes, bloqueantes por espera e bloqueantes por interrupo. Desta forma, a ferramenta atualmente permite a execuo de qualquer algoritmo desenvolvido em C, tanto de forma seqencial, quanto paralela. Para a simulao de programas paralelos necessrio o uso das primitivas de comunicao da prpria ferramenta. As simulaes atualmente permitem comparao, estudo e anlise de sistemas reais baseados em arquitetura de memria distribuda que utilizam bibliotecas de passagem de mensagem. A ferramenta uma tima alternativa para testes de Arquiteturas de Alto Desempenho.

35

3.5

Biblioteca de Passagem de Mensagem do SMS

O simulador SMS tem uma biblioteca de passagem de mensagem baseada na biblioteca MPI, o que facilita o desenvolvimento de programas paralelos a serem executados no simulador, pois essa metodologia semelhante utilizada em arquiteturas reais de computao paralela (SANDRI, 2004). Durante a programao de um algoritmo a ser simulado no SMS, o programador ir desenvolver dois arquivos fontes, um arquivo fonte principal ou mestre, que ir fornecer atributos e funcionalidades bsicas para o programa e iniciar e terminar todo o processo executado pela arquitetura paralela simulada. Esse programa executado por um processador tambm denominado de mestre. O outro um arquivo fonte secundrio ou escravo que ser executado pelos demais processadores (processadores escravos) que compem a arquitetura paralela. O arquivo escravo faz normalmente o servio bruto de processamento e computao de dados e controlado pelo programa mestre. Para se utilizar a biblioteca do SMS faz-se necessrio incluir no corpo do programa a chamada biblioteca com.h., tanto no cdigo fonte do arquivo mestre quanto do escravo (figura 4). Depois de declaradas todas as estruturas, variveis, funes e todos os atributos que podem compor um cdigo em C, faz-se necessrio na funo principal (do programa mestre e do escravo) incluir a funo de sincronizao (openchanel). Sem o uso de tal funo os programas no se comportam adequadamente (no ficam sincronizados), assim o uso da funo openchanel obrigatrio. De forma geral, essas so as nicas exigncias para se desenvolver um programa paralelo a ser simulado pelo SMS. Entretanto, se um programa no usa passagem de mensagem no necessrio utilizar a biblioteca com.h nem a funo openchanel para a simulao no SMS.

36

# arquivo mestre.c #include <stdlib.h> #include <stdio.h> #include </usr/sms/com.h> ... void main (void) { int a, b, c; double soma; openchanel(); puts("Mestre: inicia\n"); ... }

# arquivo escravo.c #include <stdlib.h> #include <stdio.h> #include </usr/sms/com.h> ... void main (void) { int a, b, c; double soma; openchanel(); puts("Mestre: inicia\n"); ... }

Cdigo fonte do programa mestre

Cdigo fonte do programa escravo

Figura 4 - Inicializando a biblioteca de comunicao do SMS

Aps fazer a devida chamada biblioteca de passagem de mensagem do SMS, e sincronizar os programas, possvel utilizar as funes de passagem e recebimento de mensagem dentro do simulador SMS. As principais funes da biblioteca SMS (todas as funes da biblioteca SMS podem ser vistas na tabela 2) so: send, sendbc, recv e recv_be. A funo send, responsvel por enviar dados de um nico computador de origem para um nico computador de destino. Tomando como exemplo a linha: send(((char *)&texto),
sizeof(texto),1). Tal linha envia o contedo da estrutura de dados texto ((char *)

&texto), e especifica o tamanho da mesma estrutura ( sizeof (texto)). O tamanho da estrutura serve para alocar memria no processador que receber a estrutura. Por fim, envia a estrutura ao processador 1. A utilizao de estruturas de dados para a passagem de valores no SMS facilita a compreenso da programao paralela. Dentro da estrutura possvel passar qualquer varivel at mesmo um conjunto delas. A figura 5 mostra um exemplo de como poderia ser enviada a

37

estrutura texto. A estrutura deve estar presente tanto no arquivo mestre como no arquivo escravo. Aps enviar os dados usando a funo send ser necessrio receb-los no processador de destino. Isso possvel atravs da funo recv, desta forma a sintaxe usada na funo para receber a estrutura texto recv(((char *)&texto), sizeof(texto)). Porm, com a funo recv no haver como sincronizar o algoritmo, de forma que, pode ser mais conveniente o uso da funo recv_be, que tambm ir receber o dado, porm o programa que usa esta funo ficar esperando (ocioso) at receber tal estrutura. Por fim, alguns dados podem ter de ser enviados para todos os processadores de forma que a funo de envio broadcast (sendbc envia para todos os processadores da arquitetura) mais recomendada. Tal funo envia com apenas uma mensagem e de uma nica vez toda a estrutura de dados para todos os processadores, o que bem mais eficaz do que enviar uma mensagem de cada vez para todos os processadores. A sintaxe para sendbc muito parecida com a do send, omitindo-se apenas o processador de destino. Uma observao pertinente que a mensagem em broadcast enviada para todos os processadores inclusive para o processador que faz o uso da funo, desta forma necessrio um recv_be neste processador tambm. Existem mais funes (tabela 2), porm apenas com as funes send, sendbc e recv_be possvel desenvolver a maioria dos algoritmos paralelos. Desta forma, atravs do uso das bibliotecas de comunicao apresentadas pelo simulador SMS, o usurio poder de forma fcil e prtica (j que no necessrio possuir um computador com vrias unidades de processamento) entender como funciona um programa paralelo, e to logo se acostume com os aspectos da programao paralela poder facilmente passar do simulador SMS para um ambiente real.

38

# arquivo mestre.c #include <stdlib.h> #include <stdio.h> #include </usr/sms/com.h> //declarao da estrutura texto struct __texto { char mensagem; int processador_nmero; } __texto; Struct _texto texto; void main (void) { int i; //abre canal openchanel(); // atribui texto a estrutura texto.mensagem=ola mundo; texto.processador_nmero=0; //envia ao processador 1 send((char *)&texto) sizeof(texto), 1); //atribui novo texto texto.mensagem=ola Todos; texto.processador_nmero=0; //envia para todos sendbc((char *)&texto) sizeof(texto)); //tambm recebe novo texto recv_be((char *)&texto) sizeof(texto)); //mostra o que foi recebido printf(o processador: %d envia um %stexto.processador_nmero, texto.mensagem); }

# arquivo escravo.c #include <stdlib.h> #include <stdio.h> #include </usr/sms/com.h> //declarao da estrutura texto struct __texto { char mensagem; int processador_nmero; } __texto; Struct _texto texto; void main (void) { int i; //abre canal openchanel(); //processador 1 recebe recv_be((char *)&texto) sizeof(texto)); //mostra o que foi recebido printf(o processador: %d envia um %stexto.processador_nmero, texto.mensagem); //recebe novo texto recv_be((char *)&texto) sizeof(texto)); //mostra o que foi recebido printf(o processador: %d envia um %stexto.processador_nmero, texto.mensagem); }

Fluxo das mensagens

Cdigo fonte do programa mestre

Cdigo fonte do programa escravo

Figura 5 - Usando funes da biblioteca SMS

39

PROGRAMAO PARALELA E ALGORITMOS PARALELOS

Normalmente arquiteturas MIMD com memria compartilhada ou distribuda so criadas para computar programas das mais diversas reas da cincia. Tais programas necessitam ser muito bem elaborados para explorar ao mximo os recursos de uma mquina paralela. Um algoritmo paralelo pode ser definido como um conjunto de processos (partes de um programa) que podem ser executados simultaneamente, tais processos podem se comunicar uns com os outros a fim de resolver um determinado problema. J um algoritmo seqencial executado passo a passo de forma seqencial como foi definido durante a sua programao (ZARGHAN, 1995). Um fato de extrema importncia na maioria dos sistemas paralelos, principalmente os que exploram o paralelismo explcito (no em nvel de instruo), que o sistema paralelo em si a combinao de um algoritmo paralelo e uma arquitetura paralela na qual o algoritmo implementado (GUPTA, 1993), ou seja, para que um sistema paralelo atinja o seu objetivo principal, que a melhora de desempenho na resoluo de determinados problemas, necessrio, alm de uma arquitetura fsica composta por vrios processadores um algoritmo que explore todo este potencial da arquitetura. Pois no adianta ter os recursos necessrios para melhorar o desempenho se estes no forem devidamente utilizados. Entretanto, a tarefa de construir algoritmos paralelos timos, que empreguem da melhor maneira possvel todos os subsdios oferecidos pela arquitetura paralela, no nada fcil, e talvez seja uma das tarefas mais difceis no desenvolvimento de um sistema paralelo. Uma prtica constantemente utilizada por programadores a reutilizao de algoritmos, pois se um algoritmo realiza uma funo de forma eficiente, ele pode ser utilizado em outro programa que ir necessitar das funcionalidades desta funo. Esta tcnica de

40

reutilizao tambm normalmente empregada na computao paralela, entretanto, muitos pesquisadores consideram que a melhor forma de se obter o paralelismo ideal reconstruindo o algoritmo inteiro, modelando-o para a arquitetura na qual ele ser executado. Sobre este problema Patterson (PATTERSON, 2000) comentou:
O maior obstculo ao sucesso dos sistemas multiprocessadores no o custo dos processadores usados em sua arquitetura, nem os problemas na topologia para conexo de redes, muito menos a indisponibilidade de linguagens de programao adequadas a tais sistemas; mas a grande dificuldade o fato de que poucos programas de aplicao importantes tm sido reescritos para executar suas tarefas em sistemas multiprocessadores. (PATTERSON, 2000, p. 416).

Assim reutilizao de algoritmos no recomendvel nem para arquiteturas paralelas semelhantes. Por exemplo, no se pode afirmar que um algoritmo projetado para ser executado em um computador contendo 8 processadores vai ser executado mais rapidamente em um sistema semelhante com 64 processadores, a menos que esse programa seja remodelado para esta arquitetura. Isso ocorre porque quanto maior a quantidade de processadores, maior ser o esforo computacional para sincronizar os processos, e maior ainda ser a utilizao da rede de interconexo que interliga os processadores (CHOI, 1993; MATHESON, 1996). Por mais absurdo que possa parecer bem provvel que um programa especificamente projetado para ser executado em um computador com 8 processadores faa melhor uso desta arquitetura, do que de uma arquitetura com 64 processadores. Portanto, fcil concluir que o programador, neste caso, tem que ser um especialista em hardware e software para tentar fazer um bom uso dos recursos de cada mquina paralela (KUMAR, 1991). Dessa discusso, conclui-se que diferentes tipos de aplicaes so mais adequadas para uma determinada configurao ou outra dependendo de como foi paralelizado o cdigo do programa.

41

No que se refere programao para computao paralela possvel encontrar modelos computacionais em que o programador no precisa se preocupar em como o sistema far uso do paralelismo, ficando isso a cargo do compilador da arquitetura. Porm, muito difcil obter-se o uso ideal dos recursos de um computador paralelo de forma automtica, j que h diversas mquinas com as mais variadas configuraes de hardware, o que dificulta o processo do compilador em explorar as caractersticas de cada arquitetura paralela, sendo ento necessrio um compilador para cada computador paralelo, o que invivel. Por isso, os mtodos mais utilizados na programao paralela so aqueles nos quais o programador deve instruir o programa em como explorar a arquitetura (os vrios processadores, a memria e a rede de interconexo), ou seja, o programador precisa conhecer a arquitetura e no apenas programar e deixar que o compilador utilize os recursos disponveis. Neste cenrio destacam-se os mtodos de variveis compartilhadas e de passagem explcita de mensagem. Na tcnica de variveis compartilhadas todos os processos tm acesso a uma memria comum (endereamento global), podendo se comunicar lendo e escrevendo (load e store) nesta memria. Esta tcnica comumente utilizada em sistemas multiprocessadores de memria compartilhada, e apesar de um pouco mais complexa pode ser empregada tambm em sistemas multicomputadores com memria distribuda. O outro mtodo o de trocas de mensagens, que tem se popularizado devido ao seu grande uso em Clusters. Neste esquema so empregadas primitivas de envio e recebimento (send e receiver), que so usadas para trocas de mensagens entre processos (TANENBAUM, 2001).

4.1. Aplicaes Paralelas

Os sistemas computacionais, em geral, so projetados com o propsito de

42

agilizar a execuo de uma determinada tarefa. Entretanto, algumas aplicaes, principalmente cientficas, requerem grande poder computacional (WOODWARD, 1996; CHANG, 1999; EWING, 1999). Algumas dessas aplicaes podem consumir muito tempo de processamento, e em casos extremos podem se tornar impraticveis devido ao longo tempo de computao. A fim de atender essa demanda foram desenvolvidas tcnicas para reduzir o tempo de execuo de tais aplicaes. Uma tcnica que vem tendo muito destaque a explorao do paralelismo apresentado por essas aplicaes. Pois a maioria das aplicaes possui algum nvel de paralelismo, que pode ser explorado de maneira que o programa possa ter seu tempo de execuo reduzido. Ento, aplicaes paralelas fazem uso de mltiplos processadores para resolver um determinado problema, e isso possvel atravs da execuo simultnea de diversos passos que compem a soluo do problema. Isso permite que uma aplicao paralela faa uso de vrios processadores, o que no ocorre em programas seqenciais, que essencialmente executam conjuntos bsicos de passos de forma seqencial, sem nenhum nvel de paralelismo (GRAMA, 2003). Mesmo com o possvel benefcio de reduo do tempo de execuo da aplicao, o uso do paralelismo requer alguns cuidados que no so necessrios em aplicaes seqenciais. Por exemplo, a aplicao paralela, apesar de possuir uma semntica parecida com a aplicao seqencial, deve tratar de aspectos inerentes s suas caractersticas paralelas tais como: definir quais processos podem ser executados de forma paralela e gerenciar de forma eficiente a sincronizao e comunicao entre tais processos. Segundo Grama a construo de um algoritmo paralelo segue basicamente os seguintes passos (GRAMA, 2003): Identificar pontos do programa que podem ser executadas de forma paralela;

43

Distribuir as entradas e sadas de dados pertinentes aplicao, bem como os dados intermedirios gerados durante a execuo das tarefas e que esto associados ao programa;

Gerenciar da melhor forma possvel o acesso aos dados compartilhados pelos processadores, para execuo de um dado problema, reduzindo a comunicao entre processos;

Sincronizar eficientemente os processadores nos mais diversos estgios de execuo de um programa paralelo, de forma que os processadores no fiquem com uma carga de trabalho muito elevada ou muito baixa. Para que um programa obtenha um bom desempenho em uma arquitetura

paralela necessrio decomp-lo em um conjunto de tarefas (processos), que so unidades de programas bem definidas que fazem parte da aplicao principal. A execuo simultnea de mltiplas tarefas para resolver um dado problema pode reduzir o tempo de execuo da aplicao. As tarefas podem ser executadas todas juntas ou em qualquer seqncia. Tarefas tambm podem apresentar dependncia, e desta forma necessitam esperar que outras tarefas sejam executadas para terminar sua prpria execuo. A decomposio de problemas em tarefas envolve o particionamento da aplicao. O particionamento definido como um conjunto especfico de tarefas que ir resolver um dado problema em um computador paralelo da maneira mais eficiente possvel. Existem dois mtodos para se particionar tarefas (CHOI, 1993; ZARGHAN, 1995): Particionamento Esttico: Neste mtodo as tarefas so particionadas durante a programao e no em tempo de execuo, desta forma cada processador recebe sua carga de trabalho antes de iniciar a computao. A vantagem que normalmente neste mtodo existe pouca comunicao e disputa entre os processos, pois estes j foram previamente particionados. Ento, no particionamento esttico existe uma

44

simplicidade relativa no gerenciamento das tarefas. Entretanto, uma tarefa extremamente complexa para o programador dividir as tarefas entre os processadores de forma eficiente (principalmente em ambientes paralelos heterogneos), e se a diviso de tarefas no for feita de forma correta alguns processadores podem ficar ociosos enquanto outros ficam sobrecarregados durante a execuo. Particionamento Dinmico: Neste mtodo o particionamento realizado durante a execuo do programa. A vantagem que ele supervisiona os processadores de forma que todos fiquem ocupados. A desvantagem que esse mtodo normalmente tem grande demanda de comunicao. Uma vez que o programa foi dividido em processos, cada processo pode ser executado em um processador diferente. A esse mapeamento entre processos e processadores d se o nome de escalonamento, o qual tem por objetivo a melhor utilizao dos recursos computacionais fornecidos pela arquitetura paralela (GRAMA, 2003). O escalonamento comumente observado em Sistemas Operacionais, porm neste caso conhecido como escalonamento local, e refere-se ao problema de atribuio de time-slices de um processador aos processos (TANENBAUM, 2001). O escalonamento em computao paralela faz referncia a um escalonamento aplicvel a Sistemas Distribudos ou Paralelos. O escalonamento (KUMAR, 1991) da mesma forma que o particionamento, tambm pode ser esttico ou dinmico. No esttico, os processos e a ordem em que eles sero executados so conhecidos antes da execuo do programa. Para se realizar um bom escalonamento esttico necessrio conhecer o tempo de execuo de cada tarefa e o tempo que cada unidade de processamento e seus recursos consomem para executar tal tarefa. obvio que isso no nada fcil. Outra dificuldade no escalonamento esttico, que se uma unidade de processamento parar de funcionar, o programa ser abortado, j que no h como fazer o re-escalonamento das tarefas, pois este esttico. No escalonamento dinmico os

45

processos so atribudos aos seus processadores durante a execuo. Neste ambiente no se faz necessrio conhecer totalmente o ambiente no qual o programa paralelo ser executado, j que normalmente o programa ir se adaptar e se moldar arquitetura paralela, o que oferece uma melhor utilizao dos processadores disponveis, incrementando desta forma a flexibilidade quanto ao aproveitamento do nmero de processadores que compem a arquitetura. Para se realizar um bom escalonamento dinmico preciso analisar os pontos crticos da arquitetura (por exemplo, gargalos como a rede de interconexo) e buscar a melhor maneira para dividir as tarefas entre os processadores, isso possibilitar a distribuio das tarefas de forma eficiente e melhorar o desempenho do algoritmo. A esse processo se d o nome de balanceamento de carga (CALZAROSSA, 2003). O nmero e o tamanho das tarefas decompostas em uma dada aplicao determinam a granularidade do problema. Desta forma, granularidade refere-se ao tamanho de uma tarefa em um processador e o desempenho de um algoritmo paralelo depende diretamente da granularidade do programa (LU, 1998). Se um programa for dividido em um pequeno nmero de grandes tarefas (granularidade grossa) a tendncia que esse algoritmo seja mais adequado para arquiteturas com um nmero pequeno de processadores e desta forma se torne uma aplicao com um nvel de paralelizao muito baixo. J se um programa for dividido em um grande nmero de pequenas tarefas (granularidade fina), o programa ter um nvel de paralelizao maior, entretanto, bem provvel que neste caso o programa faa maior uso da rede interconexo, podendo desta forma perder desempenho devido ao alto grau de comunicao requerido entre as tarefas. O programador de aplicaes paralelas deve balancear a granularidade da aplicao tentando manter um alto coeficiente de paralelizao e da mesma forma tentando reduzir a necessidade de comunicao entre as tarefas, procurando assim obter uma granularidade mdia.

46

Uma alternativa para reduzir a demanda de comunicao entre as tarefas definir grupos de tarefas, relacionando as tarefas que mais se comunicam e deixando-as juntas onde a comunicao tenha um custo menor (CHOI, 1993; MATHESON, 1996; CREMONESI, 1999). Outro aspecto que deve ser observado a relao entre o nmero de processadores e o tamanho do problema, essa relao influencia na reduo da comunicao entre as tarefas (GUSTAFSON, 1988; GUPTA, 1993; GRAMA, 1993; HOGANSON, 1999;). Esta relao ser discutida mais detalhadamente no tpico sobre avaliao de desempenho, no captulo 5. Portanto, ajustar o nmero de processadores ao tamanho do programa ou viceversa leva a um tempo de execuo melhor, e o programador deve estar atento a esse fator e aos outros discutidos anteriormente (GRAMA, 2003; ZARGHAN 1995). Quanto ao ambiente de programao e desenvolvimento de aplicaes paralelas possvel encontrar basicamente trs tipos de ferramentas de programao (GRAMA, 2003): Compiladores: Fazem a paralelizao de forma automtica. Neste tipo de ferramenta o programa normalmente construdo de forma seqencial, ficando a cargo do prprio compilador explorar o paralelismo da aplicao. Neste modelo, normalmente consegue-se um ganho de desempenho menor se comparado explorao explcita do paralelismo, mas a construo do aplicativo atravs de compiladores exige o mnimo esforo do programador, j que este ir programar normalmente (de forma seqencial), sem se preocupar em descobrir qual trecho de cdigo deve ser paralelizado e como isso ser realizado. Extenses de Paralelizao: So normalmente bibliotecas que possuem primitivas de comunicaes (como por exemplo: MPI e PVM), que facilitam o gerenciamento dos processos existentes em aplicaes paralelas. Essas bibliotecas podem ser utilizadas a

47

partir de linguagens de programao normalmente seqenciais (C++, Fortran, Pascal, etc). Linguagens de Programao Paralelas: Especialmente projetadas para serem usadas em ambientes paralelos, tais linguagens possibilitam a construo de aplicaes bem estruturadas e possuem rotinas de gerenciamento de processos paralelos muito eficientes, dinamizando desta forma a comunicao, sincronizao e gerenciamento da aplicao paralela. Todas as ferramentas apresentadas possuem seus prs e contras. O compilador paralelo facilita a programao e agiliza o desenvolvimento da aplicao, mas normalmente no consegue fazer o uso ideal dos recursos fornecidos por cada arquitetura paralela. Por sua vez, as linguagens de programao paralelas conseguem um bom desempenho em arquiteturas paralelas (GRAMA, 2003), entretanto, exigem que o programador aprenda uma nova linguagem de programao, o que pode levar um tempo considervel e consumir tambm um tempo precioso no desenvolvimento da aplicao paralela. Desta forma, as ferramentas que atualmente merecem maior destaque so as extenses paralelas, que podem ser usadas pelo programador em uma linguagem de programao j conhecida por ele, ficando a cargo do programador apenas aprender como usar de forma eficiente as rotinas que possibilitam a programao paralela. Alm disso, as extenses permitem uma melhor adaptao de cdigos seqenciais para cdigos paralelos, e conseguem explorar de forma eficiente grande parte dos recursos de uma arquitetura paralela. Alm de escolher alguma ferramenta de programao, necessrio ter-se em mente como o algoritmo ser paralelizado, principalmente se o desenvolvedor do aplicativo escolher uma ferramenta na qual necessite paralelizar a aplicao de forma direta como ferramentas de extenso e linguagens paralelas. Modelos de algoritmos paralelos so formas de estruturar algoritmos paralelos

48

atravs de tcnicas de decomposio, mapeamento e estratgias de minimizao das interaes entre as tarefas. O enfoque principal deste trabalho aborda paralelismo no contexto de memria distribuda. Neste tipo de arquitetura pode-se aplicar as seguintes abordagens para se extrair o paralelismo: Data Parallelism - Explora os dados a serem processados pelo programa paralelo. Cada tarefa executa operaes semelhantes sobre dados diferentes (GRAMA, 2003). Este modelo emprega balanceamento de carga de trabalho esttico, o que normalmente garante um bom balanceamento de carga (GRAMA, 2003; ZHANG, 1994). O paralelismo de dados apresenta timos resultados, pois geralmente no requer muita comunicao o que diminui o overhead e o tempo gasto com a comunicao (ZHANG, 1994), e quanto maior a entrada de dados melhor seu desempenho (GUSTAFSON, 1988; ZARGHAN, 1995). Um exemplo desta prtica um algoritmo de multiplicao de matrizes no qual as colunas e as linhas das matrizes a serem multiplicadas so distribudas entre os diversos processadores que compem a arquitetura paralela, e cada processador executa o mesmo cdigo para multiplicar essas linhas e colunas, completando desta forma a aplicao. Task Graph - Neste modelo o inter-relacionamento entre as tarefas do problema utilizado para agrupar os dados relacionados. Procurando-se deixar os dados que se inter-relacionam sempre onde possam ser acessados de forma mais rpida (por exemplo, na memria local), facilitando a comunicao ou pelo menos reduzindo o custo da comunicao entre os processos (CREMONESI, 1999). O modelo Task Graph utilizado para resolver problemas nos quais vrios dados esto associados e as tarefas necessitam interagir entre elas, fazendo uso desses dados (GRAMA, 2003). Este tipo de modelo mais facilmente implementado em arquiteturas de memria

49

compartilhada, mas pode ser implementado em arquiteturas de memria distribuda. Desta forma, um programa paralelo pode ser representado por um grafo de tarefas (task graph), no qual os ns representam mdulos e as arestas indicam a necessidade de comunicao entre esses ns (CHOI, 1993). Um exemplo de aplicao que utiliza este modelo o mtodo de ordenao quicksort. Work Pool - Tambm conhecido como Task Pool, caracterizado por um mapeamento dinmico entre tarefas e processadores visando desta forma um bom balanceamento de carga entre os processadores. Tal mapeamento pode ser centralizado ou descentralizado. As tarefas podem ser armazenadas em listas de prioridade, tabelas hash, ou em rvores. Em arquiteturas de passagem de mensagem esse modelo normalmente usado quando a quantia de dados associados tarefa relativamente pequena se comparada com a computao associada com as tarefas (GRAMA, 2003). O mesmo exemplo da multiplicao de matriz pode ser utilizado aqui, mas neste caso os processadores iro buscar as tarefas a serem executadas (as linhas e colunas) em uma lista. Processor Farm Neste modelo existe um processador principal (tambm chamado de mestre) que responsvel por gerenciar um grupo de processadores (chamados de escravos), no qual cada escravo processa assincronamente tarefas submetidas pelo mestre. O mestre gerencia o trabalho dos escravos e faz o balanceamento de carga. Este modelo muito utilizado tanto por arquiteturas de memria compartilhada quanto por memria distribuda, entretanto necessrio ter-se cuidado para que o processador mestre no se torne um gargalo neste modelo (GRAMA, 2003). Utilizando a mesma aplicao de multiplicao de matrizes, neste mtodo um processador ficar responsvel por distribuir as colunas e linhas a serem multiplicadas.

50

Pipeline ou Produtor-Consumidor Este modelo segue o modelo de pipeline empregado pelos processadores, ou seja, um fluxo de dados passado atravs de uma sucesso estgios (HENNESSY, 2003). Cada estgio executa uma tarefa diferente sobre este fluxo de dados (ZARGHAN, 1995). Essa execuo simultnea de diferentes tarefas sobre um fluxo de dados tambm chamado de stream parallelism. Cada processo no pipeline pode ser visto como o consumidor de uma seqncia de dados do processo que o precede e um produtor de dados para o processo seguinte do pipeline, da o nome Produtor-Consumidor (GRAMA, 2003). Utilizando mais uma vez o exemplo da multiplicao de matrizes, neste mtodo cada estgio seria responsvel por uma operao, sendo, o primeiro estgio responsvel pela entrada de dados, o segundo pela multiplicao, o seguinte pela adio e o ltimo pela sada, terminando desta forma todos os estgios do pipeline necessrios para essa aplicao. Em muitos casos mais de um modelo de programao paralela pode ser aplicado

para a resoluo de um problema. Um modelo hbrido pode ser construdo aplicando-se vrios modelos de forma hierrquica ou aplicando-se mltiplos modelos de forma seqencial para diferentes fases do algoritmo. Ainda no que se refere a modelos de programao possvel encontrar mais dois modelos (ZARGHAN, 1995): estruturas sncronas e assncronas. Tais modelos podem ser considerados como modelos base para os modelos discutidos anteriormente. Na estrutura sncrona dois ou mais processos esto ligados por um ponto comum de execuo usado com propsitos de sincronizao entre processos. Um processo ir atingir um ponto no qual ter de esperar por um ou mais processos. Aps os processos terem alcanado o ponto de sincronizao, eles podem continuar a execuo do programa at o prximo ponto de sincronizao. Nesta estrutura, os demais processos sempre esperaram pelo processo mais lento e esta a principal desvantagem deste mtodo. Esta estrutura de

51

algoritmo paralelo tambm conhecida como Partitioning Algorithms. possvel aplicar estruturas de sincronizao em diversos problemas. Este mtodo envolve, por exemplo, uma srie de iteraes em grandes estruturas de matrizes. Cada iterao usa o resultado parcial produzido pela iterao precedente e o transforma em busca de uma soluo final. A computao em cada iterao pode ser paralelizada de forma que cada processo trabalhe em diferentes partes dos dados da matriz. De qualquer forma, depois de cada iterao os processos devem ser sincronizados devido ao resultado parcial produzido, que ser usado pelo processo seguinte em outra iterao. Esse ciclo continuar at serem cumpridos todos os passos e assim atingir uma soluo final. A estrutura assncrona permite que os processos pertencentes ao algoritmo trabalhem com o dado mais recente fornecido pela execuo de outros processos. Quando um processo termina um estgio, ele atualiza as informaes necessrias e inicia o prximo estgio. Quando este modelo utilizado em um ambiente de passagem de mensagem, um processo l algumas mensagens de entrada de dados e depois completa um estgio. Baseado nas mensagens e nos resultados obtidos pelo estagio anterior, o processo ativa seu prximo estgio e envia mensagens para outros estgios. Desta forma, algoritmos assncronos continuam ou terminam seus processos conforme os valores de passagem de mensagem e no esperam por um conjunto de entrada de dados como no caso do modelo sncrono. Em comparao com algoritmos sncronos, os assncronos requerem menos acessos memria compartilhada, o que reduz a disputa por memria. Em geral, algoritmos assncronos so mais eficientes devido seguinte caracterstica: os processos no esperam pela execuo de outros processos. Isso normalmente diminui o tempo de execuo; os resultados dos processos que so executados mais rapidamente podem ser usados para eliminar processos mais lentos; proporcionando menos competio por memria. Entretanto,

52

algoritmos assncronos so difceis de programar. Sua anlise mais complexa que a de um algoritmo sncrono. Todas as tcnicas de programao para ambientes paralelos no so exclusivas e podem ser combinadas para produzirem resultados melhores em uma aplicao paralela. Alm disso, freqentemente aplicaes paralelas possuem vrias etapas de computao, em que pode ser necessrio aplicar diferentes tipos de decomposio.

4.2

Passagem de Mensagens

No basta dispor de diversos processadores para se obter computadores mais rpidos. necessrio que haja um gerenciamento correto desses processadores para que o programa obtenha um desempenho ideal e justamente com o propsito de fornecer um gerenciamento dos multiprocessadores ou multicomputadores que surge a tcnica de passagem de mensagem. Conforme discutido na seo 4.1, no existe um modelo padro de programao paralela, porm existe uma prtica chamada de extenso de paralelizao que tem sido muito utilizada. Neste contexto existem duas bibliotecas de passagem de mensagem, que tm sido amplamente utilizadas e que efetuam a intercomunicao entre os processadores, podendo ser tomadas como referncia em programao paralela. As bibliotecas PVM (Parallel Virtual Machine) e MPI (Message Passing Interface), so utilizadas a partir de linguagens de programao como C ou FORTRAN e, possibilitam o compartilhamento de informaes entre os processadores que compem a mquina paralela (PACHECO, 1997). Antes dessas bibliotecas cada fabricante tinha que desenvolver sua prpria forma de trocar informaes entre mquinas MIMD, o que dificultava ainda mais o cenrio da programao em computao paralela. Portanto, essas bibliotecas vieram para auxiliar o programador.

53

A passagem de mensagem o mtodo de comunicao baseado no envio e recebimento de mensagens, cuja funcionalidade a gerncia dos processos, entretanto quem determina como isso ser feito o programador, as bibliotecas fornecem apenas o meio de gerenciar tais tarefas no fazendo isso automaticamente, como faz um compilador (ZARGHAN, 1995).

54

AVALIAO DE DESEMPENHO

Quando um sistema paralelo utiliza dois processadores, logo se cria a expectativa de que qualquer programa executado neste sistema ser processado duas vezes mais rpido do que numa mquina monoprocessada. Porm, isso no verdade. Para que a execuo paralela atinja o mximo possvel de desempenho, o cdigo do programa originalmente desenvolvido de forma seqencial deve, de alguma maneira, ser 100% paralelizado. Supondo que seja possvel obter esse patamar de programao, bem como possuir um sistema perfeito de sincronizao entre os processadores, no qual a comunicao tambm seja efetuada em um tempo desprezvel, ento seria possvel obter um sistema totalmente paralelo que certamente alcanaria um ganho de desempenho equivalente ao nmero de processadores que compem a arquitetura. Entretanto extremamente raro encontrar problemas a serem computados que no empreguem trechos estritamente seqenciais. Amdahl, em 1967, questionou a eficincia de sistemas paralelos, afirmando que mesmo pequenas partes de um programa precisam ser paralelizadas para que todo o potencial da arquitetura possa ser explorado (SUN, 1990). Ento, pode-se deduzir por essa afirmao, que o objetivo do ganho linear de desempenho envolve a descoberta de novos algoritmos que sejam inerentemente paralelos. A lei de Amdahl sugere que muito difcil alcanar o desempenho de pico esperada para uma arquitetura paralela (PATTERSON, 2000). Mas, ainda que no se consiga paralelizar totalmente um algoritmo e alcanar sempre o desempenho ideal em sistemas paralelos, possvel obter ganhos significativos de desempenho paralelizando os ncleos de programas (partes em que se concentram os maiores esforos computacionais). Neste contexto, este captulo discute alguns aspectos relacionados avaliao de desempenho.

55

5.1

Alguns aspectos quanto a medidas de desempenho

O desempenho de sistemas paralelos o resultado de interaes complexas entre recursos de hardware e software. O desempenho de computadores paralelos est relacionado a caractersticas de aplicaes, tais como estrutura do algoritmo, parmetros de entrada, tamanho do problema, a caractersticas fsicas como nmero de processadores e taxas de transferncia da rede de interconexo. Todos esses aspectos determinam como a aplicao explora os recursos disponveis em arquiteturas paralelas e consequentemente como influenciam no desempenho (CALZAROSSA, 2003, GRAMA, 2003). Uma boa maneira de se conseguir uma tima interao entre hardware e software e atingir um bom desempenho usando sistemas paralelos analisando o comportamento de cada atributo da arquitetura frente a um conjunto de algoritmos (tais algoritmos so denominados Benchmarks) que teste tal arquitetura da maneira mais completa possvel (FRANCIS, 1988; BAILEY, 1993). Para tal, so empregadas ferramentas que permitem analisar como um algoritmo faz uso da arquitetura paralela. Softwares de anlise e mtricas de desempenho so divididos em estticos e dinmicos (CREMONESI, 1999). Os estticos so derivados de modelos que adotam a descrio da aplicao. O software captura caractersticas inerentes ao paralelismo da aplicao e sincronizao. Mtricas dinmicas so extradas a partir da execuo de aplicaes, normalmente isso se d atravs do uso de simuladores. Medidas estticas incluem: nmero de ns, grau de sincronizao, tamanho do caminho a ser percorrido, caminho mximo que um n de entrada tem de percorrer at um n de sada, tamanho do problema, etc. J algumas mtricas dinmicas so: tempo de computao dos processadores, tempo de comunicao, tempo de execuo, volume de comunicao, volume de entrada/sada, entre outros. O uso de simuladores muito considerado para este propsito, j que conseguem obter dados significativos de um grande nmero de recursos de hardware.

56

Medidas em computao paralela fazem referncia execuo de uma aplicao paralela em P processadores, onde K diferentes atividades e N regies de cdigos podem estar sendo monitoradas. A monitorao de tais aspectos da computao paralela pode ser obtida atravs da anlise de alguns parmetros, tais como: medidas de atividades de computao (por exemplo, nmero de instrues executadas pelo processador), comunicao, acesso memria, I/O (Input/Output entrada/sada) ou regies do cdigo como loops, rotinas, etc. Vrios parmetros podem ser medidos em arquiteturas paralelas: Parmetros de tempo; Nmero de operaes de entrada e sada; Nmero de bytes lidos e escritos; Nmero de acessos memria; Nmero de faltas de cache (cache misses); Nmero de bytes enviados e recebidos;

Ento, as propriedades das mtricas de sistemas paralelos devem ser estudadas, pois elas influenciam diretamente no desempenho de uma aplicao. Por exemplo, um fato bem conhecido no emprego de arquiteturas paralelas o tamanho fixo do problema, em que os ganhos de desempenho dos algoritmos paralelos no continuam crescendo com o aumento do nmero de processadores. J que a arquitetura tende a saturar conforme aumenta o nmero de processadores. Desta forma, o nmero ideal de processadores para uma arquitetura depende do tamanho do problema (GUPTA, 1993; CREMONESI, 1999). O tamanho do problema j foi um dos maiores empecilhos enfrentados pelos pesquisadores. A lei de Amdahl (SUN, 1990), causou certo marasmo dentre as pesquisas de sistemas paralelos, at que em 1988 Gustafson (GUSTAFSON, 1988), observou que Amdahl assume que o nmero de processadores independente do tamanho do problema, o que

57

normalmente no o caso. Na prtica o tamanho do problema proporcional ao nmero de processadores. Quando dado mais poder computacional, o problema geralmente se expande para fazer uso das facilidades da arquitetura, tal observao permitiu que os estudos sobre sistemas paralelos tomassem novos rumos desde ento. Existem diversas medidas para a caracterizao de desempenho de um sistema paralelo, mas as que mais se destacam so: tempo de execuo, speedup e eficincia (EAGER, 1989; SUN, 1990).

5.2

Tempo de execuo

Historicamente o tempo de execuo ou o tempo decorrido (elapsed time) uma das mtricas mais populares (CREMONESI, 1999; CALZAROSSA, 2003; GRAMA, 2003) para verificar o desempenho em um dado sistema. O tempo de execuo serial o tempo decorrido do incio da execuo do programa at o seu trmino em um computador seqencial. J o tempo de execuo paralelo o tempo decorrente do momento em que o programa inicialmente executado na arquitetura paralela at o momento em que o ltimo processador empregado para a resoluo do problema termina a execuo.

5.3

Speedup

Em conjunto com o tempo decorrido existe uma mtrica denominada speedup (acelerao ou ganho de desempenho) que extremamente utilizada. O speedup a diviso do tempo decorrido de uma arquitetura pela outra, por exemplo, uma arquitetura seqencial por uma paralela, ou at mesmo uma arquitetura paralela por outra. O speedup consegue demonstrar de forma grfica os diversos aspectos de uma arquitetura paralela (rede de

58

interconexo, nmero de processadores, etc) (CREMONESI, 1999). Existem inmeros fatores que influenciam no speedup, dentre alguns, a rede de interconexo, capacidade de processamento do processador, o nmero de processadores, os aspectos de programao (ver captulo 4 sobre programao paralela), entre outros. O speedup a medida do mrito relativo de uma aplicao frente a diferentes nmeros de processadores de um sistema paralelo, ou seja, a medida que representa o benefcio relativo do uso de determinada arquitetura paralela para resolver um dado problema. Existem duas modalidades bem definidas para se medir o speedup, que so: speedup absoluto e o relativo (SUN, 1990). O primeiro definido como o tempo decorrido na execuo seqencial do melhor algoritmo dividido pelo tempo de execuo decorrente do algoritmo paralelo. J speedup relativo definido como o tempo decorrente de um algoritmo paralelo em um nico processador e o tempo decorrente do mesmo algoritmo paralelo em N processadores. A razo para se usar speedup relativo que o desempenho de algoritmos paralelos varia de acordo com o nmero de processadores disponveis em uma arquitetura e comparando-se o mesmo algoritmo em funo da variao do nmero de processadores possvel verificar de forma mais precisa o impacto do uso do paralelismo, do que se usando o speedup absoluto que faz a comparao com um algoritmo serial (SUN, 1990). Existem vrios parmetros que podem ser expressos atravs do speedup, os mais significativos so: o speedup de tamanho de problema fixo (fixed-size speedup) que foi descrito por Amdahl, e o speedup de tempo fixo (fixed-time speedup), descrito por Gustafson que o mais usado atualmente. No speedup de tamanho fixo o tamanho do problema mantido constante variando-se apenas o nmero de processadores da arquitetura, no speedup de tempo fixo tanto o nmero de processadores quanto o tamanho do problema so alterados, o que condiz mais com a realidade (GUSTAFSON, 1988). O tempo dito fixo porque a idia aumentar o nmero de processadores junto com o tamanho do problema de forma que o

59

tempo mantenha-se constante. Uma melhor compreenso dos speedups de Amdahl e de Gustafson pode ser obtida atravs da figura 6, na qual W1 o tamanho da parte seqencial do programa e WN a parte paralela do programa, em conjunto com esses dados so apresentados a relao entre o tamanho do problema e o nmero de processadores no speedup de Amdahl e tempo de execuo e nmero de processadores no speedup de Gustafson.

Tamanho do Problema

W1 W1 W1 W1

Tempo de Execuo

T1 T1 T1 T1

WN WN WN WN 1 2 3 4 1 2 3

TN TN TN TN 4

Nmero processadores

Nmero processadores

Amdahl - fixed-size speedup

W1 W1 W1 W1 WN WN WN WN 1 2 3 4 T1 T1 T1 T1

Tamanho do Problema

Tempo de Execuo

TN TN TN TN 1 2 3 4

Nmero processadores

Nmero processadores

Gustafson - fixed-time speedup

Figura 6 - Caractersticas dos Speedups de tamanho fixo e tempo fixo (SUN, 1990)

Na prtica pode-se definir a acelerao (speedup) ou ganho que sofre cada arquitetura (BAGRODIA, 2000), medindo-se o tempo de execuo na arquitetura seqencial dividido pelo tempo consumido pela execuo na arquitetura paralela, para executar o mesmo problema (figura 7), isso para o speedup absoluto. No caso do speedup relativo s colocar

60

no lugar do tempo de execuo do programa seqencial o tempo do algoritmo paralelo executado com apenas um processador (ver figura 8). speedup = TempoExecuoSeqencial TempoExecuoParalelo

Figura 7 - Speedup Absoluto

speedup =

TempoExecuoParalelo1 TempoExecuoParalelo N

Figura 8 Speedup Relativo

Desta forma o speedup a referncia de quo melhor um sistema paralelo em relao ao sistema seqencial ou outro sistema podendo ser at mesmo outro paralelo (ZARGHAN, 1995; GRAMA, 2003). Programas com finalidade de apresentar o desempenho de sistemas paralelos (por exemplo, simuladores) so normalmente responsveis por fornecer um grande montante de dados ao usurio para viabilizar a anlise do uso dos recursos. Para uma melhor apresentao desses dados necessrio que tais programas permitam uma representao grfica de forma a facilitar a anlise (WAHEED, 1993). O speedup viabiliza uma medida grfica extremamente til para a apresentao do comportamento do algoritmo frente a arquitetura paralela. Tais apresentaes grficas mostram ao usurio o estado global do sistema paralelo, e o usurio pode analisar como est sendo efetuada a distribuio das tarefas entre os recursos e se possvel melhorar ainda mais o desempenho do sistema.

61

5.4

Eficincia

Outra medida que pode ser empregada no estudo de arquiteturas paralelas, e derivada do speedup, a eficincia. Eficincia uma medida da frao de tempo na qual um processador realmente usado. Em sistemas paralelos ideais o speedup igual ao nmero de processadores e a eficincia igual a um (GUTPA, 1993). Em sistemas reais o speedup menor que o nmero de processadores e a eficincia fica entre zero e um. A anlise de eficincia permite determinar a melhor combinao de algoritmo e arquitetura para um problema (GRAMA, 1993). A eficincia relata o tamanho do problema e o nmero de processadores requeridos para manter o sistema eficiente, e isso ajuda a determinar a escalabilidade do sistema, sua velocidade e largura de banda da rede de comunicao. Existe uma referncia direta entre o nmero de processadores, tamanho do problema e a eficincia, de forma que, quando se aumenta o nmero de processadores a eficincia reduzida, e aumentando-se o tamanho do problema aumenta-se a eficincia. Desta forma ao se aumentar ambos a eficincia ser constante (ZHANG, 1994). Uma pergunta natural ento : qual o limite para se aumentar o nmero de processadores proporcionalmente ao tamanho do problema? Isso depende da arquitetura, mas se o tamanho do problema constante enquanto o nmero de processadores aumenta, a eficincia apresenta quedas, por causa do acrscimo de overhead (controle de comunicao entre os processadores) causado pelo nmero de processadores. J se o tamanho do problema aumenta enquanto o nmero de processadores constante ento, a eficincia aumenta devido ao nvel insignificante do overhead em relao computao do problema. Desta forma, pode-se manter a eficincia desde que se aumente de forma proporcional o tamanho do problema (GRAMA, 1993). claro que muito difcil encontrar a relao exata entre o

62

tamanho do problema ideal para cada arquitetura, j que o problema pode estar associado a inmeros aspectos de hardware e software. A eficincia considerada uma mtrica que investiga a escalabilidade dos algoritmos. Tal mtrica obtida pela frmula apresentada na figura (9).

Eficincia =

Speedup Nmero de Processadores

Figura 9 Eficincia

Portanto, o nmero processadores deve ser escolhido de forma a maximizar a eficincia e o speedup da arquitetura.

63

6 ALGORITMOS PARALELOS PARA O SMS

Neste captulo so apresentados os algoritmos desenvolvidos para testes de avaliao de desempenho em arquiteturas a serem simuladas no SMS. Tais algoritmos viabilizam a investigao das arquiteturas simuladas, auxiliando assim na avaliao da arquitetura. Os algoritmos tambm tm objetivos educacionais, permitindo que alunos de computao possam analisar tais algoritmos, alter-los e test-los, introduzindo assim o ambiente de computao paralela.

6.1

Algoritmo Paralelo de Multiplicao de Matrizes

A multiplicao de matrizes e as demais operaes envolvendo matrizes esto relacionadas com inmeras aplicaes da computao cientfica, engenharia, matemtica, qumica, biologia entre outras. Ento, devido a sua usabilidade, ser utilizada a multiplicao de matrizes para demonstrar algumas caractersticas da computao paralela e os benefcios que a programao paralela pode oferecer a esta operao, j que este tipo de funo pode estar presente nos mais diversos programas. Antes de comear a desenvolver um algoritmo paralelo, no caso o de multiplicao de matrizes deve-se verificar o que envolve a multiplicao de matrizes, como ela realizada em ambientes seqenciais e finalmente como se pode obter um nvel de paralelismo neste problema. Uma matriz um arranjo de nmeros (ver figura 10), tal que A uma matriz 2
3 A=( aij ) em que, para i=1,2 e j=1,2,3, o elemento da matriz na linha i e na coluna j aij .

So usadas letras maisculas para denotarem matrizes, e letras minsculas para denotarem

64

linhas e colunas da matriz, fazendo assim referncia aos elementos da matriz.

a11 a12 a13 A= a a a 21 22 23

Figura 10 - Matriz

J a multiplicao de matrizes pode ser descrita da seguinte forma: tm-se duas matrizes A e B que so compatveis no sentido de que o nmero de colunas de A igual ao nmero de linhas de B. Se A=( aij ) uma matriz m n e B=( b jk ) uma matriz n p, ento o produto de matrizes C=AB a matriz m p C=( cik ), em que cik = aij b jk para i=1,2,...,m e
j =1 n

k=1,2,...,p (CORMEN, 2002).

Ento, atravs da descrio de multiplicao de matrizes se pode construir o algoritmo apresentado na figura 11 para realizar esta operao de maneira seqencial. Este algoritmo multiplicando uma matriz nn, executa n 3 multiplicaes e

n 2 (n 1) adies, portanto, pode-se concluir que o tempo de execuo desse algoritmo

(n 3 ) (CORMEN, 2002). Existem outras maneiras para se construir o algoritmo de multiplicao de matrizes de forma seqencial, o algoritmo de Strassem (CORMEN, 2002) apresenta uma proposta recursiva para multiplicar matrizes nn, apresentando um tempo de execuo de (n lg 7 ) = O(n 2,81 ) . Este algoritmo supera, em termos de complexidade, o algoritmo anterior, porm como o algoritmo de Strassem normalmente no o mtodo mais utilizado por programadores para multiplicao de matrizes, ser usado como algoritmo base para os estudos deste trabalho o primeiro algoritmo com tempo (n 3 ) .

65
Multiplica-Matrizes(A,B) n linhas[A] seja C uma matriz nn for i1 to n do for j1 to n do cij 0 for k1 to n do cij cij + aik * bkj return C

Figura 11 - Algoritmo seqencial para multiplicao de matrizes

O algoritmo para a multiplicao de matrizes n n em paralelo, proposto aqui, baseia-se no primeiro modelo seqencial, apresentado no incio da seo, e tem como objetivo obter um desempenho melhor que este. O algoritmo basicamente consiste em subdividir as linhas de uma matriz A em vetores, em que o nmero de vetores igual ao nmero de linhas da matriz (ver figura 12) e o tamanho dos vetores igual ao tamanho das linhas.

Matriz A

Matriz A Sub-dividida

a11

a12 a22

a13 a23 a33

a11 a21

a12 a22

a13 a23 a33

Vetor A1 Vetor A2 Vetor A3

a21

a31

a32

a31

a32

Figura 12 - Diviso da Matriz em Vetores no Programa Mestre

Cada vetor ser multiplicado pelas colunas da matriz B, a qual ser enviada para todos os processadores que compem a arquitetura (atravs da funo sendbc). Ento, para desenvolver esse algoritmo paralelo utilizam-se dois programas um mestre e outro escravo. O programa mestre envia os vetores a serem multiplicados (utilizando a funo send(((char
*)&vetor), sizeof(_vetor),p)

da biblioteca de comunicao do SMS), para os programas

escravos que esto sendo executados independentemente em cada processador. Os programas

66

escravos estaro esperando (atravs da funo recv_be) os vetores para multiplic-los com as colunas da matriz B (figura 13). Aps multiplicar o vetor pelas colunas da matriz B, o programa escravo ir enviar para o n mestre o resultado da multiplicao de cada linha, que neste momento j ser o resultado final referente mesma linha da matriz resposta. O processo mestre ter ento apenas que receber os resultados e atribu-los matriz resposta, construindo desta forma a soluo final da multiplicao (veja figura 14). Portanto, o processo mestre fica encarregado de distribuir cada vetor a ser multiplicado a um determinado programa escravo, que estar sendo executado em um processador independente, em um esquema de memria distribuda, e to logo os processos escravos terminem a multiplicao dos vetores da matriz A pelas colunas da matriz B os resultados sero enviados ao n mestre que ir re-agrupar os resultados obtidos, finalizando assim o trabalho.
Vetor A1 Matriz B

a11

a12

a13

b11 b21

b12 b22

b13 b23 b33

c11

Vetor C1

c12

c13

b31

b32

Figura 13 - Multiplicao dos Vetores pelas Colunas da Matriz B nos Processadores Escravos
Vetores C

Vetor C1 Vetor C2 Vetor C3

c11 c21

c12 c22

c13 c23 c33

Matriz C

c11 c21

c12 c22

c13 c23 c33

c31

c32

c31

c32

Figura 14 - O programa mestre reagrupa os vetores resultantes dos processos escravos

67

Ao analisar o algoritmo paralelo proposto (figura 15) pode-se notar que ele muito semelhante ao algoritmo seqencial, apresentado na figura 11, a principal diferena que ele subdivide o loop que faz a multiplicao das linhas da matriz pelas colunas da outra matriz. Essa subdiviso proporciona que o algoritmo se torne p vezes mais rpido do que o algoritmo seqencial original. Entretanto, ele p vezes mais rpido na rotina de multiplicao, ficando uma parte seqencial sem nenhuma melhora, j que uma parte do cdigo do algoritmo estritamente seqencial, portanto, o tempo de execuo do novo algoritmo paralelo pode ser dado por O(n 3 / p ) . No entanto, este tempo sofre algumas influncias externas e no chega a ser totalmente verdade que ao se usar 2 processadores (p=2) o programa ficar duas vezes mais rpido ou ao se usar 32 processadores (p=32) o programa tornar-se- trinta e duas vezes mais rpido que o programa seqencial. Um dos fatores que influenciam nesta perda de velocidade o tempo de transmisso dos dados na rede de interconexo, ento, ao tempo de execuo pode-se acrescentar um fator chamado t com , que seria o tempo de comunicao entre os elementos que constituem a arquitetura paralela que executa o algoritmo em questo (BADER, 2004). Esse fator afeta diretamente o tempo de execuo. Assim, o algoritmo dever ter o seguinte tempo de execuo O((n 3 / p) + t com ) .

Ou seja, se for possvel controlar o fator t com e reduzir os trechos estritamente seqenciais pode-se ter um ganho de tempo considervel. Depois de implementar o algoritmo de multiplicao de matrizes no ambiente de simulao SMS, foram realizados alguns testes com diferentes tamanhos de matrizes. A figura 14 exibe um resumo do arquivo de sada da simulao do algoritmo de multiplicao de matrizes de tamanho 800x800 utilizando dois processadores, sendo um processador chamado 00 e o outro 01. Se houve n processadores os nmeros que representam

68

os processadores teria uma sada para cada processador, cuja ltima sada seria n-1.

Mestre
01. #include </usr/sms/com.h> 02. struct _matriz matriz; 03. struct _vetor vetor; 04. void main(void) { 06. openchanel(); 07. sendbc(((char *)&matriz),sizeof(_matriz)); 08. recv_be(((char *)&matriz),sizeof(_matriz)); 09. for (i=0;i<N;++i){ 10. for (t=0;t<N; ++t){vetor.X[t]=A[i][t];} 11. vetor.linha=i; 12. send(((char *)&vetor), sizeof(_vetor),p); 13. if (p==P) p=1;else p++; 14. } 15. /*recebe e monta vetores nas matrizes*/ 16. for (i=0;i<N;++i){ 17. recv_be(((char *)&vetor), sizeof(_vetor)); 18. for (t=0;t<N;++t) { 19. C[vetor.linha][t]=vetor.X[t]; 20. }

Escravos
01. struct _matriz matriz; 02. struct _vetor vetor; 03. void main(void){ 04. openchanel(); 05. /*recebe matriz B para suas colunas serem multiplicadas 06. recv_be(((char *)&matriz),sizeof(_matriz)); 07. for (;;){ 08. for(i=0;i<N;++i){ 09. vtaux[i]=0;} 10. recv_be(((char *)&vetor), sizeof(_vetor)); 11. /* realiza a multiplicacao */ 12. for (t=0;t<N;++t){ 13. for (i=0;i<N;++i){ 14. vtaux[t]=vtaux[t]+(vetor.X[i]*matriz.B[i][t]);} 15. } 16. /*atribui os calculos ao vetor para devolver ao mestre*/ 17. for (t=0;t<N;++t){vetor.X[t]=vtaux[t];} 18. /*Envia vetor calculado ao mestre*/ 19. send(((char *)&vetor), sizeof(_vetor),0);

Figura 15 Algoritmo paralelo de multiplicao de matrizes

Apesar da figura 16 no apresentar todas as sadas do arquivo original, possvel analisar vrios aspectos, como nmero de instrues executadas em cada processador, tempo de simulao, total de dados enviados e recebidos, entre outras sadas que foram omitidas. O ganho de desempenho do algoritmo paralelo foi devidamente comparado com o algoritmo seqencial. O algoritmo seqencial foi implementado e testado no simulador SimpleScalar (sim-outourder). Atravs dos dados de simulaes gerados pelo SMS (Figura 16) possvel obter informaes pertinentes sobre a simulao de cada arquitetura testada. Atravs dos testes realizados possvel notar que o algoritmo de multiplicao de matrizes em paralelo obteve um timo ganho de desempenho (ver figura 17, nos grficos de tempo em todo este trabalho a legenda do lado direito informa o nmero de processadores), executando os problemas de forma paralela em um tempo de execuo muito inferior ao algoritmo seqencial. Sendo que os algoritmos executados com um tamanho de problema

69

maior (principalmente o 600x600) tiveram um ganho de tempo muito significativo se comparados com o problema seqencial.
# total simulation time in seconds sim_elapsed_time 53410 # total number of instructions executed sim_total_insn_00 23773083318 sim_total_insn_01 12126038543 # total simulation time in cycles sim_cycle 11878967426 # total number of ocupance cycles inet_ocupance_cycles_00 2560800 inet_ocupance_cycles_01 320400 # total number of bytes received inet_received_bytes_00 5123200 inet_received_bytes_01 3841600 # total number of bytes sended inet_sended_bytes_00 10243200 inet sended bytes 01 1281600

Figura 16 Sada reduzida de uma simulao no SMS

O algoritmo de multiplicao de matrizes desenvolvido neste trabalho emprega tcnicas de paralelismo de dados. O que significa que os processadores escravos executam a mesma operao sobre dados diferentes para resolver um dado problema. Conforme foi constatado no captulo 4, sobre programao paralela, esse tipo de algoritmo altamente paralelo e apresenta timos resultados, o que pode ser observado na figura 15. Por fim, tem como caracterstica marcante o fato de que quanto maior o problema melhor o desempenho. A partir da figura 18 so apresentados resultados referentes ao speedup e eficincia. Nos grficos de speedup e eficincia, a legenda do lado direito de cada figura representa o tamanho do problema simulado. Para o speedup mostrado na figura 18, nota-se que todos os problemas obtiveram ganhos de desempenhos substanciais, sobressaindo mais uma vez os problemas de maior

70

tamanho. Isso demonstra tambm a enorme relao que existe entre a arquitetura paralela, o software a ser executado nesta arquitetura e o tamanho do problema, sendo que todos estes influenciam diretamente o ganho de desempenho da arquitetura.
Multiplicao de Matrizes 50x50
16 Tempo em segundos 12 10 8 6 4 2 0 Processadores 1 2 4 8 16 32 Tempo em segundos 14 160 140 120 100 80 60 40 20 0 Processadores 1 2 4 8 16 32

Multiplicao de Matrizes 100x100

Multiplicao de Matrizes 600x600

40000 Tempo em segundos 30000 25000 20000 15000 10000 5000 0 Processadores 1 2 4 8 16 32 Tempo em segundos 35000 90000 80000 70000 60000 50000 40000 30000 20000 10000 0

Multiplicao de Matrizes 800x800

1 2 4 8 16 32

Processadores

Figura 17 Tempo de execuo do algoritmo de multiplicao de matrizes

Multiplicao de Matrizes
30 25 Speedup 20 15 10 5 0 1 2 4 8 16 32 Processadores 50x50 100x100 600x600 800x800

Figura 18 - Speedup apresentado pelo algoritmo paralelo de multiplicao de matrizes

71

A queda apresentada no grfico (figura 18) do speedup, nos problemas de tamanho 50x50 e 100x100, ocorre devido a fatores de granularidade do algoritmo e de
overhead na rede de interconexo. Provavelmente, se fosse utilizada uma rede mais eficiente

o algoritmo obteria ganhos de desempenhos melhores, mas no seriam ganhos timos j que o problema de granularidade neste caso seria o principal fator pela perda de desempenho. Assim, para um timo ganho de desempenho ser necessria a implementao de um algoritmo que permita uma granularidade de dados menor e que aproveite melhor a arquitetura, no deixando processadores ociosos, como est ocorrendo no algoritmo de multiplicao de matrizes que foi implementado. Quanto ao fator eficincia, a figura 19 mostra que apesar dos fatores: tempo de execuo e speedup apresentarem bons ganhos de desempenho, existe uma queda de eficincia da arquitetura quando esta submetida a qualquer problema usando apenas 2 processadores. No entanto, quando os problemas foram submetidos a testes com 8 ou 16 processadores, o sistema passou atingir bons picos de eficincia, voltando a cair quando se usou 32 processadores, principalmente nos menores problemas (50x50 e 100x100).
Multiplicao de Matrizes
1,8 1,6 1,4 1,2 1 0,8 0,6 0,4 0,2 0 1 2 4 8 16 32 Processadores

Eficincia

50x50 100x100 600x600 800x800

Figura 19 Eficincia apresentada pelo algoritmo paralelo de multiplicao de matrizes

72

Portanto, em uma anlise mais refinada verifica-se que se fosse necessrio implantar uma arquitetura real (com as mesmas caractersticas fsicas simuladas) para resolver este problema, seria uma tima opo a construo de um computador paralelo com 8 processadores. J que a maioria dos problemas testados atingiu seu pico de desempenho e eficincia com esta configurao. E apesar da arquitetura continuar apresentando ganhos de desempenho com 16 processadores, tal arquitetura no seria recomendada, pois seria necessrio dobrar o nmero de processadores para atingir ganhos de desempenhos insatisfatrios e que no proporcionariam uma boa relao custo/beneficio. Apesar de existirem inmeros outros algoritmos de multiplicao de matrizes em paralelo (OLEARY, 1985; BAGRODIA, 1991; CHOI, 1998), o algoritmo paralelo apresentado neste trabalho suficiente para demonstrar de forma simples como se paralelizar um algoritmo e permite analisar caractersticas importantes de arquitetura e tambm da prpria aplicao. Por fim, os testes com o programa mostraram-se muito satisfatrios e apresentaram resultados muito semelhantes aos obtidos em problemas de multiplicao de matrizes apresentados em outros trabalhos (CHOI, 1998; OLEARY, 1985; LAINE, 2003).

6.2

Algoritmo Paralelo para Clculo do

(pi) um dos nmeros mais empregados na matemtica e representa a relao

do comprimento L de uma circunferncia e o dimetro d da mesma. O um nmero irracional expresso por uma dzima infinita no peridica. A busca incansvel por esse nmero surgiu devido ao fato dele estar ligado a dois problemas fundamentais do universo matemtico, que so: o problema de retificao da circunferncia e da quadratura do crculo. A busca por esse valor transcende pocas, desde as civilizaes Babilnicas e

73

Egpcias antes de Cristo at os dias atuais. Atualmente os matemticos que buscam um valor mais preciso para o utilizam computadores, e j conseguiram calcul-lo com uma preciso de aproximadamente 1000 bilionsimos de dgitos binrios, este nmero foi obtido aps 25 dias de clculos intensivos em um cluster desenvolvido pela Universidade Simon Franser. A utilizao de um cluster para o clculo do indica o uso de tcnicas de paralelismo para a resoluo deste problema, e nesta seo ser discutida a implementao de um algoritmo paralelo para o clculo do atravs das bibliotecas de comunicao fornecidas pelo simulador SMS. Existem diversas maneiras de se calcular o , tais como: srie de Fourier, Mclaurin, Taylor e via integrao. O mtodo utilizado para a construo do algoritmo aqui proposto ser o de integrao, cuja frmula pode ser vista na figura 20. Para se determinar o valor de ser utilizado o clculo da rea gerada pela funo em um nmero finito de intervalos. Para tanto, a regra de decomposio do retngulo utilizada. A regio x dividida de 0 a 1 em n pontos. O valor da funo calculado no ponto mdio de cada intervalo. Os valores so somados e multiplicados pelo comprimento de um intervalo (MENEGHETTI, 2004).

4 1+ x2 0

Figura 20 - Frmula para calcular o valor de

Para a implementao do algoritmo de forma paralela a rea da curva a ser calculada dividida pelo nmero de processadores p. Portanto, cada processador ir calcular uma fatia do valor de , que ser um valor parcial (figura 21b). E no final todos os s parciais sero enviados para o processo mestre, que ir somar os valores parciais, calculando desta forma o valor do global (figura 21a).

74

Entrada: N iteraes N, Total de processadores TP. Sada: Valor global de pi_global send_bc(N,TP) for (x=1; x<=TP; x++) recv_be(pi) pi_global=pi_global+pi mostra (pi_global)

Entrada: Nmero do processador NP. Sada: Valor parcial de recv_be(N,TP) w = 1.0/n for (i=NP; i<=N; i=i+TP) x = w * (i 0,5) pi = pi + (4.0 / (1.0 + (x * x))) pi = pi * w send(pi)

(a)

(b)
Figura 21 - Programa escravo do clculo do

A parte fundamental para que esse algoritmo funcione de forma paralela a diviso das iteraes, tal diviso ocorre no lao de repetio (for (i=NP; i<=N; i=i+TP)), no qual o valor da varivel i jamais ir se repetir em nenhum processo escravo na funo x = w *
(i 0,5). Caso o valor da varivel i se repita nos processos paralelos o clculo do ser

apresentado de forma errada devido s propriedades do clculo do via integral. O algoritmo do clculo do naturalmente paralelo, devido s propriedades utilizadas pela funo da integral utilizada para calcular o (WILKINSON, 1999). O algoritmo faz uso dos canais de comunicao apenas no incio do processo enviando o total de iteraes (n) e o nmero total de processadores a serem utilizados para o processamento e, ao final do processo envia apenas o resultado parcial (figura 21b), que computado no processador mestre (figura 21a). Devido a essas peculiaridades de processamento totalmente independente e pouca necessidade de comunicao o algoritmo de clculo do via integral atinge um bom speedup (figura 22).

75

Clculo do pi
16 14 12 10 8 6 4 2 0 1 2 4 8 16 32 Processadores

Speedup

10.000 20.000 100.000 1.000.000

Figura 22 - Speedup do algoritmo paralelo do clculo do

Analisando a figura 23, que faz referencia ao tempo de execuo possvel perceber que neste problema conforme aumenta-se o nmero de processadores diminui-se o tempo de execuo, isso devido s propriedades do algoritmo discutidas anteriormente. Quanto a eficincia, a figura 24 mostra que a forma mais eficiente de se executar tal problema com apenas um nico processador, entretanto devemos levar em conta os resultados do speedup e tempo de execuo que demonstram que apesar da arquitetura no mostrar-se totalmente eficiente ela apresentou ganhos substanciais de desempenho, chegando em alguns casos a reduzir pela metade o tempo de execuo. Desta forma, apesar desta arquitetura apresentar uma baixa eficincia para a resoluo deste problema, ainda assim vivel o uso da computao paralela, j que o tempo economizado relativamente grande, alm do que, se for necessrio aumentar o tamanho do problema futuramente, tal arquitetura provavelmente apresentar um maior ndice de eficincia (ZHANG, 1994).

76
Clculo do pi (n=10.000)
70 Tempo em segundos 1 2 4 8 16 32 Tempo em segundos 60 50 40 30 20 10 0 Processadores 140 120 100 80 60 40 20 0 Processadores 1 2 4 8 16 32

Clculo do pi (n=20.000)

Clculo do pi (n=100.000)
700 Tempo em segundos 1 2 4 8 16 32 Tempo em segundos 600 500 400 300 200 100 0 Processadores 8000 7000 6000 5000 4000 3000 2000 1000 0

Clculo do pi (n=1.000.000)

1 2 4 8 16 32

Processadores

Figura 23 Tempo de execuo do algoritmo do clculo do

Clculo do pi
1,2 1 Eficincia 0,8 0,6 0,4 0,2 0 1 2 4 8 16 32 Processadores 10.000 20.000 100.000 1.000.000

Figura 24 Eficincia apresentada pelo algoritmo do clculo do

6.3

Algoritmo Trapezoidal Rule

Um algoritmo muito semelhante ao algoritmo do o Trapezoidal rule, que

77

calcula integral atravs do uso de trapzios. Tal algoritmo foi descrito em detalhes por Pacheco (PACHECO, 1997), para demonstrar o uso da biblioteca MPI neste trabalho ser tambm usado esse mesmo algoritmo com a biblioteca SMS. Sendo possvel ento notar algumas semelhanas e diferenas entre o SMS e o MPI. Pode-se determinar a integral de um ponto a para b em uma funo no negativa
f(x) atravs da rea restrita por um eixo x, onde x=a e x=b. O grfico desta funo pode ser

visto na figura 25 (PACHECO, 1997).

f(x)

f ( x)dx

Figura 25 - Definio de integral de uma funo no negativa (PACHECO, 1997)

Uma forma de se estimar a rea ou integral dividir a regio em figuras geomtricas, neste caso em trapzios, sendo que cada trapzio a base do eixo x, e em seu pice existem dois pontos que juntam a figura (ver figura 26). Todas as bases dos trapzios tm o mesmo tamanho, ento com n trapzios cada base ter o tamanho de h=(b-a)/n. Assim, o primeiro trapzio da esquerda ter um intervalo de [a,a+h], e o prximo ter [a+h,a+2h], de forma que o (ith) i-ensimo ser [a+(i1)h, a +ih], i=1,..., n. Pode-se simplificar tal notao de forma que xi denota a+ ih, i=0,...,n.

Ento o tamanho do lado esquerdo do i-ensimo trapzio ser f ( xi 1) , e o lado esquerdo ser f ( xi ) , conforme figura 27.

78

f(x)

Figura 26 - Usando integral para definir trapzios (PACHECO, 1997)

Assim, a rea do trapzio dada por:

figura dada pela soma de todos os trapzios:

1 h[ f ( xi 1 ) + f ( xi )] , e a rea total da 2

1 1 1 h[ f ( x0 ) + f ( x1 )] + h[ f ( x1 ) + f ( x2 )] + ... + h[ f ( xn1 ) + f ( xn )] 2 2 2 h = [ f ( x0 ) + 2 f ( x1 ) + 2 f ( x2 ) + ... + f ( xn )] 2 = [ f ( x0 ) / 2 + f ( xn ) / 2 + f ( x1 ) + f ( x2 ) + ... + f ( xn1 )]h

y f ( xi 1 )
f ( x)

f ( xi ) xi 1

h xi x

Figura 27 Trapzio (PACHECO, 1997)

Pacheco (PACHECO, 1997) prope um mtodo de paralelizao para este

79

algoritmo que consiste em distribuir os dados entre os processadores (Partitioning Data), e cada processador executa exatamente o mesmo processo sobre dados diferentes. No caso do Trapezoidal rule especificamente cada processador ir computar um intervalo entre [a,b] e o nmero de trapzios n. O algoritmo utilizando MPI pode ser visto na figura 28.
1. #include "mpi.h" 2. double Trap(double local_a, double local_b, int local_n, double h); 3. double f(double x); 4. int main(int argc, char** argv) { 5. MPI_Status status; 6. MPI_Init(&argc, &argv); 7. MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); 8. MPI_Comm_size(MPI_COMM_WORLD, &p); 9. h = (b-a)/n; /* h o mesmo em todos os processadores */ 10. local_n = n/p; /* nmero de trapezoids por ns */ 11. local_a = a + my_rank*local_n*h; 12. local_b = local_a + local_n*h; 13. integral = Trap(local_a, local_b, local_n, h); 14. if (my_rank == 0) { 15. total = integral; 16. for (source = 1; source < p; source++) { 17. MPI_Recv(&integral, 1, MPI_DOUBLE, source, tag, MPI_COMM_WORLD, &status); 18. total = total + integral; } 19. } else { 20. MPI_Send(&integral, 1, MPI_DOUBLE, dest, tag, MPI_COMM_WORLD); } 21. if (my_rank == 0) { 22. printf("With n = %d trapezoids, our estimate\n",n); 23. printf("of the integral from %f to %f = %23.16e\n", a, b, total); } 24. MPI_Finalize(); 25. return 0; }

Figura 28 Cdigo do algoritmo Trapezoidal rule com MPI (PACHECO, 1997)

Observando o cdigo do trapezoidal rule escrito para MPI tem-se da linha 1 a 3 a declarao da biblioteca de comunicao e variveis teis ao programa, das linhas 5 a 8 temse o uso especfico de funes MPI, na linha 7 tem-se uma funo que atribui varivel my_rank o nmero de cada processador, j a linha 8 atribui varivel p o nmero total de processadores, tais dados so importantes para se construir os intervalos a serem computados pelos processadores. Posteriormente, no cdigo (linhas 9 a 13) so realizados clculos pertinentes funo trapezoidal rule que fazem justamente o clculo referente aos subvalores de integral de cada processador. Por fim, na linha 14 o programa difere o processador mestre dos escravos, isso necessrio j que o MPI normalmente faz uso de um nico cdigo

80

fonte tanto para o processador mestre quanto para os escravos. Neste caso, se o processo for o mestre (my_rank for igual a zero) ele ir atribuir o valor calculado por ele varivel de armazenamento global (linha 15), em seguida aguardar que os processadores escravos enviem seus resultados (linha 17) para serem tambm somados varivel global (linha 18). Aps todos esses passos, o n mestre apresenta o resultado obtido (linhas 21 a 23) e finaliza o programa, bem como o uso da biblioteca MPI (linha 24). Para mostrar a eficincia e o grau de realismo proporcionado pela biblioteca SMS, o algoritmo trapezoidal rule apresentado anteriormente foi reproduzido, de forma muito semelhante ao algoritmo em MPI. Tal cdigo pode ser observado na figura 29. O simulador SMS possibilita que o programa a ser paralelizado seja executado com dois cdigos distintos, sendo um para o mestre e o outro para o escravo, mas possvel desenvolver tal cdigo utilizando apenas um cdigo para o mestre o e escravo (como neste caso). O cdigo do Trapezoidal rule utilizando o SMS inicia com a declarao da biblioteca SMS (linha 01) e logo em seguida faz a declarao de estruturas usadas para a passagem de mensagem dentro do simulador (linhas 02 a 11). Na linha 15 utilizada a funo que sincroniza todos os processadores para dar incio execuo do programa. Devido a biblioteca SMS no possuir uma funo para identificar o nmero de cada processador faz-se necessrio que o processador mestre identifique cada processador (linhas 17 a 22), claro que isso atribui um pouco de trfego inicial na rede de comunicao, mas de extrema importncia para o funcionamento correto do programa, quanto obteno do nmero total de processadores, isso pode ser feito atribuindo tal valor varivel p durante a programao (linha 16). O restante do programa muito parecido com o programa em MPI, exceto pelo fato de que para enviar e receber as integrais parciais, o programa faz uso das funes send e recv_be do SMS, que passa tais valores atravs das estruturas declaradas anteriormente. As funes Trap e f foram omitidas, mas so as mesmas do algoritmo em MPI.

81

01. 02. 03. 04. 05. 06. 07. 08. 09. 10. 11. 12.

#include </usr/sms/com.h> struct _rank { // estrutura que informa passar o nmero do processador int meu; } _rank; struct _integral { // double num; /* intervalo integral - local */ } _integral; struct _integral integral; struct _rank rank; double Trap(double local_a, double local_b, int local_n, double h); /* Calcula a integral local */ 13. double f(double x); 14. int main(int argc, char** argv) { 15. openchanel(); /*sincroniza os processos mestre e escravo*/ 16. p=1; //numero do processador 17. for (i=0; i<p; i++) 18. {// determinar o rank de cada processador 19. rank.meu=i; 20. send(((char *)&rank), sizeof(_rank),i); 21. recv(((char *)&rank), sizeof(_rank)); } 22. my_rank=rank.meu; 23. if (rank.meu==0) {printf("Eu sou %d\n", rank.meu);} 24. else {printf(">Eu sou %d escravo\n", rank.meu);} 25. recv(((char *)&rank), sizeof(_rank)); 26. h = (b-a)/n; /* h is the same for all processes */ 27. local_n = n/p; /* So is the number of trapezoids */ 28. local_a = a + my_rank*local_n*h; 29. local_b = local_a + local_n*h; 30. integral.num = Trap(local_a, local_b, local_n, h); 31. if (my_rank == 0) { 32. total = integral.num; 33. for (source = 1; source < p; source++) { 34. recv_be(((char *)&integral), sizeof(_integral)); 35. total = total + integral.num; } 36. } else { 37. send(((char *)&integral), sizeof(_integral),dest); } 38. if (my_rank == 0) { 39. printf("With n = %d trapezoids, our estimate\n", n); 40. printf("of the integral from %f to %f = %23.16e\n", a, b, total); } 41. return 0; }

Figura 29 - Cdigo do algoritmo Trapezoidal rule com SMS

Com essa demonstrao fica claro que diferenas existem entre o SMS e o MPI, porm so mnimas, e o objetivo principal atingido, j que o mesmo programa que executado em um ambiente real como o MPI, pode ser facilmente reconstrudo usando-se rotinas do SMS. Aps construir o algoritmo e testar no simulador, inmeros dados pertinentes

82

execuo do programa so obtidos. Usando esses dados possvel obter grficos que mostram o tempo de execuo dos problemas frente aos processadores e analisar o quo melhor se tornou ou no o sistema. Observando a figura 30 possvel obter-se uma impresso positiva da execuo do algoritmo trapezoidal rule frente s arquiteturas testadas, sendo que na maioria dos casos foram obtidos ganhos de tempo de aproximadamente cinqenta por cento em relao s arquiteturas anteriores, como por exemplo, no problema com 2.000.000 de interaes o tempo do algoritmo com apenas 1 processador de 170 segundos, ao se acrescentar mais um processador a esta arquitetura obteve-se um tempo de execuo de 88 segundos, um ganho de tempo de aproximadamente 49%, dobrando mais uma vez o nmero de processadores da arquitetura obteve-se um ganho de 74% em relao a arquitetura com apenas um processador e exatamente 50% de ganho de tempo se comparado com a arquitetura com 2 processadores. Essa mdia de 50% de ganho se mantm at a arquitetura com 16 processadores. Porm a arquitetura com 32 processadores teve um ganho de tempo de 36% em relao a arquitetura de 16 processadores, mas mesmo assim teve um ganho de tempo de aproximadamente 95% em relao a arquitetura com apenas um processador. A figura 31 que apresenta o speedup, representa fielmente o ganho de desempenho apresentado pelos grficos de tempo. Mas possvel notar ainda que o menor problema possui uma queda na acelerao quando a arquitetura utiliza 32 processadores, isso se d devido ao tamanho do problema (que pequeno neste caso). Neste caso a granularidade do problema muito pequena causando muito overhead na rede (LU, 1998). Com a visualizao do speedup possvel concluir que existe um bom aumento de desempenho conforme se aumenta o nmero de processadores. Entretanto, se for visualizado o grfico referente eficincia (figura 32) possvel notar que nem todas as arquiteturas so totalmente eficientes, sendo que apenas a arquitetura de 16 processadores

83

mostrou que consegue atingir uma tima relao entre o ganho de desempenho e o nmero de processadores empregados para tal acelerao.

Trapezoidal Rule (n=250.000)

25 Tempo em Segundos 20 15 10 5 0 Processadores 1 2 4 8 16 32 Tempo em Segundo 70 60 50 40 30 20 10 0

Trapezoidal Rule (n=750.000)

1 2 4 8 16 32

Processadores

Trapezoidal Rule (n=1.000.000)

90 80 70 60 50 40 30 20 10 0 Processadores 180 160 140 120 100 80 60 40 20 0

Trapezoidal Rule (n=2.000.000)

1 2 4 8 16 32

Tempo em Segundos

Tempo em Segundos

1 2 4 8 16 32

Processadores

Trapezoidal Rule (n=4.000.000)

400 Tempo em Segundos 350 300 250 200 150 100 50 0 Processadores 1 2 4 8 16 32

Figura 30 Tempo total de execuo do Trapezoidal rule

84

Trapezoidal Rule
35 30 25 Speedup 20 15 10 5 0 1 2 4 8 16 32 Processadores 250.000 750.000 1.000.000 2.000.000 4.000.000

Figura 31 Speedup Trapezoidal rule

Trapezoidal Rule
1,4 1,2 Eficincia 1 0,8 0,6 0,4 0,2 0 1 2 4 8 16 32 Processadores 250.000 750.000 1.000.000 2.000.000 4.000.000

Figura 32 Eficincia do algoritmo Trapezoidal rule frente a arquitetura

6.4

Algoritmo para testes da Rede de Interconexo do Simulador SMS

Numa arquitetura paralela, a rede de interconexo tem papel fundamental sobre o desempenho de todo sistema paralelo. Neste contexto, relevante que a ferramenta de simulao viabilize a investigao da arquitetura simulada em funo da rede de interconexo. Tanto a taxa de transmisso e o protocolo de controle da rede de interconexo

85

podem se tornar gargalos de desempenho para a arquitetura paralela (MATHESON, 1996; PATTERSON, 2000). Portanto, o estudo sobre as tecnologias de transmisso de dados em redes de interconexo extremamente relevante em ambientes paralelos, pois a rede tem influncia direta sobre o desempenho das aplicaes. Desta forma, importante que o projetista de sistema paralelo possa testar no simulador qual rede de interconexo mais adequada para a resoluo de seu problema. Existem inmeras possibilidades para se configurar uma rede de interconexo. No que ser refere topologia possvel encontrar diversas configuraes como: rvore, barramento, estrela, hiper-cubo, crossbar, malha, entre outras. Outro fator extremamente importante no quesito rede a tecnologia empregada para a transmisso de dados (alguns exemplos so: Ethernet, Fast-Ethernet, Gigabit-Ethernet, ATM, etc). Atravs dessas caractersticas pode-se ainda mesclar as topologias com as tecnologias de transmisso, isso proporciona uma imensa gama de configuraes. E utilizando-se a ferramenta SMS possvel simular e analisar essas diversas configuraes e identificar a rede de interconexo mais adequada para a resoluo de um determinado problema. Da mesma forma, necessrio que haja algoritmos que viabilizem testes para a rede de interconexo utilizada na ferramenta SMS. O primeiro algoritmo implementado com este fim chamado de Round-Trip, que um algoritmo que mede a taxa de transferncia dos dados na rede de interconexo do simulador. O programa basicamente consiste em um programa mestre (figura 33a) e outro escravo (figura 33b). A tarefa do programa mestre de enviar uma mensagem contendo um nmero qualquer de bytes para o programa escravo, o qual ir receber essa mensagem atravs de uma primitiva de comunicao de recebimento e imediatamente reenviar a mesma mensagem para o programa mestre, o qual ir contabilizar o tempo total do trfego da

86

mensagem. Tal programa muito utilizado para realizao de testes em redes de interconexes reais usando MPI.
Entrada: Tamanho em bytes da mensagem. Sada: Taxa de transmisso da rede de interconexo em bytes por segundo (bps) T1=tempo inicial; Msg= 1000; // bytes Send (msg, escravo); Recv_be(msg); T2=tempo final; Tempo_total=T2-T1; Calcula taxa de taxa de trasferencia(); Mostra taxa de transferncia em bps. Entrada: msg (mensagem do mestre) Sada: msg (mensagem par o mestre) Recv_be(msg); Send (msg, mestre);

(a)
Figura 33 - Algoritmo de Round-Trip

(b)

Aps a implementao do Round-Trip, o programa foi testado no simulador utilizando topologia em barramento. Nos testes realizados, foram alteradas as freqncias dos ciclos que a interface de rede (nmero de ciclos de clock em relao ao processador) utiliza para passar a informao pela rede de interconexo. A freqncia em questo (que ser chamada de fc) a relao dos ciclos necessrios para enviar os dados de uma mensagem pela rede, ou seja, se for colocado um valor igual a 1 (fc=1), a rede ir demorar apenas um ciclo de clock para enviar a mensagem, ao passo que se o valor de fc for igual a 10, a mensagem levar 10 ciclos de clock para ser enviada. importante notar que quanto menor fc mais rpida ser a taxa de transmisso da rede e conseqentemente quanto maior for o valor de fc mais lenta ser a taxa de transferncia dos dados em relao ao processador. Observando-se a tabela 3, possvel notar que utilizando freqncias menores o simulador apresenta taxas de transferncias maiores. J com uma freqncia muito alta, a rede passa a ter uma taxa de transferncia menor que 1Mbps.

87
Bytes msg 1.000 fc 1 2 3 4 5 10 20 30 100 200 10.243.802 5.799.589 4.086.971 3.013.319 2.535.703 1.312.808 0.650653 0.440441 0.135112 0.067977 11.046.794 5.829.884 4.193.892 3.084.535 2.557.434 1.283.974 0.667792 0.437780 0.137166 0.068447 bps 11.794.191 6.308.472 4.302.806 3.208.439 2.541.619 1.313.513 0.627479 0.444038 0.112469 0.069002 2000 4000

Tabela 3 - Taxa de transferncia da rede de interconexo em bytes por segundo

Os testes realizados com a rede de interconexo demonstram que a rede presente no simulador, desempenha seu papel no envio e recebimento de mensagens. Entretanto, necessrio que novas redes sejam implementadas possibilitando novos testes com redes de interconexo com diferentes topologias, protocolos de controle e taxas de transmisso.

6.5

Algoritmo de ordenao Odd-Even

muito comum tanto em aplicaes cientficas quanto comerciais a utilizao de mtodos de ordenao de dados. Desta forma o estudo sobre paralelizao de algoritmos de ordenao muito pertinente, e da mesma maneira faz-se necessrio testar o desempenho de tais algoritmos nas mais diversas plataformas de computao paralela, para que se obtenha um consenso de qual algoritmo mais indicado em determinadas situaes (FRANCIS, 1988). Define-se como um algoritmo de ordenao, o que contenha funes para rearranjar uma lista desordenada de elementos de maneira que tais elementos fiquem ordenados de forma crescente ou decrescente (WILKINSON, 1999). Portanto, temos

88

S =< a1 , a2 ,..., an > que uma seqncia arbitrria de elementos, a ordenao colocar, por
' ' exemplo, essa seqncia de forma crescente em que S ' =< a1' , a2 ,..., an > , de forma que

ai' a 'j para 1 i j n, e S uma permutao de S (GRAMA, 2003).

Um exemplo de algoritmo de ordenao bem simples e muito utilizado em programao seqencial o Bubble Sort, no qual o maior nmero da lista a ser ordenada movido para baixo utilizando operaes de comparao e troca. Na ordenao Bubble Sort, existe uma seqncia de nmeros x0 , x1 , x2 ,..., xn1 , primeiro x0 e x1 so comparados e o maior movido para x1 e conseqentemente o menor ir ocupar a posio x0 . Ento x1 e x2 so comparados e o x2 ir receber o maior nmero, essa operao ser realizada at se atribuir o maior nmero posio xn1 . Desta forma, com n nmeros so necessrias n-1 operaes de comparaes e trocas para se ordenar o arranjo, sendo que na primeira fase o algoritmo ir posicionar o maior nmero no final da lista (n-1) e na prxima fase o segundo maior nmero ser atribudo posio (n-2). O cdigo seqencial pode ser observado na figura 34. O algoritmo Bubble Sort estritamente seqencial, portanto fica difcil paralelizar tal algoritmo, uma sugesto para a paralelizao deste algoritmo a utilizao do mtodo de decomposio pipeline.
Para (i=n-1; i>0; i--) Para (j=0; j<i; j++) { K=j+1; if (a[j] > a[k]) { temp=a[j] a[j]=a[k] a[k]=temp } }

Figura 34 - Algoritmo Bubble Sort

89

Um outro algoritmo bem semelhante ao Bubble, porm mais fcil de paralelizar, o Odd-Even Sort. Este algoritmo, utiliza duas fases para ordenao: uma fase mpar e outra par. Na fase mpar os nmeros situados na posio mpar so comparados com seus vizinhos da direita, e da mesma forma na fase par os nmeros situados na posio par da lista a ser ordenada so comparados com os seus vizinhos da direita. O cdigo do algoritmo Odd-Even mostrado na figura 35. O algoritmo Odd-Even ordena n elementos em n fases (sendo n mpar), cada qual requer n/2 operaes de comparao e troca. O algoritmo funciona da seguinte forma, sendo S =< a1 , a2 ,..., an > a seqncia a ser ordenada. Durante a fase mpar os elementos (a1 , a2 ) , (a3 , a4 ) , (a5 , a6 ) , ..., (an1 , an ) so comparados e trocados. Similarmente, na fase par compara-se e troca-se os elementos (a2 , a3 ) , (a4 , a5 ) , (a6 , a7 ) , ..., (an2 , an1 ) . Por fim, depois de n fases os elementos estaro ordenados (ver figura 36). Uma forma de se paralelizar este processo de ordenao consiste em executar as fases pares em paralelo e depois as fases mpares. Sendo que, durante a fase mpar, apenas os processadores mpares e seus vizinhos direita iro fazer o processo de comparao e troca, j na fase par apenas os processadores identificados como par iro fazer a comparao e troca entre seus vizinhos da direita.
Send(A, Pi -1) Recv(B, Pi -1) If (A<B) A=B If (i<=n-3) { Send(A, Pi +1) Recv(A, Pi +1) If (A>B) A=B }
a) programa n

Send(A, Pi +1) Recv(B, Pi +1) If (A<B) A=B If (i<=2) { Recv(A, Pi -1) Send(A, Pi -1) If (A>B) B=A }
b) programa n+1

Figura 35 - Algoritmo de ordenao Odd-Even

90

Passos P0 0 1

P1

P2

P3

P4

P5

P6

P7

4 2 2 2 2 1 1 1

2 4 4 4 1 2 2 2

7 7 7 1 4 3 3 3

8 8 1 7 3 4 4 4

5 1 8 3 7 5 5 5

1 5 3 8 5 7 6 6

3 3 5 5 8 6 7 7

6 6 6 6 6 8 8 8

Tempo

2 3 4 5 6 7

Figura 36 - Processo de ordenao utilizando algoritmo Odd-even (GRAMA, 2003)

O algoritmo de ordenao Odd-Even proposto para o simulador SMS, segue o mesmo princpio. Com a diferena de que o arranjo ser dividido pelo nmero de processadores (n/p), em que n e p so mltiplos de dois. Cada n ento conter um subarranjo, durante a fase mpar, os ns iro enviar seus sub-arranjos para seus vizinhos direita e os seus vizinhos direita iro da mesma forma enviar seus sub-arranjos para seus vizinhos mpares da esquerda. Em posse desses sub-arranjos cada n que compe a operao mpar ir ordenar os dois sub-arranjos da seguinte forma: o n mpar ir ficar com os menores elementos que compem os dois sub-arranjos, e o vizinho direita deste n mpar ir ficar com os maiores elementos dos dois sub-arranjos (ver figura 37). O mesmo ocorre na fase par do algoritmo. Esse algoritmo executado em p passos (em que p igual ao nmero de processadores). O algoritmo de ordenao Odd-Even proposto para o SMS, tem como caracterstica marcante o intenso uso da rede de interconexo, desta forma ele altamente recomendado para testes com a rede de interconexo, j que faz uso constante da rede de interconexo para transferir os sub-arranjos a serem ordenados. A complexidade deste

91

algoritmo

apresentada

por

(GRAMA,

2003)

executada

em

6 4 74 8 comparao comunicao } n n } Tp = log + ( n ) + (n) , desta forma o tempo do algoritmo ((n/p)log(n/p)). p p

ordenao _ local

P1
3 9 4 2 6

P2
9 1 5 8

P3
3 6 9 0

P4
2 7 8

FASE 1

FASE 2

FASE 3

FASE 4

Figura 37 - Ordenao por Odd-Even utilizada no SMS (GRAMA, 2003)

Foram realizados vrios testes com o algoritmo de ordenao Odd-Even. O algoritmo ordenou chaves com os seguintes nmeros: 2.048, 4.096, 8.192, 16.384, 32.768 e 65.536. Analisando-se os grficos de tempo (figura 38) decorrido para ordenao das chaves possvel observar que em comparao com a arquitetura com um nico processador a arquitetura paralela com dois processadores teve um ganho de desempenho de aproximadamente 50% em todas as arquiteturas simuladas (que so: 1, 2, 4, 8, 16 e 32). Porm, as arquiteturas paralelas com 4, 8, 16 e principalmente 32 processadores no mantiveram o mesmo nvel de ganho de tempo da arquitetura com 2 processadores, chegando at mesmo no caso mais extremo (32 processadores) a obter um tempo pior do que o obtido pela arquitetura anterior (16 processadores). A queda de desempenho na ordenao entre as arquiteturas de 16 e 32 processadores pode ser vista na figura 39 que representa o speedup. Analisando essa figura

92

possvel notar que todas as arquiteturas obtiveram ganhos de desempenho exceto a de 32 processadores que apresenta queda de desempenho. Este pior caso se d por conta do algoritmo usar muito a rede de interconexo sendo necessrio a comunicao de 32 processos para executar a ordenao, o que evidentemente aumenta o overhead da rede. A figura 40 confirma os dados anteriores mostrando de que a arquitetura no se adapta adequadamente a este algoritmo principalmente com os tamanhos de problemas testados, a eficincia apresenta quedas constantes cada vez que se aumenta o nmero de processadores arquitetura.
Odd-Even Sort (n=2048)
8 Tempo em Segundos 6 5 4 3 2 1 0 Processadores 1 2 4 8 16 32
Tempo em Segundos 16 14 12 10 8 6 4 2 0 Processadores 1 2 4 8 16 32

Odd-Even Sort (n=4096)

Odd-Even Sort (n=8192)

40 Tempo em Segundos 30 25 20 15 10 5 0 Processadores 1 2 4 8 16 32 Tempo em Segundos 35 90 80 70 60 50 40 30 20 10 0

Odd-Even Sort (n=16384)

1 2 4 8 16 32

Processadores

Odd-Even Sort (n=32768)

200 Tempo em Segundos 150 100 50 0 Processadores 1 2 4 8 16 32 Tempo em Segundos 450 400 350 300 250 200 150 100 50 0

Odd-Even Sort (n=65536)

1 2 4 8 16 32

Processadores

Figura 38 Tempo total de execuo do Odd-Even sort

93

Odd-Even Sort
10 8 Speedup 6 4 2 0 1 2 4 8 16 32 Processadores 2048 4096 8192 16384 32768 65536

Figura 39 Speedup do Odd-Even sort

Odd-Even Sort
1,2 1 Eficincia 0,8 0,6 0,4 0,2 0 1 2 4 8 16 32 Processadores 2048 4096 8192 16384 32768 65536

Figura 40 Eficincia do Odd-even sort

Tais informaes demonstram a ineficincia do algoritmo, j que este utiliza de forma muito constante a rede de interconexo e demanda pouco processamento. Tal informao pode ser melhor representada pela figura 41, que mostra o grande uso da rede interconexo pelos processadores. possvel notar o funcionamento do algoritmo no qual os ns das extremidades so os que trocam menos informaes que os demais ns que compem a arquitetura (figura 37). Uma melhor comparao do uso intenso da rede de interconexo

94

possvel se for comparado o grfico de uso da rede do algoritmo Odd-Even (figura 41) com o algoritmo do clculo do pi (figura 42). Sendo que o algoritmo do pi utiliza o n mestre para enviar informaes iniciais aos escravos e depois recebe todas as informaes no final da execuo do algoritmo, o que claramente demonstrado no grfico. Desta forma, o algoritmo do pi faz pouco uso dos canais de comunicao o que no ocorre no algoritmo de ordenao. Como o algoritmo Odd-Even tem como objetivo principal o teste da rede de interconexo, tal algoritmo atinge este objetivo claramente. Desta forma, quando forem implementadas redes mais eficazes no simulador, tal algoritmo servir como ferramenta de avaliao das redes.
Envio de Mensagens do Odd-Even Sort
0 Processadores 1 2 3 4 5 6 0 50000 100000 150000 Bytes 200000 250000 300000 7 8 0 50000 100000 150000 Bytes 200000 250000 300000 Processadores

Recebimento de Mensagens do Odd-Even Sort

0 1 2 3 4 5 6 7 8

Figura 41 Uso da rede de interconexo do algoritmo Odd-Even sort

Envio de mensagens clculo do pi
0 Processadores 1 2 3 4 5 6 0 20 40 60 Bytes 80 100 120 7 8
0 10 20 30 Bytes 40 50 60 70 Processadores

Recebimento de mensagens clculo do pi

0 1 2 3 4 5 6 7 8

Figura 42 Uso da rede de interconexo do algoritmo de clculo do

6.6

Simulao de outras arquiteturas com o SMS

O simulador foi desenvolvido com o intuito principal de possibilitar a alterao

95

dos vrios componentes fsicos da arquitetura paralela de forma simples e eficiente. Para demonstrar como isso feito, essa seo apresenta algumas simulaes com diferentes configuraes arquiteturais. O SMS possibilita a alterao de inmeros itens de hardware de um processador superescalar, de forma que possvel configurar e simular vrios aspectos. Aqui so apresentados alguns. A simulao no SMS dada via linha de comando, sendo possvel passar ao simulador o nmero de processadores, as opes de simulaes e o arquivo que contm os programas a serem executados pelos processadores do simulador. Ento, um comando no simulador seria sms 2 odd-even, neste caso foram omitidas as opes, mas elas normalmente so utilizadas e permitem alterar a arquitetura. As opes mais importantes so: - redir:sim <nome do arquivo> - Redireciona a sada do resultado da simulao para um arquivo; - redir:prog_00 <nome do arquivo> - Redireciona a sada de um processador, neste caso, o 00 para um arquivo; se for colocado redir:prog_01 a sada coletada ser a do processador 01, e assim por diante. Isso valido para as opes que envolvem vrios processadores. - bpred_00 <tipo> - Neste caso alterado o esquema de previso de desvio, podendo-se alterar o tipo por: nottaken, taken, perfect, bimod, 2lev e comb. - cache:dl1_00 dl1_00:128:32:4:1 Esta opo altera as propriedades da cache de dados primria. Aps o comando so passados alguns parmetros, que so: o nome da cache, dl1 neste caso, seguido pelo tamanho da cache, tamanho do bloco da cache, associatividade da cache, e por fim a estratgia de substituio utilizada, que pode ser 1 para LRU, f para FIFO e r para random. Isso vlido para todas as caches. -cache:dl2_00 ul2_00:1024:64:4:1 Idem opo anterior, mas para cache

96

secundria. -cache:il1_00 il1_00:512:32:1:1 Nesta opo altera-se a cache primria de instruo. Como na cache de dados, aqui tambm existe uma cache secundaria que pode ser configurada da mesma forma. -mem:width_00 8 Largura do barramento de acesso memria em bytes, neste caso 8. -res:ialu_00 4 - Nmero total de unidades lgicas e aritmticas inteiras. -res:fpalu_00 4 Nmero total de unidades lgicas e aritmticas de ponto flutuante disponveis, neste caso como o anterior so 4. -inetwork bus:4:3 Configurao da rede de interconexo, neste caso a rede tem topologia barramento, o protocolo utilizado (atualmente s existe um no simulador) e por fim a freqncia da rede em relao ao processador, sendo que quanto menor a freqncia mais rpida a rede em relao ao processador. Todas as possveis alteraes e configuraes podem ser vistas em qualquer arquivo de simulao gerado durante as simulaes no SMS. Um exemplo de alterao de simulao trocar o tamanho da memria cache, tal experimento foi feito com o algoritmo do , apresentado a seguir. No exemplo do algoritmo do foi modificado o tamanho da memria cache de dados de todos os processadores, sendo ento colocada em cada processador uma cache de dados com o tamanho de 4096 bytes (ver figura 43), sendo que o simulador tem como padro uma cache de dados com tamanho de 128 bytes, que foi o tamanho utilizado nas simulaes com o algoritmo do clculo do anteriormente.

/usr/sms/sms 3 -cache:dl1_00 dl1:4096:32:1:l -cache:dl1_01 dl1:4096:32:1:l -redir:sim PIParalelo-d4096-10.000-3.sim PIP

Figura 43 Linha de comando para executar o programa de clculo do com cache de dados de tamanho de 4096

97

Os testes realizados com tamanho de memria cache de dados de 4096 foram devidamente comparados com os testes anteriores (figura 22), e apresentaram um pequeno ganho de desempenho (ver figura 44). O aumento de desempenho proporcionado pela arquitetura possibilitou at mesmo uma melhora de eficincia da arquitetura conforme pode ser visto na figura 45 o que no havia ocorrido com a mesma arquitetura com memria cache de 128 bytes. Essas possibilitades de alterao de configurao, viabilizam a identificao da melhor configurao arquitetural para cada tipo de aplicao.

Algoritmo clculo do pi com cache alterada

25 20 Speedup 10.000 cache 128 15 10 5 0 1 2 4 8 16 32 Processadores 100.000 cache 128 10.000 cache 4096 100.000 cache 4096

Figura 44 Speedup do com alterao de cache de dados

Outro algoritmo submetido a uma mudana de arquitetura simulada foi o Trapezoidal rule. Para este algoritmo foi alterado o previsor de desvios, trocando o bimod (padro do simulador) para o algoritmo 2lev (figura 46). Tal modificao foi realizada em todos os processadores, mas poderia ser feita individualmente simulando ambientes heterogneos, para isso seria necessrio especificar via linha de comando, por exemplo: sms 2 bpred_00 bimod bpred_01 2lev trapezoide.

98

Algoritmo clculo do pi com cache alterada

1,4 1,2 Eficincia 1 0,8 0,6 0,4 0,2 0 1 2 4 8 16 32 Processadores 10.000 cache 128 100.000 cache 128 10.000 cache 4096 100.000 cache 4096

Figura 45 Eficincia do com alterao de cache de dados

#sms 2 -bpred_00 2lev -bpred_01 2lev -redir:sim trapezoide2lev-44440.000-2.sim trapezoide Figura 46 - Linha de comando que dispara o simulador SMS com alteraes no previsor de desvio

Tais mudanas no previsor de desvios, proporcionaram mudanas sutis no desempenho do algoritmo frente a arquitetura. Os resultados podem ser observados na figura 47. Por fim, como o algoritmo de ordenao Odd-Even proposto tem como caracterstica marcante o intenso uso da rede de interconexo, foram realizadas simulaes com duas arquiteturas, uma com uma rede de interconexo com 1Mb/s de largura de banda e outra com 10Mb/s. A figura 48 mostra o tempo de execuo da simulao para essas configuraes de rede.

99

Alterao do sistema de previso de desvio do algoritmo Trapezoidal rule

30 25 Speedup 20 15 10 5 0 1 2 4 8 16 32 Processadores 1.000.000 2lev 2.000.000 2lev 4.000.000 2lev 1.000.000 bimod 2.000.000 bimod 4.000.000 bimod

Alterao do sistema de previso de desvio do algoritmo Trapezoidal rule

1,2 1 Eficincia 0,8 0,6 0,4 0,2 0 1 2 4 8 16 32 Processadores 1.000.000 2lev 2.000.000 2lev 4.000.000 2lev 1.000.000 bimod 2.000.000 bimod 2.000.000

Figura 47 Speedup e eficincia do algoritmo Trapezoidal rule com previsor de desvio alterado

Atravs da simulao e dos dados gerados pode-se notar que a rede de interconexo teve influncia no desempenho do algoritmo de ordenao odd-even. Assim, possvel constatar que o simulador SMS fornece uma maneira simples e fcil de alterar a arquitetura simulada, possibilitando que um mesmo algoritmo seja testado em inmeros ambientes paralelos.

100
Odd-Even sort com rede de interconexo de 1 Mb/s(n=32768)
200 Tempo em segundos 1 150 100 50 0 Processadores 2 4 8 16 32 Tempo em segundos 200 150 100 50 0 Processadores 1 2 4 8 16 32

Odd-Even sort com rede de interconexo de 10 Mb/s (n=32768)

Odd-Even sort com rede de interconexo de 1 Mb/s (n=65536)

500 Tempo em segundos 400 300 200 100 0 Processadores 1 2 4 8 16 32
Tempo em segundos 500 400 300 200 100 0

Odd-Even sort com rede de interconexo de 10 Mb/s (n=65536)

1 2 4 8 16 32 Processadores

Figura 48 - Elapsed Time do algoritmo Odd-Even com duas redes de interconexo

101

7 CONCLUSO

Este captulo resume as concluses embasado nas discusses e dados expostos nos captulos precedentes. Este trabalho utilizou a ferramenta de simulao SMS implementada por (SANDRI, 2004), que atualmente simula ambientes paralelos de memria distribuda e possibilita diversas configuraes de arquiteturas. Mas, tal ferramenta no possua algoritmos para testes e simulaes, assim, este trabalho apresenta como contribuio o desenvolvimento de algoritmos de testes para em conjunto com o simulador, viabilizar o estudo de arquiteturas paralelas em uma variedade de configuraes. Os algoritmos desenvolvidos neste trabalho possibilitam tambm que a ferramenta seja usada para apoio ao ensino de arquiteturas paralelas, j que com os algoritmos implementados os estudantes de arquiteturas paralelas podem primeiramente entender como funciona um algoritmo paralelo antes de comear a implementar os seus prprios algoritmos. Aps o desenvolvimento dos algoritmos de testes propostos foram executados intensos exerccios de simulao com a ferramenta SMS. Esses exerccios de simulao mostraram que a ferramenta viabiliza a implementao de algoritmos paralelos e a anlise de desempenho de arquiteturas paralelas com diversas configuraes de arquiteturas computacionais. Quanto a ferramenta SMS, durante os testes com os algoritmos foi possvel notar que a mesma permite realizar simulaes, nas quais possvel alterar caractersticas fsicas de baixo nvel como: larguras de barramentos internos ao processador, tamanho da memria principal, configuraes de memria cache, previsores de desvios, e unidades funcionais, entre outras. Permitindo assim o estudo do paralelismo implcito, atravs do emprego de

102

processadores superescalares. E da mesma forma possibilita configurar caractersticas de mais alto nvel, tais como: nmero de processadores, topologia da rede de interconexo, protocolos de comunicao, entre outras. Permitindo o estudo do paralelismo explcito inerente s arquiteturas que fazem uso de memria distribuda e passagem de mensagem. Quanto aos algoritmos desenvolvidos, eles possuem um papel fundamental, pois em conjunto com o simulador, fornecem uma maneira fcil de testar diversas arquiteturas explorando de forma eficiente os elementos fsicos que compem uma arquitetura paralela. Permitem da mesma forma investigar parmetros de desempenho importantes em arquiteturas paralelas. Os algoritmos implementados permitem ainda que usurios que estejam iniciando suas pesquisas em computao paralela, possam primeiramente analisar os algoritmos j implementados, estudando-os e alterando-os, para posteriormente desenvolver seus prprios algoritmos. Tais algoritmos tambm permitiram validar a ferramenta, mostrando que ela uma tima alternativa para testes de avaliao de desempenho em ambientes paralelos e como ferramenta de auxlio ao ensino e pesquisa em Arquiteturas Paralelas.

103

8 TRABALHOS FUTUROS

A ferramenta de simulao j est validada e operacional. Permite simulaes de memria distribuda, fazendo uso de passagem de mensagem. Diversos aspectos ainda podem ser investigados, suscitando trabalhos futuros envolvendo a ferramenta de simulao e algoritmos paralelos. O primeiro passo para continuidade do presente trabalho poder focar a implementao de memria compartilhada, o que tornar o SMS uma ferramenta de simulao completa. Isso demandar um outro trabalho que consistir no desenvolvimento de algoritmos para testar a memria compartilhada assim que esse mdulo for desenvolvido. Um terceiro trabalho futuro poder ser o desenvolvimento do mdulo de Interface Grfica. Esse mdulo facilitar as simulaes, j que este possibilitar uma melhor interao entre o usurio e a ferramenta, e facilitar o controle das simulaes. A Interface Grfica tambm dever fornecer sadas de simulaes mais atrativas e representativas (grficas) dando uma melhor viso do comportamento da arquitetura. Ainda h a possibilidade de se desenvolver os mesmos algoritmos deste trabalho, mas voltados para outros simuladores de arquiteturas paralelas. Isso viabilizar anlises comparativas. interessante que o simulador no futuro apresente o tempo de execuo individual de cada processador, pois atualmente ele apresenta um tempo nico de execuo para toda arquitetura. Outro tpico de pesquisa para trabalhos futuros est relacionado s Redes de Interconexo. Novas redes podem ser implementadas com diferentes topologias e protocolos de controle.

104

REFERNCIAS

AUSTIN, Todd; LARSON, Eric; ERNST, Dan. SimpleScalar: An Infrastructure for Computer System Modeling. IEEE Computer. v. 35, n. 2, p. 59-67, feb.2002. ALMASI, G. S.; GOTTLIED, A. Highly Parallel Computing. 2. ed., Redwood City: The Benjamin/Cummings Company, 1994. BADER, David A.; JJ, Joseph.; SIMPLE : A Methodology for Programming High Performance Algorithms on Cluster of Symmetric Multiprocessors (SMPS) (Preliminary Version). Institute for Advanced Computer Studies, University of Maryland, College Park, mai.1997. BADER, David A.; JJ, Joseph.; Pratical Parallel Algorithms for Dynamic Data Redistribution, Median Finding, and Selection. Institute of Advanced Computer Studies, and Department of Electrical Engineering, University of Maryland, College Park. Disponvel em: http://ipdps.eece.unm.edu/1996/PAPERS/S08/DBADER8/DBADER8.PDF, Acesso em: mai.2004. BAGRODIA, Rajive L; TAKAI, Mineo; JHA, Vikas. Performance Evaluation of Conservative Algorithms in Parallel Simulations Languages. IEEE Transactions on Parallel and Distributed Systems, v. 11, n. 4. 2000. BAGRODIA, Rajive; MARTHUR, Sharad. Efficient Implementation of High-Level Parallel Programs. ACM Press. v. 26, n. 4, p. 142-153, abr.1991. BAGRODIA, Rajive; et al. Performance prediction of large parallel applications using parallel simulations. ACM Press, pg 151-162. 1999. BAILEY, David H.; BARSZCZ, Eric; DAGUM, Leonardo; SIMON, Horst D. NAS Parallel Benchmark Results. IEEE, pg 43-51. Fev 1993. BREWER, Eric A. et al. Proteus: A High-Performance Parallel-Architecture Simulator. Technical Report MIT/LCS/TR-516, Cambridge, set.1991. BURGER, Doug.; AUSTIN, Todd M. The Simplescalar Tool Set - Version 2.0. Technical Report 1342, University of Wisconsin-Madison Computer Science Department, jun.1997. CALZAROSSA, Maria; MASSARI, Luisa; TESSERA, Daniele. A methodology towards automatic performance analysis of parallel applications. Sience Direct, Ago 2003. CHANG, H. S. Tcheng; HUANG, K. Performance of a Weather Prediction Model on Parallel Machines, Proceedings of High Performance Computing Grand Challenges in Computer Simulation (HPC-99), San Diego, California, (April 1999), pp.101-104, 1999. CHOI, Hyeong-Ah; NARAHARI, b. Efficient Algorithms for Mapping and Partitioning a

105

Class of Parallel Computations. Journal of Parallel and Distributed Computing 19, pg 349363. Washington, 1993.

CHOI, Jaeyoung. A New Matrix Multiplication Algorithm on Distributed-Memory Concurrent Computers. Concurrency: Pratice and Experience, v.10, n. 8, p. 655-670. 1998. CORMEN, Thomas H.; et al. Algoritmos Teoria e Prtica Traduo da 2o Edio Americana. 2 ed., Rio de Janeiro: Ed. Campus, 2002. CREMONESI, Paolo; ROSTI, Emilia; SERAZZI, Giuseppe; SMIRNI, Performance evaluation of parallel systems. Parallel Computing 25. 1999. Evgenia.

DUJMOVIC, J; DUJMOVIC, I. Evolution and evaluation of SPEC benchmarcks. ACM Press, pg 2-9. 1998. EAGER, Derek L.; ZAHORJAN, John; LAZOWSKA, Edward D. Speedup Versus Efficiency in Parallel Systems. IEEE transactions on Computer, vol 38, n 3, mar 1989. EECKHOUT, Lieven; BOSSCHERE, Koen De. Efficient simulation of trace samples on parallel machines. Sicence Direct, Parallel Computing. Fev 2004. EWING, T.; TENTNER, A. A Scaleable Architecture for the Modeling and Simulation of Intelligent Transportation System, Proceedings of High Performance Computing Symposium Grand Challenges in Computer Simulation (HPC-1999), San Diego, California, pp.170-174. Abr 1999. FLYNN, M. Very high-speed computing system. Proceeding of the IEEE. n 54. P.19011909. Dez 1966. FRANCIS, Rhys S.; MATHIESON, Ian D. A benchmark Parallel Sort for Shared Memory Multiprocessors. IEEE Transactions on Computers, vol 37, n 12. Dez 1988. GRAMA, Ananth Y.; GUPTA, Anshul; KUMAR, Vipin. Measuring the Scalability of Parallel Algorithms and Architectures. IEEE Parallel & Distributed Technology, pg 12-21. 1993. GRAMA, Ananth.; GUPTA, Anshul.; KARYPIS, George.; KUMAR, Vipin. Introduction to Parallel Computing. 2 ed. Ed Addison Wesley, 2003. GUPTA, Anshul; KUMAR, Vipin. Performance Properties of Large Scale Parallel Systems. Journal of Parallel and Distributed Computing 19. Minnesota, 1993. GUTZMANN, Michael M; WEPER, Ralph. Classification Approaches for Parallel Architectures. Berichte zur Rechnerarchitektur, v. 2, n. 19, FSU Friedrich-SchillerUniversitat, Jena, 1996. GUSTAFSON, John L. Reevaluating Amdahls Law. Communications of the ACM, vol 31, n 5, pg 532-533. Mai 1988. HENNESSY, John L.; PATTERSON, David A. Arquitetura de Computadores: Uma

106

Abordagem Quantitativa. 3 ed. Rio de Janeiro. Ed Campus, 2003.

HERROD, S.A. Tango Lite: A Multiprocessor Simulation Environment. Stanford University. 1993. HOGANSON, Kenneth E. Workload Execution Strategies and Parallel Speedup on Clustered Computers. IEEE Transactions on Computers, vol 48, n 11. Nov 1999. KUMAR, Vipin; GUPTA, Anshul. Analysis of Scalability of Parallel Algorithms and Architectures: A Survey. ACM, pg 396-405. 1991. LAINE, Jean Marcos. Desenvolvimento de Modelos para Predio de Desempenho de Programas Paralelos MPI. So Paulo: USP, 2003. LU, N.P; CHUNG, C.P. Parallel exploitation in superscalar multiprocessing. IEEE Proc.Comput. Digit. Tech, vol 145, n 4. jul 1998. MAGDIC, D. Limes: A Multiprocessor Simulation Environment for PC Platforms. In: Proceedings of the 3rd International Conference no Parallel Processing and Applied Mathematics (PPAM-99), Kazemiers Dolny, Poland, set.1999. MANJIKIAN, Naraig. More Enhacements of the Simplescalar Tool Set. ACM. Sigarch Computer Architecture News. v. 29, ed. 4, p. 5-12, set.2001. MATHESON, Lesley R.; TARJAN, Robert E. Analysis of Multigrid Algorithms on Massively Parallel Computers: Architectural Implications. Journal of Parallel and Distributed Computing 33. New Jersey, 1996. MATLOFF, Norman; RICH, Kevin. MulSim Multiprocessor Simulator. University of California. Disponivel em: http://heather.cs.ucdavis.edu/~matloff/MulSim/MulSimDoc.html. Acessado em: Jan 2005. NGUYEN, A.T.; MICHAEL, M.; SHARMA, A; TORRELLAS, J. The Augmint Multiprocessor Simulation Toolkit for Intel x86 Architectures. University of Illinois and University of Rochester. 1996. OLEARY, Dianne P.; STEWART, G.W. Data-Flow Algoritms for Parallel Matrix Computations. Communications of the ACM, v. 28, n. 8, p. 840-853, ago.1985. PACHECO, Peter S.; Parallel Programming With MPI. California: Ed. Morgan Kaufmann Publishers, Inc. San Francisco, 1997. PAI, V.S.; RANGANATHAN, P.; ADVE, S.V. RSIN: Na Execution-Drive Simulation for ILP-Based Shared-Memory Multiprocessors and Uniprocessor. In: Proceedings of The 3rd Workshop on Computer Architecture Education, feb.1997. PATTERSON, David A.; HENNESSY, John L.; Organizao e Projeto de Computadores A Interface Hardware/Software. 2 ed., Rio de Janeiro: ed. LTC, 2000. SANDRI, A.L; GONALVES, R.A.L; MARTINI, J.A. SMS- Tool for Development and Performance Analysis of Parallel Applications. Annual Simulation Symposium. pg 196. 2004.

107

SMITH, James E.; SOHI, Gurindar. The Microarchitecture of Superscalar Processor. In: Proceedings of the IEEE. n 83, pg 1609-1624. Dez.1995. SUN, Xian-He; NI, Lionel M. Another veiw on parallel speedup. IEEE, pg 324-333. 1990. SUNADA, D.; GLASCO, D.; FLYNN, M. ABSS v2.0: a SPARC Simulation. Technical Report CSL-TR-98-755, Standford University, 1998. TANENBAUM, Andrew S. Organizao Estruturada de Computadores. 4 ed., Rio de Janeiro: Ed. LTC, 2001. TROPPER, Carl. Parallel Discrete-Event Simulation Applications. Journal of Parallel and Distributed Computing 62, pg 327-335. 2002. VEENSTRA, J.E; FOWLER R.J. MINT Tutorial and User Manual. The University of Rochester. 1993. WAHEED, Abdul; ROVER, Diane T. Performance Visualization of Parallel Programs. IEEE, pg 174-182. 1993. WILKINSON, Barry.; ALLEN, Michael. Parallel Programming. 2ed., London: Ed. Pearson Prentice Hall, 1999. WOO, S.C; Ohara, M; TORRIE, E.; SINGH, J.P.; Gupta, A. The SPLASH-2 Programs: Characterization and Methodological Considerations. In Proceedings of the 22nd International Symposium on Computer Architecture, pages 24-36, Santa Margherita Ligure, ACM, Jun 1995. WOODWARD, P.R., Perspectives on Supercomputing: Three Decades of Change, IEEE Computer, Vol.29, No.10, pp.99-111. Out 1996. ZARGHAN, Mehdi R. Computer Architecture Single and Parallel Systems. 1 ed., New Jersey: Ed. Prentice Hall. 1995. ZHANG, Xiaodong; YAN, Yong; HE, Keqiang. Latency Metric: An Experimental Method for Measuring and Evaluating Parallel Program and Arquitecture Scalability. Journal of Parallel and Distributed Computing 22. 1994.

108

ANEXO A Manual de Instalao do SMS

Segue neste trabalho todos os passos necessrios para a instalao do conjunto de ferramentas, que fazem parte do simulador de multiprocessadores de alto-desempenho denominado SMS (Simulador de Multiprocessadores Superescalares), o qual de licena gratuita e pode ser publicamente avaliado. O SMS, tem como base o ncleo do simulador SimpleScalar, e permite a configurao de diferentes modelos arquiteturais paralelos e distribudos. Como o SMS baseado no Simplescalar, faz-se necessrio antes de instalar o SMS, instalar o simplescalar, maiores informaes sobre o Simplescalar podem ser obtidas no site www.simplescalar.com. Porem ser apresentado abaixo uma breve descrio do simplescalar bem como a sua instalao. A distribuio e uso do simulador Simplescalar possui somente duas restries que so: (1) a notificao dos direitos autorais tem que acompanhar todas as ferramentas e (2) estritamente proibido que terceiros coloquem restries a qualquer ferramenta do simulador mesmo que esta tenha sido melhorada ou incrementada. Ento permitido copias e modificaes e redistribuio do conjunto de ferramentas que compem o SimpleScalar, desde que algumas regras sejam respeitadas, tal como: o simulador gratuito para uso nocomercial, e todas as distribuies (mesmo as alteradas) tem de levar com sigo os direitos autorais. possvel obter o simulador e suas respectivas ferramentas, atravs do World Wide Web (www.simplescalar.com) ou por ftp (ftp://ftp.cs.wisc.edu/sohi/code/simplescalar/), onde nestes podem ser encontrados os seguintes arquivos:

simplesim.tar.gz - Este arquivo contem o simulador propriamente dito. Este arquivo

necessrio para a instalao do simulador.

Simpleutils.tar.gz Contem os GNU binutils recompilados para a arquitetura

SimpleScalar. Esses utilitrios no so requeridos para executar o simulador. Mas necessrio para compilar seus prprios benchmark binrios do SimpleScalar.

Simpletools.tar.gz Contem o compilador GNU e bibliotecas necessrias para criar

benchmarks binrios

(GCC, glibc e f2c), como tambm pr-criar verses das

bibliotecas big e little-endian.

109

Simplebench.big.tar.gz Contem um conjunto de benchmark binrios SPEC95,

compilados para arquitetura SimpleScalar sendo executado em computadores bigendian.

Simplebench.little.tar.gz igual ao Simplebench.big.tar.gz, s que executado em

computadores little-endian. Os arquivos viro com extenses tar.gz ou tgz, onde os arquivos que contenham estas extenses, devem ser descompactados utilizando, por exemplo, o comando: tar zxvf nome do arquivo, em um diretrio especifico (ex. /home/SimpleScalar/). Depois de descompactar os arquivos pertinentes ao SimpleScalar, dever-se- ter os seguintes subdiretrios:

simplesim-x no qual o x, a verso do simulador, por exemplo, o SimpleScalar 2.0

devera gerar o seguinte diretrio simplesim-2.0. Este diretrio conter os cdigos fontes principais do simulador, scripts de suporte e pequenos benchmarks para testes.

binutils-x da mesma forma que o simplesim, o x representa a verso, que poderia

ser binutils-2.5.2. Neste diretrio, est contido cdigos binrios GNU, reportados especialmente para a arquitetura SimpleScalar.

ssbig-na-sstrix o diretrio raiz no qual os utilitrios big-endian dos utilitrios

SimpleScalar e ferramentas de compilao sero instalados. O pacote descompactado conter cabealhos de arquivos e uma copia pr-compilada do libc e um arquivo objeto necessrio.

sslittle-na-sstrix o mesmo que o ssbig-na-sstrix, s que este armazena a verso

little-endian dos utilitrios SimpleScalar.

gcc-x o x deve ser substitudo pela verso do arquivo, (ex. gcc-2.6.3). Este arquivo

contem o compilador C GNU, focado para a arquitetura SimpleScalar.

glibc-x idem aos itens a cima no qual o x deve ser substitudo pela verso, tal como,

glibc-1.09, se for essa a verso. Este arquivo descompactado contem bibliotecas GNU, portadas para a arquitetura SimpleScalar.

f2c-1994.09.27 O release de 1994 da AT&T Bell Labs para o tradutor do

FORTRAN para cdigos em C.

spec95-big benchmark do SPEC95, pre-compilado para o SimpleScalar (na verso

big-endian).
spec95-little igual ao spec95-big s que na verso little-endian.

110

Instalao do Simplescalar Passo(1) Baixar do site www.simplescalar.com ou do ftp

ftp://ftp.cs.wisc.edu/sohi/code/simplescalar/, os seguintes arquivos:

gcc-2_7_2_3_ss_tar.gz simplesim-3v0c.tgz simpleutils-990811_tar.gz

Note que as verses dos arquivos encontrados no site podem ser diferentes desta, o que deixaria os arquivos com nomes diferentes.
Passo(2) Descompacte os arquivos, utilizando o seguinte comando:
tar zxvf gcc-2_7_2_3_ss_tar.gz tar zxvf simplesim-3v0c.tgz tar zxvf simpleutils-990811_tar.gz

Depois de executar cada um desses comandos ser criado um conjunto de diretrios e subdiretrios e a partir destes podemos dar inicio a instalao.
Passo(3) Supondo que todos os arquivos acima foram copiados e descompactados no seguinte

diretrio /home/SimpleScalar/, acesse o seguinte diretrio:

cd /home/SimpleScalar/simpleutils-990811

Ento dentro deste diretrio execute o seguinte comando:

./configure --host=i586-pc-linux --target=sslittle-na-sstrix --with-gnu-as --with-gnu-ld --prefix=/home/SimpleScalar/

Onde este comando ir gerar o arquivo Makefile adequado instalao em questo. Uma observao a ser feita sobre o comando acima, que a identificao do host i586-pclinux pode ser alterada de acordo com a compatibilidade do sistema. A sintaxe geral i#86*-linux, na qual # pode ser 2, 3 4, 5, 6 ou outra conforme a plataforma em uso e * pode ser uma string qualquer que melhor represente o nome da sua plataforma. Ainda neste comando o target sslittle-na-sstrix pode ser substitudo por ssbig-na-sstrix, se for o caso de se utilizar plataforma big-endian ao invs da little-endian.

111

Passo (4) Aps a execuo do passo anterior deve-se executar o seguinte comando no mesmo

diretrio:
make

Passo (5) O passo cinco consiste em executar o comando:

make install

Passo (6) Para execuo dos passos seguintes faz-se necessrio a mudana de diretrio:
cd /home/SimpleScalar/simplesim-3.0

Passo (7) Este passo requer a execuo do comando a seguir:

make config-pisa

Passo (8) Execute o comando:

make

Somente as execues dos passos acima j sero suficientes para a execuo do simulador Simplescalar, porem se, for desejvel implementar e compilar benchmarks faz se necessrio execuo dos passos descritos a seguir. Em algumas instalaes do SimpleScalar, no RedHat Linux 9, foram detectados alguns erros durante a execuo dos passos acima, o erro consiste em mensagens referentes aos arquivos eval.h e range.h, onde a correo desses erros, se da alterando os seguintes arquivos: Editar o arquivo eval.h e incluir as seguintes linhas que esto em negrito:
linhas 17. 18. 19. 20. 21. 22. 23. 24. #include <stdio.h> #include <stdlib.h> #include <string.h> #if defined(__CYGWIN32__) #include <errno.h> #else #include <errno.h> #endif

Editar o arquivo range.h e incluir as seguintes linhas:

linhas 19. 20. 21. 22. 23. #include <stdio.h> #include <stdlib.h> #include <string.h> #if defined(__CYGWIN32__) #include <errno.h>

112
24. 25. 26. #else #include <errno.h> #endif

Passo (9) Aps a execuo dos passos anteriores faz se necessrio os passos a seguir para que

o usurio possa criar seus prprios benchmarks, para o passo 10 entre no seguinte diretrio:
cd /home/SimpleScalar/gcc-2.7.2.3

Passo (10) Execute o comando abaixo para criar o Makefile:

./configure --host=i586-pc-linux --target=sslittle-na-sstrix --with-gnu-as --with-gnu-ld --prefix=/home/SimpleScalar/

As mesmas consideraes feitas no passo 3 so validas neste passo. Ateno nos passos 11 e 12 a seguir podem surgir erros, que pode ser visto abaixo:
_eprintf ./liggcc2.c:1419: stdio.h: No such file or directory make: *** [libgcc2.a] Error 1

Para a correo deste erro, a faz se necessrio a alterao na linha 253 no arquivo Makefile onde esta linha deve ser mudada para:
LIBGCC2_INCLUDES = -I/usr/include

Depois desta alterao possvel executar os passos restantes sem maiores problemas.
Passo (11) Execute o comando:
make LANGUAGES=c

Passo (12) Para terminar a instalao execute o comando:

make install LANGUAGE=c

Com isto a instalao estar completa, porem se durante a instalao pode ter surgido outros erros. Um outro erro que pode ser encontrado na instalao, o que segue:
_divdi3 ./libgcc2.c: In function `__udivmoddi4: ./libgcc2.c: 484: `BITS_PER_UNIT undeclared (first use this function) ./libgcc2.c: 484: (Each undeclared identifier is reported only once ./libgcc2.c: 484: for each function it appears in.) make: *** [libgcc2.a] Error 1

A correo deste erro, consiste apenas em adicionar o cdigo abaixo na linha 98 do arquivo ./libgcc2.c:
#define BITS_PER_UNIT 8

113

Outro problema que o usurio SimpleScalar pode se deparar o seguinte:

gcc o aditest aditest.c cc1: /tmp/ccuXmqQP.s: I/O error

O problema aqui que o diretrio tmp, que cotem arquivos temporrios est cheio, e isso ocasiona o erro, o gcc usa o valor da varivel de ambiente $TMPDIR, portanto para sanar esse erro, mude o valor de TMPDIR para outro valor (ex. export TMPDIR=/usr/tmp) ou apague alguns arquivos do diretrio /tmp. Quando for necessrio compilar qualquer programa usando o compilador target use a flag: -I /usr/include, para especificar ao compilador a localizao de qualquer arquivo de header padro e o flag L para especificar a biblioteca. Ainda possvel fazer o download do arquivo simpletools.tar.gz (no site do SimpleScalar), que necessita ser descompactado. Dentro descompactando o arquivo, ser encontrado no diretrio sslittle-na-sstrix/lib dois arquivos, o crt0.o e libc.a que j esto compilados para o SimpleScalar. Copie eles para o diretrio /home/SimpleScalar/lib. Supondo queira-se compilar uma aplicao chamada teste.c. De dentro do diretrio onde est a tal aplicao use a seguinte linha de comando para a compilao:
/home/SimpleScalar/sslittle-na-sstrix/bin/gcc L/home/SimpleScalar/lib o teste.ss teste.c I/usr/include

Aps executar todos os passos anteriores o simulador SimpleScalar estar pronto para ser executado.
Instalao do SMS

A instalao do SMS, simulador multiprocessador implementado a partir do SimpleScalar, muito simples e consiste dos seguintes passos:
Passo (1) requisito bsico que j esteja instalado o SimpleScalar (veja sesso acima). Passo (2) Descompacte o arquivo sms[1].tar.gz em um diretrio (ex. /usr/SMS/), utilizando o

seguinte comando:

114
tar zxvf sms[1].tar.gz

Passo (3) Execute o seguinte comando para realizar a instalao: ./make

Ao fim deste ultimo passo a instalao estar concluda. Para compilar um programa pode-se utilizar o seguinte comando:
/diretorio/do/simple/sslittle-na-sstrix-gcc -I/usr/include L/root/Simple/lib -o mestre mestre.c

Para executar os programas compilados como acima, faz se necessrio criar um arquivo (ex. PROGRAMAS) no qual estar uma lista dos programas a serem executados, veja exemplo abaixo:
# arquivo PROGRAMAS mestre escravo escravo escravo

Neste exemplo sero executados dois programas um denominado mestre e outro escravo, sendo que o ultimo ser executado em trs instncias. Depois de criar este arquivo s executar o comando que inicia a simulao, como segue abaixo:
/.sms 2 PROGRAMAS

Pode-se notar que no comando anterior existe o numero 2 que representa o nmero de processadores disponveis para esta tarefa. possvel ainda direcionar a sada do simulador para um arquivo, para isso faz se necessrio acrescentar ao comando ./sms as seguintes entradas:
/.sms 2 -redir:sim teste.txt PROGRAMS

115

O a opo redir:sim cria um arquivo denominado teste.txt contendo as sadas do simulador, este arquivo possibilita um melhor estudo das sadas do simulador.