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

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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) Mestrando: Luiz Arthur Feitosa dos Santos 3

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares SIMULADOR DE ARQUITETURAS 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. Mestrando: Luiz Arthur Feitosa dos Santos 4

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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 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. Mestrando: Luiz Arthur Feitosa dos Santos 5

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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. Mestrando: Luiz Arthur Feitosa dos Santos 6

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares SIMULADOR DE ARQUITETURAS 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 Mestrando: Luiz Arthur Feitosa dos Santos 7

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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. Mestrando: Luiz Arthur Feitosa dos Santos 8

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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. Mestrando: Luiz Arthur Feitosa dos Santos 9

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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); Mestrando: Luiz Arthur Feitosa dos Santos 10

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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 sended inet_sended_bytes_00 10243200 inet_sended_bytes_01 1281600 Saída reduzida de uma simulação no SMS Mestrando: Luiz Arthur Feitosa dos Santos 11

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares ALGORITMO PARALELO DE MULTIPLICAÇÃO DE MATRIZES 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 Processadores Processadores Tempo de execução do algoritmo de multiplicação de matrizes Mestrando: Luiz Arthur Feitosa dos Santos 12

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares ALGORITMO PARALELO 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 Mestrando: Luiz Arthur Feitosa dos Santos 13

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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 Mestrando: Luiz Arthur Feitosa dos Santos 14

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares ALGORITMO PARALELO PARA CÁLCULO DO π 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 Processadores Processadores 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 Processadores Processadores Tempo de execução do algoritmo do cálculo do π Mestrando: Luiz Arthur Feitosa dos Santos 15

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares ALGORITMO PARALELO PARA 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 Mestrando: Luiz Arthur Feitosa dos Santos 16

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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. Mestrando: Luiz Arthur Feitosa dos Santos 17

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares ALGORITMO TRAPEZOIDAL RULE 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

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares ALGORITMO TRAPEZOIDAL RULE 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 Processadores Processadores 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 Processadores Processadores Mestrando: Luiz Arthur Feitosa dos Santos 19

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares ALGORITMO TRAPEZOIDAL RULE 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 Mestrando: Luiz Arthur Feitosa dos Santos 20

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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) Mestrando: Luiz Arthur Feitosa dos Santos 21

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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 Mestrando: Luiz Arthur Feitosa dos Santos 22

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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. Mestrando: Luiz Arthur Feitosa dos Santos 23

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares ALGORITMO DE ORDENAÇÃO ODD-EVEN 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. Mestrando: Luiz Arthur Feitosa dos Santos 24

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares ALGORITMO DE ORDENAÇÃO ODD-EVEN 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 Mestrando: Luiz Arthur Feitosa dos Santos 25

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares ALGORITMO DE ORDENAÇÃO ODD-EVEN 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 Mestrando: Luiz Arthur Feitosa dos Santos 26

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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 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 Mestrando: Luiz Arthur Feitosa dos Santos 27

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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. Mestrando: Luiz Arthur Feitosa dos Santos 28

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares SIMULAÇÃO DE OUTRAS ARQUITETURAS COM O SMS 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 Mestrando: Luiz Arthur Feitosa dos Santos 29

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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 Mestrando: Luiz Arthur Feitosa dos Santos 30

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares SIMULAÇÃO DE OUTRAS ARQUITETURAS COM O SMS 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 Mestrando: Luiz Arthur Feitosa dos Santos 31

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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 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 Processadores Processadores 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 Processadores Processadores Mestrando: Luiz Arthur Feitosa dos Santos 32

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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. Mestrando: Luiz Arthur Feitosa dos Santos 33

Desenvolvimento de Algoritmos Paralelos para Simulador de Multiprocessadores Superescalares 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. Mestrando: Luiz Arthur Feitosa dos Santos 34

http://profluizarthur.wordpress.com	191
http://www.slideshare.net	12
http://webcache.googleusercontent.com	1

Dissertacao - Palestra - Algoritmos para simulador de arquiteturas paralelas

by Luiz Arthur on Jun 21, 2009

Accessibility

Categories

Upload Details

Usage Rights

3 Embeds 204

Statistics

Dissertacao - Palestra - Algoritmos para simulador de arquiteturas paralelas Presentation Transcript