Parallel Virtual Machine

(1)

PVM 1

Parallel

Parallel Virtual Virtual Machine Machine

Roberto de Beauclair Seixas

[email protected]

(2)

PVM 2

Processamento Paralelo Processamento Paralelo

Método de computação utilizado na

resolução de grandes problemas, através da subdivisão de tarefas por vários

processadores.

– alta performance – baixo custo

– produtividade

(3)

PVM 3

Tipos de Processamento Paralelo Tipos de Processamento Paralelo

l Massively Parallel Processors (MPPs)

– dezenas a centenas (ou até milhares) de

processadores interligados como um único.

– centenas de Gigabytes de memória.

l Distributed Computing

– conjunto de computadores interligados via rede local de alta velocidade.

– arquiteturas heterogêneas.

(4)

PVM 4

Paradigmas Paradigmas

l Shared Memory

l Parallelizing Compilers

l Message Passing

– PVM

“Tornar um conjunto de computadores em uma

grande Máquina Paralela Virtual “

(5)

PVM 5

Formas de Heterogeneidade Formas de Heterogeneidade

l Arquitetura

l Formato dos dados

l Velocidade Computacional

l Carga da máquina

l Carga na rede local

(6)

PVM 6

Heterogeneidade Heterogeneidade

l Arquitetura

– 386/486 PCs (UNIX) – Workstations

» SGI4, SGI5, SUN4 e RS6K

– Processadores com memória partilhada – Computadores vetoriais

– MPPs

(7)

PVM 7

Heterogeneidade Heterogeneidade

l Formato dos dados

– Em computação distribuida isto é muito importante, pois dados mandados de um computador para outro tem que ser

entendidos.

– Sistemas especificamente projetados para

MPPs não podem ser usados em sistemas

distribuidos, pois não contém informações

necessárias.

(8)

PVM 8

Heterogeneidade Heterogeneidade

l Velocidade Computacional

– arquiteturas heterogêneas

» processadores mais rápidos não podem depender ou esperar processadores mais lentos.

l Carga da Máquina

– mesma arquitetura

» os processadores podem estar executando tarefas de outros usuários, alterando drásticamente a

velocidade de processamento.

(9)

PVM 9

Heterogeneidade Heterogeneidade

l Carga da Rede Local

Como o PVM usa o paradigma de message- passing, o que significa enviar, pela rede,

mensagens de um computador para outro. Isto

implica depender de todos os computadores

da rede local, inclusive os que não pertencem

a “máquina virtual”.

(10)

PVM 10

Computação

Computação Distribuida Distribuida

l

Baixo custo pois utiliza os computadores já existentes na rede;

l

A performance final pode ser melhorada pela alocação de tarefas específicas a computadores que executam melhor, ou mais rápido, aquela tarefa;

l

Os recursos da “máquina virtual” pode ser expandidos a qualquer momento, seguindo as novas tecnologias;

l

Os programas continuam sendo desenvolvidos nos seus próprios ambientes nativos, usado compiladores,

depuradores e editores das próprias máquinas;

l

Os computadores, isoladamente, são bastante estáveis.

(11)

PVM 11

Velocidade das Redes Locais Velocidade das Redes Locais

Ethernet

Token ring

FDDI

HiPPI

SONET ATM 1000

M b/s

800 100

10 1980 1985 1990 ...

(12)

PVM 12

Evolução Evolução

1989 - Oak Ridge National Laboratory

– PVM 1.0

1991 - University of Tennessee

– PVM 2.0 até 2.4

1993 - Completamente reescrito e distribuido gratuitamente para ser usado em

aplicações, não comerciais, paralelas e/ou distribuidas.

– PVM 3.0 (versão instalada: PVM 3.3.10)

(13)

PVM 13

PVM PVM

l PVM é um sistema que permite que uma rede de computadores heterogêneos

(UNIX) seja usada como um grande computador paralelo.

– fornece funções para, automaticamente,

disparar tarefas na máquina virtual e permite a comunicação e sincronização entre elas. Uma tarefa é definida como uma “unidade de

computação”, é análoga a um processo UNIX.

(14)

PVM 14

PVM PVM

l

Ambiente da máquina virtual é definido pelo usuário;

l

Acesso transparente ao hardware;

l

Computação baseada em tarefas (tasks);

– programas UNIX

l

Modelo explícito de message-passing;

– a decomposição é definida na aplicação

