INSTITUTO DE ESTUDOS SUPERIORES DA AMAZÔNIA

CURSO DE ENGENHARIA DA COMPUTAÇÃO

ROBSON KAWASAKI

IMAGENS FRACTAIS OBTIDAS POR PROCESSAMENTO PARALELO

USANDO UM CLUSTER BEOWULF

BELÉM
2005
 NSTITUTO DE ESTUDOS SUPERIORES DA AMAZÔNIA
CURSO DE ENGENHARIA DA COMPUTAÇÃO

ROBSON KAWASAKI

IMAGENS FRACTAIS OBTIDAS POR PROCESSAMENTO PARALELO

USANDO UM CLUSTER BEOWULF

Monografia de conclusão de Curso de

Graduação em Engenharia da Computação
apresentado ao Instituto de Estudos
Superiores da Amazônia, como requisito
parcial para obtenção do grau de
Engenheira da Computação sob orientação
do Prof. Dr. José Felipe de Almeida.

BELÉM
2005
 INSTITUTO DE ESTUDOS SUPERIORES DA AMAZÔNIA
CURSO DE ENGENHARIA DA COMPUTAÇÃO

ROBSON KAWASAKI

IMAGENS FRACTAIS OBTIDAS POR PROCESSAMENTO PARALELO

USANDO UM CLUSTER BEOWULF

Esta monografia foi julgada adequada para obtenção do título de Engenheira da Computação, e
aprovada na sua forma final pelo Instituto de Estudos Superiores da Amazônia.

Data: ___/___/___
Conceito: ________

_______________________________________
Prof. Dr. José Felipe de Almeida.
Orientador

_______________________________________
Prof. Dr. Alex Sandre Guedes Alves
Membro

_______________________________________
Prof. M.Sc. Elionai Gomes de Almeida Sobrinho
Suplente

BELÉM
2005
RESUMO

Neste trabalho é apresentado um estudo sobre imagens fractais usando um Cluster

Beowulf. Para isto, usou-se o sistema de PVM (Máquina Virtual Paralela). Dessa forma, o
trabalho trata da descrição de tópicos tais como: Geometria dos Fractais; paralelização de
tarefas usando a arquitetura de Cluster do tipo Beowulf e da otimização da geração de imagens
usando sistema distribuído.

Palavras-chave: Geometria dos Fractais, Cluster BEOWULF, Processamento paralelo, Sistema

distribuído, PVM.
ABSTRACT

In this work a study on fractals images is presented by Beowulf Cluster. For this, the
PVM (Parallel Virtual Machine) system is used. In order, the work deals to description such as:
Geometry of the Fractals; parallel processing in Beowulf Cluster and the images optimization
using a distributed system.

Keywords: Fractals geometry, Beowulf Cluster, Parallel processing, Distributed system, PVM.
 Este trabalho é dedicado à minha
esposa, meu pai, minha mãe, meus irmãos e
familiares.
AGRADECIMENTOS

Primeiramente agradeço de coração à

minha esposa por sempre ter me dado força,
ajuda e motivação durante minha graduação.
Agradeço também ao meu pai, minha mãe e
meus irmãos, que me ajudaram em todos os
sentidos da melhor forma possível. E para
finalizar, agradeço aos amigos que me
ajudaram no meu trabalho de conclusão:
Thiago Coqueiro, Otávio Chase e ao Dr. José
Felipe de Almeida, que por nenhum motivo
deixaria de citar seu nome, pois no momento
em que mais precisei, ele me ajudou e ainda
continua me ajudando. Agradecido
eternamente.
 LISTA DE FIGURAS

Figura 1 Modelo da geometria dos fractais visto na natureza...................................10

Figura 2 Cluster Beowulf “IESAM MASTER”...............................................................13

Figura 3 Conjunto de Mandelbrot.................................................................................16

Figura 4 Conjunto de Mandelbrot.................................................................................17

Figura 5 Conjunto de Mandelbrot.................................................................................18

Figura 6 Conjunto de Mandelbrot.................................................................................19

Figura 7 Conjunto de Mandelbrot referente à Figura 6...............................................20

 SUMÁRIO

