O documento apresenta um trabalho de conclusão de curso sobre a viabilidade da computação paralela em clusters de alto desempenho, focando em clusters Beowulf e o sistema operacional GNU/Linux. O estudo analisa o desenvolvimento de um supercomputador de baixo custo e como as tecnologias distribuídas podem atender à crescente demanda por potência computacional. Além disso, o projeto inclui a construção de um sistema de cluster para validar a performance e a eficiência da abordagem proposta.

1. UNIVERSIDADE DE UBERABA
ROGÉRIO ABADIO CARDOSO RODRIGUES
COMPUTAÇÃO PARALELA:
VIABILIDADE EM CLUSTER DE ALTO DESEMPENHO
UBERLÂNDIA - MG
2011

2. ROGÉRIO ABADIO CARDOSO RODRIGUES
COMPUTAÇÃO PARALELA:
VIABILIDADE EM CLUSTER DE ALTO DESEMPENHO
Trabalho de conclusão de curso apresentado à
Universidade de Uberaba, como parte dos
requisitos à graduação e obtenção do título de
Engenheiro de Computação.
Orientadora: Profª Ms. Luciene Chagas de
Oliveira.
Co-Orientador: Prof. Esp. Mário Cesar
Pintaudi Peixoto
UBERLÂNDIA - MG
2011

4. A toda minha família, principalmente,
minha mãe Elza e meu pai José,
meus amigos de curso,
e à minha noiva Rossana,
sem os quais seria impossível
alcançar mais esta conquista
e que sempre estiveram ao meu lado
não importando o momento,
incentivando-me a buscar o conhecimento,
Dedico este trabalho.

5. AGRADECIMENTOS
À Deus, acima de tudo, agradeço, pela saúde, serenidade e perseverança sobre mim
concedidas, para superar mais esta batalha e alcançar mais um degrau na escada da vida.
Aos meus queridos pais, Elza e José, que se dedicaram a mim com amor , carinho e
sempre me incentivaram, acreditando em meus sonhos.
Especialmente a Rossana, que soube me ouvir e compreender, nas horas que precisei
do seu apoio e carinho, pela dedicação incondicional e pelas conquistas e superações
realizadas em conjunto.
Aos professores do curso de Engenharia de Computação, pelo apoio no convívio
estimulante durante toda a trajetória, e que, por meio de seus ensinamentos, permitiram a
construção de uma base de conhecimentos sólida. Em especial à Profª Mario Cesar e à minha
orientadora Profª Luciene Chagas de Oliveira, pelo estímulo e competente orientação durante
a pesquisa.
Aos colegas de turma, pelas reflexões críticas e sugestões recebidas, e ainda, pelo
maior aprendizado obtido durante o curso, a convivência, o companheirismo nas horas
difíceis do aprendizado e o respeito às diferenças.

6. “[...] no pain, no gain [...]”
(Scorpions)
“Por mais difícil
que seja cada novo degrau da vida ele
deve ser superado mesmo que cause alguns
desgastes emocionais"
(Rogério Cardoso)

7. Resumo
Com o avanço e popularização das tecnologias de ponta, os microcomputadores cada
vez mais presentes no cotidiano da população trazem por conseqüência um aumento do
número de usuários conectados a aplicações Web ou local em um ambiente interno de uma
Intranet. Esta demanda de poder computacional exige que o processamento seja cada vez mais
eficiente.
Na busca de garantir o sucesso das aplicações, os diferentes tipos de sistemas
distribuídos são implementados para garantir a demanda dos processos usados nas aplicações.
Justamente nesse sentido, procura-se o aumento de desempenho, colocando-se assim, a
computação paralela, como fator determinante para um maior poder computacional de
maneira mais viável.
Este projeto apresenta uma visão geral sobre Sistemas Operacionais com destaque e
ênfase para o sistema GNU/Linux, analisando o desenvolvimento de um supercomputador
com um Hardware de baixo custo, sendo uma possível solução interessante para uso em
conjunto com outras tecnologias atuais como, por exemplo, a virtualização e outras aplicações
que exijam um alto desempenho de processamento.
Para efeito de validação do conhecimento contido neste trabalho foi projetado um
sistema de cluster com três máquinas, que demonstra o desempenho possível de se conseguir
com o uso de um aglomerado de computadores do tipo Beowulf1.
Palavras - chave: Sistemas Operacionais, Cluster, Linux, Supercomputadores.
1
Beowulf são clusters de desempenho escalável baseado em hardware commodity, em uma rede do tipo privado
e software open source (BEOWULF, 2011).

8. Abstract
With the advancement and popularization of technologies, personal computers are
increasingly present in daily life of the population consequently bring an increase in the
number of users connected to applications or Web site in an internal environment
of an Intranet. This demand for computing power requires that the processing
is more efficient.
In seeking to ensure the success of applications, different types of distributed systems
are implemented to ensure the demand of the processes used in applications. Precisely in this
sense, we seek to increase performance, placing it well, and parallel computing, as the
determining factor for greater computing power in a more viable.
This project presents an overview of operating systems with emphasis and focus to
the GNU / Linux system, analyzing the development of a supercomputer with a low-cost
hardware, and an interesting possible solution for use in conjunction with other current
technologies such as virtualization and other applications requiring high
performance processing.
For the purpose of validating the knowledge contained in this paper was
designed a cluster system with three machines, which shows the performance possible to
achieve with the use of a cluster of Beowulf type computers.
Keywords: Operating Systems, Cluster, Linux, Supercomputers.

9. LISTA DE FIGURAS
Figura 1- Paralelização de Tarefas ........................................................................................... 30
Figura 2 - Organização geral de um cluster de servidores de três camadas ............................. 32
Figura 3 - modelo de sistema de alta disponibilidade .............................................................. 34
Figura 4 - Cluster de balanceamento de Carga......................................................................... 34
Figura 5 - Arquitetura de um cluster de PCs ............................................................................ 36
Figura 6 - Diagrama Básico de um cluster Beowulf ................................................................. 37
Figura 7 - Gráfico Sistemas Operacionais em Supercomputadores ......................................... 41
Figura 8 - Dois segmentos de redes .......................................................................................... 45
Figura 9 - Interface do Putty ..................................................................................................... 48
Figura 10 - Ambiente de manipulação do WinSCP ................................................................. 48
Figura 11- Teste inicial do sistema ........................................................................................... 49
Figura 12 - imagem renderizada com POVRay........................................................................ 50
Figura 13 - imagem renderizada com POVRay........................................................................ 52
Figura 14 - Webmin no servidor Mestre .................................................................................. 55
Figura 15 - Webmin no servidor escravo1 ............................................................................... 55
Figura 16 - Processo de paralelização de uma aplicação .......................................................... 57
Figura 17 - Estrutura MPI......................................................................................................... 57
Figura 18 - Funcionamento em teste do bWatch ...................................................................... 58
Figura 19 - Aplicação com POVRay ........................................................................................ 59
Figura 20 - Primeira renderização de imagem.......................................................................... 60
Figura 21 - nó Mestre ............................................................................................................... 62
Figura 22 - nó Escravo1 ........................................................................................................... 63
Figura 23 - nó Escravo 2 .......................................................................................................... 63
Figura 24 - Roteador de acesso remoto ao nó mestre ............................................................... 64

10. LISTA DE TABELAS
Tabela 1 – S. O. % utilizado em Supercomputadores .............................................................. 41
Tabela 2 - Tempo de resposta para Skyvase.pov ..................................................................... 51
Tabela 3 - Tempo de resposta para Benchmark.pov................................................................. 51

11. LISTA DE QUADROS
Quadro 1- Código utilizado no Arquivo hosts.equiv. ............................................................... 46
Quadro 2 - Código utilizado no Arquivo securetty. ................................................................. 47
Quadro 3 - Código utilizado no Arquivo exports. .................................................................... 47
Quadro 4 - Script Shell resolvendo Dependências. .................................................................. 53
Quadro 5 - Arquivo hosts de todos os micros do cluster.......................................................... 54
Quadro 6 - Arquivo .hosts ........................................................................................................ 54

12. LISTA DE ABREVIATURAS E SIGLAS
API - Application Program Interface (Interface de Aplicação)
CC-NUMA – Cache Coherence Non-Uniform Memory Access
CPU – Central Processing Unit – Unidade Central de Processamento
DNS – Domain Name Service (Serviço de Domínio de Nomes).
FTP – File Transfer Protocol (Protocolo de Transferência de Arquivo).
GNU - General Public License (Softwares Licenciados pelo Projeto GNU (Licença Pública
Geral)).
HA – High Availability
HD – Hard Disk (Disco Rígido).
HOST – Máquina ligada à rede.
HPC – High Performance Computing
HPCC/ESS - High Performance Computing Cluster/Earth and Space Sciences
HTTP - Hyper Text Transfer Protocol (Protocolo de Transferência de Hiper texto ).
HTTPS - Hyper Text Transfer Protocol Secure (Protocolo Seguro de Transferência de Hiper
texto).
IBM - International Business Machines.
IP - Internet Protocol (Protocolo de Internet).
IPV4 – Internet Protocol Version 4 (Protocolo de Internet Versão 4).
IPV6 – Internet Protocol Version 6 (Protocolo de Internet Versão 6).
LAN – Local Area Network (Rede de Área Local).
MB – Megabytes
MFlops – Megaflops
MIMD – Multiple Instruction Multiple Data (Múltiplas Instruções de Dados Múltiplos).
MISD – Multiple Instruction Single Data.
MPI - Message Passing Interface (Interface de passagem de mensagens).
MAN – Metropolitan Area Network (Rede de trabalho Metropolitana).
NAT - Network Address Translation (Conversão de Endereços de Redes).
NASA - National Aeronautics and Space Administration (Administração Nacional do Espaço
e da Aeronáutica).
NFS - Network File System (Sistema de Arquivos de Rede).
POVRay - Persistence Of Vision Raytracer (Persistência da visão Raytracer).

13. PVM - Parallel Virtual Machine (Maquina virtual paralela).
RAM – Random Access Memory (Memória de acesso aleatório).
SAD – Sistema de Arquivos Distribuído.
SSH – Security Shell (Segurança Shell).
S. O. – Sistema Operacional.

14. SUMÁRIO
Capítulo 1 – Introdução ....................................................................................... 16
1.1 Justificativa e Motivação .....................................................................................18
1.2 Objetivo Geral ..................................................................................................19
1.3 Objetivos Específicos ..........................................................................................19
1.4 Organização do Trabalho .....................................................................................20
Capítulo 2 – Sistemas Operacionais e Sistemas Distribuídos ............................. 21
2.1 Sistemas Operacionais .........................................................................................21
2.1.1 Memória virtual ....................................................................................................... 22
2.1.2 Deadlock .................................................................................................................. 22
2.1.3 Proteção do Sistema................................................................................................. 24
2.1.4 Segurança em Sistemas Operacionais ..................................................................... 25
2.1.5. Sistemas de Arquivos Distribuídos......................................................................... 25
2.1.6. Threads ................................................................................................................... 26
2.1.7. Sistemas Open Sources ........................................................................................... 26
2.2 Sistemas Distribuídos ..........................................................................................29
2.2.1 Processamentos Paralelos ........................................................................................ 29
2.2.1.1 Tipos de processamentos paralelos ...................................................................... 30
2.2.2 Tipos de Cluster ...................................................................................................... 31
2.2.2.1 - Cluster de alta disponibilidade ........................................................................... 33
2.2.2.2 – Clusters de Alto Desempenho ........................................................................... 35
2.2.2.2.1 – Arquitetura de um cluster Beowulf ................................................................. 36
2.2.2.2.2 – Vantagens e desvantagens de um cluster Beowulf ......................................... 38
2.2.2.2.3 – Tipo de Rede utilizada em um cluster Beowulf .............................................. 39
2.2.2.2.4 – Hardware utilizado em um cluster Beowulf ................................................... 40
2.2.2.2.5 – Sistema Operacional utilizado em um cluster Beowulf .................................. 40
2.2.2.2.6 – Aplicações de um cluster Beowulf ................................................................. 42
Capítulo 3 – Desenvolvimento de Cluster De Alto Desempenho ...................... 44
3.1 Visão Geral do Projeto do Cluster .......................................................................45
3.3 Protótipos do Sistema ..........................................................................................46
3.3.1 Acesso ao Nó mestre ............................................................................................... 46

