/******************************************************************
    Student Number: 3100604012
                  Name: Duwen
                  Date:2012-6-9
                  Type:Demonstration code
          Description:Operating System  Course Design (OSCD)---Thread synchronization 
          with semaphore. you must know this code only as a demonstration of the Windows
          API , it's unwise to copy this code to OSCD report directly, you should regard this
          code as a reference to you. and then write it by yourself.
    
*******************************************************************/

#include "stdafx.h"
#include <Windows.h>
#define MAX_SEM_COUNT 10
#pragma warning(disable:4996)        //Ignore 4996 warning 

typedef HANDLE  OSCD_semaphore;

////////////////////////////////////////////////////////////////////////////

//Define the semaphores needed as global variables
OSCD_semaphore mutex,reader,writer;
//Define the counters
int readcount=0, writecount=0,readapp=0;
//Allocate buffer
char buffer[256]={0};

///////////////////////////////////////////////////////////////////

//Function to create and initialize a new semaphore
OSCD_semaphore OSCD_CreateSemaphore(int nInitialCount) 
{
    OSCD_semaphore hSemaphore;
    if (nInitialCount>MAX_SEM_COUNT){ //sanity check
        printf("semaphore count too big ,please specify a value range 0 to 10\n");
        exit(0);
    }
    hSemaphore=::CreateSemaphoreA(NULL,nInitialCount,MAX_SEM_COUNT,NULL );
    if (hSemaphore == NULL) {
        printf("CreateSemaphore error: %d\n", GetLastError());
        exit(0);
    }
    return hSemaphore;
}

//Function to delete the semaphore
void OSCD_DelSemaphore( OSCD_semaphore semaphore)
{
    ::CloseHandle(semaphore);

}

//P operation
void P(OSCD_semaphore semaphore)
{
   ::WaitForSingleObject(semaphore,INFINITE);
}

//V operation
void V(OSCD_semaphore semaphore)
{
    if (!::ReleaseSemaphore(semaphore,1,NULL))
    {
        printf("release semaphore error: %d\n",GetLastError());
        exit(0);
    }
}

//Reader thread function
DWORD WINAPI Reader(LPVOID lpParameter)
{  
    char *pThreadName=(char *)lpParameter;
    Sleep((pThreadName[6]-'0')*5);
    P(mutex);
    if (writecount>0||buffer[0]==NULL){
        if(writecount>0)
            printf("%s find there exists writer(s) trying to write ,  wait\n",pThreadName);
        else
            printf("There is no data in buffer now,%s  wait\n" ,pThreadName);
        readapp++;
        V(mutex);
        P(reader);
        printf("%s gets semaphore successfully !",pThreadName);
        P(mutex);
        readapp--;
        readcount++;
        if (readapp>0) V(reader);
        V(mutex);
    }
    else{
        readcount++;
        V(mutex);
    }
    printf("%s read the data that :%s\n",pThreadName,buffer);
    P(mutex);
    readcount -- ; 
    if ( readcount == 0 && writecount>0 )
        V(writer) ;
    V(mutex) ;
    return 0;
}

//Writer thread function 
DWORD WINAPI  Writer(LPVOID lpParameter)
{  
    char *pDataToWrite=(char *)lpParameter;
    Sleep((pDataToWrite[7]-'0')*7);
    P(mutex);
    writecount ++ ;
    printf("A new writer is trying to write\n");
    //when there are  readers are  reading or writers are trying to write, waiting..
    if (readcount>0 || writecount>1 ){
        V(mutex);
        printf(" Waiting(writer) semaphore\t The contents to write is:%s\n ", pDataToWrite);
        P(writer);
    }
    else V(mutex) ; //skip waiting
    int nLen=strlen(pDataToWrite);
    strncpy(buffer,pDataToWrite,nLen/2);//write
    Sleep(3);//wait 3 ms
    strcpy(buffer+nLen/2,pDataToWrite+nLen/2);
    P(mutex); 
    writecount -- ;
    if (writecount>0 ) V(writer) ; 
    else if (readapp>0 ) V(reader) ;
    printf("A writer waited gets semaphore ,Writing: \" %s \" to buffer \n ", pDataToWrite );
    V(mutex) ;

    return 0;
}




int _tmain(int argc, _TCHAR* argv[])
{
    //Create semaphores
   mutex= OSCD_CreateSemaphore(1);
   reader=OSCD_CreateSemaphore(0);
   writer=OSCD_CreateSemaphore(0);

   int i,j; 
   char *DataToWrite[6]={
       "(writer1) ","(writer2)","(writer3)",
       "(writer4) ","(writer5)","(writer6)"
   };

   char *ReaderName[6]={
       "reader1","reader2","reader3","reader4","reader5","reader6"
   };

   HANDLE  hThreads[12];
   for ( i=0,j=0;i<6;i++)
   {
       hThreads[j]=::CreateThread(NULL,0,Reader,ReaderName[i],SW_NORMAL,NULL);
       if(!hThreads[j++]){ printf("create thread failed\n") ;return 0;}

       hThreads[j]=::CreateThread(NULL,0,Writer,DataToWrite[i],SW_NORMAL,NULL);
       if(!hThreads[j++]){ printf("create thread failed\n"); return 0;}
      
   }
   printf("CREATE THREADS COMPLETED\n");

   //Wait for all the threads ending up.and then exit.
   WaitForMultipleObjects(12,hThreads,TRUE,INFINITE);

   //Delete semaphores
   OSCD_DelSemaphore(mutex);
   OSCD_DelSemaphore(writer);
   OSCD_DelSemaphore(reader);

    return 0;
}