Figura 1 Modelo da geometria dos fractais visto na

natureza...................................10.....................................................................................8
Figura 2 Cluster Beowulf “IESAM
MASTER”...............................................................13.......................................................8
Figura 3 Conjunto de
Mandelbrot.................................................................................16..................................8
Figura 4 Conjunto de
Mandelbrot.................................................................................17..................................8
Figura 5 Conjunto de
Mandelbrot.................................................................................18..................................8
Figura 6 Conjunto de
Mandelbrot.................................................................................19..................................8
Figura 7 Conjunto de Mandelbrot referente à Figura
6...............................................20......................................................................................8
1 INTRODUÇÃO................................................................................................................9
CAPÍTULO 2 – GEOMETRIA DOS FRACTAIS ..............................................................10
CAPITULO 3 – CLUSTER BEOWULF............................................................................12
3.1 MONTAGEM FÍSICA E FUNCIONAMENTO DO CLUSTER BEOWULF: “IESAM
MASTER”..................................................................................................................................12
CAPITULO 4 – PROGRAMAÇÃO PARALELA E PVM.................................................14
4.1 PROGRAMAÇÃO PARALELA.........................................................................................14
4.2 PVM......................................................................................................................................14
CAPITULO 5 – PROCESSO DE IMAGEM FRACTAL ...................................................16
6 CONSIDERAÇÕES FINAIS..........................................................................................21
REFERÊNCIAS................................................................................................................22
ANEXOS..........................................................................................................................23
1 INTRODUÇÃO

O processamento paralelo é um método de tecnologias da programação que

permite resolver problemas complexos dividindo-o em pequenas tarefas. A utilização
deste método na computação científica oferece recursos na diminuição do tempo de
processamento e a redução de acúmulo de memória. Um exemplo disso é o
processamento digital de imagens. Dessa forma, podem-se obter resultados em
aplicações complexas como no caso de imagens geradas a partir da geometria de
fractais.
O objetivo deste trabalho é apresentar um estudo sobre imagens geradas a partir
da geometria dos fractais utilizando processamento paralelo. Também é feita uma
abordagem sobre a arquitetura de cluster Beowulf tendo como sistema gerenciador de
rede a biblioteca PVM. Dessa forma, o trabalho trata da descrição de tópicos tais como:
Geometria dos Fractais; paralelização de tarefas usando a arquitetura de Cluster do tipo
Beowulf e da otimização da geração de imagens usando sistema distribuído.
 10

CAPÍTULO 2 – GEOMETRIA DOS FRACTAIS

Durante séculos, os objetos e os conceitos da geometria euclidiana foram

considerados como os que melhor descreviam o mundo em que vivemos. A descoberta
de geometrias não-euclidianas introduziu novos objetos que representam certos
fenômenos do Universo, tal como se passou com os fractais (MANDELBROT, 1977).
Assim, considera-se hoje que tais objetos retratam formas e fenômenos da Natureza.

A palavra fractal vem do latim fractus. O verbo em latim correspondente é

frangere, que significa quebrar, criar fragmentos irregulares. Além de significar quebrado
ou partido, fractus também significa irregular. Um estudo baseado em definições, modelos
e formas geométricas com essa idealização foi proposto e investigado por Benoît
Mandelbrot (MANDELBROT, 1977). Nesta teoria, fractais são formas geométricas
abstratas, com padrões complexos que se repetem infinitamente, mesmo limitados a uma
área finita. Em sua proposição, Mandelbrot constatou ainda que todas estas formas e
padrões possuíam algumas características comuns e que havia uma curiosa e
interessante relação entre estes objetos e aqueles encontrados na natureza (Figura 1).
Além de se apresentarem como formas geométricas, os fractais representam funções
reais ou complexas e apresentam determinadas características: auto-semelhança, a
dimensionalidade e a complexidade infinita. Com esta geometria, um fractal é gerado a
partir de uma fórmula matemática, muitas vezes simples, mas que aplicada de forma
iterativa, produz resultados em diversas aplicações.

Figura 1 - Modelo da geometria dos fractais encontrado na natureza.

