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
Reemplazan
Es difícil saber el uso •
operaciones
exacto de algunas saltos lo más cerca
costosas máquina
de por
la instrucciones otras
menos costosas. Tabla1
MIRILLA
de
tener
las
los
llamadas,
siendo el salto lo más pequeño posible
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-deoptimizacionlocalciclos.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=SCD1016&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
