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