Implementação_cluster alto_desempenho_fernando_eduardo_20090726-Imetro_2013
111
INSTITUTO SUPERIOR POLITÉCNICO METROPOLITANO DE ANGOLA IMPLEMENTAÇÃO DE CLUSTER DE ALTO DESEMPENHO USANDO GNU/LINUX Luanda 2013
-
Upload
kanda-kassobo -
Category
Science
-
view
354 -
download
11
description
Trabalho de fim de curso, 2013, Imetro Angola
Transcript of Implementação_cluster alto_desempenho_fernando_eduardo_20090726-Imetro_2013
INSTITUTO SUPERIOR POLITÉCNICO
METROPOLITANO DE ANGOLA
IMPLEMENTAÇÃO DE CLUSTER DE ALTO DESEMPENHO
USANDO GNU/LINUX
Luanda
2013
ii
INSTITUTO SUPERIOR POLITÉCNICO
METROPOLITANO DE ANGOLA
Por: Fernando Kanda Kassobo Eduardo
IMPLEMENTAÇÃO DE CLUSTER DE ALTO DESEMPENHO
USANDO GNU/LINUX
Monografia apresentada ao curso de
Licenciatura em Ciência da Computação,
como requisito parcial para obtenção do título
de Licenciado em Ciência da Computação, sob
orientação do professor Engenheiro Dionísio
Teixeira
Luanda
2013
iii
IMPLEMENTAÇÃO DE CLUSTER DE ALTO DESEMPENHO
USANDO GNU/LINUX
Por: Fernando Kanda Kassobo Eduardo
Orientador: Engenheiro Dionísio Teixeira
Monografia apresentada ao curso de Licenciatura em Ciência da Computação,
requisito parcial para obtenção do título de Licenciado em Ciência Da Computação.
Aprovado por:
-------------------------------------------------
O Presidente da Banca
-------------------------------------------------
Membro da Banca
-------------------------------------------------
Membro da Banca
-------------------------------------------------
O professor orientador
Aprovado Aprovado com restrições Não Aprovado
Grau de avaliação _______________________
______ de _________________de 2013
iv
Eduardo, Fernando Kanda Kassobo
Implementação de cluster de Alto Desempenho usando GNU/Linux / por Fernando
Kanda Kassobo – Luanda, 2013
95 p.
Trabalho de conclusão de curso (Licenciatura) – Departamento de ciências e
tecnologias - Curso de Licenciatura em Ciência da Computação - 2013
Orientador: Engenheiro Dionísio Teixeira
1. Cluster, 2. Alto desempenho, 3. Computação | Implementação de Cluster de alto
desempenho usando GNU/Linux
v
DEDICATÓRIA
Dedico este trabalho em especial a minha família, a
turma LCC4N/2012 (conseguimos…), aos meus Pais
(isto é para vocês) e a todos que directa ou
indirectamente contribuíram ou não para a conclusão
deste curso.
vi
AGRADECIMENTOS
Agradeço aos meus irmãos Miguel Kindieco Luvumbo, Benvindo Luvumbo,
Sebastião Eduardo, Engrácia Luengo, por sempre acreditar incansavelmente no meu potencial
e ter ajudado na realização do nosso sonho. Aos meus pais pela impaciência da longa jornada,
ao meu Tio Álvaro Mwanza que nunca desistiu da sua visão (ela se realizou), ao meu Tutor
Prof. Dr. Luvuvamo e Engº. Dionísio, pela motivação e orientação incansável, e
disponibilidade para que o fim deste trabalho fosse possível, e sem esquecer os meus
caríssimos colegas que sempre acreditaram desde a turma LCC1N (2009) e vencemos a
batalha.
vii
“As pedras no caminho?
guardo todas,
um dia faço um castelo ...”
Nemo Nox
viii
LISTA DE TABELAS
Tabela 1- Relação dos 5 supercomputadores mais rápidos do mundo (top500.org, 2013).................. 15
Tabela 2 - Linux & Windows (diffen.com, 2013) .................................................................................. 19
Tabela 3 - Classificação de arquitecturas paralelas, segundo FLYNN ................................................ 27
Tabela 4 - Níveis de Alta disponibilidade ............................................................................................. 44
Tabela 5 - Medida de desempenho dos computadores em Flops .......................................................... 54
ix
LISTA DE FIGURAS
Figura 1- Arquitectura de Von Neumann (wikipedia, 2013) .................................................................. 8
Figura 2- Computadores baseado na arquitectura de Von Neumann, ENIAC(fi.edu, 2013) ................. 8
Figura 3 - Exemplo de computador comercializado na segunda geração (ufpb.br, 2013) .................... 9
Figura 4 - Comparação do circuito integrado com uma moeda (ufpb.br, 2013) ................................... 9
Figura 5 - Computador pessoal de quarta geração (ufpb.br, 2013)..................................................... 10
Figura 6 - Computador de quinta geração (ufpb.br, 2013) .................................................................. 11
Figura 7 – Supercomputador Jaguar, da classe Cray XT5 (olcf.ornl.gov, 2013) ................................ 12
Figura 8 - Tinhae 2, o supercomputador mais rápido do mundo (cri.cn, 2013) .................................. 14
Figura 9 - Logomarca do projecto Gnu (gnu.org, 2013) ...................................................................... 18
Figura 10 - Tux a mascote do Linux (wikipedia, 2013) ........................................................................ 18
Figura 11- Arquitectura SISD ............................................................................................................... 28
Figura 12 - Arquitectura MISD ............................................................................................................ 29
Figura 13 - Arquitectura SIMD ............................................................................................................ 30
Figura 14 - Arquitectura MIMD ........................................................................................................... 31
Figura 15 - Classificação segundo o compartilhamento de memória (TANENBAUM 2003) .............. 31
Figura 16 - Multiprocessadores (UMA - Uniform Memory Access) .................................................... 32
Figura 17 - Multiprocessadores (NUMA - Non Uniform Memory Access) .......................................... 33
Figura 18 - Arquitectura de um multicomputador ................................................................................ 34
Figura 19 - Arquitectura PVP ............................................................................................................... 35
Figura 20 - Arquitectura SMP .............................................................................................................. 36
Figura 21 - Arquitectura DSM .............................................................................................................. 37
Figura 22 - Arquitectura MPP .............................................................................................................. 38
Figura 23 - Cluster da força aérea Americana (AFRL), tem 1760 PlayStation 3 (US Air Force) ....... 40
Figura 24 - Cluster classe I, na Universidade de Tecnologia de Chemnitz (megware.com, 2013) ...... 41
Figura 25 - Cluster classe II, Sun Microsystem Solaris Cluster (ChrisDag, 2013) ............................. 42
Figura 26 - Cluster de alta disponibilidade (wikipedia, 2013) ............................................................. 45
Figura 27 - Arquitectura do Cluster com balanceamento de Carga (devmedia.com.br, 2013) ........... 47
Figura 28 - Arquitectura do cluster de alto desempenho, HPC (wikipedia, 2013) .............................. 48
Figura 29 - Cluster do grupo Structural and Computational Biology (norma.mbg.duth.gr, 2013) ..... 52
Figura 30 - Exponencial crescimento da supercomputação, (top500.org) ........................................... 54
Figura 31 - Modelo de execução de Fork-Join (openmp.org, 2013) .................................................... 61
.
x
Lista de abreviaturas e siglas
ANSI American National Standards Institute
API Application Programming Interface
CC-NUMA Cache Coherence Non-Uniform Memory Access
CDC Control Data Corporation
CESDIS Center of Excellence in Space Data and Information Sciences
CI Circuitos Integrados
COTS Comercial Off-The-Shelf
CPU Unidade central de processamento
CUDA Computer Unified Device Architecture
DEC Digital Electronic Computer
DHCP Dynamic Host Configuration Protocol
DSM Distributed Shared Memory
EDVAC Electronic Discrete Variable Automatic Computer
ENIAC Electronic Numerical Integrator and Calculator
FLOPS Operações De Ponto Flutuante Por Segundo
FSF Free Software Foundation
GCC Gnu Compiler Collection
Gnome Gnu Network Object Model Environment
GNU General Public License
GPGPU General Purpose Graphics Processing Unit
GPL General Public License
HA High Availability
HIPPI High Performance Parallel Interface
xi
HPC High Performance Cluster
HD Hard Disk
IAS Institute of Advanced Studies
IBM International Business Machines
IP Internet Protocol
KDE K Desktop Environment
LAN Local Area Network
LB Balanceamento de Carga
LSI Large Scale of Integration
M2COTS Mass Market Commercial-Off-The-Shelf
MC Memória Compartilhada
MIMD Multiple Instruction Multiple Data
MISD Multiple Instruction Single Data
MIT Massachusetts Institute of Technology
MPI Message Passing Interface
MPMD Multiple Program Multiple Data
MPP Massively Parallel Processor
NASA National Aeronautics and Space Administration
NFS Network File System
NUDT National University for Defense Technology
NUMA Non Uniform Memory Access
OSI Open Systems Interconnection
PAD Processamento de Alto Desempenho
PC Personal Computers
xii
PCI Interfase de Comunicação com Periféricos
PDP Programmed Data Processor
PV Processadores Vectoriais
PVM Parallel Virtual Machine
PVP Parallel Vector Processors
SCI Scalable Coherent Interface
SIMD Single Instruction Multiple Data
SISD Single Instruction Single Data
SMP Simmetric Multiprocessors
SSH Secure Shell
SSI Single System Image
UC Unidade de Controlo
ULA Unidade Logica e Aritmética
ULSI Ultra Large Scale of Integration
UMA Uniform Memory Access
VLSI Very Large Scale Integration
VLSI Very Large Scale of Integration
VPI Virtual Path Identifier
xiii
RESUMO
Com o desenvolvimento do nosso país na última década, tem surgido algumas
necessidades por poder computacional mais propriamente nas áreas que exigem
processamento em massa e área que necessitam eficiência e rapidez nos resultados, como as
aplicações de pesquisa, e outras, faz-se necessário a criação de ambientes com elevado poder
computacional. O uso de cluster tem sido uma das alternativas mais adoptadas para o
desenvolvimento de sistemas computacionais, que visam o alto desempenho, para atender as
necessidades por poder computacional.
O objectivo deste trabalho é o estudo fundamentado de arquitecturas para ambientes
de alto desempenho servindo como base a idealização, projecto e construção de um Cluster
Computacional.
Palavras-chave: Cluster, Programação Paralela, Sistemas de Alto Desempenho, super
computação.
xiv
Abstract
With the development of our country in the last decade, there has been some needs for
computing power more specifically in the areas that require bulk processing and areas in need
efficiently and quickly in the results, as research applications, and other it is necessary to
create environments with more computing power. The use of clusters has been one of the
alternatives adopted for the development of computer systems, aimed at the high
performance, and to meet the need for computational power.
The aim of this work is the study of the technologies and architectures for high-
performance environments serving as a basis ideation, design and construction of a
Computational Cluster.
Keywords: Cluster, Parallel Programming, High Performance Systems,
supercomputing.
xv
SUMÁRIO
LISTA DE TABELAS ............................................................................................................ VIII
LISTA DE FIGURAS ............................................................................................................... IX
LISTA DE ABREVIATURAS E SIGLAS ............................................................................................ X
RESUMO ................................................................................................................................ XIII
ABSTRACT ............................................................................................................................... XIV
SUMÁRIO ............................................................................................................................... XV
1. INTRODUÇÃO ................................................................................................................... 1
1.1. BREVE HISTORIAL .............................................................................................................. 2
1.2. DESCRIÇÃO DO TEMA ....................................................................................................... 3
1.3. HIPÓTESES ............................................................................................................................ 4
1.4. JUSTIFICATIVA .................................................................................................................... 4
1.5. OBJECTIVOS ......................................................................................................................... 5
1.5.1. Objectivos Gerais ............................................................................................................ 5
1.5.2. Objectivos específicos ..................................................................................................... 5
1.6. METODOLOGIA ................................................................................................................... 5
1.7. APRESENTAÇÃO DOS CAPÍTULOS ................................................................................. 6
2. BREVE HISTORIAL DA COMPUTAÇÃO ...................................................................... 7
2.1. GERAÇÃO DOS COMPUTADORES ................................................................................... 7
2.2. SUPER COMPUTADOR ..................................................................................................... 12
2.3. GNU/LINUX ......................................................................................................................... 16
2.3.1. Linux & Windows ......................................................................................................... 18
3. FUNDAMENTOS DE PROCESSAMENTO DE ALTO DESEMPENHO ...................... 23
3.1. ARQUITECTURA COMPUTACIONAL (TAXONOMIA DE FLYNN) ........................... 27
3.1.1. Multiprocessadores ........................................................................................................ 31
3.1.2. Multicomputadores ........................................................................................................ 33
3.2. TENDÊNCIAS NA CONSTRUÇÃO DE MÁQUINAS PARALELAS .............................. 35
3.2.1. Processadores Vectoriais ............................................................................................... 35
3.2.2. Simmetric Multiprocessors (SMP) ................................................................................ 36
3.2.3. Distributed Shared Memory (DSM) .............................................................................. 37
3.2.4. Massively Parallel Process (MPP) ................................................................................ 38
3.2.5. Sistemas distribuídos ..................................................................................................... 39
3.2.6. Clusters .......................................................................................................................... 40
xvi
4. CLUSTER ......................................................................................................................... 41
4.1. TIPOS DE CLUSTER ........................................................................................................... 44
4.1.1. Cluster de alta disponibilidade (HA) ............................................................................. 44
4.1.2. Cluster de Balanceamento de carga (LB). ..................................................................... 46
4.1.3. Cluster de alto desempenho (HPC) ............................................................................... 47
4.2. COMBINAÇÃO DE CLUSTER .......................................................................................... 48
4.3. VANTAGENS DO CLUSTER DE ALTO DESEMPENHO ................................................ 48
5. CLUSTER DE ALTO DESEMPENHO/PROCESSAMENTO PARALELO .................. 51
5.1. UTILIZAÇÃO DE LINUX EM CLUSTER ......................................................................... 53
5.2. O AUMENTO DA DEMANDA POR PROCESSAMENTO PARALELO ......................... 53
5.3. ARQUITECTURAS COM MÚLTIPLOS PROCESSADORES .......................................... 56
5.4. VISÃO GERAL SOBRE PROGRAMAÇÃO PARALELA ................................................. 57
5.5. TÉCNICAS DE PROCESSAMENTO PARALELO ............................................................ 59
5.5.1. Programação multithread com OpenMP ....................................................................... 59
5.5.2. Troca de Mensagens com MPI ...................................................................................... 62
5.5.3. Programação Paralela em GPU com CUDA ................................................................. 63
6. CONFIGURAÇÃO DE UM CLUSTER DE ALTO DESEMPENHO .............................. 65
6.1. CLUSTER EM MAQUINAS VIRTUAIS ............................................................................ 66
6.2. CLUSTER EM MAQUINAS FÍSICAS ................................................................................ 66
6.3. ADICIONAR NÓS ............................................................................................................... 69
6.4. DEFINIÇÃO DE UM USUÁRIO PARA EXECUTAR TAREFAS .................................... 69
6.5. PREPARANDO O SISTEMA (SERVIDOR E NÓS):. ........................................................ 70
7. CONCLUSÃO E SUGESTÃO .......................................................................................... 89
8. REFERÊNCIAS BIBLIOGRÁFICAS ............................................................................. 91
9. ANEXO ............................................................................................................................. 94
1
1. INTRODUÇÃO
O desenvolvimento do nosso país na última década tem sido crescente, alinhar a
estratégia de negócio a tecnologia de informação tem sido encarada para muitas instituições
como um problema devido a altos custos financeiros dos recursos computacionais empregue,
que reflectem assim na qualidade dos serviços prestados, desempenhando assim um papel
importante nos processos produtivos, e de suporte ao negócio.
A crescente demanda por informações e a dependência dos recursos computacionais,
que tratam com rapidez e eficiência grandes volumes de dados, pela sociedade e pelo
mercado, exige uma disponibilidade de serviços, sem a ocorrência de paragens em maior
quantidade de tempo possível, já que as empresas tem no seu portefólio produtos que exigem
alta disponibilidade e desempenho, não podem ter seus sistemas comprometidos, sejam por
hora, minutos e até mesmo segundos.
A solução para esta necessidade são os supercomputadores, e a sua aquisição tem
custos elevados, na maior parte dos casos a sua compra não é rentável em termos de custos,
surgindo como alternativas os cluster.
Nos últimos anos as redes de computadores se tornaram mais rápidas e mais
confiáveis, permitindo a interligação de computadores pessoais de forma eficiente
possibilitando a criação de sistemas distribuídos, cluster. Cluster permite a formação de uma
imagem única do sistema, de forma que o usuário não perceba que estamos a trabalhar em
vários computadores conectados.
2
A computação em cluster ganhou destaque nos anos 80 com a convergência de três
importantes factores: microprocessadores de alta performance, redes de alta velocidade, e
ferramentas de computação distribuída de alta performance (YEO et al., 2006).
Segundo Karl Kopper (2005), cluster é um sistema paralelo ou distribuído que
constitui um conjunto de computadores interligados, que são utilizados como um recurso
computacional único.
Diante do exposto e da importância do tema, este trabalho tem por objectivo
desenvolver uma solução, descrevendo os passos, para implementação de cluster eficiente e
de baixo custo, envolvendo o sistema operacional GNU/Linux, sistema de código livre
baseado em Unix.
O facto de ter o código livre possibilita as empresas fazer personalização do sistema
para seu próprio cenário, obtendo assim melhor desempenho da tecnologia (FERREIRA,
2008).
1.1. BREVE HISTORIAL
A primeira ideia de cluster foi desenvolvida pela IBM na década de 60, com o
objectivo de interligar grandes mainframes. Mais tarde em 1994 surge nos laboratórios do
CESDIS - Center of Excellence in Space Data and Information Sciences, da NASA, uma das
soluções, quando engenheiros e pesquisadores tiveram a ideia de utilizar microcomputadores
comuns, para realizarem tal tarefa, bastava fazer com que vários deles, ligados em rede,
funcionassem como uma máquina – um computador virtual – também chamado de cluster. O
projecto contava com 16 computadores 486, hardware comum e de fácil acesso, executando a
plataforma GNU/Linux. (BUENO, 2007).
3
Segundo (PITANGA, 2003), o primeiro cluster recebeu o nome de BEOWULF, e até
hoje é conhecido como nome padrão para todos os clusters que têm configuração semelhante
ao primeiro cluster. O BEOWULF marcou um período de ouro para o Linux na área de super
computação, justamente por permitir que grande poder computacional pudesse ser alcançado
com equipamento disponível no mercado.
Cluster de alto desempenho, HPC (do inglês High Perfomance Computing), hoje em
todo mundo são comuns em grandes centros de pesquisas e industrias, que necessitam de
grande poder computacional, e um dos grandes factores é o preço relativamente baixo às
ofertas existentes nos mercados para supercomputadores. Hoje a utilidade dos clusters vai
desde a: meteorologia, astrofísica, exploração de petróleo, optimização, pesquisa operacional,
biotecnologia, tolerância a falhas, simulação de mercados financeiro, inteligência artificial,
servidores de internet, tratamento de imagens, jogos, e até renderização de efeitos visuais para
o cinema (BROWN, 2006).
A era da Supercomputação, no nosso pais ainda é miúda, e reconhecendo a amplitude
e valor da mesma, mesclando o papel da computação de alto desempenho hoje, e caindo o véu
da necessidade eminente da evolução das tecnologias de software voltadas a estas
arquitectura, decidi apresentar neste trabalho, a implementação de HPC usando Linux que
possibilita obter um desempenho superior a qualquer computador desktop disponível a baixo
custo.
1.2. DESCRIÇÃO DO TEMA
No nosso país, existem instituições que enfrentam inúmeros problemas no que tange a
elevada capacidade computacional com alto desempenho na sua solução, para suprir cálculos
complexos e repetitivos, reflectindo assim na qualidade do serviço prestado, tarefa esta,
executada por supercomputadores. A aquisição de supercomputadores, apesar de ser muito
4
poderosa, não é viável em alguns casos, tendo em vista o desenvolvimento de
microprocessadores poderosos hoje em dia, a baixo custo e de redes de alta velocidade para
atingirmos o alto desempenho.
1.3. HIPÓTESES
Face os problemas acima exposto, proponho as seguintes hipóteses para a sua
resolução:
1. Aquisição de Supercomputadores proprietários.
2. Construção de cluster beowulf, sistemas de processamento paralelo e
distribuído, solução de baixo custo usando software livres.
3. Compra de cluster comercial, configurações simplificadas e de custos mais
altos usando software proprietário e hardware sofisticados.
1.4. JUSTIFICATIVA
É crescente o número de projectos no nosso país que necessitam de grande poder de
processamento, onde normalmente são empregues os supercomputadores. Um computador
deste porte tem custos elevadíssimos, os clusters representam uma alternativa. No final deste
trabalho, o mesmo servirá de orientação inicial para usuários que queiram Implementar ou
atingir alto desempenho usando cluster, a partir de configurações manuais a custo
relativamente baixos, usando software livres. E estudar os paradigmas da computação paralela
de forma a solidificar os conhecimentos mais abrangente sobre cluster HPC.
O cluster tem como principal vantagem seu valor de custo e benefício muito inferior
em relação as outras tecnologias existentes no mercado no que toca a disponibilidade, alto
desempenho, e balanceamento de cargas, conforme (PITANGA, 2007).
5
1.5. OBJECTIVOS
Este trabalho servirá como primeiro contacto a área de supercomputação. Respostas as
questões “o que é um supercomputador? E cluster é a alternativa a supercomputação?”. Será
apresentado aos objectivos geral e específico, que se pretende atingir com este projecto de
pesquisa.
1.5.1. Objectivos Gerais
Realizar estudo sobre computação paralela e cluster, permitindo a aquisição de
conceitos básicos sobre o tema e como resultado final a implantação de um cluster de alto
desempenho usando o Linux para resolução dos problemas acima referenciados.
1.5.2. Objectivos específicos
Os objectivos específicos deste trabalho são:
Aprender a origem da computação e fundamentos do processamento de alto
desempenho.
Descrever alguns recursos do Linux e vantagens do Cluster.
Configurar um cluster de alto desempenho usando Linux Ubuntu.
Realizar um teste básico.
1.6. METODOLOGIA
Para o desenvolvimento deste projecto, utilizar-se-á referências bibliográficas sobre
clusters, equipamentos de redes e materiais didácticos de apoios.
O estudo deste projecto contará com uma abordagem básica sobre paralelismo
estritamente ligado ao tema do projecto, para depois partir para uma abordagem mais prática
com implantação de alguns conceitos teóricos pré-estudados. E no final iniciaremos a
6
configuração passo a passo de um cluster HPC de baixo custo e considerações futuras de
como melhorar o seu desempenho.
1.7. APRESENTAÇÃO DOS CAPÍTULOS
Este trabalho de fim de curso conta com 7 (sete) capítulos.
No capítulo 1, constitui a apresentação global do tema incluindo breve histórico,
importância e justificativa do tema. O capítulo 2 faz uma abordagem histórica da computação
desde a primeira geração até a era dos supercomputadores, e sem esquecer do papel do
GNU/Linux no desenvolvimento dos supercomputadores de hoje.
O capitulo 3 contem fundamentos teóricos, necessários para um melhor entendimento
sobre paralelismo, onde faz-se uma abordagem sobre arquitecturas computacional baseando
se na taxonomia de FLYNN.
O capítulo 4, fala de clusters, tipos de clusters, vantagens e desvantagens. O capitulo
5, debruça se mais ao cluster de processamento paralelo ou alto desempenho, e suas
ferramentas necessárias, e o funcionamento do MPI (do inglês Message Passing Interface).
O capítulo 6, representa a parte prática do projecto, configuração de um cluster HPC, e
finamente o capítulo 7, mostrando as considerações finais e futuras, do cluster construído para
sua melhoria.
7
2. BREVE HISTORIAL DA COMPUTAÇÃO
De acordo com TANENBAUM (2003), sempre que nos apegamos a evolução dos
computadores, quantidade disponível, variedades de modelos, logo, associamos estes
dispositivos a nova tecnologia. Não podemos nos esquecer jamais que a tecnologias utilizadas
na construção dos mesmos evoluíram, mas os conceitos básicos descendem da década de 40.
2.1. GERAÇÃO DOS COMPUTADORES
Primeira Geração
A primeira geração de computadores, na década de 1940 estabeleceu os conceitos
básicos da organização dos computadores electrónicos. Os computadores desta época
utilizavam válvulas electrónicas e uma quantidade enorme de fios. Eram muito grandes e
lentos, além de aquecerem muito. Estes computadores possuíam somente dois níveis de
linguagem de programação:
O nível da linguagem de máquina, onde toda a programação era feita, através de zeros
e uns.
E o nível da lógica digital, local na qual os programas eram efectivamente executados,
sendo formado nesta geração por válvulas e depois por transístores, circuitos
integrados (CI).
Em 1946, Von Neumann sugeriu um sistema binário, que viria a se tornar à base de
outros projectos de desenvolvimento computacional subsequente. A máquina proposta por
Von Neumann era composta por uma unidade de processamento centralizada, responsável
pela execução de operações aritméticas e lógicas, uma unidade de controlo de programa, na
qual determinava quais acções executar, uma unidade de memória principal e uma unidade de
entrada e saída de dados (WEBER, 2000).
8
De acordo com PITANGA (2004), o processador executa as instruções
sequencialmente, de acordo com a ordem estabelecida por uma UC (unidade de controlo). O
modelo lógico de computador proposto por Von Neumann pode ser descrito pela figura
abaixo:
Figura 1- Arquitectura de Von Neumann (wikipedia, 2013)
Figura 2- Computadores baseado na arquitectura de Von Neumann, ENIAC(fi.edu, 2013)
Segunda Geração
A segunda geração de computadores ficou marcada pela invenção do transístor que
venho a substituir as válvulas electrónicas e a troca dos fios de ligações por circuitos
impressos. Com estas trocas, os computadores não só ficaram mais rápidos, mas tiveram
também uma redução no tamanho dos equipamentos, nos custos e no consumo de energia.
Além disso, com a troca das válvulas pelos transístores, não era mais necessário um tempo
9
para aquecimento antes do seu funcionamento. Nesse período surgem também alguns
dispositivos como impressoras, fitas magnéticas e discos de armazenamento (ufpb.br, 2013).
Figura 3 - Exemplo de computador comercializado na segunda geração (ufpb.br, 2013)
Terceira Geração
A invenção dos CI proporcionou mais um grande avanço na evolução da computação
e com eles surgem os computadores de terceira geração. Os transístores foram substituídos
por esta nova tecnologia e sua utilização tornou os equipamentos mais compactos, rápidos e
confiáveis, com baixo consumo de energia, e um custo ainda menor que os das gerações
anteriores. Nesta geração, também foram desenvolvidas as linguagens de programação de alto
nível orientada a procedimentos.
Figura 4 - Comparação do circuito integrado com uma moeda (ufpb.br, 2013)
10
Quarta Geração
O período decorrente de 1970 até os dias de hoje, ficou caracterizado pelo
aperfeiçoamento das tecnologias já existentes, denominando-se os computadores da quarta
geração. Tecnologias de integração dos CI foram desenvolvidas, incorporando milhões de
componentes electrónicos em um pequeno espaço ou chip, denominados por escala de
integração (ufpb.br, 2013):
Figura 5 - Computador pessoal de quarta geração (ufpb.br, 2013)
Escala de integração grande (LSI - Large Scale of Integration)
Escala de integração muito grande (VLSI - Very Large Scale of Integration)
Escala de integração ultra grande (ULSI - Ultra Large Scale of Integration).
Assim, avanços significativos com a optimização dos componentes e o surgimento dos
microprocessadores e microcomputadores fizeram com que houvesse uma explosão no
mercado de computadores a partir de 1980, sendo fabricados em escala comercial, uma vez
que, computadores anteriores a esta geração eram restritos a poucas empresas e universidades,
devido a custos e tamanho dos equipamentos. A partir daí, os avanços tecnológicos vem
sendo cada vez maior até chegar nos pc actuais, com velocidades cada vez maiores e com
custos muito mais baixo, se comparados com as tecnologias anteriores (PITANGA, 2003).
11
Figura 6 - Computador de quinta geração (ufpb.br, 2013)
Quinta Geração
A computação da quinta geração ou computador da quinta geração, deve o seu nome a
um projecto gigantesco de pesquisa governamental e industrial no Japão durante a década 80
do século XX. O projecto tinha como principal objectivo a criação de um computador que
“marcasse uma época” com performance semelhante a um supercomputador e capacidade
prática de inteligência artificial (ufpb.br, 2013)..
Visto que a anterior geração de computadores (quarta geração) se tinha focado no
aumento do número de elementos lógicos numa única CPU, acreditava-se plenamente na
altura que a quinta geração iria virar-se completamente para a utilização de quantidades
enormes de CPU’s para um desempenho maior das máquinas.
Sendo assim, a indústria da computação é uma das que mais cresce e é abastecida
pelos desenvolvimentos tecnológicos rápidos na área de software e hardware. Os avanços de
tecnologias de hardware incluem o desenvolvimento e fabricação de chips e processadores
rápidos e baratos, com largura de banda elevada e baixa latência de interconexão. Destacam-
se recentemente avanços na tecnologia VLSI, que deram um dos principais passos no
desenvolvimento de computadores sequenciais e paralelos. Assim como o desenvolvimento
12
de hardware teve grande evolução, o desenvolvimento de software também evoluiu
rapidamente. Softwares maduros como sistemas operativos, linguagens de programação e
ferramentas de desenvolvimento estão disponíveis no mercado a fim de suprir as necessidades
comerciais (BUYYA, 1999).
Cada era da computação ficou caracterizada pelo inicio do desenvolvimento de
arquitecturas de hardware, seguido pelo desenvolvimento de sistemas operativos e
compiladores, até alcançar seu crescimento comercial.
Figura 7 – Supercomputador Jaguar, da classe Cray XT5 (olcf.ornl.gov, 2013)
2.2. SUPER COMPUTADOR
Supercomputador é um computador com altíssima velocidade de processamento e
grande capacidade de memória. Tem aplicação em áreas de pesquisa que grande quantidade
de processamento se faz necessária, como pesquisas militares, científica, química, medicina.
Supercomputadores são usados para cálculos muito complexos e tarefas intensivas, como
problemas envolvendo física quântica, mecânica, meteorologia, pesquisas de clima,
modelagem molecular (computação nas estruturas e propriedades de compostos químicos,
macromoléculas biológicas, polímeros e cristais) e simulações físicas, como simulação de
13
aviões em túneis de vento, simulação da detonação de armas nucleares e investigação sobre a
fusão nuclear (wikipedia, 2013).
O que diferencia dos computadores normais, é que vários processadores, hd´s e
módulos de memória são combinados para criar um sistema incrivelmente rápido
(MORIMOTO, 2012).
Os primeiros supercomputadores foram criados na década de 1960 por Seymour Cray.
Seymour Cray fundou sua própria empresa, a Cray Research, em 1970 e dominou o mercado
da supercomputação durante 25 anos (1965-1990).
Máquinas estas, que inovaram em arquitectura, no entanto, o aumento da eficiência
computacional estava limitado pelo desenvolvimento tecnológico, principalmente pelo facto
dos processadores terem que terminar uma tarefa antes de iniciar outra. Dessa forma,
percebeu-se que a divisão de tarefas traria avanços significativos quanto ao desempenho das
máquinas, surgindo a partir desta época dois caminhos distintos: Arquitecturas paralelas e
sistemas distribuídos (PITANGA, 2004)
As principais características dos supercomputadores são:
Velocidade de processamento: triliões de operações de ponto flutuante por segundo
(TFlops).
Tamanho: requerem instalações e sistemas de refrigeração especiais;
Dificuldade de uso: escolhido por especialistas;
Clientes usuais: grandes centros de pesquisa;
Penetração social: praticamente zero;
Impacto social: muito importante no espaço da investigação, a partir do momento em
que fornece cálculos em alta velocidade, permitindo, por exemplo, analisar a ordem do
14
genoma, o número pi, números complexos, o desenvolvimento de cálculos para
problemas físicos que requerem uma baixíssima margem de erro, etc.
Parques instalados: menos de mil em qualquer lugar no mundo;
Custo: actualmente (2010) até centenas de milhões de dólares cada (~ US$ 225MM o
Cray XT5) (fonte: wikipedia, 2013).
Actualmente, os supercomputadores estão com capacidades altíssimas de poder de
processamento. O supercomputador mais rápido na actualidade opera a uma velocidade de
33,86 petaflops (34 quatrilhões de cálculos matemáticos por segundo), tem 32.000
processadores Ivy Bridge e 48.000 co-processadores Xeon Phi da Intel, e tem 12,4 petabytes
de espaço de armazenamento e com um consumo energético de total de 17,8 MW, arrefecido
por um sistema de ar de circuito fechado. Pertence a National University for Defense
Technology (NUDT) da China e chama se TIANHE-2, também conhecido por Milkyway-2,
foi testado em junho deste ano (2013) e entra em funcionamento no final do ano. O TIANHE-
2 roda o Kylin Linux, uma versão do Linux desenvolvida pela NUDT, quando estiver a
funcionar fornecerá uma plataforma aberta para o ensino, pesquisa, e a prestação de serviços
de computação de alto desempenho para o sul da China (cri.cn, 2013).
Figura 8 - Tinhae 2, o supercomputador mais rápido do mundo (cri.cn, 2013)
15
Tabela 1- Relação dos 5 supercomputadores mais rápidos do mundo (top500.org, 2013)
Nome Fabricante Processadores Perfomance
Max
Perfomance
teórico Memoria SO
Tianhe-2 NUDT 3.120.000
33,862.7
TFLOP/s
54,902.4
TFLOP/s
1.024.000
GB
Linux
Titan Cray Inc. 560.640
17,590
TFLOP/s
27,112.5
TFLOP/s
710.144
GB
Linux
Sequoia IBM 1.572.864
17,173.2
TFLOP/s
20,132.7
TFLOP/s
1.572.864
GB
Linux
K Computer Fujitsu 705.024
10,510
TFLOP/s
11,280.4
TFLOP/s
1.410.048
GB
Linux
Mira -
BlueGene
IBM 786.432
8,586.6
TFLOP/s
10,066.3
TFLOP/s
-- Linux
Se olharmos para tabela acima, que representa o top 5 dos melhores
supercomputadores do mundo, vemos logo que todos usam o Linux como sistema operativo.
Segundo o site top500.org, 95,2% dos sistemas operativos usados nos supercomputadores são
da família Linux (TOP500.ORG, 2013).
fonte: top500.org
Supercomputadores são sistemas de processamento de dados com o poder
computacional altíssimo, capaz de realizar cálculos complexos. Eles são usados
principalmente em instituições de pesquisa e grandes corporações e são projectados para
executarem tarefas específicas com eficiência.
16
2.3. GNU/LINUX
O Linux e um sistema operativo criado à partir do Unix, como alternativa funcional e
acessível a comunidade, devido aos altos preços do unix na época.
O Linux foi desenvolvido por Linus Torvalds, baseado no Unix, desenvolvido em
meados da década de 60, por um grupo de programadores da Bell, Telephone Labs. da AT&T,
juntamente com a GE (General Electric) o projecto MAC do MIT (Massachusetts Institute of
Technology), desenvolvem o sistema operativo Multics. Porém, como ele não atinge seu
propósito inicial, logo o Laboratório Bell retira-se do projecto devido a atrasos dos prazos
(WELSH; KAUFMAN, 1995).
Por causa de um jogo chamado Space Travel usado como passatempo durante o
projecto Multics, dois engenheiros de software da AT&T, Ken Thompson e Dennis Richie,
que não tinham mais acesso ao sistema, resolveram criar um sistema operativo rudimentar que
possibilitasse a portabilidade do jogo em um computador PDP-7, que já não era mais
utilizado. Desta forma nasceu o sistema operativo chamado Unics, em troca ao Multics e que
de alguma forma, passou a ser escrito posteriormente como Unix (GNU.ORG, 2013).
Já no início da década de 70, o Unix é reescrito em linguagem C pelo próprio criador
da Linguagem, Dennis Ritchie, fazendo com que seu uso dentro da AT&T crescesse tanto,
que um grupo de suporte interno para o sistema acabou sendo criada. Eles forneciam cópias
do código fonte para fins educacionais em universidades.
Em 1983, Richard Stallman, um cientista do MIT lança o projecto GNU (GNU´s not
Unix) que tinha a pretensão de criar um sistema operacional do tipo Unix gratuito, em defesa
de muitos programadores que haviam contribuído para o aprimoramento do Unix e
consideravam injusto que a AT&T e outros se apoderassem do fruto deste trabalho. No ano
seguinte, o projecto GNU é iniciado oficialmente, e para efeito de organização, Stallman e
17
outros criam a Free Software Foundation (FSF), uma corporação sem fins lucrativos que
buscava promover softwares gratuitos, eliminando restrições à cópia, formulando assim a
licença GPL (General Public License)(WIKIPEDIA, 2013).
De acordo com o mesmo site, no final da década de 80, um estudante finlandês
chamado Linus Torvalds inicia um processo de desenvolvimento do núcleo como um projecto
particular inspirado no sistema Minix, um sistema operacional do tipo Unix escrito por
Andrew Tannenbaum, Linus chama-o de Linus's Minix. Depois de um certo tempo de
trabalho, Linus envia uma mensagem para o grupo de discussão do Minix, na qual afirma
estar trabalhando em uma versão livre de um sistema operacional similar ao minix para
computadores AT-386, tendo finalmente alcançado o estágio de utilização, e estava disposto a
colocar o código-fonte disponível para ampla distribuição.
Como a FSF já tinha obtido ou escrito vários componentes importantes do sistema
operativo GNU, com excepção de um kernel, foi uma questão de tempo até que em 5 de
Outubro de 1991, Linus Torvalds anuncia a primeira versão oficial do Linux, versão 0.02
tendo sucesso ao executar alguns compiladores, bash, gcc, e outros. No ano seguinte, o Linux
se integra a GNU com o objectivo de produzirem sistema operacional completo
(WIKIPEDIA, 2013).
Desde então, muitos programadores e usuários espalhados pelo mundo, têm seguido as
ideais de Richard Stallman e Linus Torvalds, e contribuído para o desenvolvimento do Linux.
No início, o Linux era utilizado por programadores ou com conhecimentos, e usavam
a linha de comando. Hoje com o chamado de Linus em 1991, isso mudou e existem diversas
empresas que criam os ambientes gráficos, distribuições cada vez mais amigáveis de forma
que uma pessoa com poucos conhecimentos conseguem usar o Linux (interface gráfica KDE e
Gnome). Hoje o Linux e um sistema estável.
18
Figura 9 - Logomarca do projecto Gnu (gnu.org, 2013)
Figura 10 - Tux a mascote do Linux (wikipedia, 2013)
Inicialmente desenvolvido e utilizado por grupos de entusiastas em computadores
pessoais, os sistemas operativos com núcleo Linux passaram a ter a colaboração de grandes
empresas como a IBM, Sun, HP, Novell, Google, e outras.
2.3.1. Linux & Windows
O lançamento do Linux, como alternativa ao sistema operativo dominante da
Microsoft, causou impacto no mundo inteiro principalmente pelo facto de ter o código-fonte
aberto, possibilitando sua alteração por qualquer um que tivesse habilidade. Começava a era
do software livre e por ironia, o Linux teve sucesso em rejuvenescer um dos mais antigos
sistemas operacionais até então em uso, o Unix (WELSH; KAUFMAN, 1995).
19
Tabela 2 - Linux & Windows (diffen.com, 2013)
GNU/Linux Windows
O que é? Um exemplo de software e SO opensource Da família do SO da Microsoft, e o mais
famoso do mundo
Preço Gratuito ou baixo custo 50 - 450 USD dependendo da licença
Facilidade Cada vez mais facilitado para os usuários
menos experientes
Mais avançado no que toca a facilidade de
uso. Mais fácil que o Linux
Desenvolvimento O kernel, e desenvolvido pela comunidade, e
o Linux Torvalds superviona.
A Microsoft criou o SO, mas permite que
outros fabricantes de computadores
distribuem seus próprios pc com o SO pré-
instalado
Utilidade
Pode ser instalado em uma ampla variedade
de hardware de computador, que vão desde
telefones, tablets e videogame, para
mainframes e supercomputadores.
Em desktops, pc, servidores e alguns
telefones.
Distribuição
Opensource, através da partilha e
colaboração de varias comunidades, fóruns,
vários fornecedores
Pela Microsoft
GUI Duas interfaces gráficas, KDE e Gnome.
Opcional
A interface e um componente integral do
SO
Extensões Ext2, Ext3, Ext4, Jfs, ReiserFS, Xfs, Btrfs,
FAT, FAT32, NTFS FAT, FAT32, NTFS, exFAT
Modo Texto BASH é o padrão.
Suporta vários interpretadores de comando
usa um shell de comando e cada versão do
Windows tem um único interpretador de
comandos com comandos dos, recentemente
a adição do PowerShell opcional, usa mais
comandos do Unix.
Segurança Registou 60 a 100 vírus até a data de hoje, e
nenhum deles está no activo.
De acordo com o Dr. Nic Peeling e Dr.
Julian Satchell’s, já houve mais de 60.000
vírus
Detecção de
ameaças e
solução
é muito rápido, sempre que há quaisquer
mensagens de usuários Linux em qualquer
tipo de ameaça, vários desenvolvedores
começam a trabalhar nele a partir de
diferentes partes do mundo.
Depois de detectar uma ameaça no SO,
geralmente libera um patch que pode
corrigir o problema e pode levar mais de 2/3
meses. Às vezes, mais cedo, lança patches e
actualizações semanais.
20
Em termos técnicos, o Linux é apenas o núcleo do sistema operativo, responsável
pelos serviços básicos de escalonamento de processos, memória virtual, tratamento de
excepções, gerenciamento de arquivos, dispositivos entrada/saída etc. No entanto, a maior
parte das pessoas utiliza o termo “Linux” referindo-se ao sistema completo – núcleo junto das
aplicações, interfaces gráficas, jogos e outros. Estas aplicações foram desenvolvidas em sua
maior parte graças ao projecto GNU, daí a razão de muitos desenvolvedores denominarem o
sistema completo como “GNU/Linux” (WELSH; KAUFMAN, 1995).
Como o Linux pode ser modificado e distribuído por qualquer um, naturalmente
começaram a surgir as tão faladas distribuições, ou “distros” como são carinhosamente
chamadas em alguns círculos. As mais famosas são, com certeza, Ubuntu, RedHat, Debian,
Suse, Mandriva, Fedora, e tantos.
Falar de popularidade em todo mundo devido à facilidade de manuseio, configuração e
por disponibilização de infinidade de pacotes (softwares) nos repositórios on-line de
programas sem falar do Ubuntu hoje, é extremamente chocante, razão pela qual é a nossa
escolha para implementação da parte prática.
Os programas são instalados e executados no Linux de uma forma muito mais
eficiente, segura e elegante do que em outros sistemas operativos: o usuário não precisa se
preocupar em qual directório o programa deve ser instalado ou muito menos se irá contrair um
vírus ao fazê-lo, pois os pacotes Linux vêm pré-compilados, diferentemente dos executáveis
“.exe” do Windows. Além do mais, no Linux não é necessário ficarmos horas a procura por
programa, pois as distribuições vêm com a maioria dos programas essenciais para o trabalho,
como editores de texto, planilhas, utilitários para gravação de CDs, tocadores de música e
DVD, entre outros. Na pior hipótese, caso o usuário não encontre o programa que deseja,
basta digitar um comando simples em um terminal, que o Linux se encarrega
21
automaticamente de procurá-lo nos repositórios on-line, fazendo o seu download e instalação
sem intervenção externa (BUENO, 2002).
De acordo com o mesmo autor, além do poder do Linux em transformar qualquer
computador pessoal em uma estação de trabalho com o poder do Unix, ele também é utilizado
para controlar grandes servidores, devido às suas características de flexibilidade e estabilidade
para lidar com grandes arrays de disco e sistemas multiprocessados, com aplicações que vão
desde servidores web a bases de dados corporativas.
A utilização do Linux como sistema operativo em um ambiente de Cluster se encaixa
muito bem, ainda mais para fins académicos. Segundo os administradores do Tianhe-2, – um
dos maiores Clusters em operação, situado na China – a utilização do Linux não se deve ao
facto de ser gratuito e sim porque ele tem o código fonte aberto, desempenho de rede superior,
e está sendo continuamente desenvolvido de maneira aberta e acessível (WARREN, 2002).
Entretanto, vários outros factores podem influenciar em tal escolha, como facilidade
de manuseio, configuração, compatibilidade de hardware e até familiaridade do projectista
com a distribuição em questão, visto que podem haver diferenças significativas entre elas
dependendo da aplicação, apesar de todas carregarem o nome Linux.
22
23
3. FUNDAMENTOS DE PROCESSAMENTO DE ALTO DESEMPENHO
Em 1943, um matemático Howard Aiken, começou um projecto que abriu caminho
para o surgimento dos primeiros grandes computadores. Nomeado de MARK I, o computador
realizava, em um dia, cálculos que antes consumiriam seis meses. Juntamente com o início da
Segunda Guerra Mundial, Alan Turing utilizou seu projecto Colossus para decifrar mensagens
interceptadas de exércitos inimigos. Colossus, primeiro computador a utilizar válvulas,
procurava coincidências entre as mensagens cifradas e os códigos conhecidos, em uma taxa
de 5.000 caracteres por segundo.
Com um projecto iniciado em 1942 e finalizado em 1945, coincidindo com o final da
Segunda Guerra Mundial, o Eletronic Numerical Integrator and Calculator (ENIAC),
projecto de John Mauchly e Presper Eckert com aporte financeiro do exército americano,
usando válvulas eletrônicas, alcançou clock de 100 khz. O seu sucessor, Electronic Discrete
Variable Automatic Computer (EDVAC), foi modelo para a construção de outros
computadores. Planejado por John von Neumann, principal ícone do desenvolvimento de
computadores do pós-guerra, a máquina Institute of Advanced Studies (IAS), já processava
informações de forma binária e armazenava tanto dados quanto o programa em uma memória
interna. Os complexos cálculos de balística passaram a ser executados em 30 segundos, contra
12 horas dos métodos anteriores. Findando a primeira geração de computadores a
International Business Machines (IBM) lançou o modelo 704 que contemplava componentes
de hardware exclusivos para dados em ponto-flutuante.
A geração posterior dos computadores é caracterizada pela substituição das válvulas
pelos transístores e o início do uso de computadores para fins comerciais. Em 1956, surgiu o
primeiro computador transistorizado. Inventado em 1948, nos Laboratórios da Bell , o
transístor era mais rápido e mais confiável. Com uma dimensão aproximada de 100 vezes
24
menor que uma válvula, não precisava de tempo para aquecimento e consumia menos energia.
Alguns computadores desta geração eram programados em linguagem montadora e já faziam
cálculos em microssegundos (milionésimos de segundos). Fabricados pela Digital Electronic
Computer (DEC), surgem em 1961 os computadores da família Programmed Data Processor
(PDP), dando origem à indústria dos chamados minicomputadores. O modelo 6600 da
companhia Control Data Corporation (CDC), em 1964, foi o primeiro expoente dos
computadores que poderiam executar instruções em paralelo. Exclusivamente projectado para
processamento científico, se bem programado, poderia executar 10 instruções ao mesmo
tempo (TANENBAUM 2003).
De acordo o autor, os circuitos integrados, associação de vários transístores em um
mesmo chip, e a miniaturização de outros componentes electrónicos, propiciaram um novo
avanço e com eles surgiram os computadores de terceira geração. Ainda mais confiáveis e
menores, pela proximidade dos componentes, os circuitos integrados tornaram os
computadores mais compactos, rápidos, baratos e com baixo consumo de energia. Os
representantes mais importantes foram os modelos da família System/360, fabricados pela
IBM , projectados tanto para aplicações científicas quanto para aplicações comerciais. Uma
outra inovação desta geração foi a implantação do conceito de multi-programação e um
grande espaço de endereçamento de memória.
A próxima geração dos computadores foi marcada pela técnica VLSI, que possibilitou
a inclusão de dezenas de milhares e, posteriormente, centenas de milhões de transístores em
um único chip. Surge então o microprocessador e com ele a era da computação pessoal.
Assim, os fabricantes dividiram esforços na fabricação de supercomputadores e computadores
pessoais. Os supercomputadores eram dominantes na área científica, que é baseada em
cálculos complexos, e nas empresas, com vários terminais acoplados executando aplicações
25
comerciais. Os Personal Computers (pcs) alavancaram as aplicações integradas como editores
de texto, planilhas electrónicas, manipuladores de imagens, entre outros.
Ao longo do tempo, uma série de técnicas e recursos sofisticados da supercomputação
foram incorporados, sucessivamente, aos microprocessadores utilizados em computadores
pessoais e estações de trabalho. Acreditava-se, na década de 80, que o aumento do
desempenho de uma máquina dependia apenas e tão-somente da criação de processadores
mais rápidos e eficientes, porém havia outros empecilhos, tais como:
Alto custo e longos prazos, na pesquisa e projecto de novas arquitecturas de hardware;
Necessidade de se trabalhar com tecnologia de ponta;
Limitação e dependência de outros componentes como memória e dispositivos de
armazenamento;
Uma esperada saturação da tecnologia, ou seja, em um determinado momento a
tecnologia aplicada aos processadores não conseguirá miniaturizar e colocar tantos
transístores quanto necessários para aumentar o poder de processamento do chip em questão.
A computação passou por um processo evolutivo intenso, em termos de hardware e
software, a fim de proporcionar maior desempenho e ampliar o leque de aplicações que
podem ser computacionalmente resolvidas de maneira eficiente. Diversas técnicas e
tecnologias foram propostas para se chegar o mais próximo possível do estado da arte e
construir componentes complexos em chips cada vez menores (STALLINGS 2002).
Os Grandes avanços ocorridos no processo de fabricação de microprocessadores
actuais estão baseados no aumento do pipeline, melhor organização da hierarquia de memória
cache, hyper-threading, dual core, dentre outros.
26
Estas inovações trazem mais eficiência e velocidade aos microprocessadores, dando
oportunidades aos softwares, principalmente os de propósito geral, um excelente ambiente de
execução. Entretanto, essa evolução não é suficiente para suprir a exigência de alguns
softwares específicos que consomem facilmente os recursos computacionais oferecidos pelas
máquinas convencionais (modelo de von Neumann).
O tratamento de grandes problemas, principalmente das áreas científicas como:
processamento de imagens e sinais, inteligência artificial, mineração de dados, física
molecular, previsão meteorológica, estudos sísmicos, pesquisas militares, aerodinâmica de
aviões e mísseis, exploração de petróleo, diagnóstico médico, entre outras, demandam o uso
de máquinas com múltiplos processadores ou ainda supercomputadores proprietários,
fornecidos por grandes empresas. Ambas as soluções oferecem grande desempenho, mas
apresentavam problemas no elevado custo e na baixa escalabilidade.
Baseado nas dificuldades apresentadas, Donald Becker e Thomas Sterling, em 1993,
na NASA, tiveram a ideia de juntar computadores pessoais para um trabalho cooperativo
(STERLING & Lusk 2003) e (BELL & GRAY 2002). Com o grande sucesso desta
experiência, baptizada de cluster, conseguiram alcançar níveis de processamento equivalentes
aos de supercomputadores da época, mas por uma fracção do seu preço.
Segundo (FRANCO, 2004), cluster é um conjunto de máquinas ou nós, normalmente
sem necessidade de periféricos, interligadas via rede, que trabalham em conjunto, trocando
informações entre si para solucionar uma determinada tarefa.
Como já foi mencionado, a estrutura do cluster apresenta vantagens competitivas em
relação a outros ambientes multiprocessador, tanto de memória compartilhada quanto
distribuídas, além do custo, que em geral é menor, oferece uma maior flexibilidade com um
proporcional poder de processamento (STALLINGS 2002).
27
Isto é possível pela utilização de componentes padrão de mercado, ligados por uma
rede tradicional de interconexão, que, através de softwares livres e programação paralela,
fornecem um ambiente propício para a comunicação e sincronização das tarefas em execução
(STERLING & Lusk 2003).
Assim, o aprimoramento dos computadores pessoais, a redução dos preços e a
excelente relação custo/benefício apresentada pelos clusters tiveram um impacto notório nos
centros de pesquisas, que, novamente, vislumbraram boas oportunidades para solucionar seus
problemas de grande escala.
3.1. ARQUITECTURA COMPUTACIONAL (TAXONOMIA DE FLYNN)
A classificação dos ambientes de hardware mais aceite na área de arquitectura de
computadores é a conhecida por taxonomia de Flynn, (FLYNN 1974), proposta de Michael J.
Flynn em 1966 e publicada pela IEEE em 1972.
Esta classificação distingue a arquitectura de computadores, de acordo com o fluxo de
instruções e de dados leva em consideração o número de instruções executadas em paralelo
versus o conjunto de dados para os quais as instruções são submetidas. Desta forma, a
taxonomia de Flynn estabeleceu as seguintes classificações de computadores (DANTAS
2005):
Tabela 3 - Classificação de arquitecturas paralelas, segundo FLYNN
SD (Single Data) MD (Multiple Data)
SI (Single Instruction) SISD
Maquinas de Von Neumann
SIMD
Maquinas Array
(CM-2, MasPar)
MI (Multiple Instruction) MISD
Sem representante
MIMD
Multiprocessadores e
Multicomputadores (nCube,
Intel Paragon, Cray T3D)
28
• SISD (Single Intruction Single Data) - Computadores com estas características são
aqueles que executam uma instrução de um programa de cada vez. Na Figura 11, o fluxo de
instruções (linha contínua) alimenta uma unidade de controle (C) que activa a unidade
central de processamento (P). A unidade P, por sua vez, atua sobre um único fluxo de dados
(linha tracejada), que é lido, processado e reescrito na memória (M). Nessa classe, são
enquadradas as máquinas Von Neumann tradicionais com apenas um processador, como
microcomputadores pessoais e estações de trabalho.
Figura 11- Arquitectura SISD
• MISD (Multiple Instruction Single Data) - não se tem conhecimento de arquitectura
de máquinas com múltiplas instruções trabalhando com um único conjunto de dados. A
Figura 12, mostra múltiplas unidades de processamento P, cada uma com sua unidade de
controlo própria C, recebendo um fluxo diferente de instruções. Essas unidades de
processamento executam suas diferentes instruções sobre o mesmo fluxo de dados. Na
prática, diferentes instruções operam a mesma posição de memória ao mesmo tempo,
executando instruções diferentes. Como isso, até os dias de hoje, não faz qualquer sentido,
além de ser tecnicamente impraticável, essa classe é considerada vazia
29
Figura 12 - Arquitectura MISD
As máquinas paralelas concentram-se nas duas classes restantes, SIMD e MIMD.
No caso SIMD (Single Instruction Multiple Data), uma única instrução é executada ao
mesmo tempo sobre múltiplos dados. O processamento é controlado por uma única unidade
de controle C, alimentada por um único fluxo de instruções. A mesma instrução é enviada
para os diversos processadores P envolvidos na execução. Todos os processadores executam
suas instruções em paralelo de forma síncrona sobre diferentes fluxos de dados (Figura 13).
Na prática, pode-se dizer que o mesmo programa está sendo executado sobre diferentes dados,
o que faz com que o princípio de execução SIMD assemelhe-se bastante ao paradigma de
execução sequencial. É importante ressaltar que, para que o processamento das diferentes
posições de memória possa ocorrer em paralelo, a unidade de memória M não pode ser
implementada como um único módulo de memória, o que permitiria só uma operação por vez.
Nessa classe, são enquadradas as máquinas Array como CM-2.
• SIMD (Single Instrucion Multiple Data) - neste tipo de arquitectura existe, também,
a execução de uma única instrução. Todavia, devido a existência de facilidades em hardware
para armazenamento (um vector ou array), a mesma instrução é processada sob diferentes
itens de dados, ou seja, só um programa, está sendo executado, em uma máquina MIMD
30
(Multiple Instruction Multiple Data), cada unidade de controlo C recebe um fluxo de
instruções próprio e repassa-o para sua unidade processadora P para que seja executado sobre
um fluxo de instruções próprio (Figura 13). Dessa forma, cada processador executa o seu
próprio programa sobre seus próprios dados de forma assíncrona.
Figura 13 - Arquitectura SIMD
• MIMD (Multiple Intruction Multiple Data) - arquitectura caracterizada por possuir
múltiplos fluxos de instruções e múltiplos fluxos de dados, envolve múltiplos processadores,
executando diferentes instruções em diferentes conjuntos de dados, de maneira independente.
É modelo para a maioria dos computadores paralelos.
O princípio MIMD é bastante genérico, pois qualquer grupo de máquinas, se analisado
como uma unidade (executando, por exemplo, um sistema distribuído), pode ser considerado
uma máquina MIMD. Nesse caso, como na classe SIMD, para que o processamento das
diferentes posições de memória possa ocorrer em paralelo, a unidade de memória M não
pode ser implementada como um único módulo de memória, o que permitiria só uma
operação por vez.
31
Figura 14 - Arquitectura MIMD
Sabe-se que a comunicação e o sincronismo dos processos em execução são
directamente relacionados à organização da memória. Sendo assim, a classe MIMD, proposta
por Flynn, pode ainda, segundo (TANENBAUM 2003), ser subdividida em duas novas
categorias, como mostra a Figura 15: Multiprocessadores e Multicomputadores.
Figura 15 - Classificação segundo o compartilhamento de memória (TANENBAUM 2003)
3.1.1. Multiprocessadores
Estas arquitecturas são caracterizadas por vários processadores compartilhando uma
única memória, ou um conjunto de memórias.
32
A arquitectura dos multiprocessadores é conhecida como fortemente acoplada, uma
vez que processadores e memória estão fortemente interligados através de seu sistema local de
interconexão. A interconexão local de processadores e memória, quando efectuada por
intermédio de uma barra, prove a facilidade de configuração compartilhada. Por outro lado, a
interligação de processadores e memórias através de um equipamento de comutação
estabelece uma configuração comutada simples, podendo também se estender até a múltiplos
níveis (TANENBAUM 2003).
É importante observar que independente do hardware de interconexão, seja esta uma
barra ou um elemento comutador (switch), a arquitectura de um multiprocessador é
caracterizada pelo compartilhamento global de uma memória pelos diversos processadores do
ambiente.
A escalabilidade em uma configuração deste tipo varia entre alguns até centenas de
processadores. Os processadores compartilham a memória de uma forma global.
Figura 16 - Multiprocessadores (UMA - Uniform Memory Access)
Os múltiplos processadores são ligados por meio de uma rede de interconexão (BUS)
a uma memória global centralizada. Essa memória central é formada por módulos disjuntos,
os quais podem ser acessados independentemente um do outro por diferentes processadores
da máquina. Para reduzir o tráfego na rede, a cada processador pode ser associada uma
memória local privativa (b) para o armazenamento de dados locais e instruções de programa.
33
As máquinas recebem nomes porque o tempo de acesso à memória compartilhada é igual para
todos os processadores.
Figura 17 - Multiprocessadores (NUMA - Non Uniform Memory Access)
Cada processador possui uma memória local, a qual é agregada ao espaço de
endereçamento global da máquina. Dessa forma, podem existir até três padrões de acesso à
memória compartilhada em uma mesma máquina. O primeiro, é o mais rápido, é aquele onde
a variável compartilhada está localizada na memória local do processador. O segundo padrão
refere-se ao acesso a um endereço na memória central (a). Já o terceiro, é o mais lento, diz
respeito ao acesso a uma posição localizada em uma memória local de outro processador.
3.1.2. Multicomputadores
São ambientes fracamente acoplados. Em outras palavras, estas configurações
caracterizadas por centenas de processadores têm suas próprias memórias locais. Não existe
um compartilhamento forte, o que significa dizer que a comunicação entre processos é
efectuada apenas por troca de mensagens entre os processos que estão executando nos
processadores. Processadores e memórias podem estar conectados por uma barra ou
comutador.
34
PATTERSON & HENNESSY (2005), ainda adiciona uma categoria híbrida, chamada
(arquitectura de memória compartilhada distribuída) ou Distributed Shared Memory (DSM),
na qual a comunicação é feita por meio de um espaço de endereçamento compartilhado. Isto
é, as memórias fisicamente separadas podem ser endereçadas como um único espaço de
endereços logicamente compartilhado.
Figura 18 - Arquitectura de um Multicomputadores
Cada processador P possui uma memória local M, à qual só ele tem acesso. As
memórias dos outros processadores são consideradas memórias remotas e possuem espaços de
endereçamento distintos (um endereço gerado por P1 só é capaz de endereçar M1). Como não
é possível o uso de variáveis compartilhadas nesse ambiente, a troca de informações com
outros processos é feita por envio de mensagens pela rede de interconexão Por essa razão,
essas máquinas também são chamadas de sistemas de troca de mensagens (MPI). Essas
características resultam do fato de esse tipo de máquina paralela ser construído a partir da
replicação de toda a arquitectura convencional, e não apenas do componente processador
como nos multiprocessadores. Daí o nome múltiplos computadores.
35
3.2. TENDÊNCIAS NA CONSTRUÇÃO DE MÁQUINAS PARALELAS
Nesta seção são apresentados os principais modelos físicos de máquinas paralelas que
constituem actualmente as principais tendências para a construção destes sistemas. Para cada
modelo são apresentadas suas principais características e sua classificação segundo a
terminologia. No final são apresentadas tabelas e diagramas comparativos entre os modelos.
Cabe destacar que, segundo a classificação de Flynn, todos os modelos aqui apresentados
pertencem à classe MIMD.
3.2.1. Processadores Vectoriais
Processadores vectoriais paralelos (PVP - Parallel Vector Processors) são sistemas
constituídos de poucos processadores vectoriais poderosos (PV) que são especialmente
desenvolvidos para esse tipo de máquina. A interconexão dos processadores a módulos de
memória compartilhada (MC) é feita, na maioria dos casos, por uma matriz de chaveamento
(crossbar) de alta vazão.
A implementação da memória compartilhada com blocos entrelaçados e o uso de uma
rede de interconexão não bloqueante permite que os processadores acessem a memória em
paralelo. A comunicação entre os processadores é feita através da memória compartilhada que
possui apenas um espaço de endereçamento que engloba todos os módulos de memória (todos
os processadores podem endereçar todos os módulos de memória).
Figura 19 - Arquitectura PVP
36
Como o tempo de acesso à memória compartilhada é uniforme, essas máquinas são
classificadas como multiprocessadores UMA. Esse tipo de máquina normalmente não se
utiliza de memórias cache, usando para essa função um grande número de registradores
vectoriais e um buffer de instrução.
3.2.2. Simmetric Multiprocessors (SMP)
Multiprocessadores simétricos (SMP - Symmetric Multiprocessors) são sistemas
constituídos de processadores comerciais, também denominados “de prateleira” (of the shelf),
conectados a uma memória compartilhada (MC) na maioria dos casos através de um
barramento de alta velocidade (Figura 20). Como a maioria dos processadores comerciais
encontrados no mercado utiliza memórias cache, tanto no chip quanto fora dele, os
processadores foram representados na figura por PC. Como consequência, o barramento
utilizado nessas máquinas implementa coerência de cache através do protocolo snoopy.
Figura 20 - Arquitectura SMP
A utilização de configuração SMP é a mais popular. Exemplos comerciais que
empregam esta abordagem são os servidores de fabricantes como Compaq, IBM, Dell e HP.
Uma outra máquina que ilustra o uso categoria da arquitectura SMP é um computador
do tipo IBM-PC com um processador Intel Pentium Pro Four-Processador Quand Pack. A
organização desta arquitectura da Intel é formada por quatro processadores compartilhando
um barramento principal, onde também estão conectados os módulos de memória e o
componente de interfase de comunicação com periféricos (PCI).
37
3.2.3. Distributed Shared Memory (DSM)
Máquinas com memória compartilhada distribuída (DSM – Distributed Shared
Memory) são sistemas em que, apesar de a memória se encontrar-se fisicamente distribuída
através dos nós, todos os processadores pode endereçar todas as memórias. Isso se deve à
implementação de um único espaço de endereçamento. Essa implementação pode ser feita em
hardware, em software ou ainda com a combinação dos dois. A distribuição da memória, por
sua vez, pode ser resultado da escolha de uma arquitectura multiprocessada com memória
entrelaçada distribuída (máquinas NUMA) ou de uma arquitectura de multicomputador com
memórias locais (máquina NORMA). Em ambos os casos, a máquina resultante é considerada
CC-NUMA se tiver coerência de cache implementada em hardware ou SC-NUMA se a
implementação for em software.
Figura 21 - Arquitectura DSM
A Figura 21, apresenta a arquitectura de uma máquina com memória compartilhada
distribuída derivada de um Multicomputadores NORMA. Nesse caso, os vários nós com suas
memórias locais (ML) são interligados através de adaptadores de rede (AR) a uma rede de
interconexão específica. O que diferencia essa arquitectura da máquina maciçamente paralela
da Figura 20, é a possibilidade do acesso às memórias remotas e a utilização de um directório
(DIR) para a implementação da coerência de cache. É importante destacar que, em alguns
casos, a coerência de cache não é implementada com um directório, como no caso do Cray
38
T3D que usa uma combinação de hardware especial e extensões de software para garantir a
coerência em nível de bloco.
3.2.4. Massively Parallel Process (MPP)
As máquinas com configuração maciçamente paralelas (Massively Parallel Processors
- MPP) são conhecidas como arquitecturas fracamente acopladas. Computadores sob este
paradigma são classificados usualmente como multicomputadores.
MPP são multicomputadores construídos com milhares de processadores comerciais
(PC) conectados por uma rede proprietária de alta velocidade (Figura abaixo). A expressão
“maciçamente paralela” indica a proposta dessas máquinas: a obtenção de alto desempenho
através da utilização de um grande número de processadores, os quais, devido ao factor custo,
acabam sendo processadores de poder computacional médio ou pequeno. Essa é uma
alternativa à proposta dos PVPs, por exemplo, em que o alto desempenho é obtido através da
utilização de poucos processadores vectoriais de grande poder computacional.
Figura 22 - Arquitectura MPP
Para que essas máquinas possam ser altamente escaláveis, suportando tantos
processadores, cada nó possui sua memória local (ML) com um espaço de endereçamento
próprio. Dessa forma, não é possível o acesso à memória de nós vizinhos, caracterizando um
multicomputador NORMA. A ligação desses nós à rede de interconexão é feita através de um
adaptador de rede (AR).
39
Como consequência directa dessa organização de memória distribuída com vários
espaços de endereçamento locais, a comunicação nessas máquinas é realizada através de troca
de mensagens. Esse paradigma é considerado de mais difícil programação do que o paradigma
de memória compartilhada, por ser mais distante da programação feita em sistemas
tradicionais.
Computadores com a arquitectura MPP são caracterizados por milhares de nós
interligados por dispositivos de interconexão de alta velocidade. Cada nó pode ser composto
por um ou mais processadores, possuindo cache e memórias locais. Uma outra característica
da arquitectura é que cada nó possui sua própria copia de sistema operacional, onde as
aplicações executam localmente e se comunicam através de pacotes de troca de mensagem,
tais como MPI e PVM.
A escalabilidade da abordagem MPP é a maior do que as arquitecturas como memória
Compartilhada, uma vez que cada nó tem sua própria estrutura de memória.
3.2.5. Sistemas distribuídos
Os sistemas distribuídos, sob o aspecto de arquitectura de máquinas para a execução
de aplicativos, devem ser vistos como configurações com grande poder de escala pela
agregação dos computadores existentes nas redes convencionais (DANTAS 2005).
Nos ambientes distribuídos, a heterogeneidade e a homogeneidade de um conjunto de
máquinas, onde cada qual possui sua arquitectura de hardware-software executando sua
própria cópia de sistema operacional, permite a formação de interessantes configurações de
SMP, de MPP, de Clusters e Grids computacionais. Embora a utilização de ambientes
distribuídos seja interessante sob o aspecto de utilização de recursos abundantes e na maioria
das vezes ociosos nas redes, alguns cuidados devem ser verificados nas fases de projecto e
implementação de aplicativos candidatos ao processamento nestas configurações.
40
Dentre esses aspecto tem-se concorrência, segurança, confiabilidade, latência da rede
de comunicações, compatibilidades de pacotes de softwares, entre outros.
3.2.6. Clusters
As configurações de clusters em termos de arquitectura computacional, podem ser
entendidas como uma agregação de computadores de forma dedicada (ou não) para a
execução de aplicações específicas (DANTAS 2005). Normalmente formados por
computadores do tipo PC, pertencentes a uma única unidade (ex: laboratório).
Figura 23 - Cluster da força aérea Americana (AFRL), tem 1760 PlayStation 3 (US Air Force)
41
4. CLUSTER
Um Cluster de computadores é um sistema composto por mais de um computador
interconectados e trabalhando em sincronia, com a finalidade de melhorar o desempenho das
aplicações e criar redundâncias em caso de falhas de hardware ou software os recursos ou
aplicativos de serviços (missão critica) estejam disponíveis para o usuário ou cliente executar
determinada tarefa desejada.
Os componentes de um Cluster são geralmente ligados uns aos outros através de
rápidas redes local ("LAN"), com cada nó (computador usado como um servidor) executando
a sua própria instância de um sistema operativo. Clusters de computadores surgiram como
resultado da convergência de uma série de tendências de computação, incluindo a
disponibilidade de microprocessadores de baixo custo, redes de alta velocidade, e software de
alto desempenho de computação distribuída (PITANGA, 2007).
Os clusters são usados principalmente para duas funções: Alta disponibilidade (HA –
High Availability) e Alto desempenho (HPC – High Perfomance Computing).
Os clusters dividem se em classes, na qual de classe I, são construídos a partir de
tecnologia padrão e de fácil acesso. E são mais baratos que os de classe II, que usam hardware
altamente especializado com objectivo de alcançar alto desempenho (BROWN, 2006).
Figura 24 - Cluster classe I, na Universidade de Tecnologia de Chemnitz (megware.com, 2013)
42
Figura 25 - Cluster classe II, Sun Microsystem Solaris Cluster (ChrisDag, 2013)
Os clusters são mais usados nas áreas técnicas, como servidores de internet, ambientes
de simulação de biotecnologia, mercado financeiro, previsão do tempo, entre outras
(BROWN, 2006).
Cada computador presente no cluster é chamado de nó, onde um assume o papel de Nó
Mestre (Master) e os outros nó escravos ou simplesmente nó. Os computadores dividem as
actividades de processamento e executam o trabalho de maneira simultânea. Os computadores
que fazem parte do cluster permanecem em sincronia, através de trocas de mensagem
periódica.
A sincronia dos computadores é complexa e perfeita que, caso ocorra alguma falha no
sistema, qualquer Nó assume a função de Nó Master num intervalo de tempo fraccionado,
permitindo que o serviço permaneça operacional (Cluster de alta disponibilidade) (PITANGA,
2004).
Segundo o mesmo autor, na sua forma mais básica um cluster é um sistema que
compreende dois ou mais computadores ou sistemas (denominados nós) na qual trabalham em
conjunto para executar aplicações ou realizar outras tarefas, de tal forma para que os usuários
que os utilizam tenham a impressão que somente um único sistema responde para eles,
43
criando assim uma ilusão de um recurso único (computador virtual). Este conceito é
denominado transparência do sistema. Como características fundamentais para a construção
destas plataformas inclui-se elevação dá: confiança, distribuição de carga e performance.
De acordo com (KOPPER, 2005), um cluster compõem-se de quatro características
básicas:
Transparência para os usuários;
Os computadores do cluster não têm ideia que fazem parte de um cluster;
As aplicações ou recursos em execução, não têm ideia que fazem parte de um cluster;
Os computadores que fazem parte do cluster têm que ser vistos como clientes comuns.
Os nós do cluster devem ser interconectados, preferencialmente, por uma tecnologia
de rede conhecida, para fins de manutenção e controle de custos, como a Ethernet. É
extremamente importante que o padrão adoptado permita a inclusão ou a retirada de nós com
o cluster em funcionamento, do contrário, o trabalho de remoção e substituição de um
computador que apresenta problemas, por exemplo, faria a aplicação como um todo parar.
A computação em cluster se mostra muitas vezes como uma solução viável porque os
nós pode até mesmo ser composta por computadores simples, como computadores de
desempenho normal. Juntos, eles configuram um sistema de processamento com capacidade
suficiente para dar conta de determinadas aplicações que, se fossem atendidas por
supercomputadores ou servidores sofisticados, exigiriam investimentos muito maiores.
Um projecto inicial que mostrou a viabilidade do conceito foi usado 133 nós, os
desenvolvedores usaram Linux, o PVM kit de ferramentas e o MPI biblioteca para atingir alta
performance a um custo relativamente baixo.
44
4.1. TIPOS DE CLUSTER
Em qualquer ambiente onde a aplicação é considerada de missão critica, que não pode
parar de funcionar ou não pode ter perda de dados, o Cluster surge como solução mais viável
dependendo simplesmente do tipo a ser implementado.
4.1.1. Cluster de alta disponibilidade (HA)
Clusters de alta disponibilidade, este cluster é caracterizada pela alta disponibilidade
dos serviços, ou seja, utilizam vários equipamentos em conjunto para manter o serviço sempre
disponível, replicando os dados e evitando que as máquinas fiquem paradas ou ociosas. Este
cluster fica à espera de um equipamento falhar ou parar, delegando as tarefas a uma outra
máquina. O objectivo principal é não parar, isto não quer dizer que não há paralisação da
mesma, mas quando tal aconteça, a paralisação deve ser a menor tempo possível, como é o
caso de soluções de missão crítica que exigem disponibilidade de, pelo menos, 99,999% do
tempo a cada ano, por exemplo.
Tabela 4 - Níveis de Alta disponibilidade
Disponibilidade Down Time / Ano Down Time / Mês
95 % 18 Dias 6 horas 1 Dia e 12 horas
96 % 14 Dias 14 horas e 24 min 1 Dia e 4 horas e 48 min
97 % 10 Dias, 22 horas e 48 min. 0 Dia, 21 horas e 36 min.
98 % 7 Dias, 7 horas e 12 min. 0 Dia, 14 hora e 24 min
99 % 3 Dias, 15 horas e 36 min. 0 Dia, 7 horas e 12 min.
99,9 % 8 Horas e 45 min. 35.99 Segundos 43 Min. 11,99 Segundos
99,99 % 52 Min e 33,60 segundos 4 Min e 19,20 segundos
99,999 % 5 Min e 15,36 segundos 25,92 Segundos
45
Para atender a esta exigência, os clusters de alta disponibilidade podem contar com
diversos recursos: Ferramenta de monitoramento que identificam nós defeituosos com falhas
ou falhas na conexão, replicação (redundância) de sistemas e computadores para substituição
imediata de máquinas com problemas, uso de geradores para garantir o funcionamento em
caso de queda de energia, entre outros.
Em determinadas circunstâncias, é tolerável que o sistema apresente algum grau de
perda de desempenho, especialmente quando esta situação é consequência de algum esforço
para manter a aplicação em actividade.
Figura 26 - Cluster de alta disponibilidade (wikipedia, 2013)
O objectivo principal deste tipo de cluster é a tolerância à falhas. Este tipo de cluster
funciona da seguinte maneira: dos computadores ligados entre si, um deles (server 1) executa
a tarefa enquanto o outro (server 2) tem a função de monitorar e manter os dados actualizados
em relação ao primeiro. Se o primeiro computador para por alguma razão o segundo assume
imediatamente o seu lugar. Normalmente usados em servidores web ou banco de dados em
intranets (MORIMOTO, 2003).
46
4.1.2. Cluster de Balanceamento de carga (LB).
Nos clusters de balanceamento de carga, as tarefas de processamento são distribuídas
o mais uniformemente possível entre os nós de forma uniforme. O foco aqui é fazer com que
cada computador receba e atenda a uma requisição, e não, necessariamente, que divida uma
tarefa com outras máquinas.
Imagine, por exemplo, que um grande site na internet receba por volta de mil visitas
por segundo e que um cluster formado por 20 nós tenha sido desenvolvido para atender a esta
demanda. Como se trata de uma solução de balanceamento de carga, estas requisições são
distribuídas igualmente entre as 20 máquinas, de forma que cada uma receba e realize, em
média, 50 atendimentos a cada segundo.
O seu princípio de funcionamento baseia-se na distribuição de pedidos através de um
ou mais dos nós de entrada, o que lhes redireccionado para processamento nos outros, os nós
de computação. O propósito original deste tipo de cluster é produtividade, no entanto, também
são frequentemente utilizados métodos que melhoram a confiabilidade. No mercado existe
Software especializados, e pode ser tanto comercial (OpenVMS , MOSIX , Platform LSF
HPC, Solaris Cluster , Moab Cluster Suite, Maui Cluster Scheduler) e livre ( OpenMosix ,
Sun Grid Engine , Linux Virtual Server ).
O balanceamento de carga pode ser utilizado em vários tipos de aplicações, mas o seu
uso é bastante comum na internet, já que soluções do tipo têm maior tolerância ao aumento
instantâneo do número de requisições, justamente por causa do equilíbrio oriundo da
distribuição de tarefas.
47
Figura 27 - Arquitectura do Cluster com balanceamento de Carga (devmedia.com.br, 2013)
4.1.3. Cluster de alto desempenho (HPC)
Este tipo de cluster, e o tema principal deste trabalho. Computação de alto
desempenho é uma necessidade em certos ramos de pesquisa cientifica.
Base se no cluster BEOWULF, consiste na criação de computadores paralelos a apartir
de computadores de uso comum atingindo alto desempenho em computação com custos
extremamente baixos.
Este tipo de cluster muitas vezes chamado de cluster de alta performance permite uma
grande carga de processamento com um volume alto de flops em computadores de uso
comum utilizando sistemas operativos gratuito.
Clusters de alto desempenho são direccionados a aplicações bastante exigentes no que
diz respeito ao processamento.
O foco deste tipo de cluster é o de permitir que o processamento direccionado à
aplicação forneça resultados satisfatórios em tempo hábil, mesmo que haja centenas de
milhares de giga flops envolvidos com a tarefa.
48
Figura 28 - Arquitectura do cluster de alto desempenho, HPC (wikipedia, 2013)
4.2. COMBINAÇÃO DE CLUSTER
É válido frisar que uma solução de cluster não precisa se "prender" a apenas um tipo.
Conforme a necessidade, pode-se combinar características de tipos diferentes no intuito de
atender plenamente à aplicação.
Por exemplo, a instituição que gere a rede de multicaixa no nosso país, utiliza um
cluster de alta disponibilidade para garantir que os pedidos de movimentos bancário possam
ser realizadas 24 horas por dia e, ao mesmo tempo, aplicar balanceamento de carga para
suportar um expressivo aumento no número de pedidos causados por qualquer movimento
bancário na rede de multicaixa.
4.3. VANTAGENS DO CLUSTER DE ALTO DESEMPENHO
Uma verdade irrefutável é, o mercado de PC´s é maior que o mercado de workstations,
permitindo que o preço de PC desça, e aumentando a sua performance, sobrepondo a
performance dos workstation dedicados.
Segundo PITANGA (2007), este tipo de cluster tem uma importância devido o seu uso
na indústria cinematográfica, para renderização de imagens, engenharia e finanças para
49
actuarem nos projectos de desdobramentos de proteínas, dinâmica dos fluidos, redes neurais,
analise genética, estatística, economia, astrofísica, etc..
Vantagens:
Quanto mais computadores na rede mais rápido fica.
Componentes de fácil aquisição.
Fácil manutenção.
Independência de fornecedores de hardware.
Custo baixo. Utilizando computadores simples ou até mesmo computadores obsoletos.
Se um computador falhar, nada impede o usuário de prosseguir.
Cluster BEOWULF suporta mais de um nó mestre, do mesmo jeito que nó escravos da
rede.
Qualquer estudante ou não pode construir um em casa, para testar seus estudos em
programação paralela a baixo custo porque no nosso país nenhuma universidade tem
disponível um Computador (supercomputador) para teste da programação em paralelo.
Um exemplo do uso do mesmo foi na produção do filme TITANIC, onde 105
computadores, computadores comuns, montados em uma rede local de alta velocidade,
equipados com sistemas operativos LINUX, utilizados param renderização de imagens.
50
51
5. CLUSTER DE ALTO DESEMPENHO/PROCESSAMENTO PARALELO
Algumas áreas de conhecimento (por exemplo, astronomia, meteorologia e genética)
requerem, para os problemas estudados, de muitos recursos computacionais com alto
desempenho para suprir cálculos complexos e repetitivos. Os avanços da tecnologia de
computadores geralmente não acompanham a demanda solicitada e, às vezes, a utilização de
supercomputadores não é viável financeiramente. Uma alternativa a ser adoptada pode ser a
soma dos recursos computacionais já existentes utilizando-os de forma mais apropriada e
equilibrada, resultando em um ganho substancial de desempenho (speed up).
A implementação de cluster viabiliza a computação em paralelo, utilizando
microcomputadores ligados em redes e sistema operativo Linux, com distribuição gratuita.
Este tipo de cluster, é e continua a ser um projecto bem-sucedido.
A opção feita pelos seus criadores de usar hardwares populares e software aberto, tornou-o
fácil de replicar e modificar, a prova disso é a grande quantidade de sistemas construídos
baseando-se no Cluster BEOWULF em diversas universidades, empresas, e residenciais em
todo o mundo. Não só foi uma experiencia como também foi obtido um sistema de uso
pratico que continua sendo aperfeiçoado constantemente ate o dia de hoje.
Uma característica chave de um cluster Beowulf, é o software utilizado, que é de
elevado desempenho e gratuito a maioria de suas ferramentas, como exemplo podemos citar
os sistemas operativos GNU/Linux e Freebsd, sobre os quais estão instaladas as diversas
ferramentas que viabilizam o processamento paralelo, como é o caso das API’s, MPI e PVM.
Isto permitiu fazer alterações no sistema operacional Linux para dotá-lo de novas
características que facilitaram a implementação para aplicações paralelas.
52
O sistema é dividido em um nó controlador denominado front-end (nó mestre), cuja
função é controlar o cluster, monitorar e distribuir as tarefas, actua como
servidor de arquivos e executa o elo entre os usuários e o cluster. Os demais nós são
conhecidos como clientes ou back-ends (nós escravos), e são exclusivamente dedicados para
processamento das tarefas enviadas pelo nó controlador, e não existe a necessidade de
teclados e monitores, e eventualmente até sem a utilização de discos rígidos (boot remoto), e
podem ser acessadas via login remoto (telnet ou ssh).
Figura 29 - Cluster do grupo Structural and Computational Biology (norma.mbg.duth.gr, 2013)
“Este cluster baptizado com o nome Norma, tem 96 núcleos, 82 GB de
memória física, 11 nós e conexão de 1 gigabit, usada para simulações de
dinâmica molecular e cristalogia computacional. E pode ser acessado e ter mais
detalhes on line no endereço http://norma.mbg.duth.gr/index.php?id=status” .
Processamento paralelo consiste em dividir uma tarefa em suas partes independentes e
na execução de cada uma das partes em diferentes processadores.
Os clusters compreendem um conjunto de nós que operam de maneira cooperativa e
transparente, disponibilizando serviços e/ou efectuando tarefas a fim de atender uma demanda
específica. A fim de atenderem tal demanda, os clusters apresentam uma arquitectura
específica e elementos constituintes, onde o entendimento de conceitos chaves nesse cenário é
importante.
53
5.1. UTILIZAÇÃO DE LINUX EM CLUSTER
Existem versões de UNIX para muitos sistemas, sendo normalmente proprietárias e
com custos bastante elevados. O Linux foi inspirado no sistema operacional MINIX, uma
pequena versão do UNIX criada por Andrew Tannembaum (2003).
Pode ser livremente distribuído nos termos da GNU (General Public License), ou seja,
o usuário pode alterar o seu núcleo (kernel) de acordo com as suas necessidades. As
vantagens de se utilizar o Linux na implantação de clusters são diversas, entre elas destacam-
se o fato do Linux ser um sistema robusto, que dá suporte desde aplicações simples até
aplicações extremamente complexas, e por ser possível dotá-lo de novas características que
facilitam a implementação para aplicações paralelas.
Além disso, em específico para clusters Beowulf, o Linux atende uma das suas
principais características que é ser um sistema operativo de código aberto e de distribuição
livre [Pitanga, 2004]. Assim, tem-se um sistema extremamente flexível e robusto sem nenhum
ónus adicional, que permite qualquer alteração que se fizer necessária para melhor adaptação
a um ambiente paralelo e de alto desempenho.
5.2. O AUMENTO DA DEMANDA POR PROCESSAMENTO PARALELO
A evolução do desempenho dos 500 maiores computadores do mundo nos últimos
anos pode ser acompanhada através da página do projecto Top500, http://www.top500.org. De
seis em seis meses é actualizada uma lista elaborada com base num benchmark específico de
desempenho, contendo os principais detalhes dos 500 maiores computadores do mundo. Para
quem não está familiarizado com as magnitudes neste tipo de gráfico a Tabela abaixo
apresenta as unidades utilizadas para quantificar o desempenho destes supercomputadores.
54
Tabela 5 - Medida de desempenho dos computadores em Flops
Nome Números de operações por segundo
Kiloflops
Megaflops
Gigaflops
Teraflops
Petaflops
Hexaflops
Zettaflops
Dando uma vista no gráfico de evolução de desempenho publicado no relatório mais
recente do Top500, apresentado na Figura abaixo, fica em aberto a pergunta: qual a força
motriz que impulsiona esta corrida desenfreada por um maior desempenho?
Figura 30 - Exponencial crescimento da supercomputação, (top500.org)
55
Procurando uma resposta para esta pergunta podemos começar por algumas
constatações simples. Para começar, a formulação e resolução de problemas cada dia mais
complexos nos leva a níveis mais profundos de conhecimento. As diversas áreas das ciências
e as engenharias têm contribuído, de uma forma ou de outra, com o surgimento de mais e
maiores problemas a ser resolvidos.
De facto os principais paradigmas da ciência e da engenharia estão cada dia mais
permeados pela computação. A simulação computacional tem-se mostrado ferramentas
confiáveis e baratas para ser utilizadas na comprovação de teorias, projecção de sistemas, e na
construção de protótipos. As ferramentas computacionais disponíveis devem então permitir a
resolução de problemas complexos em um tempo razoável. O PDA passa a ser uma
ferramenta importante quando nos deparamos com problemas de grande porte, ou seja,
problemas que não podem ser resolvidos, com os recursos computacionais disponíveis, em
um intervalo razoável de tempo.
Para exemplificar o conceito de problema de grande porte podemos utilizar um
exemplo clássico: o cálculo do movimento de corpos estelares. Basicamente o problema a ser
resolvido é estimar as posições dos corpos estelares sendo que: cada corpo é atraído pelas
forças gravitacionais exercidas por todos os outros corpos; o movimento de um corpo é
modelado calculando o efeito de todas as forças que actuam sobre ele. Se temos N corpos
teremos N - 1 forças actuando sobre cada corpo e operações de ponto flutuante (flop) para
determinar a posição de todos os corpos. Após determinar a posição de cada um deles o
cálculo deve ser repetido de forma iterativa, de acordo com o período de tempo que esteja
sendo simulado.
Colocando o exemplo anterior em números teremos que a galáxia tem
aproximadamente Estrelas. Se cada operação fosse feita em 1µ s teríamos s ou 1
56
bilhão de anos. Mesmo aprimorando o algoritmo para conseguir complexidade da ordem de N
log N somente conseguiríamos terminar cada iteração em 1 ano.
Existem outros inúmeros exemplos de problemas de grande porte em áreas como
simulação de biomoléculas, simulação estocástica utilizada em Monte Carlo - simulação de
reservatório de hidrocarbonetos, processamento de imagens e nano tecnologia.
5.3. ARQUITECTURAS COM MÚLTIPLOS PROCESSADORES
Depois de termos uma explanação da taxonomia de Flynn, no capítulo 3, taxonomia de
Flynn pode ser utilizada para obter uma classificação amplamente aceite. Apesar de ter se
originado nos anos 70 trata-se de uma classificação ainda válida que se baseia na capacidade
dos computadores de lidar com fluxos de instruções e fluxos de dados. Politécnico
Os computadores pessoais, equipados com chips de um único núcleo, podem ser
classificados como sistemas SISD. O principal gargalo nesta arquitectura é a transferência de
dados entre a memória principal e a CPU. Para melhorar este fluxo de dados foi introduzido
uma estrutura hierárquica de memória. Com base em computadores pessoais deste tipo e em
equipamentos simples encontrados nas lojas de informáticas fora construído um tipo
particular de máquina paralela: os clusters tipo Beowulf.
As arquitecturas paralelas modernas podem ser caracterizadas como SIMD ou como
MIMD. No primeiro caso temos um único fluxo de instruções actuando sobre múltiplos
fluxos de dados. As modernas GPGPUs são um exemplo típico deste tipo de sistemas.
57
5.4. VISÃO GERAL SOBRE PROGRAMAÇÃO PARALELA
Antes de começar a falar sobre programação paralela, deve-se analisar alguns aspectos
relacionados com programação sequencial. O algoritmo serial ou sequencial é aquele que
executa, de forma independente, em um único processador. Ao contrário do algoritmo
paralelo que roda simultaneamente em dois ou mais processadores. Para cada algoritmo
paralelo existe um algoritmo sequencial que realiza a mesma tarefa.
Para se implementar um algoritmo paralelo é extremadamente importante criar uma
versão serial do mesmo. O algoritmo serial serve de ponto de partida, como base para o
melhor e mais rápido entendimento do problema e como ferramenta para validar os resultados
do programa paralelo. O desempenho do algoritmo serial auxilia também na avaliação do
ganho de desempenho e da eficiência do algoritmo paralelo.
Existem diversas métricas para avaliar o desempenho de algoritmos paralelos. Os
cursos específicos de programação paralela discutem diversas métricas que permitem avaliar
o desempenho de aplicações paralelas.
A primeira destas métricas é o speedup, uma das medidas mais utilizadas para avaliar
o desempenho de um algoritmo paralelo.
O speedup pode ser utilizado também para calcular outro parâmetro importante, a
eficiência. A eficiência não é mais que a medida de utilização dos processos em um programa
paralelo em relação ao programa serial. Desta forma a eficiência é calculada como a razão
entre o speedup e a quantidade de processadores.
Para se obter algoritmos paralelos eficientes deve-se levar em consideração alguns
aspectos importantes como a divisão equitativa do trabalho entre os processos, a minimização
da necessidade de comunicação entre os processos e do tempo ocioso dos mesmos, a
58
sobreposição, das operações de comunicação e computação, e a concentração das operações
de entrada e saida visando minimizar seu efeito.
Existem basicamente dois enfoques na hora de projectar programas paralelos. São eles
o paralelismo de dados e o paralelismo de controlo.
O paralelismo de dados dá se através do particionamento do conjunto de dados a ser
processados em subconjuntos menores que são atribuídos a cada processo. Este enfoque pode
ser implementado de forma simples, não é prejudicado pela dependência entre as operações,
os programas que utilizam o mesmo são facilmente escalável e geralmente utilizam pouca
comunicação entre processos. As implementações paralelas utilizando CUDA em dispositivos
GPGPU são um exemplo de uso intensivo de paralelismo de dados.
Entretanto, nem sempre é possível utilizar o paralelismo de dados. Muitas vezes
precisamos dividir o problema em tarefas independentes, que podem ser atribuídas a
processos diferentes e executadas em paralelo. Neste caso utilizamos o paralelismo de
controle. Este enfoque deve considerar a dependência entre as operações, é mais difícil de se
implementar e escalonar, e implica, geralmente, em um uso elevado de comunicação entre
processos. O construtor paralelo sections, utilizado em OpenMPI, é um exemplo de
implementação de paralelismo de controlo. A maior parte dos programas paralelos envolvem,
de uma forma ou outra, os dois enfoques ainda que o paralelismo de dados seja mais
comummente encontrado.
Finalmente, antes de começar a analisar técnicas de programação paralela, podemos
desenhar um roteiro geral que pode ser utilizado para construir um programa paralelo:
1. Implementação sequencial: Analisar, implementar e validar uma solução sequencial
para o problema que pretende-se solucionar;
59
2. Análise da divisão do trabalho: Avaliar a possibilidade divisão do conjunto de dados
do problema entre os diferentes processos;
3. Avaliar a viabilidade do paralelismo de dados puro: verificar se o problema pode ser
resolvido apenas executando o algoritmo serial nos distintos conjuntos de dados;
4. Análise da necessidade de comunicação: Se o paralelismo de dados não for suficiente
identificar as necessidades de comunicação entre os processos;
5. Avaliar a necessidade de paralelismo de controlo: Analisar a necessidade de introduzir
paralelismo de controlo na implementação da solução paralela;
6. Validação da implementação paralela: Verificar a solução paralela com ajuda do
algoritmo serial.
7. Análise de desempenho: Avaliar diferentes métricas de desempenho para analisar as
características do algoritmo paralelo implementado.
5.5. TÉCNICAS DE PROCESSAMENTO PARALELO
Na actualidade existem diversas abordagens que podem ser utilizadas para se
implementar programas paralelos. Cada uma delas depende, essencialmente, da arquitectura
computacional para a qual está-se programando. O grande problema nestas abordagens hoje é
a portabilidade dos códigos que, em muitos casos fica limitada por soluções específicas para
determinado tipo de hardware. Apresentaremos a seguir três paradigmas de programação
paralela. No final voltaremos a discutir o tema de portabilidade.
5.5.1. Programação multithread com OpenMP
Os computadores multiprocessador de memória compartilhados representam uma das
arquitecturas paralelas mais amplamente disponíveis nos dias de hoje. Quase todos os
computadores pessoais e laptops na actualidade podem ser considerados computadores
60
multiprocessadores de memória compartilhados. Uma das formas de se implementar
processamento paralelo neste tipo arquitectura é através de programação multithread.
Uma thread, ou linha ou fio de execução, não é mais que a menor parte de um
processo que pode ser manipulado pelo escalonador do sistema operativo. As threads de um
processo se originam da divisão da thread principal em dois ou mais threads. Elas podem ser
executadas em paralelo, são atribuídos pelo escalonador, quando possível, a processadores
diferentes e compartilham entre sim o mesmo espaço de memória.
As técnicas mais comuns para se trabalhar com multithread são: o threading explícito
e as directivas de compilação. Neste texto será abordado o uso de directivas de compilação,
através de OpenMP, que consiste em inserir directivas no código sequencial para informar ao
compilador quais regiões devem ser paralelizadas.
O Open specification for Multi Processing, ou simplesmente OpenMP, é um modelo
de programação em memória compartilhada que surgiu a partir da cooperação de grandes
fabricantes de hardware e software como a Sun, Intel, SGI, AMD, HP, IBM e outras.
Projectada para ser utilizada com C/C++ e Fortran, as especificações são desenvolvidas e
mantidas pelo grupo OpenMP ARB (Architecture Review Board). Trata-se de um padrão (não
é uma linguagem de programação) que define como os compiladores devem gerar códigos
paralelos através de directivas e funções. Por este motivo o resultado depende, em grande
medida, do compilador que foi utilizado para gerar o aplicativo.
A versão 1.0 destas especificações para Fortran foi liberada em Outubro de 1997 e um
ano depois saíram as especificações para C/C++. Em Novembro de 1999 foi liberada a versão
1.1 para Fortran e em 2000 a versão 2.0 também para Fortran. A versão 2.0 para C/C++
demorou ainda dois anos mas, a partir 2005 com a versão 2.5, começaram a ser
disponibilizadas as especificações para Fortran e C/C++ simultaneamente. Em 2008 saiu a
61
versão 3.0 e em julho de 2011 foi disponibilizada a versão 3.1, que está implementada nas
versões mais recentes do compilador GNU/GCC. No momento que este texto estava sendo
preparado os desenvolvedores de compiladores trabalhavam na implementação do padrão 4.0
que foi disponível em Agosto de 2013.
Os programas desenvolvidos com ajuda de OpenMP utilizam um modelo de execução
conhecido como Fork-Join, que pode ser entendido da seguinte forma: todos os programas
iniciam com a execução de uma thread principal ou master thread; a master thread executa de
forma sequencial até encontrar um construtor paralelo, momento em que cria um grupo de
threads; o código delimitado pelo construtor paralelo é executado pelo conjunto de threads;
Ao concluírem a execução paralela o grupo de threads sincroniza numa barreira implícita com
a master thread; o grupo de thread termina sua execução e a master thread continua sua
execução sequencial. A Figura abaixo exemplifica o modelo de execução Fork-Join.
Figura 31 - Modelo de execução de Fork-Join (openmp.org, 2013)
Actualmente uma grande quantidades de compiladores implementam as especificações
OpenMP, entre eles alguns dos mais populares como os compiladores da Intel e os do
projecto GNU/GCC (a partir da versão 4.3.2). A programação multithread com OpenMP tem
62
uma série de vantagens sobre outras formas de implementação de paralelismo em
arquitecturas de memória compartilhada. Entre elas podemos citar a facilidade de conversão
de programas sequenciais em paralelos, a maneira simples de se explorar o paralelismo, a
facilidade de compreender o uso das directivas entre outros.
5.5.2. Troca de Mensagens com MPI
A implementação de programas paralelos em ambientes de memória distribuída requer
um mecanismo para criação de processos que permita sua execução em máquinas diferentes e
um mecanismo que viabilize a troca de mensagens entre os processos. O padrão mais
utilizado para implementar troca de mensagens é o de Message Passing Interface (MPI).
Da mesma forma que OpenMP, MPI não é uma linguagem de programação. O padrão
MPI define a sintaxe e a semântica de um conjunto de rotinas que devem ser implementadas
numa biblioteca de funções para Fortran e C/C++. Este padrão surgiu como fruto da
colaboração de um conjunto de pessoas e instituições representando a indústria, o meio
académico e importantes centros de pesquisa. Como resultado inicial desta colaboração surgiu
o MPI Forum em 1992 e dois anos mais tarde o foi lançado o padrão MPI 1.0. Após um longo
processo de discussão que levaram a melhoras significativas foi lançado, em 1997, o padrão
2.0 que recebeu uma actualização de menor porte (2.1) apenas em 2008.
O surgimento de implementações importantes e eficientes do padrão MPI viabilizou o
desenvolvimento do cluster tipo Beowulf que foram a base de muitos sistemas de alto
desempenho em instituições de pequeno e médio porte. Actualmente existem inúmeras
implementações do padrão MPI entre as quais destacam-se:
OpenMPI, desenvolvida pelo OpenMPI Team, http://www.open-mpi.org
63
MPICH, uma das implementações mais conhecidas e da qual se derivaram outras
implementações importantes como a implementação da Intel.
A programação utilizando MPI pode se resumir da seguinte forma: Todos os
processadores executam o mesmo programa, entretanto cada programa executa um
subconjunto específico de instruções com base numa estrutura de desvio que utiliza a
identificação de cada processo chamada de rank. Este enfoque utilizado em sistemas MIMD é
conhecido como SPMD (Single Program Multiple Data).
Outro problema importante com que tem que lidar os desenvolvedores do MPI são os
mecanismos de comunicação. O padrão MPI implemente um conjunto bastante amplo de
mecanismos de comunicação entre os quais destacam-se funções que implementam
comunicação ponto a ponto, mecanismos de comunicação bloqueada e não bloqueada e
mecanismos de comunicação colectiva.
Como foi colocado anteriormente, na busca por algoritmos paralelos mais eficientes
procura-se diminuir ao máximo a comunicação entre os processos. Nesta tarefa desempenha
um papel importante a localidade dos dados, ou seja o problema de atribuir um conjunto de
dados a um determinado processo de forma que as operações de comunicação sejam
minimizadas. Na mesma linha tem que se prestar uma atenção especial ao balanceamento de
carga, ou seja atribuir uma quantidade de trabalho equivalente a cada processo (PITANGA,
2007).
5.5.3. Programação Paralela em GPU com CUDA
A programação paralela e, particularmente, a PAD ganharam mais uma linha
importante de trabalho com o aperfeiçoamento das GPGPUs e das ferramentas para
implementar processamento paralelo nelas. A evolução das GPGPUs e das suas interfaces de
programação ocupariam mais tempo do que dispomos neste texto. Várias APIs já estão
64
disponíveis no mercado, algumas delas pensadas para rodar em qualquer GPGPU. Destaca-se
pelo avançado da sua implementação o OpenCL. Entretanto os recursos disponíveis nas
GPGPUs da NVIDIA através da arquitectura CUDA são os que apresentam resultados mais
consistentes na actualidade.
A partir dos dispositivos G80 da NVIDIA uma nova arquitectura foi desenhada para
permitir computação paralela. O modelo de programação CUDA, introduzido pela NVIDIA
em 2007, foi projectado para permitir a execução conjunta em CPU e GPU de um aplicativo.
CUDA tem muitos aspectos em comum com outros modelos utilizados para
programação paralela, como MPI e OpenMP. Os programadores estão encarregados de
construir o código paralelo através de um conjunto de extensões da linguagem C/C++.
Os conhecedores de OpenMP são unânimes em afirmar que os compiladores que
utilizam esta ferramenta têm um maior grau de automação na hora de criar código paralelo.
O sucesso do modelo de paralelização implementado na arquitetura CUDA foi tanto
que modelos posteriores, como o OpenCL, seguiram a mesma estratégia com excelentes
resultados.
Entretanto a curva de aprendizagem destes modelos é um pouco mais lenta, devido ao
conceito, totalmente novo, introduzido a partir da aplicação desta nova tecnologia.
65
6. CONFIGURAÇÃO DE UM CLUSTER DE ALTO DESEMPENHO
Neste capítulo do trabalho, vou descrever todo o processo de construção do cluster de
alto desempenho do laboratório prático.
A configuração do cluster, foi realizada manualmente permitindo assim um controlo
total da localização dos arquivos.
O processo de configuração não se detém em muitas explicações sobre todas definições
de cada programa instalado no Cluster, apenas dá breves comentários antes da instalação de
cada um. E também não se perde em explicações sobre comandos, pois partimos do princípio
de que a configuração de um cluster requer que o usuário já tenha algum conhecimento sobre
os comandos básicos de GNU/Linux.
Robert G. Brown, no seu livro Engineering a Beowulf-style Compute Cluster, 2003, da
uma definição mais detalhada de cluster. Este livro descreve o verdadeiro Cluster Beowulf,
como um conjunto de computadores interligados por uma rede com as seguintes
características:
1. Os nós são dedicados ao cluster Beowulf.
2. A rede na qual os nós residem são dedicados ao cluster Beowulf.
3. Os nós são computadores Mass Market Commercial-Off-The-Shelf (M2COTS).
4. A rede também é uma entidade COTS.
5. Os nós todos executam o software de código aberto.
6. O agrupamento resultante é utilizado para High Performance Computing (HPC).
66
6.1. CLUSTER EM MAQUINAS VIRTUAIS
Para este trabalho a construção de um cluster será em um ambiente virtual, usamos o
software de virtualização VirtualBox . O cluster virtual permite construir e testar o cluster sem
a necessidade de hardware adicional. No entanto, este método serve apenas para testes e não é
adequado se você quiser melhorar o desempenho.
Quando se trata de configurar os nós do cluster, a construção de um cluster virtual é
praticamente o mesmo que construir um cluster com máquinas reais. A diferença é que você
não precisa se preocupar com o hardware mais. Você tem que configurar correctamente as
interfaces de rede virtual dos nós virtuais. Eles precisam ser configurados de forma que o nó
mestre (por exemplo, o computador no qual os nós virtuais estão em execução) tem acesso à
rede para os nós virtuais, e vice-versa.
6.2. CLUSTER EM MAQUINAS FÍSICAS
Os componentes do cluster são dispositivos disponíveis para o público em geral
(requisito beowulf 3 e 4). Neste tutorial, vamos usar o sistema operativo Debian 7 (Wheezy)
SO de código aberto para permitir a computação paralela distribuída (requisito beowulf 5).
O cluster é composto pelas seguintes peças de hardware:
Switch
Computadores (No mestre e escravos)
Todos nós (incluindo o nó mestre) executando os seguintes software:
GNU / Linux OS, Debian 7.3 (Wheezy) 32-bit. Kernel Linux 3.2.0-4-486, Gnome
3.4.2 (apenas no master).
Network File System (NFS)
67
Secure Shell (SSH)
Message Passing Interface (MPI) - MPICH, um alto desempenho e implementação
amplamente portátil da Message Passing Interface (MPI) padrão (5).
Ganglia web.
Vamos partir do princípio que todos os nós, são parte da mesma rede privada e que
eles estão conectados correctamente.
RECOMENDAÇÃO
i. Siga a sequência de passos, cada biblioteca deve estar no directório correto. Se
você mudar o caminho, lembre-se de alterar também em todos os locais onde a
biblioteca referida for usada.
ii. Iremos instalar e configurar nos directórios /opt e /usr/local. No Debian, os
directórios /usr/local e /opt, são os únicos directórios onde o sistema não "mete
a mão", ou seja, são directórios próprios para instalações "alienígenas", por
assim dizer. Além do que, dessa maneira, as instalações ficam melhor
organizadas.
iii. O Debian não toca nos arquivos em /usr/local/ ou em /opt, portanto, ao
compilar um programa a partir do código fonte, instale-o em /usr/local/ ou /opt,
para que não interfira com o Debian.
iv. Nome de máquina: servidor, no0X (no01, no02, no03, etc).
v. Nome de usuário: cluster.
vi. Mesmo nome de usuário para todos e na instalação do sistema, deve ser a
mesma localização e fuso horário.
68
REPOSITORIOS DO DEBIAN
Editar o arquivo sources.list, e adicionar os seguintes repositórios. Para o master, por
ter sido instalado a parte gráfica:
deb http://ftp.br.debian.org/debian/ wheezy main contrib non-free
deb-src http://ftp.br.debian.org/debian/ wheezy main contrib non-free
deb http://security.debian.org/ wheezy/updates main contrib non-free
deb-src http://security.debian.org/ wheezy/updates main contrib non-free
deb http://ftp.br.debian.org/debian/ wheezy-updates main contrib non-free
deb-src http://ftp.br.debian.org/debian/ wheezy-updates main contrib non-free
deb http://mirrors.kernel.org/debian/ wheezy-updates main contrib non-free
deb-src http://mirrors.kernel.org/debian/ wheezy-updates main contrib non-free
deb http://ftp.debian.org/debian/ wheezy-updates main contrib non-free
deb-src http://ftp.debian.org/debian/ wheezy-updates main contrib non-free
Para os nos escravos, instalado somente o modo texto:
deb http://ftp.br.debian.org/debian/ wheezy main contrib non-free
deb-src http://ftp.br.debian.org/debian/ wheezy main contrib non-free
deb http://security.debian.org/ wheezy/updates main contrib non-free
deb-src http://security.debian.org/ wheezy/updates main contrib non-free
deb http://ftp.br.debian.org/debian/ wheezy-updates main contrib non-free
deb-src http://ftp.br.debian.org/debian/ wheezy-updates main contrib non-free
deb http://ftp.debian.org/debian/ wheezy-updates main contrib non-free
deb-src http://ftp.debian.org/debian/ wheezy-updates main contrib non-free
deb http://ftp.debian.org/debian/ wheezy-backports main contrib non-free
69
6.3. ADICIONAR NÓS
Partimos do princípio que todos os nos já estão configurados correctamente para ter
um endereço estático.
Edite o arquivo /hosts, precisa fazer isso em todos os nós.
127.0.0.1 localhost
192.168.1.6 master
192.168.1.7 node1
192.168.1.8 node2
192.168.1.9 node3
Master é usado como o nó mestre. Uma vez que o grupo foi criado, o nó master será
usado para iniciar os trabalhos no cluster. O nó master será usado para gerar postos de
trabalho no cluster. Os nós de computação são node1 para node3 e, assim, executar os
trabalhos.
6.4. DEFINIÇÃO DE UM USUÁRIO PARA EXECUTAR TAREFAS
Todos nós precisam de um usuário separado para a execução de trabalhos de MPI.
Baseando se nas seguintes razões:
1. Não há necessidade de lembrar os nomes de usuário e ter senhas diferentes se todos os
nós usar o mesmo nome de usuário e senha.
2. MPICH2 pode usar SSH para comunicação entre nós. O login sem senha com o uso de
chaves autorizadas só funciona se o nome de usuário corresponde ao conjunto sem
senha de login. Não temos que nos preocupar com isso, se todos os nós usarem o
mesmo nome de usuário.
3. O directório NFS pode ser acessível apenas para os usuários MPI. Os usuários MPI
todos precisam ter o mesmo ID de usuário para o sistema funcionar.
70
4. A separação de usuário requer permissões especiais.
6.5. PREPARANDO O SISTEMA (SERVIDOR E NÓS):.
Actualizar o sistema
# apt-get update
# aptitude safe-upgrade
Instalar e actualizar pacotes (servidor e nós):
# aptitude install build-essential module-init-tools kernel-package initramfs-tools
# aptitude install autoconf libaal-dev wget liblzo2-dev gzip libncurses5 libncurses5-
dev dpatch udev
Vamos instalar pacotes, a mais do que o necessário, para compilação dos programas
que queremos. Caso, futuramente, for preciso compilar o kernel ou compilar e instalar um
outro pacote, bastará actualizar o sistema.
# aptitude install openjdk-7-jre
Somente se for trabalhar com Java - servidor e nós. Para optimizar o sistema. Execute
o seguinte comando no servidor e nós:
# aptitude install cgroup-bin
Abrir o arquivo rc.local e adicionar o conteudo:
# vim /etc/rc.local
…
mkdir -p /dev/cgroup/cpu
mount -t cgroup cgroup /dev/cgroup/cpu -o cpu
mkdir -m 0777 /dev/cgroup/cpu/user
echo "1" > /dev/cgroup/cpu/user/notify_on_release
echo "/usr/local/sbin/cgroup_clean" > /dev/cgroup/cpu/release_agent
71
…
Salvar e sair.
Criar o arquivo cgroup_clean e colocar o conteúdo:
# vim /usr/local/sbin/cgroup_clean
#!/bin/sh
if [ "$1" != "/user" -a "$1" != "/user/" ]; then
rmdir /dev/cgroup/cpu$1
fi
Salvar e sair. E execute o commando:
# chmod +x /usr/local/sbin/cgroup_clean
Abrir o arquivo bash.bashrc e edite, adicionando o conteúdo:
# vim /etc/bash.bashrc
# this file has to be sourced in /etc/profile.
if [ "$PS1" ] ; then
mkdir -m 0700 /dev/cgroup/cpu/user/$$
echo $$ > /dev/cgroup/cpu/user/$$/tasks
fi
Salvar e sair.
Instalando mais pacotes necessários (servidor e nós):
# apt-get update
# apt-get install gfortran-*
Reiniciar: # shutdown -r now
Criando os arquivos necessários (servidor e nós):
72
Para ver qual a placa de rede eth0 ou eth1.
# ifconfig
Para vermos o arquivo que contem a configuração das interfaces.
# cat /etc/network/interfaces
Auto lo
Iface lo inet loopback
# the primary network interface
Allow-hotplug eth0
Iface eth0 inet static
Address 192.168.1.6
Netmask 255.255.255.0
Network 192.168.1.0
Broadcast 192.168.1.255
Gateway 192.168.1.1
#the secondary network interface
Allow-hotplug eth1
Iface eth1 inet dhcp
O arquivo interfaces acima, é do servidor. Em algumas máquinas, a placa de rede
utilizada com IP fixo na eth0, em outras, a eth1. Adapte para a sua configuração de hardware.
Abri o arquivo hosts e edite:
# vim /etc/hosts
127.0.0.1 localhost
192.168.1.6 master
192.168.1.7 no01
192.168.1.8 no02
73
192.168.1.9 no03
# the following lines are desirable for IPv6 capable hosts
::1 localhost ip6-localhost ip6-loopback
Ff02::1 ip6-allnodes
Ff02::2 ip6-allrouters
O arquivo /etc/hosts deve ser igual, tanto no servidor como nos nós.
Abrir o arquivo e edite com o conteúdo abaixo:
# vim /etc/hosts.equiv
master
no01
no02
no03
O arquivo /etc/hosts.equiv, deve ser o mesmo em todas as máquinas do cluster.
Abrir o arquivo .rhosts e edite com o conteúdo abaixo:
# vim /home/.rhosts
master
no01
no02
no03
O arquivo /home/.rhosts, deve ser o mesmo em todas as máquinas do Cluster.
Abrir o arquivo e edite com o conteúdo abaixo.
# vim /root/.rhosts
master
74
no01
no02
no03
Abri o arquivo o securetty, somente acrescente as linhas,:
# vim /etc/securetty
…
console
rsh
ssh
…
Abrir o arquivo hostfile e edite com o conteúdo abaixo.
# vim /opt/hostfile
master
no01
no02
no03
O arquivo /opt/hostfile deve ser rigorosamente o mesmo em todas as máquinas.
Instalando NTP (servidor e nós).
NTP (Network Time Protocol), ou Protocolo de Tempo para Redes, permite a
sincronização do tempo em servidores ou máquinas em uma rede, buscando em uma estrutura
confiável de outros servidores NTP, para obter a hora certa.
O NTP é necessário para fins de sincronização de tempo entre as máquinas do cluster.
# aptitude install ntp
Abrir o arquivo ntp.conf:
75
# vim /etc/ntp.conf
Edite o arquivo adicionando e comentando as linhas necessárias em seus respectivos
lugares.
# /etc/ntp.conf, configuration for ntpd; see ntp.conf(5) for help
Server 192.168.1.6
Driftfile /var/lib/ntp/ntp.drift
Authenticate no
…
E passe a comentário as linhas
#server 0.debian.pool.ntp.org iburst
#server 1.debian.pool.ntp.org iburst
#server 2.debian.pool.ntp.org iburst
#server 3.debian.pool.ntp.org iburst
…
Aumentando descritores e swappiness (opcional: servidor e nós)
Um Descritor de Arquivo (FD - File Descriptor) é um número inteiro positivo que o
processo usa para referenciar um determinado arquivo aberto. Quando um processo precisa
acessar um arquivo, ele faz isso através do descritor do arquivo. Os descritores, propriamente
ditos, são mantidos pelo kernel. O tamanho dessa tabela varia de sistema para sistema.
swappinnes é o processo de troca responsável por controlar a quantidade de memória
RAM e swap que será utilizada pelo sistema. É uma variável contida no código fonte do
kernel.
Alterando:
# sysctl -w fs.file-max=921600
76
Acesse ao ficheiro sysctl.conf :
# vim /etc/sysctl.conf
Acrescentar no final as linhas:
…
fs.file-max=921600
vm.swappiness=10
Reinicie.
Para ver a alteração da swappiness, execute:
# sysctl vm.swappiness
Servidor SSH
Instale no servidor e nòs.
# aptitude install ssh
No servidor, gerando a chave com 1024 bits:
# ssh-keygen -b 1024 -t rsa
Copiando a chave para os nós. Mudando os IP´s no comando abaixo:
# ssh-copy-id -i /root/.ssh/id_rsa.pub [email protected]
Para testar, vamos executar o shell nos nós a partir do servidor. Na primeira vez,
deverá pedir a senha, digite a senha.
# ssh 192.168.1.x -n 'echo $SHELL'
Ou:
# rsh 192.168.1.x -n 'echo $SHELL'
77
Deverá aparecer: /bin/bash
Mudando os IP’s no comando acima e teste todos.
Em caso de algum erro e de não conseguir acessar alguma máquina, acesse o arquivo
abaixo no servidor e apague todo o conteúdo dentro dele:
# vim /root/.ssh/known_hosts
Depois, ao acessar um nó com, por exemplo,
# ssh no01
Deverá aparecer uma mensagem "Are you sure you want to continue...", digite yes. Irá
pedir a senha, digite-a e, na próxima vez, não pedirá mais senha.
Instalando PVFS2 (servidor e nós)
PVFS (Parallel Virtual File System), é um sistema de arquivos concebido para
proporcionar alto desempenho para aplicações paralelas, onde tem grande concorrência de
acesso a muitos arquivos e grande volume de I/O (Entrada e Saída de Dados) a arquivos em
comum (compartilhados).
A instalação do PVFS2 é interessante em Clusters com grande volume de dados. Aqui
foi instalado para fins de testes.
Para o cluster que se propõe vamos utilizar o NFS.
Servidor NFS
Tem a mesma função do PVFS2, fazer o compartilhamento e sincronização de
directórios e arquivos no cluster. Grosso modo podemos dizer que um sistema de arquivos
78
desse tipo permite que instalemos somente no servidor os programas que queremos executar
no cluster, cabendo ao sistema de arquivos fazer o compartilhamento e o sincronismo.
Prefira o sistema de arquivos NFS, pois tem melhor desempenho em clusters caseiros
com baixo volume de dados e não habilite os dois sistemas de arquivos (PVFS2 e NFS) ao
mesmo tempo no cluster, senão dará problemas.
E lembre-se, se você instalar o PVFS2 com o NFS e for usar o NFS, comente a linha
/etc/init.d/pvfs2-server no arquivo /etc/rc.local no servidor e nos nós.
Iniciando a instalação do NFS:
# cd /home/kluster
No servidor:
# apt-get install portmap
# apt-get install nfs-common
# apt-get install nfs-kernel-server
# apt-get install nfs-user-server
Abrir o arquivo:
# vim /etc/exports
Coloque o conteúdo no final:
/home/kluster
192.168.1.0/24(rw,all_squash,subtree_check,anonuid=150,anongid=100)
/opt 192.168.1.0/24(rw,all_squash,subtree_check)
/usr/local 192.168.1.0/24(rw,all_squash,subtree_check)
Deve ir o endereço da rede. Salve e saia.
79
Veja bem, as pastas colocadas ali serão as pastas a serem compartilhadas pelo servidor
com as outras máquinas do cluster. Então, todo e qualquer arquivo que deverá ser utilizado
pelo cluster durante a execução de um programa devem ser colocados nesta mesma pasta.
Actualizando o kernel com as mudanças no arquivo /etc/exports:
# exportfs -a
Reinicie o serviço:
# /etc/init.d/nfs-kernel-server restart
Nos nós:
Entre no arquivo /etc/fstab:
# vim /etc/fstab
Adicione no final:
192.168.1.6:/home/kluster /home/kluster nfs defaults 0 0
192.168.1.6:/opt /opt nfs defaults 0 0
192.168.1.6:/usr/local /usr/local nfs defaults 0 0
E salve o arquivo.
MPICH
MPI (Message Passing Interface), em uma tradução livre, Interface de Passagem de
Mensagens. É uma biblioteca com funções para troca de mensagens que faz a comunicação e
a sincronização de processos em um Cluster paralelo.
Essa é a biblioteca que fará todo o trabalho de processamento no Cluster. Essa é a
biblioteca que transforma um conjunto de máquinas em um Cluster.
80
Os objectivos do MPICH são fornecer uma implementação MPI que suporte
eficientemente, diferentes plataformas de computação e comunicação, incluindo grupos de
commodities (sistemas de Desktop, sistemas de memória compartilhada e arquiteturas
multicore), redes de alta velocidade e sistemas de computação High-end de propriedade (Blue
Gene, Cray); e permitir a pesquisa de ponta em MPI através de uma estrutura modular fácil de
estender para outras implementações derivadas.
Servidor e nós:
# cd /usr/src
# wget http://www.mpich.org/static/downloads/3.0.4/mpich-3.0.4.tar.gz
# tar -xzvf mpich-3.0.4.tar.gz
# ls
# cd mpich-3.0.4
#./configure --help | less
# ./configure --prefix=/opt/mpich --enable-shared --enable-f95 --enable-
threads=runtime --enable-romio --enable-nemesis-shm-collectives --enable-debuginfo
CC=gcc CXX=g++ FC=gfortran F77=gfortran --with-pvfs2=/opt/pvfs2 --with-file-
system="pvfs2+nfs" --with-thread-package=posix --with-device=ch3:nemesis --with-
java=/etc/java-7-openjdk
# make
O make deverá terminar com a frase abaixo sem nenhuma mensagem de erro antes
dela:
make[1]: saindo do directorio '/usr/src/mpich-3.0.4'
# make install
O make install, idem ao make, não deverá apresentar erros.
Configurando as variáveis:
# vim ~/.bashrc
81
PATH=/opt/mpich/bin:$PATH
export PATH
E acrescentar, também, o caminho na variável LD_LIBRARY_PATH=/opt/mpich/lib
O arquivo bashrc acima com as variáveis, é o mesmo para o servidor e os nós.
Reinicie:
# shutdown -r now
Vendo as informações:
# mpiexec -info
Vamos testar nossa instalação, compilando e executando:
# cd /usr/src/mpich-3.0.4/examples
# ls
# mpicc -o cpi cpi.c
Esse arquivo deve ser compilado em todas as máquinas; acesse uma por uma ou utilize
o seguinte comando:
# mpicc -o -hostfile /opt/hostfile /usr/src/mpich-3.0.4/examples/cpi.c cpi
O arquivo cpi.c realiza cálculo do π (PI).
Testando:
# mpirun -hostfile /opt/hostfile -n 3 /usr/src/mpich-3.0.4/examples/cpi
Para ver o manual, execute:
# man mpicc
Ou:
82
# man mpi_Barrier
Ou:
# man mpiexec
Ganglia
O Ganglia é um sistema de monitoramento distribuído escalável para sistemas de
computação de alto desempenho, como Clusters e grids. Ele é baseado em um projecto
hierárquico dirigido a Clusters. Ele aproveita as tecnologias amplamente utilizadas, tais como
XML para representação de dados, XDR para compacto, transporte de dados portátil e
RRDtool para o armazenamento e visualização de dados.
Ele usa as estruturas de dados e algoritmos projectados cuidadosamente para alcançar
baixos custos gerais por nós e alta concorrência. A implementação é robusta e foi portada para
um amplo conjunto de sistemas operacionais e arquiteturas de processadores, e está
actualmente em uso em milhares de grupos em todo o mundo.
Ele tem sido usado para ligar os Clusters através de campi universitários e em todo o
mundo, e pode ser escalado para lidar com grupos com 2000 nós.
Nos nós:
# apt-get update
# apt-get install ganglia-monitor
No servidor:
# apt-get update
# apt-get install apache2
Testando o Apache: abra o navegador e digite: localhost, deverá aparecer: It works.
83
# apt-get install php5 libapache2-mod-php5
Crie o arquivo:
# vim /var/www/info.php
Coloque dentro dele:
<?php
phpinfo();
?>
Salve e saia. Reinicie o Apache:
# /etc/init.d/apache2 restart
Abra o navegador e digite localhost/info.php, deverá aparecer a página de informações
do PHP.
Instalando o Ganglia:
# apt-get install ganglia-webfrontend ganglia-monitor
Irá pedir duas vezes para reiniciar o Apache 2, faça. Vamos copiar o arquivo
necessário:
# cp /etc/ganglia-webfrontend/apache.conf /etc/apache2/sites-enabled/ganglia.conf
Alterar o arquivo /etc/ganglia/gmod.conf no servidor e copiar para os nós. É
extremamente necessário, tendo em vista que a conexão remota fica muito lenta, devido ao IP
239.2.11.71. Comente as linhas onde tem o IP 239.2.11.71, ou similar, e configure o host com
o IP do servidor.
...
84
Udp_send_channel {
Host = 192.168.1.6
/* mcast_join = 239.2.11.71 */
Port = 8649
…
/* mcast_join = 239.2.11.71 */
Port = 8649
/* bind = 239.2.11.71 */
..
Altere o arquivo /etc/ganglia/gmetad.conf no servidor:
…
Data_source “cluster” 15 localhost 192.168.1.6
…
Gridname “cluster”
…
…
Authority “http://192.168.1.6/ganglia/”
…
Para reiniciar o serviço nos nós:
# service ganglia-monitor restart
Reiniciar o Apache e o Ganglia no servidor:
# /etc/init.d/apache2 restart
# service gmetad restart
A partir daí é só digitar no navegador localhost/ganglia.
85
HPL
O HPL é um pacote de software que resolve um sistema aritmético (aleatório) de
densidade linear de precisão dupla (64 bits) em computadores de memória distribuída. É uma
implementação livremente disponível do projeto High Performance Computing Benchmark
Linpack.
No servidor e nós. Volte ao diretório /opt.
# wget http://www.netlib.org/benchmark/hpl/hpl-2.1.tar.gz
# tar -vzxf hpl-2.1.tar.gz
# mv hpl-2.1 hpl
# cd hpl
Copiando o arquivo de configuração. Dependendo da sua arquitectura, você
copiar/alterar o arquivo Make.Linux_PII_CBLAS ou Make.Linux_PII_FBLAS.
Nessa configuração aqui apresentada, foi utilizado o arquivo
Make.Linux_PII_FBLAS.
# cp /opt/hpl/setup/Make.Linux_PII_FBLAS Make.Linux_PII
Entre no arquivo:
# vim Make.Linux_PII
E altere/acrescente os seguintes parâmetros:
ARCH = Linux_PII
...
TOPdir = /opt/hpl
...
MPdir = /opt/mpich
86
...
#LAdir = $(HOME)/netlib/ARCHIVES/Linux_PII
LAinc =
LAlib = /opt/mpich/lib/BLAS/blas_LINUX.a
...
HPL_OPTS = -DHPL_COPY_L -DHPL_DETAILED_TIMING
...
CC = /opt/mpich/bin/mpicc
CCNOOPT = $(HPL_DEFS)
CCFLAGS = $(HPL_DEFS) -fomit-frame-pointer -O3 -funroll-loops -W -Wall
...
LINKER = /opt/mpich/bin/mpif90
Salve e saia do arquivo.
Compilando:
# make arch=Linux_PII
Testando:
# cd /opt/hpl/bin/Linux_PII
# mpirun -np 7 -hostfile /opt/hostfile ./xhpl
Veja imagem com a saída do comando acima nas conclusões, ao final do artigo.
SIESTA
O SIESTA (Spanish Initiative for Electronic Simulations with Thousands of Atoms), é
um método, uma implementação de programa de computador para realizar cálculos eficientes
de estrutura electrónica ab initio e simulações de dinâmica molecular de moléculas e sólidos.
87
A eficiência do SIESTA deriva do uso de conjuntos de bases estritamente localizadas
e da aplicação de algoritmos de escalonamento linear, que podem ser aplicados a sistemas
adequados.
Uma característica muito importante do código, é que sua precisão e seu custo podem
ser sintonizados em uma ampla gama, a partir de cálculos rápidos preliminares para
simulações de alta precisão combinando a qualidade de outras abordagens, como plane-wave
e métodos de eléctrons.
O SIESTA possui as bibliotecas BLAS e LAPACK nativamente, porém, vamos
utilizar as bibliotecas que instalamos anteriormente.
Como o SIESTA é um programa que utilizará o MPI, podemos instalá-lo somente no
servidor, mas, para isso, devemos ter o NFS ou o PVFS2 bem configurados, pois serão eles
que compartilharão os arquivos utilizados na execução.
Pode-se não utilizar NFS e nem PVFS2, mas, para tanto, deve-se instalar o SIESTA
(ou qualquer outro programa a ser utilizado) no servidor e nos nós.
Volte ao directório /opt.
# wget http://departments.icmab.es/leem/siesta/CodeAccess/Code/siesta-3.2-pl3.tgz
# tar -xzf siesta-3.2-pl3.tgz
# cd siesta-3.2-pl3/Obj
# sh ../Src/obj_setup.sh
# ../Src/configure --enable-mpi --enable-debug --enable-fast --with-
blas=/opt/mpich/lib/BLAS/blas_LINUX.a --with-lapack=/opt/lapack-3.4.2/liblapack.a --with-
blacs="/opt/BLACS/LIB/blacsF77init_MPI-LINUX-0.a /opt/BLACS/LIB/blacsCinit_MPI-
LINUX-0.a /opt/BLACS/LIB/blacs_MPI-LINUX-0.a" --with-scalapack=/opt/scalapack-
2.0.2/libscalapack.a
88
Configurando o arquivo arch.make:
# vim arch.make
FPP_OUTPUT=
FC=/opt/mpich/bin/mpif90
# Editar essa linha deixando-a assim
RANLIB=ranlib
# make
Será criado, entre outros, o arquivo executável siesta. Vamos copiá-lo para o
directório /opt para facilitar a execução:
# cp siesta /opt/siesta
Agora, para chamar o SIESTA (estando na mesma pasta onde está o arquivo .fdf e o
.psf), basta digitar:
# /opt/siesta < arquivo.fdf | tee arquivo.out
Para executar no cluster:
# mpirun -hostfile /opt/hostfile -n 7 /opt/siesta < /home/kluster/arquivo.fdf | tee
arquivo.out
89
7. CONCLUSÃO E SUGESTÃO
Neste trabalho de fim de curso os objectivos principais foram alcançados, a
configuração de um cluster de alto desempenho, usando a versão mais popular do Linux para
servidores, o Debian.
Começamos por dar uma visão do estado actual da área de supercomputação no
mundo e como os cluster dão uma solução em alternativa aos supercomputadores no que toca
a custos e benefícios, tornando se mais económico em comparação as outras arquitecturas
existentes no mercado com fins de alta performance.
Os cluster podem ser construído em função do orçamento do projecto e necessidade,
permitindo a disponibilidade da computação de alto desempenho.
Na configuração do cluster foi simplesmente usado o necessário para termos o cluster
beowulf em funcionamento, para que se realização dos testes. Em casos reais, haveria a
necessidade de instalarmos ferramentas para gerenciar e monitorar o desempenho do cluster,
sistemas de arquivos paralelos, e escalonadores para facilitar a manutenção e uso do mesmo,
middleware.
Com o nosso objectivo concluído podemos criar assim perspectivas de novos campos
de pesquisa através de cursos para programação paralela e construção de supercomputadores.
O resultado final deste trabalho será demonstrado na apresentação da monografia, o mesmo
enriqueceu em experiencia e conhecimento a parte teórica estudada, demonstrando através
dos testes que o uso da arquitectura cluster apresenta vantagens em relação aos custos, na
instalação e nos resultados positivos, e que por isso a arquitectura cluster é realmente uma
solução para a computação de alto desempenho.
90
Este trabalho será um forte contributo na implementação do Projecto AWA (Arquivo
Web Angolano), uma iniciativa dos alunos da turma LCC4N (2012). Para o seu
funcionamento do mesmo seria necessário a implementação do Hadoop, uma plataforma em
java de computação distribuída voltada para cluster e processamento grandes volumes de
dados.
Sugerindo trabalhos futuros, direcciono em projectos com foco na solução de um
problema de uma área especifica, como por exemplo em mineração de dados e algoritmos
genéticos em inteligência artificial, grandes renderização na área de computação gráfica ou
estudos na área de criptografia. Um passo alternativo seria o uso de clusters no estudo e
desenvolvimento de algoritmos paralelos, onde seria possível visualizar na prática os seus
resultados.
Também é interessante o estudo dos outros diferentes tipos de cluster abordados
superficialmente no capítulo 4, como os clusters de alta disponibilidade e os de
balanceamento de carga, que são bem diferentes dos clusters de alta performance, mas
também são muito úteis e usados actualmente.
91
8. REFERÊNCIAS BIBLIOGRÁFICAS
AZIMI, Reza, 2013 Building a simple Beowulf cluster with Ubuntu, disponível em:
<http://byobu.info/article/Building_a_simple_Beowulf_cluster_with_Ubuntu>, acedido em
Agosto de 2013
BELL, G. & J. GRAY (2002), What’s next in high-performance computing?,
Communications of the ACM.
BOOKMAN, Charles. Agrupamento de computadores em Linux: aprenda a construir e
manter grupos de computadores com Linux. Rio de Janeiro: Ciência Moderna, 2003. 240p.
BRAUN, Leandro R. (2006), Avaliação da Implantação de Cluster de Computadores
Usando Tecnologias Livres, trabalho de conclusão de curso, Centro Universitário Feevale.
BROWN, R. G. What makes a Cluster Beowulf? Duke University Physics Department,
2006. Disponível em: <www.beowulf.org/overview/howto.html>. Acedido em: 15 Fev. 2008,
11:24.
BUENO, A.D. Introdução ao Processamento Paralelo e ao Uso de Clusters de
Workstations em Sistemas GNU/LINUX. UFSC, 2002. disponível em:< www.rau-
tu.unicamp.br/nou-rau/softwarelivre/document/stats.php>. Acedido em: 24 jul. 2013, 16:03.
BUYYA, Rajkumar (editor). High Perfomance Cluster Computing: Architectures and
Systems, Vol. I. Capitulo 1. New Jersey: Prentice Hall, 1999. disponível em:
<http://www.buyya.com/cluster/v1preface.pdf>. acedido em: Novembro de 2013
DANTAS, Mario (2005), Computação Distribuída de Alto Desempenho: Redes, Clusters
e Grids Computacionais, 1a edição, Axcel Books, Rio de Janeiro - RJ.
devmedia.com.br, 2013, Configurando um Cluster de Tomcat com Balanceamento de
Carga, disponível em: <http://www.devmedia.com.br/configurando-um-cluster-de-tomcat-
com-balanceamento-de-carga/22631>. Acedido em: Novembro de 2013.
differ.com, 2013, Linux vs Windows - Difference and Comparison | Diffen, disponível em:
<http://www.diffen.com/difference/Linux_vs_Windows>. acedido em: Agosto de 2013.
FARIAS, Gilberto, Introdução a informática, disponível em:
<http://producao.virtual.ufpb.br/books/camyle/introducao-a-computacao-
livro/livro/livro.chunked/index.html>, acedido em 20 de Agosto de 2013.
FERREIRA, Rubem E. 2008. Linux: Guia do administrador do sistema. 2. ed. Novatec:
São Paulo.
FRANCO, L. D. (2004), Implementação Computacional em Ambiente Paralelo de Me-
mória Distribuída para Análise Acoplada de Sistemas Offshore, Tese de doutorado,
Universidade Federal do Rio de Janeiro (COPPE-UFRJ), Rio de Janeiro, RJ.
fi.edu, 2013, ENIAC_Image_2.jpg (JPEG Image, 1500 × 1012 pixels) - Scaled (66%)
disponível em: <http://www.fi.edu/learn/case-files/eckertmauchly/ENIAC_Image_2.jpg.>.
Acedido em: Setembro de 2013.
92
fi.edu, John W. Mauchly and J. Presper Eckert: The ENIAC Team. Disponível em:
<http://www.fi.edu/learn/case-files/eckertmauchly/team.html>; acedido em: Agosto de 201.
IEEE, 2006. Disponível em: <http://www.feg.unesp.br/~caeel/about/aboutieee.htm>. Acedido
em: 09 jun. 2013.
KOPPER, K, 2005. The Linux Enterprise cluster : build a highly available cluster with
commodity hardware and free software.
LYNN, M. (1974), Some Computer Organizations and Their Effectiveness, IEEE
Transaction Computers, Rio de Janeiro - RJ, p. 94.
MINDCRAFT. Web Stone: The Benchmarks for Web Servers. [S.l: Mindcraft], 1998.
Disponível em: <http://www.mindcraft.com/benchmarks/webstone/> Acedido em: 22 de julho
de 2013.
M IM , arlos. Dominando o SSH. Disponível em: http://www.guiadohardware.net/
Acessado em: 05 de nov. de 2013
MPI, 2012. Disponível em: <http://www.mpi-forum.org>. Acedido em 16 maio2013.
MPIBENCH Home Page, 2009. Disponível em:
<http://icl.cs.utk.edu/projects/llcbench/mpbench.html>. Acedido em: 02 de Agosto de 2013.
OMENA, Moisés, Clusters e Supercomputadores, fórum viva o Linux on line, Disponível
em < http://www.vivaolinux.com.br/artigo/Clusters-e-Supercomputacao/ >. acedido em: 02 de
Agosto de 2013.
OPENMP, 2013, Introduction to OpenMP. Disponível em:
<http://www.rc.unesp.br/igce/demac/balthazar/gpacp/bibliografia/E-
01%20%20Introduction%20to%20OpenMP%20-%20LLNL%20-
%20University%20of%20Califor.htm >; acedido em: Dezembro de 201.
PINTO, Hudson J. L., SILVA, Michel P. e SILVEIRA, Gabriel D. (2005) . Ambientes de
Alto Desempenho utilizando Cluster de Computadores: Universidade de Formiga,
Departamento de Ciência da Computação, Instituto de Ciências Sociais Aplicadas e Exactas.
Formiga, MG, Brasil.
PITANGA, Marcos. Computação em cluster: o estado da arte da computação. Rio de
Janeiro: Brasport Livros e Multimídia Ltda, 2003.
PITANGA, Marcos. Construindo supercomputadores com linux. 3ª edição. Rio de Janeiro:
Brasport, 2008. 321p.
SILVA, José Maurício Oliveira e (2009), Estudo e construção de um ambiente de alto
desempenho utilizando cluster computacional, trabalho de conclusão de curso II, UFP.
STALLINGS, W. (2002), Arquitetura e Organização de Computadores, 5a edição, Pren-
tice Hall, São Paulo - SP.
93
STERLING, T. & E. Lusk (2003), Beowulf Cluster Computing with LINUX, 2a edição,
The MIT Press.
TANENBAUM, ANDREW S. . Sistemas operacionais modernos. 2 ed. São Paulo: Pearson
Education do Brasil, 2003.
Webber, Melvin, Societal Contexts of Transportation and Communication, Working Pag.
220,. Institute of Urban and Regional Development, University of California -Berkeley, 1973.
WELSH, M.; KAUFMAN, L. Running Linux. 1. ed. United States of America: O'Reilly &
Associates, Inc, 1995. ISBN 1-56592-100-3.
WIKIPEDIA, Arquitectura de Von Neumann, Enciclopédia Livre. Disponível em:
http://pt.wikipedia.org/wiki/Arquitetura_de_von_Neumann >. Acesso em: 04 de fevereiro de
2013.
WIKIPÉDIA. Seymour Cray. Enciclopédia livre. Disponível em:
<http://pt.wikipedia.org/wiki/Seymour_Cray > Acedido em: 04 Maio de 2013.
WIKIPÉDIA. SuperComputador. Enciclopédia Livre. Disponível em:
<http://pt.wikipedia.org/wiki/Supercomputador > Acesso em: 04 de maio de 2013.
YEO, C. Shin; BUYYA, Rajkumar; POURREZA, Houssein; ESKICIOGLU, Rasit;
GRAHAM, Peter, SOMMERS, Frank, 2006. Cluster Computing: High-Performance,
High-Availability, and High- Throughput Processing on a Network of Computers. Handbook of Nature-Inspired and Innovative Computing: Integrating Classical Models with
Emerging Technologies, p 521-551, Springer US.
ufpd.br, 2013, As gerações dos computadores. Disponível em:
<http://producao.virtual.ufpb.br/books/camyle/introducao-a-computacao-livro/livro/livro
.chunked/ch01s02.html>; acedido em: Agosto de 2013.
U.S. Air Force, 2013, U.S. Air Force PS3, Cluster Computing Project Screwed By Sony.
disponível em:
<http://www.everydaynodaysoff.com/2010/05/12/u-s-air-force-ps3-cluster-computing-project-
screwed-by-sony/>, acedido em: Agosto de 2013.
Wikipedia, 2013, File:Official gnu.svg - Wikimedia Commons. Disponível em:
<http://commons.wikimedia.org/wiki/File:Official_gnu.svg> acedido em: Setembro de 2013.
WIKIPEDIA, 2013, Cray XT5 - Wikipedia, the free encyclopedia. Disponível em:
<http://en.wikipedia.org/wiki/Cray_XT5>. acedido em: Agosto de 2013.
WIKIPEDIA, 2013, Arquitetura de von Neumann – Wikipédia, a enciclopédia livre.
Disponível em:
<http://pt.wikipedia.org/wiki/Arquitetura_de_von_Neumann>; acedido em: Novembro de
2013.
94
9. ANEXO
Em anexo, o acesso aos nòs escravos por ssh.
95
Após a configuração do Cluster, monitorizando o funcionamento do cluster com o ganglia.
