warmup2.tar

Makefile0000644102503400121630000000040312773076777014060 0ustar  sravaniacsci-maj00000000000000warmup2: warmup2.o my402list.o
	gcc -pthread -o warmup2 -g warmup2.o my402list.o -lm

warmup2.o: warmup2.c my402list.h
	gcc -pthread -g -c -Wall warmup2.c -lm

my402list.o: my402list.c my402list.h
	gcc -g -c -Wall my402list.c

clean:
	rm -f *.o *.gch warmup2
cs402.h0000644102503400121630000000401712773076750013420 0ustar  sravaniacsci-maj00000000000000/******************************************************************************/
/* Important CSCI 402 usage information:                                      */
/*                                                                            */
/* This fils is part of CSCI 402 programming assignments at USC.              */
/*         53616c7465645f5f2e8d450c0c5851acd538befe33744efca0f1c4f9fb5f       */
/*         3c8feabc561a99e53d4d21951738da923cd1c7bbd11b30a1afb11172f80b       */
/*         984b1acfbbf8fae6ea57e0583d2610a618379293cb1de8e1e9d07e6287e8       */
/*         de7e82f3d48866aa2009b599e92c852f7dbf7a6e573f1c7228ca34b9f368       */
/*         faaef0c0fcf294cb                                                   */
/* Please understand that you are NOT permitted to distribute or publically   */
/*         display a copy of this file (or ANY PART of it) for any reason.    */
/* If anyone (including your prospective employer) asks you to post the code, */
/*         you must inform them that you do NOT have permissions to do so.    */
/* You are also NOT permitted to remove or alter this comment block.          */
/* If this comment block is removed or altered in a submitted file, 20 points */
/*         will be deducted.                                                  */
/******************************************************************************/

/*
 * Author:      William Chia-Wei Cheng (bill.cheng@acm.org)
 *:
 * @(#)$Id: cs402.h,v 1.1 2016/08/18 05:24:28 william Exp $
 */

#ifndef _CS402_H_
#define _CS402_H_

#ifndef NULL
#define NULL 0L
#endif /* ~NULL */

#ifndef TRUE
#define FALSE 0
#define TRUE 1
#endif /* ~TRUE */

#ifdef WIN32
#define DIR_SEP '\\'
#else /* ~WIN32 */
#define DIR_SEP '/'
#endif /* WIN32 */

#ifndef max
#define max(A,B) (((A)>(B)) ? (A) : (B))
#define min(A,B) (((A)>(B)) ? (B) : (A))
#endif /* ~max */

#ifndef round
#define round(X) (((X) >= 0) ? (int)((X)+0.5) : (int)((X)-0.5))
#endif /* ~round */

#ifndef MAXPATHLENGTH
#define MAXPATHLENGTH 256
#endif /* ~MAXPATHLENGTH */

#endif /*_CS402_H_*/
my402list.c0000644102503400121630000001442612773076674014341 0ustar  sravaniacsci-maj00000000000000#include <stdio.h>
#include <stdlib.h>
#include "my402list.h"
#include "cs402.h"