15. 3.3.2 Requisitando uma tarefa .......................................................................................... 49
3.3.3 Resposta do Sistema ................................................................................................ 51
3.4 Ferramentas e Tecnologias ..................................................................................53
3.4.1 Scripts ...................................................................................................................... 53
3.4.2 Automatização da Construção do Cluster ............................................................... 54
3.4.3 Programação Paralela .............................................................................................. 56
3.4.4 Ferramentas de Monitoramento do Cluster ............................................................. 58
3.4.5 Aplicação do Cluster Renderizando Imagens ......................................................... 58
3.6 Hardware .............................................................................................................61
Capítulo 4 – Considerações Finais ...................................................................... 65
REFERÊNCIAS BIBLIOGRÁFICAS ................................................................ 66
ANEXO ............................................................................................................... 68

16. 16
Capítulo 1 – Introdução
Nas últimas décadas, a taxa de crescimento do poder de processamento de mini-
computadores, mainframes2 e os tradicionais supercomputadores tem sido algo em torno de
20% ao ano, enquanto a taxa de crescimento do poder de processamento de
microprocessadores tem sido algo em média de 40% ao ano (PITANGA, 2008).
Atualmente, os computadores voltados para usuários finais evoluem tanto na
arquitetura quanto na tecnologia. Exemplos destas tecnologias que foram incorporadas são o
uso da memória cache, pipelines dentre outros, que os supercomputadores da década de 70 já
tinham a maioria destes recursos que foram incorporados.
Conforme comentado por Morimoto (2009), com a popularização das redes e da
Internet, passamos a depender da conexão com a Internet até mesmo para as tarefas mais
básicas e a armazenar cada vez mais informações em servidores remotos.
As aplicações e a estrutura que mantém esse suporte passam a ter uma vital
importância para os dias atuais e aplicações como Google Docs e serviços online dependem
de mais processamento e velocidade, exigindo mais esforços tanto de Hardware quanto de
desenvolvimento de softwares otimizados para esse tipo de aplicação.
Cluster pode ser definido como um sistema onde dois ou mais computadores
trabalham de maneira conjunta para realizar processamento pesado. Em outras palavras, os
computadores dividem as tarefas de processamento e trabalham como se fossem um único
computador (ALECRIM, 2011).
A computação em cluster possui um longo histórico de casos atividades bem
sucedidas como é o caso cluster do tipo Beowulf que foi usado na produção do filme Titanic
feito pela Digital Domain (DOMAIN, 2002), em Venice, Califórnia com o uso de 160
computadores, para fazer os cálculos de adição de elementos nas cenas do navio fazendo com
que o mesmo pareça estar navegando, ancorado ou afundando. O custo do projeto foi 40%
menor que uma solução baseada em supercomputadores do mesmo poder de processamento
da época.
Os grandes mainframes de duas décadas atrás deram lugar a servidores de baixo
custo, montados usando componentes similares aos usados nos desktops, hospedados em
2
Mainframes: computadores de grande porte de processamento.

17. 17
datacenters3 e administrados remotamente. Os links de fibra óptica caíram brutalmente de
preço tornando viáveis sites que disponibilizam vídeos e outros tipos de mídia (MORIMOTO,
2009).
Os supercomputadores, como são de se esperar, são máquinas caras, mas que
oferecem um grande desempenho. Essa característica os torna quase inacessíveis para as
empresas de menor porte. Fica então o dilema: ou se gasta muito dinheiro e compra-se um
supercomputador de alto desempenho, ou então se economiza dinheiro e tenta-se satisfazer
com máquinas de desempenho inferior. Por esta razão que os clusters de computadores a cada
dia crescem mais (PITANGA, 2008).
O Sistema Operacional que tem o maior destaque no uso de clusters é o GNU/Linux
por ser de código fonte aberto possui maior flexibilidade a diferentes tipos de situações.
Dados estatísticos do site TOP500 (TOP500, 2011) mostram os mais potentes
supercomputadores sendo que 79% deles utilizam o GNU/Linux. Portanto, este é o sistema
utilizado nesse projeto para comprovar a versatilidade e viabilidade de um cluster.
Cluster Beowulf pode ser considerado o cluster mais difundido e utilizado para o
processamento de alto desempenho, isto se deve muito ao seu baixo custo de implementação.
Veio suprir a crescente necessidade de elevada capacidade de processamento em diversas
áreas científicas. (ALVARENGA, 2007).
Ha outros tipos de aglomerados de computadores como o Mosix que baseia-se na
distribuição de processos, mais por ser relativamente complicado de implantar, pois envolve
modificar o Kernel do sistema e recompilar o Beowulf acaba sendo mais atrativo aos
iniciantes em supercomputadores.
A semente inicial veio ainda na década de 1960, com a IBM (International
Business Machines), em uma forma de interligar vários mainframes, com o projeto que
recebeu o nome de IBM Parallel Sysplex System. Porém, foi somente em 1993 que os
pesquisadores Donald J. Becker e Thomas Sterling começaram a desenvolver um sistema de
processamento distribuído utilizando-se Hardware convencional. Em 1994, trabalhando no
CEDIS (subsidiária da NASA), sob o patrocínio do Projeto HPCC/EES, nasceu o projeto
Beowulf (NETO, 2008).
3
Datacenters: são conhecidos como central de processamento de dados, que possuem toda uma estrutura
adequada e abrigar vários computadores.

18. 18
1.1 Justificativa e Motivação
Os benefícios mais importantes que os clusters podem nos proporcionar segundo
Pitanga (2008), Batista (2007) e Dantas (2005) são:
 Baixo custo: a redução de custo para se obter processamento de alto
desempenho utilizando-se simples PCs.
 Disponibilidade: devido ao cluster possuir no mínimo dois nós, em caso de
ocorrer qualquer problema, a disponibilidade dos serviços não deve ser
prejudicada.
 Escalabilidade: a configuração pode crescer à medida que mais recursos
estiverem disponíveis.
 Tolerância à falhas: o aumento de confiabilidade do sistema como um todo,
caso alguma parte falhe.
 Alto desempenho: possibilidade de se resolver problemas muito complexos
através do processamento paralelo, o que diminui o tempo de resolução dos
problemas.
 Produtividade de Negócios: Empresas que operam em cluster possuem uma
operaração com mais eficiência, melhor aproveitamento de economias de
escala e recursos compartilhados.
 Sensibilização de Mercado: Clustering permite que as empresas possam
atender aos mercados existentes é responder melhor às mudanças do mercado
futuro, através do estabelecimento de laços mais estreitos com clientes e
mercados locais. Empresas que empregam cluster também podem atuar de
forma cooperativa no fornecimento de dados de mercado para novas
soluções.
 Transferência de Inovação e conhecimento: Como parte de um cluster, as
empresas podem conhecer melhor novas fontes e buscar oportunidades de
inovação através de vínculos mais fortes com instituições, prestadores de
serviços e estabelecimentos de ensino.
A estrutura de aglomerados de computadores ou cluster tem como vantagem
diferencial o seu valor de custo-benefício muito inferior ao de um ambiente multiprocessado e
por esta razão permite maior flexibilidade de expansão de processamento acrescentando mais

19. 19
máquinas de forma rápida. Outro fator também importante é a manutenção do cluster, pois os
componentes são facilmente encontrados no mercado, ao contrário do ambiente
multiprocessado. Entende-se por ambiente multiprocessado como sendo um Hardware
dedicado com motherboards que possuem vários processadores em uma única placa
(PITANGA, 2008).
São inúmeros os benefícios que um aglomerado de computadores, ou seja, cluster
pode trazer para uma organização ou instituição. Porém, antes do desenvolvimento do cluster,
a finalidade do mesmo já deve estar previamente definida, pois devem ser desenvolvidos com
uma finalidade especifica e não desenvolver sem saber os processos que devem ser agilizados.
(DANTAS, 2005).
Um cluster de computadores pode ser visto como uma solução alternativa para
universidades e empresas de pequeno a médio porte, para obterem processamento de alto
desempenho na resolução de problemas através de aplicações paralelizáveis, a um custo
razoavelmente baixo se comparado com os altos valores necessários para a aquisição de um
supercomputador da mesma classe de processamento (PITANGA, 2008).
Este trabalho tem a proposta de montar um cluster físico e abordar os conhecimentos
sobre computação paralela, para que seja atribuído o cluster a sistemas de virtualização
comercial utilizando a plataforma do Citrix XENServer.
1.2 Objetivo Geral
O objetivo deste trabalho é realizar um estudo aprofundado nos conteúdos de
sistemas operacionais e sistemas distribuídos usando cluster, bem como realizar uma
implementação prática de um cluster de alto desempenho e baixo custo facilitando a
compreensão e implementação.
1.3 Objetivos Específicos
Os objetivos específicos deste trabalho são:
 Apresentar uma abordagem geral da teoria de sistemas distribuídos e clusters;
 Desenvolver um cluster Beowulf que tenha as seguintes características:

20. 20
 Baixo custo de implementação;
 Alto poder de processamento;
 Gerenciamento fácil de ser visualizado e monitorado;
 Utilização de sistemas GNU/Linux de forma que a implementação seja
facilmente personalizada para determinadas aplicações;
 Implementação de configurações específicas;
 Construção de um nó mestre e três escravos;
Portanto, o trabalho tem por objetivo realizar o projeto de um cluster Beowulf de
baixo custo e fácil entendimento do seu funcionamento.
1.4 Organização do Trabalho
O presente trabalho encontra-se dividido e organizado nos seguintes capítulos:
 Capítulo 1 foi apresentado uma introdução e contextualização geral do tema
computação paralela: cluster, destacando sua colocação no momento
histórico atual e suas aplicações;
 Capítulo 2 apresenta um referencial teórico e apresenta uma abordagem geral
sobre o cluster Beowulf, em que são apresentados os principais conceitos
relativos à sistemas operacionais e sistemas distribuídos para o entendimento
do cluster, destacando as vantagens do uso de sistemas open source em
implementações do tipo, principais supercomputadores que marcaram épocas,
o funcionamento dos clusters de alta disponibilidade e de alto desempenho;
 Capítulo 3 apresenta o Cluster desenvolvido, mostrando a topologia,
tecnologias usadas e os resultados de testes obtidos comparando o sistema
como todo;
 Capítulo 4 apresenta as considerações finais e trabalhos futuros, concluindo a
pesquisa sobre cluster e sua colocação no mercado atual;

21. 21
Capítulo 2 – Sistemas Operacionais e Sistemas Distribuídos
Este capítulo aborda conceitos fundamentais para a construção do cluster, que de
certa maneira pode ser definido com duas áreas distintas para sua construção: sistemas
operacionais e sistemas distribuídos.
No contexto de Sistemas Operacionais, citam-se os problemas encontrados para que
a solução de computação paralela fosse implementada e os conteúdos relacionados como
funcionamento de memória virtual do sistema, Deadlock e segurança do sistema.
Já em Sistemas distribuídos é discutido as soluções de computação paralela e quais
os ambientes possíveis para sua aplicação, discutindo sobre tipos de clusters e forma de como
este pode ser utilizado. Ainda neste capítulo, tem-se uma introdução aos tipos de redes que
podem ser utilizadas na implementação do Cluster Beowulf.
2.1 Sistemas Operacionais
Um sistema operacional é um programa que gerência o Hardware do computador.
Ele também fornece uma base para os programas e aplicativos e atua como intermediário
entre o usuário e o Hardware do computador (SILBERSCHATZ, 2010).
Um aspecto interessante dos sistemas operacionais é o quanto eles assumem
diferentes abordagens ao cumprir regras e tarefas. Por exemplo, os sistemas de mainframe são
projetados basicamente para aperfeiçoar a utilização do Hardware, os sistemas desktop são
utilizados para a utilização de jogos e aplicações do usuário, os sistemas para tablets são
voltados para mobilidade, e cada um possui suas características específicas. Já a utilização de
sistemas operacionais com a distribuição de tarefas e de processamento leva ao
aperfeiçoamento da computação paralela detalhadas em sistemas distribuídos e para
apresentar os fundamentos de um cluster será descritos estes dois conceitos.
Para o entendimento das aplicações relacionadas a clusters ou outras variações da
sua arquitetura, o conhecimento de sistemas operacionais é de suma importância, pois sem o
entendimento do seu funcionamento como um todo, as funcionalidades desejadas ao se
construir um cluster podem não ter sucesso durante sua construção. Tais problemas podem
estar relacionados a programação paralela mal feita gerando deadlocks, travamentos por má