Fonte: (TEORIA dos fractais, 2005).
 11

Os fractais deram origem a um novo ramo da matemática, muitas vezes designado

como a geometria da natureza (MANDELBROT, 1982). As formas complexas e caóticas
dos fractais descrevem alguns fenômenos naturais, como os sismos, a estrutura da casca
de árvores, a forma de algumas raízes, a linha de costa marítima, as nuvens, entre outros.
Este novo tipo de geometria aplica-se na astronomia, na meteorologia, na economia e na
complexidade da teoria de antenas, por exemplo, (GIANVITTORIO, 2002).
 12

CAPITULO 3 – CLUSTER BEOWULF

O Beowulf (STERLING, 1995) é um cluster de alto desempenho, que foi iniciado

pela NASA em 1994, no Goddard Space Flight Center. Como relato histórico, tem-se que
este centro de pesquisa precisava de um supercomputador que processasse dados na
ordem de Gigaflops (bilhões de operações por pontos flutuantes por segundo). Esta
necessidade surgiu devido ao tratamento de informações conseguidas por satélites.
Porém o custo desse supercomputador (multiprocessado) era em torno de um milhão de
dólares, o que era considerado um custo muito alto para ser usado somente por um grupo
de pesquisadores, na época dois pesquisadores Thomas Sterling e Donald Becker. Em
função disso, decidiram construir um sistema que pudesse processar dados de maneira
semelhante a um supercomputador multiprocessado, mas com um custo financeiro
extremamente baixo. Assim resolveram interligar computadores pessoais (Intel 486) entre
si, utilizando uma rede do tipo Ethernet e usando o sistema operacional Linux. A partir
desse agrupamento de computadores, foi criado então um cluster denominado de
Beowulf.

3.1 MONTAGEM FÍSICA E FUNCIONAMENTO DO CLUSTER BEOWULF: “IESAM

MASTER”

O Cluster utilizado, neste trabalho, foi montado no laboratório de Automação e

Controle no IESAM (Instituto de Estudos Superiores da Amazônia). Esse modelo de
arquitetura física de Cluster Beowulf foi denominado IESAM MASTER. O modelo do
Cluster IESAM MASTER é composto de um computador controlador, o qual tem a função
de servidor, e seis nós ligados ao servidor, onde todos possuem a mesma configuração
de máquina e são interconectados em rede, isto é feito através de um switch com
velocidade de 100 Mbits/seg. A Figura 2 ilustra o tipo de arquitetura do IESAM MASTER.
A função do servidor ou controlador é repartir uma tarefa complexa em partes
proporcionais e relativas ao número de nós presentes. Isto é feito para que possam
distribuir cada tarefa a cada nó correspondente. Desse modo, esses nós podem
processar sua parte de maneira sincronizada e simultânea. Em seguida, o resultado do
processamento de todos os nós, é entregue para o computador mestre (servidor) o qual
reunirá esses dados (resultados), transformando-os em informações que serão exibidas
para o usuário.
 13

Figura 2 - Cluster Beowulf “IESAM MASTER”.

Fonte: (arquivo do autor, 2005).
 14

CAPITULO 4 – PROGRAMAÇÃO PARALELA E PVM

4.1 PROGRAMAÇÃO PARALELA

A Programação Paralela tem como objetivo transformar grandes algoritmos
complexos em pequenas tarefas que possam ser executadas simultaneamente por vários
processadores, reduzindo assim o tempo de processamento (Wall Time Clock). Na
programação paralela, os processos não são realizados de forma sequencial. Muito pelo
contrário, como o próprio nome sugere, ele é executado paralelamente. A paralelização
dos códigos é uma técnica muito comum para escalonar tais processos. Ela consiste em
transformar um programa sequencial em paralelo para que partes do código possam ser
executadas independentemente. Mas leva-se um grande tempo para analisar o código a
ser paralelizado, recodificar a aplicação, depurar e encontrar a melhor solução para a
resolução do problema. Faz-se necessário, em alguns casos, mudar o próprio algoritmo
para que a paralelização do código seja bem sucedida.

4.2 PVM

