Dissertacao - Palestra - Algoritmos para simulador de arquiteturas paralelas

UEM - Universidade Estadual de Maringá
DIN - Departamento de Informática
Mestrado em Ciência da Computação

Desenvolvimento de Algoritmos Paralelos para Simulador
de Multiprocessadores Superescalares

Mestrando: Luiz Arthur Feitosa dos Santos

Orientador: Prof. Dr. João Angelo Martini

Desenvolvimento de Algoritmos Paralelos para
Simulador de Multiprocessadores Superescalares

ESTRUTURA DO TRABALHO

COMPUTAÇÃO PARALELA

SIMULADOR DE ARQUITETURAS

PROGRAMAÇÃO PARALELA E ALGORITMOS PARALELOS

AVALIAÇÃO DE DESEMPENHO

ALGORITMOS PARALELOS PARA O SMS

TRABALHOS FUTUROS

CONCLUSÃO

Mestrando: Luiz Arthur Feitosa dos Santos 2

COMPUTAÇÃO PARALELA
PROCESSAMENTO SEQÜENCIAL

Memória
Dispositivo
de entrada
Unidade
Aritmética MÁQUINA DE VON NEUMANN
lógica Dispositivo (TANEMBAUM 2001)
Unidade de de saída
controle

Acumulador
(a)

ARQUITETURAS PARALELAS COM MEMÓRIA COMPARTILHADA E DISTRIBUÍDA
Processador 1
Cache
Processador 1 Memória
Memória

Rede de Interconexão
Cache
Barramento

Processador 2
Processador 2 Disp.
Cache Entrada/S Cache
aída
Memória
Disp.
Processador N Entrada/
Processador N
Cache Saída
Cache

(b) Memória

(c)

Simuladores de arquiteturas:

MINT (MIPS Interpreter) (VEENSTRA, 1993) utiliza threads para simular um ambiente
multiprocessador, conta com sistema de interconexão e hierarquia de memória. O MINT roda
executáveis compilados para plataformas MIPS (R3000).

RSIM (Rice Simulator) (PAI, 1997) implementa um modelo de processador detalhado para
arquitetura superescalar. Simula um sistema multiprocessador de memória compartilhada. O RSIM
roda nas plataformas SPARC e Solaris.

ABSS (SPARC Simulator) (SUNADA, 1998) empregado principalmente nas simulações de
memória. O ABSS usa threads para simular multiprocessadores. Ele roda apenas nas plataformas
SPARC e possui interface gráfica derivada do MINT.

Proteus (BREWER, 1991) permite a simulação de multiprocessadores com interconexões do tipo:
bus, k-ary, n-cube e butterfly. Possui biblioteca para passagem de mensagens, gerenciamento de
memória e threads, além de coleta de dados e interface gráfica sofisticada para representar as saídas
da simulação.



Augmint (NGUYEN, 1996) usa threads para simular um sistema multiprocessador com espaço de
memória compartilhada e privada (para determinadas variáveis). Ele roda aplicações escritas em C e
C++ com macros-m4. Ele roda em arquiteturas Intel x86.

Tango Lite (HERROD, 1993) simula um ambiente multiprocessador com memória compartilhada.
Ao contrário do seu predecessor o Tango, o Tango Lite usa threads ao invés de Unix Process. O
Tango Lite roda em plataforma MIPS (R3000).

MulSim (MATLOFF, 2005) é um simulador para ambiente multiprocessador com memória
compartilhada, dispondo de vários tipos de interconexão entre memória e processador.

Multiprocessor Enhancements of the SimpleScalar Tool Set (MANJIKIAN, 2001). Simulador
funcional (não detalhado) e simulador de cache baseados na ferramenta SimpleScalar, usam threads
para simular um ambiente multiprocessador. Conta com suporte à visualização gráfica do conteúdo
da cache.

SMINT ou Superescalar MINT (LU, 1998) é um simulador de multiprocessadores superescalares
baseado no simulador MINT.



SIMPLESCALAR
O SimpleScalar foi desenvolvido em 1992 na Universidade de Wisconsin sob
coordenação de Gurindar S. Sohi e pode emular diversos conjuntos de instruções
como por exemplo: ARM, Alpha, PowerPC e x86, e devido à sua arquitetura
aberta ele pode ser estendido a outros conjuntos de instruções.