22. 22
configuração de memória virtual ou SWAP, defeitos de distribuição de arquivos entre os nós
do cluster e entre outros assuntos relacionados a sistemas operacionais.
Relacionado a sistemas operacionais será discutido os conceitos de memória virtual,
Deadlock, sistemas de I/O, proteção dos sistemas, segurança e sistemas Open Source que são
importantes para a realização do trabalho com clusters Beowulf.
2.1.1 Memória virtual
A memória virtual é uma técnica que permite a execução de processos que não estão
completamente em memória. Uma das principais vantagens desse esquema é que os
programas podem ser maiores do que a memória física.
A memória virtual abstrai a memória principal em um array de armazenamento muito
extenso e uniforme, separando a memória lógica visualizada pelo usuário da memória física.
Essa técnica libera os programadores das preocupações com as limitações de armazenamento
da memória. A memória virtual também permite que os processos compartilhem arquivos
facilmente e que a memória compartilhada seja implementada (SILBERSCHATZ, 2010).
Além disso, ela fornece um mecanismo eficiente para a criação de processos.
Entretanto, a memória virtual não é fácil de implementar e pode degradar o desempenho se
for empregada de uma forma descuidada.
Clusters possuem suas particularidades para serem montados, mas um problema
encontrado após sua montagem é conseguir encontrar softwares aptos a trabalharem em seu
ambiente. É importante que vários cuidados adicionais sejam tomados ao se tratar a memória
virtual que é um importante assunto tratado em sistemas operacionais. É um recurso que
permite um desempenho mais aprimorado do cluster se bem dimensionada e configurada de
acordo com a carga de processamento imposta ao aglomerado de computadores.
2.1.2 Deadlock
Deadlock são problemas que necessitam ser tratados e em um ambiente de clustering,
que possui um alto poder de processamento, o que de certa forma não o deixa imune a um
deadlock. O deadlock deve ser conhecido e ter um tipo de prevenção ou administração para
que o cluster fique otimizado, aproveitando o máximo seus recursos, ao invés de ter

23. 23
problemas de travamentos ocasionados por má gerenciamento ou falta de prevenção de
deadlocks.
Um estado de deadlock ocorre quando dois ou mais processo estão esperando
indefinidamente por um evento que só pode ser causado por um dos processos em espera. Há
três métodos principais para a manipulação de deadlock:
 Usar algum protocolo para a prevenção ou o impedimento de Deadlock, garantindo
que o sistema nunca entre em estado de Deadlock;
 Permitir que o sistema entre em estado de Deadlock, detecte-o e promova a
recuperação;
 Ignorar o problema e assumir que nunca ocorrerão Deadlocks no sistema.
Um método de impedimento de Deadlock alternativo ao método de prevenção requer
que o sistema tenha a informações a priori sobre como cada processo utilizará os recursos do
sistema. O algoritmo do banqueiro, por exemplo, requer informações a priori sobre a
quantidade máxima de cada classe de recurso que cada processo pode solicitar, usando essas
informações podemos as diferenças entre um processo que estará em um estado seguro e um
inseguro garantindo assim que todos serão concluídos e impedindo o estado de Deadlock
(TANENBAUM, 2003).
Se um sistema não empregar um protocolo pra garantir que os Deadlock jamais
ocorram, então um esquema de detecção e recuperação pode ser usado um algoritmo de
detecção de Deadlock deve ser invocado para determinar se ocorreu um Deadlock. Se um
Deadlock for detectado, o sistema deve se recuperar encerrando alguns dos processos
envolvidos no Deadlock ou provocando a preempção dos recursos de alguns desses processos.
A maioria dos sistemas operacionais, incluindo Unix e Windows, simplesmente ignora
o problema, supondo que a maior parte dos usuários preferiria um Deadlock ocasional a uma
regra que restrinja cada usuário a somente um processo, um arquivo aberto e um de cada
recurso. Se fosse possível eliminar Deadlock sem custo, não haveria muita discussão. O
problema e que o custo e alto – na maioria das vezes implica restrições não convencionais aos
processos. Assim, deparamos com uma analise não muito prazerosa de custo-benefício ente
conveniência e correção, alem de muita discussão acerca do que e mais importante para quem.
Nessas condições torna-se difícil encontrar soluções gerais. Uma citação que pode-se ser
lembrada e o algoritmo do avestruz(TANENBAUM, 2003).

24. 24
2.1.3 Proteção do Sistema
Os sistemas de computação contem muitos objetos, e eles precisam ser protegidos
contra a má utilização. Os objetos podem ser de Hardware (tais como memória, tempo de
CPU e outros) ou de software (tais como arquivos programas e semáforos). Um direito de
acesso é a permissão para executar uma operação sobre um objeto. Um domínio é um
conjunto de direitos de acesso.
Os processos são executados em domínios e podem utilizar qualquer um dos direitos
de acesso do domínio para acessar e manipular objetos. Durante seu tempo de vida, um
processo pode tanto ser limitado a um domínio de proteção como autorizando a comutar de
um domínio para outro. A matriz de acesso é um modelo geral que fornece um mecanismo
para proteção sem a imposição de uma determinada política de acesso ao sistema ou a seus
usuários. A separação entre política e mecanismo é uma propriedade de projeto importante a
matriz de acesso e esparsa. Ela é normalmente implementada tanto como lista de acessos
associadas a cada objeto, quanto como listas de competência associadas a cada domínio.
Podemos incluir proteção dinâmica no modelo da matriz de acesso considerando os
domínios e a própria matriz de acesso como objetos. A revogação de direitos de acesso em
um modelo de proteção dinâmica e normalmente mais fácil de implementar com um esquema
de lista de acessos do que com uma lista de competências (SILBERSCHATZ, 2010).
Proteção de sistema refere-se a um conjunto de técnicas para proteger o sistema de
erros e sobreposições em várias camadas. A prevenção de que um mesmo pacote ou aplicativo
utilize a mesma área de memória alocada é um exemplo, que inclusive foi o motivo da
clássica tela de erro com a mensagem “este programa executou uma operação ilegal e será
finalizado" que ocorrem freqüentemente no Windows 3.x e no Windows 9x. Essa proteção e a
sua utilização é de suma importância, pois o sistema Beowulf deve possuir estabilidade para
executar exaustivas tarefas de processamento e a proteção do sistema operacional escolhido
deve garantir essa característica.

25. 25
2.1.4 Segurança em Sistemas Operacionais
Os recursos computacionais devem ser protegidos contra acessos não autorizados,
destruição ou alteração maliciosa e introdução acidental de inconsistências. Esses recursos
incluem as informações armazenadas no sistema tanto de dados quanto código, assim como a
CPU, memória e discos e rede que compõem o computador (SILBERSCHATZ, 2010).
Os Beowulfs, por definição, não tem contato com o mundo externo à sua própria rede.
Isto os torna seguros por natureza. A única preocupação seria entre o nó principal e o resto da
rede, mas neste caso se aplicam as regras padrões de segurança para qualquer rede normal.
Como em geral eles são usados em ambientes de pesquisa e por poucas pessoas, segurança
normalmente não é uma preocupação. Em ambientes mais hostis onde possa ser necessário
um controle mais severo, pode-se limitar o acesso ao nó principal (que na verdade representa
todo o cluster para o mundo externo) da mesma maneira que se limita o acesso a qualquer
máquina em qualquer rede na Internet (RUIZ, 2011).
2.1.5. Sistemas de Arquivos Distribuídos
Um sistema de arquivos distribuído (SAD) é um tipo de sistema de arquivos no qual
todos os dados nele armazenados estão espalhados em Hardwares fisicamente diferentes,
interconectados através de uma rede. Tais sistemas possuem vários aspectos semelhantes aos
dos sistemas de arquivos centralizados, além de operações de manipulação de arquivos,
mecanismos de redundância e consistência, entre outros atributos. A vantagem do uso de um
SAD é a possibilidade de montar estratégias de distribuição de carga para melhor desempenho
no acesso aos dados, mesmo sob alta demanda (MAGAZINE, 2010).
A escolha da melhor opção de um sistema de arquivos distribuído eficiente depende da
topologia de rede, ou da estratégia de armazenamento de dados. E para os clusters que usam a
distribuição de arquivos entre o nó mestre e os escravos, o conhecimento do tipo e da
estrutura de arquivos distribuído é fundamental para o seu funcionamento e para sua
otimização.

26. 26
2.1.6. Threads
Em sistemas operacionais tradicionais, cada processo tem um espaço de
endereçamento e um único thread (fluxo) de controle. Na verdade, isso é quase uma definição
de processo. Contudo, freqüentemente há situações em que é desejável ter múltiplos Threads
de controle no mesmo espaço de endereçamento executando em quase-paralelo, como se eles
fossem processos separados (exceto para espaços de endereçamento compartilhados)
(TANANENBAUM, 2003).
Uma thread, às vezes chamado de processo leve, é uma unidade básica de utilização de
CPU; compreende um ID de thread, um contador de programa, um conjunto de registradores e
uma pilha. Compartilha com outros Threads pertencentes ao mesmo processo sua seção de
código, seção de dados e outros recursos do sistema operacional, tais como arquivos abertos e
sinais. Um processo tradicional, ou pesado, tem um único fluxo de controle. Processos com
múltiplos Threads podem realizar mais de uma tarefa de cada vez (SILBERSCHATZ, 2000).
O conhecimento e controle sobre os Threads em um cluster no momento de distribuir
as informações a serem processadas pelos nós ocasiona melhor desempenho e otimização do
sistema distribuído para os recursos do sistema.
2.1.7. Sistemas Open Sources
Uma das características de clusters Beowulfs é a utilização de sistemas Open Sources
e em função desta propriedade que será detalhada a seguir.
Segundo Mazioli (2010), Linux é um Sistema Operacional criado em 1991 por Linus
Torvalds na universidade de Helsinki na Finlândia. É um sistema Operacional de código
aberto distribuído gratuitamente pela Internet. Seu código fonte é liberado como Free
Software (software livre), sob licença GNU GPL (General Public License), o aviso de
copyright do Kernel feito por Linus descreve detalhadamente isto e mesmo ele não pode
fechar o sistema para que seja usado apenas comercialmente.
As definições para a licença de softwares livres se definem em quatro liberdades
básicas que são elas:

27. 27
 A liberdade de executar um programa seja qual for o propósito;
 A liberdade de modificar um programa para adaptá-lo às suas necessidades e, para que
isso ocorra, você deve ter acesso ao código-fonte;
 A liberdade de redistribuir cópias, gratuitamente ou mediante uma taxa;
 A liberdade de distribuir versões modificadas do programa e, nesse caso, toda a
comunidade poderá beneficiar-se dos aperfeiçoamentos.
As definições anteriores são palavras de Richard Stallman (1985), o fundador do
movimento de softwares livre em 1985 que agregou mais tarde ao sistema Linux
desenvolvido por Linux Torvalds e foi combinado formando um sistema operacional
completo.
Para a construção de um projeto com alto poder de processamento, manipulação de
dados, informações e gerenciamento de diferentes tipos de Hardwares, os sistemas Open
Sources possuem como principal característica da liberdade número dois, sendo este um fator
decisivo para sua escolha, sendo mais utilizado para clusters do tipo Beowulf. Mas não é
somente essa característica que o torna o favorito para este tipo de aplicação, de acordo com
Mazioli (2010) algumas das características do Linux são:
 Recebe apoio de grandes empresas como IBM, Sun, HP, etc. para seu
