Instituto Tecnológico de Lázaro Cárdenas.

Materia:
Lenguajes y autómatas II

TRABAJO DE INVESTIGACIÓN DE LA UNIDAD III

Profesor:
RENATO MORALES NAVA

Integrantes: No. De Control:

César Ricardo Campa Mercado 19560307
Ernesto Emmanuelle de la Cruz 19560377

Carrera:
Ingeniería en Sistemas Computacionales.

6to Semestre.
Contenido
Introducción......................................................................................................................... 4
3.1 Tipos de optimización....................................................................................................4
Tipos de optimización:.....................................................................................................4
3.1.1 Locales....................................................................................................................... 5
• Las optimizaciones locales se realizan sobre el bloque básico.....................................5
• Optimizaciones locales..................................................................................................5
– Folding...................................................................................................................... 5
– Propagación de constantes.......................................................................................5
– Reducción de potencia..............................................................................................6
– Reducción de sub-expresiones comunes..................................................................6
3.1.2 Ciclos......................................................................................................................... 7
Invariante del ciclo........................................................................................................... 7
3.1.3 Globales..................................................................................................................... 7
Tipos de optimización global:...........................................................................................8
 Estocásticos:.........................................................................................................8
 No Confiables:......................................................................................................8
 Determinísticos:....................................................................................................8
 Confiables:............................................................................................................8
Algunos tipos de problemas de optimización global:........................................................8
Problemas combinatorios:............................................................................................8
Problemas generales sin restricciones:........................................................................8
Problemas generales con restricciones:.......................................................................8
3.1.4 De mirilla.................................................................................................................... 8
Ideas básicas:.................................................................................................................. 8
Instrucciones de bifurcación............................................................................................9
3.2 Costos........................................................................................................................... 9
3.2.1 Costo de ejecución. (memoria, registros, pilas)..........................................................9
Memoria:.......................................................................................................................... 9
Organización de la memoria en tiempo de ejecución:................................................10
Registros:...................................................................................................................... 10
Pila:............................................................................................................................... 10
Memoria estática:.......................................................................................................... 11
3.2.2 Criterios para mejorar el código................................................................................11
 Existen 3 criterios para mejorar el código:.....................................................................13
Asignación de registros..............................................................................................13
Operaciones innecesarias..........................................................................................13
Operaciones costosas................................................................................................13
3.2.3 Herramientas para el análisis del flujo de datos.......................................................13
DEPURADOR................................................................................................................ 13
El depurador permite detener el programa en:...........................................................13
Durante esa interrupción, el usuario puede:...............................................................13
DESAMBLADOR o DESENSAMBLADOR.....................................................................14
¿Qué hace un desensamblador?...............................................................................14
Usos del desensamblador..........................................................................................14
Ejemplos:................................................................................................................... 14
DIAGRAMA DE FLUJO.................................................................................................14
Software de Ejemplo:.................................................................................................15
DICCIONARIO DE DATOS............................................................................................15
Contenido de un registro del diccionario....................................................................15
Cada uno está identificado con:.................................................................................15
Ejemplo:..................................................................................................................... 16
Conclusiones..................................................................................................................... 16
Bibliografía........................................................................................................................ 17
INTRODUCCIÓN.
El siguiente documento tiene como finalidad el presentar todos los temas debidamente
explicados y con ejemplos sobre la unidad III de la materia de lenguajes y autómatas II. La
optimización busca mejorar la forma en que un programa utiliza los recursos. Las
optimizaciones se realizan en base al alcance ofrecido por el compilador. La optimización
va a depender del lenguaje de programación y es directamente proporcional al tiempo de
compilación; es decir, entre más optimización mayor tiempo de compilación.
Existen diversas técnicas de optimización se pueden clasificar o dividir de diversas
formas:
1. Dependientes de la maquina: técnicas que solo se pueden aplicar a una
determinada maquina objeto.
2. Independientes de la maquina: técnicas que son aplicables a cualquier
maquina objeto.
3. Locales: analizaran solo pequeñas porciones de código y en ellas realizaran
mejoras.
4. Globales: será necesario el análisis de todo el código.

3.1 TIPOS DE OPTIMIZACIÓN.