int  My402ListLength(My402List *list){
	int count=0;
	My402ListElem *elem;
	elem = My402ListFirst(list);	
	while (elem!=NULL){
		count++;
		elem=My402ListNext(list, elem);
	}
	return count;
}
int  My402ListEmpty(My402List *list){
	if (My402ListLength(list) == 0)	
		return 1;
	else 
		return 0;
}
int  My402ListAppend(My402List *list, void *nobj){
	if (My402ListEmpty(list)){
	My402ListElem *nnode=(My402ListElem *)malloc(sizeof(My402ListElem));	
	nnode->obj=nobj;
	//append to the anchor
		(list->anchor).next=nnode;
		nnode->prev=&(list->anchor);
		nnode->next=&(list->anchor);
	(list->anchor).prev=nnode;			
		return 1;	
	}
	else{
	//append in the end
		My402ListElem *nnode=(My402ListElem *)malloc(sizeof(My402ListElem));	
		nnode->obj=nobj;
		My402ListElem *elem = My402ListLast(list);
		elem->next=nnode;
		(list->anchor).prev=nnode;
		nnode->next=&(list->anchor);
		nnode->prev=elem;
		return 1;
	}
	return 0;
}
int  My402ListPrepend(My402List *list, void *nobj){
	if (My402ListEmpty(list)){
	My402ListElem *nnode=(My402ListElem *)malloc(sizeof(My402ListElem));	
		nnode->obj=nobj;
		(list->anchor).next=nnode;
		nnode->prev=&(list->anchor);
		nnode->next=&(list->anchor);
	(list->anchor).prev=nnode;			
		return 1;	
	}
	else{
                My402ListElem *nnode=(My402ListElem *)malloc(sizeof(My402ListElem));	
		nnode->obj=nobj;
		My402ListElem *elem = My402ListFirst(list);
		nnode->prev=elem->prev;		
		elem->prev=nnode;
		nnode->next=elem;
		(list->anchor).next=nnode;		
		return 1;	
	}
	return 0;
}
void My402ListUnlink(My402List *list, My402ListElem *elem){
	My402ListElem *belem=elem->prev;
	//printf("before:%d\n", (int)belem->obj);
	My402ListElem *aelem=elem->next;
	//printf("after:%d\n", (int)aelem->obj);	
	elem->next=NULL;
	elem->prev=NULL;
	belem->next=aelem;
	aelem->prev=belem;	
}
void My402ListUnlinkAll(My402List *list){
	My402ListElem *curr= My402ListFirst(list);
	My402ListElem *nextcurr=My402ListNext(list,curr);	
	while (curr!=NULL){
		My402ListUnlink(list, curr);
		curr=nextcurr;
		nextcurr=My402ListNext(list, nextcurr);
	}
	(list->anchor).next=&(list->anchor);
	(list->anchor).prev=&(list->anchor);
}
int  My402ListInsertAfter(My402List *list, void *nobj, My402ListElem *lelem){
	if (lelem == NULL){
		My402ListAppend(list, nobj);
		return 1;	
	}
	else{
		My402ListElem *nnode=(My402ListElem *)malloc(sizeof(My402ListElem));	
		nnode->obj=nobj;
		nnode->next=lelem->next;
		(lelem->next)->prev=nnode;
		lelem->next=nnode;
		nnode->prev=lelem;
		return 1;
	}
	return 0;	
}
int  My402ListInsertBefore(My402List *list, void *nobj, My402ListElem *lelem){
	if(lelem==NULL){
		My402ListPrepend(list, nobj);
		return 1;
	}
	else{
		My402ListElem *nnode=(My402ListElem *)malloc(sizeof(My402ListElem));	
		nnode->obj=nobj;
		nnode->prev=lelem->prev;
		(lelem->prev)->next=nnode;
		nnode->next=lelem;
		lelem->prev=nnode;
		return 1;
	}
	return 0;
}
My402ListElem *My402ListFirst(My402List *list){
	if((list->anchor).next == &(list->anchor)){	
		return NULL;
	}
	else 
		return (list->anchor).next;
}
My402ListElem *My402ListLast(My402List *list){
	if((list->anchor).next == &(list->anchor)){	
		return NULL;
	}
	else
		return (list->anchor).prev;
}
My402ListElem *My402ListNext(My402List *list, My402ListElem *elem){
	if (elem == My402ListLast(list))
		return NULL;
	else 
		return elem->next;
}
My402ListElem *My402ListPrev(My402List *list, My402ListElem *elem){	
	if (elem == My402ListFirst(list))
		return NULL;
	else 
		return elem->prev;	
	
}
My402ListElem *My402ListFind(My402List *list, void *lobj){
	My402ListElem *curr=My402ListFirst(list);
	while(curr!=NULL && curr->obj!=lobj){		
		curr=My402ListNext(list,curr);		
	}
	//printf("Inside My402ListFind: %d\n", (int)curr);
	return curr;
}
int My402ListInit(My402List *list){
	(list->anchor).next= &(list->anchor);
	(list->anchor).prev= &(list->anchor);
	(list->anchor).obj=NULL;	
	return 1;
}

/*main(){
	My402List mylist;
	My402ListElem *curr;
	int appe;
	My402ListInit(&mylist); //no error
	curr = &(mylist.anchor);	
	printf("%d\n",(int)curr->obj);
	curr= My402ListFirst(&mylist); //no error
	//printf("%d\n", (int)curr);
	curr= My402ListLast(&mylist); //no error
	printf("%d\n", My402ListLength(&mylist)); // no error
	printf("%d\n", My402ListEmpty(&mylist));//no error
	appe=My402ListAppend(&mylist,(void *)3); //no error
	appe= My402ListAppend(&mylist,(void *)4);	
	curr= My402ListFirst(&mylist);	
	printf("%d\n", (int)curr->obj);
	curr= My402ListNext(&mylist, curr);
	printf("%d\n", (int)curr->obj);
	appe=My402ListPrepend(&mylist, (void *)2);//works for nonempty list
	curr= My402ListFirst(&mylist);
	printf("%d\n", (int)curr->obj);
	curr=My402ListFirst(&mylist);
	curr=My402ListNext(&mylist, curr);
	//curr=My402ListNext(&mylist, curr);
	printf("printing unlinking\n");
	//curr=My402ListFirst(&mylist);
	My402ListUnlink(&mylist,curr); //deleting 3, no error
	curr=My402ListFirst(&mylist);	
	printf("%d\n", (int)curr->obj);
	curr=My402ListNext(&mylist, curr);
	printf("%d\n", (int)curr->obj);
	printf("Insert after\n");	
	curr=My402ListFirst(&mylist);	
	My402ListInsertAfter(&mylist, (void *)5, curr); //no error	
	My402ListInsertAfter(&mylist, (void *)6, NULL);
	printf("%d\n", (int)curr->obj);
	curr=My402ListNext(&mylist, curr);
	printf("%d\n", (int)curr->obj);
	curr=My402ListNext(&mylist, curr);
	printf("%d\n", (int)curr->obj);
	curr=My402ListNext(&mylist, curr);
	printf("%d\n", (int)curr->obj);
	My402ListInsertBefore(&mylist, (void *)7, NULL); //no error
	curr=My402ListFirst(&mylist);
	printf("%d\n", (int)curr->obj);
	curr=My402ListNext(&mylist, curr);
	My402ListInsertBefore(&mylist, (void *)8, curr);//no error
	printf("Inserting before\n");	
	curr=My402ListFirst(&mylist);
	printf("%d\n", (int)curr->obj);
	curr=My402ListNext(&mylist, curr);
	printf("%d\n", (int)curr->obj);
	curr=My402ListNext(&mylist, curr);
	printf("%d\n", (int)curr->obj);
	printf("printing previous element\n");
	curr= My402ListPrev(&mylist,curr); //no error
	printf("%d\n", (int)curr->obj);	
	printf("testing find operation\n");
	curr=NULL;
	curr=My402ListFind(&mylist, (void *)5); //no error	
	printf("found object:%d\n", (int) curr->obj);
	printf("Unlinking all\n");
	My402ListUnlinkAll(&mylist); //no error
	curr=My402ListFirst(&mylist);
	printf("%d\n", (int)curr);
	printf("length: %d\n", My402ListLength(&mylist));
//-----------------------------------
}*/
my402list.h0000644102503400121630000000646312773076716014345 0ustar  sravaniacsci-maj00000000000000/******************************************************************************/
/* Important CSCI 402 usage information:                                      */
/*                                                                            */
/* This fils is part of CSCI 402 programming assignments at USC.              */
/*         53616c7465645f5f2e8d450c0c5851acd538befe33744efca0f1c4f9fb5f       */
/*         3c8feabc561a99e53d4d21951738da923cd1c7bbd11b30a1afb11172f80b       */
/*         984b1acfbbf8fae6ea57e0583d2610a618379293cb1de8e1e9d07e6287e8       */
/*         de7e82f3d48866aa2009b599e92c852f7dbf7a6e573f1c7228ca34b9f368       */
/*         faaef0c0fcf294cb                                                   */
/* Please understand that you are NOT permitted to distribute or publically   */
/*         display a copy of this file (or ANY PART of it) for any reason.    */
/* If anyone (including your prospective employer) asks you to post the code, */
/*         you must inform them that you do NOT have permissions to do so.    */
/* You are also NOT permitted to remove or alter this comment block.          */
/* If this comment block is removed or altered in a submitted file, 20 points */
/*         will be deducted.                                                  */
/******************************************************************************/

