/* mutex.c  for task synchronization  */
#include "mutex.h"
#include <stdio.h>
#include <stdlib.h>

static int n_thread;
static pthread_mutex_t *ready; /* [n_thread]; allows worker to proceed  */
static pthread_mutex_t *done;  /* [n_thread]; allows master to proceed */
static pthread_mutex_t *ack;   /* [n_thread];  acknowlege proceeding    */
static pthread_t *threads;     /* [n_thread]; */
static int debug = 0;

void mutex_init(int num_threads) // call only once
{
  n_thread = num_threads;
  ready = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)*n_thread);
  done = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)*n_thread);
  ack = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)*n_thread);
  threads = (pthread_t *)malloc(sizeof(pthread_t)*n_thread);
} /* end mutex_init */

void master_init(void *(*worker_code)(void * threadID))
{
  int rc, t;

  for(t=0; t<n_thread; t++)
  {
    if(debug){printf("creating thread %d \n", t);fflush(stdout);}
    pthread_mutex_init(&ready[t], NULL); /* holds up worker */
    pthread_mutex_lock(&ready[t]);
    pthread_mutex_init(&done[t], NULL);  /* holds up master */
    pthread_mutex_unlock(&done[t]);
    pthread_mutex_init(&ack[t], NULL);   /* holds up worker */
    pthread_mutex_unlock(&ack[t]);
    rc = pthread_create(&threads[t], NULL, worker_code, (void *)(long int)t);
    if(rc)
    {
      printf("error, thread not created, code=%d, at t=%d \n", rc, t);
      exit(-1);
    }
  }
  if(debug){printf("all threads created, end master_init \n");fflush(stdout);}
} /* end master_init */

void master_release()
{
  int t;
  for(t=0; t<n_thread; t++) /* restart all threads */
  {
    pthread_mutex_lock(&ack[t]);     /* for hold after ready */
    pthread_mutex_unlock(&ready[t]); /* let workers run */
    if(debug){printf("master release %d \n", t); fflush(stdout);}
  }
} /* end master_release */

void master_barrier()
{
  int t;
  for(t=0; t<n_thread; t++) /* wait for all threads to continue */
  {
    pthread_mutex_lock(&done[t]);    /* waits for worker to be done */
    pthread_mutex_lock(&ready[t]);   /* hold workers until everybody done  */
    pthread_mutex_unlock(&done[t]);  /* ready for workers next task */
    pthread_mutex_unlock(&ack[t]);   /* ready for workers next task */
    if(debug){printf("master barrier %d \n", t); fflush(stdout);}
  }
} /* end master_barrier */

void worker_init(int workerID)
{
  int i = workerID;
  pthread_mutex_lock(&done[i]);    /* no wait, master keeps unlocked */
  pthread_mutex_lock(&ready[i]);   /* wait for master to release */
  pthread_mutex_unlock(&ready[i]); /* unlock */
} /* end worker_init */

void worker_task_done(int workerID)
{
  int i = workerID;
  pthread_mutex_unlock(&done[i]); /* this task done */
} /* end worker_task_done */

void worker_barrier(int workerID)
{
  int i = workerID;
  pthread_mutex_unlock(&done[i]);  /* master can test for done */
  pthread_mutex_lock(&ack[i]);     /* wait for master ack */
  pthread_mutex_unlock(&ack[i]);   /* unlock */
  pthread_mutex_lock(&ready[i]);   /* waiting for master to release */
  pthread_mutex_unlock(&ready[i]); /* unlock */
  pthread_mutex_lock(&done[i]);    /* no wait, master keeps unlocked */
} /* end worker barrier */

/* end mutex.c */