A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

Módulo IV Técnicas de Otimização I Otimizações Gerais usando uma Linguagem Compilada.

Apresentações semelhantes


Apresentação em tema: "Módulo IV Técnicas de Otimização I Otimizações Gerais usando uma Linguagem Compilada."— Transcrição da apresentação:

1 Módulo IV Técnicas de Otimização I Otimizações Gerais usando uma Linguagem Compilada

2 Computação de Constantes no Laço LoopInvar(int size,int step,int ratio) { int gradient; for ( i = 0; i < size/step; i += step ) { gradient = step*ratio; sort[i] *= gradient; } return; } Este cálculo é uma constante, mas o compilador o trata como uma equação qualquer, processando-a a cada iteração no laço O compilador não consegue otimizar esta operação, assim temos um valor constante sendo calculado sempre e sem necessidade

3 Computação de Constantes em Laços LoopInvar(int size,int step,int ratio) { int gradient; int limit; gradient = step * ratio; limit = size/step; for ( i = 0; i < limit; i += step ) { sort[i] *= gradient; } return; } Uso de variáveis temporárias pode ajudar o compilador na otimização do código

4 Computação de Constantes em Laços: Desvios (Branches) InvarBranch(int size, int mode, int offset){ for (int i = 0; i < size; i += 1) if (mode & DIV_OFST) data[i] /= offset; else data[i] += offset; return; } Desvios no código não combinam com desempenho, então por que fazer um desvio a cada passo dentro do laço? O valor de mode pode mudar a cada chamada dessa função, mas não dentro do laço. Uma vez dentro do laço, toda iteração é igual, não precisamos do desvio

5 Computação de Constantes em Laços: Desvios (Branches) InvarBranch(int size, int mode, int offset) { if (mode & DIV_OFST) for (i = 0; i < size; i += 1) data[i] /= offset; else for (i = 0; i < size; i += 1) data[i] += offset; return; } Mais código, menos intuitivo e mais rápido!

6 Laços com Contagem: Decrementando em um Laço CountDown(int size) { int i; for (i = 0; i < size; i++) array[i] = 0; return; } É mais simples para o processador comparar a variável i com zero!

7 Laços com Contagem: Um Solução CountDown(int size) { int i; for (i = size-1; i >= 0; i--) array[i] = 0; return; } A comparação com zero é mais eficiente, no decremento ao passar por zero o indicador de zero do processador é ativado, nenhuma comparação é necessária com outro valor para resolver esta condição

8 Agrupando Variáveis int ClusterVar( int offset, int ratio, int size) { int i, gradient, delta; gradient = offset * ratio; for (i = 0; i < size; i++) array[i] = 0; delta = offset – ratio; return delta + gradiente; } delta também é calculado pelos valores de offset e ratio gradient é calculado pelos valores de offset e ratio

9 Agrupando Variáveis de maneira Eficiente int ClusterVar(int offset, int ratio, int size){ int i, gradient, delta; for ( i = 0; i < size; i++) array[i] = 0; gradient = offset * ratio; delta = offset – ratio; return delta + gradiente; } A utilização agrupada das variáveis facilita a tarefa de otimização ao compilador

10 Interpretando e Simplificando uma Função int IsEven(int value) { int result; result = value / 2; if (result * 2 == value) return 1; else return 0; } O objetivo desta função é determinar se o parâmetro é par. Se for retorna 1.

11 Uma Solução mais Simples int IsEven(int value) { return !(value & 0x1); } Toda representação binária de um número par termina com zero e esta função utiliza esse fato

12 Simplificando ainda mais __inline int IsEven(int value) { return (~value)&0x1; } Agora a função é tão simples que devemos considerar o uso de inline ou macro