desenvolvimento
 Multitarefa real
 Multiusuário
 Utiliza permissões de acesso a arquivos, diretórios e programas em execução na
memória RAM.
 Proteção entre processos executados na memória RAM
 Suporte a mais de 63 terminais virtuais (consoles)
 Modularização - O Linux somente carrega para a memória o que é usado durante o
processamento, liberando totalmente a memória assim que o programa/dispositivo é
finalizado
 Suporte nativo a rede e tecnologias avançadas como: balanceamento de carga, ips,
alias, failover, vlans, bridge.

28. 28
 Suporte nativo a múltiplas CPUs, assim processadores como Dual Core, Core Duo,
Athlon Duo, Quad Core tem seu poder de processamento integralmente aproveitado,
tanto em 32 ou 64 bits.
 Rede TCP/IP mais rápida que no Windows e tem sua pilha constantemente melhorada.
O GNU/Linux tem suporte nativo a redes TCP/IP e não depende de uma camada
intermediária como o WinSock. Em acessos via modem a Internet, a velocidade de
transmissão é 10% maior.
 Possui recursos para atender a mais de um endereço IP na mesma placa de rede, útil
para situações de manutenção em servidores de redes ou para a emulação de
"múltiplos computadores".
 Suporte a diversos dispositivos e periféricos disponíveis no mercado, tanto os novos
como obsoletos.
 Pode ser executado em 16 arquiteturas diferentes (Intel, Macintosh, Alpha, Arm, etc.)
e diversas outras sub-arquiteturas.
Os sistemas operacionais do tipo Open Sources possuem características e qualidades
que fazem com que o aglomerado de computadores do tipo Beowulf tenha-o como sistema
favorito para suas implementações e desenvolvimentos. Torna-se básico um conhecimento
prévio das características e vantagens que esse tipo de sistema pode oferecer, como por
exemplo da necessidade deste conhecimento pode-se comparar uma analogia a este fato a
compra e utilização de um carro: quando um mecânico/piloto compra um carro ele preza não
somente o fato do carro andar, mas também a possibilidade de melhorar este com regulagens
especificas e próprias para o seu uso adaptando-o. Agora caso este mesmo carro fosse de
alguma forma impossibilitado de ser manipulado, provavelmente ele não terá um bom
desempenho para este dono, já que originalmente é feito de forma genérica para ser utilizado
por qualquer tipo de usuário sem seus devidos ajustes é de certa maneira um problema maior
ainda o fato de nem mesmo saber como este carro anda ou funciona. Portanto, sistemas
proprietários não podem ser alterados para a montagem de um cluster.

29. 29
2.2 Sistemas Distribuídos
Um sistema distribuído é uma coleção de processadores que não compartilha memória
ou relógio. Em vez disso cada processador possui sua própria memória local. Os
processadores comunicam-se uns com os outros através de várias redes de comunicação, tais
como, os buses de alta velocidade ou linhas telefônicas.
De acordo com Silberschatz (2010), um sistema distribuído é uma coleção de
processadores fracamente acoplados interconectados por uma rede de comunicação. Do ponto
de vista de um processador específico em um sistema distribuído, os outros processadores e
seus respectivos recursos são remotos, enquanto seus próprios recursos são locais.
Os conceitos básicos para montagem de um cluster Beowulf são mostrados com a
soma de conhecimentos de duas áreas de tecnologia uma delas são os sistemas operacionais
que fora explicada na seção anterior e sistemas distribuídos que se relaciona com Beowulfs.
Pelo princípio de que um conjunto de operações são feitas e compartilhadas com outros
componentes do sistema, o papel fundamental de sistemas distribuídos para cluster é entender
sua arquitetura, estrutura e sua distribuição de cargas entre os componentes.
2.2.1 Processamentos Paralelos
Os problemas computacionais usualmente podem ter algumas de suas partes divididas
em pedaços que poderiam ser solucionados ao mesmo tempo ou processados em paralelo.
Define-se então processamento paralelo como uma forma pela qual a demanda computacional
é suprida através do uso simultâneo de recursos computacionais como processadores para
solução de um problema de forma mais rápida com algum tipo de coordenação (PINHEIROS,
2008).
Os sistemas com múltiplos processadores também podem economizar dinheiro em
comparação com vários sistemas de um único processador, porque os processadores podem
compartilhar periféricos, armazenamento de massa e fontes de alimentação. Se vários
programas forem processar o mesmo conjunto de dados, fica mais barato armazenar esses
dados em um disco e fazer com que todos os processadores os compartilhem, em vez de ter
muitos computadores com discos locais e muitas cópias dos dados (SILBERSCHATZ, 2000).

30. 30
O processamento paralelo é uma técnica que divide as tarefas grandes em tarefas
menores, e estas são distribuídas em vários processadores para serem executadas
simultaneamente. Estes processadores comunicam-se entre si para que haja coordenação
(sincronização) na sua execução (REBONATTO, 2004). A Figura 1 apresenta o modelo de
paralelismo computacional.
Tarefa 1 Processador A
Tarefas Grandes e
complexas Tarefa 2 Processador B
Tarefa 3 Processador C
Figura 1- Paralelização de Tarefas
Fonte: PITANGA, 2008.
2.2.1.1 Tipos de processamentos paralelos
A área de processadores paralelos foi, por muitos anos, uma área ativa de pesquisa.
Houve várias abordagens diferentes para criar computadores paralelos efetivos, e todos eles
(inclusive Clusters tipo Beowulf) tiveram níveis diferentes de efetividade para diferentes tipos
de problemas. Com o decorrer dos anos foram surgindo diversos sistemas computacionais de
elevado desempenho (HPC – High Performance Computing) baseados em diversas
arquiteturas.
Uma forma de classificação é referente aos tipos de processamento paralelo. De
acordo Pitanga (2008), os tipos podem ser: Multiprocessadores Simétricos (SMP),
Processadores Massivamente Paralelas (MPP) e CC-NUMA (Memória de Acesso não-
uniforme com Coerência de Cachê) e as características de cada um deles são:

31. 31
 Processadores Paralelos Massivos (MPP): É um grande sistema de processamento
paralelo com arquitetura de memória compartilhada (DSM) e centralizada. Conta com
centenas e até milhares de elementos processadores (nós), que são interligados por
uma conexão de rede com alta velocidade, os nós possuem memória própria e um ou
mais processadores.
 Multiprocessadores Simétricos (SMP): Sistema de processamento simétrico que
apresenta de dois até sessenta e quatro processadores, compartilhando a mesma
memória, através de um barramento ou uma rede de comunicação dedicada. Como
todos os processadores podem acessar a mesma memória, o tempo de acesso deve ser
muito baixo, porém quanto maior o sistema mais cresce o tempo de acesso.
 Memória de Acesso não-uniforme com Coerência de Cachê (CC-NUMA): CC-
NUMA é um sistema de multiprocessadores escaláveis que possuem uma arquitetura
de coerência de cachê com acesso não uniforme. Igual a uma máquina SMP, cada
processador é um sistema CC-NUMA com uma visão globalizada da memória. Nessa
arquitetura a memória é dividida e cada processador tem seu bloco de memória, cada
bloco de memória é conectado via barramento a um processador como memória local.
Segundo Dantas (2005) Destaca-se algumas aplicações para esta arquitetura como
serviços de Web, banco de dados, processamento de sinal, CRM e ERP.
2.2.2 Tipos de Cluster
Quando se utilizam dois ou mais computadores em conjunto para resolver um problema,
você tem um cluster, que do inglês significa agrupamento (PITANGA, 2008).
Em muitas palavras simples, um cluster de servidores nada mais é que um conjunto de
máquina conectado por uma rede, no qual cada máquina executa um ou mais servidores. Na
maioria dos casos o cluster é organizado logicamente em três camadas como mostra a Figura
2. A primeira camada consiste em um comutador (lógico) por meio do qual são rateadas as
requisições do cliente. Esse comutador pode variar muito de acordo com o tipo de cluster
(TANENBAUM, 2007). A segunda camada corresponde aos servidores de aplicação que são
responsáveis pelo processamento das requisições e a terceira camada consiste em servidores
de arquivos e bancos de dados. Neste modelo, temos uma explicação genérica para a maioria
dos clusters.

32. 32
Comutador logico Serviço de aplicaçao Sistema distribuido de
arquivos/ banco de dados
Requisição
despachada
requisição de cliente
Primeira Camada Segunda Camada Segunda Camada
Figura 2 - Organização geral de um cluster de servidores de três camadas
Fonte: TANEMBAUM, 2007.
O termo “clustering” referencia atualmente a um número de diferentes tecnologias e
configurações. Podemos dividir os clusters em duas categorias básicas: alta disponibilidade
(HA – High Avaibility) e alto desempenho de computação (HPC – High Performance
Computing). Os clusters HA têm a finalidade de manter um determinado serviço de forma
segura o maior tempo possível. Os clusters HPC são uma configuração designada a prover
grande poder computacional do que somente um único computador poderia lhe oferecer em
capacidade de processamento (PITANGA, 2008).
De uma forma geral, a computação baseada em clusters já ocasionou o
desenvolvimento de dezenas de ambientes de programação e gerenciamento. O teste de várias
tecnologias para interconexão de nós, o desenvolvimento e até mesmo, reimplementações de
bibliotecas e aplicações já desenvolvidas, a produção de inúmeros artigos e o estabelecimento
de grupos de trabalhos ao redor do mundo. O ponto desfavorável é que todo o conhecimento
produzido está espalhado por várias fontes e cresce rapidamente, o que dificulta, às vezes, um
entendimento mais amplo ou atualizado desse assunto (PITANGA, 2008).
O “Cluster da NASA” era “formado por 16 PCs 486 DX-100 ligados em rede. Para
manter a independência do sistema e baixar os custos, os desenvolvedores optaram por
utilizar o Linux”. (MORIMOTO, 2011).

33. 33
Os tipos de clusters são divididos em duas categorias: alta disponibilidade e de alto
desempenho. O tipo de cluster utilizado neste trabalho foi do de alto desempenho denominado
cluster Beowulf.
2.2.2.1 - Cluster de alta disponibilidade
Clusters de alta disponibilidade ou (HA – High Avaibility) fazem parte do tipo mais
comum de cluster, pois são utilizados como servidores de tarefas criticas que não podem
deixar de funcionar em momento algum. Um bom exemplo desse tipo de cluster são alguns
sistemas web que para suportar determinado fluxo de informações mantém dois ou mais
servidores em forma de Load Balancing ou balanceamento de cargas para que caso um fique
com muitas tarefas o fluxo e direcionado para o outro que assume fazendo com que o sistema
fique sempre disponível.
O cenário típico de Clusters HA possui duas ou mais máquinas cujos serviços estão
espelhados. Dois arranjos normalmente são utilizados. O primeiro deles é o caso de um
servidor ficar sempre na espera que o outro fique fora de funcionamento e quando isso ocorre,
entra no lugar e passa a realizar a função do servidor que está fora. Isso é mostrado na Figura
3, mas para que tudo ocorra perfeitamente os dois compartilham um disco em comum.
No segundo tipo, os dois servidores ou mais ficam em funcionamento distribuindo a
carga sobre eles, conforme mostrado na Figura 4. Em algumas situações, pode haver a
combinação desses dois arranjos de forma que a disponibilidade dos serviços tenha a maior
disponibilidade possível.
Este tipo de sistema é bem conhecido, pois ele faz com que serviços de vitais
importâncias para as empresas fiquem sempre funcionando. Exemplos comerciais onde esse
tipo de cluster é vital são os sites de comércio eletrônicos. Segundo Pitanga (2008), de uma
maneira geral um servidor de boa qualidade apresenta uma disponibilidade de 99,5%,
enquanto uma solução baseada em clusters de computadores apresenta uma disponibilidade
de 99,99%.

34. 34
Requisição dos
Clientes
Rede Pública
Disco Local Disco Local
Cabo Crossover
Servidor 1 Servidor 1: Servidor 2:
192.168.1.8 192.168.1.9 Servidor 2 em
ativo como
espera por falha
primario
ou Standby
Resposta do cluster Storage
Endereço IP: compartilhado
192.168.1.10 do Cluster
Figura 3 - modelo de sistema de alta disponibilidade
Fonte: JAYASWAL, 2006.
Clientes Clientes Clientes
Internet
VIP ( IP virtual)
Balanceador
Servidores Reais
Figura 4 - Cluster de balanceamento de Carga.