O Sistema PVM foi especialmente desenhado para interligar recursos

computacionais em rede. Isso fornece ao usuário uma plataforma paralela para
desenvolver aplicações. Esta configuração de rede independentemente da localização, da
quantidade ou das diferenças entre os computadores interligados. No PVM, a
programação é feita de tal forma que se pode usar um conjunto heterogêneo de
computadores, de um modo uniforme como se tratasse de um único computador paralelo.
Dessa forma, esse sistema é instalado para criar uma máquina paralela virtual cuja
finalidade é inspecionar a execução de um processo, manipulado pelo usuário, o qual
contém uma aplicação PVM. Isto é feito, por uma biblioteca de rotinas. A biblioteca PVM
contém rotinas que devem ser acessadas pelo usuário para codificação, envio e
recebimento de mensagem. Também, a criação e eliminação de processos, sincronização
de tarefas e modificações de máquina virtual. Dessa forma, todas as aplicações devem
corresponder a essa biblioteca para que o ambiente paralelo criado pelo PVM seja
utilizado.

O Cluster PVM adquire as características SSI (Single System Image) onde todos
os nós do cluster se tornam uma única máquina virtual. Para que haja a comunicação
entre os nós, em cada um haverá um processo chamado pvmd3 que efetua a troca de
 15

mensagens entre os nós. O diretório em comum e especifico entre as máquinas da rede

no cluster IESAM MASTER é “/usr/share/pvm3/bin/LINUXI386”. No servidor do cluster
deve estar o programa mestre e escravo, e nos nós escravos devem estar residentes os
programas escravos.
 16

CAPITULO 5 – PROCESSO DE IMAGEM FRACTAL

Neste trabalho foi feita a execução de um código fonte para gerar uma imagem de
geometria de Fractais em ambiente PVM. Como exemplo, usou-se o conjunto de
Mandelbrot mostrado na Figura 3.

Figura 3 – Conjunto de Mandelbrot.

Fonte: (TEORIA dos fractais, 2005).

O algoritmo para geração dessa imagem foi implementado em Linguagem C e

executado a partir de um arquivo PVM. Dessa forma, a seqüência a ser algoritmizada é
descrita por: o conjunto de Mandelbrot é obtido por um processo iterativo de números
complexos do tipo a + jb. Esse processo é feito repetidamente e se obtém uma seqüência
de números Zn. O módulo |Zn| é a distância ao centro zero do plano complexo. Esta
distância pode se manter finita ou tender para infinito. Esta fronteira irá delimitar a imagem
a ser criada. Assim, o processo iterativo é dado por:

Zn + 1 = Zn + w

Na qual w é um número complexo constante.

A partir da observação do comportamento de Zn +1, ou seja, do seu módulo |
Zn+1|, temos as seguintes possibilidades:
|Zn| se mantém sempre finito - Atribui-se uma cor preta a z.
 17

|Zn| tende para infinito - Atribuem-se diferentes cores à z, dependendo do

comportamento de |Zn|. A classificação é definida por quem desenha o fractal. Um ponto
é marcado neste fractal não quando satisfaz a equação, mas sim segundo certo tipo de
comportamento. Um dos comportamentos possíveis pode ser um estado estacionário;
outro pode ser a convergência para uma repetição periódica de estados; ou ainda pode
ser uma corrida descontrolada para o infinito. As imagens mostradas nas Figuras 4, 5, 6 e
7, visualizam vários processos gerados ao conjunto de Mandelbrot.

Figura 4 – Conjunto de Mandelbrot.

Fonte: Cluster Beowulf “IESAM MASTER”, 2005.
 18

Figura 5 – Conjunto de Mandelbrot.

Fonte: Cluster Beowulf “IESAM MASTER”, 2005.
 19

Figura 6 – Conjunto de Mandelbrot.

Fonte: Cluster Beowulf “IESAM MASTER”, 2005.
 20

Figura 7 – Conjunto de Mandelbrot referente à Figura 6.

Fonte: Cluster Beowulf “IESAM MASTER”, 2005.
 21

6 CONSIDERAÇÕES FINAIS

