/************************************************************
  File:          main.cc
  Description:   A program that simulates a dependancy graph 
                 for a set of threads.
                                                         
  Author:        Dana Vrajitoru                          
  Organization:  IUSB                                    
  Date:          November 24, 2004
**************************************************************/

#include <stdlib.h>
#include <iostream>
using namespace std;
#include <pthread.h>
#include "gsemaphore.h"
#include "graph.h"

Graph gr;
Gsemaphore *sem;

// Prototypes.
void Create_threads(pthread_t *threads, int nr_threads);
void Synchronise(pthread_t *threads, int nr_threads);
void *Thread(void *arg);
void Task(int id);
void Signal_out(int id);

int main()
{
  int i, nr_threads;
  char filename[80];

  cout << "Enter the graph filename" << endl;
  cin>> filename;
  gr.Read(filename);
  gr.Print();
  nr_threads = gr.nr_vertices;

  pthread_t *threads = new pthread_t[nr_threads];
  sem = new Gsemaphore[nr_threads];

  Create_threads(threads, nr_threads);
  Synchronise(threads, nr_threads);
}

// Creates the threads calling the producer function, then those
// calling the consumer function, and to each of them it passes the
// pointer to the number of items as the argument.
void Create_threads(pthread_t *threads, int nr_threads)
{
  for (int i=0; i<nr_threads; i++) {
    int j = i;
    void *arg = &j;
    if (pthread_create(&threads[i], NULL, Thread, arg) != 0)
      printf("Pthread_create fails");    
  }
}

// Joins all of the threads so that the program doesn;t end before
// they have finished the work.
void Synchronise(pthread_t *threads, int nr_threads)
{
  for (int i=0; i<nr_threads; i++)
    if (pthread_join(threads[i], NULL) != 0)
      printf("Pthread_join fails\n");
}

// The thread function that executes the task after waiting for all
// the threads on which it depends to finish their task.
void *Thread(void *arg)
{
  int id = *((int *)arg);
  int d = gr.Count_incoming(id);
  Init_sem(sem[id], d);
  Test_and_inc(sem[id]);
  Task(id);
  Signal_out(id);
}

// Printing out an appropriate message and introducing a delay.
void Task(int id)
{
  cout << "Thread " << id << " performing task" << endl;
  sleep(1);
}

// This function must scan the adjacency list of the vertex id in the
// graph and call the function Dec for the semaphores of all of the
// vertices in its adjacency list.
void Signal_out(int id)
{
  // Code to be supplied by the student.
}