OPTIMIZACION LOCAL

La optimización local se realiza sobre módulos del programa. En la mayoría de las

ocasiones a través de funciones, métodos, procedimientos, clases, etc.

 Folding: remplaza las expresiones por su resultado cuando se pueden

evaluar en tiempo de compilación.

CODIGO NO OPTIMIZADO CODIGO OPTIMIZADO

int a; int a;
int b; int b;
int c; int c;

public int Suma () { public int Suma () {

a = 2 + 5 + 6 + a + b + c; a = 13+ a + b + c;
return a; return a;
} }

 Propagación de constantes: se le considera a la variable el valor de la

constante.

CODIGO NO OPTIMIZADO CODIGO OPTIMIZADO

int a=0; int a=10;

int b=0; int b=10;
int c=0; int c=0;

public int Suma () public int Suma ()

{ {
a = 10; c = a + b;
b = 10 + a; return c;
c = a + b; }
return c;
}

 Reducción de potencia: se busca la sustitución de operaciones más costosas

como es el producto por otras más simples como la suma.
 CODIGO NO OPTIMIZADO CODIGO OPTIMIZADO
int a; int a;
int b; int b;

public int Operación () { public int Operación () {

b=a*5; b=a + a + a + a + a;
return b; return b;
} }

 Reducción de subexpresiones comunes: las subexpresiones que aparecen

más de una vez se calculan una sola vez y se reutiliza el resultado.

CODIGO NO OPTIMIZADO CODIGO OPTIMIZADO

int a; int a;
int b = 20; int b = 20;
int c = 5; int c = 5;
int d; int resultado;
int resultado;

public int Operación () { public int Operación () {

a = ((25 / c) * b) + 55; a = (25 / c) * b;
d = ((25 / c) * b) + 15; resultado = (a+ 55) + (a + 15);
resultado = (((25 / c) * b) + 55) + return resultado;
(((25 / c) * b) + 15); }
return resultado;
}

 Ejecución en tiempo de compilación: Pre-calcula expresiones constantes

(con constantes o variables cuyo valor no cambia)

CODIGO NO OPTIMIZADO CODIGO OPTIMIZADO

int resultado; int resultado;

public int Operación (int numero) public int Operación (int numero)
{ {
resultado = numero * 3 * 4; resultado = numero * 12;
return resultado; return resultado;
} }
  Propagación de copias: ante instrucciones como “c=a;” sustituir todas las c
por a y evitar así instrucciones redundantes.

CODIGO NO OPTIMIZADO CODIGO OPTIMIZADO

int a, b, c, d, e, f, g; int a, b, d, e, f, g;

public int Operacion(int numero) { public int Operacion(int numero) {

a = 80 + b; a = 80 + b;
c = a; e = a + f;
e = c + f; d = a + g;
d = a + g; g = a + d;
g = c + d;
return g;
return g;
}
}

OPTIMIZACION DE CICLOS
Los ciclos son una de las partes más esenciales en el rendimiento de un programa
dado que realizan acciones repetitivas, y si dichas acciones están mal realizadas,
el problema se hace N veces más grandes.

CODIGO NO OPTIMIZADO CODIGO OPTIMIZADO

int numero = 5; int contador = 1;

while (1 <= numero) { int numero = 5;
int contador = 1; while (contador <= numero) {
System.out.println("*****\n"); System.out.println("*****\n");
contador++; contador++;

} }

OPTIMIZACION GLOBAL
La optimización global se da con respecto a todo el código. Este tipo de optimización
es más lenta, pero mejora el desempeño general de todo programa. Las
optimizaciones globales pueden depender de la arquitectura de la máquina. En
algunos casos es mejor mantener variables globales para agilizar los procesos (el
proceso de declarar variables y eliminarlas toma su tiempo) pero consume más
memoria.
 CODIGO NO OPTIMIZADO
