Computadores e Programação (MAB ) Lista 2 - Grupo de até 3 alunos - 90 pontos

Transcrição

1 Computadores e Programação (MAB ) Lista 2 - Grupo de até 3 alunos - 90 pontos Entrega impressa em sala de aula até o dia 04 de maio (mesmo limite da lista1). Grupo: GABARITO... Questão 1 (45 pontos) Preencha o que foi apagado (pode ser expressão lógica ou aritmética complexa ou comando) do código C abaixo, fazendo a engenharia reversa sobre o código de montagem. int foo(int a, int b,... p){ if (...) urn...; else... (...) urn...; urn...; int foo(int a, int b, int* p){ if (a < b && a > *p) urn (a-b)*(a-*p); else if ((a==b) (a == *p)) urn 0; urn (b-a) * ( *p - a); Ao compilar, foi gerado o código de montagem abaixo: foo: salva %ebx pois irá usá-lo... movl 8(%esp), %ecx pega a... movl 12(%esp), %ebx pega b... cmpl %ebx, %ecx faz a-b... jge.l2 desvia se a >= b ou continua se (a < b)... movl 16(%esp), %eax pega p... movl (%eax), %edx pega *p... cmpl %edx, %ecx faz a-*p... jg.l9 desvia se a>*p,i.e. (a>*p && a<b) ou continua cmpl %edx, %ecx faz a-*p... je.l6 desvia se for igual para ornar 0....L10: movl %ebx, %eax pega b... subl %ecx, %edx faz (*p-a)... subl %ecx, %eax faz b-a... imull %edx, %eax (b-a)*(*p-a) ou (a-b)*(a-*p) como orno....l4: restaura %ebx... orna... 1

2 .L2: movl $0, %eax.prepara orno com 0... je.l4 se (a==b) desvia para ornar 0... movl 16(%esp), %eax pega p... movl (%eax), %edx pega *p... cmpl %edx, %ecx faz a -*p... jne.l10 desvia de a!=*p, ou continua se (a==*p) para ornar 0.L6: xorl %eax, %eax zera valor de orno... restaura %ebx... orna....l9: movl %ecx, %eax pega a... subl %edx, %ecx faz a-*p... subl %ebx, %eax a-b... imull %ecx, %eax (a-b)*(a-*p) como orno... restaura %ebx... orna... a) (15) Comente cada linha do código de montagem referente à rotina foo. Cada linha do código de montagem terá que ser associada ao código C ou justificada sua presença. b) (5) Dê argumentos para justificar se a compilação foi feita com otimização ou não. R: A compilação foi feita com otimização, pois quando entramos na rotina não é criado um registro de ativação. Oberva-se ainda que o código de montagem não segue exatamente o código C, demonstrando alguma otimização, já que não há repetição de busca de valores e há uso racional dos regiatradores. c) (5) Entre duas linhas do código de montagem aparecem as linhas abaixo. Explique o que acontecerá em termos de alinhamento do código que segue as ditas linhas..p2align 4,,10.p2align 3 R: A primeira diiva irá alinhar em múltiplos de 16 caso não precise pular mais de 10 bytes. Também é indicado o preenchimento default para os bytes pulados, já que nada é especificado. Se tiver que pular mais de 10 bytes, alinha-se em múltiplo de 8. Então, teremos um alinhamento em múltiplo de 16 ou de 8. d) (5) Justifique o tipo do parâmetro p da rotina. R: Como o parâmetro é usado como endereço num movl, então ele é um ponteiro para inteiro. e) (15) Faça a engenharia reversa do código C, preenchendo as lacunas. Questão 2 (20 pontos) Seja dada rotina C: int var_prod (int N, int M, int A[M][N], int B[N][M], int i, int k){ int j; int result = 0; if (i < M && k < M) { for (j=0;j<n;j++) result += A[i][j] * B[j][k]; 2

3 urn result; Compile com -O2 -S e gere o código de montagem otimizado. Elimine todas as linhas que são diivas do GCC iniciando com ponto. Deixe apenas as linhas correspondentes às instruções da rotina até o seu orno. Comente todas as linhas deste código e interpe o que está sendo executado com base no código C. var_prod: pushl %ebp // salva ebp pushl %edi // salva edi // salva esi // salva ebx movl 24(%esp), %edi // pega M movl 36(%esp), %esi // pega i movl 20(%esp), %ebp // pega N movl 40(%esp), %eax // pega k cmpl %esi, %edi // faz M-i jle.l5 // continua de M > i cmpl %eax, %edi // faz M-k jle.l5 // continua de M > k testl %ebp, %ebp // testa N jle.l5 // continua se N > 0 sall $2, %esi // calcula 4*i movl 32(%esp), %edx // pega B sall $2, %edi // calcula 4*M imull %ebp, %esi // N*4*i addl 28(%esp), %esi // A + N*4*i => %esi é ponteiro para a linha i de A leal (%edx,%eax,4), %ebx // B+4*k => %ebx é ponteiro para a coluna k de B xorl %eax, %eax // zera %eax, usará para orno xorl %edx, %edx // zera %edx, usará como índice j=0.l3: movl (%esi,%edx,4), %ecx // pega A+ 4*j + N*4*i, ou seja, A[i][j] addl $1, %edx // incrementa j imull (%ebx), %ecx // A[i][j]*B[j][k] addl %edi, %ebx // B+4*k+4*M, ou seja, próximo elemento da coluna k addl %ecx, %eax // acumula produto em eax cmpl %edx, %ebp // faz N-j jne.l3 // enquanto j for menor, desvia // restaura %edi // restaura %ebp // orna.l5: // restaura ebx xorl %eax, %eax // zera orno // restaura esi // restaura edi // restaura ebp // orna Questão 3 (25 pontos) Seja agora dado o código: #define N 6 3

4 typedef int fix_matrix[n][n]; int fix_prod_ele (fix_matrix A, fix_matrix B, int i, int k){ int j; int result = 0; for (j=0;j<n;j++) result += A[i][j] * B[j][k]; urn result; a) (10) Compile o código acima com -m32 -S -O2. Elimine todas as diivas do GCC (linhas inciadas com ponto), deixando apenas o código básico da rotina. Comente cada linha e associe ao código C. Verifique que este código ainda usa os desvios condicionais. Se não usar, diminua a otimização. fix_prod_ele: movl 20(%esp), %eax // pega i leal (%eax,%eax,2), %edx // 3*i movl 12(%esp), %eax // pega A leal (%eax,%edx,8), %edx // 24*i + A movl 24(%esp), %eax // pega k leal 24(%edx), %esi // A+ 24*i + 24, limite leal 0(,%eax,4), %ebx // 4*k addl 16(%esp), %ebx // B + 4*k => ponteiro para coluna k de B xorl %eax, %eax // zera %eax.l2: movl (%edx), %ecx // pega A[i][j], começando com j=0 addl $4, %edx // A+24*i + 4, &A[i][j+1], aponta para o próximo elemento da linha i de A addl $24, %ebx // B+4*k+24, &B[j+1][k], aponta para o próximo da coluna k de B imull -24(%ebx), %ecx // A[i][j]*B[j][k], multiplica os valores anteriores addl %ecx, %eax // acumula soma em %eax cmpl %edx, %esi // compara j com 6 na lógica do loop jne.l2 // se ainda n~ao chegou, orna ao loop b) (10) Repita agora a compilação usando -m32 -S -O3. Elimine todas as diivas do GCC (linhas inciadas com ponto), deixando apenas o código básico da rotina. Comente cada linha e associe ao código C. Esta otimização deve ser suficiente para gerar um assembler bem diferente do anterior, onde os testes condicionais foram suprimidos. Se por acaso em sua máquina isso não acontecer, use uma otimização maior. fix_prod_ele: pushl %ebp pushl %edi movl 28(%esp), %edx // pega i movl 32(%esp), %eax // pega k movl 24(%esp), %edi // pega B leal (%edx,%edx,2), %esi // calcula 3*i movl 20(%esp), %edx // pega A leal 0(,%eax,4), %ebp // calcula 4*k movl (%edi,%eax,4), %eax // pega B[0][k] 4

5 movl 24(%edi,%ebp), %ebx // pega B[1][k] movl 48(%edi,%ebp), %ecx // pega B[2][k] leal (%edx,%esi,8), %esi // calcula A+24*i => &A[i][0] movl 72(%edi,%ebp), %edx // pega B[3][k] imull 4(%esi), %ebx // A[i][1]*B[1][k] imull (%esi), %eax // A[i][0]*B[0][k] imull 8(%esi), %ecx // A[i][2]*B[2][k] imull 12(%esi), %edx // A[i][3]*b[3][k] addl %ebx, %eax // A[i][0]*B[0][k]+A[i][1]*B[1][k] leal (%ecx,%eax), %ebx // A[i][0]*B[0][k]+A[i][1]*B[1][k]+A[i][2]*B[2][k] movl 96(%edi,%ebp), %eax // pega B+4*24+4*k => B[4][k] imull 16(%esi), %eax // A[i][4]*B[4][k] leal (%edx,%ebx), %ecx // A[i][0]*B[0][k]+A[i][1]*B[1][k]+A[i][2]*B[2][k]+A[i][3]*b[3][k] leal (%eax,%ecx), %edx // acumula os 5 primeiros produtos movl 120(%edi,%ebp), %eax // B[5][k] imull 20(%esi), %eax // A[i][5]*B[5][k] // restaura %edi // restaura %ebp addl %edx, %eax // acumula os 6 produtos em %eax, pronto para orno // orna c) (5) Tente justificar a otimização feita pelo GCC, pensando na eficiência da execução. R: Como otimização, o GCC elemina o teste de desvio e calcula todos os elementos da soma e os soma dois a dois. Como o tamanho da matriz é conhecido, 6x6, então os elementos da soma também estão determinados, o que possibilita a otimização. Sem otimização, na rotina são executadas 56 instruções (42 no laço e 14 fora do laço). Das instruções fora do laço, 9 acessam a memória. No laço temos 7 instruções sendo executadas, sendo duas de acesso a a memória e 4 de adição. Assim, sem otimização, temos 21 acessos à memória, do total de 56 instruções. Com otimização, são executadas 33 instruções, sendo 25 com acesso à memória. Basicamente alguns acessos extras foram feitos para salvar registradores e restaurá-los ao final, pois temos que usar mais registradores. 5