Understanding unix child processes that use semaphore and shared memory

Question

I'm going to do my best to ask this question with the understanding that I have.

I'm doing a programming assignment (let's just get that out of the way now) that uses C or C++ on a Unix server to fork four children and use semaphore and shared memory to update a global variable. I'm not sure I have an issue yet, but my lack of understanding has me questioning my structure. Here it is:

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define NUM_REPEATS 10
#define SEM_KEY  1111
#define SHM_KEY  2222

int globalCounter = 0;

/***** Test function for confriming a process type ******/
int checkProcessType(const char *whoami)
{
  printf("I am a %s.  My pid is:%d  my ppid is %d\n",
  whoami, getpid(), getppid() );
  for(int i = 1; i<=3; i++){
    printf("%s counting %d\n", whoami, i);
  }
  return 1;
}

void 

int main (void) {

  pid_t process_id;       // PID (child or zero)
  int sharedMemID;        // Shared memory ID
  int sharedMemSize;      // shared memory size
  struct my_mem * sharedMemPointer;   // pointer to the attached shared memory

  // Definition of shared memory  //
  struct my_mem {
    long counter;
    int parent;
    int child;
  };

  // Gathering size of shared memory in bytes //
  sharedMemSize = sizeof(my_mem);
  if(sharedMemSize <= 0){
    perror("error collection shared memory size: Exiting...\n");
    exit(0);
  }

  // Creating Shared Memory //
  sharedMemID = shmget(SHM_KEY, sharedMemSize, 0666 | IPC_CREAT);
  if (sharedMemID < 0) {
    perror("Creating shared memory has failed: Exiting...");
    exit(0);
  }

  // Attaching Shared Memory //
  sharedMemPointer = (struct my_mem *)shmat(sharedMemID, NULL, 0);
  if (sharedMemPointer == (struct my_mem*) -1) {
    perror("Attaching shared memory has failed. Exiting...\n");
    exit(0);
  }

  // Initializing Shared Memory //
  sharedMemPointer->counter = 0;
  sharedMemPointer->parent = 0;
  sharedMemPointer->child = 0;

  pid_t adder, reader1, reader2, reader3;
  adder = fork();
  if(adder > 0)
  {
    // In parent

    reader1 = fork();
    if(reader1 > 0)
    {
      // In parent

      reader2 = fork();
      if(reader2 > 0)
      {
        //In parent

        reader3 = fork();
        if (reader3 > 0)
        {
          //In parent

        }
        else if (reader3 < 0)
        {
          // Error
          perror("fork() error");
        }
        else
        {
          // In reader3

        }
      }
      else if(reader2 < 0)
      {
        //Error
        perror("fork() error");
      }
      else
      {
        // In reader2

      }
    }
    else if(reader1 < 0)
    {
      // Error
      perror("fork() error");
    }
    else
    {
      // In reader1

    }
  }
  else if(adder < 0 )
  {
    // Error
    perror("fork() error");
  }
  else
  {
    // In adder
    //LOOP here for global var in critical section
  }


}

Just some info of what I'm doing (I think), I'm creating a hunk of shared memory that will contain a variable, lets call it counter that will strictly be updated by adder and by the parent which becomes a subtractor after all child processes are active. I'm still trying to figure out the semaphore stuff that I will be using so adder and subtractor execute in critical section, but my main question is this.

How can I know where I am in this structure? My adder should have a loop that will do some job (update global var), and the parent/subtractor should have a loop for its job (also update global var). And all the readers can look at any time. Does the loop placement for parent/subtractor matter? I basically have 3 locations I know I'll be in parent. But since all children need to be created first does it have to be in the last conditional after my third fork where I know I'm in parent? When I use my test method I get scattered outputs, meaning child one can be after parent's output, then child three, etc. It's never in any order, and from what I understand of fork that's expected.

I really have like three questions going on, but I need to first wrap my head around the structure. So let me just try to say this again concisely without any junk cause I'm hung up on loop and critical section placement that isn't even written up yet.

More directly, when does parent know the existence of all children and with this structure can one child do a task and somehow come back to it (i.e. adder/first child adding to global variable once, exits, and some other child can do its thing etc).

I still feel like I'm not asking the right thing, and I believe this is due to still trying to grasp concepts. Hopefully my stammering will kind of show what I'm stuck on conceptually. If not I can clarify.