SYNC_INIT(); 

    int i=0, counter=0; 
    pid_t pid = fork (); 
    if (pid < 0)
        err_sys ("fork error"); 
    else if (pid > 0)
    {
        // parent
        for (i=0; i<NLOOPS; i+=2)
        {
            counter = update ((long *)area); 
            if (counter != i)
                err_quit ("parent: expected %d, got %d", i, counter); 
            else 
                printf ("parent increase to %d based %d\n", i+1, counter); 

            SYNC_TELL(pid, 1); 
            SYNC_WAIT(0); 
        }

        printf ("parent exit\n"); 
    }
    else 
    {
        for (i=1; i<NLOOPS+1; i+=2)
        {
            SYNC_WAIT(1); 
            counter = update ((long *)area); 
            if (counter != i)
                err_quit ("child: expected %d, got %d", i, counter); 
            else 
                printf ("child increase to %d based %d\n", i+1, counter); 

            SYNC_TELL(getppid (), 0);
        }

        printf ("child exit\n"); 
    }

#ifdef USE_PIPE_SYNC

// pp is the pipe that parent notify(write) child wait(read)
// pc is the pipe that child notify(write) parent wait(read)
static int pp[2], pc[2]; 

void SYNC_INIT (void)
{
    if (pipe (pp) < 0 || pipe(pc) < 0)
        err_sys ("pipe error"); 
}

void SYNC_TELL (pid_t pid, int child)
{
    // close unused read end to avoid poll receive events
    // note, we can NOT do it in SYNC_INIT, 
    // as at that moment, we have not fork yet !
    if (child) { 
        close (pp[0]); 
        close (pc[1]); 
        pp[0] = pc[1] = -1; 
    } else { 
        close (pc[0]); 
        close (pp[1]); 
        pc[0] = pp[1] = -1; 
    }

    if (write (child ? pp[1] : pc[1], child ? "p" : "c", 1) != 1)
        err_sys ("write error"); 
}

void SYNC_WAIT (int child /* unused */)
{
    int n = 0, m = 0; 
    struct pollfd fds[2] = {{ 0 }}; 
    // if fd==-1, just be a place taker !
    //if (pp[0] != -1) 
    {
        fds[n].fd = pp[0]; 
        fds[n].events = POLLIN; 
        n++; 
    }

    //if (pc[0] != -1) 
    { 
        fds[n].fd = pc[0]; 
        fds[n].events = POLLIN; 
        n++; 
    }

    int ret = poll (fds, n, -1); 
    if (ret == -1)
        err_sys ("poll error"); 
    else if (ret > 0) { 
        char c = 0; 
        //printf ("poll %d from %d\n", ret, n); 
        for (m=0; m<n; ++m) {
            //printf ("poll fd %d event 0x%08x\n", fds[m].fd, fds[m].revents); 
            if (fds[m].revents & POLLIN) { 
                if (fds[m].fd == pp[0]) { 
                    if (read (pp[0], &c, 1) != 1)
                        err_sys ("read parent pipe error"); 
                    if (c != 'p')
                        err_quit ("wait parent pipe but got incorrect data %c", c); 
                }
                else {
                    if (read (pc[0], &c, 1) != 1) 
                        err_sys ("read child pipe error"); 
                    if (c != 'c') 
                        err_quit ("wait child pipe but got incorrect data %c", c); 
                }
            }
        }
    }
    else 
        printf ("poll return 0\n"); 
}

#endif

#ifdef USE_SEM_SYNC

union semun
{
  int val;                //<= value for SETVAL
  struct semid_ds *buf; //        <= buffer for IPC_STAT & IPC_SET
  unsigned short int *array;//         <= array for GETALL & SETALL
  struct seminfo *__buf;    //        <= buffer for IPC_INFO
};

static int semid = -1;  

void SYNC_INIT ()
{
    int mode = 0666;  // 0; 
    int flag = IPC_CREAT; 
#ifdef USE_EXCL
    flag |= IPC_EXCL; 
#endif

    semid = semget (IPC_PRIVATE, 2, flag | mode); 
    if (semid < 0)
        err_sys ("semget for SYNC failed"); 

    printf ("create semaphore %d for SYNC ok\n", semid); 

    union semun sem; 
    //sem.val = 1;
    //int ret = semctl (semid, 0, SETVAL, sem); 
    //if (ret < 0)
    //    err_sys ("semctl to set val failed"); 
    
    short arr[2] = { 0 }; 
    sem.array = arr; 
    int ret = semctl (semid, 0, SETALL, sem); 
    if (ret < 0)
        err_sys ("semctl to set all val failed"); 

    printf ("reset all semaphores ok\n"); 
}

void SYNC_TELL (pid_t pid, int child)
{
    struct sembuf sb; 
    sb.sem_op = 1; 
    sb.sem_num = child ? 1 : 0; 
    sb.sem_flg = 0;  // IPC_NOWAIT, SEM_UNDO
    int ret = semop (semid, &sb, 1); 
    if (ret < 0)
        printf ("semop to release resource failed, ret %d, errno %d\n", ret, errno); 
    else 
        printf ("release %d resource %d\n", sb.sem_op, ret); 
}

void SYNC_WAIT (int child)
{
    struct sembuf sb; 
    sb.sem_op = -1; 
    sb.sem_num = child ? 1 : 0; 
    sb.sem_flg = 0;  // IPC_NOWAIT, SEM_UNDO
    int ret = semop (semid, &sb, 1); 
    if (ret < 0)
        printf ("semop to require resource failed, ret %d, errno %d\n", ret, errno); 
    else 
        printf ("require %d resource %d\n", sb.sem_op, ret); 
}

#endif

#ifdef USE_SIGNAL_SYNC

static volatile sig_atomic_t sigflag; 
static sigset_t newmask, oldmask, zeromask; 

static void sig_usr (int signo)
{
    sigflag = 1; 
    printf ("SIGUSR1/2 called\n"); 
}

void SYNC_INIT ()
{
    if (apue_signal (SIGUSR1, sig_usr) == SIG_ERR)
        err_sys ("signal (SIGUSR1) error"); 
    if (apue_signal (SIGUSR2, sig_usr) == SIG_ERR)
        err_sys ("signal (SIGUSR2) error"); 

    sigemptyset (&zeromask); 
    sigemptyset (&newmask); 
    sigaddset (&newmask, SIGUSR1); 
    sigaddset (&newmask, SIGUSR2); 

    if (sigprocmask (SIG_BLOCK, &newmask, &oldmask) < 0)
        err_sys ("SIG_BLOCK error"); 
}

void SYNC_TELL (pid_t pid, int child)
{
    kill (pid, child ? SIGUSR1 : SIGUSR2); 
}

void SYNC_WAIT (int child /* unused */)
{
    while (sigflag == 0)
        sigsuspend (&zeromask); 

    sigflag = 0; 
    if (sigprocmask (SIG_SETMASK, &oldmask, NULL) < 0)
        err_sys ("SIG_SETMASK error"); 
}

#endif