Las optimizaciones pueden realizarse de diferentes formas. Las optimizaciones se
realizan en base al alcance ofrecido por el compilador.
Esta va a depender del lenguaje de programación y es directamente proporcional al
tiempo de compilación; es decir, entre más optimización mayor tiempo de compilación.
Como el tiempo de optimización es gran consumidor de tiempo (dado que tiene que
recorrer todo el árbol de posibles soluciones para el proceso de optimización) la
optimización se deja hasta la fase de prueba final.
Algunos editores ofrecen una versión de depuración y otra de entrega o final.
La optimización es un proceso que tiene a minimizar o maximizar alguna variable de
rendimiento, generalmente tiempo, espacio, procesador, etc. Desafortunamente 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.
La mayoría de los compiladores tienen una optimización baja, se necesita de
compiladores especiales para realmente optimizar el código.

Tipos de optimización:
 Optimizaciones Globales
 Optimizaciones de Ciclo
 Optimización de Mirilla
 Optimizaciones Locales
3.1.1 LOCALES.
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.
La característica de las optimizaciones locales es que sólo se ven reflejados en dichas
secciones.
La optimización local sirve cuando un bloque de programa o sección es crítico, por
ejemplo: la E/S, la concurrencia, la rapidez y confiabilidad de un conjunto de
instrucciones.
Como el espacio de soluciones es más pequeño la optimización local es más rápida.

• Las optimizaciones locales se realizan sobre el bloque básico

Un bloque básico es un fragmento de código que tiene una única entrada y salida, y cuyas
instrucciones se ejecutan secuencialmente.
La idea del bloque básico es encontrar partes del programa cuyo análisis necesario para
la optimización sea lo más simple posible.

• Optimizaciones locales
– Folding
El ensamblamiento es remplazar las expresiones por su resultado cuando se pueden
evaluar en tiempo de compilación (resultado constante).
– Propagación de constantes
Estas optimizaciones permiten que el programador utilice variables como constantes sin
introducir ineficiencias.
Ejemplo en C no hay constantes y será lo mismo utilizar.

– Reducción de potencia
Se busca sustituir operaciones costosas por otras más simples.

– Reducción de sub-expresiones comunes

Es una optimización que consiste en buscar expresiones que se repitan, y analizar si vale
la pena reemplazarlas por una variable para computar el valor una sola vez.
3.1.2 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.
La mayoría de las optimizaciones sobre ciclos tratan de encontrar elementos que no
deben repetirse en un ciclo.
Ejemplo:

En este caso es mejor pasar el int c =a; fuera del ciclo de ser posible.
El problema de la optimización en ciclos y en general radica es que muy difícil saber el
uso exacto de algunas instrucciones. Así que no todo código de proceso puede ser
optimizado.
Otros usos de la optimización pueden ser el mejoramiento de consultas en SQL o en
aplicaciones remotas (sockets, E/S, etc.)
Invariante del ciclo
 No tiene sentido evaluarla dentro del ciclo.
 Se mueve el código fuera del ciclo.
 El destino del código es el bloque de entrada al ciclo, i es una variable de
inducción para un ciclo L si existe una constante c tal que cada vez que se asigna
un valor a i, su valor aumenta c – note que c puede ser positiva o negativa.

3.1.3 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.

Tipos de optimización global:

 Estocásticos: evalúan f sobre una muestra aleatoria sobre la región de interés
 No Confiables:
Simulado recocido (Simulated annealing), búsqueda aleatoria (random search)
Sin embargo, la eficiencia es una característica de estos métodos
Problemas de gran escala (+100 variables) son resueltos mejor con estos métodos
estocásticos
 Determinísticos: no envuelve ningún elemento aleatorio
 Confiables:
Ramas y bordes (Branch and Bound), métodos de intervalos (Interval methods)
Métodos de puntos (Point methods): calculan valores de la función sobre puntos de
muestras (incapaces de resolver confiablemente un problema de optimización global).
Ejemplo Monte Carlo.
Métodos de bordes (Boundary Methods): calculan cotas sobre conjuntos compactos. Si
son implementados apropiadamente y considerando errores de redondeo, pueden
producir soluciones globales rigurosas.

Algunos tipos de problemas de optimización global:

Problemas combinatorios: tienen una función objetivo lineal o no lineal definida
sobre un conjunto admisible discreto pero muy grande (problemas de redes,
planificación, transporte, ...).
 Problemas generales sin restricciones: Con una función no lineal definida sobre
valores reales. Esta función será, en general no convexa. Se han propuesto dos
clases genéricas de métodos de resolución: los métodos deterministas y los
métodos estocásticos.
Problemas generales con restricciones: En los métodos deterministas, el
tratamiento de las restricciones es similar al de los métodos equivalentes locales
(por ejemplo, SQP).

