/********************************************************************/
/* CalculosMatrices.h */
/* */
/* Copyright (c) 1997-2006 Rafael Rico (rafael.rico@uah.es) */
/* */
/* This file is part of ADD version 5.10. */
/* */
/* ADD is free software; you can redistribute it and/or modify */
/* it under the terms of the GNU General Public License as */
/* published by the Free Software Foundation; either version 2 of */
/* the License, or (at your option) any later version. */
/* */
/* ADD is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public */
/* License along with ADD; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA */
/* 02111-1307 USA */
/* */
/* --------------------------- History --------------------------- */
/* */
/* Revision 1.2. 01/2006 */
/* Added GPL License and JavaDoc style documentation */
/* */
/* Revision 1.1. 09/2005 */
/* Initial Revision */
/* */
/********************************************************************/
/******************************************************************************/
/* MÓDULO: CalculosMatrices.c */
/* */
/* Este módulo contiene las funciones que realizan cálculos sobre */
/* las matrices. */
/******************************************************************************/
/* Fecha: 26 de septiembre de 2005 */
/******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "defines.h"
#include "tipos.h"
#include "calculosmatrices.h"
/* configuración */
extern struct argumentos configuracion;
/* análisis de dependencias de datos */
extern struct punterosD matriz;
extern unsigned char **matrizC;
extern char **OrdenParcial;
/* parámetros asociados a las matrices */
extern parametromatriz *pasos;
extern parametromatriz *mediapasos;
extern parametromatriz *grado;
extern parametromatriz *mediagrado;
extern parametromatriz *acoplo;
extern parametromatriz *mediaacoplo;
/* otros resultados */
extern unsigned long *distribucionpasos;
/* esta función calcula la matriz de caminos de dependencias C */
/* a partir de una matriz de dependencias D */
/* devuelve el número de pasos de computación requeridos para */
/* finalizar la computación de la secuencia expresada por D */
/* (la matriz de caminos devuelta no ha sido reducida a 0s y 1s) */
/* esta función es muy consumidora de tiempo ya que calcula potencias de D */
unsigned int CalcularMatrizCaminos(unsigned char **D, unsigned char **C)
{
char mensaje[MAX_LINE];
unsigned char *v; /* vector temporal */
unsigned char **tmp; /* matriz temporal */
unsigned int i, j, k, potencia;
unsigned int suma;
unsigned char matriz_nula;
if(D == NULL)
{
sprintf(mensaje, "[CalcularMatrizCaminos] La matriz D indicada no existe");
Notificar(mensaje, ERROR_SALIR, ECO_NO);
}
/* necesito un vector y una matriz temporal de 'unsigned char' */
/* para calcular las sucesivas potencias de la matriz D */
/* hago la reserva de memoria para el vector */
v = calloc(configuracion.ventana , sizeof(unsigned char *));
if (v == NULL)
{
sprintf(mensaje, "[CalcularMatrizCaminos] Memoria insuficiente");
Notificar(mensaje, ERROR_SALIR, ECO_NO);
/* el programa finaliza si no hay memoria suficiente */
}
/* hago la reserva de memoria para la matriz */
/* 1º un puntero por cada fila */
tmp = calloc(configuracion.ventana , sizeof(unsigned char *));
if (tmp == NULL)
{
sprintf(mensaje, "[CalcularMatrizCaminos] Memoria insuficiente");
Notificar(mensaje, ERROR_SALIR, ECO_NO);
/* el programa finaliza si no hay memoria suficiente */
}
/* 2º un 'char' por cada columna */
for(i=0; i<configuracion.ventana; i++)
{
tmp[i] = calloc(configuracion.ventana, sizeof(unsigned char));
if (tmp[i] == NULL)
{
sprintf(mensaje, "[CalcularMatrizCaminos] Memoria insuficiente");
Notificar(mensaje, ERROR_SALIR, ECO_NO);
/* el programa finaliza si no hay memoria suficiente */
}
}
/* inicio la matriz temporal con la matriz 'identidad' (1s en la diagonal) */
/* al reservar con 'calloc' se rellena con 0s */
for(i=0; i<configuracion.ventana; i++) tmp[i][i] = 1;
/* calculo sucesivas potencias de la matriz 'D' hasta que se anule */
/* utilizo la expresión TMP * D = TMP */
/* el uso del vector me permite escribir el resultado sobre 'TMP' */
for(potencia=0; potencia<configuracion.ventana; potencia++)
{
for(i=0; i<configuracion.ventana; i++)
{
for(k=0; k<configuracion.ventana; k++) v[k]=tmp[i][k];
for(j=0; j<configuracion.ventana; j++)
{
suma = 0;
for(k=0; k<configuracion.ventana; k++)
{
suma += v[k] * D[k][j];
}
tmp[i][j] = suma;
}
}
/* la matriz 'TMP' contiene la n-ésima+1 potencia de 'D' */
/* ahora evalúo si el resultado es la matriz nula */
/* si es así no tengo que continuar ya que no hay */
/* caminos de dependencias de longitud mayor */
matriz_nula = SI;
for(i=0; i<configuracion.ventana; i++)
{
for(j=0; j<configuracion.ventana; j++)
{
if(tmp[i][j] != 0) {matriz_nula = NO; break;}
}
if(matriz_nula == NO) break;
}
if(matriz_nula == SI) break;
/* sumo la nueva potencia de la matriz de dependencias D^^p */
/* a la matriz de caminos parcial 'C' si me han pasado un puntero no nulo */
if(*C != NULL)
{
for(i=0; i<configuracion.ventana; i++)
{
for(j=0; j<configuracion.ventana; j++) C[i][j] += tmp[i][j];
}
}
}
/* libero la memoria reservada anteriormente */
/* libero el vector */
free(v);
/* libero la matriz */
for(i=0; i<configuracion.ventana; i++) free(tmp[i]); free(tmp);
return potencia+1; /* devuelve el rango de la primera potencia nula de 'D' */
}
/* esta función establece la lista del orden parcial contenido en D */
/* y devuelve el número de pasos de computación del camino crítico */
/* si le pasamos un puntero NULO en el parámetro lista sólo realiza el */
/* calculo de pasos de computación (método más rápido que el anterior) */
/* se asume que la matriz D no ha sido reducida a 0s y 1s */
unsigned int ListaOrdenParcial(unsigned char **D, char **lista)
{
char mensaje[MAX_LINE];
unsigned char *lanzadas; /* vector de instrucciones lanzadas */
unsigned char **tmp; /* matriz temporal */
unsigned int pasos, procesadas;
unsigned int i, j;
char cadena[6]; /* cadena para pasar enteros a strings */
if(D == NULL)
{
sprintf(mensaje, "[ListaOrdenParcial] La matriz D indicada no existe");
Notificar(mensaje, ERROR_SALIR, ECO_NO);
}
/* necesito un vector y una matriz temporal de 'unsigned char' */
/* para calcular las sucesivas potencias de la matriz D */
/* hago la reserva de memoria para el vector */
lanzadas = calloc(configuracion.ventana , sizeof(unsigned char *));
if (lanzadas == NULL)
{
sprintf(mensaje, "[ListaOrdenParcial] Memoria insuficiente");
Notificar(mensaje, ERROR_SALIR, ECO_NO);
/* el programa finaliza si no hay memoria suficiente */
}
/* hago la reserva de memoria para la matriz */
/* 1º un puntero por cada fila */
tmp = calloc(configuracion.ventana , sizeof(unsigned char *));
if (tmp == NULL)
{
sprintf(mensaje, "[ListaOrdenParcial] Memoria insuficiente");
Notificar(mensaje, ERROR_SALIR, ECO_NO);
/* el programa finaliza si no hay memoria suficiente */
}
/* 2º un 'char' por cada columna */
for(i=0; i<configuracion.ventana; i++)
{
tmp[i] = calloc(configuracion.ventana, sizeof(unsigned char));
if (tmp[i] == NULL)
{
sprintf(mensaje, "[ListaOrdenParcial] Memoria insuficiente");
Notificar(mensaje, ERROR_SALIR, ECO_NO);
/* el programa finaliza si no hay memoria suficiente */
}
}
/* copio la matriz de dependencias D sobre la temporal */
for(i=0; i<configuracion.ventana; i++)
{
for(j=0; j<configuracion.ventana; j++) tmp[i][j] = D[i][j];
}
/* pongo a cero el vector de lanzadas */
for(i=0; i<configuracion.ventana; i++) lanzadas[i] = 0;
/* inicio el contador de pasos de computaci¢n */
pasos = 0;
/* inicio el contador de instrucciones procesadas */
procesadas = 0;
while(configuracion.ventana - procesadas)
{
pasos++;
/* busco tareas independientes entre las NO lanzadas */
for(i=0; i<configuracion.ventana; i++)
{
if(lanzadas[i]==0) /* si es 0 significa que no se ha lanzado */
{
/* miro si el vector de dependencias es nulo */
for(j=0; j<i; j++)
{
if(tmp[i][j]!=0) break;
}
if(j==i)
{
lanzadas[i]=1; /* la instrucci¢n es independiente */
/* anoto la instrucción en la lista del orden parcial */
/* en el paso de computación en curso */
if(lista != NULL)
{
sprintf(cadena, "%u", i);
AgregarElementoLista(lista[pasos-1], cadena);
}
}
}
}
/* ahora actualizo la matriz de dependencias con la lista de */
/* instrucciones independientes que han sido lanzadas */
for(i=0; i<configuracion.ventana; i++)
{
if(lanzadas[i]==1) /* si es 1 significa que es independiente */
{
for(j=i+1; j<configuracion.ventana; j++)
{
if(tmp[j][i]!=0) tmp[j][i]=0;
}
}
}
/* ahora actualizo el vector de lanzadas */
for(i=0; i<configuracion.ventana; i++)
{
if(lanzadas[i]==1)
{
lanzadas[i]=2; /* significa que ha sido procesada */
procesadas++;
}
}
}
/* libero la memoria reservada anteriormente */
/* libero el vector */
free(lanzadas);
/* libero la matriz */
for(i=0; i<configuracion.ventana; i++) free(tmp[i]); free(tmp);
return pasos;
}
/* esta función determina el 'acoplamiento' de una matriz de dependencias de datos */
unsigned int Acoplamiento(unsigned char **D)
{
char mensaje[MAX_LINE];
unsigned int i, j;
unsigned int acoplo = 0;
if(D == NULL)
{
sprintf(mensaje, "[Acoplamiento] La matriz D indicada no existe");
Notificar(mensaje, ERROR_SALIR, ECO_NO);
}
/* puesto que las matrices se obtienen de la secuencia de código */
/* estamos seguros de que son canónicas y, por tanto, no es necesario */
/* hacer el recorrido completo de todas sus componentes */
/* basta con empezar en la instrucción 1 y recorres columnas hasta la diagonal */
for(i=1; i<configuracion.ventana; i++)
{
for(j=0; j<i; j++) if(D[i][j] != 0) acoplo++;
}
return acoplo;
}
/* esta función reserva memoria para un array de 'num_cadenas' de punteros /*
/* a cadenas de caracteres de tamaño fijo 'tamano' y devuelve el puntero */
/* con esta estructura implantaremos la lista de orden parcial */
/* trabajando con punteros a char y cadenas de tamaño variable puede */
/* ser más eficaz pero es necesario ser más cuidadoso */
char ** CrearArrayStrings(unsigned int num_cadenas, unsigned int tamano)
{
char mensaje[MAX_LINE];
unsigned int i;
char **listado;
/* 1º un puntero por cada fila */
listado = calloc(num_cadenas, sizeof(char *));
if (listado == NULL)
{
sprintf(mensaje, "[CrearArrayStrings] Memoria insuficiente");
Notificar(mensaje, ERROR_SALIR, ECO_NO);
/* el programa finaliza si no hay memoria suficiente */
}
/* 2º cuatro 'char' por cada columna (3 caracteres de número y un separador ':') */
for(i=0; i<configuracion.ventana; i++)
{
listado[i] = calloc(tamano, sizeof(char));
if (listado[i] == NULL)
{
sprintf(mensaje, "[CrearArrayStrings] Memoria insuficiente");
Notificar(mensaje, ERROR_SALIR, ECO_NO);
/* el programa finaliza si no hay memoria suficiente */
}
}
return listado;
}
/* reserva memoria para construir un listado de orden parcial: */
/* cada línea del listado corresponde a un paso de computación */
/* y cada paso de computación contiene una cadena con la lista */
/* de instrucciones sin dependencias de datos en ese momento */
void CrearListaOrdenParcial()
{
unsigned int dim;
dim = configuracion.ventana;
OrdenParcial = CrearArrayStrings(dim, 4*dim);
}
/* inicia el listado de orden parcial rellenando con la cadena vacía '\0' */
void IniciarListaOrdenParcial()
{
unsigned int i, dim;
dim = configuracion.ventana;
if(OrdenParcial != NULL) for(i=0; i<dim; i++) *OrdenParcial[i] = '\0';
}
/* libera la memoria reservada para el listado de orden parcial */
void LiberarMemoriaListaOrdenParcial()
{
unsigned int i,dim;
dim = configuracion.ventana;
if(OrdenParcial != NULL)
{
for(i=0; i<dim; i++)
{
free(OrdenParcial[i]);
}
free(OrdenParcial);
}
}
/* crea la matriz de caminos de dependencias */
void CrearMatrizCaminos()
{
matrizC = CrearMatriz();
}
/* inicia la matriz de caminos de dependencias */
void IniciarMatrizCaminos()
{
IniciarMatriz(matrizC);
}
/* libera la memoria de la matriz de caminos */
void LiberarMemoriaMatrizCaminos()
{
LiberarMemoriaMatriz(matrizC);
}
/* reserva espacio en memoria para una variable agregada */
parametromatriz * CrearVariableAgregada()
{
char mensaje[MAX_LINE];
parametromatriz *variable;
variable = calloc(1, sizeof(parametromatriz));
if (variable == NULL)
{
sprintf(mensaje, "[CrearVariableAgragada] Memoria insuficiente");
Notificar(mensaje, ERROR_SALIR, ECO_NO);
/* el programa finaliza si no hay memoria suficiente */
}
return variable;
}
/* inicia a 0 una variable agregada */
void IniciarVariableAgregada(parametromatriz *variable)
{
variable->Ddatoexp = 0.0;
variable->Ddir_exp = 0.0;
variable->Dpilaexp = 0.0;
variable->Destadoexp = 0.0;
variable->Ddatoimp = 0.0;
variable->Ddir_imp = 0.0;
variable->Dpilaimp = 0.0;
variable->Destadoimp = 0.0;
variable->ADdatoexp = 0.0;
variable->ADdir_exp = 0.0;
variable->ADpilaexp = 0.0;
variable->ADestadoexp = 0.0;
variable->ADdatoimp = 0.0;
variable->ADdir_imp = 0.0;
variable->ADpilaimp = 0.0;
variable->ADestadoimp = 0.0;
variable->Sdatoexp = 0.0;
variable->Sdir_exp = 0.0;
variable->Spilaexp = 0.0;
variable->Sestadoexp = 0.0;
variable->Sdatoimp = 0.0;
variable->Sdir_imp = 0.0;
variable->Spilaimp = 0.0;
variable->Sestadoimp = 0.0;
variable->D = 0.0;
}
/* esta función calcula el nuevo promedio de una variable agregada (media) a partir del */
/* índice (n) y del valor actual o en curso de esa variable (actual) */
/*
void CalcularPromedioVariableAgregada(parametromatriz *media, parametromatriz *actual, unsigned long n)
{
if(matriz.Ddatoexp != NULL) media->Ddatoexp = ((n - 1) * media->Ddatoexp + actual->Ddatoexp) / n;
if(matriz.Ddir_exp != NULL) media->Ddir_exp = ((n - 1) * media->Ddir_exp + actual->Ddir_exp) / n;
if(matriz.Dpilaexp != NULL) media->Dpilaexp = ((n - 1) * media->Dpilaexp + actual->Dpilaexp) / n;
if(matriz.Destadoexp != NULL) media->Destadoexp = ((n - 1) * media->Destadoexp + actual->Destadoexp) / n;
if(matriz.Ddatoimp != NULL) media->Ddatoimp = ((n - 1) * media->Ddatoimp + actual->Ddatoimp) / n;
if(matriz.Ddir_imp != NULL) media->Ddir_imp = ((n - 1) * media->Ddir_imp + actual->Ddir_imp) / n;
if(matriz.Dpilaimp != NULL) media->Dpilaimp = ((n - 1) * media->Dpilaimp + actual->Dpilaimp) / n;
if(matriz.Destadoimp != NULL) media->Destadoimp = ((n - 1) * media->Destadoimp + actual->Destadoimp) / n;
if(matriz.ADdatoexp != NULL) media->ADdatoexp = ((n - 1) * media->ADdatoexp + actual->ADdatoexp) / n;
if(matriz.ADdir_exp != NULL) media->ADdir_exp = ((n - 1) * media->ADdir_exp + actual->ADdir_exp) / n;
if(matriz.ADpilaexp != NULL) media->ADpilaexp = ((n - 1) * media->ADpilaexp + actual->ADpilaexp) / n;
if(matriz.ADestadoexp != NULL) media->ADestadoexp = ((n - 1) * media->ADestadoexp + actual->ADestadoexp) / n;
if(matriz.ADdatoimp != NULL) media->ADdatoimp = ((n - 1) * media->ADdatoimp + actual->ADdatoimp) / n;
if(matriz.ADdir_imp != NULL) media->ADdir_imp = ((n - 1) * media->ADdir_imp + actual->ADdir_imp) / n;
if(matriz.ADpilaimp != NULL) media->ADpilaimp = ((n - 1) * media->ADpilaimp + actual->ADpilaimp) / n;
if(matriz.ADestadoimp != NULL) media->ADestadoimp = ((n - 1) * media->ADestadoimp + actual->ADestadoimp) / n;
if(matriz.Sdatoexp != NULL) media->Sdatoexp = ((n - 1) * media->Sdatoexp + actual->Sdatoexp) / n;
if(matriz.Sdir_exp != NULL) media->Sdir_exp = ((n - 1) * media->Sdir_exp + actual->Sdir_exp) / n;
if(matriz.Spilaexp != NULL) media->Spilaexp = ((n - 1) * media->Spilaexp + actual->Spilaexp) / n;
if(matriz.Sestadoexp != NULL) media->Sestadoexp = ((n - 1) * media->Sestadoexp + actual->Sestadoexp) / n;
if(matriz.Sdatoimp != NULL) media->Sdatoimp = ((n - 1) * media->Sdatoimp + actual->Sdatoimp) / n;
if(matriz.Sdir_imp != NULL) media->Sdir_imp = ((n - 1) * media->Sdir_imp + actual->Sdir_imp) / n;
if(matriz.Spilaimp != NULL) media->Spilaimp = ((n - 1) * media->Spilaimp + actual->Spilaimp) / n;
if(matriz.Sestadoimp != NULL) media->Sestadoimp = ((n - 1) * media->Sestadoimp + actual->Sestadoimp) / n;
if(matriz.D != NULL) media->D = ((n - 1) * media->D + actual->D) / n;
}
*/
/* utilizando la función: */
/* double CalcularNuevoPromedio (double promedioanterior, double valoractual, unsigned long n)
/* es más compacto aunque quizá algo más lento */
void CalcularPromedioVariableAgregada(parametromatriz *media, parametromatriz *actual, unsigned long n)
{
if(matriz.Ddatoexp != NULL) media->Ddatoexp = CalcularNuevoPromedio(media->Ddatoexp, actual->Ddatoexp, n);
if(matriz.Ddir_exp != NULL) media->Ddir_exp = CalcularNuevoPromedio(media->Ddir_exp, actual->Ddir_exp, n);
if(matriz.Dpilaexp != NULL) media->Dpilaexp = CalcularNuevoPromedio(media->Dpilaexp, actual->Dpilaexp, n);
if(matriz.Destadoexp != NULL) media->Destadoexp = CalcularNuevoPromedio(media->Destadoexp, actual->Destadoexp, n);
if(matriz.Ddatoimp != NULL) media->Ddatoimp = CalcularNuevoPromedio(media->Ddatoimp, actual->Ddatoimp, n);
if(matriz.Ddir_imp != NULL) media->Ddir_imp = CalcularNuevoPromedio(media->Ddir_imp, actual->Ddir_imp, n);
if(matriz.Dpilaimp != NULL) media->Dpilaimp = CalcularNuevoPromedio(media->Dpilaimp, actual->Dpilaimp, n);
if(matriz.Destadoimp != NULL) media->Destadoimp = CalcularNuevoPromedio(media->Destadoimp, actual->Destadoimp, n);
if(matriz.ADdatoexp != NULL) media->ADdatoexp = CalcularNuevoPromedio(media->ADdatoexp, actual->ADdatoexp, n);
if(matriz.ADdir_exp != NULL) media->ADdir_exp = CalcularNuevoPromedio(media->ADdir_exp, actual->ADdir_exp, n);
if(matriz.ADpilaexp != NULL) media->ADpilaexp = CalcularNuevoPromedio(media->ADpilaexp, actual->ADpilaexp, n);
if(matriz.ADestadoexp != NULL) media->ADestadoexp = CalcularNuevoPromedio(media->ADestadoexp, actual->ADestadoexp, n);
if(matriz.ADdatoimp != NULL) media->ADdatoimp = CalcularNuevoPromedio(media->ADdatoimp, actual->ADdatoimp, n);
if(matriz.ADdir_imp != NULL) media->ADdir_imp = CalcularNuevoPromedio(media->ADdir_imp, actual->ADdir_imp, n);
if(matriz.ADpilaimp != NULL) media->ADpilaimp = CalcularNuevoPromedio(media->ADpilaimp, actual->ADpilaimp, n);
if(matriz.ADestadoimp != NULL) media->ADestadoimp = CalcularNuevoPromedio(media->ADestadoimp, actual->ADestadoimp, n);
if(matriz.Sdatoexp != NULL) media->Sdatoexp = CalcularNuevoPromedio(media->Sdatoexp, actual->Sdatoexp, n);
if(matriz.Sdir_exp != NULL) media->Sdir_exp = CalcularNuevoPromedio(media->Sdir_exp, actual->Sdir_exp, n);
if(matriz.Spilaexp != NULL) media->Spilaexp = CalcularNuevoPromedio(media->Spilaexp, actual->Spilaexp, n);
if(matriz.Sestadoexp != NULL) media->Sestadoexp = CalcularNuevoPromedio(media->Sestadoexp, actual->Sestadoexp, n);
if(matriz.Sdatoimp != NULL) media->Sdatoimp = CalcularNuevoPromedio(media->Sdatoimp, actual->Sdatoimp, n);
if(matriz.Sdir_imp != NULL) media->Sdir_imp = CalcularNuevoPromedio(media->Sdir_imp, actual->Sdir_imp, n);
if(matriz.Spilaimp != NULL) media->Spilaimp = CalcularNuevoPromedio(media->Spilaimp, actual->Spilaimp, n);
if(matriz.Sestadoimp != NULL) media->Sestadoimp = CalcularNuevoPromedio(media->Sestadoimp, actual->Sestadoimp, n);
if(matriz.D != NULL) media->D = CalcularNuevoPromedio(media->D, actual->D, n);
}
/* esta función calcula los pasos de computación de cada matriz de dependencias */
/* para calcular los pasos de computación se usa el método más rápido, es decir, */
/* construir la lista de orden parcial... aunque no se anote ya que pasamos un puntero nulo */
void CalcularPasosComputacion(parametromatriz *pasos)
{
if(matriz.Ddatoexp != NULL) pasos->Ddatoexp = ListaOrdenParcial(matriz.Ddatoexp, NULL);
if(matriz.Ddir_exp != NULL) pasos->Ddir_exp = ListaOrdenParcial(matriz.Ddir_exp, NULL);
if(matriz.Dpilaexp != NULL) pasos->Dpilaexp = ListaOrdenParcial(matriz.Dpilaexp, NULL);
if(matriz.Destadoexp != NULL) pasos->Destadoexp = ListaOrdenParcial(matriz.Destadoexp, NULL);
if(matriz.Ddatoimp != NULL) pasos->Ddatoimp = ListaOrdenParcial(matriz.Ddatoimp, NULL);
if(matriz.Ddir_imp != NULL) pasos->Ddir_imp = ListaOrdenParcial(matriz.Ddir_imp, NULL);
if(matriz.Dpilaimp != NULL) pasos->Dpilaimp = ListaOrdenParcial(matriz.Dpilaimp, NULL);
if(matriz.Destadoimp != NULL) pasos->Destadoimp = ListaOrdenParcial(matriz.Destadoimp, NULL);
if(matriz.ADdatoexp != NULL) pasos->ADdatoexp = ListaOrdenParcial(matriz.ADdatoexp, NULL);
if(matriz.ADdir_exp != NULL) pasos->ADdir_exp = ListaOrdenParcial(matriz.ADdir_exp, NULL);
if(matriz.ADpilaexp != NULL) pasos->ADpilaexp = ListaOrdenParcial(matriz.ADpilaexp, NULL);
if(matriz.ADestadoexp != NULL) pasos->ADestadoexp = ListaOrdenParcial(matriz.ADestadoexp, NULL);
if(matriz.ADdatoimp != NULL) pasos->ADdatoimp = ListaOrdenParcial(matriz.ADdatoimp, NULL);
if(matriz.ADdir_imp != NULL) pasos->ADdir_imp = ListaOrdenParcial(matriz.ADdir_imp, NULL);
if(matriz.ADpilaimp != NULL) pasos->ADpilaimp = ListaOrdenParcial(matriz.ADpilaimp, NULL);
if(matriz.ADestadoimp != NULL) pasos->ADestadoimp = ListaOrdenParcial(matriz.ADestadoimp, NULL);
if(matriz.Sdatoexp != NULL) pasos->Sdatoexp = ListaOrdenParcial(matriz.Sdatoexp, NULL);
if(matriz.Sdir_exp != NULL) pasos->Sdir_exp = ListaOrdenParcial(matriz.Sdir_exp, NULL);
if(matriz.Spilaexp != NULL) pasos->Spilaexp = ListaOrdenParcial(matriz.Spilaexp, NULL);
if(matriz.Sestadoexp != NULL) pasos->Sestadoexp = ListaOrdenParcial(matriz.Sestadoexp, NULL);
if(matriz.Sdatoimp != NULL) pasos->Sdatoimp = ListaOrdenParcial(matriz.Sdatoimp, NULL);
if(matriz.Sdir_imp != NULL) pasos->Sdir_imp = ListaOrdenParcial(matriz.Sdir_imp, NULL);
if(matriz.Spilaimp != NULL) pasos->Spilaimp = ListaOrdenParcial(matriz.Spilaimp, NULL);
if(matriz.Sestadoimp != NULL) pasos->Sestadoimp = ListaOrdenParcial(matriz.Sestadoimp, NULL);
if(matriz.D != NULL) pasos->D = ListaOrdenParcial(matriz.D, NULL);
}
/* esta función calcula el grado de paralelismo a partir de los pasos de computación */
/* ver si es necesario prevenir la división por 0 */
/*
void CalcularGradoParalelismo(parametromatriz *pasos, parametromatriz *grado)
{
if(matriz.Ddatoexp != NULL) grado->Ddatoexp = 1 / pasos->Ddatoexp;
if(matriz.Ddir_exp != NULL) grado->Ddir_exp = 1 / pasos->Ddir_exp;
if(matriz.Dpilaexp != NULL) grado->Dpilaexp = 1 / pasos->Dpilaexp;
if(matriz.Destadoexp != NULL) grado->Destadoexp = 1 / pasos->Destadoexp;
if(matriz.Ddatoimp != NULL) grado->Ddatoimp = 1 / pasos->Ddatoimp;
if(matriz.Ddir_imp != NULL) grado->Ddir_imp = 1 / pasos->Ddir_imp;
if(matriz.Dpilaimp != NULL) grado->Dpilaimp = 1 / pasos->Dpilaimp;
if(matriz.Destadoimp != NULL) grado->Destadoimp = 1 / pasos->Destadoimp;
if(matriz.ADdatoexp != NULL) grado->ADdatoexp = 1 / pasos->ADdatoexp;
if(matriz.ADdir_exp != NULL) grado->ADdir_exp = 1 / pasos->ADdir_exp;
if(matriz.ADpilaexp != NULL) grado->ADpilaexp = 1 / pasos->ADpilaexp;
if(matriz.ADestadoexp != NULL) grado->ADestadoexp = 1 / pasos->ADestadoexp;
if(matriz.ADdatoimp != NULL) grado->ADdatoimp = 1 / pasos->ADdatoimp;
if(matriz.ADdir_imp != NULL) grado->ADdir_imp = 1 / pasos->ADdir_imp;
if(matriz.ADpilaimp != NULL) grado->ADpilaimp = 1 / pasos->ADpilaimp;
if(matriz.ADestadoimp != NULL) grado->ADestadoimp = 1 / pasos->ADestadoimp;
if(matriz.Sdatoexp != NULL) grado->Sdatoexp = 1 / pasos->Sdatoexp;
if(matriz.Sdir_exp != NULL) grado->Sdir_exp = 1 / pasos->Sdir_exp;
if(matriz.Spilaexp != NULL) grado->Spilaexp = 1 / pasos->Spilaexp;
if(matriz.Sestadoexp != NULL) grado->Sestadoexp = 1 / pasos->Sestadoexp;
if(matriz.Sdatoimp != NULL) grado->Sdatoimp = 1 / pasos->Sdatoimp;
if(matriz.Sdir_imp != NULL) grado->Sdir_imp = 1 / pasos->Sdir_imp;
if(matriz.Spilaimp != NULL) grado->Spilaimp = 1 / pasos->Spilaimp;
if(matriz.Sestadoimp != NULL) grado->Sestadoimp = 1 / pasos->Sestadoimp;
if(matriz.D != NULL) grado->D = 1 / pasos->D;
}
*/
/* esta función calcula el grado de paralelismo NORMALIZADO a partir de */
/* la dimensión de la ventana de instrucciones y de los pasos de computación */
void CalcularGradoParalelismoNormalizado(parametromatriz *pasos, parametromatriz *grado)
{
unsigned int dim;
dim = configuracion.ventana;
if(matriz.Ddatoexp != NULL) grado->Ddatoexp = InversoNormalizado(dim, pasos->Ddatoexp);
if(matriz.Ddir_exp != NULL) grado->Ddir_exp = InversoNormalizado(dim, pasos->Ddir_exp);
if(matriz.Dpilaexp != NULL) grado->Dpilaexp = InversoNormalizado(dim, pasos->Dpilaexp);
if(matriz.Destadoexp != NULL) grado->Destadoexp = InversoNormalizado(dim, pasos->Destadoexp);
if(matriz.Ddatoimp != NULL) grado->Ddatoimp = InversoNormalizado(dim, pasos->Ddatoimp);
if(matriz.Ddir_imp != NULL) grado->Ddir_imp = InversoNormalizado(dim, pasos->Ddir_imp);
if(matriz.Dpilaimp != NULL) grado->Dpilaimp = InversoNormalizado(dim, pasos->Dpilaimp);
if(matriz.Destadoimp != NULL) grado->Destadoimp = InversoNormalizado(dim, pasos->Destadoimp);
if(matriz.ADdatoexp != NULL) grado->ADdatoexp = InversoNormalizado(dim, pasos->ADdatoexp);
if(matriz.ADdir_exp != NULL) grado->ADdir_exp = InversoNormalizado(dim, pasos->ADdir_exp);
if(matriz.ADpilaexp != NULL) grado->ADpilaexp = InversoNormalizado(dim, pasos->ADpilaexp);
if(matriz.ADestadoexp != NULL) grado->ADestadoexp = InversoNormalizado(dim, pasos->ADestadoexp);
if(matriz.ADdatoimp != NULL) grado->ADdatoimp = InversoNormalizado(dim, pasos->ADdatoimp);
if(matriz.ADdir_imp != NULL) grado->ADdir_imp = InversoNormalizado(dim, pasos->ADdir_imp);
if(matriz.ADpilaimp != NULL) grado->ADpilaimp = InversoNormalizado(dim, pasos->ADpilaimp);
if(matriz.ADestadoimp != NULL) grado->ADestadoimp = InversoNormalizado(dim, pasos->ADestadoimp);
if(matriz.Sdatoexp != NULL) grado->Sdatoexp = InversoNormalizado(dim, pasos->Sdatoexp);
if(matriz.Sdir_exp != NULL) grado->Sdir_exp = InversoNormalizado(dim, pasos->Sdir_exp);
if(matriz.Spilaexp != NULL) grado->Spilaexp = InversoNormalizado(dim, pasos->Spilaexp);
if(matriz.Sestadoexp != NULL) grado->Sestadoexp = InversoNormalizado(dim, pasos->Sestadoexp);
if(matriz.Sdatoimp != NULL) grado->Sdatoimp = InversoNormalizado(dim, pasos->Sdatoimp);
if(matriz.Sdir_imp != NULL) grado->Sdir_imp = InversoNormalizado(dim, pasos->Sdir_imp);
if(matriz.Spilaimp != NULL) grado->Spilaimp = InversoNormalizado(dim, pasos->Spilaimp);
if(matriz.Sestadoimp != NULL) grado->Sestadoimp = InversoNormalizado(dim, pasos->Sestadoimp);
if(matriz.D != NULL) grado->D = InversoNormalizado(dim, pasos->D);
}
/* esta función calcula el acoplamiento de cada matriz de dependencias */
void CalcularAcoplamiento(parametromatriz *acoplamiento)
{
if(matriz.Ddatoexp != NULL) acoplamiento->Ddatoexp = Acoplamiento(matriz.Ddatoexp);
if(matriz.Ddir_exp != NULL) acoplamiento->Ddir_exp = Acoplamiento(matriz.Ddir_exp);
if(matriz.Dpilaexp != NULL) acoplamiento->Dpilaexp = Acoplamiento(matriz.Dpilaexp);
if(matriz.Destadoexp != NULL) acoplamiento->Destadoexp = Acoplamiento(matriz.Destadoexp);
if(matriz.Ddatoimp != NULL) acoplamiento->Ddatoimp = Acoplamiento(matriz.Ddatoimp);
if(matriz.Ddir_imp != NULL) acoplamiento->Ddir_imp = Acoplamiento(matriz.Ddir_imp);
if(matriz.Dpilaimp != NULL) acoplamiento->Dpilaimp = Acoplamiento(matriz.Dpilaimp);
if(matriz.Destadoimp != NULL) acoplamiento->Destadoimp = Acoplamiento(matriz.Destadoimp);
if(matriz.ADdatoexp != NULL) acoplamiento->ADdatoexp = Acoplamiento(matriz.ADdatoexp);
if(matriz.ADdir_exp != NULL) acoplamiento->ADdir_exp = Acoplamiento(matriz.ADdir_exp);
if(matriz.ADpilaexp != NULL) acoplamiento->ADpilaexp = Acoplamiento(matriz.ADpilaexp);
if(matriz.ADestadoexp != NULL) acoplamiento->ADestadoexp = Acoplamiento(matriz.ADestadoexp);
if(matriz.ADdatoimp != NULL) acoplamiento->ADdatoimp = Acoplamiento(matriz.ADdatoimp);
if(matriz.ADdir_imp != NULL) acoplamiento->ADdir_imp = Acoplamiento(matriz.ADdir_imp);
if(matriz.ADpilaimp != NULL) acoplamiento->ADpilaimp = Acoplamiento(matriz.ADpilaimp);
if(matriz.ADestadoimp != NULL) acoplamiento->ADestadoimp = Acoplamiento(matriz.ADestadoimp);
if(matriz.Sdatoexp != NULL) acoplamiento->Sdatoexp = Acoplamiento(matriz.Sdatoexp);
if(matriz.Sdir_exp != NULL) acoplamiento->Sdir_exp = Acoplamiento(matriz.Sdir_exp);
if(matriz.Spilaexp != NULL) acoplamiento->Spilaexp = Acoplamiento(matriz.Spilaexp);
if(matriz.Sestadoexp != NULL) acoplamiento->Sestadoexp = Acoplamiento(matriz.Sestadoexp);
if(matriz.Sdatoimp != NULL) acoplamiento->Sdatoimp = Acoplamiento(matriz.Sdatoimp);
if(matriz.Sdir_imp != NULL) acoplamiento->Sdir_imp = Acoplamiento(matriz.Sdir_imp);
if(matriz.Spilaimp != NULL) acoplamiento->Spilaimp = Acoplamiento(matriz.Spilaimp);
if(matriz.Sestadoimp != NULL) acoplamiento->Sestadoimp = Acoplamiento(matriz.Sestadoimp);
if(matriz.D != NULL) acoplamiento->D = (double) Acoplamiento(matriz.D);
}
/* esta función reserva memoria para salvar el histograma de pasos de computación */
/* asociado a la matriz de dependencias de datos D (no el resto) */
void CrearHistogramaPasos()
{
char mensaje[MAX_LINE];
distribucionpasos = calloc(configuracion.ventana+1, sizeof(unsigned long));
if (distribucionpasos == NULL)
{
sprintf(mensaje, "[CrearHistogramaPasos] Memoria insuficiente");
Notificar(mensaje, ERROR_SALIR, ECO_NO);
/* el programa finaliza si no hay memoria suficiente */
}
}
/* inicia el histograma a 0 (con la reserva de calloc no es necesario) */
void IniciarHistogramaPasos()
{
unsigned int i;
for(i=0; i<configuracion.ventana; i++) distribucionpasos[i] = 0;
}
/* libera la memoria reservada para el histograma */
void LiberarMemoriaHistogramaPasos()
{
free(distribucionpasos);
}
/* actualiza los datos del histograma */
void ActualizarHistogramaPasos()
{
distribucionpasos[(unsigned int)pasos->D]++;
}
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to CalculosMatrices.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository ATC2] / ADD_ver_10