/******************************************************************************
* DESCRIPTION:
*   Example code for using Pthreads condition variables.  The global data gets 
*   incremented  (in readval function) and everything it reaches nLimit, the 
*   writeval function will write and append the array to a output file.
******************************************************************************/

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define NUM_THREADS  2

int global_data;
int nSamples = 10000;
int nLimit  = 1000;

pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_sample_limit = PTHREAD_COND_INITIALIZER;

void *readval(void *arg);
void *writeval(void *arg);

// ============================== Main Program ==============================
int main()
{
  int i;
  pthread_t threads[NUM_THREADS];
  
  // Initialise mutex and condition
  pthread_mutex_init(&mymutex, NULL);
  pthread_cond_init (&cond_sample_limit, NULL);

  if (pthread_create(&threads[0], NULL, readval, NULL)) {
    printf("error creating reading_thread.\n"); abort();
  }

  if (pthread_create(&threads[1], NULL, writeval, NULL)) {
    printf("error creating writing_thread.\n"); abort();
  }

  /* Join all threads upon completion*/
  for (i = 0; i < NUM_THREADS; i++) {
    pthread_join(threads[i], NULL);
  }
  printf ("Main(): Completion on %d  threads. Done.\n", NUM_THREADS);

  pthread_mutex_destroy(&mymutex);
  pthread_cond_destroy(&cond_sample_limit);
  pthread_exit (NULL);

}

// ==================== Reading Values from Device =====================
void *readval(void *arg) 
{
  int i,j, count;
  for ( i=0; i<nSamples; i++ ) {
    j=global_data;
    j++;
    global_data=j;

    pthread_mutex_lock(&mymutex);
    if (i!=0 && i%nLimit==0) {
      pthread_cond_broadcast(&cond_sample_limit);
      printf("readval(): count = %d  Threshold reached.\n", i);
    }
    pthread_mutex_unlock(&mymutex);
  }
  pthread_exit(NULL);
}

// ====================== Writing Values to File =======================

void *writeval(void *arg) 
{
	size_t obj_size=sizeof(int);
	size_t obj_cnt=sizeof(nLimit)/sizeof(int);

	FILE *p_file;
	char *filename= "/temp/output.log";
	p_file=fopen(filename,"w");
	pthread_mutex_lock(&mymutex);

	while (global_data != 0) {
	pthread_cond_wait(&cond_sample_limit, &mymutex);
	printf("writeval(): Data written to file.\n");
	fwrite(&global_data, obj_size,obj_cnt, p_file);
	}

  	pthread_mutex_unlock(&mymutex);
  	pthread_exit(NULL);
	fclose(p_file);
	fflush(stdout);
}

// ==================== Reading Values from Device =====================
void *readval(void *arg) 
{
  int i,j, count;
  for ( i=0; i<nSamples; i++ ) {
    j=global_data;
    j++;
    global_data=j;

    pthread_mutex_lock(&mymutex);
    if (i!=0 && i%nLimit==0) {
      pthread_cond_broadcast(&cond_sample_limit);
      printf("readval(): count = %d  Threshold reached.\n", i);
    }
    pthread_mutex_unlock(&mymutex);
  }
  pthread_exit(NULL);
}

// ====================== Writing Values to File =======================

void *writeval(void *arg) 
{
	size_t obj_size=sizeof(int);
	size_t obj_cnt=sizeof(nLimit)/sizeof(int);

	FILE *p_file;
	char *filename= "/temp/output.log";

	p_file=fopen(filename,"w");

/*  should check if  fopen succeeded. e.g. if folder /temp/ does not exist 
 *  or no writing permissions etc. possibilities always exist and should be
 *  anticipated
*/

	pthread_mutex_lock(&mymutex);

      /*  for one thing there is no initial value for global_data.
       *  secondly this seems to be ending condition also.
       *  your first thread never sets the value of global_data to zero
       * before calling _broadcast. therefore this loop can never end.
       *  and file is thus never flushed, never closed...
       */
	while (global_data != 0) {
	pthread_cond_wait(&cond_sample_limit, &mymutex);
	printf("writeval(): Data written to file.\n");

        /**
          *  But the following is really breaker because global_data
          *  is currently just one integer. Therefore the obj_cnt should
          *  be 1 instead of 1000.. and still it would write the integer
          *  to the file in a binary format... perhaps wasn't the idea ??
          */
	fwrite(&global_data, obj_size,obj_cnt, p_file);
	}

  	pthread_mutex_unlock(&mymutex);

        /*  If you exit THIS thread before the file is closed then it is 
             never really closed !
        */
  	pthread_exit(NULL);

        /*  cannot flush the writing buffer after file has already been closed!
         *  but then fclose() does automatically flush the outbuffer into the file
         *  before closing so using fflush is not called for. 
         */
	fclose(p_file);
	fflush(stdout);
}