l

Suporte à heterogeneidade;

l

Suporte à multiprocessamento.

(15)

PVM 15

PVM PVM

l É composto de duas partes:

– daemon

– biblioteca (C, C++ e Fortran)

l Aplicação é um conjunto de tarefas

– Functional Parallelism

» input, initialization, solution, output and display.

– Data Parallelism

» uma única tarefa atuando em conjuntos diferentes

de dados.

(16)

PVM 16

PVM PVM

SPMD SPMD

computador 1 computador 2

entrada e

particionamento

exibição dos

resultados

(17)

PVM 17

PVM PVM

MPP

(18)

PVM 18

TIDs TIDs e e Groups Groups

l

Todas as tarefas PVM são identificadas por um número inteiro: task identifier - TID;

l

As mensagens são recebidas e enviadas pelos TIDs;

l

Os TIDs são únicos em toda a máquina virtual;

l

Pode-se agrupar e numerar tarefas;

l

Cada tarefa pode “entrar” e “sair” dos grupos

sem interferir nas outras tarefas.

(19)

PVM 19

Desenvolvendo uma Aplicação Desenvolvendo uma Aplicação

1. Criam-se programas sequenciais, contendo chamadas à biblioteca PVM.

– cada programa corresponde a uma tarefa da aplicação – os programa são compilados para cada arquitetura

disponível

2. A aplicação é executada por um dos programas, responsável pela execução dos demais, contendo tarefas de inicialização e particionamento.

– esta master task dispara e controla, via mensagens, as

slave tasks e, normalmente, coleta os resultados

(20)

PVM 20

Protocolo PVM Protocolo PVM

master

– dispara slave tasks

» parâmetros (argv)

– transmite perguntas

» aloca buffer

» empacota dados

» qualifica mensagem

» envia buffer

– recebe respostas

» recebe buffer

» desempacota dados

slave

– espera perguntas

» testa qualificador

» recebe buffer

» desempacota dados

– processa os dados – transmite respostas

» aloca buffer

» empacota dados

» qualifica mensagem

» envia buffer

(21)

PVM 21

Hello

Hello , PVM ! , PVM !

#include “pvm3.h”

void main () {

int nt, tid, msgtag = 1;

char buf[100];

printf (“Hello, world!\n”);

nt = pvm_spawn (“hello_cnt”, NULL, PvmTaskDefault, NULL, 1, &tid);

pvm_recv (tid, msgtag);

pvm_upkstr (buf);

printf (“%s da TID=%x\n”, buf, tid);

pvm_exit();

}

(22)

PVM 22

Hello

Hello , PVM ! , PVM !

#include “pvm3.h”

void main () {

int p_tid, msgtag = 1;

char buf[100] = “Hello, PVM! da “;

p_tid = pvm_parent ();

strcat (buf, getenv(“HOST”)); /* nome da máquina */

pvm_initsend (PvmDataDefault);

pvm_pkstr (buf);

pvm_send (p_tid, msgtag);

pvm_exit ();

}

(23)

PVM 23

Executando o PVM Executando o PVM

l

PVM usa duas variáveis de ambiente:

– PVM_ROOT ( ${HOME}/pvm3 )

– PVM_ARCH ( ${PVM_ROOT}/lib/cshrc.stub )

l

${PVM_ROOT}/lib/PVM_ARCH

– pvm e pvmd3

– libpvm3.a, libfpvm3.a e libgpvm3.a

l

${PVM_ROOT}/bin/PVM_ARCH

– pvmgs

– executáveis gerados pelo usuário

(24)

PVM 24

Executando o PVM Executando o PVM

% pvm ↵ dispara o console PVM

pvm> add hostname ↵ insere na VM

pvm> delete hostname ↵ retira da VM

pvm> conf ↵ lista as máquinas

pvm> t a ↵ lista as tasks

ativas

pvm> quit ↵ sai do console PVM

pvm> halt ↵ encerra o PVM

% pvm hostfile ↵ dispara & insere

(25)

PVM 25

Compilando a Aplicação Compilando a Aplicação

PVM_ARCH = SGI

PVMDIR = /usr/local/pvm

PVMLIB = $(PVMDIR)/lib/$(PVM_ARCH)/libpvm3.a \

$(PVMDIR)/lib/$(PVM_ARCH)/libgpvm3.a

BDIR = $(HOME)/pvm3/bin