35. 35
2.2.2.2 – Clusters de Alto Desempenho
O funcionamento básico de um cluster de alto desempenho pode ser exemplificado da
seguinte forma: dado um problema, que possa ser divido em partes menores (“ser
paralelizado”), um servidor fica responsável por dividir o problema em várias partes e enviar
para os respectivos nós. Esses, por sua vez, acham a solução e respondem ao servidor, que
junta às respostas e disponibiliza para o usuário. (GORINO, 2006).
Um cluster de computadores pode ser visto como uma solução alternativa para
universidades e empresas de pequeno a médio porte, para obterem processamento de alto
desempenho na resolução de problemas através de aplicações paralelizáveis, a um custo
razoavelmente baixo se comparado com os altos valores necessários para a aquisição de um
supercomputador da mesma classe de processamento (PITANGA, 2008).
De acordo com Pitanga (2008), as características principais dos clusters são: alto
desempenho, escalabilidade, tolerância a falhas, baixo custo e independência de fornecedores,
a saber:
 Alto Desempenho: capacidade de resolver problemas complexos utilizando o
poder computacional gerado pelo processamento paralelo, de forma que o tempo
de resolução de uma atividade seja reduzido a valores consideráveis;
 Escalabilidade: característica que permite a possibilidade de expansão do cluster
a medida que for necessário o crescimento do poder computacional, o cluster pode
ser facilmente adicionado com recursos;
 Tolerância a falhas: quanto maior o sistema, maior será sua confiabilidade com
um todo. Caso uma parte falhe, outro executará sua tarefa;
 Baixo custo: devido a sua implementação ser feita com PC’s simples, o custo é
relativamente menor se comparado com o custo de computadores de grande porte;
 Independência de fornecedores: utilização de Hardware aberto, software de uso
livre e independência de fabricantes e licenças de uso.
Entre os principais objetivos dos projetos de clusters de alto desempenho, em geral,
está a busca pelo aperfeiçoamento do processamento e a melhoria na distribuição de tarefas
entre os nós integrantes do sistema. Para os clusters de alto desempenho, outra necessidade é
que o sistema deve parecer para o usuário final como um único computador ou a soma dos

36. 36
recursos individuais de todos os nós pertencentes ao cluster. Um exemplo de cluster de alto
desempenho é o cluster Beowulf mostrados a seguir. O cluster do tipo Beowulf surge na
história como uma necessidade de elevar o processamento em diversas áreas científicas com o
objetivo de compor os sistemas computacionais de alto desempenho e com viabilidade
econômica.
2.2.2.2.1 – Arquitetura de um cluster Beowulf
O cluster HPC é um tipo de sistema para processamento paralelo ou distribuído que
consiste de uma coleção de computadores interconectados, trabalhando juntos como um
recurso de computação simples e integrado. Um nó do cluster pode ser um simples sistema:
multiprocessador (PCs4, estações de trabalho ou SMPs) com memória, dispositivos de
entrada/saída de dados e um sistema operacional. No entanto, esse sistema pode fornecer
características e benefícios (serviços rápidos e confiáveis), encontrados somente em sistemas
com memória compartilhada (multiprocessadores simétricos - SMP), como os
supercomputadores. A arquitetura típica de um cluster é mostrada na Figura 5 (PITANGA,
2008).
Aplicações Paralelas
Aplicações Sequenciais Ferramentas de programação Paralela
Cluster Middleware – Sistema de Imagen Simples (SSI – System Single Image)
PC PC PC
Interface de Interface de Interface de
Rede Rede Rede
Rede / Comutador de alta velocidade
Figura 5 - Arquitetura de um cluster de PCs
A arquitetura apresentada mostra de certa maneira um formato genérico de clusters de
computadores. O tipo Beowulf apresenta particularidades especificas da sua implementação
4
PC’s: abreviatura de Personal Computers ou computadores pessoais no português

37. 37
entre elas pode-se verificar o esquema na Figura 6 que pode-se destacar os seguintes
componentes:
 Nó Controlador (Servidor Mestre): controla a administração e distribuição das
tarefas entre seus clientes também chamados de escravos. Este membro é
responsável pela interface de conexão com o lado externo do sistema de acesso de
clientes e usuários finais do software. Portanto, ele está em um ponto critico, pois
controla tanto a segurança do sistema, quanto as suas ligações de front-end.
Comumente é utilizado somente um servidor do tipo mestre. Em clusters de
grandes proporções, pode-se utilizar mais de um.
 Nós Escravos: definido como a parte do sistema que não pode ser acessado pela
rede externa. Normalmente, não possui nem mesmo dispositivos de acesso local a
eles, são controlados pelo nó controlador e ficam a disposição do mestre para
executar tarefas de processamento que lhe são enviadas pela rede.
 Rede dedicada: esta parte é a rede de alta velocidade que interliga o nó
controlador aos nos escravos.
Usuário
Nós Escravos Estrutura de
Back-End’s
LAN Pública interface de rede esclusiva
Nó Controlador
Nós Escravos Estrutura de
Back-End’s
Figura 6 - Diagrama Básico de um cluster Beowulf

38. 38
2.2.2.2.2 – Vantagens e desvantagens de um cluster Beowulf
Considerando-se que o desempenho de um cluster Beowulf pode ser a mesma de (ou
maior que) um supercomputador, sem dúvida a maior vantagem é o preço (RUIZ, 2011).
Depois cita-se a manutenção barata e também o alto nível de experiência que já foi
atingido por cientistas que trabalham nesta área e estão dispostos a compartilhar este
conhecimento com outras pessoas (RUIZ, 2011).
Quanto às vantagens de um cluster podemos segundo Marcus (2006), citar:
 Estes sistemas são muito escaláveis, pois é possível pôr em rede (e coordenar)
um grande número de nós. Assim, não existe um limite definido para o
tamanho de um cluster.
 Os componentes utilizados são maciçamente comercializados e que desta
forma pode-se usufrui economias de escala.
 Substituir um nó defeituoso é tão simples quanto mudar de PC. Assim, é
possível ter uma gestão de falhas eficiente, baseada na fácil substituição de
componentes.
 Existe uma independência em relação ao fornecedor de hardware. Como o
material que o constitui é muito comum, se faltar uma peça pode-se encontrá-la
com facilidade. Existem também mais especialistas em PCs do que de
Hardware proprietário.
 O software é gratuito e inclui o código fonte. Por essa razão é mais flexível
permitindo alterações tanto ao nível do sistema operacional, como das
aplicações utilizadas. Disponibilizar o código fonte torna o sistema mais
robusto e de confiança, pois significa que quem estiver interessado pode fazer
debugging5, detectar erros e gerar correções.
 Cada nó do cluster pode ser um sistema completo, útil para uma grande
variedade de aplicações. Assim, o risco de um projeto de cluster não resultar
em nada é sempre reduzido pelo fato de todo o hardware poder ser reutilizável.
Da mesma forma, toda a configuração pode ser utilizada (e testada) para outros
fins.
5
Debugging: também conhecido por Debug e o processo de encontrar e reduzir defeitos em software’s ou
hardware’s.

39. 39
Entretanto, há algumas desvantagens no uso de clusters Beowulfs:
 Com algumas exceções, o Hardware de rede não foi criado para funcionar em
Processamento Paralelo. Tipicamente tem uma grande latência e largura de
banda menor que sistemas SMP.
 Existe ainda pouco software que suporte e trate o cluster como um sistema
único. Por exemplo, o comando ps, do Sistema Operacional Linux só dá
informação sobre processos sendo executados em um único nó do cluster.
 É necessário ter experiência e conhecimento de administração de sistemas
Linux. A configuração dos nós pode não ser muito trivial.
Porém, apesar de algumas desvantagens, clusters são surpreendentemente poderosos.
Há uma inscrição semestral reunida pela Universidade de Manhiem na Alemanha que
descreve os 500 supercomputadores mais poderosos no mundo (TOP 500, 2011).
Até 1997, quase todos os sistemas listados eram supercomputadores comerciais de
fabricantes famosos como Cray, Silicon Graphics e IBM. Porém em 1998, começaram a
aparecer nesta lista Clusters paralelos baseados em Linux. Dois sistemas se localizam perto
do topo da lista: o número 97, chamado “CPlant” desenvolvido por Sandia National Labs, e o
número 113, chamado “Avalon” desenvolvido por Los Alamos Labs. O Avalon é um cluster
de 140 máquinas Alpha 533 MHz, localizado no Laboratório Nacional de Los Alamos, nos
Estados Unidos, e custou uma fração do preço de seus concorrentes próximos no ranking,
mesmo usando máquinas de alta qualidade, é um exemplo do poder que clusters podem ter
(MARCUS, 2006).
2.2.2.2.3 – Tipo de Rede utilizada em um cluster Beowulf
Um cluster é um tipo de sistema de processamento paralelo, que consiste num
conjunto de computadores (nós), interligados entre si, funcionando de uma forma integrada
como se fosse um único sistema de computação. Um nó de um cluster pode ser um sistema
monoprocessador ou multiprocessador, PC, Workstation ou SMP, com memória, facilidades
de I/O e sistema operacional. Os clusters Beowulf em particular são pilhas de PCs, consistindo
no mínimo em dois ou mais nós (PCs) interligados através de uma rede local privada.
Tipicamente utilizam-se dois segmentos Ethernet para interligar os nós (MARCUS, 2006).

40. 40
2.2.2.2.4 – Hardware utilizado em um cluster Beowulf
Pitanga (2008) lista uma série importante de características a serem levadas em
consideração na hora da montagem do projeto de cluster: tipo de processador; tamanho e
velocidade da memória cache (L1/L2/L3); número de processadores por nó; capacidade,
velocidade e tecnologia da memória RAM; velocidade do barramento; chipset da placa mãe e
placas de rede.
Para Dantas (2005) quando à interconexão é formado por multiprocessadores e
multicomputadores específicos, o projetista poderá avaliar o sistema de interconexão somente
com a comparação do material fornecido pelo fabricante.
Braga (2003) orienta que a escolha dos componentes de “Hardware” e “software” para
a construção de clusters do tipo Beowulf devem ser criteriosa e vem se mostrando bastante
viável a computação de alto desempenho para instituições com fortes restrições financeiras.
Em um projeto de cluster, o ideal é produzir uma análise dos aplicativos que irão compor o
ambiente e o respectivo custo-benefício do ambiente projetado. (DANTAS, 2005).
2.2.2.2.5 – Sistema Operacional utilizado em um cluster Beowulf
Segundo Ferreira (2001), um sistema operacional executa várias tarefas como
gerenciamento de periféricos de entrada / saída, memória e controle de arquivos e diretórios
no disco. Vários sistemas operacionais podem ser usados no projeto de cluster Beowulf e o
GNU/Linux (incluindo suas variadas distribuições) é o mais utilizado para este fim, devido a
sua confiabilidade, robustez e por ser software livre com código fonte aberto, permitindo
várias otimizações e custo reduzido.
De acordo com o principal projeto de classificação de supercomputadores o Top 500
organizado por Hans Meuer da University of Mannheim, Alemanha, Jack Dongarra da
University of Tennessee, Erich Strohmaier e Horst Simon do NERSC / Lawrence Berkeley
National Laboratory. o principal sistema operacional utilizado em Supercomputadores é o
sistema operacional Linux como pode ser verificado na Tabela 1. A Figura 7 mostra a Tabela
1 com seu gráfico correspondente.

