Subsecretaría de Educación Superior

Dirección General de Educación Superior Tecnológica

Instituto Tecnológico de San Juan del Río

Instituto Tecnológico de San Juan del Río

ENSAYO UNIDAD III

LENGUAJES Y AUTOMATAS II
OPTIMIZACIÓN

P RE S E N T A:
ING. SISTEMAS COMPUTACIONALES

PERIODO [JUN-DIC 2014]

Contenido
INTRODUCCION........................................................................................................................... 3
OPTIMIZACION ............................................................................................................................ 3
TIPOS DE OPTIMIZACION .......................................................................................................... 5
Locales. ....................................................................................................................................... 5
Ciclos. ......................................................................................................................................... 6
Globales. ..................................................................................................................................... 7
Mirilla. ........................................................................................................................................ 8
COSTOS ........................................................................................................................................10
Ejecución. ...................................................................................................................................10
Criterios para mejorar el código. .................................................................................................11
Herramientas para el análisis del flujo de datos. ..........................................................................12
MAPA ............................................................................................................................................13
CONCLUCIONES .........................................................................................................................13
REFERENCIAS .............................................................................................................................14
INTRODUCCION

La optimización es el proceso que se realiza para mejorar el rendimiento de una actividad

o proceso, evitando así la pérdida de tiempo y de datos. Puede ser aplicado al rendimiento
de sistemas operativos, software, dispositivos móviles y aplicaciones. Puede ser aplicada
en cualquier área donde se busque o desee realizar una actividad de forma eficaz y
eficiente, sin perder datos relevantes ni tiempo, es la encargada de las constantes
actualizaciones.

La optimización de código puede realizarse durante la propia generación o como paso

adicional, ya sea intercalado entre el análisis semántico y la generación de código (se
optimizan las cuádruplas) o situado después de ésta (se optimiza a posteriori el código
generado).

El objetivo de las técnicas de optimización es mejorar el programa objeto para que nos dé
un rendimiento mayor, se pueden clasificar o dividir de diversas formas.
Por una parte podemos hablar de aquellas técnicas que son dependientes de la máquina,
y aquellas que son independientes de la máquina (o sea, técnicas que sólo se pueden
aplicar a una determinada máquina objeto y técnicas que son aplicables a cualquier
máquina objeto).

OPTIMIZACION

El objetivo de las técnicas de optimización es mejorar el programa objeto para que nos dé
un rendimiento mayor. La mayoría de estas técnicas vienen a compensar ciertas
ineficiencias que aparecen en el lenguaje fuente, ineficiencias que son inherentes al
concepto de lenguaje de alto nivel, el cual suprime detalles de la máquina objeto para
facilitar la tarea de implementar un algoritmo.
Por último, comentar que por muchas optimizaciones que se hayan realizado para mejorar
el rendimiento de un programa, siempre se obtendrá un mejor rendimiento si se utiliza un
algoritmo mejor. Por todo ello, para obtener un buen programa lo primero es ver qué
algoritmo utilizamos y si no es posible desarrollar otro más eficiente. Una vez
implementado el mejor algoritmo, ya se puede entonces optimizar el código obtenido a
partir de él para mejorar el rendimiento del programa.

Como se puede apreciar en la figura 1. La optimización del código es parte fundamental

dentro de la generación de cualquier software ya que esta forma parte de un proceso a
realizar.

Figura 1.
TIPOS DE OPTIMIZACION

Existen varias técnicas de optimización que se aplican al código generado para un

programa sencillo. Por programa sencillo entendemos aquel que se reduce a un solo
procedimiento o subrutina. Las técnicas de optimización a través de varios procedimientos.

La optimización es un proceso que tiene a minimizar o maximizar alguna variable de

rendimiento, generalmente tiempo, espacio, procesador, etc. Aun no existen optimizador
que hagan un programa más rápido y que ocupe menor espacio.
La optimización se realiza reestructurando el código de tal forma que el nuevo código
generado tenga mayores beneficios.

Locales.

Características:

a) Optimizaciones que no modifican la estructura. Son:

1. Eliminación de sub-expresiones comunes.

2. Eliminación de código muerto.
3. Renombrar variables temporales.
4. Intercambio de sentencias independientes adyacentes.

b) Transformaciones algebraicas. Son aquellas transformaciones que simplifican

expresiones y/o reemplazan operaciones costosas de la máquina por otras menos
costosas.
 c) Existe otra categoría de optimización local se le llama optimización peephole, e
intenta mejorar el rendimiento del programa por medio de reemplazar esa breve
secuencia de instrucciones objeto por otra secuencia más corta y/o más rápida.

Por ejemplo:

1. Eliminación de instrucciones redundantes.

2. Optimizaciones en el flujo de control.
3. Simplificaciones algebraicas.
4. Uso de instrucciones máquina específicas.

Ciclos.