/*
 * Author:      William Chia-Wei Cheng (bill.cheng@acm.org)
 *
 * @(#)$Id: my402list.h,v 1.1 2016/08/18 05:24:29 william Exp $
 */

#ifndef _MY402LIST_H_
#define _MY402LIST_H_

#include "cs402.h"

typedef struct tagMy402ListElem {
    void *obj;
    struct tagMy402ListElem *next;
    struct tagMy402ListElem *prev;
} My402ListElem;

typedef struct tagMy402List {
    int num_members;
    My402ListElem anchor;

    /* You do not have to set these function pointers */
    int  (*Length)(struct tagMy402List *);
    int  (*Empty)(struct tagMy402List *);

    int  (*Append)(struct tagMy402List *, void*);
    int  (*Prepend)(struct tagMy402List *, void*);
    void (*Unlink)(struct tagMy402List *, My402ListElem*);
    void (*UnlinkAll)(struct tagMy402List *);
    int  (*InsertBefore)(struct tagMy402List *, void*, My402ListElem*);
    int  (*InsertAfter)(struct tagMy402List *, void*, My402ListElem*);

    My402ListElem *(*First)(struct tagMy402List *);
    My402ListElem *(*Last)(struct tagMy402List *);
    My402ListElem *(*Next)(struct tagMy402List *, My402ListElem *cur);
    My402ListElem *(*Prev)(struct tagMy402List *, My402ListElem *cur);

    My402ListElem *(*Find)(struct tagMy402List *, void *obj);
} My402List;

extern int  My402ListLength(My402List*);
extern int  My402ListEmpty(My402List*);

extern int  My402ListAppend(My402List*, void*);
extern int  My402ListPrepend(My402List*, void*);
extern void My402ListUnlink(My402List*, My402ListElem*);
extern void My402ListUnlinkAll(My402List*);
extern int  My402ListInsertAfter(My402List*, void*, My402ListElem*);
extern int  My402ListInsertBefore(My402List*, void*, My402ListElem*);

extern My402ListElem *My402ListFirst(My402List*);
extern My402ListElem *My402ListLast(My402List*);
extern My402ListElem *My402ListNext(My402List*, My402ListElem*);
extern My402ListElem *My402ListPrev(My402List*, My402ListElem*);

extern My402ListElem *My402ListFind(My402List*, void*);

extern int My402ListInit(My402List*);

#endif /*_MY402LIST_H_*/
warmup2.c0000644102503400121630000004342012773152154014147 0ustar  sravaniacsci-maj00000000000000#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>
#include <time.h>
#include <math.h>
#include <signal.h>

#include "my402list.h"
#include "cs402.h"

extern int errno;
long int B=10,P=3;
long int num=20;
double lambda=1.0,mu=0.35,r=1.5;
long int tokens=0,packets=0, served=0, drop_tok=0, drop_pac=0;
char *filename=NULL;
double tot_time_q1=0.0,tot_time_q2=0.0;
double tot_time_s1=0.0,tot_time_s2=0.0;
double tot_time_sys=0.0, tot_time_lambda=0.0;
double tot_sys_sqr=0.0,tot_ser_s1=0.0,tot_ser_s2=0.0;

sigset_t set;
int die=0;