Este tratou sobre a geração de imagens geométricas de fractais. Usou-se um

cluster de computadores ligados em rede utilizando a arquitetura Beowulf. O sistema
gerenciador usado foi à biblioteca PVM. No caso, usou-se como exemplo dessa aplicação
o conjunto de Mandelbrot. A contribuição desse trabalho pode ser reforçada para o caso
de aplicações referentes à engenharia, por exemplo. Com essa descrição, o processo
dessa geometria pode estar associado à teoria de antena ou até mesmo a sistemas de
aterramento para o controle de suas características. Dessa forma, este trabalho é o início
de um desenvolvimento no que se refere à computação aplicada com a utilização de
processamento paralelo.
 22

REFERÊNCIAS

GIANVITTORIO, J. P.; RAHMAT-SAMII, Y. Fractal Antenna: a Novel Antenna

miniaturization technique and application. IEEE Ant. and Propagation, v. 44, n.1, Feb
2002.N.J.

MANDELBROT, B. Fractais: Forma, Hipóteses e Dimensão. Ed. Gradiva, 1977.

MANDELBROT, B. A Geometria Fractal da Natureza. Ed. Gradiva, 1982.

PITANGA, M. Construindo Supercomputadores com Linux. Rio de Janeiro: 2 ed.

Brasport, 2004.

STERLING, T. et. al. Beowulf: A Parallel Workstation for Scientitific Computation,

January, 1995. Disponível em:
<http://beowulf.es.embnet.org/papers/ICPP95/icpp95.html>. Acesso em: 16 de out. 2005.
 23

ANEXOS
 Código em C para Geometria dos Fractais usando processamento paralelo na
plataforma PVM/LINUX:

Programa Mestre:

* Mandelbrot Program with PVM

