How Can I use fork() recursively?

user_6349251 0
Viewed 4489

I've been programming this over and over again and I've had trouble learning how to work with fork() in order to generate child processes recursively. I started programming some pretty complicated stuff and I decided to start over again with something way more simple.

I just started learning about processes and I've had trouble understanding them. The program is designed to fork a tree of processes, however , I must fork from the root two processes which will fork , on the left side 3 children processes, and on the right side 4 children processes. These processes must fork 3 and 4, respectively, processes of their own.

My issue with this is that the program can fork the processes, however only one process on each side is fathering all of the children on their respective side.

Any help you could give me would be great, please tell me if I'm not being clear enough. 

#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>

/* Prototypes */
void three_children();
void four_children();

int main()
{
    pid_t process;
    int status,n;

    printf("Number of levels: \n");
    scanf("%d", &n);
    for (int i = 0; i < n ; i++) {
        process = fork();
        switch (process) {
            case -1:
                printf("Error\n");
                break;
            case 0:
                if (i == 0) {
                    printf("Left\n");
                    three_children(process, status);
                } 
                if (i == 1) {
                    printf("Right\n");
                    three_children(process, status);
                }
                printf("Hi I'm a child PID: %d, my father is PPID: %d\n", getpid(), getppid());
                exit(0);
            default:
                printf("I'm a father PPID: %d\n", getppid());
                break;
        }
    }
}

void four_children(pid_t process, int status)
{
    for (int j = 0; j < 4; j++) {
        process = fork();
        switch (process) {
            case -1:
                printf("Error\n");
                break;
            case 0:
                printf("I'm child: %d, and my father is: %d\n(four children)\n", getpid(), getppid());
                exit(0);
                break;
            default:
                printf("I'm a father process: %d\n", getpid());
                four_children(process, status);
                for (int j = 0; j < 3; j++) {
                    wait(&status);
                }
                break;
        }
    }
}

void three_children(pid_t process, int status)
{
    for (int k = 0; k < 3; k++) {
        process = fork();
        switch (process) {
            case -1:
                printf("Error\n");
                break;
            case 0:
                printf("I'm a child: %d, and my father is: %d\n(three children )\n", getpid(), getppid());
                exit(0);
                break;
            default:
                printf("I'm father %d\n", getpid());
                three_child(process, status);
                for (int j = 0; j < 3; j++) {
                    wait(&status);
                }
                break;
        }
    }
}
process unix fork c
1 Answers
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
typedef struct Node
{   
    int             childrenCount;
    struct Node*    child[0];
} Node;

Node* makeNode(int children)
{   
    Node* result = (Node*)malloc(sizeof(Node) + sizeof(Node*) * children);
    if (!result) {
        exit(1);
    }   
    result->childrenCount = children;
    for(int loop = 0;loop < children; ++loop) {
        result->child[loop] = NULL;
    }   
    return result;
}   

void buildTree(int indent, pid_t parent, Node* node);
void createChild(int indent, pid_t parent, Node* node, int childIndex)
{   
    pid_t pid = fork();
    if (pid == -1) {
        exit(1);
    }   
    if (pid == 0) {
        buildTree(indent + 1, getpid(), node->child[childIndex]);
        srand(parent * 10  + childIndex);
        exit(rand());
    }   
    for(int ind = 0; ind < indent; ++ind) {
        fprintf(stderr, " ");
    }   
    fprintf(stderr, "Parent: %d Spawned %d\n", parent, pid);
}   

void buildTree(int indent, pid_t parent, Node* node)
{   
    for(int ind = 0; ind < indent; ++ind) {
        fprintf(stderr, " ");
    }   
    fprintf(stderr, "Parent %d Has %d Children\n", parent, node->childrenCount);
    for(int loop = 0; loop < node->childrenCount; ++loop) {
        createChild(indent, parent, node, loop);
    }   
    for(int loop = 0; loop < node->childrenCount; ++loop) {
        int status;
        int child = wait(&status);
        for(int ind = 0; ind < indent; ++ind) {
            fprintf(stderr, " ");
        }
        fprintf(stderr, "Parent: %d Reaped %d with status %d\n", parent, child, status);
    }
}

int main()
{
    Node* root = makeNode(2);
    root->child[0]   = makeNode(3);
    for(int loopChild = 0;loopChild < 3; ++loopChild) {
        root->child[0]->child[loopChild] = makeNode(3);
        for(int loopGrandChild = 0;loopGrandChild < 3; ++loopGrandChild) {
            root->child[0]->child[loopChild]->child[loopGrandChild] = makeNode(0);
        }
    }
    root->child[1]   = makeNode(4);
    for(int loopChild = 0;loopChild < 4; ++loopChild) {
        root->child[1]->child[loopChild] = makeNode(4);
        for(int loopGrandChild = 0;loopGrandChild < 4; ++loopGrandChild) {
            root->child[1]->child[loopChild]->child[loopGrandChild] = makeNode(0);
        }
    }

    fprintf(stderr, "Start\n");
    buildTree(0, getpid(), root);
    fprintf(stderr, "Stop\n");
}
Martin_York_140650
Related