Dissertacao - Palestra - Algoritmos para simulador de arquiteturas paralelas
-
Upload
luiz-arthur -
Category
Technology
-
view
2.013 -
download
0
Transcript of Dissertacao - Palestra - Algoritmos para simulador de arquiteturas paralelas
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
Orientador: Prof. Dr. João Angelo Martini
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 2
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
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos 3
COMPUTAÇÃO PARALELA
ARQUITETURAS PARALELAS COM MEMÓRIA COMPARTILHADA E DISTRIBUÍDA
Processador 1
CacheMemória
Disp. Entrada/
Saída
Barram
ento
Processador 2
Cache
Processador N
Cache
(b)
Processador 1
Cache
Memória
Disp. Entrada/S
aída
Rede de Interconexão
Processador 2
Cache
Processador N
Cache
Memória
Memória
(c)
Memória
Unidade de controle
Unidade Aritmética
lógica
Acumulador
Dispositivo de entrada
Dispositivo de saída
PROCESSAMENTO SEQÜENCIAL
MÁQUINA DE VON NEUMANN (TANEMBAUM 2001)
(a)
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos 4
SIMULADOR DE ARQUITETURASSimuladores 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.
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
SIMULADOR DE ARQUITETURAS
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 threadspara 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 superescalaresbaseado no simulador MINT.
5
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
SIMULADOR DE ARQUITETURAS
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.
6
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos 7
SIMULADOR DE ARQUITETURAS
Interface para passagem de parâmetros da simulação
Disparador e Coletor
Programa1
Programa2
Programa N
Programa 3
...
Bibliotecas – Send e Receive Gerenciador de Memória
Protocolo
Topologia
Processador 1
Processador 2
Processador N
Processador 3
...
Interface GráficaInterface
Simulador
Simulador Paralelo
Programas do Usuário
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos 8
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.
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
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.
Paralelo
Seqüencial
çãoTempoExecuçãoTempoExecu
Aceleração =NoçãoParalelTempoExecu
oçãoParalelTempoExecuAceleração 1=
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.
Speedup Absoluto Speedup Relativo
9
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
ALGORITMO PARALELO DE MULTIPLICAÇÃO DE MATRIZES
01. #include </usr/sms/com.h>02. struct _matriz matriz;03. struct _vetor vetor;04. void main(void) {06. openchanel();07. sendbc(((char *)&matriz),sizeof(_matriz));08. recv_be(((char *)&matriz),sizeof(_matriz));09. for (i=0;i<N;++i){10. for (t=0;t<N; ++t){vetor.X[t]=A[i][t];}11. vetor.linha=i;12. send(((char *)&vetor), sizeof(_vetor),p);13. if (p==P) p=1;else p++;14. }15. /*recebe e monta vetores nas matrizes*/16. for (i=0;i<N;++i){17. recv_be(((char *)&vetor), sizeof(_vetor));18. for (t=0;t<N;++t) {19. C[vetor.linha][t]=vetor.X[t];20. }
01. struct _matriz matriz;02. struct _vetor vetor;03. void main(void){04. openchanel();05. /*recebe matriz B para suas colunas serem multiplicadas06. recv_be(((char *)&matriz),sizeof(_matriz));07. for (;;){08. for(i=0;i<N;++i){09. vtaux[i]=0;}10. recv_be(((char *)&vetor), sizeof(_vetor));11. /* realiza a multiplicacao */12. for (t=0;t<N;++t){ 13. for (i=0;i<N;++i){14. vtaux[t]=vtaux[t]+(vetor.X[i]*matriz.B[i][t]);}15. }16. /*atribui os calculos ao vetor para devolver ao mestre*/17. for (t=0;t<N;++t){vetor.X[t]=vtaux[t];}18. /*Envia vetor calculado ao mestre*/19. send(((char *)&vetor), sizeof(_vetor),0);
Mestre Escravos
10
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
ALGORITMO PARALELO DE MULTIPLICAÇÃO DE MATRIZES
# 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 sendedinet_sended_bytes_00 10243200 inet_sended_bytes_01 1281600
Saída reduzida de uma simulação no SMS
11
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
ALGORITMO PARALELO DE MULTIPLICAÇÃO DE MATRIZES
Multiplicação de Matrizes 50x50
02
46
810
1214
16
Processadores
Tem
po e
m s
egun
dos
12481632
Multiplicação de Matrizes 100x100
020
4060
80100
120140
160
Processadores
Tem
po e
m s
egun
dos
12481632
Multiplicação de Matrizes 600x600
05000
1000015000
2000025000
3000035000
40000
Processadores
Tem
po e
m s
egun
dos
12481632
Multiplicação de Matrizes 800x800
0100002000030000400005000060000700008000090000
Processadores
Tem
po e
m s
egun
dos
12481632
Tempo de execução do algoritmo de multiplicação de matrizes 12
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
ALGORITMO PARALELO DE MULTIPLICAÇÃO DE MATRIZESMultiplicação de Matrizes
0
5
10
15
20
25
30
1 2 4 8 16 32
Processadores
Spe
edup
50x50100x100600x600800x800
Multiplicação de Matrizes
00,20,40,60,8
11,21,41,61,8
1 2 4 8 16 32
Processadores
Efic
iênc
ia 50x50100x100600x600800x800
Speedup apresentado pelo algoritmo
paralelo de multiplicação de
matrizes
Eficiência apresentada pelo algoritmo paralelo
de multiplicação de matrizes
13
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
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
021
4x
π
Entrada: Número do processador NP.Saída: Valor parcial de recv_be(N,TP) w = 1.0/nfor (i=NP; i<=N; i=i+TP) x = w * (i – 0,5)pi = pi + (4.0 / (1.0 + (x * x)))pi = pi * wsend(pi)
Mestre
Entrada: Nº iterações N, Total de processadores TP.Saída: Valor global de pi_globalsend_bc(N,TP) for (x=1; x<=TP; x++)
recv_be(pi) pi_global=pi_global+pi
mostra (pi_global)
Escravo
14
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
ALGORITMO PARALELO PARA CÁLCULO DO π
Cálculo do pi (n=10.000)
0
10
20
30
40
50
60
70
Processadores
Tem
po e
m s
egun
dos
12481632
Cálculo do pi (n=20.000)
0
20
40
60
80
100
120
140
Processadores
Tem
po e
m s
egun
dos
12481632
Cálculo do pi (n=100.000)
0
100
200
300
400
500
600
700
Processadores
Tem
po e
m s
egun
dos
12481632
Cálculo do pi (n=1.000.000)
01000
20003000
40005000
60007000
8000
Processadores
Tem
po e
m s
egun
dos
12481632
Tempo de execução do algoritmo do cálculo do π
15
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos 16
ALGORITMO PARALELO PARA CÁLCULO DO πCálculo do pi
02468
10121416
1 2 4 8 16 32
Processadores
Spe
edup
10.00020.000100.0001.000.000
Cálculo do pi
0
0,2
0,4
0,6
0,8
1
1,2
1 2 4 8 16 32
Processadores
Efic
iênc
ia 10.000
20.000100.0001.000.000
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
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.
f(x)
y
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.
∫b
adxxf )(
ba
f(x)
y
x
(a) (b)
17
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
ALGORITMO TRAPEZOIDAL RULE
2. #include "mpi.h"3. double Trap(double local_a, double local_b, int local_n, double h); 4. double f(double x); 5. int main(int argc, char** argv) {…20. MPI_Status status;21. MPI_Init(&argc, &argv);22. MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);23. MPI_Comm_size(MPI_COMM_WORLD, &p);24. h = (b-a)/n; /* h é o mesmo em todos os processadores */25. local_n = n/p; /* número de trapezoids por nós */26. local_a = a + my_rank*local_n*h;27. local_b = local_a + local_n*h;28. integral = Trap(local_a, local_b, local_n, h);29. if (my_rank == 0) {30. total = integral;31. for (source = 1; source < p; source++) {32. MPI_Recv(&integral, 1, MPI_DOUBLE, source, tag,33. MPI_COMM_WORLD, &status);34. total = total + integral;35. }36. } else { 37. MPI_Send(&integral, 1, MPI_DOUBLE, dest,
tag, MPI_COMM_WORLD);38. }39. if (my_rank == 0) {40. printf("With n = %d trapezoids, our estimate\n",n);41. printf("of the integral from %f to %f = %23.16e\n",
a, b, total);42. }43. MPI_Finalize();44. return 0;45. }
02. #include </usr/sms/com.h>03. struct _rank { // estrutura que informa passar o número do processador05. int meu; } _rank;07. struct _integral08. { double num; /* intervalo integral - local */ } _integral;13. double Trap(double local_a, double local_b, int local_n, double h); 14. double f(double x);15. int main(int argc, char** argv) {30. openchanel(); /*sincroniza os processos mestre e escravo*/31. p=2; //numero do processador32. for (i=0; i<p; i++)33. {// determinar o rank de cada processador34. rank.meu=i;35. send(((char *)&rank), sizeof(_rank),i);36. recv(((char *)&rank), sizeof(_rank));37. }38. my_rank=rank.meu;41. recv(((char *)&rank), sizeof(_rank));42. h = (b-a)/n; 43. local_n = n/p; 44. local_a = a + my_rank*local_n*h;45. local_b = local_a + local_n*h;46. integral.num = Trap(local_a, local_b, local_n, h);47. if (my_rank == 0) {48. total = integral.num;49. for (source = 1; source < p; source++) {50. recv_be(((char *)&integral), sizeof(_integral));51. total = total + integral.num;52. }53. } else {send(((char *)&integral), sizeof(_integral),dest);}56. if (my_rank == 0) {57. printf("With n = %d trapezoids, our estimate\n", n);58. printf("of the integral from %f to %f = %23.16e\n", a, b, total);59. }60. return 0;61. } /* main */
MPI SMS 18
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
ALGORITMO TRAPEZOIDAL RULETrapezoidal Rule (n=250.000)
0
5
10
15
20
25
Processadores
Tem
po e
m S
egun
dos
12481632
Trapezoidal Rule (n=750.000)
0
10
20
30
40
50
60
70
Processadores
Tem
po e
m S
egun
do 12481632
Trapezoidal Rule (n=1.000.000)
0102030405060708090
Processadores
Tem
po e
m S
egun
dos
12481632
Trapezoidal Rule (n=2.000.000)
020406080
100120140160180
Processadores
Tem
po e
m S
egun
dos
12481632
Trapezoidal Rule (n=4.000.000)
050
100150
200250
300350
400
ProcessadoresTe
mpo
em
Seg
undo
s
12481632
19
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
ALGORITMO TRAPEZOIDAL RULETrapezoidal Rule
0
510
15
20
2530
35
1 2 4 8 16 32
Processadores
Spe
edup
250.000750.0001.000.0002.000.0004.000.000
Trapezoidal Rule
0
0,20,4
0,6
0,8
11,2
1,4
1 2 4 8 16 32
Processadores
Efic
iênc
ia
250.000750.0001.000.0002.000.0004.000.000
20
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
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.Saída: Taxa de transmissão da rede de interconexão em bytes por segundo (bps)
T1=tempo inicial;Msg= 1000; // bytesSend (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.
Entrada: msg (mensagem do mestre)Saída: msg (mensagem par o mestre)Recv_be(msg);Send (msg, mestre);
(b)(a)
21
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
ALGORITMO PARA TESTES DA REDE DE INTERCONEXÃO DO SIMULADOR SMS
Bytes msg
fc
bps
0.069002 0.068447 0.067977 200
0.112469 0.137166 0.135112 100
0.444038 0.437780 0.440441 30
0.627479 0.667792 0.65065320
1.313.5131.283.9741.312.80810
2.541.6192.557.4342.535.7035
3.208.4393.084.5353.013.3194
4.302.8064.193.8924.086.9713
6.308.4725.829.8845.799.5892
11.794.19111.046.79410.243.8021
4.0002.0001.000Bytes msg
fc
22
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
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.
23
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
ALGORITMO DE ORDENAÇÃO ODD-EVENO 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.
24
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
ALGORITMO DE ORDENAÇÃO ODD-EVEN
Odd-Even Sort (n=2048)
0
12
34
5
67
8
Processadores
Tem
po e
m S
egun
dos
12481632
Odd-Even Sort (n=4096)
0
24
6
8
1012
14
16
Processadores
Tem
po e
m S
egun
dos
12481632
Odd-Even Sort (n=8192)
0
510
15
20
2530
35
40
Processadores
Tem
po e
m S
egun
dos
12481632
Odd-Even Sort (n=16384)
0102030405060708090
Processadores
Tem
po e
m S
egun
dos
12481632
Odd-Even Sort (n=32768)
0
50
100
150
200
Processadores
Tem
po e
m S
egun
dos
12481632
Odd-Even Sort (n=65536)
050
100150200250300350400450
Processadores
Tem
po e
m S
egun
dos
12481632
25
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
ALGORITMO DE ORDENAÇÃO ODD-EVENOdd-Even Sort
0
2
4
6
8
10
1 2 4 8 16 32
Processadores
Spe
edup
204840968192163843276865536
Odd-Even Sort
0
0,2
0,4
0,6
0,8
1
1,2
1 2 4 8 16 32
Processadores
Efic
iênc
ia
204840968192163843276865536
26
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
ALGORITMO DE ORDENAÇÃO ODD-EVEN
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 do Odd-Even Sort
0 50000 100000 150000 200000 250000 300000
Proc
essa
dore
s
Bytes
012345678
Recebimento de Mensagens do Odd-Even Sort
0 50000 100000 150000 200000 250000 300000
Proc
essa
dore
s
Bytes
012345678
Uso da rede de interconexão do algoritmo Odd-Even sort
Envio de mensagens cálculo do pi
0 20 40 60 80 100 120
Proc
essa
dore
s
Bytes
012345678
Recebimento de mensagens cálculo do pi
0 10 20 30 40 50 60 70
Proc
essa
dore
s
Bytes
012345678
Uso da rede de interconexão do algoritmo de cálculo do π
27
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
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.
28
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
SIMULAÇÃO DE OUTRAS ARQUITETURAS COM O SMS
Algoritmo cálculo do pi com cache alterada
0
5
10
15
20
25
1 2 4 8 16 32
Processadores
Spe
edup
10.000 cache 128100.000 cache 12810.000 cache 4096100.000 cache 4096
Algoritmo cálculo do pi com cache alterada
0
0,2
0,4
0,60,8
1
1,2
1,4
1 2 4 8 16 32
Processadores
Efic
iênc
ia 10.000 cache 128100.000 cache 12810.000 cache 4096100.000 cache 4096
29
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
SIMULAÇÃO DE OUTRAS ARQUITETURAS COM O SMS
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
30
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
SIMULAÇÃO DE OUTRAS ARQUITETURAS COM O SMSAlteração do sistema de previsão de desvio do
algoritmo Trapezoidal rule
0
5
1015
20
25
30
1 2 4 8 16 32
Processadores
Spee
dup
1.000.000 2lev2.000.000 2lev4.000.000 2lev1.000.000 bimod2.000.000 bimod4.000.000 bimod
Alteração do sistema de previsão de desvio do algoritmo Trapezoidal rule
0
0,2
0,4
0,6
0,8
1
1,2
1 2 4 8 16 32
Processadores
Efic
iênc
ia
1.000.000 2lev2.000.000 2lev4.000.000 2lev1.000.000 bimod2.000.000 bimod2.000.000
31
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
SIMULAÇÃO DE OUTRAS ARQUITETURAS COM O SMS
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 1 Mb/s(n=32768)
0
50
100
150
200
Processadores
Tem
po e
m s
egun
dos
12481632
Odd-Even sort com rede de interconexão de 10 Mb/s (n=32768)
0
50
100
150
200
Processadores
Tem
po e
m s
egun
dos
12481632
Odd-Even sort com rede de interconexão de 1 Mb/s (n=65536)
0
100
200
300
400
500
Processadores
Tem
po e
m s
egun
dos
12481632
Odd-Even sort com rede de interconexão de 10 Mb/s (n=65536)
0
100
200
300
400
500
Processadores
Tem
po e
m s
egun
dos
12481632
32
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
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.
33
Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares
Mestrando: Luiz Arthur Feitosa dos Santos
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.
34