__________________________
Buenas,
Refloto el hilo porque tengo que hacer esta práctica para septiembre me lleva por el camino de la amargura...
Os voy a poner los dos ficheros de código y la salidas que tengo.
Se trata de un padre, main.c que crea un hijo. El hijo escribe un fichero.
Lo he querido dejar hay para ver si consigo algo....
Padre:
main.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <dirent.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <pvm3.h>
//Constantes
//Tamano maximo de una senal
#define MAX_TAM_SENAL 16384
//Tamano maximo de fichero
#define MAX_TAM_FICH 50
//Número de esclavos
#define NUM_ESCLAVOS 1
//Declaracion de funciones
int leerFicheroSenal(double *arr, char fichero[MAX_TAM_FICH] ) ;
int PPA_padre(char ficheroEntrada[],int N, char ficheroSalida[]);
int main(int argc, char *argv[]) {
PPA_padre(argv[1],(int)argv[2],argv[3]);
}
int PPA_padre(char ficheroEntrada[],int N, char ficheroSalida[])
{
//Programa maestro
int i;
int j;
//Se define un array de punteros a un array de chars (strings) para almacenar la lista de ficheros
char *arrFicheros[300][MAX_TAM_FICH];
//Se recorre el fichero ficheroEntrada para rellenar el array arrFicheros con los ficheros de señal
char strGuardado[300];
FILE *archivo;
archivo = fopen( ficheroEntrada,"r");
int numPalabras = 0;
if (archivo == NULL){
return 0;
}
else {
while (feof(archivo) == 0 )
{
fscanf(archivo,"%s",strGuardado);
strcpy(arrFicheros[numPalabras], strGuardado);
numPalabras++;
}
}
fclose(archivo);
//En la variable numPalabras se encuentra el número de ficheros
///Se calcula el numero de ficheros a cada esclavo
int ficherosEsclavo = numPalabras/NUM_ESCLAVOS;
int ntids[NUM_ESCLAVOS] ;
//Se crean NUM_ESCLAVOS procesos hijos que llaman a PPA_Hijo
//la intención era pasar en los argumentos N y el número de señales a tratar por cada hijo pero
// debido a problemas de compilación se ha decidido realizar dichos pasos vÃ*a PVM
//Se crean NUM_ESCLAVOS procesos hijo que ejecutarán el comando PPA_Hijo
//Ignoramos los fallos ya que si que crea bien los hijos
int numt = pvm_spawn ("PAA_Hijo",(char **)0,0,"",NUM_ESCLAVOS,ntids);
if (numt!=NUM_ESCLAVOS) {
pvm_exit();
printf("Fallo a intentar crear los procesos hijos");
}
int resultado;
//Envio de senales a procesos hijos
for (i=0;i<NUM_ESCLAVOS;i++) {
//Enviamos los parametros número de señales y N con las etiquetas 0001 y 0002 respectivamente
pvm_initsend(PvmDataDefault);
pvm_pkint(&ficherosEsclavo,1,1);
printf("El valor de el tid es %i..\n y el de i es %i",ntids[i],i);
pvm_send(ntids[i],0001);
pvm_pkint(&N,1,1);
pvm_send(ntids[i],0002);
//Para cada esclavo se envia el array de senal
for (j=0;j<ficherosEsclavo;j++) {
//Se crea una varialbe para almacenar la senal a enviar
double senal[MAX_TAM_SENAL];
double *puntSenal = senal;
//Se obtiene en senal la señal a enviar para su tratamiento
//Se envia un puntero que apunta a senal, con esto, se modifica la senal que podra seguir siendo accedida por la variable senal
printf("\nA pillar la sena\n");
resultado = leerFicheroSenal(puntSenal, arrFicheros[j] );
printf("\nLeido, vamos a enviar la senal con resultado %i l\n",resultado);
printf("\nEsto no hay quien lo entienda%i l\n",resultado);
if (resultado==0) {
//No se han encontrado resultados en el fichero
printf("\nNo se han encontrado resultados en el fichero %i l\n",resultado);
}
else {
//Se envia el nombre de la señal
pvm_initsend(PvmDataDefault);
printf("Tenemos leida la senal, vamos a enviarla ");
pvm_pkstr(*arrFicheros[j]);
pvm_send(ntids[i],1000);
//Se envia la señal al esclavo para su tratamiento
//pvm_pkdouble(puntSenal,MAX_TAM_SENAL,1);
//pvm_send(ntids[i],1001);
}
printf("\nEstoy aki\n");
}
}
int numFicherosEsc = 0;
//Una vez enviados todas las senales simplemente hay que esperar a recibirlas una tras otra
// para escribirlas en el fichero resultado
FILE *archivo2;
archivo2 = fopen(ficheroSalida,"wb");
if (archivo2 == NULL){
}
else {
for (i=0;i<NUM_ESCLAVOS;i++) {
for (j=0;j<ficherosEsclavo;j++) {
//Se recibe el nombre de la señal
char *nombre[(int)MAX_TAM_FICH];
pvm_recv(ntids[j],2000);
pvm_upkstr(*nombre);
//Se recibe la señal para guardar en el fichero
double senalResultado[N];
pvm_recv(ntids[j],2000);
pvm_upkdouble(senalResultado,N,1);
fwrite (&nombre, 20, 1, archivo2);
int x;
for (x=0;x<=N;x++) {
fwrite (&senalResultado[x], sizeof(double), 1, archivo2);
}
numFicherosEsc++;
}
}
fclose(archivo2);
}
printf("Press ENTER to SALIR...\n");
//getchar();
return 0;
}
/*
Name: leerFichero
Copyright:
Author: jgonzalez2115
Date: 06/07/10 09:29
Description: Lee un fichero e introduce los primeros 16.384 valores en un array de doubles
devuelve el n�mero de valores del array. Si hay error devuelve 0
*/
int leerFicheroSenal(double *arr, char fichero[MAX_TAM_FICH] ) {
printf("Voy a abrir el fichero\n %s \n",fichero);
FILE *archivo;
char caracter;
double numGuardado;
char strGuardado[256];
archivo = fopen(fichero,"r");
if (archivo == NULL){
printf("\nError de apertura del archivo. %s \n\n",fichero);
return 0;
}else{
printf("\nSe va tratar el fichero \n\n");
int numPalabras = 0;
//Se leeran los 16.384 primeros valores de la se�al . Siempre hay minimos dichos valores
// Se guardaran en un array desde la posici�n 0 a la 16.384
while (feof(archivo) == 0 )
{
fscanf(archivo,"%s",strGuardado);
//Como la primera columna no sirve volvemos a leer
fscanf(archivo,"%s",strGuardado);
numPalabras++;
//printf("\n\n %s \n\n",strGuardado);
numGuardado = atof ( strGuardado);
// A lo que apunta el puntero + el número de palabras, es decir, a la posición numPalabras se le introduce numGuardado
*(arr+numPalabras) = numGuardado;
if (numPalabras >= MAX_TAM_SENAL) {
break;
}
}
printf("\n\n El total de numeros almacenado es : %d \n\n",numPalabras);
return numPalabras;
}
}
hijo.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <dirent.h>
#include <pvm3.h>
//Constantes
//Tamano maximo de una senal
#define MAX_TAM_SENAL 16384
//Tamano maximo de fichero
#define MAX_TAM_FICH 50
//Definicion de estructuras
// Lo OPTIMO serÃ*a hacer que resultado tenga el tamaño N pero no se si voy a poder definir la estructura dentro del método
struct estructura_senal {
char nombre[MAX_TAM_FICH];
double senal[MAX_TAM_SENAL];
};
//Definicion de funciones
void hijo_PAA(int nSenales, int N);
int main() {
int arg1=0;
int arg2=0;
pvm_initsend(PvmDataDefault);
//Debido a problemas a la hora de pasar argv se ha decido enviar los argumentos por PVM
pvm_recv (pvm_parent(),0001);
pvm_upkint(&arg1,1,1);
pvm_recv (pvm_parent(),0002);
pvm_upkint(&arg2,1,1);
//Se llama a la funcion hija que trata las senales recibidas
hijo_PAA(arg1,arg2);
pvm_exit();
}
void hijo_PAA(int nSenales, int N) {
//Se crea un fichero para depurar
int miTid = pvm_mytid();
FILE *archivo2;
archivo2 = fopen("ficheroprueba.txt","wb");
if (archivo2 != NULL){
fwrite ("Soy un hijo", 20, 1, archivo2);
fwrite (&miTid, sizeof(int), 1, archivo2);
//fclose(archivo2);
}
//Se crea lista de senales
struct estructura_senal lista_senales[nSenales];
int numSenal;
/* SE SUSTITUYE POR LA ESTRUCTURA
//Se crea un array que contendra los valores a tratar, las señales
double *arr[nSenales][MAX_TAM_SENAL];
*/
/* SE VA ENVIAR LA SEÑAL SEGUN SE TRATE CON LO QUE NO HAY QUE GUARDARLA EN NINGUNA ESTRUCTURA
//Se crea un array que contendra los valores resultado, las medias
double *arrResul[nSenales][N];
*/
fwrite ("Aqui", 20, 1, archivo2);
fclose(archivo2);
// Obtener las señales (Se recogen todas primero porque es más rápido que tratarlas al no bloquear al padre el envio)
for (numSenal=0;numSenal<nSenales;numSenal++) {
char nombre[MAX_TAM_FICH];
fwrite ("Aqui2", 20, 1, archivo2);
//Se recoge primero el nombre de la senal:
pvm_recv (pvm_parent(),1000);
pvm_upkstr(nombre);
char *puntNombre = nombre;
*lista_senales[numSenal].nombre = *puntNombre;
fwrite ("Aqui3", 20, 1, archivo2);
//A continuacion obtenemos los valores de la señal. No estoy seguro de si se puede hacer asÃ*
//int kk=12345678;
//fwrite (123477, sizeof(int), 1, archivo2);
double senal[MAX_TAM_SENAL];
double *puntSenal = senal;
//pvm_recv (pvm_parent(),1001);
//pvm_upkdouble(puntSenal,MAX_TAM_SENAL,1);
*lista_senales[numSenal].senal = *puntSenal;
fwrite ("Hola4", 21, 1, archivo2);
}
fwrite ("Aqui5", 20, 1, archivo2);
for (numSenal=0;numSenal<nSenales;numSenal++) {
// _____________________________TRANSFORMAR__________ ____________________
//A continuacion se calcula el tamaño de trozos de señal que hay que partir y hacer la media
int tamano = MAX_TAM_SENAL / N;
double *arrResultado[N];
double aux = 0;
//Limite inferior del intervalo
int limI;
//Limite superior del intervalo
int limS ;
int j = 1;
//Se calcula la media de cada intervalo
while (j<=N) {
limI = (j-1) * tamano;
limS = (j * tamano)-1;
j++;
//***************************Obtenemos la media del intervalo*****************************/
//Recorrer el array y sumar todos sus contenidos para luego dividir entre el tamano
long double suma = 0;
double media =0;
int k=0;
while (k<limS) {
suma = suma + (double) lista_senales[numSenal].senal[k];
k++;
}
media = suma / (double) tamano;
/*****************************Fin calculo de media********************************************/
aux = media;
*arrResultado[j]= (double) aux;
}
// _____________________________FIN TRANSFORMAR______________________________
//Envia la senal al padre
char *nombre2 =lista_senales[numSenal].nombre;
pvm_initsend(PvmDataDefault);
pvm_pkstr(nombre2);
pvm_send(pvm_parent(),2000);
pvm_pkdouble(*arrResultado,N,1);
pvm_send(pvm_parent(),2001);
}
}
Compilan perfectamente y en pantalla el padre me dice lo siguiente:
El valor de el tid es 262147..
y el de i es 0
A pillar la sena
Voy a abrir el fichero
BO213_10000.txt
Se va tratar el fichero
El total de numeros almacenado es : 16384
Leido, vamos a enviar la senal con resultado 16384 l
Esto no hay quien lo entienda16384 l
./ejecutar: line 1: 5720 Fallo de segmentación ./trasnformadaPPA ENTRADA.txt 2 SALIDA.txt
sebas@sebas-desktop:~/pvm3/bin/LINUX$ ./ejecutar
El valor de el tid es 262150..
y el de i es 0
A pillar la sena
Voy a abrir el fichero
BO213_10000.txt
Se va tratar el fichero
El total de numeros almacenado es : 16384
Leido, vamos a enviar la senal con resultado 16384 l
Esto no hay quien lo entienda16384 l
./ejecutar: line 1: 5814 Fallo de segmentación ./trasnformadaPPA ENTRADA.txt 2 SALIDA.txt
Nota: Para ejecutar utilzo un fichero ejecutar que hace la llamada a el ejecutable con los parámetros.
Y el hijo escribe este fichero de depuración:
Soy un hijo#Aqui#Aqu####Aqui#Aqui2#Aqui3#Hol
El caso es que estoy totalmente atascado y no se porque me da ese fallo de segmentación, si es un fallo de C, si es un fallo de PVM o que narices...
Pagaría por no tener que hacer esta pesadilla pero es lo que toca así que un poquito de ayuda.. por favor... tened piedad ;)