41. 41
Sistema Operacional
Contagem Participação em %
Linux 413 82.60 %
Super-UX 1 0.20 %
AIX 20 4.00 %
Cell OS 1 0.20 %
SuSE Linux Enterprise
Server 9 3 0.60 %
CNK/SLES 9 14 2.80 %
SUSE Linux 2 0.40 %
Redhat Linux 4 0.80 %
RedHat Enterprise 4 1 0.20 %
SUSE Linux Enterprise
Server 10 2 0.40 %
SLES10 + SGI ProPack 5 14 2.80 %
UNICOS/lc 1 0.20 %
CNL 10 2.00 %
Windows HPC 2008 6 1.20 %
RedHat Enterprise 5 1 0.20 %
CentOS 6 1.20 %
Open Solaris 1 0.20 %
Totals 500 100%
Tabela 1 – S. O. % utilizado em Supercomputadores
Fonte: Top 500, 2011.
Linux
Super-UX
AIX
Cell OS
SuSE Linux Enterprise Server 9
CNK/SLES 9
SUSE Linux
Redhat Linux
RedHat Enterprise 4
SUSE Linux Enterprise Server 10
SLES10 + SGI ProPack 5
Figura 7 - Gráfico Sistemas Operacionais em Supercomputadores
Fonte: Top 500, 2011.

42. 42
Segundo Rubem e Ferreira (2003) as vantagens principais do Linux são:
 Estabilidade: O sistema operacional Linux, embora exista uma variação entre a
maioria das distribuições, apresenta uma estabilidade muito satisfatória;
 Recursos do UNIX: O Linux compartilha as mesmas vantagens da maioria das versões
do UNIX;
 Gerenciamento: Assim como o UNIX, o Linux possui um poderoso gerenciamento e
interface de linhas de comandos.
 Fonte Aberta: Além de adquirir o sistema operacional gratuitamente, tem-se também o
código fonte. O que permite mudar inclusive o Kernel de acordo com os requisitos de
segurança.
Ainda de acordo com Rubem e Ferreira (2003) o Linux possui também algumas
desvantagens, de onde pode se destacar:
 Pessoal Habilitado: ainda existe uma carência com relação à pessoal habilitado para o
mercado de trabalho;
 Variação entre distribuições: apesar de obedecer a uma padronização, existem muitas
variações entre as diversas distribuições disponíveis.
Mediante todas confirmações de diversos especialistas na área inclusive o projeto Top 500
que possui significativa participação em medidas de desempenho e auxilia a projetos de
supercomputadores, confirma a escolha pelo sistema operacional Linux para a implementação
de projetos do tipo Beowulf como melhor alternativa principalmente pelas suas características
e o seu valor para implementações de baixo custo.
2.2.2.2.6 – Aplicações de um cluster Beowulf
O desenvolvimento da eletrônica que impulsionou a construção dos semicondutores e
por conseqüência o acesso a equipamentos eletrônicos somado ao uso da Internet tiveram um
grande efeito no público em geral. Computadores de alto-desempenho e sistemas de clusters

43. 43
Beowulf podem ter o mesmo efeito, em particular a pessoas que fazem ferramentas de
informação e ambientes de simulação.
A área de aplicação dos clusters é muito diversificada. São geralmente as aplicações
seqüenciais muito grandes, que necessitam de enorme quantidade de memória e tempo de
enorme de processamento. Tradicionalmente, o desenvolvimento de computadores tem sido
motivado por simulações numéricas de sistemas complexos como analise meteorológica,
simulação de dispositivos mecânicos, circuitos eletrônicos, reações químicas, seqüenciamento
de DNA e aplicações que podem manipular grandes quantidades de dados para extrair alguma
espécie de informação ou conhecimento (MARCUS, 2006).
Alguns exemplos de áreas onde os clusters podem ser implementados e serão muito
úteis são: servidores de Internet, banco de dados, computação gráfica, aerodinâmica, análise
de elementos finitos, inteligência artificial e automação, engenharia genética, exploração
sísmica, oceanografia e astrofísica, previsão do tempo, pesquisas militares, problemas e
pesquisa básica (física, química, engenharia e matemática), segurança de reatores nucleares.
(PITANGA, 2008).

44. 44
Capítulo 3 – Desenvolvimento de Cluster De Alto Desempenho
O projeto desenvolvido neste trabalho tem como finalidade fazer a montagem de um
cluster paralelo com custo de viabilidade baixo aproveitando micro-computadores antigos e
conseguindo uma alta performance de processamento. Lembra-se também que neste momento
será demostrado os passos de montagem e configuração do cluster Beowolf.
O desenvolvimento do projeto foi feito em duas partes: no primeiro momento a
montagem dos locais físicos para alocar os computadores, montagem e testes com os
componentes adquirido logo em seguida a instalação e configuração do sistema operacional
básico no caso do projeto foi utilizado a distribuição Linux Centos 6 por já ser bastante
utilizada no meio acadêmico e comercial com suas características sempre mencionadas de
estabilidade e robustez para trabalhos de servidores.
As etapas de configuração do sistema Beowolf foram divididas de acordo com o
modelo proposto por PITANGA (2008):
 Configurar endereços lógicos (IP) para o controlador mestre e os nos
computacionais;
 Projetar um ambiente de resolução de nomes, podendo utilizar arquivos host
ou DNS.
 Criar um relacionamento de confiança entre as máquinas
 Permitir o uso de comandos remotos para colocar as aplicações em execução
nos nodos;
 Distribuir o sistema de arquivos do controlador mestre para os nos escravos
via Network File System (NFS)
 Instalar uma aplicação de gerenciamento
 Instalar bibliotecas de passagem de mensagens: PVM e MPI
 Instalar sistemas de gerenciamento de recursos para aproveitar nos ociosos no
cluster.

45. 45
3.1 Visão Geral do Projeto do Cluster
O intuito principal da construção do projeto foi a configuração e o estudo teórico para
manipular um cluster do tipo Beowulfs e conseguir realizar sua aplicação com um baixo
custo de implantação, e com isso o projeto foi desenvolvido e montado através de um
computador comum de uso pessoal com desempenho razoavelmente bom para os padrões
atuais de computação e com mais dois micros que foram descartados, por serem antigos e
lentos para os dias atuais. Desta forma, o projeto visa unir poder de processamento e
conseguir um desempenho de supercomputador a doação do que seria descartado como lixo,
foi aproveitada nesse projeto.
A Figura 8 ilustra o tipo de rede utilizada para a construção do cluster do projeto e
suas configurações mais simples como o acesso remoto ao computador mestre e as classes de
endereçamento IP’s 6utilizadas.
Acesso
remoto ao
nó mestre
Roteador Wireless Interface de
rede Wlan
192.168.0.0/24
Interface de Nós Escravos com
rede eth0 rede separada
192.168.1.0/24
Nó mestre
Mestre.tcc.local
192.168.1.1
Figura 8 - Dois segmentos de redes
6
IP’S: Internet Protocol ou no português protocolo de internet e o mais utilizado protocolo para envio de pacotes
via rede de comunicação.

46. 46
3.3 Protótipos do Sistema
Para explicar melhor o funcionamento do sistema foi dividido em: acessar o no mestre,
requisitar uma tarefa e resultados conseguidos. Que será mais bem detalhado nos tópicos 3.3.1
ao 3.3.3.
3.3.1 Acesso ao Nó mestre
O acesso ao servidor mestre para realizar as configurações tanto iniciais quanto as
programações para realizar tarefas são feita remotamente por uma rede wireless e alguns
pontos interessantes a serem destacados é que o acesso ao sistema é feito utilizando o
protocolo SSH com o pacote OpenSSH. O acesso entre o mestre e seus nos escravos é feito
por acesso remoto com relação de confiança através do RSH, Rlogin e Rexec com algumas
configurações especificas podem ser visualizadas nos Quadros 1,2 que mostram os arquivos
de configuração que estão localizados em: /etc/securetty, /etc/hosts.equiv. O arquivo que
monta o sistema de arquivos remoto no servidor mestre e compartilha o sistema de arquivos
distribuídos com os nos escravos através do protocolo NFS Network File System a
configuração foi feita no arquivo localizado em /etc/exports acrescentando algumas
configurações para que o sistema permita a montagem do sistema de arquivos durante a
inicialização do sistema operacional o arquivo e visualizado no Quadro 3.
hosts.equiv
mestre
escravo1
escravo2
Quadro 1- Código utilizado no Arquivo hosts.equiv.
console
vc/1
vc/2
vc/3
vc/4
vc/5
vc/6
vc/7
vc/8
vc/9
vc/10
vc/11
tty1
tty2

47. 47
tty3
tty4
tty5
tty6
tty7
tty8
tty9
tty10
tty11
rsh
rlogin
Quadro 2 - Código utilizado no Arquivo securetty.
/home *(rw,no_root_squash)
/usr/local *(rw,no_root_squash)
Quadro 3 - Código utilizado no Arquivo exports.
O ntsysv é um utilitário de configuração de quais pacotes serão inicializados com o
sistema durante o boot, tanto para o mestre quanto para os nós escravos é importante que
alguns pacotes sejam inicializados por padrão devem estar marcados no ntsysv: rsh, sshd,
rlogin e rexec as opções marcadas já anteriormente não devem ser alteradas já que para a
utilização do sistema neste projeto foi utilizado uma versão mínima da distribuição Centos
que traz instalada por padrão o mínimo possível para que o sistema funcione e, portanto, não
possui acessórios extras que muitas vezes nem mesmo são utilizados deixando o sistema
enxuto e com recursos sempre a disposição do cluster para uma máxima performance.
Para o gerenciamento do sistema o computador remoto que acessa o mestre utiliza
sistema Windows e com isso, as ferramentas utilizadas para acessar o sistema foram o Putty e
o WinSCP para manipular arquivos e comandos no nó mestre a interface do Putty e
visualizada na Figura 9 e a interface do WinSCP na Figura 10.

48. 48
Figura 9 - Interface do Putty
Figura 10 - Ambiente de manipulação do WinSCP

49. 49
3.3.2 Requisitando uma tarefa
Com todo sistema montado os primeiros testes foram executados, com tarefas simples,
a primeira delas foi o cálculo do número matemático PI com várias casas decimais, e
distribuindo a tarefa pelos nós do cluster esta tela é verificada na Figura 11 que mostra os
tempos de respostas dos dois nós integrantes do cluster executando a requisição remota e
trocando mensagens entre eles para o cálculo o código fonte utilizado para realizar a
simulação abaixo está no anexo.
Figura 11- Teste inicial do sistema

50. 50
Para confirmar o desempenho proporcionado pelo cluster Beowolf em segundo
momento pós testes iniciais foi utilizado o exemplo skyvase.pov que inclusive funciona como
benchmark 7para vários clusters e possui uma lista de adeptos e inscritos no seu site que pode
ser acessado em : http://www.haveland.com/index.htm?povbench/index.php . O arquivo
skyvase.pov esta no capítulo em anexo para possíveis referências é a imagem gerada pode ser
visualizada na Figura 12.
A requisição de uma renderização utilizado o POVRay em conjunto com a biblioteca
MPICH que foi utilizada no projeto foi feita utilizando o seguinte comando:
# povray -i skyvase.pov +v1 -d +ft -x +a0.300 +r3 -q9 -w1024 -h768
Figura 12 - imagem renderizada com POVRay
7
Benchmark: processo sistemático e contínuo de avaliação que são reconhecidas como representantes das
melhores práticas com a finalidade de comparar desempenhos.