My402List Q1,Q2;
long int bucket=0;
struct timeval init_time;
double timestr;
double init_time_d;
int trace_driven=0;

pthread_mutex_t m=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cv=PTHREAD_COND_INITIALIZER;

struct packet{
 long int pac_no;
 long int pac_P;
 double pac_mu;
 double pac_lambda;
 double entry_time;
 double depart_time;
 double Q1_entry;
 double Q1_depart;
 double Q2_entry;
 double Q2_depart;
};
 
double timestamp(struct timeval time){
 return ((time.tv_sec)*1000)+((time.tv_usec)/1000.00); 
}

double absol(double x){
 if(x>0.0)
  return x;
 else
  return -x;
}
 
void* pop_buck(){
 sigprocmask(SIG_BLOCK, &set,0);
 struct timeval timer;
 double timestr;
 
 while(1){
  usleep((1/r)*1000000.00F); //takes in milliseconds
 
  pthread_mutex_lock(&m); 
  if(die==1){
   pthread_mutex_unlock(&m);
   //printf("token thread:CntrlC pressed\n");
   pthread_exit((void *)1);
  }

  tokens++;
  
  if(My402ListEmpty(&Q1) && packets==num){
   pthread_mutex_unlock(&m);
   return NULL;
  }

  gettimeofday(&timer,NULL);
  timestr=timestamp(timer);
  //if(served<num){
  if(bucket<B){
   bucket++;
   if(bucket<=1){
    printf("%012.3lfms:token t%ld arrives,token bucket now has %ld token\n",timestr-init_time_d,tokens,bucket);
   
   }
   else{
    printf("%012.3lfms:token t%ld arrives,token bucket now has %ld tokens\n",timestr-init_time_d,tokens,bucket);
   } 
  }
  else{
   printf("%012.3lfms:token t%ld arrives, dropped\n",timestr-init_time_d,tokens);
   drop_tok++;
  }
 
 //check if Q1 is eligible for transmission
  if(!My402ListEmpty(&Q1)){
   My402ListElem *new_packet;
   new_packet=My402ListFirst(&Q1);
   struct packet *new_pack=(struct packet *)new_packet->obj;
  
   if(bucket>=new_pack->pac_P){

    My402ListUnlink(&Q1,new_packet);
   
    gettimeofday(&timer,NULL);
    timestr=timestamp(timer);
    new_pack->Q1_depart=timestr-init_time_d;
   
    gettimeofday(&timer,NULL);
    timestr=timestamp(timer);
    if(bucket<=1){
     printf("%012.3lfms:p%ld leaves Q1, time in Q1 = %lfms, token bucket now has %ld token\n",timestr-init_time_d,new_pack->pac_no,absol(new_pack->Q1_depart-new_pack->Q1_entry),bucket);
     tot_time_q1+=absol(new_pack->Q1_depart-new_pack->Q1_entry);
    }
    else{
     printf("%012.3lfms:p%ld leaves Q1, time in Q1 = %lfms, token bucket now has %ld tokens\n",timestr-init_time_d,new_pack->pac_no,absol(new_pack->Q1_depart-new_pack->Q1_entry),bucket);
     tot_time_q1+=absol(new_pack->Q1_depart-new_pack->Q1_entry);    
    }
   
    My402ListAppend(&Q2, (void *)new_pack);
    gettimeofday(&timer,NULL);
    timestr=timestamp(timer);
    printf("%012.3lfms:p%ld enters Q2\n",timestr-init_time_d,new_pack->pac_no);
    new_pack->Q2_entry=timestr-init_time_d;
   
   //wake up the servers;
    pthread_cond_broadcast(&cv);
   }
  }
 pthread_mutex_unlock(&m);
 }
 return NULL;
}