* and zooming capability
* MASTER PROGRAM
*/
#include <stdlib.h>
#include <iostream.h>
#include "glaux.h" //For auxiliary functions.
#include "gltk.h" //For mouse functions.
#include "/usr/pvm3/include/pvm3.h"
const int PIXELS = 600; //Holds the size of the window
const int NPROCESS = 20; //Holds the number of PVM slaves
int NumberDone[NPROCESS]; //A record of the progress of each slave
float X1,Y1, X2,Y2; //Define the viewing rectangle
/* A palette of colors */
float palette[17][3] = {{0.1,0.2,0.3}, {0.5,0.2,0.7}, {0.3,0.8,0.1}, {0.9,0.3,0.5},
{0.8,0.6,0.5}, {0.1,0.7,0.4}, {0.5,0.8,0.3}, {0.7,0.4,0.8},
{0.1,0.2,0.3}, {0.5,0.2,0.7}, {0.3,0.8,0.1}, {0.9,0.3,0.5},
{0.8,0.6,0.5}, {0.1,0.7,0.4}, {0.5,0.8,0.3}, {0.7,0.4,0.8},
{1.0,1.0,1.0} };
static void SetArray(float yarray[]) {
/* Initializes the arrays */
int i;
//Divides the window into areas for each slave
for (i=0;i<NPROCESS+1;i++) {
yarray[i] = Y1 + ((float)i/NPROCESS)*(Y2-Y1);
}

//Clears the progress record

 for (i=0;i<NPROCESS;i++)
{ NumberDone[i] = 0; }
}
static void DrawRow(int data[], int who) {
/* Draws one row using data from a slave program */
int ypos,i;
//Get the y position of the row
ypos = who*(PIXELS/NPROCESS) + NumberDone[who];
//Draw the points
for (i=0;i<PIXELS;i++) {
glColor3fv(palette[data[i]]);
glBegin(GL_POINTS);
glVertex2i(i,ypos);
glEnd();
}
glFlush();
//Increment the progress record
NumberDone[who] += 1;
}
static void DrawStuff() {
/* Broadcasts window data to PVM slaves,
Receives the appropriate colors back
And draws the Mandelbrot set */
int mytid,who,i,nhost,narch,msgtype,numt,nproc,
tids[NPROCESS], data[PIXELS];
float yarray[NPROCESS+1];
struct pvmhostinfo *hostp[NPROCESS];
mytid = pvm_mytid();
//Request NPROCESS slaves
if ( pvm_parent() != PvmNoParent) {
pvm_config( &nhost, &narch, hostp );
nproc = nhost;
if (nproc > NPROCESS) nproc = NPROCESS;
}
 //If problems, quit the program
numt = pvm_spawn("mandslave", (char**)0,0,"",NPROCESS,tids);
if (numt < NPROCESS) {
cout << "MandMaster: PVM error\n";
for (i=0; i<numt; i++) {
pvm_kill(tids[i]);
}
pvm_exit();
exit(0);
}
SetArray(yarray);
/*Start PVM stuff*/
pvm_initsend(PvmDataDefault);
pvm_pkint(tids,NPROCESS,1); //Send task ID's
pvm_pkfloat(&X1,1,1);
pvm_pkfloat(&X2,1,1); //Send the x positions
pvm_pkfloat(yarray,NPROCESS+1,1); //Send the y positions
pvm_mcast(tids, NPROCESS, 0);
msgtype=5;
for (i=0;i<PIXELS;i++) { //Get an array of
pvm_recv( -1, msgtype); //color values back,
pvm_upkint( &who, 1, 1);
pvm_upkint(data, PIXELS, 1);
DrawRow(data,who); //Draw them on screen.
}
pvm_exit();
}
static void SmallZoom(int x,int y) {
/* Zooms in on a relatively small area of the viewing window. */
int zm = PIXELS/60; //The size of the zoom
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2i(x-zm,(PIXELS-y)-zm); //Draw a red rectangle to indicate
glVertex2i(x-zm,(PIXELS-y)+zm); //where zooming is taking place
 glVertex2i(x+zm,(PIXELS-y)+zm);
glVertex2i(x+zm,(PIXELS-y)-zm);
glEnd;
double Xsave,Xavg,Ysave,Yavg;
Xsave = X1;
Xavg = (X2 - X1);
Ysave = Y1;
Yavg = (Y2 - Y1);
X1 = Xsave+(x-zm)*((Xavg)/PIXELS); //Set new viewing rectangle
X2 = Xsave+(x+zm)*((Xavg)/PIXELS); //By converting from pixel
Y1 = Ysave+((PIXELS-y)-zm)*((Yavg)/PIXELS); //coords to real coords.
Y2 = Ysave+((PIXELS-y)+zm)*((Yavg)/PIXELS);
}
static void LargeZoom(int x,int y) {
/* Zooms in on a relatively large area of the viewing window. */
int zm = PIXELS/12; //Size of the zoom
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2i(x-zm,(PIXELS-y)-zm); //Draw a red rectangle to indicate
glVertex2i(x-zm,(PIXELS-y)+zm); //where zooming is taking place
glVertex2i(x+zm,(PIXELS-y)+zm);
glVertex2i(x+zm,(PIXELS-y)-zm);
glEnd;
double Xsave,Xavg,Ysave,Yavg;
Xsave = X1;
Xavg = (X2 - X1);
Ysave = Y1;
Yavg = (Y2 - Y1);
X1 = Xsave+(x-zm)*((Xavg)/PIXELS); //Set new viewing rectangle
X2 = Xsave+(x+zm)*((Xavg)/PIXELS); //by converting from pixel
Y1 = Ysave+((PIXELS-y)-zm)*((Yavg)/PIXELS); //coords to real coords
Y2 = Ysave+((PIXELS-y)+zm)*((Yavg)/PIXELS);
}
static GLenum MousePressed(int x,int y, GLenum button) {
/* This procedure manages the mouse calls */
if (button & TK_LEFTBUTTON)
{ SmallZoom(x,y); } //Left button activates a small zoom.
if (button & TK_RIGHTBUTTON)
{ LargeZoom(x,y); } //Right button activates a large zoom.
return GL_TRUE; //The mouse toolkit wants a boolean return.
}
static void Restore(...) {
/* Resets the viewing window to its initial values */
/* Used to zoom back out once you have zoomed in. */

X1 = -2; //These coordinates are a good window

X2 = 0.6; //for the Mandelbrot set.
Y1 = -1.5;
Y2 = 1.5;
}
static void Init() {
/* Sets initial viewing window, and clears the screen */
X1 = -2;
Y1 = -1.5;
X2 = 0.6;
Y2 = 1.5;
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
}
static void DisplayStuff(...) {
/* Calls the drawing function, then displays the result to the screen. */
DrawStuff();
glFlush();
auxSwapBuffers();
}
static void Reshape(int w, int h) {
/* Mystical Magical stuff */
glViewport(0,0,(GLint)w,(GLint)h);
 glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,PIXELS,0,PIXELS,-1,1);
