C/Visual C - Ayuda con comunicación de procesos.

 
Vista:
sin imagen de perfil
Val: 6
Ha aumentado su posición en 9 puestos en C/Visual C (en relación al último mes)
Gráfica de C/Visual C

Ayuda con comunicación de procesos.

Publicado por Jesús (2 intervenciones) el 28/06/2018 17:54:47
Hola, compañeros, soy nuevo en esta comunidad, ya me he beneficiado aquí con las dudas de otros desde hace tiempo y hoy traigo una duda propia para ustedes. Espero puedan ayudarme.

Tengo que hacer un programa que comunique dos procesos y checar cuanto tarda (para despues compararlo con uno igual pero con hilos), el hijo hace la serie de Fibonacci hasta el N-esimo numero de Fibonacci (ingresado como argumento para main desde consola), mete el resultado en una cadena y se la pasa al padre, el padre la imprime (lo tiene que meter a un archivo pero por el momento solo lo imprimo para checar que este chido) y listo.
Todo va bien hasta que el padre imprime porque solo imprime una parte de la cadena.

Este es mi codigo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <wait.h>
#include <unistd.h>
 
//** Funcion para hacer la serie de Fibinacci hasta el N-simo fibo
char* fibo(int N){
	char *serie;
	serie = malloc(200*sizeof(char));
	int i, F1=0, F2=1, F3;
 
	sprintf(serie, "%d", F1);
	if(N>=1){
		for(i=1; i<N; i++){
			F3=F1+F2;
			F1=F2;
			F2=F3;
			sprintf(serie, "%s %d",serie, F1);
		}
	}
	return serie;
}
 
int main(int argc, char *argv[]){
	int N, idf, st, tubo[2];
	char *serie;		//El buffer para los procesos
	clock_t inicio;
	serie = malloc(200*sizeof(char));
 
	N=atoi(argv[1]);	//a N le paso el argumento de main
	inicio = clock();
	pipe(tubo);
 
	idf = fork();
 
	if(idf==0){			//aca entra el hijo
		close(tubo[0]);
		serie = fibo(N);
		write(tubo[1], serie, sizeof(serie));
		//Este printf no debe ir, solo es un chismoso
		printf("Este lo imprime chido el hijo(%d): %s\n", idf, serie);
		exit(0);
	}else{			//Aca el padre
		wait(&st);	//La cosa va igual con el wait aca o mas abajo
		close(tubo[1]);
		read(tubo[0], serie, sizeof(serie));
 
		//Aca tuerce la puerca el rabo u_u
		printf("Aca el padre(%d) ya no lo imprime chido: %s\n", idf, serie);
		//wait(&st);
	}
 
 
	printf("Tiempo procesos: %f.\n", (clock()-inicio)/(double)CLOCKS_PER_SEC);
 
 
	return 0;
}

Y esta es la salida:

1
2
3
4
$ ./procesosH2.1 10
Este lo imprime chido el hijo(0): 0 1 1 2 3 5 8 13 21 34
Aca el padre(5425) ya no lo imprime chido: 0 1 1 2
Tiempo procesos: 0.000113.

¿Podrian ayudarme a encontrar mi error, por favor?
¡Gracias!
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

Ayuda con comunicación de procesos.

Publicado por Tom (602 intervenciones) el 29/06/2018 14:50:41
Nada te asegura que esto:
read(tubo[0], serie, sizeof(serie));
lea el tamaño que tú esperas de una sola vez.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
Comentar

Ayuda con comunicación de procesos.

Publicado por Tom (602 intervenciones) el 29/06/2018 18:20:11
Ah! y, por cierto, tal y como lo usas, sizeof(serie) vale 8 ... así que en realidad todo está funcionando bien (aunque no como tu esperas) :D
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
Comentar
sin imagen de perfil
Val: 6
Ha aumentado su posición en 9 puestos en C/Visual C (en relación al último mes)
Gráfica de C/Visual C

¡Gracias!

Publicado por Jesús (2 intervenciones) el 01/07/2018 07:32:05
¡Es cierto! siempre es 8 sizeof(serie) en cualquier parte del código (después de declararla). Entonces desde que la manda el hijo esta mandando una cadena tamaño 8 :'v.
Lo arregle mandando directamente el tamaño de la cadena en el write y aunque podría poner el tamaño de la cadena en el read, el padre no sabe cuanto mide la cadena así que hay leerla caracter por caracter. ¡Ahora si puedo mandarla a un archivo!
Gracias por tu ayuda, Tom. Saludos.

Acá dejo mi código corregido por si a alguien le interesa.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <wait.h>
#include <unistd.h>
#include <string.h>
 
//** Funcion para hacer la serie de Fibonacci hasta el N-simo fibo
char* fibo(int N){
	char *serie;
	serie = malloc(200*sizeof(char));
	int i, F1=0, F2=1, F3;
 
	printf("sizeof(serie) = %ld\n", sizeof(serie));
 
	sprintf(serie, "%d", F1);
	if(N>=1){
		for(i=1; i<N; i++){
			F3=F1+F2;
			F1=F2;
			F2=F3;
			sprintf(serie, "%s %d",serie, F1);
		}
	}
	return serie;
}
 
int main(int argc, char *argv[]){
	int N, idf, st, tubo[2];
	char *serie;		//El buffer para los procesos
	clock_t inicio;
	serie = malloc(200*sizeof(char));
 
	N=atoi(argv[1]);	//a N le paso el argumento de main
	inicio = clock();
	pipe(tubo);
 
	idf = fork();
	if(idf==0){			//aca entra el hijo
		close(tubo[0]);
		serie = fibo(N);
		write(tubo[1], serie, strlen(serie));
		printf("En hijo: %s\n", serie);
		exit(0);
	}else{			//Aca el padre
		wait(&st);
		close(tubo[1]);
		printf("En padre: ");
		while((read(tubo[0], serie, sizeof(char))) > 0){
			printf("%s", serie);
		} //esto antes era: read(tubo[0], serie, sizeof(serie));
				printf("\n");
 
	}
	printf("Tiempo procesos: %f.\n", (clock()-inicio)/(double)CLOCKS_PER_SEC);
	return 0;
}
Y ahora esta es la salida:
1
2
3
4
5
$ ./procesosH2.1 15
sizeof(serie) = 8
En hijo: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
En padre: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Tiempo procesos: 0.000606.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar