Desempenho Computacional Renato N. Elias, Marcos A. D. Martins, Alvaro L. G. A. Coutinho {renato, marcos, Núcleo de Atendimento em.

Apresentação em tema: "Desempenho Computacional Renato N. Elias, Marcos A. D. Martins, Alvaro L. G. A. Coutinho {renato, marcos, Núcleo de Atendimento em."— Transcrição da apresentação:

1 Desempenho Computacional Renato N. Elias, Marcos A. D. Martins, Alvaro L. G. A. Coutinho {renato, marcos, alvaro}@nacad.ufrj.br Núcleo de Atendimento em Computação de Alto Desempenho E Departamento de Engenharia Civil Universidade Federal do Rio de Janeiro, Brasil www.nacad.ufrj.br

2 2 Sumário  Construção de software científico  Ciclo de desempenho –Quando começar –Por que começar –Quando parar  Critérios de qualidade de software  Técnicas de otimização de programas –Manual Vetorização e pipelining Inilining Boas e más práticas Desalinhamento de dados Fragmentação de memória –Automática Chaves do compilador –Assistida Profilling Guided Optimization (PGO)  Instrumentação e perfilagem –Medição de desempenho de programas –Métricas de desempenho –Medidas de tempo –Instrumentação de programas Perfilagem Árvore de chamadas Linha do tempo –GPROF –Oprofile –Sun Studio Analyzer 11 –Intel VTune 8 –Valgrind

3 3 Referências  Goedecker Stefan e Hoisie Adolfy, Performance Optimization of Numerical Intensive Codes, SIAM, março de 2001 (US$ 59.00 na Amazon);  Dongarra J., Foster I., Fox G., Gropp W., Kennedy K., Torczon L. and White A., Source Book of Parallel Computing, The Morgan Kaufmann Series in Computer Architecture and Design (US$ 58.46 na Amazon)  Intel Fortran Compiler – Optimizing Applications  Google

4 4 Expectativas  Ao final do curso o aluno deverá: –Entender os principais aspectos relacionados à construção de aplicações científicas; –Conhecer técnicas de otimização manual, automática e assistida mais frequentemente empregadas; –Conhecer boas práticas de programação de alta performance; –Conhecer alguns softwares de instrumentação de programas

5 5 Processo de Construção de Software Científico Nosso Foco Atual!

6 6 Ciclo de Desempenho Analisar os dados e identificar os problemas Testar os resultados Implementar as melhorias Criar alternativas de solução Início Obter informações de desempenho

7 7 Desempenho: O problema.  A velocidade dos computadores aumentou 500 vezes desde 1981 o que permite que softwares mais complexos e mais famintos por recursos sejam utilizados;  Como fazer com que um programa seja mais rápido utilizando-se a mesma arquitetura? –Aplicações otimizados rodam dezenas de vezes mais rápido do que aplicações mal-escritas; –Usar algoritmos eficientes e implementações corretas originam aplicações de alto desempenho.

8 8 Mitos Mitos e mal hábitos relacionados à otimização  O desempenho de uma aplicação não pode ser melhorado antes que a aplicação esteja compilando/rodando;  Verificar o sistema no qual o programa funciona somente após ter concluído;  Se o programa roda bem no meu computador, rodará bem em qualquer outro;  Não há diferença entre versão de produção e versão de depuração;  Desempenho só se obtém com programação de baixo nível (assembly);  Perder tempo desenvolvendo as características do software e somente pensar em otimização se restar algum tempo;

9 9 Premissa Básica: A otimização de um software não deve iniciar onde o código termina – É um processo contínuo que inicia no estágio de projeto e continua por todo o seu desenvolvimento

10 10 Quando começar?  O quanto antes  fase de projeto/desenvolvimento –Preocupação contínua com boas práticas de programação  Caso o software já tenha sido desenvolvido: –Expectativas do usuário “…Gostaria que o resultado da minha análise estivesse pronto antes do meu chefe me cobrar…” “…Gostaria que esse software rodasse mais rápido para que eu pudesse analisar mais casos…” –Expectativas do cliente “…só usarei seu software se ele for 10% mais rápido que o do concorrente…”

11 11  Responsabilidade com a qualidade do software  Identificação de desempenho ruim. “…esse resultado já deveria estar pronto…”  O programador não adotou as práticas mínimas para a construção de um software eficiente. “… vou usar um ponteiro de objeto para instanciar o campo de uma classe polimórfíca que por sua vez será operada por um método virtual…”. Eu realmente preciso disso???? Existe uma forma simples de fazer a mesma coisa? –DICA 1: Inteligentemente substitua “sofisticação” por desempenho –DICA 2: Em computação de alto desempenho, o simples normalmente é o mais eficiente  Surgimento de tecnologias das quais posso tirar proveito em novas versões do software: –MMX, SSE, 3DNOW, HT são exemplos de tecnologias que trazem ganhos substanciais para alguns tipos de tarefas. Por que começar?

12 12 Quando parar?  O software alcançou o máximo de eficiência da máquina? –Teoricamente, impossível de se alcançar...  Os requisitos de desempenho previamente definidos foram completamente atingidos?  Não há mais o que ser melhorado  raro de acontecer

13 13  Portável –Roda em qualquer máquina, sistema operacional e compilador com nenhum ou com um mínimo de esforço; DICA 1: Procure utilizar somente os padrões da linguagem de programação! DICA 2: EVITE usar bibliotecas que NÃO sejam distribuídas com código fonte ou que não sejam minimamente portáveis.  Legível –A qualquer momento você, ou qualquer pessoa, saberá exatamente o que cada trecho do programa faz;  Manutenível –Documentação, controle de versão, etc…  Confiável/Robusto –Produz resultados corretos e possui proteções contra mal-uso Critérios de Qualidade de Software

14 14 Técnicas de otimização de programas  Regras gerais: –Seleção dos melhores algoritmos; –Uso de bibliotecas eficientes (não esquecendo da portabilidade); BLAS GOTO “...comprovadamente a implementação de BLAS mais eficiente para diversos sistemas...” –Escolha do melhor layout de dados; –Programar com boas práticas (otimizações manuais); –Usar otimizações do compilador SEMPRE!!!;

15 15 Técnicas de otimização de programas  Manual –Interferência direta do programador sobre o fluxo, estrutura, técnicas, algoritmos e implementações  Automática –Utilização das opções de otimização (flags) disponibilizadas pelo compilador –Utilização de um software de otimização de flags de compilação (ACOVEA)  Assistida –Compilar o software com opções de geração de relatórios de otimização que podem ser posteriormente utilizados pelo compilador para gerar uma nova versão otimizada; –Utilizar um perfilador que forneça dicas de otimização baseadas nos resultados da periflagem

16 16 Técnicas de Otimização de programas (cont.)  Otimização manual: –O usuário tem maior controle a respeito das dependências de dados; –Pode reduzir a legibilidade do programa; –Algumas otimizações podem ser benéficas em algumas arquiteturas e maléficas para outras;  Otimização automática: –O compilador possui um conhecimento limitado das dependências de dados; –Praticamente impossível em C/C++ se forem utilizados ponteiros indiscriminadamente; –Não altera a legibilidade do código; –Resultados ótimos de acordo com a arquitetura e a habilidade do compilador; –Pode aumentar consideravelmente o tempo de compilação  Otimização na prática –Realizar otimizações manuais básicas e deixar outras otimização por conta do compilador –Utilizar otimizações avançadas somente para as arquiteturas predominantes

17 17 Otimização Manual  Forma mais trabalhosa porém a mais efetiva; –O programador deve ter controle sobre o que deve ser otimizado  Baseia-se em: –Utilizar boas práticas de programação durante a fase de concepção do software; –Por em prática o ciclo de desempenho: Analisar os dados e identificar os problemas Testar os resultados Implementar as melhorias Criar alternativas de solução Início Obter informações de desempenho

18 Práticas de Programação Eficiente para High Performance Computing (HPC)

19 19 Diretrizes Básicas  Lema número 1: –Quanto mais simples melhor!  Lema número 2: –Utilizar somente linguagens de programação suportadas por máquinas de HPC, ou seja, Fortran e C/C++  Lema número 3: –Ajude o compilador a melhorar ainda mais o seu código  Lema número 4: –Tenha “carinho” pelos recursos computacionais que seu software irá utilizar. Por mais potente que um computador seja, ele não deve perder tempo realizando tarefas secundárias

20 Técnicas de Otimização Manual em outras palavras: “Boas Práticas de Programação 20

21 21 Eliminação de sub-expressões Muitas dessas otimizações também podem ser automaticamente feitas pelo compilador s1 = a + c + b s2 = a + b – c ordem das operações inibindo as otimizações por parte do compilador No mínimo, substitua por: s1 = (a + b) + c s2 = (a + b) – c ou melhor: t = a + b s1 = t + c s2 = t – c r = 2.*x(i) s = x(i)-1. t1 = x(i) r = 2.*t1 s = t1-1. x = acos(-1.) + acos(-1.)**2 tt = acos(-1.) x = tt + tt**2 ou melhor: tt = acos(-1.) x = tt + tt*tt Original Melhorado

22 22 Reduções 2*i onde i é um valor inteiro i + i 2*f onde f é um valor de ponto flutuante f + f essa modificação não traz benefícios pois a adição e a multiplicação de ponto flutuante consomem o mesmo número de ciclos x**2.d0 No mínimo, substitua por: x**2 ou melhor: x*x Original Melhorado Alternativa Melhorado

23 23 Expressões constantes em laços do i=1,n a(i) = r*a(i)*s enddo ordem das operações inibindo as otimizações por parte do compilador No mínimo, substitua por: do i=1,n a(i) = r*s*a(i) enddo ou melhor: t1 = r*s do i=1,n a(i) = t1*a(i) enddo OriginalMelhorado

24 24 Conversão de sinais  A conversão de sinais consome alguns ciclos de processamento;  A omissão das conversões, em operações de ponto flutuante, podem alterar o resultado das operações, ou seja, o compilador não tenta fazer tais transformações em níveis baixos de otimização; a(i) = -(1.d0-.5d0*b(i))a(i) = -1.d0+.5d0*b(i) OriginalMelhorado

25 25 Propagação e avaliação de constantes e simplificação no cálculo de endereços two = 2.d0 x = 3.d0*two*y x = 6.d0*y dimension a(4,100) do i=1,100 x = x+a(1,i) enddo o endereço de a(1,i) em relação ao elemento a(1,1) é 4*i-4 dimension a(4*100) iadd = 1 do i=1,100 x = x+a(iadd) iadd = iadd+4 enddo aqui o endereço é calculado por uma simples adição Original Melhorado

26 Sistema de Memória 26

27 27 Tipos de dependências e instruções FMA t3 = t4 + t5 t6 = t7 – t3 t3 = t4 + t5 t4 = t6 – t7 t3 = t4 + t5 t3 = t6 – t7 Dependência verdadeira Anti-dependência Dependência de saída Fused multiply-add (FMA) x = 2.*y+1. s = s+x z = 3.*r+2. t = t+z Original x = 2.*y+1. z = 3.*r+2. s = s+x t = t+z Melhorado

28 28 Acesso à memória e localidade de dados A ordem de leitura de arrays depende diretamente da forma como a linguagem de programaçao armazena os dados. O Fortran armazena dados por coluna, enquanto C/C++ e Pascal armazenam por linhas. subroutine mult(n1,nd1,n2,nd2,y,a,x) implicit real*8(a-h,o-z) dimension a(nd1,*), y(*), x(*) do j=1,n1 t=0.d0 do i=1,n2 t=t+a(j,i)*x(i) enddo y(j)=t enddo end subroutine subroutine mult(n1,nd1,n2,nd2,y,a,x) implicit real*8(a-h,o-z) dimension a(nd1,*), y(*), x(*) do i=1,n2 t=0.d0 do j=1,n1 t=t+a(j,i)*x(j) enddo y(i)=t enddo end subroutine OriginalMelhorado

29 29 Ordem de armazenamento de dados em arrays integer :: idx(2,3) = (/1,2,3,1,2,3/)integer :: idx(2,3) = (/1,1,2,2,3,3/) Fortran (por colunas)C/C ++ e Pascal (por linhas)

30 30 Large stride memory access Qual seria a forma mais adequada de acessar a matriz “idx”? do i=1,2 do j=1,3 idx(i,j) = j enddo do j=1,3 do i=1,2 idx(i,j) = j enddo OU

31 31 Razão entre operações de ponto flutuante e acesso à memória subroutine mult(n1,nd1,n2,nd2,y,a,x) implicit real*8(a-h,o-z) dimension a(nd1,*), y(*), x(*) do i=1,n2 t=0.d0 do j=1,n1 t=t+a(j,i)*x(j) enddo y(i)=t enddo end subroutine subroutine mult(n1,nd1,n2,nd2,y,a,x) implicit real*8(a-h,o-z) dimension a(nd1,*), y(*), x(*) do i=1,n2-3,4 t1=0.d0 t2=0.d0 t3=0.d0 t4=0.d0 do j=1,n1-3,4 t1=t1+a(j+0,i+0)*x(j+0)+a(j+1,i+0)*x(j+1)+a(j+2,i+0)*x(j+2)+a(j+3,i+0)*x(j+3) t2=t2+a(j+0,i+1)*x(j+0)+a(j+1,i+1)*x(j+1)+a(j+2,i+1)*x(j+2)+a(j+3,i+1)*x(j+3) t3=t3+a(j+0,i+2)*x(j+0)+a(j+1,i+2)*x(j+1)+a(j+2,i+2)*x(j+2)+a(j+3,i+2)*x(j+3) t4=t4+a(j+0,i+3)*x(j+0)+a(j+1,i+3)*x(j+1)+a(j+2,i+3)*x(j+2)+a(j+3,i+3)*x(j+3) enddo y(i+0)=t1 y(i+1)=t2 y(i+2)=t3 y(i+3)=t4 enddo end subroutine Original Melhorado

32 32 Número de ciclos para algumas funções intrínsecas  O cálculo de algumas operações requer a decomposição em uma seqüência de operações mais simples o que eleva consideravelmente seu custo computacional DIVIDEDSQRTDSINDEXPDLOGDPOWER IBM RS/6000 P22030515452179 IBM RS/6000 P2 (MASS)7126865 Cray T3E308213387149780 Cray T3E (libbench)3246343362 SGI R100002136125119110257

33 33 Desenrolamento de laços subroutine lngth1(n,a,tt) implicit none integer :: n, j real*8, dimension(n) :: a real*8 :: tt tt=0.d0 do j=1,n tt=tt+a(j)*a(j) enddo end subroutine subroutine lngth4(n,a,tt) implicit none integer :: n, j real*8, dimension(n) :: a real*8 :: t1, t2, t3, t4, tt t1 = 0.d0 t2 = 0.d0 t3 = 0.d0 t4 = 0.d0 do j=1,n-3,4 t1 = t1+a(j+0)*a(j+0) t2 = t2+a(j+1)*a(j+1) t3 = t3+a(j+2)*a(j+2) t4 = t4+a(j+3)*a(j+3) enddo tt = t1+t2+t3+t4 end subroutine OriginalDesenrolamento em 4 níveis O desenrolamento de laços tira proveito do caráter “paralelo” (mais de uma unidade de ponto flutuante sendo utilizadas simultaneamente) dos processadores superescalares modernos. CUIDADO: Laços muito complexos tendem a estourar a capacidade dos registradores

34 34 Software Pipelining  Alguns processadores conseguem realizar cálculos entrelaçados com operações na memória (loads and stores);  O “software pipelining” é uma técnica na qual as instruções são rearranjadas com o intuito de remover ciclos de espera (stalls).  A maioria dos compiladores tentam realizar “software pipelining” quando utilizamos os níveis máximos de otimização.  Para laços simples geralmente o compilador obtém sucesso.  Difícil de ser feito manualmente pois envolve análise de código em assembly subroutine lngth4(n,a,tt) implicit none integer :: n, j real*8, dimension(n) :: a real*8 :: t1, t2, t3, t4, tt t1 = 0.d0 t2 = 0.d0 t3 = 0.d0 t4 = 0.d0 do j=1,n-3,4 t1 = t1+a(j+0)*a(j+0) t2 = t2+a(j+1)*a(j+1) t3 = t3+a(j+2)*a(j+2) t4 = t4+a(j+3)*a(j+3) enddo tt = t1+t2+t3+t4 end subroutine Desenrolamento em 4 níveis

35 35 Vetorização e pipelining  A vetorização e o pipelining são mecanismos que permitem que uma única instrução seja simultaneamente aplicada à múltiplos dados;  Esses mecanismos são inerentes à arquitetura que se esteja utilizando, ou seja, os ganhos com vetorização só podem ser obtidos em máquinas verdadeiramente vetoriais (CRAY SV1 e NEC SX), “pipelined” (ITANIUM-2) ou emulados por algum outro mecanismo (SSE);  Os resultados de operações vetoriais são severamente alterados devido a aspectos de dependência de memória, portanto, MUITO CUIDADO;

36 36 Vetorização: Como funciona? ESCALAR  Uma operação ESCALAR pode ser ilustrada por: c(1)not used a(1)not used b(1)not used do i=1,n c(i) = a(i) + b(i) enddo

37 37 Vetorização: Como funciona? (cont.) VETORIAL  Executando-se a mesma operação em um processador VETORIAL teríamos: c(1)c(2)c(3)c(4)c(5) a(1)a(2)a(3)a(4)a(5) b(1)b(2)b(3)b(4)b(5) do i=1,n c(i) = a(i) + b(i) enddo ou seja, poderíamos operar em 5 posições dos vetores simultaneamente a cada ciclo do processador (5 x mais rápido!).

38 38 Inibidores de vetorização  Dependência de dados –As iterações em um laço devem ser independentes; do i=1,n a(i) = b(i) – c(i) c(i) = a(i) + 10.d0 enddo  Alguns aspectos importantes: –Chamadas de funções inibem a vetorização; –Estruturas condicionais devem ser evitadas; –Os laços devem possuir limites; –O laço externo de laços aninhados não podem ser vetorizados; –Dados de tipos diferentes não podem ser vetorizados; –Acesso aos dados em saltos (non-unit stride access) –Muitos outros aspectos mais complexos... NÃO VETORIZAVEL O compilador pode ajudar a entender porque um laço não vetoriza.

39 39 In-lining  Função sendo chamada dentro de um laço:... do i=1,max r(i) = dist(x(i),y(i)) enddo... function dist(x,y) real*8 :: x, y, dist dist = dsqrt(x*x + y*y) end function  A técnica de “in-lining” consiste em substituir as chamadas de rotinas escrevendo-as explicitamente onde elas são chamadas:... do i=1,max r(i) = dsqrt(x(i)*x(i)+y(i)*y(i)) enddo... Os compiladores possuem flags específicos para realizar esse tipo de substituição baseado em alguns critérios, porém, quando efetuamos essa substituição explicitamente facilitamos o trabalho do compilador.

40 40 solução: common /data/ a,n na(1)a(2)a(3)... a(nx) 8 bytes subroutine lngth(tt) implicit real*8 (a-h,o-z) parameter (nx=2**12) dimension a(nx) common /data/ n,a tt=0.d0 do j=1,n tt=tt+a(j)*a(j) enddo end subroutine Desalinhamento de dados  Números de ponto flutuante são usualmente alinhados e armazenados em uma posição de memória múltipla de 8 bytes;  As operações de carga e armazenamento de dados tiram proveito dessa característica para transferir blocos de 8 bytes cada;  Alguns descuidos de programação podem inadvertidamente destruir tal característica; na(1)a(2)a(3)... a(nx) 8 bytes

41 41 Outro exemplo de desalinhamento de dados  O desalinhamento de dados também ocorre com tipos de dados derivados: type Desalinhado integer :: n real*8, dimension(100) :: x end type type Alinhado real*8, dimension(100) :: x integer :: n end type type Alinhado integer :: n integer :: j real*8, dimension(100) :: x end type

42 42 Fragmentação de memória  Os arrays sempre corresponderão a áreas contíguas de memória;  A alocação e desalocação freqüente de pequenos blocos de memória favorecem a fragmentação da mesma com a conseqüente perda de desempenho  Como ocorre a fragmentação da memória? Suponha o seguinte exemplo: –1º. estágio: 6 blocos de memória são alocados exaurindo completamente a memória física do sistema; –2º. estágio: Os blocos 1, 3 e 5 são desalocados restando os blocos 2, 4 e 6; –3º. estágio: Aloca-se um novo bloco de memória com o dobro do tamanho dos blocos originais. Como o novo bloco não pode ser alocado nos buracos deixados na memória esse novo bloco é alocado no espaço de endereçamento virtual fora do espaço da memória física e que corresponde ao disco rígido –VER ILUSTRAÇÃO DO PRÓXIMO SLIDE 

43 43 Fragmentação de memória (cont.) MEMÓRIADISCO RÍGIDO Estágio 1 Estágio 2 Estágio 3 1º. estágio: 6 blocos de memória são alocados exaurindo completamente a memória física do sistema; 2º. estágio: Os blocos 1, 3 e 5 são desalocados restando os blocos 2, 4 e 6; 3º. estágio: Aloca-se um novo bloco de memória com o dobro do tamanho dos blocos originais. Como o novo bloco não pode ser alocado nos buracos deixados na memória esse novo bloco é alocado no espaço de endereçamento virtual fora do espaço da memória física e que corresponde ao disco rígido

44 44 Como minimizar a fragmentação de memória?  Utilize critérios de longevidade e tamanho para priorizar alocações de memória, ou seja: –Primeiro aloque arrays grandes e que deverão existir durante todo, ou quase todo, o tempo de execução; –Por último aloque os arrays pequenos e temporários.

45 45 Evite sempre!  Testes no interior de laços intensivos do i=1,1000 if (i.lt.50) ! do something enddo  Chamadas de rotinas no interior de laços intensivos do i=1,1000 call something enddo  Operações de divisão “...custam muito mais ciclos de processamento do que as operações de multiplicação...”  Operações de IO no interior de laços intensos  Gravação de dados volumosos em formato ASCII  Variáveis não iniciadas;  Arrays com dimensões superiores a 2;  Aritmética de arrays do Fortran90 “...facilita a vida do programador mas deixa o desempenho inteiramente sob responsabilidade do compilador.”  Sobrecarga de operadores (C++ e Fortran90)  “Aliasing”: 2 arrays compartilhando a mesma área de memória –call sub(n,a(1),a(1),c(1),sum)

46 46 Otimização automática UTILIZE SEMPRE  É a forma mais simples e rápida de se obter ganhos de desempenho, portanto, UTILIZE SEMPRE independentemente de ter feito otimização manual ou não; NÃO NUNCA UTILIZE FLAGS DE DEPURAÇÃO  Versão de depuração NÃO é versão de produção, portanto, NUNCA UTILIZE FLAGS DE DEPURAÇÃO em softwares de produção;  Para gerar um código otimizado o compilador realiza algumas operações bastante similares a algumas técnicas de otimização manual, tais como: alteração da ordem de algumas instruções, desenrolamento de laços, inlining, etc...

47 47 Otimização automática (cont.) Lista de alguns flags de otimização:

48 48 Otimização automática (cont.)  Armadilhas dos flags de otimização: –Um compilador normalmente possui dezenas de opções de otimização que podem ser usadas individualmente ou agrupadas entre si. Nem sempre a associação dos flags de otimização produzem o melhor resultado. É importante ressaltar que em alguns casos uma associação de flags mal-feita pode acarretar em efeito contrário (“pessimização”).  Escolhendo os flags de otimização que devem ser usados –Teste os flags recomendados pelo fabricante do compilador; –Utilize os flags mais conhecidos e avalie as diferenças; –Para otimizações mais agressivas, utilize um software de otimização dos flags (ACOVEA).  OBSERVAÇÃO CRUCIAL: –Os flags de otimização podem influenciar severamente no resultado de alguns cálculos, portanto, certifique-se que o programa otimizado está produzindo o resultado correto.

49 49 Otimização automática (cont.)  ACOVEA ( A nalysis of C ompiler O ptions via E volutionary A lgorithm) –Software baseado em algoritmo genético que determina a melhor combinação de opções de compilação; –Gratuito; –Até o momento só otimiza códigos escritos em C/C++ e compilados com o compilador GNU; –Maiores informações em: http://www.coyotegulch.com/acovea/

50 50 Otimização automática (cont.) alma Calculates the daily ephemeris (at noon) for the years 2000-2099; tests array handling, floating-point math, and mathematical functions such as sin() and cos(). Acovea's solution: -fno-defer-pop -fno-thread-jumps -ftree-ccp -ftree-dce -ftree-dse -ftree-ter - ftree-lrs -ftree-sra -ftree-fre -ftree-ch -fcrossjumping -foptimize-sibling-calls - fcse-follow-jumps -fexpensive-optimizations -fcaller-saves -fforce-addr - fschedule-insns -fschedule-insns2 -fregmove -fstrict-aliasing -fdelete-null- pointer-checks -fgcse-lm -freorder-functions -funit-at-a-time -falign- functions -falign-jumps -finline-functions -fomit-frame-pointer -fpeel-loops - funroll-all-loops -freschedule-modulo-scheduled-loops -ftree-loop-im - fivopts -fvariable-expansion-in-unroller -mieee-fp -mno-push-args -mno- align-stringops -minline-all-stringops -mfpmath=387 -funsafe-math- optimizations -fno-trapping-math -finline-limit=700 Strongly Optimistic Options: ftree-fre -finline-functions -fpeel-loops -funsafe-math-optimizations -finline- limit Strongly Pessimistic Options: -floop-optimize2 -momit-leaf-frame-pointer -ffloat-store -fno-inline - mfpmath=sse -mfpmath=sse,387 -fno-math-errno Acovea turned in its best performance on this benchmark, gaining 8% over the -On options.

51 51 Otimização assistida  Alguns compiladores possuem opções específicas para a geração de relatórios de avaliação de desempenho; –Compila-se o programa com essas opções ativadas; –Executa-se uma rodada normal do software. Será produzido o relatório de otimização; –Recompile o software fornecendo o relatório de otimização para o compilador; –Baseado no relatório de otimização o compilador tentará produzir uma versão de código binário mais eficiente que o primeiro.  Enquanto houver algum ganho esse ciclo pode ser repetido Alguns fabricantes de compiladores chamam este procedimento de PGO Profile Guided Optimization

52 52 Otimização assistida (cont.)  Fase 1: ifort –prof-gen –c foo.f ifort –o foo foo.o  Fase 2:./foo  Fase 3: ifort –prof-use –c foo.f ifort –o foo foo.o

53 Instrumentação e Perfilagem

54 54 Medindo o desempenho de programas  Descobrir onde o programa consome tempo (bottleneck e hotsposts) –Rotinas de obtenção de tempo –Perfilagem  Descobrir por que o tempo esta sendo consumido nesses trechos –Uso da CPU –Uso da cache –Uso da Memoria –Uso do disco

55 55 Medindo o desempenho de programas  Cronometrar o tempo de execução; –Avaliação simples  Utilizar um software de instrumentação –Avaliação detalhada; –Perfil, árvore de chamadas, linha do tempo

56 56 Métricas de desempenho mais conhecidas  Tempo de CPU (CPU time) –tempo realmente consumido pelo processador para efetuar uma tarefa  Tempo de parede (wall time) –tempo total consumido desde o início até o fim da execução de uma tarefa  Ciclos de processador (clockticks ou cycle) –menor unidade de tempo reconhecida pelo processador  Número de operações de ponto flutuante (flops) –medida do número de contas efetuadas  Quantidade de endereçamento indireto (ia) –medida de quantidade de acessos à memória  Eficiência e speedup –métricas comuns de processamento paralelo  Métricas avançadas: –instructions retired, cache hit, thoughput, branch mispredictions, TLB misses, cache misses, e muitas outras...

57 57 Medindo desempenho pelo tempo  Medir o tempo consumido pelo programa, ou somente de algumas partes consideradas intensivas, é a forma mais simples, direta e ingênua de estimativa de desempenho.  Fatores de interferência: –Carga do sistema: vários processos sendo executados simultaneamente e compartilhando os recursos  vários usuários utilizando o sistema DICA: Utilize um sistema de filas CUIDADO: Não medir tempo de parede quando estiver utilizando um sistema de filas!!! Sua tarefa pode ser suspensa e o tempo medido não representará a realidade.

58 58 Medindo tempo  Utilizando o comando time (Unix e similares): /usr/bin/time meu_programa 19.894u 4.482s 1:43.25 23.6% 0+0k 0+0io 84pf+0w  Rotinas de tempo do Fortran: SECNDS, CPU_TIME, DATE_AND_TIME, CLOCK, ETIME Exemplo: CALL CPU_TIME ( time_begin )... !task to be timed... CALL CPU_TIME ( time_end ) PRINT *, ‘cputime spent:’, time_end - time_begin, ' seconds'

59 59 Instrumentação de programas  Normalmente utilizamos softwares para extrair as informações de desempenho: –gprof (mais antigo e rústico. Existente na maioria dos sistemas Unix) –Oprofile (gratuito e código aberto) –VTune (comercial, código fechado, propriedade da Intel) –Sun Studio (gratuito, código fechado, propriedade da Sun) –TAU – Tuning Analysis Utilities –Outros...  Características comuns e desejáveis de softwares de instrumentação: –Baixa interferência (low overhead) – VTune e Oprofile –Capacidade de detalhamento do esforço consumido em partes do programa –Facilidade de uso (VTune e Sun Studio)

60 60 Instrumentação de programas (cont.)  Formas de instrumentação de programas: –Intrusiva: as rotinas que realizam a instrumentação são explicitamente inseridas dentro do código-fonte. Demorado, trabalhoso, susceptível a erros, necessita de código-fonte e compilação. –Automática: As rotinas de instrumentação são automaticamente inseridas no código-fonte a partir de um pré-processamento Simples, rápido, susceptível a incompatibilidades, necessita código-fonte, necessita de pré-processamento e recompilação –Dinâmica: as tarefas são acompanhadas em tempo de execução (runtime). Simples, rápido, pouco susceptível a erros, não necessita de código-fonte

61 61 Perfilagem (profiling)  Detalhamento do esforço computacional consumido em cada trecho do programa.  Obtenção de relatórios na forma de tabelas, gráficos e listagens do código-fonte relacionando o esforço consumido linha-a-linha  Formas de perfilagem –Contagem: todas as operações efetuadas pelo programa são contabilizadas (muita interferência) –Amostragem: o programa é amostrado em intervalos de tempo regulares e o resultado final se baseia em análises estatísticas. (pouca interferência) –Eventos: somente alguns eventos especificamente pré-definidos são amostrados (muito pouca interferência)

62 62 Árvore de chamadas (Call graph)  Extração do fluxo de execução de um programa. “...quem chama quem, quantas vezes e quanto tempo consome...”;  Quantidade de vezes que cada rotina é chamada;  Tempo próprio (self time), tempo total (total time), etc...  Interfere severamente no tempo de execução do programa (pelo menos 3 x mais lento);  Importante para analisar programas desconhecidos;  Tamanho e complexidade da árvore proporcional à complexidade do programa

63 63 Linha do tempo (tracing e tracking)  Avaliação da linha de tempo do software. “...o que acontece e quando acontece...”  Auxilia na compreensão de programas em paralelo  Estima propriedades relacionadas à troca de mensagens (MPI) -- desbalanço, tamanho, sincronismo, etc...

64 64 Instrumentação  Softwares de instrumentação –Gprof –Oprofile –Sun Studio Analizer –VTune –Valgrind –TAU (Tuning and Analysis Utilities)

65 GPROF

66 66 GPROF: Características  Antigo  Limitado  Modo texto  Gratuito  Disponível na maioria dos sistemas Unix (e similares)  Simples de usar 1.Compile o programa com informações de depuração; ifort –c –pg foo.f ifort -pg –o foo foo.o 2.Rode o programa;./foo 3.Carregue o arquivo de relatório no gprof; gprof –p foo

67 67 Instrumentação com o GPROF  Flat Profile ( gprof –p foo ) Each sample counts as 0.01 seconds. % cumulative self self total time seconds seconds calls Ks/call Ks/call name 22.85 2747.73 2747.73 400 0.01 0.01 stiffnewtonianflow_ 18.94 5025.21 2277.48 17803 0.00 0.00 matvec4_ 14.04 6713.26 1688.05 225862 0.00 0.00 daxpy_ 12.66 8235.92 1522.65 229390 0.00 0.00 ddot_ 8.26 9228.81 992.89 457 0.00 0.00 stiffnesstransport_...  informação truncada percentual do tempo total consumido por esta rotina somatório de tempo consumido nessa rotina incluindo todas as rotinas acima dela tempo consumido somente no interior da rotina Número de vezes que a rotina foi chamada

68 68 Instrumentação com o GPROF  Call Graph ( gprof –q foo ) index % time self children called name 0.00 12021.13 1/1 main [2] [1] 100.0 0.00 12021.13 1 MAIN__ [1] 0.00 12020.98 1/1 solve_ [3] 0.07 0.00 1/1 setuptransport_ [53] 0.00 0.03 1/1 meshindriver_ [60]...  informação truncada ----------------------------------------------- [2] 100.0 0.00 12021.13 main [2] 0.00 12021.13 1/1 MAIN__ [1] ----------------------------------------------- 0.00 12020.98 1/1 MAIN__ [1] [3] 100.0 0.00 12020.98 1 solve_ [3] 16.37 12004.42 1/1 timeintegration_ [4] 0.10 0.00 1/1 equationmapbuilder_ [48]...  informação truncada ----------------------------------------------- 16.37 12004.42 1/1 solve_ [3] [4] 100.0 16.37 12004.42 1 timeintegration_ [4] 0.00 6641.65 400/400 flowsolver_ [5] 0.00 2747.73 400/400 stiffnessflow_ [7] 992.89 0.00 457/457 stiffnesstransport_ [13]...  informação truncada

69 Oprofile

70 70 Oprofile: Características  Ainda em desenvolvimento;  Interface gráfica baseada em Qt (ainda em desenvolvimento);  Baixa interferência (overhead); –Opera em modo de amostragem (sampling)  Monitora todos os processos ativos no sistema;  Não requer recompilações; –informações no código-fonte somente disponível para recompilações com informação de depuração;  Gratuito (http://oprofile.sourceforge.net);  Difícil de ser instalado, configurado e usado; –A maioria dos recursos só está disponível para administradores  Disponível somente para sistemas Unix e similares;  A versão 0.9.1 não funciona direito com as distribuições Red Hat  Maioria das operações em modo texto e acessível somente pelo root;

71 71 Oprofile: instalação  Baixando o código fonte do site http://oprofile.sourceforge.net wget http://ufpr.dl.sourceforge.net/sourceforge/oprofile/oprofile-0.9.1.tar.gz  Descompactando os arquivos tar xvfz oprofile-0.9.1.tar.gz  Configuração para kernel 2.6 ou mais recentes cd oprofile-0.9.1./configure --with-kernel-support make make install

72 72 Oprofile: Como usar?  O Oprofile requer que um daemon seja carregado para que seja feito o monitoramento dos processos em execução. Este daemon só pode ser carregado por usuários administradores (root). –carregar o daemon: opcontrol --vmlinux=/boot/vmlinux-`uname -r` ou caso não queira que o kernel seja monitorado: opcontrol --no-vmlinux –Iniciar o profilling opcontrol --start –Iniciar o programa a ser monitorado./foo –Parar o profiling opcontrol --shutdown

73 73 Oprofile: Interpretando os resultados  System-wide binary image summary $ opreport --exclude-dependent CPU: PIII, speed 863.195 MHz (estimated) Counted CPU_CLK_UNHALTED events with a unit mask of 0x00 (No unit mask) count 50000 450385 75.6634 cc1plus 60213 10.1156 lyx 29313 4.9245 XFree86 11633 1.9543 as 10204 1.7142 oprofiled 7289 1.2245 vmlinux 7066 1.1871 bash 6417 1.0780 oprofile 6397 1.0747 vim 3027 0.5085 wineserver...

74 74 Oprofile: Interpretando os resultados (cont.)  Symbol summary for a single application $ opreport --exclude-dependent --demangle=smart --symbols `which lyx` CPU: PIII, speed 863.195 MHz (estimated) Counted CPU_CLK_UNHALTED events with a unit mask of 0x00 (No unit mask) count 50000 vma samples % symbol name 081ec974 5016 8.5096 _Rb_tree<unsigned short, pair<unsigned short const, int... 0810c4ec 3323 5.6375 Paragraph::getFontSettings(BufferParams const&, int) const 081319d8 3220 5.4627 LyXText::getFont(Buffer const*, Paragraph*, int) const 080e45d8 3011 5.1082 LyXFont::realize(LyXFont const&) 080e3d78 2623 4.4499 LyXFont::LyXFont() 081255a4 1823 3.0927 LyXText::singleWidth(BufferView*, Paragraph*, int, char) const 080e3cf0 1804 3.0605 operator==(LyXFont::FontBits const&, LyXFont::FontBits const&) 081128e0 1729 2.9332 Paragraph::Pimpl::getChar(int) const 081ed020 1380 2.3412 font_metrics::width(char const*, unsigned, LyXFont const&)...

75 75 Oprofile: Interpretando os resultados (cont.)  Annotated source: –Importante na detecção de hostspots opannotate --source -x --output-dir=/home/moz/src/oprofile- www/examples/opannotated --source-dir=/home/moz/src/oprofile /usr/local/oprofile/bin/oprofiled... :void opd_put_image_sample(struct opd_image * image, vma_t offset,...) 147 1.4416 :{ /* opd_put_image_sample total: 405 3.9718 */ :samples_odb_t * sample_file; : 2 0.0196 :sample_file = &image->sample_files[counter]; : 85 0.8336 :if (!sample_file->base_memory) { :opd_open_sample_file(image, counter); 1 0.0098 :if (!sample_file->base_memory) { :/* opd_open_sample_file output an error message */ :return; :} : :/* Possible narrowing to 32-bit value only. */ 100 0.9807 :if (odb_insert(sample_file, (unsigned long)offset, 1) != EXIT_SUCCESS) : } 70 0.6865 :}...

76 76 Oprofile: Interpretando os resultados (cont.)  Annotate mixed source/assembly $ opannotate --source --assembly `which oprofiled`... :return ((value > 8)) & hash->hash_mask; 44 0.4315 : 804c5ac:mov 0xc(%ebp),%eax 3 0.0294 : 804c5af:mov 0xc(%ebp),%ebx 5 0.0490 : 804c5b2:mov 0xc(%esi),%ecx 59 0.5786 : 804c5b5:shr $0x8,%eax : 804c5b8:mov 0x4(%esi),%edx 12 0.1177 : 804c5bb:xor %ebx,%eax 3 0.0294 : 804c5bd:and %ecx,%eax : 804c5bf:mov (%edx,%eax,4),%eax :odb_index_t index; :odb_index_t new_node; :odb_node_t * node; : :index = hash->hash_base[odb_do_hash(hash, key)]; :while (index) { 1455 14.2689 : 804c5c2:test %eax,%eax 13 0.1275 : 804c5c4:je 804c5ef :if (index = hash->descr->current_size) { 12 0.1177 : 804c5c6:mov 0x8(%esi),%ecx...

77 Sun Studio Analyzer 11

78 78 Sun Studio Analyzer 11: Características  Gratuito;  Fácil de usar;  Baixa interferência;  Interface gráfica em ambiente java; –Também permite utilização em modo texto  Não requer recompilação;  Compatível somente com sistemas Linux e Solaris

79 79 Sun Studio Analyzer 11: Instalação  Baixar os arquivos de instalação do Sun Studio 11 diretamente do site da Sun (http://www.sun.com) –Necessita a criação de uma conta de usuário para ter acesso ao download  Descompacte os arquivos de instalação tar xvfj studio11-lin-x86.tar.bz2  Rode o instalador./installer  Observação: O Sun Studio é um ambiente de desenvolvimento com IDE (Integrated Development Environment), software de perfilagem (Sun Studio Analyzer), editor de textos, controle de versões, etc… porém ele NÃO INSTALA OS COMPILADORES que devem ser baixados e instalados individualmente.

80 80 Sun Studio Analyzer 11: Ambiente  O ambiente do Sun Studio Analyzer pode ser carregado individualmente (stand alone) ou anexado ao ambiente do Sun Studio (IDE).  Para carregar o Sun Studio Analyzer individualmente, faça: /opt/sun/sunstudio11/bin/analyzer

81 81 Sun Studio Analyzer 11: Ambiente  O ambiente completo do Sun Studio é carregado com o seguinte comando: /opt/sun/sunstudio11/bin/sunstudio Note que o Analyzer se integra ao ambiente do Sun Studio Os modos de operação, tanto stand alone quanto na interface do Sun Studio, são perfeitamente equivalentes

82 82 Sun Studio Analyzer 11: Como usar? Programa que será analisado Diretório de trabalho (onde o programa será rodado) Diretório onde os arquivos da perfilagem serão salvos Configuração básica: Rodar a análise Configurações avançadas de como a análise será feita Tela de saída do programa analisado

83 83 Sun Studio Analyzer 11: Interpretando os resultados  Tempo consumido por função: –Relaciona o tempo consumido por função. Auxilia na detecção de rotinas críticas.

84 84 Sun Studio Analyzer 11: Interpretando os resultados (cont.)  Árvore chamador/chamado (caller/calee) –Identifica qual função chama e qual é chamada. Ajuda da compreensão do fluxo do programa.

85 85 Sun Studio Analyzer 11: Interpretando os resultados (cont.)  Linha do tempo –Normalmente utilizada para comparar o mesmo software rodando em várias condições distintas.

86 86 Sun Studio Analyzer 11: Interpretando os resultados (cont.)  Estatística –Resumo de informações mais relevantes

87 87 Sun Studio Analyzer 11: Interpretando os resultados (cont.)  Sumário da perfilagem –Resumo de informações a respeito dos parâmetros de perfilagem

88 Intel VTune TM 8

89 89 Intel VTune 8: Características  Comercializado pela Intel ($$$);  Recomendado somente para uso com sistemas Intel; –“...espreme todas as informações possíveis e inimagináveis de um processador Intel...”  Fácil de instalar e usar;  Não requer recompilação;  Opera por amostragem e/ou por eventos;  Dispõe de um assistente de otimização;  Modos operacionais; –Interface gráfica WINDOWS: Stand alone  interface gráfica própria; WINDOWS: Associada ao ambiente do Microsoft Visual Studio ® ; LINUX: Associada à IDE do Eclipse  DIFÍCIL UTILIZAÇÃO –Modo texto (Linux e Windows)  DIFÍCIL UTILIZAÇÃO –Modo nativo ou remoto

90 90 Intel VTune 8: Compatibilidade  Intel® IA-32/EM64T Processors –Microsoft Windows* operating systems (GUI + command line) –Red Hat Linux* (command line only) –SuSE Linux (command line only)  Itanium® Family Processors –Microsoft Windows operating systems (GUI + command line) –Red Hat Linux (command line only) –SuSE Linux (command line only)  For specific operating systems versions, see the release notes.

91 91 Intel VTune 8: Perfilagem remota  VTune™ Performance Analyzer supports remote data collection  VTune™ Performance Analyzer installed on host system  Remote agent installed on target system Host System  Windows*  Controls target  View results of data collection Target System  IA-32 or Itanium ® processor  Windows or Linux*  Intel ® PXA2xx processors running Windows CE* LAN Connection

92 92 Intel VTune 8: Características do agende remoto Windows*Linux* Intel ® IA-32Sampling Call Graph Intel Itanium ® Processor Family Sampling Call Graph Intel ® PXA2xx Processors Sampling A compatibilidade desses recursos também dependem das versões dos sistemas operacionais e do VTune, portanto, verifique os release notes

93 93 Intel VTune 8: Instalação básica (Windows)  Aquisição de uma licença –Número serial ou arquivo de licenças;  Aquisição do CD de instalação ou download dos arquivos de instalação diretamente no site da Intel (http://www.intel.com)  Rodar o instalador;  Quando solicitado forneça o arquivo de licenças adquirido;

94 94 Intel VTune 8: Instalação básica (Linux)  Aquisição de uma licença –Número serial ou arquivo de licenças;  Aquisição do CD de instalação ou download dos arquivos de instalação diretamente no site da Intel (http://www.intel.com)  Caso tenha feito o download, descompacte os arquivos tar xvfz vtune_linux_8.0.245.tar.gz  No diretório que será descompactado, rode o script de instalação:./install.sh  Quando solicitado, forneça o número serial ou arquivo de licenças  A instalação em modo Linux compreende vários módulos: –Daemon do VTune e componentes básicos; –Módulos DCom; –Arquivos de integração com o Eclipse.

95 95 Intel VTune 8: Como usar?  O VTune em modo gráfico (GUI) possui assistentes que auxiliam na configuração das análises. Esses assistentes são auto-explicativos o que torna a tarefa de configuração bastante simples

96 96 Sampling Collects System-wide Performance Data

97 97 Sampling Over Time Views Show How Sampling Data Changes Over Time

98 98 Sampling Source View Displays Source Code Annotated with Performance Data

99 99 Call Graph Collects and Displays Information About the Program Flow of the Application Overhead extremamente elevado!!!

100 100 Counter Monitor Tracks Operating System Counters Over Time

101 101 The Tuning Assistant Provides Tuning Advice Based on Performance Data

102 Valgrind

103 103 Valgrind: Características  Suíte de aplicativos para depuração e perfilagem de programas no que concerne ao uso de memória;  O Valgrind possui 5 ferramentas: –MEMCHECK: Detecção de erros de memória; –CACHEGRIND: Perfilador de cache; –CALLGRIND: Call graph; –MASSIF: Perfilador de uso de memória (heap); –HELGRIND: perfilador de threads.  Roda em: –X86/Linux –AMD64/Linux –PPC32/Linux –PPC64/Linux  Gratuito e código aberto (http://valgrind.org)  Fácil de instalar e usar;  As análises interferem substancialmente no tempo de execução;

104 104 Valgrind: características  Problemas que o Valgrind ajuda a detectar: –Uso de memória não iniciada; –Leitura e escrita de memória após a mesma ter sido liberada (desalocada); –Leitura e escrita em áreas impróprias da pilha de dados (stack); –Vazamentos de memória: perda dos ponteiros de blocos de memória previamente alocados; –Incorreção de uso das rotinas correspondentes para alocação e desalocação de memória em códigos escritos em C/C++ (malloc/new/new[] vs free/delete/delete[]); –Entrelaçamento de áreas-fonte e destino em operações de cópia de áreas de memória (comando memcpy())

105 105 Valgrind: Instalação  Algumas distribuições de Linux possuem pacotes de instalação do Valgrind. Na ausência desse pacote de instalação podemos fazer a instalação a partir do código fonte: –Acesse a máquina com conta de administrador (root) –Baixe o código fonte do Valgrind em: http://valgrind.org wget http://valgrind.org/downloads/valgrind-3.2.0.tar.bz2 –Descompacte os arquivos tar xvfj valgrind-3.2.0.tar.bz2 –Execute a seguinte seqüência de comandos cd valgrind-3.0.1/./configure make make install

106 106 Valgrind: Utilização básica  A utilização do Valgrind segue a seguinte sintaxe: –valgrind --tool= –onde é o nome da ferramenta que se deseja utilizar, ou seja: memcheck massif cachegrind callgrind helgrind –O Valgrind não requer a recompilação do programa, porém caso queira incluir informações extra recompile o programa com –g (debug info)

107 107 Valgrind/Memcheck: Exemplo de utilização (1)  Para a ferramenta Memcheck, que monitora a execução de um programa detectando possíveis problemas associados ao uso da memória, os procedimentos de uso da ferramenta são: –Para um programa que é comumente executado com: myprog arg1 arg2 –Utilize a seguinte linha de comando: valgrind --leak-check=yes myprog arg1 arg2 memcheck é a ferramenta padrão e a opção --leak-check ativa a verificação de vazamento de memória  Observação: o programa rodará de 20 a 30 vezes mais lento que o normal (1) este exemplo foi extraído do “quick start” no site do Valgrind

108 108 #include void f(void) { int* x = malloc(10 * sizeof(int)); x[10] = 0; // problem 1: heap block overrun // problem 2: memory leak -- x not freed } int main(void) { f(); return 0; } Valgrind/Memcheck: Interpretando os resultados Relatório correspondente: ==19182== Invalid write of size 4 ==19182== at 0x804838F: f (example.c:6) ==19182== by 0x80483AB: main (example.c:11) ==19182== Address 0x1BA45050 is 0 bytes after a block of size 40 alloc'd ==19182== at 0x1B8FF5CD: malloc (vg_replace_malloc.c:130) ==19182== by 0x8048385: f (example.c:5) ==19182== by 0x80483AB: main (example.c:11) Atribuição fora do limite do array x Memória não liberada

109 109 Valgrind/Massif: exemplo de utilização  A ferramenta Massif, um perfilador de memória que mede a quantidade de memória alocada pelo programa monitorado, os procedimentos de uso são: –Para um programa que é comumente executado com: myprog arg1 arg2 –Utilize a seguinte linha de comando: valgrind --tool=massif myprog arg1 arg2  Ao final serão gerados um relatório em texto e um gráfico de alocação de memória (ver o próximo slide)  Observação: o programa rodará mais lento que o habitual

110 110 Valgrind/Massif: Interpretando resultados Relatórios emitidos pelo Massif == 0 =========================== Heap allocation functions accounted for 50.8% of measured spacetime Called from: 22.1%22.1%: 0x401767D0: _nl_intern_locale_data (in /lib/i686/libc-2.3.2.so) 8.6%8.6%: 0x4017C393: read_alias_file (in /lib/i686/libc-2.3.2.so)...... (several entries omitted) and 6 other insignificant places Alocação suspeitaAlocação suspeita corrigida

111 TAU Tuning and Analysis Utilities

112 112 Entendendo o TAU  O TAU é uma sistema composto de diversos aplicativos de perfilagem e análise de softwares capaz de monitorar de diversas formas diferentes sistemas seriais ou paralelos (MPI e OpenMP);  Os recursos e modos de funcionamento do TAU dependem de como ele é configurado e dos pacotes dos quais ele faz uso;  O TAU possui diversas formas distintas de instrumentação: –MANUAL: através da utilização direta das rotinas de perfilagem disponibilizadas por sua biblioteca; –AUTOMÁTICA: através da utilização de um outro pacote chamado PDT (Program Database Toolkit) que fará a interpretação (parsing) e inserção das rotinas de perfilagem nos locais adequados; –DINÂMICA: através da utilização do sub-pacote Dyninst. Nesse modo o TAU monitora os softwares em runtime sem a necessidade de recompilação;

113 113 Alguns componentes do TAU  PDT (Program Database Toolkit) –Preprocessa, interpreta e insere as rotinas de perfilagem  Opari (OpenMP Pragma And Region Instrumentor) –Instrumentação de códigos em OpenMP  PCL (Performance Counter Library) –Interface para acesso aos contadores de hardware  PAPI (Performance data standard and API) –Interface para acesso aos contadores de hardware  Dyninst –Instrumentador dinâmico  VTF3 –Interface para geração de arquivos de tracing para o Vampir  SLOG2 –Interface para geração de arquivos de tracing para o Jumpshot  EPILOG –Interface para geração de arquivos de tracing para o Expert

114 114 Exemplo de instalação do TAU  A seguir ilustraremos uma possibilidade de configuração básica do TAU: –Para esse exemplo necessitaremos primeiramente da compilação das bibliotecas PAPI e PDT  PAPI (Performance data standard and API): wget http://icl.cs.utk.edu/projects/papi/downloads/papi-3.2.1.tar.gz tar xvfz papi-3.2.1.tar.gz cd papi-3.2.1/src./configure –prefix=diretorio/de/instalacao/do/papi make make install  Adicione a biblioteca do PAPI ao LD_LIBRARY_PATH de usuário setenv LD_LIBRARY_PATH ${LD_LIBRARY_PATH}:diretorio/de/instalacao/do/papi/lib ou para o shell bash export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:diretorio/de/instalacao/do/papi/lib

115 115 Exemplo de instalação do TAU (cont.)  PDT (Program Database Toolkit) Baixe os arquivos do PDT em http://www.cs.uoregon.edu/research/pdt cd pdtoolkit-3.9./configure -prefix=/diretorio/de/instalacao/do/pdt make make install  Após a instalação, adicione os binários do PDT ao PATH de usuário (ou de sistema) setenv PATH ${PATH}:/diretorio/de/instalacao/do/pdt/sistema/bin ou para o shell bash export PATH=${PATH}:/diretorio/de/instalacao/do/pdt/sistema/bin

116 116 Finalmente, a compilação do TAU  Existe um utilitário em interface gráfica chamado tau_setup que auxilia na configuração do TAU  Baixe os arquivos em: http://www.cs.uoregon.edu/research/tau/ tar xvfz tau_latest.tar.gz cd tau-2.15.5/./configure -prefix=/diretorio/de/instalacao/do/tau \ -c++=g++ \ -cc=gcc \ -fortran=intel \ -mpi \ -mpiinc=/usr/local/mpich-1.2.6/include \ -mpilib=/usr/local/mpich-1.2.6/lib \ -pdt=/diretorio/de/instalacao/do/pdt \ -papi=/diretorio/de/instalacao/do/papi \ -LINUXTIMERS \ -PAPIWALLCLOCK \ -PROFILE -TRACE make install

117 117 Após a compilação do TAU  Os executáveis do visualizador ParaDyn, o banco de dados perfexplorer e os demais scripts de conversão dos arquivos do TAU para outros softwares (VAMPIR, JUMPSHOT, etc...) estarão do diretório “bin” do TAU  A biblioteca assim como o Makefile que dá acesso aos recursos do TAU estarão no diretório “lib”. Para o exemplo anterior, será gerado o seguinte makefile: Makefile.tau-linuxtimers-papiwallclock-mpi-papi-pdt-profile-trace

118 118 Usando o TAU  Forma automática: –O código-fonte é pré-processado e as rotinas de perfilagem são inseridas sem a intervenção do programador; –Para que isso ocorra teremos de fazer algumas modificações no processo de compilação (normalmente essas modificações são feitas no Makefile) –Veja um exemplo de Makefile no próximo slide:

119 119 Exemplo de Makefile utilizando o TAU # Inclusão do Makefile do TAU para podermos acessar os recursos do software include Makefile.tau-linuxtimers-papiwallclock-mpi-papi-pdt-profile-trace... # Definição do compilador #F90= mpif90 F90 = $(TAU_COMPILER) -optPdtGnuFortranParser -optPreProcess -optKeepFiles ifort... # includes #INCLUDE= INCLUDE= $(TAU_MPI_INCLUDE)... # Flags de compilação #LFLAGS= LFLAGS= $(TAU_MPI_FLIBS) $(TAU_LIBS) $(TAU_LDFLAGS) $(TAU_FORTRANLIBS)... O código fonte com a instrumentação será gerado e a execução do programa criará os arquivos de perfilagem de acordo com o Makefile (TAU) utilizado no include e recursos compilados com o TAU

120 120 TAU: Resultados que podem ser obtidos Call graph Custo de funções por processo ParaDYN

121 121 TAU: Resultados que podem ser obtidos ParaDYN