SMS (SIMULADOR DE MULTIPROCESSADORES SUPERESCALAR)
O SMS tem como base o núcleo do simulador SimpleScalar. Atualmente a
ferramenta dispõe de memória distribuída, primitivas de comunicação (Send e
Receive) para troca de mensagens e uso de uma rede de interconexão com
topologia de barramento compartilhado e viabiliza o desenvolvimento de
aplicações e análise de desempenho de computadores paralelos.


Interface
Gráfica Interface para passagem de parâmetros da simulação
Interface
Simulador Disparador e Coletor

Programas Programa Programa Programa ... Programa
do Usuário 1 2 3 N

Simulador Bibliotecas – Send e Receive Gerenciador de Memória
Paralelo
Protocolo

Topologia

Processador Processador Processador ... Processador
1 2 3 N


PROGRAMAÇÃO PARALELA E ALGORITMOS PARALELOS

Um algoritmo paralelo pode ser definido como um conjunto de processos (partes de um programa)
que podem ser executados simultaneamente, tais processos podem se comunicar uns com os outros
a fim de resolver um determinado problema. Já um algoritmo seqüencial é executado passo a passo
de forma seqüencial como foi definido durante a sua programação (ZARGHAN, 1995).

A construção de um algoritmo paralelo segue basicamente os seguintes passos:

•Identificar pontos do programa que podem ser executados de forma paralela;
•Distribuir as entradas e saídas de dados pertinentes à aplicação, bem como os dados intermediários
gerados durante a execução das tarefas e que estão associados ao programa;
•Gerenciar da melhor forma possível o acesso aos dados compartilhados pelos processadores, para
execução de um dado problema, reduzindo a comunicação entre processos;
•Sincronizar eficientemente os processadores nos mais diversos estágios de execução de um
programa paralelo, de forma que os processadores não fiquem com uma carga de trabalho muito
elevada ou muito baixa.


AVALIAÇÃO DE DESEMPENHO

Historicamente o tempo de execução ou o tempo decorrido (elapsed time) é uma das métricas mais
populares para verificar a performance em um dado sistema.

O speedup é a referência de quão melhor é um sistema paralelo em relação ao sistema seqüencial
ou outro sistema podendo ser até mesmo outro paralelo.

TempoExecuçãoSeqüencial TempoExecuçãoParalelo1
Aceleração = Aceleração =
TempoExecuçãoParalelo TempoExecuçãoParalelo N

Speedup Absoluto Speedup Relativo

Eficiência é uma medida da fração de tempo na qual um processador é realmente usado. A
eficiência é considerada uma métrica que investiga a escalabilidade dos algoritmos. Tal métrica é
obtida pela fórmula E = S/p, sendo S o speedup e p o número de processadores.