void* pop_q1(){
 sigprocmask(SIG_BLOCK, &set,0);
 struct timeval timer;
 double timestr;
 char *line;
 char *param_tok;
 FILE *tptr;

 if(trace_driven==1){
  line=(char *)malloc(60*sizeof(char));
  tptr= fopen(filename,"r");
  fgets(line,60,tptr);
 }
 while(1){

  if(trace_driven==1){
   fgets(line,60,tptr);
   param_tok=strtok(line,"	 ");  
   lambda=atof(param_tok);
   if(lambda<0.1)
    lambda=0.1;
  }
  struct packet *new_pack;
  new_pack=(struct packet *)malloc(sizeof(struct packet));
  
  new_pack->pac_lambda=lambda;
  if(trace_driven==1){
   param_tok=strtok(NULL,"	 ");
  }
  usleep((1/(new_pack->pac_lambda))*1000000.00F);
  
  pthread_mutex_lock(&m);
  if(die==1){
   pthread_mutex_unlock(&m);
   pthread_exit((void *)1);
  }
  if(packets>=num){
   pthread_mutex_unlock(&m);
   return NULL;
  }
 
  tot_time_lambda+=new_pack->pac_lambda;
  packets++;
  new_pack->pac_no=packets;
 
  if(trace_driven==1){
   P=atoi(param_tok);
  }
  new_pack->pac_P=P;
 
  gettimeofday(&timer,NULL);
  timestr=timestamp(timer);
  if(new_pack->pac_P<=B){
  printf("%012.3lfms:p%ld arrives, needs %ld tokens, inter-arrival time=%lfms\n",timestr-init_time_d, new_pack->pac_no,new_pack->pac_P,new_pack->pac_lambda);
  }
  else{
   printf("%012.3lfms:p%ld arrives, needs %ld tokens, inter-arrival time=%lfms, dropped\n",timestr-init_time_d, new_pack->pac_no,new_pack->pac_P,new_pack->pac_lambda);
   drop_pac++;
   served=new_pack->pac_no;
   pthread_mutex_unlock(&m);
   continue;
  }
  
  new_pack->entry_time=timestr-init_time_d;
  if(trace_driven==1){
   param_tok=strtok(NULL,"	 ");
   mu=atof(param_tok);
   if(mu<0.1)
    mu=0.1;
  }
  new_pack->pac_mu=mu;

  //pthread_mutex_lock(&m); 
  
  if(!My402ListEmpty(&Q1)){
   
   My402ListAppend(&Q1, (void *)new_pack);
   gettimeofday(&timer,NULL);
   timestr=timestamp(timer);
   printf("%012.3lfms:p%ld enters Q1\n",timestr-init_time_d, new_pack->pac_no);
   new_pack->Q1_entry=timestr-init_time_d;
   
  }
  else if(bucket>=new_pack->pac_P){
   bucket-=new_pack->pac_P;
   
   My402ListAppend(&Q1, (void *)new_pack);
   gettimeofday(&timer,NULL);
   timestr=timestamp(timer);
   printf("%012.3lfms:p%ld enters Q1\n",timestr-init_time_d, new_pack->pac_no);
   new_pack->Q1_entry=timestr-init_time_d;
   
   My402ListElem *new_packet;
   new_packet=My402ListFirst(&Q1);
   struct packet *curr_pack=(struct packet *)new_packet->obj;
   My402ListUnlink(&Q1,new_packet);//check

   gettimeofday(&timer,NULL);
   timestr=timestamp(timer);
   curr_pack->Q1_depart=timestr-init_time_d;
   
   
   gettimeofday(&timer,NULL);
   timestr=timestamp(timer);
   if(bucket<=1){
    printf("%012.3lfms:p%ld leaves Q1, time in Q1 = %lfms, token bucket now has %ld token\n",timestr-init_time_d,curr_pack->pac_no,absol(curr_pack->Q1_depart-curr_pack->Q1_entry),bucket);
    tot_time_q1+=absol(curr_pack->Q1_depart-curr_pack->Q1_entry);
   }
   else{
    printf("%012.3lfms:p%ld leaves Q1, time in Q1 = %lfms, token bucket now has %ld tokens\n",timestr,curr_pack->pac_no,absol(curr_pack->Q1_depart-curr_pack->Q1_entry),bucket); 
    tot_time_q1+=absol(curr_pack->Q1_depart-curr_pack->Q1_entry);    
   }

   My402ListAppend(&Q2, (void *)curr_pack);
   gettimeofday(&timer,NULL);
   timestr=timestamp(timer);
   printf("%012.3lfms:p%ld enters Q2\n",timestr-init_time_d,curr_pack->pac_no);
   curr_pack->Q2_entry=timestr-init_time_d;
   
   //wake up the servers;
   pthread_cond_broadcast(&cv);
   
  }
  else{
   My402ListAppend(&Q1, (void *)new_pack);
   gettimeofday(&timer,NULL);
   timestr=timestamp(timer);
   printf("%012.3lfms:p%ld enters Q1\n",timestr-init_time_d, new_pack->pac_no);
   new_pack->Q1_entry=timestr-init_time_d;
  }
  pthread_mutex_unlock(&m);
 }
 return NULL;
}

void * s1_service(){
 sigprocmask(SIG_BLOCK, &set,0);
 struct timeval timer;
 double timestr;
 
 while(1){

  pthread_cond_wait(&cv, &m);

  if(served==num && My402ListEmpty(&Q1)){
   pthread_mutex_unlock(&m);
   return NULL;
  }  

  if(My402ListEmpty(&Q2)){
   pthread_mutex_unlock(&m);
   continue;
  }
  
  else{
   My402ListElem *curr_packet=My402ListFirst(&Q2);
   struct packet *curr_pack=(struct packet *)curr_packet->obj;
   My402ListUnlink(&Q2,(void *)curr_packet);
   gettimeofday(&timer,NULL);
   timestr=timestamp(timer);
   curr_pack->Q2_depart=timestr-init_time_d;
   printf("%012.3lfms:p%ld leaves Q2, time in Q2 = %lfms\n",timestr-init_time_d,curr_pack->pac_no,absol(curr_pack->Q2_depart-curr_pack->Q2_entry));
   tot_time_q2+=absol(curr_pack->Q2_depart-curr_pack->Q2_entry);
   
   gettimeofday(&timer,NULL);
   timestr=timestamp(timer);
   printf("%012.3lfms:p%ld begins service at S1, requesting %lfms of service\n", timestr-init_time_d,curr_pack->pac_no, curr_pack->pac_mu);

   usleep((1/curr_pack->pac_mu)*1000000.00F);

   if(die==1){
    pthread_mutex_unlock(&m);
    //printf("s1:CntrlC pressed\n");
    pthread_exit((void *)1);
   }
 
   gettimeofday(&timer,NULL);
   timestr=timestamp(timer);
   curr_pack->depart_time=timestr-init_time_d;

   printf("%012.3lfms:p%ld departs from S1, service time=%lfms, time in system = %lfms\n", timestr-init_time_d,curr_pack->pac_no, curr_pack->pac_mu,absol(curr_pack->entry_time-curr_pack->depart_time));
   tot_ser_s1+=(curr_pack->pac_mu);
   tot_time_s1+=absol(curr_pack->Q2_depart-curr_pack->depart_time);
   tot_time_sys+=absol(curr_pack->entry_time-curr_pack->depart_time);
   tot_sys_sqr=absol(curr_pack->entry_time-curr_pack->depart_time)*absol(curr_pack->entry_time-curr_pack->depart_time);
   served=curr_pack->pac_no;
  }
  
 }
 pthread_mutex_unlock(&m);
 return NULL;
}