3.1.4 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.

Ideas básicas:

 Se recorre el código buscando combinaciones de instrucciones que pueden ser

reemplazadas por otras equivalentes más eficientes.
 Se utiliza una ventana de n instrucciones y un conjunto de patrones de
transformación (patrón, secuencias, remplazan).
 Las nuevas instrucciones son reconsideradas para las futuras optimizaciones.

Instrucciones de bifurcación
Interrumpen el flujo normal de un programa, es decir que evitan que se ejecute alguna
instrucción del programa y salta a otra parte del programa.

3.2 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.

3.2.1 COSTO DE EJECUCIÓN. (MEMORIA, REGISTROS, PILAS).

Memoria:
La memoria es uno de los recursos más importantes de la computadora, la parte del
sistema operativo responsable de tratar con este recurso, es el gestor de memoria.
El gestor de memoria del sistema operativo debe hacer de puente entre los requisitos de
las aplicaciones y los mecanismos que proporciona el hardware de gestión de memoria.
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.

Organización de la memoria en tiempo de ejecución:

Las técnicas de gestión de la memoria durante la ejecución del programa difieren de unos
lenguajes de programación a otros, e incluso de unos compiladores a otros. Para datos,
básicamente la memoria se divide en:
- Memoria Estática.
- La Pila.
- Heap (El Montón).

Registros:
Los registros del procesador se emplean para controlar instrucciones en ejecución,
manejar direccionamiento de memoria y proporcionar capacidad aritmética. Los registros
son espacios físicos dentro del microprocesador con capacidad de 4 bits hasta 64 bits
dependiendo del microprocesador que se emplee.

Pila:
La asignación de memoria de variables locales se hace de una forma flexible, atendiendo
al hecho de que solamente necesitan memoria asignada desde el momento que comienza
la ejecución de la función hasta el momento en que ésta finaliza.
Para que una variable pueda ser almacenada en memoria estática, es necesario conocer
su tamaño (número de bytes necesarios para su almacenamiento) en tiempo de
compilación.

Memoria estática:
La forma más sencilla de almacenar el contenido de una variable en memoria, en tiempo
de ejecución, es hacerlo de la memoria estática. Así, el almacenamiento de dichas
variables será permanente (durante la ejecución del programa).
Así, cada vez que comienza la ejecución de un procedimiento (o función) se crea un
registro de activación para contener los objetos necesarios para su ejecución,
eliminándolo una vez terminada ésta.
Dado que durante la ejecución de un programa es habitual que unos procedimientos
llamen a otros y estos a otros, sucesivamente, se crea cadena jerárquica de llamadas a
procedimiento.
Dado que la cadena de llamadas está organizada jerárquicamente, los distintos registros
de activación asociados a cada procedimiento (o función) se colocarán en una pila en la
que entrarán cuando comience la ejecución del procedimiento y saldrán al terminar el
mismo.
Esta área de memoria se llama heap.

3.2.2 CRITERIOS PARA MEJORAR EL CÓDIGO.

Escribir código fuente de programas es una de las tareas más importantes del ciclo de
vida del software, no solo es importante su diseño, también la manera en que está
estructurado el código fuente.
El código fuente bien estructurado permite un mejor análisis por parte de los
desarrolladores del software, tanto para los creadores de la aplicación, como también
para cualquier desarrollador que requiera realizar modificaciones al sistema para su
posterior mantenimiento.
El código fuente correctamente estructurado en algunos casos puede mejorar la
optimización del sistema en cuanto a su funcionamiento, ya que elimina funciones
redundantes o incluye mejores prácticas de codificación.
La inclusión de comentarios al código fuente mejora de manera notable su interpretación
por parte del analista del sistema.
Conforme el desarrollador del software adquiere práctica y lógica de programación, el
código fuente del sistema será de mayor calidad, ya que simplifica funciones, elimina
funciones redundantes, así como también crea sus propias funciones que realicen tareas
de la aplicación de una manera más simple y óptima.
La cantidad de líneas de código no influye en la calidad del código del sistema, en
algunos casos es necesario aplicar modelos que siguen determinados patrones como la
modelo vista controlador, el cual en aplicaciones sencillas requieren mayor cantidad de
código. Este código será de mayor calidad debido a su mayor facilidad de mantenimiento
y optimización.
Un claro ejemplo que demuestra que la cantidad líneas de código no influye directamente
en la calidad del sistema está en los métodos de ordenamiento. El método burbuja posee
menos cantidad de líneas de código que el método QuickSort, pero esto no influye en su
rendimiento, ya que el método burbuja es más lento en tiempo de ejecución que el
método QuickSort.