51. 51
3.3.3 Resposta do Sistema
Para verificar o teste de desempenho do sistema utilizando a imagem skyvase.pov foi
feito a renderização desta imagem com 2 configurações distintas no primeiro momento
usando 2 nós do cluster e em segundo momento somente com o poder de processamento do
mestre no primeiro teste a imagem foi renderizada com o tamanho de 1024 x 768 e no
segundo teste em alta resolução 640 x 480 a Tabela 5 mostra a o tempo de resposta do
sistema usando estes parâmetros.
Tamanho da imagem 640 x 480 1024 x 768
Somente no mestre 00:04:15 00:10:05
Mestre + escravo 1 00:03:10 00:06:08
Tabela 2 - Tempo de resposta para Skyvase.pov
O tempo de resposta da renderização de imagens é diretamente afetado de acordo com
a quantidade de computadores que manipulam a as imagens é comprova de acordo com a
tabela 5 justamente a idéia que o cluster que possui maior quantidade de nós consegue um
desempenho maior, mesmo que tenham diferentes Hardwares envolvidos no sistema.
Para poder comprovar o funcionamento e o desempenho do cluster foi utilizado em
segundo momento uma imagem um pouco mais pesada que a anterior com um maior grau de
detalhes, para que o desempenho de processamento fosse realmente tirado a prova, neste
segundo teste foi utilizada a imagem gerada pelo arquivo Benchmark.pov mostrada na Figura
13.
Tamanho da imagem 1024 x 768 640 x 480
Somente no mestre 00:42:35 00:20:05
Mestre + escravo 1 00:30:18 00:17:10
Tabela 3 - Tempo de resposta para Benchmark.pov
Comparando a Tabela 3 de resposta com a Tabela 2 é verificado que o segundo
arquivo possui um grau de detalhes muito maior que o anterior necessitado assim de muito
mais poder de processamento, mas mesmo assim é possível verificar o funcionamento do
cluster que com um no escravo a mais para complementar seu poder de processamento da
demonstra uma melhoria de quase 30% em relação a somente o micro mestre fazendo seu
trabalho.

52. 52
Figura 13 - imagem renderizada com POVRay
Uma questão interessante que vale a pena ser lembrada que inclusive é citada por
Pitanga (2008), e a diferença entre clusters homogêneos e heterogêneos, no desenvolvimento
do projeto foi utilizado um sistema heterogêneo que de certa maneira tem várias diferenças
entre os Hardwares utilizados, mas mesmo assim cumpriram bem o seu papel fazendo o
trabalho distribuído as tarefas normalmente entre os nós, mas poderia oferecer um
processamento melhor caso fosse homogêneo, pois iria processar no mesmo tempo cada parte
de informação que lhe foi enviada, mas por maior que seja o esforço para manter o cluster
sempre homogêneo em um determinado momento ele se tornara heterogêneo, devido a rápida
mudança de tecnologia no mercado e quando for necessário mudar ou modificar qualquer
componente ele será diretamente afetado.

53. 53
3.4 Ferramentas e Tecnologias
Para o desenvolvimento do trabalho foram utilizadas algumas ferramentas de
controle e monitoramento, entre elas pode-se mencionar o uso de editores de arquivos como
VIM, o conhecido protocolo de comunicação com servidores Linux e acesso remoto
OpenSSH, administrador de servidores via Web com o Webmin e ferramentas de
monitoramento de conexão e testes como o Nmap, o POVRay e o Nagios.
3.4.1 Scripts
Os scripts de configuração que são arquivos executáveis em sistemas Linux, eles
podem desde modificar uma simples configuração ate mesmo instalar editar arquivos e
realizar toda uma configuração ou automatização de uma tarefa. No projeto foi utilizada uma
linguagem comum conhecida para os administradores de redes. Os scripts têm o formato
básico padrão em Shell e utilizando o interpretador Bash comum e normalmente básico em
todas distribuições Linux atuais.
Scripts para instalação das principais dependências tanto no micro mestre quanto nos
escravos. O Quadro 4 mostra este detalhe.
#/bin/bash!
yum –y update;
yum install - y htop unrar zip rar locate perl-Net-SSLeay perl-Net-Rexec rsh-server ntsysv
nmap nfs* ;
cd /usr/src;
wget http://prdownloads.sourceforge.net/webadmin/webmin-1.570-1.noarch.rpm ;
rpm –uvh webmin-1.570-1.noarch.rpm ;
Quadro 4 - Script Shell resolvendo Dependências.
O arquivo do Quadro 4 foi salvo e teve permissão de execução utilizando o comando
chmod +x e depois deve ser executado com ./nome_do_arquivo.sh

54. 54
O Quadro 5 mostra o arquivo de hosts de cada nó componente do cluster ele foi
configurado desta maneira para que cada computador do cluster consiga identificar tanto por
nome quanto por IP o computador presente no sistema, também poderia ser utilizado um
servidor DNS – Domain Name Server mais por questões de preferência foi utilizado a
configuração do arquivo hosts que por padrão fica localizado em /etc/ .
127.0.0.1 mestre.tcc.local mestre localhost.localdomain localhost
::1 mestre.tcc.local mestre localhost6.localdomain6 localhost6
192.168.1.1 mestre mestre.tcc.local
192.168.1.2 escravo1 escravo1.tcc.local
192.168.1.3 escravo2 escravo2.tcc.local
Quadro 5 - Arquivo hosts de todos os micros do cluster.
O Arquivo .hosts de todos micros localizado em: /home e /root mostrado no Quadro
6, este arquivo e necessário para que cada computador tenha confiança de acesso remoto sem
senha pelo pacote rsh.
.rhosts
mestre
escravo1
escravo2
Quadro 6 - Arquivo .hosts
3.4.2 Automatização da Construção do Cluster
Para automatizar algumas mudanças de configuração tornando-as mais ágeis para
serem executadas foi utilizado tanto nó mestre como nos nós escravos a ferramenta de
administração por Web browser, o Webmin, que facilitou a configuração do sistema de horas
e várias outras tarefas. Na Figura 14 pode-se visualizar a tela inicial do micro mestre e na
Figura 15 a tela de exemplo do mesmo sistema para manipulação dos escravos na rede.

55. 55
Figura 14 - Webmin no servidor Mestre
Figura 15 - Webmin no servidor escravo1

56. 56
3.4.3 Programação Paralela
Até pouco tempo atrás, o paralelismo era visto como uma área da computação, sem
qualquer interesse para os programadores experientes. O estudo das tendências nas aplicações,
tanto ao nível das arquiteturas de computadores como das redes de interligação, tem revelado
que esta perspectiva deixou de ter qualquer realidade. Com efeito, o paralelismo tem vindo a
se tornar o tema central na programação. Nas últimas décadas, a ciência da computação tem
se dedicado aos sistemas de computação paralela e distribuída (PITANGA, 2008).
Paralelismo de software é a habilidade de acelerar a execução de um programa
dividindo o mesmo em fragmentos múltiplos que podem ser executados simultaneamente.
Antes de se executar um programa em um cluster paralelo, tem que assegurar que o problema
que está se tentando resolver pode ser executado de forma paralela (MARCUS, 2006).
Para desenvolver o projeto foi utilizada a biblioteca MPI8, uma biblioteca com funções
de troca de mensagens e sincronização das atividades desenvolvidas pelo cluster seu
funcionamento permite que os processos de um programa que foi escrito em uma linguagem
seqüencial como C ou Fortran possa ser executado no projeto de forma paralelo desde que
tenha sido programado desta maneira a Figura 17 mostra a estrutura de funcionamento da
biblioteca MPI.
Há também, além da biblioteca MPI que foi utilizada, várias outras bibliotecas para
desenvolvimento paralelo: uma delas é a PVM – Maquina Virtual Paralela que foi
desenvolvida em 1989 pela University of Tennessee. O PVM foi um dos primeiros sistemas
de software a possibilitar que programadores utilizem uma rede de sistemas heterogêneos
(máquinas com sistemas operacionais diversos) para desenvolver aplicações paralelas sob o
conceito de passagem de mensagens (PITANGA, 2008).
O objetivo da programação paralela é transformar grandes algoritmos complexos em
pequenas tarefas que possam ser executadas simultaneamente por vários processadores,
reduzindo, assim, o tempo de processamento. A Figura 16 mostra o processo de paralelização
de uma aplicação de maneira genérica.
8
MPI: Message Passing Interface é um padrão para comunicação de dados em computação paralela.

57. 57
Problema original
Decomposição em tarefas
Unidades de execução agrupados
Tarefas, dados locais e compatilhados
Código com o ambiente de
programação paralela
Unidades de execução + novos dados Codigo fonte conrrespondente
compartilhados para as dependências
extraídas
Figura 16 - Processo de paralelização de uma aplicação
Fonte: PITANGA, 2008
Figura 17 - Estrutura MPI
Fonte: VIANA, 2010

58. 58
3.4.4 Ferramentas de Monitoramento do Cluster
O monitoramento de um cluster é de fundamental importância para o seu
funcionamento, para esta função existem vários recursos que podem ser utilizados desde
avançados monitores de sistema com o protocolo snmp como: Nagios, Gaglia, Cacti e vários
outros, como também o BWatch que o próprio nome diz B de Beowolf que é simples e ideal
para o monitoramento de até 10 micros no cluster. O bWatch é um script escrito em Tcl/Tk
designado para monitorar supercomputadores foi desenvolvido por Jack Radajewski
(PITANGA,2008).
Somente para efeito de teste após, instalado e configurado o bWatch foi feito o teste
desligando os dois escravos e deixando somente o nó mestre funcionando e o resultado é
visualizado na Figura 18 mostrando o sistema de monitoramento funcionando.
Figura 18 - Funcionamento em teste do bWatch
3.4.5 Aplicação do Cluster Renderizando Imagens
A aplicação escolhida para teste do processamento do cluster foi uma ferramenta
muito usada em filmes de Hollywood como Titanic, Final Fantasy, True Lies, Apolo 13 e
vários outros esta ferramenta e Open Source e pode ser utilizada livremente. O pacote
POVRay (Persistence Of Vision Raytracer) que possui algoritmos que produzem imagens
tridimensionais com mais alta qualidade e requinte de detalhes

59. 59
Hub ou Switch
Nó mestre Escravo 1 Escravo 2
Figura 19 - Aplicação com POVRay
A Figura 19 representa uma aplicação do tipo – cluster.pov, um arquivo desenvolvido
com o pacote POVRay. O esquema mostrado na figura mostra como o cluster Beowulf do
projeto dividiu a aplicação em pequenos pedaços em cada nó do cluster, portanto, cada
quadradinho do quadro representa um pedaço da aplicação que foi enviado para os nós
escravos para processamento, o nó mestre gerenciar o processo de envio dos pacotes e a
recuperação do resultado do processamento dos nós.
Ao completar a instalação do POVRay com sucesso e visualizado a primeira
renderização com sucesso do cluster o seu funcionamento pode ser visualizado na Figura 20.

60. 60
Figura 20 - Primeira renderização de imagem

61. 61
3.6 Hardware
Para o desenvolvimento do projeto foi utilizado três computadores do tipo PC
utilizando uma característica heterogênea no cluster, pois, devido a necessidade de viabilizar
o projeto foi utilizado modelos de baixo custo abaixo as características de cada um dos micros
utilizados na construção do cluster começando pelo mestre e na seqüência mostrando os 3
micros escravos
 Mestre
Computador com configuração voltada para usuários intermediários
Processador: AMD Atlhon X2 5200+ com dois núcleos de 2.6Ghz e chache l2 de 512
x2
Memória: Dual Channel com 4 Gigas de memória DDR II 800Mhz
Placa mãe: Asus M3A78
Placa de vídeo: ATI radeon 4550
Disco rígido: Sansung 500 gigas sata II
Sistema operacional: Centos 6
Duas interfaces de rede 1 ethernet e 1 wireless
 Escravo 1
Processador: Intel Pentium 4 2.4Ghz
Memória: 512 Mb DDR I 400Mhz
Placa mãe: Pcchips
Disco rígido: Maxtor 40 gigas IDE
Sistema operacional: Centos 6
 Escravo 2
Processador: Intel Celerom 2,13Ghz
Memória: 512MB DDR I
Placa mãe: Gigabyte P4M800
Disco rígido: Seagate 200 gigas sata I
Sistema operacional: Centos 6

62. 62
Para montar o sistema de cluster, também foram utilizados materiais para conectar o
nó mestre com os nós escravos e também o nó mestre com a rede de internet e acesso remoto
para envio de tarefas a serem executadas estes equipamentos são:
 Roteador wireless 300mbps
Marca: Tp-link
Modelo: TL-WR1043N
Conexões: 1 porta WAN 4 portas LAN todas Fast Ethernet
USB: 1 porta para armazenamento de dados
 Roteador wireless 54mbps
Marca: Mymax
Modelo: MWR/AP
Conexões: 1 porta WAN 4 portas LAN todas Fast Ethernet
Os equipamentos são mostrados nas Figuras: 21(mestre), 22(escravo1), 23(escravo2) e
24(Roteador de acesso Remoto ao mestre). Todos os componentes mostrados seguem a
sugestão do projeto Beowulf de serem equipamentos de fácil reposição, baratos e simples de
serem encontrados no mercado
Figura 21 - nó Mestre