void * s2_service(){
 sigprocmask(SIG_BLOCK, &set,0);
 struct timeval timer;
 double timestr;

 while(1){
 
  pthread_cond_wait(&cv, &m);
  
  if(served==num && My402ListEmpty(&Q1)){
   pthread_mutex_unlock(&m);
   return NULL;
  }

  if(My402ListEmpty(&Q2)){
   pthread_mutex_unlock(&m);
   continue;
  }
  
  else{
   My402ListElem *curr_packet=My402ListFirst(&Q2);
   struct packet *curr_pack=(struct packet *)curr_packet->obj;
   My402ListUnlink(&Q2,(void *)curr_packet);
   gettimeofday(&timer,NULL);
   timestr=timestamp(timer);
   curr_pack->Q2_depart=timestr-init_time_d;
   printf("%012.3lfms:p%ld leaves Q2, time in Q2 = %lfms\n",timestr-init_time_d,curr_pack->pac_no,absol(curr_pack->Q2_depart-curr_pack->Q2_entry));
   tot_time_q2+=absol(curr_pack->Q2_depart-curr_pack->Q2_entry);
   
   gettimeofday(&timer,NULL);
   timestr=timestamp(timer);
   printf("%012.3lfms:p%ld begins service at S2, requesting %lfms of service\n", timestr-init_time_d,curr_pack->pac_no, curr_pack->pac_mu);

   usleep((1/curr_pack->pac_mu)*1000000.00F);
   
   if(die==1){
    pthread_mutex_unlock(&m);
    //printf("s2:CntrlC pressed\n");
    pthread_exit((void *)1);
   }

   gettimeofday(&timer,NULL);
   timestr=timestamp(timer);
   curr_pack->depart_time=timestr-init_time_d;

   printf("%012.3lfms:p%ld departs from S2, service time=%lfms, time in system = %lfms\n", timestr-init_time_d,curr_pack->pac_no, curr_pack->pac_mu,absol(curr_pack->entry_time-curr_pack->depart_time));
   tot_ser_s2+=(curr_pack->pac_mu);
   tot_time_s2+=absol(curr_pack->Q2_depart-curr_pack->depart_time);
   tot_time_sys+=absol(curr_pack->entry_time-curr_pack->depart_time);
   tot_sys_sqr=absol(curr_pack->entry_time-curr_pack->depart_time)*absol(curr_pack->entry_time-curr_pack->depart_time);
   served=curr_pack->pac_no;
   //printf("served:%ld\n", served);
  }

 }
 pthread_mutex_unlock(&m);
 return NULL;
}

int validate_tsfile(FILE *tptr){
 //check tfile specification 
  char *line, *tok_end;
  char *param_tok;
  long int finp; 
  int param_count=0;
  double fval=0.0;
  long int i=0;
  line=(char *)malloc(60*sizeof(char)); //maybe inc the limit

//check if num is +ve
  fgets(line,60,tptr);
  finp=strtol(line, &tok_end, 10); 
  if(tok_end<line+(sizeof(char)*strlen(line))-1){
   printf("input file is not in the right format\n");
   return 1;
  } 
  else if(finp<=0){
   printf("input file is not in the right format\n");
   return 1;
  }
  else 
   num=finp;

  while(i<num){
   fgets(line,60,tptr);
   i++;
   //parsing lambda
   param_tok=strtok(line,"	 ");
    
   fval=strtof(param_tok,&tok_end);
   
   if(tok_end<param_tok+(sizeof(char)*strlen(param_tok))-1){
    printf("lambda:input file is not in the right format\n");
    return 1;
   } 
   else if(fval<=0.0){
    printf("lambda:input file is not in the right format\n");
    return 1;
   }
   else{
    lambda=fval;
    if(lambda<0.1)
     lambda=0.1;
    param_count++;
   }
    //parsing P
   param_tok=strtok(NULL,"	 ");
   finp=strtol(param_tok, &tok_end,10);
   
   if(tok_end<param_tok+(sizeof(char)*strlen(param_tok))-1){
    printf("P:input file is not in the right format\n");
    return 1;
   }
   else if(finp<=0){
    printf("P:input file is not in the right format\n");
    return 1; 
   }
   else{
    P=finp;
    param_count++;
   }
    //parsing mu
   param_tok=strtok(NULL,"	 ");
   fval=strtof(param_tok,&tok_end);
   
   if(tok_end<param_tok+(sizeof(char)*strlen(param_tok))-1){
    printf("mu:input file is not in the right format\n");
    return 1;
   }
   else if(fval<=0.0){
    printf("mu:input file is not in the right format\n");
    return 1;
   }
   else{
    mu=fval;
    if(mu<0.1)
     mu=0.1;
    param_count++;
   }
   
  }
  if(param_count!=3*num){
   printf("input file is not in the right format\n");
   return 1;
  }
 return 0;
}

