#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include <fstream>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <cstdlib>
 
using namespace std; // consider removing this line in serious projects
 
int totalProcessesToBeForked = 10;
int processesCurrentlyForked = 0;
int maxAllowedAtOnce = 5;
int timeBeforeTerminate = 10;
bool endTimer = false;
pid_t masterPId;
pid_t childPId;
 
void forkChild(int);
void catchChild(int);
void onTimeout(int);
void cleanup();
 
int main() {
	// Start timer
    alarm(timeBeforeTerminate);                  						// Terminate after 10s
    signal(SIGALRM, onTimeout);
    signal(SIGCHLD, catchChild);
 
    masterPId = getpid();
 
    // Allocate & attach shared memory
 
    int currentChild = 0;
    while(currentChild < totalProcessesToBeForked) {
	  	if(processesCurrentlyForked < maxAllowedAtOnce) {
	    	forkChild(currentChild);
	    	currentChild++;
	    	processesCurrentlyForked++;
	    }
  		sleep(1);
  	}
 
    // Completed before timeout
    endTimer = true;
    int timeRemaining = alarm(0);
    if (timeRemaining > 0) {
        printf("\nCompleted w/ %is remaining. Performing cleanup.\n", timeRemaining);
        cleanup();
    }
 
	return 0;
}
 
void forkChild(int currentChild) {
    pid_t pid = fork();
 
    if (pid < 0) {
        // Error
    } else if (pid == 0) {
        // Child
        printf("#Log: #Inside %i.\n", currentChild + 1);
        execl("/bin/date", "date", 0, 0);
    } else {
        // Parent
        printf("#Log: Started %i.\n", currentChild + 1);
    }
}
 
void catchChild(int sig) {
    pid_t p;
    int state;
    p=wait(&state);
    printf("Got child %d\n",p);
    processesCurrentlyForked--;
}
 
void cleanup() {
    // Kill children
    signal(SIGINT, SIG_IGN);
    kill(-masterPId, SIGINT);
    sleep(2);
 
    // Detach & release shared memory
}
 
void onTimeout(int signal) {
    if (!endTimer && alarm(timeBeforeTerminate) == 0) {
        printf("\nTimeout! Killing slaves & performing clean up.\n");
 
        kill(masterPId, SIGINT);
    }
    exit(0);
}

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