Annotation of ADD_ver_10/Source Code/Source Files/Recuentos.c, revision 1.2

1.2     ! rico        1: /********************************************************************/
        !             2: /*  Recuentos.c                                                     */
        !             3: /*                                                                  */
        !             4: /*                                                                  */
        !             5: /*  Copyright (c) 1997-2006 Rafael Rico      (rafael.rico@uah.es)   */
        !             6: /*                                                                  */
        !             7: /*  Este fichero forma parte de ADD                                 */
        !             8: /*  (Analizador de Dependencias de Datos)                           */
        !             9: /*  Version 5.10.                                                   */
        !            10: /*                                                                  */
        !            11: /*                                                                  */
        !            12: /*  ADD es software libre. Puede redistribuirlo y/o modificarlo     */
        !            13: /*  bajo los términos de la Licencia Pública General de GNU         */
        !            14: /*  según es publicada por la Free Software Foundation, bien bajo   */
        !            15: /*  la versión 2 de dicha Licencia o bien (según su elección)       */
        !            16: /*  bajo cualquier versión posterior.                               */
        !            17: /*                                                                  */
        !            18: /*  ADD se distribuye con la esperanza de que sea útil,             */
        !            19: /*  pero SIN NINGUNA GARANTÍA, incluso sin la garantía MERCANTIL    */
        !            20: /*  implícita y sin garantizar la CONVENIENCIA PARA UN PROPÓSITO    */
        !            21: /*  PARTICULAR. Véase la Licencia Pública General de GNU para       */
        !            22: /*  más detalles.                                                   */
        !            23: /*                                                                  */
        !            24: /*  Debería haber recibido una copia de la Licencia Pública General */
        !            25: /*  junto con ADD. Si no ha sido así, escriba a la Free Software    */
        !            26: /*  Foundation, Inc., 51 Franklin St, Fifth Floor,                  */
        !            27: /*  Boston, MA  02110-1301  EEUU.                                   */
        !            28: /*                                                                  */
        !            29: /*  -------------------------- Historia --------------------------- */
        !            30: /*                                                                  */
        !            31: /*  $Id$                                                            */
        !            32: /*                                                                  */
        !            33: /*  Revisión 1.2. 01/2006                                           */
        !            34: /*  Se añade la licencia GPL y documentación en estilo Javadoc      */
        !            35: /*                                                                  */
        !            36: /*  Revisión 1.1. 09/2005                                           */
        !            37: /*  Versión inicial                                                 */
        !            38: /*                                                                  */
        !            39: /********************************************************************/
        !            40: 