Habitualmente, un programa pasa la mayor parte del tiempo de la ejecución en un trozo de

código pequeño. A este fenómeno se le conoce como la regla 90-10, queriendo decir que
el 90% del tiempo es pasado en el 10% del código. Este 10% del código suele estar
constituido por bucles, y de ahí la importancia de una correcta optimización del código que
forma parte de los bucles.

Las principales optimizaciones que se realizan en los bucles son las siguientes:

1. Movimiento de código.
2. Eliminación de variables inducidas.
3. Sustitución de variables costosas por otras menos costosas.
Y también se suelen aplicar (aunque con menor importancia):
4. Expansión de código (loop unrolling).
5. Unión de bucles (loop jamming).

Para una máquina con registros -lo común en los procesadores actuales- las instrucciones
cuyos operando están en los registros de la máquina son más cortas y más rápidas que
aquellas que tratan con operando que están en la memoria. Es por tanto importante decidir
qué variables se deben almacenar en los registros (localización) y en qué registro se debe
almacenar cada variable (asignación). Existen diversas estrategias para la localización y
asignación de los registros.

Es frecuente asignar algún número fijo de registros que contengan las variables más
usadas en un bucle interno, sirviendo los registros restantes para las variables locales a
cada bloque básico.

CARACTERISTICAS:

- Son parte en el rendimiento de un programa dado.

- Realizan acciones repetitivas, y si dichas acciones están mal realizadas, el
problema se hace N veces más grandes.
- Trata de encontrar elementos que no deben repetirse en un ciclo.
- Mejoramiento de consultas en SQL o en aplicaciones remotas
- Difícil saber el uso exacto de algunas instrucciones.

Globales.

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.
Algunas optimizaciones incluyen utilizar como variables registros del CPU, utilizar
instrucciones en ensamblador.
Antes de realizar una optimización global es necesario crear el grafo de flujo de
ejecución. El grafo de flujo de ejecución representa todos los caminos posibles de
ejecución del programa. La información contenida en el grafo es útil para el
programador y el optimizador La optimización global a partir del análisis del grafo del
flujo de ejecución permite

Ejemplo: En la figura 2. Podemos ver un ejemplo.

Figura 2.

Mirilla.

La optimización de tipo Mirilla (peephole optimización) es aplicable en código intermedio o

código objeto y constituye una nueva fase aislada. Se recorre el código buscando
combinaciones de instrucciones que puedan ser reemplazadas por otras equivalentes más
eficientes. Se utiliza una ventana de *n instrucciones y un conjunto de patrones de
trasformación. Si las instrucciones de la ventana encajan con algún patrón se reemplazan
por la secuencia de reemplazamiento asociada.
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.

CARACTERISTICAS:

- Estructurar de manera eficiente el flujo del programa, sobre todo en

instrucciones de bifurcación como son las decisiones, ciclos y saltos de rutinas.

- Tiene los saltos lo más cerca de las llamadas, siendo el salto lo más pequeño
posible

- Se recorre el código buscando combinaciones de instrucciones que puedan ser

remplazadas Por otras equivalentes más eficientes

- Se utiliza en: C#, Java, Javacc, Pyton, Haskell, Ensamblador, Condiciones if,
Condiciones while, case.

Tabla de diferencias entre la optimización del tipo: Local, Ciclos y Mirilla.

DIFERENCIAS
LOCAL CICLOS MIRILLA
Reemplazan Es difícil saber el uso • tener los
operaciones exacto de algunas saltos lo más cerca
costosas de la instrucciones de las llamadas,
máquina por otras siendo el salto lo
menos costosas. más pequeño posible
Tabla1
COSTOS

Los costos son el factor más importante a tomar en cuenta a la hora de optimizar ya que
en ocasiones la mejora obtenida puede verse no reflejada en el programa final pero si ser
perjudicial para el equipo de desarrollo. La optimización de una pequeña mejora tal vez
tenga una pequeña ganancia en tiempo o en espacio pero sale muy costosa en tiempo en
generarla.

Pero en cambio si esa optimización se hace por ejemplo en un ciclo, la mejora obtenida
puede ser N veces mayor por lo cual el costo se minimiza y es benéfico la mejora.
• Por ejemplo: for(int i=0; i < 10000; i++); si la ganancia es de 30 ms 300s

Ejecución.

Los costos de ejecución son aquellos que vienen implícitos al ejecutar el programa.
En algunos programas se tiene un mínimo para ejecutar el programa, por lo que el
espacio y la velocidad de los microprocesadores son elementos que se deben optimizar
para tener un mercado potencial más amplio.

La memoria es uno de los recursos más importantes de la computadora y en

consecuencia el gestor de memoria es un componente básico para el funcionamiento de
esta, ya que durante la optimización del código se cuidara que esta no sea desperdiciada
en sentencias donde podría realizarse de forma más eficaz.

Ejemplo:
 Las aplicaciones multimedia como los videojuegos tienen un costo de