public class Factorial1 extends Thread {

public Factorial1() { }

public void run() {

int respuesta = 0;
long TInicio, TFin, tiempo;
int numero2;
int numero = Integer.parseInt(JOptionPane.showInputDialog("Ingresa el
numero "));
numero2 = numero;
TInicio = System.currentTimeMillis();
System.out.println(" \n FACTORIAL DE " + numero2 + " = " + respuesta +
"\n");
TFin = System.currentTimeMillis();
tiempo = TFin - TInicio;
JOptionPane.showMessageDialog(null, "Tiempo de ejecucion " + tiempo
+ " milisegundos ");

public void calcular(int n) {

BigInteger factorial = BigInteger.ONE;
long TInicio, TFin, tiempo;
int numero2;
int numero = Integer.parseInt(JOptionPane.showInputDialog("Ingresa el
numero "));
TInicio = System.currentTimeMillis();
numero2 = numero;

while (numero != 0) {
factorial = factorial.multiply(BigInteger.valueOf(numero));
numero--;
}

JOptionPane.showMessageDialog(null, "El factorial del numero " +

numero2 + " es " + factorial);
TFin = System.currentTimeMillis();
tiempo = TFin - TInicio;
JOptionPane.showMessageDialog(null, "Tiempo de ejecucion " + tiempo
+ " milisegundos ");
 }

public static void main(String[] args) {

int n = 11;

long timeStart = System.currentTimeMillis();

Factorial1 f = new Factorial1();

}
}

CODIGO OPTIMIZADO
public class Factorial1 extends Thread {

BigInteger factorial = BigInteger.ONE;

int numero = Integer.parseInt(JOptionPane.showInputDialog("Ingresa el
numero "));
int numero2;
static long TInicio, TFin, tiempo;
int respuesta;

public Factorial1() {
}

public void run() {

System.out.println(" \n FACTORIAL DE " + numero2 + " = " + respuesta +
"\n");
TFin = System.currentTimeMillis();
tiempo = TFin - TInicio;
JOptionPane.showMessageDialog(null, "Tiempo de ejecucion " + tiempo
+ " milisegundos ");

public void calcular(int n) {

TInicio = System.currentTimeMillis();
numero2 = numero;

while (numero != 0) {
factorial = factorial.multiply(BigInteger.valueOf(numero));
numero--;
 }

JOptionPane.showMessageDialog(null, "El factorial del numero " +

numero2 + " es " + factorial);
TFin = System.currentTimeMillis();
tiempo = TFin - TInicio;
JOptionPane.showMessageDialog(null, "Tiempo de ejecucion " + tiempo
+ " milisegundos ");

public static void main(String[] args) {

int n = 11;

long timeStart = System.currentTimeMillis();

Factorial1 f = new Factorial1();

}
}

OPTIMIZACION DE MIRILLA

La optimización de mirilla trata de estructurar de manera eficiente el flujo del

programa, sobre todo en instrucciones de bifurcación como son las decisiones,
ciclos y saltos de rutinas. La idea es tener los saltos lo más cerca de las llamadas,
siendo el salto lo más pequeño posible.

CODIGO NO OPTIMIZADO CODIGO OPTIMIZADO

org 100h org 100h
mov ax,c1 mov ax,2
mov c1,2 mov bx,-1
mov bx,-1
salto:
salto: inc bx
inc bx
mov dh, vector1[bx]
mov dh, vector1[bx] add dh, vector2[bx]
add dh, vector2[bx]
mov vector3[bx],dh
mov vector3[bx],dh
 cmp ax,bx
cmp ax,bx jnz salto
jnz salto

mov aux,2
mov aux,c mov si,-1
mov c,2 printer:
mov si,-1 inc si
printer:
inc si
mov bl, vector3[si]
mov cx, 8
mov bl, vector3[si] print: mov ah, 2
mov cx, 8 mov dl, '0'
print: mov ah, 2 test bl, 10000000b
mov dl, '0' jz zero
test bl, 10000000b mov dl, '1'
jz zero zero: int 21h
mov dl, '1' shl bl, 1
zero: int 21h loop print
shl bl, 1 mov dl, 'b'
loop print int 21h
mov dl, 'b'
int 21h MOV dl, 10
MOV ah, 02h
MOV dl, 10 INT 21h
MOV ah, 02h MOV dl, 13
INT 21h MOV ah, 02h
MOV dl, 13 INT 21h
MOV ah, 02h
INT 21h
cmp aux,si
jnz printer
cmp aux,si
jnz printer aux dw 0
vector1 db 5,3,2
aux dw 0 vector2 db 6,4,1
vector1 db 5,3,2 vector3 db 0,0,0
vector2 db 6,4,1
vector3 db 0,0,0 ret

ret