glMatrixMode(GL_MODELVIEW);
}
int main(int argc, char **argv) {
/* Window Initialization and Main Loop */
auxInitDisplayMode(AUX_RGBA);
auxInitPosition(100,50,PIXELS,PIXELS);
if (auxInitWindow("Mandelbrot Set") == GL_FALSE)
{ auxQuit(); }
Init();
auxExposeFunc(Reshape);
auxReshapeFunc(Reshape);
auxKeyFunc(AUX_r,Restore);
tkMouseDownFunc(MousePressed);
auxMainLoop(DisplayStuff);
}
Programa Escravo:

* Mandelbrot Program with PVM

* and zooming capability
* SLAVE PROGRAM
*/
#include <stdlib.h>
#include "/usr/pvm3/include/pvm3.h" //PVM header file
const int PIXELS=600; //Holds the size of the window
const int NPROCESS=20; //Holds the number of PVM slaves
static float X1,X2,Y1,Y2; //Define the viewing rectangle
static void SetWindow(int me, float yarray[]) {
/* Sets the upper and lower Y coords of
the particular window handled by the slave */
Y1 = yarray[me];
Y2 = yarray[me+1];
}
static float ConvertX(int x) {
/* Converts from pixel coordinates to real coordinates */
return X1 + ((float)x/PIXELS)*(X2-X1);
}
static float ConvertY(int y) {
/* Converts from pixel coordinates to real coordinates */
return Y1 + ((float)y/(PIXELS/NPROCESS))*(Y2-Y1);
}
static void CalculateRow(int ypos, int data[] ) {
/* The mandelbrot algorithm.
Color values are saved in an array. */
float j,x1,y1,x,y,r,b;
int n,i;
j = ConvertY(ypos);
for (i = 0; i<PIXELS; i++) {
b = ConvertX(i);
x = b;
y = j;
 n = 0;
r = 0;
while (n<64 && r<4) {
x1 = x*x - y*y + b;
y1 = 2*x*y + j;
r = x1*x1 + y1*y1;
x = x1;
y = y1;
n++;
}
//If the point escaped, save white
//Else save an indexed color value
if (r < 4)
{ data[i] = 16; }
else
{ data[i] = n/4;}
}
}
int main() {
/* Sets up PVM, receives window data,
Calculates color values for the mandelbrot
set within a specific window, and returns the data. */
int mytid,n,me,i,master,msgtype,
tids[NPROCESS],data[PIXELS];
float yarray[NPROCESS+1];
mytid = pvm_mytid();
//Receive data
msgtype = 0;
pvm_recv(-1,msgtype);
pvm_upkint(tids,NPROCESS,1); // Task ID's
pvm_upkfloat(&X1,1,1);
pvm_upkfloat(&X2,1,1); // X coordinates
pvm_upkfloat(yarray,NPROCESS+1,1); // Y coordinates
for (i=0;i<NPROCESS;i++)
 if (mytid == tids[i]) { // get my number
me = i; // (0..NPROCESS-1)
break;
}
SetWindow(me,yarray); // Set up the window
msgtype = 5;
master = pvm_parent();
for (i=0;i<PIXELS/NPROCESS;i++) { //Send back arrays of data
CalculateRow(i,data); //containing color index values
pvm_initsend(PvmDataDefault);
pvm_pkint(&me,1,1); //also send my process number
pvm_pkint(data,PIXELS,1);
pvm_send(master,msgtype);
}
pvm_exit();
}