Ejecución alto por lo cual la optimización de su desempeño es crítico, la gran
Mayoría de las veces requieren de procesadores rápidos (e.g. tarjetas de
Video) o de mucha memoria.
 Otro tipo de aplicaciones que deben optimizarse son las aplicaciones para
Dispositivos móviles.
  Los dispositivos móviles tiene recursos más limitados que un dispositivo de
Cómputo convencional razón por la cual, el mejor uso de memoria y otros
Recursos de hardware tiene mayor rendimiento.
 En algunos casos es preferible tener la lógica del negocio más fuerte en otros
Dispositivos y hacer uso de arquitecturas descentralizadas como
Cliente/servidor o P2P.

Criterios para mejorar el código.

Cuando un programa se ejecuta sobre un sistema operativo existe un proceso previo

llamado cargador que suministra al programa un bloque contiguo de memoria sobre el cual
ha de ejecutarse. El programa resultante de la compilación debe organizarse de forma que
haga uso de este bloque. Para ello el compilador incorpora al programa objeto el código
necesario.

Las técnicas de gestión de la memoria durante la ejecución del programa difieren de unos
lenguajes a otros, e incluso de unos compiladores a otros.
Para lenguajes imperativos, los compiladores generan programas que tendrán en tiempo
de ejecución una organización de la memoria similar (a grandes rasgos) a la que aparece
en la figura 3.
Figura 3

La mejor manera de optimizar el código es hacer ver a los programadores que
Optimicen su código desde el inicio, el problema radica en que el costo podría
Ser muy grande ya que tendría que codificar más y/o hacer su código más
Legible.
Los criterios de optimización siempre están definidos por el compilador
Muchos de estos criterios pueden modificarse con directivas del compilador
Desde el código o de manera externa.
Este proceso lo realizan algunas herramientas del sistema como los
Ofuscadores para código móvil y código para dispositivos móviles.

Herramientas para el análisis del flujo de datos.

Existen algunas herramientas que permiten el análisis de los flujos de datos, entre ellas
tenemos los depuradores y des ambladores. La optimización al igual que la programación
es un arte y no se ha podido sistematizar del todo.

Para que el compilador pueda realizar la mayoría de las optimizaciones vistas hasta ahora,
es necesario que posea información de todo el programa, para poder determinar si una
variable está viva, o si dos sub expresiones son comunes, o si una variable se puede
sustituir por un valor constante, etc.
MAPA

CONCLUCIONES

Después de todo este análisis obtenemos que la optimización de código no solo nos
permite hacer más agiles los programas sino que también es la fase de optimización de
código consiste en mejorar el código intermedio, de modo que resulte un código máquina
más rápido de ejecutar. Esta fase de la etapa de síntesis es posible sobre todo si el
traductor es un compilador (difícilmente un intérprete puede optimizar el código objeto).
Hay mucha variación en la cantidad de optimización de código que ejecutan los distintos
compiladores. En los que hacen mucha optimización, llamados «compiladores
optimizadores», una parte significativa del tiempo del compilador se ocupa en esta fase.
Sin embargo, hay optimizaciones sencillas que mejoran sensiblemente el tiempo de
ejecución del programa objeto sin retardar demasiado la compilación.
REFERENCIAS
Aho (2006), et. Al. Compiladores: Principios y Técnicas. Segunda Edición.

(s.f.). Obtenido de http://lenguajesyautomatas2lizethgiron.blogspot.mx/2013/11/tarea8tipos-de-

optimizacionlocalciclos.html

(s.f.). Obtenido de http://arantxa.ii.uam.es/~alfonsec/docs/compila7.htm

(s.f.). Obtenido de http://www.uclm.es/ab/educacion/ensayos/pdf/revista7/r7a21.pdf

(s.f.). Obtenido de http://www.cvc.uab.es/shared/teach/a25002/Optimizacion%20de%20codigo.pdf

(s.f.). Obtenido de http://ditec.um.es/~jmgarcia/papers/ensayos.pdf

(s.f.). Obtenido de http://www.tufuncion.com/optimizar-codigo

(s.f.). Obtenido de http://es.slideshare.net/Sonechkaengel/optimizacin-global

(s.f.). Obtenido de http://ingarely.files.wordpress.com/2012/11/unidad-vii.pdf

(s.f.). Obtenido de https://prezi.com/f2ankz9ryt2m/optimizacion-de-mirilla/

(s.f.). Obtenido de http://www.itescam.edu.mx/portal/asignatura.php?clave_asig=SCD-

1016&carrera=ISIC-2010-224&id_d=16

(s.f.). Obtenido de https://prezi.com/m-ft53psccpy/321-costo-de-ejecucion-memoria-registros-pilas/

(s.f.). Obtenido de http://www.itescam.edu.mx/principal/sylabus/fpdb/recursos/r101579.PDF