1.1       rico       41: /******************************************************************************/
                     42: /* MÓDULO: Recuentos.c                                                        */
                     43: /*                                                                            */
                     44: /* Este módulo se encarga de contabilizar las operaciones y los diferentes    */
                     45: /* accesos a operandos.                                                       */
                     46: /******************************************************************************/
                     47: /* Fecha: 23 de septiembre de 2005                                            */
                     48: /******************************************************************************/
                     49: 
                     50: #include <stdio.h>
                     51: #include <string.h>
                     52: #include <malloc.h>
                     53: 
                     54: #include "defines.h"
                     55: #include "tipos.h"
                     56: #include "recuentos.h"
                     57: 
                     58: 
                     59: /* bases de datos */
                     60: extern unsigned int num_nemonicos;
                     61: extern operacion *nemonicos;
                     62: extern unsigned int num_simbolos;
                     63: extern operando *simbolos;
                     64: extern unsigned int num_tiempos;
                     65: extern tiempo *ciclos;
                     66: 
                     67: /* recuentos */
                     68: extern unsigned long int *contadornemonicos;
                     69: extern unsigned long int *contadorlecturas;
                     70: extern unsigned long int *contadorescrituras;
                     71: 
                     72: 
                     73: /* esta función hace una reserva de memoria para los contadores */
                     74: /* de recuentos de nemónicos y de accesos a operandos */
                     75: 
                     76: void CrearContadores()
                     77: {
                     78:     char mensaje[MAX_LINE];
                     79: 
                     80:     /* reservo memoria para los contadores de nemónicos */
                     81:     contadornemonicos = calloc(num_nemonicos, sizeof(unsigned long int));
                     82:     if (contadornemonicos == NULL)
                     83:     {
                     84:         sprintf(mensaje, "[CrearContadores] Memoria insuficiente");
                     85:         Notificar(mensaje, ERROR_SALIR, ECO_NO);
                     86:         /* el programa finaliza si no hay memoria suficiente */
                     87:     }
                     88: 
                     89: 
                     90:     /* reservo memoria para los contadores de accesos a operandos */
                     91:     /* lecturas */
                     92:     contadorlecturas = calloc(num_simbolos, sizeof(unsigned long int));
                     93:     if (contadorlecturas == NULL)
                     94:     {
                     95:         sprintf(mensaje, "[CrearContadores] Memoria insuficiente");
                     96:         Notificar(mensaje, ERROR_SALIR, ECO_NO);
                     97:         /* el programa finaliza si no hay memoria suficiente */
                     98:     }
                     99:     /* escrituras */
                    100:     contadorescrituras = calloc(num_simbolos, sizeof(unsigned long int));
                    101:     if (contadorlecturas == NULL)
                    102:     {
                    103:         sprintf(mensaje, "[CrearContadores] Memoria insuficiente");
                    104:         Notificar(mensaje, ERROR_SALIR, ECO_NO);
                    105:         /* el programa finaliza si no hay memoria suficiente */
                    106:     }
                    107: }
                    108: 
                    109: 
                    110: /* esta función actualiza los recuentos de operaciones y acceso a */
                    111: /* operandos explícitos; la contabilidad de los implícitos se puede */
                    112: /* obtener posteriormente a partir del recuento de nemónicos */
                    113: 
                    114: void ActualizarRecuentos(fichainstruccion *tarjetaoperandos)
                    115: {
                    116:     int id_nemo, id_simb;
                    117:     char mensaje[MAX_LINE], cadena[MAX_LINE];
                    118:     
                    119:     /* PREFIJO (si lo hay) */
                    120:     if(tarjetaoperandos->prefijo[0]!='\0')
                    121:     {
                    122:         id_nemo = BDBuscarCadena(TABLA_NEMONICOS, CAMPO_NEMONICO, tarjetaoperandos->prefijo);
                    123: 
                    124:         if(id_nemo == -1)
                    125:         {
                    126:             /* emito un error al fichero de log */ 
                    127:             sprintf(mensaje, "[ActualizarRecuentos] La cadena '%s' no se ha encontrado en Tabla Nemónicos", tarjetaoperandos->prefijo);
                    128:             Notificar(mensaje, ERROR_SALIR, ECO_NO);
                    129:         }
                    130: 
                    131:         /* incremento el contador para el nemónico en cuestión */
                    132:         contadornemonicos[id_nemo]++;
                    133:     }
                    134: 
                    135:     /* NEMÓNICO */
                    136:     id_nemo = BDBuscarCadena(TABLA_NEMONICOS, CAMPO_NEMONICO, tarjetaoperandos->nemonico);
                    137: 
                    138:     if(id_nemo == -1)
                    139:     {
                    140:         /* emito un error al fichero de log */ 
                    141:         sprintf(mensaje, "[ActualizarRecuentos] La cadena '%s' no se ha encontrado en Tabla Nemónicos", tarjetaoperandos->nemonico);
                    142:         Notificar(mensaje, ERROR_SALIR, ECO_NO);
                    143:     }
                    144: 
                    145:     /* incremento el contador para el nemónico en cuestión */
                    146:     contadornemonicos[id_nemo]++;
                    147: 
                    148: 
                    149:     /* OP2 (FUENTE) si lo hay */
                    150:     if(tarjetaoperandos->op2[0]!='\0')
                    151:     {
                    152:         strcpy(cadena, tarjetaoperandos->op2);
                    153:         NormalizarUbicacion(cadena);
                    154: 
                    155:         id_simb = BDBuscarCadena(TABLA_SIMBOLOS, CAMPO_SIMBOLO, cadena);
                    156: 
                    157:         if(id_simb == -1)
                    158:         {
                    159:             /* emito un error al fichero de log */ 
                    160:             sprintf(mensaje, "[ActualizarRecuentos] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena);
                    161:             Notificar(mensaje, ERROR_SALIR, ECO_NO);
                    162:         }
                    163: 
                    164:         /* incremento el contador para el símbolo en cuestión según el tipo de acceso */
                    165:         switch(nemonicos[id_nemo].modo_op2)
                    166:         {
                    167:             case LEIDOYESCRITO:        /* leido y escrito */
                    168:             contadorlecturas[id_simb]++;
                    169:             case ESCRITO:            /* escrito */
                    170:             contadorescrituras[id_simb]++;
                    171:             break;
                    172: 
                    173:             case LEIDO:                /* leido */
                    174:             contadorlecturas[id_simb]++;
                    175:             break;
                    176: 
                    177:             case NO_EXISTE:    /* no existe */
                    178:             /* emitir un error al fichero de log */
                    179:             sprintf(mensaje, "[ActualizarRecuentos] El operando no existe");
                    180:             Notificar(mensaje, ERROR_SALIR, ECO_NO);
                    181:             break;
                    182:         }
                    183:     }
                    184: 
                    185:     /* aquí se puede hacer una función ya que el código es igual al anterior */
                    186:     /* OP1 (DESTINO) si lo hay */
                    187:     if(tarjetaoperandos->op1[0]!='\0')
                    188:     {
                    189:         strcpy(cadena, tarjetaoperandos->op1);
                    190:         NormalizarUbicacion(cadena);
                    191: 
                    192:         id_simb = BDBuscarCadena(TABLA_SIMBOLOS, CAMPO_SIMBOLO, cadena);
                    193: 
                    194:         if(id_simb == -1)
                    195:         {
                    196:             /* emito un error al fichero de log */ 
                    197:             sprintf(mensaje, "[ActualizarRecuentos] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena);
                    198:             Notificar(mensaje, ERROR_SALIR, ECO_NO);
                    199:         }
                    200: 
                    201:         /* incremento el contador para el símbolo en cuestión según el tipo de acceso */
                    202:         switch(nemonicos[id_nemo].modo_op1)
                    203:         {
                    204:             case LEIDOYESCRITO:        /* leido y escrito */
                    205:             contadorlecturas[id_simb]++;
                    206:             case ESCRITO:            /* escrito */
                    207:             contadorescrituras[id_simb]++;
                    208:             break;
                    209: 
                    210:             case LEIDO:                /* leido */
                    211:             contadorlecturas[id_simb]++;
                    212:             break;
                    213: 
                    214:             case NO_EXISTE:    /* no existe */
                    215:             /* emitir un error al fichero de log */
                    216:             sprintf(mensaje, "[ActualizarRecuentos] El operando no existe");
                    217:             Notificar(mensaje, ERROR_SALIR, ECO_NO);
                    218:             break;
                    219:         }
                    220:     }
                    221:     /* los accesos a memoria se pueden contabilizar también bajo el nombre 'MEM' */
                    222: }
                    223: 
                    224: 
                    225: /* esta función libera la memoria reservada para los contadores */
                    226: 
                    227: void LiberarMemoriaContadores()
                    228: {
                    229:     free(contadornemonicos);
                    230:     free(contadorlecturas);
                    231:     free(contadorescrituras);
                    232: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>