Discrepancies in Matrix Data Communicated Between Parent and Child Process - c

Question

For a project of mine, I am required to pass matrices (which, later on will be of various sizes determined at run-time) between processes, and perform operations on them. This will be performed on a UNIX system.
While teaching myself about fork() and pipe(), I managed to establish two one-way pipes between the processes (one from parent to child and vice versa) to some extent.
===========================================================
Here is my code:
#include <sys/types.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#define READ_END 0
#define WRITE_END 1
#define MATRIX_N 2
void print_mat(int**, int);
int main(void){
// INITIALIZE
int **w_mat, **r_mat, **return_mat, i, j;
int fd1[2];
int fd2[2];
pid_t pid;
// Allocate memory for respective arrays
w_mat = (int**) malloc(sizeof(int *) * MATRIX_N);
for( i = 0 ; i < MATRIX_N ; i++ ){
*(w_mat + i) = (int*) malloc (sizeof(int *) * MATRIX_N);
}
r_mat = (int**) malloc(sizeof(int *) * MATRIX_N);
for( i = 0 ; i < MATRIX_N ; i++ ){
*(r_mat + i) = (int*) malloc (sizeof(int *) * MATRIX_N);
}
return_mat = (int**) malloc(sizeof(int *) * MATRIX_N);
for( i = 0 ; i < MATRIX_N ; i++ ){
*(return_mat + i) = (int*) malloc (sizeof(int *) * MATRIX_N);
}
// Assign initial values to matrix for writing
w_mat[0][0] = 2;
w_mat[0][1] = 7;
w_mat[1][0] = 12;
w_mat[1][1] = 9;
// Initialize and check pipes respectively
if( pipe(fd1) == -1){
fprintf(stderr, "Pipe failed");
return 1;
}
if( pipe(fd2) == -1){
fprintf(stderr, "Pipe failed");
return 1;
}
// Fork a child, then check it
pid = fork();
if( pid < 0 ){
fprintf(stderr, "Fork failed");
}
if( pid > 0 ){ /* PARENT */
// Close unnecessary pipe ends
close(fd1[READ_END]);
close(fd2[WRITE_END]);
printf("\nMatrix to send to child: ");
print_mat(w_mat, MATRIX_N);
// Write to pipe 1, matrix for child, then close pipe
write(fd1[WRITE_END], w_mat, MATRIX_N * MATRIX_N * sizeof(int*));
// Wait for child to process values, write, and terminate
wait(NULL);
// Read values from pipe 2
read(fd2[READ_END], return_mat, MATRIX_N * MATRIX_N * sizeof(int*));
printf("\nDoubled matrix received from child: ");
print_mat(return_mat, MATRIX_N);
// Close used pipe ends
close(fd2[READ_END]);
close(fd1[WRITE_END]);
}else{ /* CHILD */
// Close unnecessary pipe ends
close(fd1[WRITE_END]);
close(fd2[READ_END]);
// Read from pipe 1 the matrix from the parent
read(fd1[READ_END], r_mat, MATRIX_N * MATRIX_N * sizeof(int*));
printf("\nReceived matrix from parent to double: ");
print_mat(r_mat, MATRIX_N);
// Double the values in the matrix from parent
for( i = 0 ; i < MATRIX_N ; i++ ){
for( j = 0 ; j < MATRIX_N ; j++){
r_mat[i][j] = r_mat[i][j] * MATRIX_N;
}
}
printf("\nDoubled matrix to send to parent: ");
print_mat(r_mat, MATRIX_N);
// Write to pipe 2, the doubled matrix to be received by parent
write(fd2[WRITE_END], r_mat, MATRIX_N * MATRIX_N * sizeof(int*));
// Close used pipe ends
close(fd2[WRITE_END]);
close(fd1[READ_END]);
}
// Terminate
return 0;
}
===========================================================
The problem arises when running the program:
===========================================================
Matrix to send to child:
| 2 7 |
| 12 9 |
Received matrix from parent to double:
| 2 7 |
| 12 9 |
Doubled matrix to send to parent:
| 4 14 |
| 24 18 |
Doubled matrix received from child:
| 2 7 |
| 12 9 |
===========================================================
The array before writing is correct, and it seems as if somehow in the midst of writing it to pipe 2 from the child and reading it back in from said pipe once the child terminates; the values return to what they were. I don't believe it could be either process tampering with it, as each has its own variable array to store the data, and aside from the pipes there is really no instance where, in the if-statement of my program, either process directly affects the array of another--To the best of my knowledge, that is.
Could there, in fact, be an instance in which the parent or child indirectly affects the written and read arrays which I am not considering? If so, how could I keep this in check? If not, where exactly did I go wrong? Was my pipe implementation inherently flawed? I'm not really sure what to look for.
Also; in the far-left of field instance that my matrix printing function is the culprit, here is that:
void print_mat(int** a, int n){
int i, j;
for( i = 0 ; i < n ; i++){
printf("\n| ");
for( j = 0 ; j < n ; j++){
printf("%d", a[i][j]);
if( j != n - 1){
printf(" ");
}
}
printf(" |\n");
}
}

Answer 1

Each matrix is an array of pointers, where each pointer points to an array of ints. Therefore the method that you are using to pass the matrix between the parent and child won't work the way you want it to.
What you are doing is passing four pointers across the pipe (of which only the first two are valid). Since the child is a carbon copy of the parent, those pointers do in fact point to the original matrix in the parent's address space. Therefore, the parent prints the original matrix.
What you want to do is pass the integer values across the pipe and reconstruct the matrix on the other side. Code similar to the print_mat function is needed to write the individual values into the pipe. On the receiving side, those values need to be read and stored at the proper locations in the array.
Let me see if I can clarify with an example. If the array was declared as
int w_mat[2][2];
then you could transfer the entire array like this
write(fd1[WRITE_END], w_mat, 2*2 * sizeof(int) );
But in fact the array is equivalent to this
int *w_mat[2];
w_mat[0] = malloc( 2 * sizeof(int) );
w_mat[1] = malloc( 2 * sizeof(int) );
Therefore, the line
write(fd1[WRITE_END], w_mat, MATRIX_N * MATRIX_N * sizeof(int*));
is writing four int * to the pipe. That's bad for two reasons.
The array only has two pointers in it
Passing pointers across the pipe is not the same as sending the data across the pipe.