13 Inlining Otimização muito oportuna para eliminar a sobrecarga da chamada e do retorno de uma função int IsEven(int value) { int result; result = value / 2; if ( result * 2 == value ) { return 1; } else { return 0; } int IsEven(int value) { return (~value)&0x1; } __inline int IsEven(int value) { return (~value)&0x1; } Simplificando Usando __inline na função

14 Ponteiros: Indexação BasePtr(int *ptr, int *cmask, int section, int limit) { int i; for (i = 0; i < limit; i++) { *(ptr + section * secsize + i) &= *cmask; cmask++; } return; } Uma parte do cálculo deste ponteiro não varia dentro deste laço, logo é possível implementações mais eficientes

15 Ponteiros: Indexação BasePtr(int *ptr, int *cmask, int section, int limit) { int *auxptr, i; auxptr = ptr + section * secsize; for (i = 0; i < limit; i++) { *(auxptr + i ) &= *cmask; cmask++; } return; } Calculando a parte do ponteiro que é independente de qualquer valor do laço, resta uma parte de cálculo bem mais simples para ser executada dentro dele. Poderíamos ir além dessa otimização?

16 Ponteiros: Mais otimizações int BasePtr(int *ptr,int *cmask, int section,int limit) { int i; int *auxptr; auxptr = ptr + section * secsize; auxptr += limit – 1; cmask += limit – 1; for ( i = limit - 1; i >=; 0 i-- ) *(auxptr--) &= *(cmask--); return; } Ajustamos nossos ponteiros para o último elemento, assim podemos contar decrementando Fazer o laço decrementar até zero tira vantagem do conjunto de instruções do processador ARM Pós-decremento dos ponteiros torna mais fácil para o compilador o uso de instruções de load/store com pós-decremento.

17 Redução de Desvios (Branches) Void MultBranch(void) { //iniciação de mask e shiftbits if (mode & TRANSPNT ) { mask = 0x0110; shiftbits = 4; } else { mask = 0x1100; shiftbits = 8; } //ajustando limite limit = 5; if (mode & TRANSPNT) limit = 9;... Existe alguma maneira de reduzirmos os ifs e os desvio? Iniciação de shiftbits e mask Iniciação de limit

18 Redução de Desvios (Branches) void MultBranch(void) { //iniciação de mask, shiftbits e limit if (mode & TRANSPNT ) { limit = 5; mask = 0x0110; shiftbits = 4; } else { limit = 9; mask = 0x1100; shiftbits = 8; }... Evitar desvios em um código é uma prática saudável! Iniciação de shiftbits e mask, além de alterar o valor de limit, tudo em um só if.

19 Localidade de Referência de Memória int Image[128][128]; void ImageFilter(void) { int i, j, k, sum; // Percorre as colunas for ( i = 0; i < 128; i++ ) { sum = 0; for ( j = 0; j < 128; j++ ) { sum = 0; for ( k = 0; k < 8; k++ ) { sum += Image[j][i] * filter[j]; } Image[j][i] = sum; } // Percorre as linhas for ( i = 0; i < 128; i++ ) Estamos percorrendo a matriz imagem pela coluna, embora ela seja armazenada na memória em função de suas linhas Pensando como os dados são armazenados na cache vemos que essa não é uma boa maneira de se trabalhar com um array...

20 Localidade de Referência de Memória TransmuteArray(Image,0); for ( i = 0; i < 128; i++ ) { sum = 0; for ( j = 0; j < 128; j++ ) { sum = 0; for ( k = 0; k < 8; k++ ) sum += Image[i][j] * filter[j]; Image[i][j] = sum; } TransmuteArray(Image,1); Essa é uma maneira muito mais eficiente de se percorrer a matriz Reordene a matriz antes de processá-la de maneira a transpor as linhas pelas colunas. Depois re- processe novamente a matriz

21 Uso Eficiente de Bibliotecas void OutputMethod(HANDLE JavaSource, HANDLE JavaBin) { unsigned char BCode; int EndMethod; EndMethod = 0; while( !EndMethod ) { EndMethod = GenByteCode(JavaSource, &BCode); write(JavaBin,&BCode,1); } A rotina write é chamada para todos os bytecodes pela JIT A função write realiza várias verificações no handle do arquivo e no seu estado (e faz isso a cada chamada da função) Ela pode armazenar ou não as escritas internamente

22 Uso Eficiente de Bibliotecas - Otimização #define BSIZE 128 void OutputMethod( HANDLE JavaSource, HANDLE JavaBin) { unsigned char *pBuff; unsigned char buffer[BSIZE]; int BuffLeft; int EndMethod; /* write out bytecodes till we reach the end of method */ EndMethod = 0; pBuff = buffer; BuffLeft = BSIZE; while( !EndMethod ) { EndMethod = GenByteCode(JavaSource, &BCode); *pBuff++ = BCode; if (BuffLeft-- <= 0 ) { write(JavaBin,buffer,BSIZE); BuffLeft = BSIZE; pBuff = buffer; } } // end of while… if ( BuffLeft < BSIZE ) { write(JavaBin,buffer, BSIZE – BuffLeft); } } // end of function OutputMethod

23 EndMethod = GenByteCode(JavaSource, &BCode); *pBuff++ = BCode; if (BuffLeft-- <= 0 ) { write(JavaBin,buffer,BSIZE); BuffLeft = BSIZE; pBuff = buffer; } } // end of while… if ( BuffLeft < BSIZE ) { write(JavaBin,buffer, BSIZE – BuffLeft); } } // end of function OutputMethod Uso Eficiente de Bibliotecas - Otimização Agora a função write é usada muito mais eficientemente Veja que a variável BuffLeft é decrementada até Zero Observe esse ponteiro pós-incrementado: Uma única instrução assembly STR é capaz de armazenar e atualizar o ponteiro

24 Uso Eficiente de Bibliotecas Use cada função com mais eficiência, pois fazer menos chamadas implica: Menor sobrecarga da chamada da função Menor sobrecarga de verificação de erros Menos acessos a dispositivos físicos Compreenda as limitações dos dispositivos Eficiência na escrita em Flash Limitação da Biblioteca

25 Desenrolamento de Laço void LoopUnRoll(int limit,int translate) { int i; for ( i = 0; i < limit, i++ ) { array[i] += translate; } A sobrecarga para percorrer o laço prejudica o desempenho! De 2 a 3 instruções a cada iteração do laço do for De 3 a 4 instruções para executar o corpo do laço

26 Implementação do Desenrolamento de Laço void LoopUnRoll(int limit,int translate) { int i; for ( i = 0; i < limit, i += 4 ) { array[i] += translate; array[i + 1] += translate; array[i + 2] += translate; array[i + 3] += translate; } E a escrita consegutiva para dados contíguos pode aproveitar mais uma característica do processador XScale: Write Coalescing De 2 a 3 instruções a cada iteração do laço do for De 12 a 16 instruções para executar o corpo do laço

27 Usando Comentários no Código como Técnica de Medição Se você gostaria de saber o quanto uma linha ou pedaço de código contribuem para o desempenho de execução de uma função... Considere comentar a linha ou bloco de código a ser analisado. Tenha certeza que o código ao redor não é demasiadamente sem importância a ponto do otimizador do compilador simplesmente descartá-lo. Substitua algo muito simples que o compilador não possa otimizar.

28 Usando Comentários no Código como Técnica de Medição Sx = 0; for ( col = 0; col < numCols; col++) { for ( row = 3; row < (numRows – 3);row++) { ploc1 = in + (row*numCols + col); ploc2 = ploc1 + 1; Kr = ((*(ploc1-adj3)... Ks = ((*(ploc2 – adj3).... } if (Kr < 0 ) Kr = -Kr; if (Ks < 0 ) Ks = -Ks; // Sx += (S16Word)sqrt( Kr +Ks ); Sx += Kr + Ks; } Exemplo: Comente a linha que contém sqrt Substitua esta linha com algo que evite que o compilador altere drasticamente o código compilado.

29 Módulo IV Técnicas de Otimização II

30 O que é PreLoad? PreLoad coloca o dado a ser utilizado pelo processador dentro da memória cache. Suporte na extensão ARM.v5 DSP do compilador Microsoft na versão 4.0 Dado um endereço, o PreLoad inicia a carga dos 32 bytes da memória que inclui o endereço para a memória cache.

31 O que é PreLoad? Os 5 bits inferiores de endereço são ignorados, desde que as linhas da cache são alinhadas em 32 bytes. Não há o conceito de largura. Não se pode carregar o conteúdo de um valor de tamanho maior que 32 bytes usando PreLoad, pois ele ultrapassa o tamanho da linha de cache (32 bytes). Leitura sem atribuição para um registrador de destino, não ocupa o pend buffer. Endereços inválidos de memória não geram exceções, são ignorados.

32 Quando o PreLoad é eficiente? Quando o processamento de dados contíguos são repetido dentro de um laço Quando o endereço de elementos em uma iteração posterior são facilmente determinados O dado provavelmente não está na cache É muito grande em bytes para caber inteiro na cache O dado não foi recentemente gerado ou preparado em outro estágio

33 Por que usar PreLoad? Buscar um dado na memória é uma operação cara em qualquer tipo de processador Dados presentes na memória cache são manipulados mais rapidamente PreLoad busca o dado e o coloca na cache. Se bem usado, pode economizar tempo do processador na utilização de um dado da memória

34 PreLoad irá ajudar? Utilize o VTune Procure por funções onde há uma taxa alta de cache miss Taxa alta de Cache Miss Cache Miss = 28,76%

35 Alterações no Código para Incrementar a Eficiência de PreLoad Otimize o uso da Cache Os dados devem preferencialmente estar próximos na memória Use dados em posições contíguas de memória Para listas encadeadas, onde todos os elementos estão embaralhados Use um ponteiro especial que aponta para n elementos a frente

36 Alterações no Código para Incrementar a Eficiência de PreLoad Para matrizes de estruturas onde somente alguns membros são usados em algum laço Faça duas matrizes de estruturas, com os membros mais usados em uma estrutura e o resto em outra matriz Permite que as estruturas com os dados usados mais freqüentemente fiquem contidas em uma única linha da memória cache

37 Ajustando o PreLoad Quantos dados devem ser colocados na cache por antecipação de uso? Tente usar o método empírico Depende da complexidade do código executado no laço entre sucessivas execuções do PreLoad O PreLoad deve carregar os dados na cache com 40 a 80 clocks de instrução antes de usá-los Faça do valor de antecipação do PreLoad uma constante que possa ser alterada no seu código

38 Eficiência máxima do PreLoad Melhor se houve apenas um PreLoad por linha de cache (Tempo do processamento por item de dado) * (Número de itens por linha de cache) deve ser aproximadamente tempo de acesso externo Senão, faça PreLoad no número apropriado de linhas de cache Não exceda 4 linhas com PreLoad de uma vez Linha de cacheVia 31 DadosEnder. Linha de cacheVia 1 Linha de cacheVia 0 32 conjuntos

39 Eficiência máxima do PreLoad Considere que outros dados também receberão acesso (leitura e escrita à memória). Lembre-se do fill buffer. A taxa de alimentação deve ser igual a taxa de consumo Se o tempo de processamento por uma linha de cache é menor do que o tempo entre PreLoads, então é necessário fazer o PreLoad de um endereço mais a frente

40 Riscos ao Usar o PreLoad A instrução de PreLoad consome um ciclo de clock, se ele não melhorar o desempenho, ele poderá piorá-lo Evite algoritmos que demandem muito custo computacional para descobrir qual endereço que o PreLoad usará Não exagere no uso de PreLoad colocando-o em todo o código, pois ele também usa um buffer de preenchimento O processador ficará em espera se o buffer de preenchimento estiver cheio

41 Exemplo de PreLoad void __PreLoad(void *ptr); void UsePreLoad(int array[], int limit) { int i; for (i = 0; i < limit; i++) { /*Carrega elemento antecipadamente 10 iterações a frente*/ __PreLoad(&(array[i+10])); /* Código de processamento do array[i] aqui */ } return; } Inclua o Protótipo PreLoad chamado para carregar na cache elementos do array com 10 iterações de antecedência PreLoad será chamado a cada iteração do laço mesmo que o elemento do array já esteja na linha da cache.

42 Exemplo de PreLoad: Melhoria void __PreLoad(void *ptr); void UsePreLoad(int array[], int limit){ int i; for (i = 0; i < limit; i +=8) { /*Carrega elemento antecipadamente 10 iterações a frente*/ __PreLoad(&(array[i+10])); /* código para array[i]*/ /* código para array[i+1]*/ /* código para array[i+2]*/ /* código para array[i+3]*/ /* código para array[i+4]*/ /* código para array[i+5]*/ /* código para array[i+6]*/ /* código para array[i+7]*/ } return; } O laço é estendido para poder processar todos os elementos do vetor que estão presentes na linha de cache carregada da memória Isso reduz o número de chamadas que são feitas ao PreLoad com o dado já presente na linha de cache

43 Use PreLoad cuidadosamente O bom senso é necessário para balancear quantos itens estão presentes na linha de cache, qual o tempo para processar os elementos na linha de cache determinar o futuro uso de memória que PreLoad precisa carregar qual o tempo necessário para a carga da cache Se o PreLoad for chamado a cada iteração do laço carregando linhas da cache não necessárias, junto aos acessos normais do processamento, poderá resultar em esperas devido a falta de entradas vazias no buffer de preenchimento

44 Módulo IV Laboratório


Carregar ppt "Módulo IV Técnicas de Otimização I Otimizações Gerais usando uma Linguagem Compilada."

Apresentações semelhantes


Anúncios Google