Java tem dessas coisas...
O javac tem uma opção -O que otimiza o bytecode. Já tentou isso ???
[]'s
Sergio
>From: Sven van ´t Veer <[EMAIL PROTECTED]>
>Reply-To: [EMAIL PROTECTED]
>To: [EMAIL PROTECTED]
>Subject: [java-list] Engraçado : QuickSort em Java & Optimalizacão em Java
>Date: Thu, 03 May 2001 09:30:57 -0300
>
>Em relação de QuickSort, mandei uma modificação do metodo swap ontem:
> private void swap(int a[], int i, int j){
> a[i] ^= a[j];
> a[j] ^= a[i];
> a[i] ^= a[j];
> }
>em vez de:
> private void swap(int a[], int i, int j){
> int T = a[i];
> a[i] = a[j];
> a[j] = T;
> }
>
>O primeiro exemplo em C/C++ é muito mais rapido que o segundo (em
>assembler são 6 a 8 operações a menos). Ai fez um teste em Java e o
>resultado é exatamente o oposto, quase o dobro de linhas em byecode.
>
>Veja abaixo: (swaptemp utiliza a variavel temporaria T)
>private void swaptemp(int a[], int i, int j)
> {
> // 0 0:aload_1
> // 1 1:iload_2
> // 2 2:iaload
> // 3 3:istore 4
> // 4 5:aload_1
> // 5 6:iload_2
> // 6 7:aload_1
> // 7 8:iload_3
> // 8 9:iaload
> // 9 10:iastore
> // 10 11:aload_1
> // 11 12:iload_3
> // 12 13:iload 4
> // 13 15:iastore
> // 14 16:return
> }
>
> private void swap(int a[], int i, int j)
> {
> // 0 0:aload_1
> // 1 1:iload_2
> // 2 2:dup2
> // 3 3:iaload
> // 4 4:aload_1
> // 5 5:iload_3
> // 6 6:iaload
> // 7 7:ixor
> // 8 8:iastore
> // 9 9:aload_1
> // 10 10:iload_3
> // 11 11:dup2
> // 12 12:iaload
> // 13 13:aload_1
> // 14 14:iload_2
> // 15 15:iaload
> // 16 16:ixor
> // 17 17:iastore
> // 18 18:aload_1
> // 19 19:iload_2
> // 20 20:dup2
> // 21 21:iaload
> // 22 22:aload_1
> // 23 23:iload_3
> // 24 24:iaload
> // 25 25:ixor
> // 26 26:iastore
> // 27 27:return
> }
>}
>
>com este resultado na mão fize um terceiro teste:
> private void swap2(int a[], int i, int j){
> a[i] = a[i] ^ a[j];
> a[j] = a[j] ^ a[i];
> a[i] = a[i] ^ a[j];
> }
>
>Isso é igual a :
> private void swap(int a[], int i, int j){
> a[i] ^= a[j];
> a[j] ^= a[i];
> a[i] ^= a[j];
> }
>e porém deveria gerar os mesmos bytecodes, mas o resultado é pior ainda:
>private void swap2(int a[], int i, int j)
> {
> // 0 0:aload_1
> // 1 1:iload_2
> // 2 2:aload_1
> // 3 3:iload_2
> // 4 4:iaload
> // 5 5:aload_1
> // 6 6:iload_3
> // 7 7:iaload
> // 8 8:ixor
> // 9 9:iastore
> // 10 10:aload_1
> // 11 11:iload_3
> // 12 12:aload_1
> // 13 13:iload_3
> // 14 14:iaload
> // 15 15:aload_1
> // 16 16:iload_2
> // 17 17:iaload
> // 18 18:ixor
> // 19 19:iastore
> // 20 20:aload_1
> // 21 21:iload_2
> // 22 22:aload_1
> // 23 23:iload_2
> // 24 24:iaload
> // 25 25:aload_1
> // 26 26:iload_3
> // 27 27:iaload
> // 28 28:ixor
> // 29 29:iastore
> // 30 30:return
> }
>
>Será que java não pode fazer otimalizações ??
>
>sven
>
>
>------------------------------ LISTA SOUJAVA ----------------------------
>http://www.soujava.org.br - Sociedade de Usuários Java da Sucesu-SP
>dúvidas mais comuns: http://www.soujava.org.br/faq.htm
>regras da lista: http://www.soujava.org.br/regras.htm
>para sair da lista: envie email para [EMAIL PROTECTED]
>-------------------------------------------------------------------------
>
_________________________________________________________________________
Get Your Private, Free E-mail from MSN Hotmail at http://www.hotmail.com.
------------------------------ LISTA SOUJAVA ----------------------------
http://www.soujava.org.br - Sociedade de Usuários Java da Sucesu-SP
dúvidas mais comuns: http://www.soujava.org.br/faq.htm
regras da lista: http://www.soujava.org.br/regras.htm
para sair da lista: envie email para [EMAIL PROTECTED]
-------------------------------------------------------------------------