void * monitor(){
 //int sig;
 while(1){
  //sigwait(&set, &sig);
  sigwait(&set);
  pthread_mutex_lock(&m);
  //critical section
  die=1;
  pthread_mutex_unlock(&m);
 }
 return NULL;
}

void print_statistics(double timestr){
 printf("Statistics:\n");
 printf("\taverage packet inter-arrival time = ");
 printf("%.6g\n", tot_time_lambda/(timestr-init_time_d));
 printf("\taverage packet service time = ");
 printf("%.6g\n",(tot_ser_s1+tot_ser_s2)/(timestr-init_time_d));
 printf("\n");
 printf("\taverage number of packets in Q1 = ");
 printf("%.6g\n",tot_time_q1/(timestr-init_time_d));
 printf("\taverage number of packets in Q2 = ");
 printf("%.6g\n",tot_time_q2/(timestr-init_time_d));
 printf("\taverage number of packets at S1 = ");
 printf("%.6g\n",tot_time_s1/(timestr-init_time_d));
 printf("\taverage number of packets at S2 = ");
 printf("%.6g\n",tot_time_s2/(timestr-init_time_d));
 printf("\n");
 printf("\taverage time a packet spent in system = ");
 printf("%.6g\n",tot_time_sys/(timestr-init_time_d));
 double stnd_dev=tot_sys_sqr/(timestr-init_time_d);
 stnd_dev-=tot_time_sys/(timestr-init_time_d);
 printf("\tstandard deviation for time spent in system = ");
 if(stnd_dev>0){
  printf("%.6g\n",sqrt(stnd_dev));
 }
 else{
  printf("0.000000\n");
 }
 printf("\n");
 printf("\ttoken drop probability = ");
 printf("%.6g\n", (double)drop_tok/tokens);
 printf("\tpacket drop probability = ");
 printf("%.6g\n", (double)drop_pac/packets);
}

int main(int argc, char * argv[]){
 int i=1;
 FILE *tptr;
 struct timeval timer;
 double timestr;
 
 char *line=NULL;
 pthread_t pack_arr, token_arr, s1,s2 ,interrupt_handle;
 sigemptyset(&set);
 sigaddset(&set, SIGINT); 
 
 line=(char *)malloc(60*sizeof(char));
 
 sigprocmask(SIG_BLOCK, &set, 0);
 pthread_create(&interrupt_handle,0,monitor,0);
 
//handle commandline arguments
 while(i<argc){
  if (strcmp(argv[i], "-lambda")==0){
   i++;
   if(i<argc){			
    lambda=atof(argv[i]); //use strtof()
    if(lambda<0.1)
     lambda=0.1;
   }
   else{
    printf("usage:malformed command\n");
    exit(1);
   }
   i++;
  }
  else if(strcmp(argv[i], "-mu")==0){
   i++;
   if(i<argc){			
    mu=atof(argv[i]);
    if(mu<0.1)
     mu=0.1;
   }
   else{
    printf("usage:malformed command\n");
    exit(1);
   }			
   i++;		
  }
  else if(strcmp(argv[i], "-r")==0){
   i++;			
   if(i<argc)			
    r=atof(argv[i]); //use strof()??
   else{
    printf("usage:malformed command\n");
    exit(1);
   }
   i++;
   if(r<0.1)
    r=0.1;
  }
  else if(strcmp(argv[i], "-B")==0){
   i++;
   if(i<argc)			
    B=atoi(argv[i]); //use strtoi()??
   else{
    printf("usage:malformed command\n");
    exit(1);
   }			
   i++;
  }
  else if(strcmp(argv[i], "-P")==0){
   i++;
   if(i<argc)			
    P=atoi(argv[i]);
   else{
    printf("usage:malformed command\n");
    exit(1);
   }			
   i++;
  }
  else if(strcmp(argv[i], "-n")==0){
   i++;
   if(i<argc)			
    num=atoi(argv[i]);
   else{
    printf("usage:malformed command\n");
    exit(1);
   }			
   i++;
  }
  else if(strcmp(argv[i], "-t")==0){
   i++;
   if(i<argc){
    struct stat path_stat;
    stat(argv[i], &path_stat);
    tptr=fopen(argv[i],"r");
    if(tptr==NULL){
     if(errno==ENOENT)
      printf("usage:input file %s does not exist\n", argv[i]);
     else if(errno==EACCES)
      printf("usage: input file %s cannot be opened -access denies\n", argv[i]);
			
     exit(1);
    }
    if(S_ISREG(path_stat.st_mode)==0){
     printf("usage:input file %s is a directory\n", argv[i]);
     exit(1);
    }
   }
   else{
    printf("usage:malformed command\n");
    exit(1);
   }
   filename=argv[i];
   trace_driven=1;
   i++;
  }
  else{
   printf("usage: malformed command\n");
   exit(1);		
  } 
 }

 if(trace_driven==1){
  int wrong=2;
  wrong=validate_tsfile(tptr);
  if(wrong==1){
   fclose(tptr);
   exit(1);
  }
  else if(wrong==0){
   fclose(tptr);
//start thread emulation
   printf("Emulation Parameters:\n");
   printf("\ttsfile = %s\n", argv[argc-1]);
   tptr= fopen(filename,"r");
   num=atoi(fgets(line,60,tptr)); 
  }    
 }
 else{
  printf("Emulation Parameters:\n");
  printf("\tnumber to arrive = %ld\n", num);
  printf("\tlambda = %lf\n", lambda);
  printf("\tmu = %lf\n",mu);
  printf("\tr = %lf\n", r);
  printf("\tB = %ld\n", B);
  printf("\tP = %ld\n", P);
 }
 
 My402ListInit(&Q1);
 My402ListInit(&Q2);
 
 gettimeofday(&init_time,NULL);
 init_time_d=timestamp(init_time);
 printf("00000000.000ms:emulation begins\n");

 pthread_create(&pack_arr,0,pop_q1,0);
 pthread_create(&token_arr,0,pop_buck,0);
 pthread_create(&s1, 0, s1_service, 0);
 pthread_create(&s2, 0, s2_service, 0);
 
 pthread_join(pack_arr,0);	
 pthread_join(token_arr,0);
 
 pthread_mutex_lock(&m);
 if(My402ListEmpty(&Q2)){
  pthread_cancel(s1);
  pthread_cancel(s2);
 }
 pthread_mutex_unlock(&m);

 pthread_mutex_lock(&m);
 if(die==1){
  pthread_mutex_unlock(&m);
  pthread_cancel(s1);
  pthread_cancel(s2);
  
  gettimeofday(&timer,NULL);
  timestr=timestamp(timer);
  print_statistics(timestr);

  My402ListUnlinkAll(&Q1);
  My402ListUnlinkAll(&Q2);
  //printf("Q1:%ld\n", My402ListLength(&Q1));
  exit(1);
 }
 
 /*pthread_join(s1,0);
 pthread_join(s2,0);*/
 
 gettimeofday(&timer,NULL);
 timestr=timestamp(timer);
 printf("%012.3lfms:emulation ends\n",timestr-init_time_d);
 print_statistics(timestr);

 return 0;
}
w2-README.txt0000644102503400121630000000663712773137533014447 0ustar  sravaniacsci-maj00000000000000Documentation for Warmup Assignment 2
=====================================