63. 63
Figura 22 - nó Escravo1
Figura 23 - nó Escravo 2
Por se tratar de um pequeno cluster, para montar o sistema foi utilizado um roteador
wireless para acesso entre os nós escravos e o mestre com quatro portas de comunicação
ethernet /10/100 Mbps com função wireless desligada, utilizado por questões de custo de
implementação e facilidades como gerenciamento do seu funcionamento.

64. 64
A estrutura da rede se baseia em dois tipos: uma de acesso entre o mestre e os escravos
do cluster e outro segmento feito pela conexão de rede wireless como a segunda interface de
rede do nó mestre tronado possível o acesso remoto externo e inclusive a comunicação com a
internet pelo cluster para configurações iniciais e download de pacotes para a instalação e
configuração do sistema a Figura 24 mostra o roteador de acesso remoto e conexão com a web
do sistema.
Figura 24 - Roteador de acesso remoto ao nó mestre

65. 65
Capítulo 4 – Considerações Finais
Este trabalho apresentou uma abordagem teórica sobre clusters e como foi
desenvolvida uma aplicação do uso de clusters de alto desempenho e com viabilidade técnica
mostrando resultados e utilizando um cluster pode-se comprovar.
O sistema de renderização de imagens por ser uma atividade que necessita de grande
poder de processamento, foi utilizado para poder comparar o desempenho do cluster criado e
com o aplicativo POVRay, conseguiu se mostrar o quanto o aglomerado de computadores
possui de potencial a ser explorado os exemplos que foram utilizados mostraram exatamente
este poder e a capacidade que em muito pode ser explorado em vários outros estudos
acadêmicos.
O sistema permitirá que sejam realizados pesquisas e projetos futuros que tenham
necessidade de alto poder computacional e até mesmo, como possível alternativa a compra de
supercomputadores ou servidores dedicados para utilizar o conhecido sistema de virtualização
Citrix XEN criar clouds ou máquinas virtuais sobre clusters, sobretudo contribuindo para
futuras soluções de clouds computing.
A manipulação do Citrix XEN sobre o cluster possui poucos estudos relacionados e
por ser uma área de grande interesse comercial a idéia de virtualizar sobre o cluster e pouco
conhecida e caso fosse mais aprofundada poderia gerar conhecimentos novos na área de
virtualização.

66. 66
REFERÊNCIAS BIBLIOGRÁFICAS
ALECRIM, Emerson. Cluster: Principais conceitos. site infowester disponível em
<http://www.infowester.com/cluster.php>. acessado em 08 de setembro de 2011
BEOWULF, Org, Beowulf Project Overview. Site oficial da comunidade que desenvolve o
projeto disponível em: <http://www.beowulf.org/overview/index.html>. acessado em 15 de
novembro de 2011.
BRAGA, Ataulpa Albert Carmo. Aspectos Técnicos Envolvidos na Construção de um
"Cluster Beowulf". Artigo. Química Nova, Vol. 26, N. 3, 401-406: 2003.
DANTAS, MARIO. Computação Distribuída de Alto Desempenho. 1ª edição. Rio de
Janeiro: Axcel Books do Brasil Editora: 2005
DOMAIN, digital Site Oficial disponível em http://digitaldomain.com/ acessado em 09 de
setembro de 2011
FERREIRA, Luis; et al. Linux HPC Cluster Installation. IBM Redbooks, Ano 2001.
Disponível em: http://www.redbooks.ibm.com/redbooks/pdfs/sg246041.pdf. Acessado em: 05
jun. 2011.
GORINO, Fabio Valle Rego. Balanceamento de carga em clusters de alto desempenho:
uma extensão para a LAM/MPI. Universidade Estadual de Maringá. 2006.
JAYASWAL, Kailash. Administering Data Centers: Servers, Storage, and voice over IP.
Indianápolis, EUA. Editora Wiley Publishing Inc, 2006.
MAGAZINE, Linux, Sistemas De Arquivos Distribuídos. Edição nº 73, dez 2010, pág. 29
MARCUS, Johnny Gomes Rocha. Cluster Beowulf: Aspectos De Projeto E
Implementação. Universidade Federal Do Pará. 2006.
MAZIOLI, Gleydson da silva. Guia Foca GNU/Linux. Versão 5.65, set 2010. Disponível em
< http://www.guiafoca.org/cgs/guia/iniciante/ch-intro.html#s-introducao-linux-carac >
Acessado em 30 set. 2011.
MORIMOTO, Carlos Eduardo. "Servidores Linux, Guia Prático". 1ª reimpressão. Porto
Alegre, Editora Meridional e Sul Editores, 2009.
MORIMOTO, Carlos E. Glossário – Beowulf. Disponível em <http:// www .guiadohardware
.net/termos/beowulf > Acessado em: 12 jun. 2011.

67. 67
NETO, Calil Jorge; YAMAGISHI, Erika; SUGAYA, Helder Ken. Top500.org -
Supercomputadores. Instituto de Computação - Universidade Estadual de Campinas
(UNICAMP). Ano 2008. Disponível em<
http://www.ic.unicamp.br/~rodolfo/Cursos/mc722/2s2008/Trabalho/g11_texto.pdf >
Acessado em: 12 jun. 2011.
PINHEIROS, Alisson de Oliveira; GARCIA, Daniel Caixeta Queiroz. Arquitetura paralela
ou computação paralela. Ano 2008. Disponível em < http://knol.google.com/k/arquitetura-
paralela-ou-computa%C3%A7%C3%A3o-paralela# > Acessado em: 11 jun. 2011.
PITANGA, Marcos." Construindo Supercomputadores com Linux". 3ª edição. Rio de
janeiro: Brasport Livros e Multimídia Ltda.: 2008.
REBONATTO, M. T. Introdução a programação paralela com MPI em agregados de
computadores (clusters). Congresso Brasileiro de Ciência da Computação, Itajaí, 2004, 938
– 955. Itajaí, SC – Brasil, ISSN 1677-2822.
STALLMAN, Richard. Documentação do Projeto GNU. Disponível em
http://www.gnu.org/doc/doc.pt-br.html acessado em 20 out. 2011.
RUIZ, André. Implementando Cluster Beowulf usando Conectiva Linux. Disponível em
<http://suporte.lbr.com.br/linux/documentos/Portugues/Documentos%20Conectiva/beowulf.p
dp>. acessado em: 15 set. 2011.
SILBERSCHATZ, Abraham; Galvin, Peter Baer; Gagne, Greg. Fundamentos de sistemas
operacionais. Tradução: Aldir José Coelho Corrêa da Silva; revisão técnica: Elisabete do
Rego Lins. 8. ed. Rio de Janeiro: LTC, 2010.
SILBERSCHATZ, Abraham; Galvin, Peter Baer; Gagne Greg. Sistemas Operacionais -
Conceitos E Aplicações. Tradução de Adriana Ceschin Rieche. Rio de Janeiro: Campus,
2000.
TANANENBAUM, Andrews S. Sistemas Operacionais Modernos. Tradução: Ronaldo A.
L., Luis A. Consularo; revisão técnica: Regina Borges de Araujo 2ª. Ed. São Paulo; Pearson
Prentice Hall, 2003.
TOP 500, Supercomputers. Site Oficial. Disponível em: < http://www.top500.org/>.
Acessado em 22 março 2011.
VIANA, Hilário Barcellar. Cluster: Computação de Alto Desempenho. Instituto de
Computação, Universidade Estadual de Campinas. 2010.

68. 68
ANEXO
Arquivo CPI.c utilizado no teste do calculo de PI
#include "mpi.h"
#include <stdio.h>
#include <math.h>
double f(double);
double f(double a)
{
return (4.0 / (1.0 + a*a));
}
int main(int argc,char *argv[])
{
int done = 0, n, myid, numprocs, i;
double PI25DT = 3.141592653589793238462643;
double mypi, pi, h, sum, x;
double startwtime = 0.0, endwtime;
int namelen;
char processor_name[MPI_MAX_PROCESSOR_NAME];
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&myid);
MPI_Get_processor_name(processor_name,&namelen);
fprintf(stdout,"Process %d of %d on %sn",
myid, numprocs, processor_name);
n = 0;
while (!done)
{
if (myid == 0)
{
/*
printf("Enter the number of intervals: (0 quits) ");
scanf("%d",&n);
*/
if (n==0) n=10000; else n=0;
startwtime = MPI_Wtime();
}
MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);
if (n == 0)

69. 69
done = 1;
else
{
h = 1.0 / (double) n;
sum = 0.0;
/* A slightly better approach starts from large i and works back */
for (i = myid + 1; i <= n; i += numprocs)
{
x = h * ((double)i - 0.5);
sum += f(x);
}
mypi = h * sum;
MPI_Reduce(&mypi, &pi, 1, MPI_DOUBLE, MPI_SUM, 0,
MPI_COMM_WORLD);
if (myid == 0)
{
printf("pi is approximately %.16f, Error is %.16fn",
pi, fabs(pi - PI25DT));
endwtime = MPI_Wtime();
printf("wall clock time = %fn", endwtime-startwtime);
fflush( stdout );
}
}
}
MPI_Finalize();
return 0;
}
Arquivo skyvase.pov utilizado nos testes
// Persistence Of Vision raytracer version 2.0 sample file.
// By Dan Farmer
// Minneapolis, mn
// skyvase.pov
// Vase made with Hyperboloid and sphere {, sitting on a hexagonal
// marble column. Take note of the color and surface characteristics
// of the gold band around the vase. It seems to be a successful
// combination for gold or brass.
//
// Contains a Disk_Y object which may have changed in shapes.dat
#include "shapes.inc"

70. 70
#include "shapes2.inc"
#include "colors.inc"
#include "textures.inc"
#declare DMF_Hyperboloid = quadric { /* Like Hyperboloid_Y, but more curvy */
<1.0, -1.0, 1.0>,
<0.0, 0.0, 0.0>,
<0.0, 0.0, 0.0>,
-0.5
}
camera {
location <0.0, 28.0, -200.0>
direction <0.0, 0.0, 2.0>
up <0.0, 1.0, 0.0>
right <4/3, 0.0, 0.0>
look_at <0.0, -12.0, 0.0>
}
/* Light behind viewer postion (pseudo-ambient light) */
light_source { <100.0, 500.0, -500.0> colour White }
union {
union {
intersection {
plane { y, 0.7 }
object { DMF_Hyperboloid scale <0.75, 1.25, 0.75> }
object { DMF_Hyperboloid scale <0.70, 1.25, 0.70> inverse }
plane { y, -1.0 inverse }
}
sphere { <0, 0, 0>, 1 scale <1.6, 0.75, 1.6 > translate <0, -1.15, 0> }
scale <20, 25, 20>
pigment {
Bright_Blue_Sky
turbulence 0.3
quick_color Blue
scale <8.0, 4.0, 4.0>
rotate 15*z
}
finish {
ambient 0.1
diffuse 0.75
phong 1
phong_size 100
reflection 0.35
}
}

71. 71
sphere { /* Gold ridge around sphere portion of vase*/
<0, 0, 0>, 1
scale <1.6, 0.75, 1.6>
translate -7*y
scale <20.5, 4.0, 20.5>
finish { Metal }
pigment { OldGold }
}
bounded_by {
object {
Disk_Y
translate -0.5*y // Remove for new Disk_Y definition
scale <34, 100, 34>
}
}
}
/* Stand for the vase */
object { Hexagon
rotate -90.0*z /* Stand it on end (vertical)*/
rotate -45*y /* Turn it to a pleasing angle */
scale <40, 25, 40>
translate -70*y
pigment {
Sapphire_Agate
quick_color Red
scale 10.0
}
finish {
ambient 0.2
diffuse 0.75
reflection 0.85
}
}
union {
plane { z, 50 rotate -45*y }
plane { z, 50 rotate +45*y }
pigment { DimGray }
finish {
ambient 0.2
diffuse 0.75
reflection 0.5
}
}