Annotation of ADD_ver_10/Main.c, revision 1.1
1.1 ! rico 1: /********************************************************************/
! 2: /* Main.c */
! 3: /* */
! 4: /* Copyright (c) 1997-2006 Rafael Rico (rafael.rico@uah.es) */
! 5: /* */
! 6: /* This file is part of ADD version 5.10. */
! 7: /* */
! 8: /* ADD is free software; you can redistribute it and/or modify */
! 9: /* it under the terms of the GNU General Public License as */
! 10: /* published by the Free Software Foundation; either version 2 of */
! 11: /* the License, or (at your option) any later version. */
! 12: /* */
! 13: /* ADD is distributed in the hope that it will be useful, */
! 14: /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
! 15: /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
! 16: /* GNU General Public License for more details. */
! 17: /* */
! 18: /* You should have received a copy of the GNU General Public */
! 19: /* License along with ADD; if not, write to the Free Software */
! 20: /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA */
! 21: /* 02111-1307 USA */
! 22: /* */
! 23: /* --------------------------- History --------------------------- */
! 24: /* */
! 25: /* Revision 1.2. 01/2006 */
! 26: /* Added GPL License and JavaDoc style documentation */
! 27: /* */
! 28: /* Revision 1.1. 09/2005 */
! 29: /* Initial Revision */
! 30: /* */
! 31: /********************************************************************/
! 32:
! 33:
! 34: /******************************************************************************/
! 35: /* MÓDULO: Main.c */
! 36: /* */
! 37: /******************************************************************************/
! 38: /* Fecha: 19 de septiembre de 2005 */
! 39: /******************************************************************************/
! 40:
! 41: #include <stdio.h>
! 42: #include <stdlib.h>
! 43: #include <string.h>
! 44:
! 45: #include "defines.h"
! 46: #include "tipos.h"
! 47: #include "main.h"
! 48:
! 49: /* configuración */
! 50: struct argumentos configuracion;
! 51:
! 52: /* bases de datos */
! 53: unsigned int num_nemonicos;
! 54: operacion *nemonicos = NULL;
! 55: unsigned int num_simbolos;
! 56: operando *simbolos = NULL;
! 57:
! 58: unsigned int num_tiempos;
! 59: tiempo *ciclos = NULL;
! 60:
! 61: /* recuentos */
! 62: unsigned long int *contadornemonicos = NULL;
! 63: unsigned long int *contadorlecturas = NULL;
! 64: unsigned long int *contadorescrituras = NULL;
! 65:
! 66: /* contadores de instrucciones y ventanas */
! 67: unsigned long instruccion, ventana;
! 68:
! 69: /* otros resultados */
! 70: double cpimedio = 0.0;
! 71: double tiempoejecucion = 0.0;
! 72: unsigned long *distribucionpasos = NULL;
! 73:
! 74: /* posibles ubicaciones de datos */
! 75: unsigned int num_ubicaciones;
! 76: ubicacion *datos = NULL;
! 77:
! 78: /* análisis de dependencias de datos */
! 79: int *pizarra_escrituras = NULL;
! 80: int **pizarra_lecturas = NULL;
! 81:
! 82: unsigned char *vector = NULL;
! 83:
! 84: struct punterosD matriz;
! 85: unsigned char **matrizC = NULL; /* matriz de caminos de dependencias */
! 86: char **OrdenParcial = NULL; /* lista de instrucciones según orden parcial de D */
! 87:
! 88: /* parámetros asociados a las matrices */
! 89: parametromatriz *pasos = NULL;
! 90: parametromatriz *mediapasos = NULL;
! 91: parametromatriz *grado = NULL;
! 92: parametromatriz *mediagrado = NULL;
! 93: parametromatriz *acoplo = NULL;
! 94: parametromatriz *mediaacoplo = NULL;
! 95:
! 96:
! 97: /* declaro aquí mismo algunas funciones sencillas para no repetir secuencias de código */
! 98:
! 99: void ProcesarInstruccion(unsigned int ins, unsigned char secuencia[12], fichainstruccion *tarjetaoperandos)
! 100: {
! 101: AnalizarOperandosIA16(secuencia, tarjetaoperandos);
! 102:
! 103: if(configuracion.recuentos == SI) ActualizarRecuentos(tarjetaoperandos);
! 104:
! 105: if(configuracion.cpi == SI) CalcularCiclosInstruccion(tarjetaoperandos);
! 106:
! 107: if(configuracion.CPImedio == SI) ActualizarCPImedio(tarjetaoperandos->ciclosALU, tarjetaoperandos->ciclosBIU);
! 108:
! 109: if(configuracion.dependencias == SI)
! 110: {
! 111: AnalizarDependencias(tarjetaoperandos, ins);
! 112:
! 113: AnotarEscrituras(tarjetaoperandos, ins);
! 114: AnotarLecturas(tarjetaoperandos, ins);
! 115:
! 116: /* si tengo que calcular el tiempo de ejecución */
! 117: /* debo construir un array con el tipo de instrucción */
! 118: /* y su latencia en ciclos */
! 119: }
! 120: }
! 121:
! 122: void IniciarVentana()
! 123: {
! 124: if(configuracion.dependencias == SI)
! 125: {
! 126: IniciarPizarras();
! 127: IniciarVectorDependencias();
! 128: IniciarMatricesDependencias();
! 129: if(configuracion.ordenparcial == SI) IniciarListaOrdenParcial();
! 130: if(configuracion.matrizcaminos == SI) IniciarMatrizCaminos();
! 131: if(configuracion.pasoscomputacion == SI) IniciarVariableAgregada(pasos);
! 132: if(configuracion.gradoparalelismo == SI) IniciarVariableAgregada(grado);;
! 133: if(configuracion.acoplamiento == SI) IniciarVariableAgregada(acoplo);
! 134: }
! 135: }
! 136:
! 137: void ProcesarVentana()
! 138: {
! 139: if(configuracion.dependencias == SI)
! 140: {
! 141: GenerarMatrizD(); /* a partir de las matrices desacopladas */
! 142:
! 143: /* EXTRAIGO INFORMACIÓN DE LAS MATRICES */
! 144: /* lista orden parcial (la función también puede devolver pasos) */
! 145: if(configuracion.ordenparcial == SI) ListaOrdenParcial(matriz.D, OrdenParcial);
! 146: /* matriz de caminos (la función también puede devolver pasos) */
! 147: if(configuracion.matrizcaminos == SI) CalcularMatrizCaminos(matriz.D, matrizC);
! 148: /* pasos de computación */
! 149: if(configuracion.pasoscomputacion == SI)
! 150: {
! 151: /* pasos de computación de todas las matrices de dependencias */
! 152: CalcularPasosComputacion(pasos);
! 153: if(configuracion.distribucionpasos == SI) ActualizarHistogramaPasos();
! 154: /* valor medio de pasos de computación */
! 155: CalcularPromedioVariableAgregada(mediapasos, pasos, ventana);
! 156: }
! 157: /* grado de paralelismo (a partir de los pasos de computación) */
! 158: if(configuracion.gradoparalelismo == SI)
! 159: {
! 160: /* grado de paralelismo a partir de los pasos de computación */
! 161: CalcularGradoParalelismoNormalizado(pasos, grado);
! 162: /* valor medio del grado de paralelismo */
! 163: CalcularPromedioVariableAgregada(mediagrado, grado, ventana);
! 164: }
! 165: /* acoplamiento */
! 166: if(configuracion.acoplamiento == SI);
! 167: {
! 168: /* grado de paralelismo a partir de los pasos de computación */
! 169: CalcularAcoplamiento(acoplo);
! 170: /* valor medio del grado de paralelismo */
! 171: CalcularPromedioVariableAgregada(mediaacoplo, acoplo, ventana);
! 172: }
! 173:
! 174: if(configuracion.tiempo == SI) tiempoejecucion = CalcularTiempo();
! 175: }
! 176: }
! 177:
! 178: void ReservarMemoriaAnalisisDependencias()
! 179: {
! 180: CrearPizarras();
! 181:
! 182: CrearVectorDependencias();
! 183:
! 184: CrearMatricesDependencias();
! 185:
! 186: if(configuracion.ordenparcial == SI) CrearListaOrdenParcial();
! 187: if(configuracion.matrizcaminos == SI) CrearMatrizCaminos();
! 188: if(configuracion.pasoscomputacion == SI)
! 189: {
! 190: pasos = CrearVariableAgregada();
! 191: IniciarVariableAgregada(pasos);
! 192: mediapasos = CrearVariableAgregada();
! 193: IniciarVariableAgregada(mediapasos);
! 194: if(configuracion.distribucionpasos == SI) CrearHistogramaPasos();
! 195: }
! 196: if(configuracion.gradoparalelismo == SI);
! 197: {
! 198: grado = CrearVariableAgregada();
! 199: IniciarVariableAgregada(grado);
! 200: mediagrado = CrearVariableAgregada();
! 201: IniciarVariableAgregada(mediagrado);
! 202: }
! 203: if(configuracion.acoplamiento == SI);
! 204: {
! 205: acoplo = CrearVariableAgregada();
! 206: IniciarVariableAgregada(acoplo);
! 207: mediaacoplo = CrearVariableAgregada();
! 208: IniciarVariableAgregada(mediaacoplo);
! 209: }
! 210: }
! 211:
! 212:
! 213: void LiberarMemoriaAnalisisDependencias()
! 214: {
! 215: LiberarMemoriaPizarras();
! 216: LiberarMemoriaVectorDependencias();
! 217: LiberarMemoriaMatricesDependencias();
! 218:
! 219: if(configuracion.ordenparcial == SI) LiberarMemoriaListaOrdenParcial();
! 220: if(configuracion.matrizcaminos == SI) LiberarMemoriaMatrizCaminos();
! 221:
! 222: if(configuracion.pasoscomputacion == SI) {free(pasos); free(mediapasos);}
! 223: if(configuracion.gradoparalelismo == SI) {free(grado); free(mediagrado);};
! 224: if(configuracion.acoplamiento == SI) {free(acoplo); free(mediaacoplo);};
! 225:
! 226: if(configuracion.distribucionpasos == SI) LiberarMemoriaHistogramaPasos();
! 227: }
! 228:
! 229:
! 230:
! 231:
! 232:
! 233: void main(int argc, char *argv[])
! 234: {
! 235: /* puntero al fichero origen de datos */
! 236: FILE *origendatos;
! 237: /* total instrucciones y ventanas a procesar */
! 238: unsigned long total_ins, total_ven;
! 239: /* secuencia en bytes de 2 instrucciones consecutivas */
! 240: unsigned char secuencia[2*BYTES_POR_INSTRUCCION];
! 241: /* reservo espacio para una estructura de tipo ficha de instrucción */
! 242: fichainstruccion tarjetaoperandos;
! 243:
! 244: unsigned int i, ins;
! 245: char cadena[MAX_LINE];
! 246: char mensaje[MAX_LINE];
! 247: unsigned char salvarventana = NO;
! 248: char listadoventanas[MAX_LINE];
! 249:
! 250:
! 251: /* inicio los punteros de las matrices de dependencias a NULL */
! 252: /* es una medida higiénica pero no necesaria ya que la reserva de memoria */
! 253: /* correspondiente a la declaración se hace rellenando con 0s */
! 254:
! 255: /* ver si es posible con {NULL, NULL...} */
! 256: IniciarPunterosMatrices();
! 257:
! 258: /* NOTIFICACIONES DE SUCESOS Y ERRORES */
! 259: /* inicio el fichero que va a recibir las notificaciones */
! 260: IniciarNotificaciones();
! 261:
! 262: /* CONFIGURACIÓN */
! 263: /* cargo la configuración de la aplicación por defecto */
! 264: CargarConfiguracionInicial();
! 265: /* modifico la configuración de la aplicación en función de los argumentos */
! 266: CapturarArgumentos(argc, argv);
! 267:
! 268: /* escribo la configuración en el fichero de notificaciones */
! 269: if(configuracion.nivelnotificaciones != EX_CFG) NotificarConfiguracion();
! 270:
! 271: /* BASES DE DATOS */
! 272: CargarBasesDatos();
! 273:
! 274: /* CALCULOS A REALIZAR */
! 275: if(configuracion.recuentos == SI) CrearContadores();
! 276: if(configuracion.dependencias == SI) ReservarMemoriaAnalisisDependencias();
! 277:
! 278: /* FICHEROS A CREAR */
! 279: if(configuracion.volcarBD == SI) SalvarBasesDatos();
! 280: if(configuracion.crearficheroconfig == SI) CrearFicheroConfiguracion();
! 281:
! 282: /* PROCESAMIENTO */
! 283: if(configuracion.origen == TRAZA)
! 284: {
! 285: /* determino el rango de instrucciones a analizar */
! 286: DeterminarRango();
! 287: /* determino el número total de instrucciones */
! 288: total_ins = (unsigned long)(configuracion.ultima - configuracion.primera + 1);
! 289: /* determino el número de ventanas de instrucciones */
! 290: total_ven = (unsigned long)total_ins/configuracion.ventana;
! 291: /* inicio los contadores */
! 292: instruccion = 1; /* cuento las instrucciones desde el '1' */
! 293: ventana = 0;
! 294: /* listado de ventanas a volcar */
! 295: strcpy(listadoventanas, configuracion.volcarventana);
! 296:
! 297: /* abro el fichero de traza */
! 298: if((origendatos = fopen(configuracion.ficherodatos, "rb")) != NULL)
! 299: {
! 300: sprintf(mensaje, "[Main] El fichero '%s' se ha abierto con éxito", configuracion.ficherodatos);
! 301: Notificar(mensaje, NO_ERROR, ECO_NO);
! 302:
! 303: /* sitúo el puntero del fichero en la instrucción de comienzo */
! 304: fseek(origendatos, (configuracion.primera - 1) * BYTES_POR_INSTRUCCION, SEEK_SET);
! 305:
! 306: /* leo el formato de la primera instrucción a tratar */
! 307: /* y lo coloco en la parte alta de la secuencia (2ª instrucción) */
! 308: for(i=0; i<BYTES_POR_INSTRUCCION; i++) secuencia[i+BYTES_POR_INSTRUCCION] = fgetc(origendatos);
! 309:
! 310: while(total_ven-ventana)
! 311: {
! 312: ventana++;
! 313: IniciarVentana();
! 314:
! 315: /* ¿salvar información de la ventana en curso? */
! 316: if(listadoventanas[0] != '\0') /* si el listado no es vacío */
! 317: {
! 318: sprintf(cadena, "%lu", ventana);
! 319: if(BuscarElementoLista(listadoventanas, cadena) != 0)
! 320: {
! 321: salvarventana = SI;
! 322: EliminarElementoLista(listadoventanas, cadena);
! 323: /* construyo una planilla con resultados de la ventana en curso */
! 324: IniciarFicheroVentana();
! 325: }
! 326: else salvarventana = NO;
! 327: }
! 328:
! 329: for(ins=0; ins<configuracion.ventana; ins++, instruccion++)
! 330: {
! 331: /* paso el formato de la parte alta a la baja */
! 332: for(i=0; i<BYTES_POR_INSTRUCCION; i++) secuencia[i] = secuencia[i+BYTES_POR_INSTRUCCION];
! 333: /* leo el formato de la instrucción siguiente desde la traza */
! 334: for(i=0; i<BYTES_POR_INSTRUCCION; i++) secuencia[i+BYTES_POR_INSTRUCCION] = fgetc(origendatos);
! 335:
! 336: ProcesarInstruccion(ins, secuencia, &tarjetaoperandos);
! 337:
! 338: if(configuracion.verinstruccion == SI) MostrarTarjeta(&tarjetaoperandos);
! 339:
! 340: if(salvarventana == SI) Instruccion2FicheroVentana(&tarjetaoperandos);
! 341:
! 342: /* _getch(); */
! 343: }
! 344: ProcesarVentana();
! 345:
! 346: if(configuracion.verventana == SI) MostrarVentana();
! 347:
! 348: /* salvo las matrices de la ventana en la planilla y sus parámetros */
! 349: if(salvarventana == SI) Matrices2FicheroVentana();
! 350: }
! 351:
! 352: /* cierro el fichero de traza */
! 353: if(fclose(origendatos))
! 354: {
! 355: sprintf(mensaje, "[Main] El fichero '%s' no se ha podido cerrar", configuracion.ficherodatos);
! 356: Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
! 357: }
! 358: else
! 359: {
! 360: sprintf(mensaje, "[Main] El fichero '%s' ha sido cerrado con éxito", configuracion.ficherodatos);
! 361: Notificar(mensaje, NO_ERROR, ECO_NO);
! 362: }
! 363: }
! 364: else
! 365: {
! 366: sprintf(mensaje, "[Main] El fichero '%s' no se ha podido abrir", configuracion.ficherodatos);
! 367: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 368: }
! 369: }
! 370:
! 371: else if(configuracion.origen == SECUENCIA)
! 372: {
! 373: /* abro el fichero de la secuencia */
! 374: if((origendatos = fopen(configuracion.ficherodatos, "r")) != NULL)
! 375: {
! 376: sprintf(mensaje, "[Main] El fichero '%s' se ha abierto con éxito", configuracion.ficherodatos);
! 377: Notificar(mensaje, NO_ERROR, ECO_NO);
! 378:
! 379: /* cuento las instrucciones de la secuencia */
! 380: ins = 0;
! 381: while(!feof(origendatos))
! 382: {
! 383: fgets (cadena, MAX_LINE, origendatos);
! 384:
! 385: if (cadena[0]!='\n' && cadena[0]!='#') ins++;
! 386: }
! 387: configuracion.primera = 1;
! 388: configuracion.ultima = ins;
! 389:
! 390: /* determino el número total de instrucciones */
! 391: total_ins = (unsigned long)(configuracion.ultima - configuracion.primera + 1);
! 392: /* determino el número de ventanas de instrucciones */
! 393: total_ven = (unsigned long)total_ins/configuracion.ventana;
! 394: /* inicio los contadores */
! 395: instruccion = 1; /* cuento las instrucciones desde el '1' */
! 396: ventana = 0;
! 397: /* listado de ventanas a volcar */
! 398: strcpy(listadoventanas, configuracion.volcarventana);
! 399:
! 400:
! 401: /* coloco el puntero del fichero al principio */
! 402: fseek(origendatos, 0L, SEEK_SET);
! 403:
! 404: /* comienzo el análisis de la secuencia */
! 405: while(total_ven-ventana)
! 406: {
! 407: ventana++;
! 408: IniciarVentana();
! 409:
! 410: /* ¿salvar información de la ventana en curso? */
! 411: if(listadoventanas[0] != '\0') /* si el listado no es vacío */
! 412: {
! 413: sprintf(cadena, "%lu", ventana);
! 414: if(BuscarElementoLista(listadoventanas, cadena) != 0)
! 415: {
! 416: salvarventana = SI;
! 417: EliminarElementoLista(listadoventanas, cadena);
! 418: /* construyo una planilla con resultados de la ventana en curso */
! 419: IniciarFicheroVentana();
! 420: }
! 421: else salvarventana = NO;
! 422: }
! 423:
! 424: for(ins=0; ins<configuracion.ventana; ins++, instruccion++)
! 425: {
! 426: do
! 427: {
! 428: fgets (cadena, MAX_LINE, origendatos);
! 429: }
! 430: while (cadena[0]=='\n' || cadena[0]=='#');
! 431:
! 432: /* quito el caracter '\n' (0x0A) final de la cadena correspondiente a una línea de texto */
! 433: /* ¡OJO! si abro el fichero en modo binario el final de linea es "\r\n" (0x0D 0x0A) */
! 434: *(cadena+strlen(cadena)-1)='\0';
! 435:
! 436: ConvertirHex2Bin(cadena, secuencia, BYTES_POR_INSTRUCCION);
! 437:
! 438: ProcesarInstruccion(ins, secuencia, &tarjetaoperandos);
! 439:
! 440: if(configuracion.verinstruccion == SI) MostrarTarjeta(&tarjetaoperandos);
! 441:
! 442: /* salvo las instrucciones en la planilla de la ventana */
! 443: if(salvarventana == SI) Instruccion2FicheroVentana(&tarjetaoperandos);
! 444: }
! 445:
! 446: ProcesarVentana();
! 447:
! 448: if(configuracion.verventana == SI) MostrarVentana();
! 449:
! 450: /* salvo las matrices de la ventana en la planilla y sus parámetros */
! 451: if(salvarventana == SI) Matrices2FicheroVentana();
! 452: }
! 453:
! 454: /* cierro el fichero de la secuencia */
! 455: if(fclose(origendatos))
! 456: {
! 457: sprintf(mensaje, "[Main] El fichero '%s' no se ha podido cerrar", configuracion.ficherodatos);
! 458: Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
! 459: }
! 460: else
! 461: {
! 462: sprintf(mensaje, "[Main] El fichero '%s' ha sido cerrado con éxito", configuracion.ficherodatos);
! 463: Notificar(mensaje, NO_ERROR, ECO_NO);
! 464: }
! 465: }
! 466: else
! 467: {
! 468: sprintf(mensaje, "[Main] El fichero '%s' no se ha podido abrir", configuracion.ficherodatos);
! 469: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 470: }
! 471: }
! 472:
! 473: else if(configuracion.origen == CADENAHEX)
! 474: {
! 475: instruccion = 1;
! 476: ventana = 1;
! 477:
! 478: ConvertirHex2Bin(configuracion.cadenahex, secuencia, BYTES_POR_INSTRUCCION);
! 479:
! 480: AnalizarOperandosIA16(secuencia, &tarjetaoperandos);
! 481:
! 482: if(configuracion.cpi == SI) CalcularCiclosInstruccion(&tarjetaoperandos);
! 483:
! 484: /* if(configuracion.verinstruccion == SI) */
! 485: /* muestro en la pantalla la información siempre */
! 486: MostrarTarjeta(&tarjetaoperandos);
! 487: }
! 488:
! 489: /* SALVAR RESULTADOS */
! 490: /* salvo los resultados en un fichero de formato EXCEL */
! 491: if(configuracion.origen != CADENAHEX) CrearFicheroResultados(configuracion.ficheroresultados);
! 492:
! 493: /* LIBERAR MEMORIA */
! 494: /* al final hay que liberar toda la memoria reservada */
! 495: LiberarMemoriaBasesDatos();
! 496: if(configuracion.recuentos == SI) LiberarMemoriaContadores();
! 497: if(configuracion.dependencias == SI) LiberarMemoriaAnalisisDependencias();
! 498: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository ATC2] / ADD_ver_10