+-------+
| BUILD |
+-------+
type 'make' will create the require executables for running the program. 

+---------+
| GRADING |
+---------+
Basic running of the code : +100 points (+10 points for each run
100/100- All testcases passed
        
+---------------+
| Minus points: |
+---------------+

Missing/incomplete required section(s) in README file : -20 points (even if lots of comments in code): None

Submitted binary file : -2 points :No binary is submitted

Cannot compile      : -5 to -10, depending on effort to make it work: Just type 'make'

Compiler warnings   : -1 to -3
                      None, 

"make clean" : -2 points if cannot delete all binary files created during compilation
               All the executables are deleted.

Segmentation faults : -10 points
                No seg faults
Separate compilation : -10 points
                No code is write in .h files. Separate files are created and linked using the linker.

Delay trace printing : -30 points
                      There is some delay. But its not deadlock. I couldnt figure out why.

Using busy-wait : -30 points
                       ./warmup2
                       No busy waiting. Used condition variables whenever required.

Handling of commandline arguments:
        All the commandline arguments are handled perfectly

Trace output : -46 points
    Trace output is right. It matches the sample output given in the spec and satisfies the requirements given in the grading guidelines.

Statistics output : -24 points
        I dont know if my statistics are right. I implemented the logic given for statistics in the spec.

Output bad format : -5 points
    All the timestamps are lined up!

Output wrong precision for statistics (should be 6-8 significant digits) : -3 points: Correct precision is used.".6g" format specifier as instructed in the spec.

Large service time test : -3 points
    Handled properly. It(1/mu) cant be more than 10 seconds according to the spec. 
Large inter-arrival time test : -3 points
    Handled appropriately. Again cant be more than 10 secs
Tiny inter-arrival time test : -3 points
    Done.
Tiny service time test : -3 points
    Didnot test
Large total number of customers test : -5 points
    (press <Cntrl+C> after 15 seconds)
    Done
Large total number of customers with high arrival rate test : -5 points
    (press <Cntrl+C> after 5 seconds)
    Didnot test the case.

Cannot handle <Cntrl+C> at all (ignored or no statistics) : -20 points: Cntrl+C is handled perfectly.

Cannot stop token depositing thread when required : -3 points
    Token thread stops when last packet is out o the system.

Not using condition variables or do some kind of busy-wait : -15 points
Condition variable used. No busy waiting

Synchronization check : -20 points
    All threads are synchronized. Mutex variable used whenever required.

Deadlocks : -10 points: No deadlocks

Bad commandline or command : -1 point each for each not handling properly: All the commandline errors are handled correctly.

+------+
| BUGS |
+------+
No bugs according to the spec described. All the requirements to solve the problem are implemented successfully.

Comments on design decisions: 
Used single mutex variable to lock all the shared variables whenever required.
Contains six threads-4+a parent thread(main function)+ thread for handling cntrl+c

Comments on deviation from spec: 
No deviations.