XDIR = $(BDIR)/$(PVM_ARCH)

CC = gcc

CFLAGS= -g

INCS = -I$(PVMDIR)/include -I$(XABDIR)/include

LIBS = $(PVMLIB) -lm

(26)

PVM 26

Compilando a Aplicação Compilando a Aplicação

default: raycast main main: main.c

$(CC) $(CFLAGS) -o main main.c $(INCS) $(LIBS) cp main $(XDIR)

raycast: raycast.c

$(CC) $(CFLAGS) -o raycast raycast.c $(INCS) $(LIBS) cp raycast $(XDIR)

(27)

PVM 27

Tipos de Aplicações Tipos de Aplicações

l Crowd

– É uma coleção de processos (relacionando-se), tipicamente executando um mesmo código, realizando cálculos em partes diferentes do problema, normalmente envolvendo troca de resultados intermediários.

» Host-Node Model (Star Computational Model)

domain decompositions and number crunching algorithms

(28)

PVM 28

Tipos de Aplicações Tipos de Aplicações

l Tree

– Os processos são “disparados”,

dinâmicamente, de acordo com o decorrer da execução, estabelecendo uma hieraquia parent- child, em uma configuração de árvore.

» Node-Only Model (Tree Computational Model)

branch-and-bound, divide-and-conquer and recursive algorithms

(29)

PVM 29

Técnicas de Programação Técnicas de Programação

l

Fase 1: Crowd Model

– Inicialização do grupo de processos

l

Fase 1: Tree Model

– Disseminação das informações do grupo e dos parâmetros do problema e particionamento.

l

Fase 2

– Computação propriamente dita.

l

Fase 3

– Coleta dos resultados, exibição e encerramento do

grupo de processos.

(30)

PVM 30

Particionamento

Particionamento do Problema do Problema

l

Particionamento Estático (Static Data Decomposition)

– Assumindo-se que um problema de N elementos será executado em P processadores, determina-se um

particionamento de N/P elementos por processador.

l

Particionamento Dinâmico (Dynamic Data Decomposition) – O master subdivide o problema em de N elementos em

K partes e cada processador recebe N/K elementos. De acordo com a disponibilização dos processadores,

estes recebem mais N/K elementos até o término do

problema.

(31)

PVM 31

Exemplos Exemplos

l Crowd Model

– Mandelbrot algorithm

» sem comunicação entre clientes

– Cannon’s algorithm (multiplicação de matrizes)

» com comunicação entre clientes l Tree Model

– Split-Sort-Merge algorithm

(32)

PVM 32

Mandelbrot Mandelbrot

slave slave

slave slave master

mandelbrot

tasks

(33)

PVM 33

Mandelbrot

Mandelbrot : : master master

for (i = 0; i < NumWorkers; i++)

pvm_spawn (worker name); { start up worker i }

pvm_send (worker tid, 999); { send task to worker i } while (“work to do”)

pvm_recv (888); { receive results } pvm_send (available worker id, 999);

display_result ( );

for (i = 0; i < NumWorkers; i++)

pvm_recv (888); { receive results }

pvm_kill (worker tid i); { terminate worker i } display_result ( );

(34)

PVM 34

Mandelbrot

Mandelbrot : : slave slave

while (TRUE)

pvm_recv (999); { receive task}

result = Mandelbrot_Calculations (task); { compute result }

pvm_send (master tid, 888); { send result to master }

(35)

PVM 35

Matrix Multiplication Matrix Multiplication

C⁰⁰ C⁰¹ C⁰² C¹⁰ C¹¹ C¹² C²⁰ C²¹ C²² C⁰⁰ C⁰¹ C⁰² C¹⁰ C¹¹ C¹² C²⁰ C²¹ C²²

A⁰⁰

A¹¹ A²² A⁰⁰ A⁰⁰ A⁰⁰ A¹¹ A¹¹ A¹¹ A²² A²² A²²

A⁰¹

A¹² A²⁰

A⁰⁰ A⁰¹ A⁰² A¹⁰ A¹¹ A¹² A²⁰ A²¹ A²²

B⁰⁰ B⁰¹ B⁰² B¹⁰ B¹¹ B¹² B²⁰ B²¹ B²² B⁰⁰ B⁰¹ B⁰² B¹⁰ B¹¹ B¹² B²⁰ B²¹ B²²