Existen ciertas metodologías para mejorar la calidad del código fuente de las aplicaciones,
un claro ejemplo sería el uso de Programación Orientada a Objetos, la cual simplifica la
codificación del programa al separar el archivo del programa en «clases» de código para
determinadas partes del sistema; la inclusión de «métodos o funciones» para
determinadas acciones del sistema.
En algunos casos será necesario implementar ciertos «frameworks» para implementar
cierta manera de trabajo para las aplicaciones. Por ejemplo, en PHP es útil trabajar con
frameworks para mejorar el código y facilitar al programador el desarrollo del software,
existen frameworks que se pueden utilizar, tal es el caso de «CodeIgniter», «Zend»,
«Nuke» entre otros.

Existen 3 criterios para mejorar el código:

Asignación de registros
un registro es una memoria de alta velocidad y poca capacidad, integrada en el
microprocesador, que permite guardar transitoriamente y acceder valores muy usados,
generalmente en operaciones matemáticas.
Operaciones innecesarias
Las operaciones innecesarias surgen a menudo por un desempeño inadecuado de la
operación anterior. Debe utilizarse una segunda operación para "corregir" o dejar
aceptable el trabajo de la primera.
Operaciones costosas
En algunos casos la realización de algunas operaciones suele tener un costo de ejecución
elevado, y en ocasiones estas operaciones pueden cambiarse por otros métodos de
producción que podrían ser más complejos si es la primera vez que se realiza, pero a lo
largo estos métodos terminan por ser beneficiosos trayendo consigo ganancias al a hora
de ejecutar las operaciones.
3.2.3 HERRAMIENTAS PARA EL ANÁLISIS DEL FLUJO DE
DATOS.
Existen algunas herramientas que permiten el análisis y la correcta optimización del flujo
de datos entre las más importantes están:

DEPURADOR
Es una aplicación que permite correr otros programas, permitiendo al usuario ejercer
cierto control sobre los mismos a medida que los estos se ejecutan, y examinar el estado
del sistema (variables, registros, banderas, etc.) en el momento en que se presente algún
problema.
El depurador permite detener el programa en:
 Un punto determinado mediante un punto de ruptura.
 Un punto determinado bajo ciertas condiciones mediante un punto de ruptura
condicional.
 Un momento determinado cuando se cumplan ciertas condiciones.
 Un momento determinado a petición del usuario.
Durante esa interrupción, el usuario puede:
 Examinar y modificar la memoria y las variables del programa.
 Examinar el contenido de los registros del procesador.
 Cambiar el punto de ejecución, de manera que el programa continúe su ejecución
en un punto diferente al punto en el que fue detenido.
 Ejecutar instrucción a instrucción.
 Ejecutar partes determinadas del código, como el interior de una función, o el resto
de código antes de salir de una función.

DESAMBLADOR o DESENSAMBLADOR
Es un programa de computadora que traduce el lenguaje de máquina a lenguaje
ensamblador, la operación inversa de la que hace el ensamblador.
Un desensamblador se diferencia de un decompilador, en que está dirigido a un lenguaje
de alto nivel en vez de al lenguaje ensamblador.
¿Qué hace un desensamblador?
 Transforma el código binario en instrucciones básicas del PC en la que se ejecuta,
el programa no es capaz de distinguir si dichas instrucciones provienen de un "if",
de un "for" o de un "while".
 No conoce los nombres de las variables (no se incluyen en el código binario ya
que la máquina no usa nombres), así que suele inventar nombres como
VAR_0001, VAR_0002, etc.
 Las funciones internas del programa, se suelen llamar CALL_0001 o JMP_0001, o
similares, dependiendo de si son direcciones de llamadas con o sin retorno,
respectivamente.
Usos del desensamblador
Son ampliamente utilizados para crackear programas y para realizar ingeniería inversa.
También son utilizados por desarrolladores de software, investigadores o estudiantes.
Ejemplos:
 Interactive Disassembler es el más comúnmente utilizado.
 ILDASM es una herramienta contenida en el SDK del .NET Framework.
 OllyDbg es un desensamblador integrado para Lenguaje Ensamblador y COBOL.
 Texe es un desensamblador que corre a 32 bits y además un analizador de
archivos PE (Portable Executable) de Windows libre.