ALGORITMO PARALELO DE MULTIPLICAÇÃO DE MATRIZES
Mestre Escravos
01. #include </usr/sms/com.h> 01. struct _matriz matriz;
02. struct _matriz matriz; 02. struct _vetor vetor;
03. struct _vetor vetor; 03. void main(void){
04. void main(void) { 04. openchanel();
06. openchanel(); 05. /*recebe matriz B para suas colunas serem multiplicadas
07. sendbc(((char *)&matriz),sizeof(_matriz)); 06. recv_be(((char *)&matriz),sizeof(_matriz));
08. recv_be(((char *)&matriz),sizeof(_matriz)); 07. for (;;){
09. for (i=0;i<N;++i){ 08. for(i=0;i<N;++i){
10. for (t=0;t<N; ++t){vetor.X[t]=A[i][t];} 09. vtaux[i]=0;}
11. vetor.linha=i; 10. recv_be(((char *)&vetor), sizeof(_vetor));
12. send(((char *)&vetor), sizeof(_vetor),p); 11. /* realiza a multiplicacao */
13. if (p==P) p=1;else p++; 12. for (t=0;t<N;++t){
14. } 13. for (i=0;i<N;++i){
15. /*recebe e monta vetores nas matrizes*/ 14. vtaux[t]=vtaux[t]+(vetor.X[i]*matriz.B[i][t]);}
16. for (i=0;i<N;++i){ 15. }
17. recv_be(((char *)&vetor), sizeof(_vetor)); 16. /*atribui os calculos ao vetor para devolver ao mestre*/
18. for (t=0;t<N;++t) { 17. for (t=0;t<N;++t){vetor.X[t]=vtaux[t];}
19. C[vetor.linha][t]=vetor.X[t]; 18. /*Envia vetor calculado ao mestre*/
20. } 19. send(((char *)&vetor), sizeof(_vetor),0);


# total simulation time in seconds
sim_elapsed_time 53410

# total number of instructions executed
sim_total_insn_00 23773083318
sim_total_insn_01 12126038543

# total simulation time in cycles
sim_cycle 11878967426

# total number of ocupance cycles
inet_ocupance_cycles_00 2560800
inet_ocupance_cycles_01 320400

# total number of bytes received
inet_received_bytes_00 5123200
inet_received_bytes_01 3841600

# total number of bytes sended
inet_sended_bytes_00 10243200
inet_sended_bytes_01 1281600

Saída reduzida de uma simulação no SMS


Multiplicação de Matrizes 50x50 Multiplicação de Matrizes 100x100

16 160
14 140

Tempo em segundos
Tempo em segundos

1 1
12 120
2 2
10 100
4 4
8 80
8 8
6 60
16 16
4 40
32 32
2 20
0 0
Processadores Processadores

Multiplicação de Matrizes 600x600 Multiplicação de Matrizes 800x800

40000 90000
35000 80000
Tempo em segundos

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

Tempo de execução do algoritmo de multiplicação de matrizes

Multiplicação de Matrizes
Speedup apresentado
30
pelo algoritmo
25
paralelo de 50x50
20
multiplicação de Speedup 100x100
15
matrizes 600x600
10
800x800
5
0
1 2 4 8 16 32
Processadores

Multiplicação de Matrizes

1,8
1,6
1,4
50x50 Eficiência apresentada
1,2
Eficiência

1 100x100 pelo algoritmo paralelo
0,8 600x600 de multiplicação de
0,6
800x800
0,4 matrizes
0,2
0
1 2 4 8 16 32
Processadores


ALGORITMO PARALELO PARA CÁLCULO DO π

O π é um número irracional expresso por uma dízima infinita não periódica. A busca incansável por
esse número surgiu devido ao fato dele estar ligado a dois problemas fundamentais do universo
matemático.

Existem diversas maneiras de se calcular o π, tais como: série de Fourier, Mclaurin, Taylor e via
integração. O método utilizado para a construção do algoritmo aqui proposto será o de integração
1
4
π =∫
0
1+ x2

Entrada: Nº iterações N, Total de Entrada: Número do processador NP.
processadores TP. Saída: Valor parcial de
Saída: Valor global de pi_global recv_be(N,TP)
send_bc(N,TP) w = 1.0/n
for (x=1; x<=TP; x++) for (i=NP; i<=N; i=i+TP)
recv_be(pi) x = w * (i – 0,5)
pi_global=pi_global+pi pi = pi + (4.0 / (1.0 + (x * x)))
mostra (pi_global) pi = pi * w
send(pi)
Mestre Escravo


Cálculo do pi (n=10.000) Cálculo do pi (n=20.000)

70 140
60 120
Tempo em segundos

Tempo em segundos
1 1
50 2 100 2
40 4 80 4
30 8 60 8

20 16 40 16
32 32
10 20
0 0

Cálculo do pi (n=100.000) Cálculo do pi (n=1.000.000)

700 8000
600 7000
Tempo em segundos

Tempo em segundos
1 1
500 6000
2 2
5000
400 4 4
4000
300 8 8
3000
200 16 16
2000
32 32
100 1000
0 0

Tempo de execução do algoritmo do cálculo do π

Cálculo do pi

16
14
12
10.000
Speedup 10
20.000
8
100.000
6
4 1.000.000
2
0
1 2 4 8 16 32
Processadores

Cálculo do pi

1,2
1
0,8 10.000
Eficiência

20.000
0,6
100.000
0,4 1.000.000
0,2

0
1 2 4 8 16 32
Processadores


ALGORITMO TRAPEZOIDAL RULE

Para demonstrar a semelhança entre a biblioteca SMS de passagem de mensagem e o MPI, foi
desenvolvido o algoritmo Trapezoidal Rule. Sendo que tal algoritmo determina a integral de um
ponto a para b em uma função não negativa f(x) através da área restrita por um eixo x.

y y

f(x) f(x)
b
∫
a
f ( x)dx

a b x
(a) (b)

Uma forma de se estimar a área ou integral é dividir a região em figuras geométricas, neste caso
em trapézios, sendo que cada trapézio é a base do eixo x, e em seu ápice existem dois pontos que
juntam a figura.


02. #include </usr/sms/com.h>
03. struct _rank { // estrutura que informa passar o número do processador
2. #include "mpi.h"
05. int meu; } _rank;
3. double Trap(double local_a, double local_b, int local_n, double h);
07. struct _integral
4. double f(double x);
08. { double num; /* intervalo integral - local */ } _integral;
5. int main(int argc, char** argv) {
13. double Trap(double local_a, double local_b, int local_n, double h);
…
14. double f(double x);
20. MPI_Status status;
15. int main(int argc, char** argv) {
21. MPI_Init(&argc, &argv);
30. openchanel(); /*sincroniza os processos mestre e escravo*/
22. MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
31. p=2; //numero do processador
23. MPI_Comm_size(MPI_COMM_WORLD, &p);
32. for (i=0; i<p; i++)
24. h = (b-a)/n; /* h é o mesmo em todos os processadores */
33. {// determinar o rank de cada processador
25. local_n = n/p; /* número de trapezoids por nós */
34. rank.meu=i;
26. local_a = a + my_rank*local_n*h;
35. send(((char *)&rank), sizeof(_rank),i);
27. local_b = local_a + local_n*h;
36. recv(((char *)&rank), sizeof(_rank));
28. integral = Trap(local_a, local_b, local_n, h);
37. }
29. if (my_rank == 0) {
38. my_rank=rank.meu;
30. total = integral;
41. recv(((char *)&rank), sizeof(_rank));
31. for (source = 1; source < p; source++) {
42. h = (b-a)/n;
32. MPI_Recv(&integral, 1, MPI_DOUBLE, source, tag,
43. local_n = n/p;
33. MPI_COMM_WORLD, &status);
44. local_a = a + my_rank*local_n*h;
34. total = total + integral;
45. local_b = local_a + local_n*h;
35. }
46. integral.num = Trap(local_a, local_b, local_n, h);
36. } else {
47. if (my_rank == 0) {
37. MPI_Send(&integral, 1, MPI_DOUBLE, dest,
48. total = integral.num;
tag, MPI_COMM_WORLD);
49. for (source = 1; source < p; source++) {
38. }
50. recv_be(((char *)&integral), sizeof(_integral));
39. if (my_rank == 0) {
51. total = total + integral.num;
40. printf("With n = %d trapezoids, our estimaten",n);
52. }
41. printf("of the integral from %f to %f = %23.16en",
53. } else {send(((char *)&integral), sizeof(_integral),dest);}
a, b, total);
56. if (my_rank == 0) {
42. }
57. printf("With n = %d trapezoids, our estimaten", n);
43. MPI_Finalize();
58. printf("of the integral from %f to %f = %23.16en", a, b, total);
44. return 0;
59. }
45. }
60. return 0;
61. } /* main */

MPI SMS 18

Trapezoidal Rule (n=250.000) Trapezoidal Rule (n=750.000)

25 70
60
Tempo em Segundos

Tempo em Segundo
20 1 1
2 50 2
15 40
4 4

10 8 30 8
16 20 16
5 32 32
10
0 0

Trapezoidal Rule (n=1.000.000)

90
80
Tempo em Segundos

70 1
60 2
50 4
40 8
30 16
20 32
10
0
Processadores

Trapezoidal Rule (n=2.000.000) Trapezoidal Rule (n=4.000.000)

180 400
160 350
Tempo em Segundos

Tempo em Segundos
140 1 1
300
120 2 2
250
100 4 4
200
80 8 8
150
60 16 16
40 100
32 32
20 50
0 0


Trapezoidal Rule

35
30
250.000
25
750.000

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

Trapezoidal Rule

1,4
1,2
250.000
1
Eficiência

750.000
0,8
1.000.000
0,6
2.000.000
0,4
4.000.000
0,2
0
1 2 4 8 16 32
Processadores


ALGORITMO PARA TESTES DA REDE DE INTERCONEXÃO DO SIMULADOR SMS

Numa arquitetura paralela, a rede de interconexão tem papel fundamental sobre o desempenho de todo
sistema paralelo. Neste contexto, é relevante que a ferramenta de simulação viabilize a investigação da
arquitetura simulada em função da rede de interconexão.

Portanto, o estudo sobre as tecnologias de transmissão de dados em redes de interconexão é
extremamente relevante em ambientes paralelos, pois a rede tem influência direta sobre o desempenho
das aplicações.

Tornando necessário que existam algoritmos que viabilizem testes para a rede de interconexão
utilizada na ferramenta SMS. O primeiro algoritmo implementado com este fim é chamado de Round-
Trip, que é um algoritmo que mede a taxa de transferência dos dados na rede de interconexão do
simulador.
Entrada: Tamanho em bytes da mensagem. Entrada: msg (mensagem do mestre)
Saída: Taxa de transmissão da rede de Saída: msg (mensagem par o mestre)
interconexão em bytes por segundo (bps) Recv_be(msg);
Send (msg, mestre);
T1=tempo inicial;
Msg= 1000; // bytes
Send (msg, escravo);
Recv_be(msg);
T2=tempo final;
Tempo_total=T2-T1;
Calcula taxa de taxa de trasferencia();
Mostra taxa de transferência em bps.
(a) (b)


ALGORITMO PARA TESTES DA REDE DE INTERCONEXÃO DO SIMULADOR SMS

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


ALGORITMO DE ORDENAÇÃO ODD-EVEN
É muito comum tanto em aplicações científicas quanto comerciais a utilização de métodos de
ordenação de dados.
Define-se como um algoritmo de ordenação, o que contenha funções para rearranjar uma lista
desordenada de elementos de maneira que tais elementos fiquem ordenados de forma crescente ou
decrescente.
O algoritmo Odd-Even ordena n elementos em n fases (sendo n ímpar), cada qual requer n/2
operações de comparação e troca.


O algoritmo de ordenação Odd-Even proposto para o simulador SMS, segue o mesmo princípio.
Com a diferença de que o arranjo será dividido pelo número de processadores (n/p), em que n e p
são múltiplos de dois. Cada nó então conterá um sub-arranjo, durante a fase ímpar, os nós irão
enviar seus sub-arranjos para seus vizinhos à direita e os seus vizinhos à direita irão da mesma
forma enviar seus sub-arranjos para seus vizinhos ímpares da esquerda. Em posse desses sub-
arranjos cada nó que compõe a operação ímpar irá ordenar os dois sub-arranjos.



Odd-Even Sort (n=2048) Odd-Even Sort (n=4096) Odd-Even Sort (n=8192)

8 16 40
7 14 35
Tempo em Segundos

Tempo em Segundos

Tempo em Segundos
1 1 1
6 12 30
2 2 2
5 10 25
4 4 4
4 8 20
8 8 8
3 6 15
16 16 16
2 4 10
32 32 32
1 2 5
0 0 0
Processadores Processadores Processadores

Odd-Even Sort (n=16384) Odd-Even Sort (n=32768) Odd-Even Sort (n=65536)

90 200 450
80 400
Tempo em Segundos

Tempo em Segundos

Tempo em Segundos
70 1 1 350 1
150
60 2 2 300 2
50 4 4 250 4
100
40 8 8 200 8
30 16 16 150 16
20 50 100
32 32 32
10 50
0 0 0
Processadores Processadores Processadores


Odd-Even Sort

10

8 2048
4096

Speedup
6 8192
4 16384
32768
2
65536
0
1 2 4 8 16 32
Processadores

Odd-Even Sort

1,2

1 2048

0,8 4096
Eficiência

8192
0,6
16384
0,4 32768
0,2 65536
0
1 2 4 8 16 32
Processadores



Como o algoritmo Odd-Even tem como objetivo principal o teste da rede de interconexão, tal
algoritmo atinge este objetivo claramente. Para isto basta comparar o fluxo da rede de interconexão
dos algoritmos Odd-Even e do π.

Envio de mensagens cálculo do pi Recebimento de mensagens cálculo do pi

0 0

Processadores
Processadores

1 1
2 2
3 3
4 4
5 5
6 6
7 7
0 20 40 60 80 100 120 0 10 20 30 40 50 60 70
8 8
Bytes Bytes

Uso da rede de interconexão do algoritmo de cálculo do π

Envio de Mensagens do Odd-Even Sort Recebimento de Mensagens do Odd-Even Sort

0 Processadores 0
Processadores

1 1
2 2
3 3
4 4
5 5
6 6
7 7
0 50000 100000 150000 200000 250000 300000 0 50000 100000 150000 200000 250000 300000
8 8
Bytes Bytes

Uso da rede de interconexão do algoritmo Odd-Even sort

SIMULAÇÃO DE OUTRAS ARQUITETURAS COM O SMS

O SMS possibilita a alteração de inúmeros itens de hardware de um processador superescalar, de
forma que é possível configurar e simular vários aspectos.
Um exemplo de alteração de simulação é trocar o tamanho da memória cache, tal experimento foi
feito com o algoritmo do π

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

Linha de comando para executar o programa de cálculo do π com cache de dados de tamanho de 4096

No exemplo do algoritmo do π foi modificado o tamanho da memória cache de dados de todos os
processadores, sendo então colocada em cada processador uma cache de dados com o tamanho de
4096 bytes (ver figura 39), sendo que o simulador tem como padrão uma cache de dados com tamanho
de 128 bytes, que foi o tamanho utilizado nas simulações com o algoritmo do cálculo do π
anteriormente.


Algoritmo cálculo do pi com cache alterada

25

20
10.000 cache 128
Speedup

15 100.000 cache 128
10 10.000 cache 4096
100.000 cache 4096
5

0
1 2 4 8 16 32
Processadores

Algoritmo cálculo do pi com cache alterada

1,4
1,2
1 10.000 cache 128
Eficiência

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



Outro algoritmo submetido a uma mudança de arquitetura simulada foi o Trapezoidal rule. Para este
algoritmo foi alterado o previsor de desvios, trocando o bimod (padrão do simulador) para o
algoritmo 2lev.

Tal modificação foi realizada em todos os processadores, mas poderia ser feita individualmente
simulando ambientes heterogêneos, para isso seria necessário especificar via linha de comando, por
exemplo: sms 2 –bpred_00 bimod –bpred_01 2lev trapezoide.

#sms 2 -bpred_00 2lev -bpred_01 2lev -redir:sim trapezoide-2lev-44440.000-2.sim
trapezoide


Alteração do sistema de previsão de desvio do
algoritmo Trapezoidal rule

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

Alteração do sistema de previsão de desvio do
algoritmo Trapezoidal rule

1,2
1.000.000 2lev
1
2.000.000 2lev
Eficiência

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



O algoritmo de ordenação Odd-Even proposto tem como característica marcante o intenso uso da
rede de interconexão, foram realizadas simulações com duas arquiteturas, uma com uma rede de
interconexão com 1Mb/s de largura de banda e outra com 10Mb/s.
Odd-Even sort com rede de interconexão de Odd-Even sort com rede de interconexão de
1 Mb/s(n=32768) 10 Mb/s (n=32768)

200 200
Tempo em segundos

Tempo em segundos
1 1
150 150
2 2
4 4
100 100
8 8

50 16 16
50
32 32
0 0

Odd-Even sort com rede de interconexão de Odd-Even sort com rede de interconexão de
1 Mb/s (n=65536) 10 Mb/s (n=65536)

500 500
Tempo em segundos

Tempo em segundos

400 1 1
400
2 2
300 4 300 4
200 8 200 8
16 16
100 100
32 32
0 0


TRABALHOS FUTUROS

Memória Compartilhada: O desenvolvimento de tal modulo tornará o SMS uma
ferramenta de simulação completa, simulando ambientes de memória distribuída e
compartilhada;

Desenvolvimento de Algoritmos Paralelos para memória compartilhada: Com a
implementação do modulo de memória compartilhada faz se necessário o
desenvolvimento de algoritmos para testes neste ambiente;

Interface Gráfica: A criação de tal modulo possibilitará uma melhor interação entre o
usuário e a ferramenta, e facilitará o controle das simulações;

Redes de Interconexão: Outras redes de interconexão devem ser implementadas com
diferentes topologias e protocolos de controle.


CONCLUSÃO

Foram executados intensos exercícios de simulação. Esses exercícios de simulação mostraram que a
ferramenta viabiliza a implementação de algoritmos paralelos e a análise de desempenho de
arquiteturas paralelas.

A ferramenta permite realizar simulações, nas quais é possível alterar características físicas de
baixo nível e alto nível.

Os algoritmos implementados permitem ainda que usuários que estejam iniciando suas pesquisas
em computação paralela, possam primeiramente analisar os algoritmos já implementados, estudando-
os e alterando-os, para posteriormente desenvolver seus próprios algoritmos.

Tais algoritmos também permitiram validar a ferramenta, mostrando que ela é uma ótima
alternativa para testes de avaliação de desempenho em ambientes paralelos e como ferramenta de
auxílio ao ensino e pesquisa em Arquiteturas Paralelas.


Dissertacao - Palestra - Algoritmos para simulador de arquiteturas paralelas

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (15)

Similar a Dissertacao - Palestra - Algoritmos para simulador de arquiteturas paralelas

Similar a Dissertacao - Palestra - Algoritmos para simulador de arquiteturas paralelas (20)

Más de Luiz Arthur

Más de Luiz Arthur (20)

Dissertacao - Palestra - Algoritmos para simulador de arquiteturas paralelas