B¹⁰ B¹¹ B¹² B²⁰ B²¹ B²² B⁰⁰ B⁰¹ B⁰² B⁰⁰ B⁰¹ B⁰² B¹⁰ B¹¹ B¹² B²⁰ B²¹ B²²

=

+

first pipe

second pipe first roll multiply A’ and B

(36)

PVM 36

Matrix Multiplication

Matrix Multiplication : SPMD : SPMD

{ Processor 0 starts up other processes } if (my processor number >= 0)

for (i = 1; i <= MeshDimension*MeshDimension; i++)

pvm_spawn (slave name, ...)

(37)

PVM 37

Matrix Multiplication

Matrix Multiplication : SPMD : SPMD

forall processors Pij, 0 <= i,j < MeshDimension for k = 0 to MeshDimension-1

{ pipe } if (myrow = (mycolumn+k) mod MeshDimension

{send A to all Pxy, x = myrow, y <> mycolumn } pvm_mcast ((Pxy, x = myrow, y <> mycolumn), 99) else

pvm_recv (999) { receive A } { multiply } Multiply (A, B, C)

{ roll } { send B to Pxy, x = myrow -1, y = mycolumn }

pvm_send ((Pxy, x = myrow -1, y = mycolumn), 888) pvm_recv (888) { receive B }

(38)

PVM 38

5 3 6 4 1 7 0 2 8 10 9 15 12 14 13 11 5 3 6 4 1 7 0 2 8 10 9 11 12 15 13 14 5 3 6 4 1 7 0 2 8 10 9 11 12 13 14 15 2 3 0 1 4 7 6 5

2 3 0 1 4 5 6 7

0 1 2 3

0 1 2 3 4 5 6 7

9 10 11

5 3 6 4 1 7 0 2 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

stage 1 stage 2 stage 3 stage 2

stage 3

stage 4

stage 4 stage 3

stage 5

2 0

1 3

1

0 Split-Sort-Merge Algorithm

time

(39)

PVM 39

Split

Split - - Sort Sort - - Merge Algorithm Merge Algorithm

{ Spawn and partition list based on a broadcast tree pattern. } for (i = 1; i <=N; i++) { such that 2^N = Num_Procs }

forall processors P such that P < 2^i

pvm_spawn (. . .) { process id P xor 2^i } if (P < 2^(i - 1))

midpt = PartitionList (list)

{ send list [0..midpt] to P xor 2^i } pvm_send ((P xor 2^i), 999)

list = list [midpt + 1 .. MAXSIZE]

else

pvm_recv(999)

(40)

PVM 40

Split

Split - - Sort Sort - - Merge Algorithm Merge Algorithm

{ Sort remaining list }

Quicksort (list [midpt + 1 .. MAXSIZE]) { Gather/Merge sorted sub-lists. }

for (i = N; i >=1; i--) { such that 2^N = Num_Procs } forall processors P such that P < 2^i

if (P > 2^(i - 1))

{ Send list to P xor 2^i }

pvm_send ((P xor 2^i), 888) else

pvm_recv (888)

merge templist into list

(41)

PVM 41

API do PVM (funções principais) API do PVM (funções principais)

l

Process Control

– int tid = pvm_mytid ( void ) – int info = pvm_exit ( void ) l

Information

– int tid = pvm_parent ( void ) l

Message Buffer

– int bufid = pvm_initsend (int encoding) l

Sending / Receiving Data

– int info = pvm_send (int tid, int msgtag)

– int info = pvm_mcast (int *tids, int ntask, int msgtag) – int budif = pvm_recv (int tid, int msgtag)

– int bufid = pvm_nrecv (int tid, int msgtag)

(42)

PVM 42

API do PVM (funções principais) API do PVM (funções principais)

l

Packing Data (pvm_pk...) / Unpacking Data (pvm_upk...)

– int info = pvm_pkbyte (char *cp, int nitem, int stride) – int info = pvm_pkint (int *ip, int nitem, int stride) – int info = pvm_pkfloat (float *fp. int nitem, int stride) – int info = pvm_pkdouble (double *dp, int nitem, int stride) – int info = pvm_pkstr (char *cp)

– int info = pvm_pkcplx (float *xp, int nitem, int stride) – int info = pvm_pkdcplx (double *zp, int nitem, int stride) – int info = pvm_pklong (long *lp, int nitem, int stride) – int info = pvm_pkshort (short *sp, int nitem, int stride)

(43)