DIAGRAMA DE FLUJO
Es una herramienta de modelización que permite describir, de un sistema, la
transformación de entradas en salidas; el DFD también es conocido con el nombre de
Modelo de Procesos de Negocios.

Software de Ejemplo:
DICCIONARIO DE DATOS
El Diccionario de Datos es un listado organizado de todos los elementos de datos que son
pertinentes para el sistema, con definiciones precisas y rigurosas que le permite al usuario
y al proyectista del sistema tener una misma comprensión de las entradas, de las salidas,
y también de cálculos intermedios.
Contenido de un registro del diccionario
El diccionario tiene dos tipos de descripciones para el flujo de datos del sistema, son los
elementos datos y estructura de datos.
Elemento dato: son los bloques básicos para todos los demás datos del sistema, por si
mismos no le dan un significado suficiente al usuario. Se agrupan para formar una
estructura de datos.
Descripción: Cada entrada en el diccionario consiste de un conjunto de detalles que
describen los datos utilizados o producidos por el sistema.
Cada uno está identificado con:
Un nombre: para distinguir un dato de otro.
Descripción: indica lo que representa en el sistema.
Alias: porque un dato puede recibir varios nombres, dependiendo de quien uso este dato.
Longitud: porque es de importancia de saber la cantidad de espacio necesario para cada
dato.
Valores de los datos: porque en algunos procesos solo son permitidos valores muy
específicos para los datos. Si los valores de los datos están restringidos a un intervalo
especifico, esto debe estar en la entrada del diccionario.
Estructura de datos: es un grupo de datos que están relacionados con otros y que en
conjunto describen un componente del sistema.
Descripción: Se construyen sobre cuatro relaciones de componentes. Se pueden utilizar
las siguientes combinaciones ya sea individualmente o en conjunción con alguna otra.
Relación secuencial: define los componentes que siempre se incluyen en una estructura
de datos.
Relación de selección: (uno u otro), define las alternativas para datos o estructuras de
datos incluidos en una estructura de datos.
Relación de iteración: (repetitiva), define la repetición de un componente.
Relación opcional: los datos pueden o no estar incluidos, o sea, una o ninguna iteración.
Ejemplo:

CONCLUSIONES.
La optimización en el momento de la realización de un programa en código puede ser de
gran aporte para el programador o equipo de programadores, esto por el gran tiempo y
espacio que puede ser ahorrado para poder llegar dar terminado algún proyecto en
tiempo y forma.
Incluso creando un código más sencillo y entendible que no requiera de tantos usos de
recursos para poder llevar su ejecución.

BIBLIOGRAFÍA.
colaboradores de Wikipedia. (2021, 10 enero). Eliminación de subexpresiones comunes.

Wikipedia, la enciclopedia libre. Recuperado 22 de abril de 2022, de

https://es.wikipedia.org/wiki/Eliminaci%C3%B3n_de_subexpresiones_comunes

Davila, C. (2014, 21 octubre). 3.2.3 HERRAMIENTAS PARA EL ANALISIS DEL FLUJO

DE DATOS. Prezi.Com. Recuperado 22 de abril de 2022, de

https://prezi.com/4dtcp9qnkjbk/323-herramientas-para-el-analisis-del-flujo-de-

datos/

Gilberto, C. (2019, 20 noviembre). UNIDAD 3 Optimizacion. BlogSpot. Recuperado 22 de

abril de 2022, de

https://carlosgilbertogarciajimenez1.blogspot.com/2019/11/unidad-3.html
Glez, J. (2017, 25 octubre). Unidad 3 Lenguajes y automatas II. Prezi.Com. Recuperado

22 de abril de 2022, de https://prezi.com/cohkyt4tvdww/unidad-3-lenguajes-y-

automatas-ii/

Laura, V. (2019, 18 octubre). Tipos De Optimización. BlogSpot. Recuperado 22 de abril de

2022, de https://vilmalauramoraleszunun.blogspot.com/2019/10/tipos-de-

optimizacion.html

M.C. Juan Carlos Olivares Rojas. (2018). Unidad VII Optimización.

http://dsc.itmorelia.edu.mx/~jcolivares/courses/ps207a/ps2_u7.pdf

Vasquez, G. (2019, 18 septiembre). UNIDAD 3 - OPTIMIZACIÓN. BlogSpot. Recuperado

22 de abril de 2022, de

https://vasquezcalvogabrieltrinidad.blogspot.com/2019/11/unidad-3-

optimizacion.html