예제 #1
0
void *Token(void* arg){
    int j=0;
    useconds_t wait_time = 0;
    
    if(r < 0.1)
        r = 0.1;
    
    wait_time = (1/r)*SECTOMSEC;
    
    
    while( 1 ) {
        
        pthread_mutex_lock(&lock);
        
        if( total_packets_prod == num && My402ListEmpty(&Q1_node)){
            curr_q2_size = 1;
            pthread_cond_signal(&serverQ);
            pthread_mutex_unlock(&lock);
            break;
        }
        
        pthread_mutex_unlock(&lock);
        
        usleep(wait_time);
        
        pthread_mutex_lock(&lock);
        
        if( total_packets_prod == num && My402ListEmpty(&Q1_node)){
            pthread_mutex_unlock(&lock);
            continue;
        }
        pthread_mutex_unlock(&lock);
        
        pthread_mutex_lock(&lock);
        if(token_limit < B){
            j++;
            total_tokens_prod = j;
            token_limit++;
            fprintf(stdout, "%012.3lfms: token t%d arrives, token bucket now has %d token\n",GetMTimeOfDay(),j,token_limit);
        }else{
            j++;
            total_tokens_prod = j;
            tokens_drop++;
            fprintf(stdout, "%012.3lfms: token t%d arrives, dropped\n",GetMTimeOfDay(), j );
        }
        //check if it can move first packet from Q1 to Q2
        if(!My402ListEmpty(&Q1_node)){
            ProcessPacket();
            
        }
        pthread_mutex_unlock(&lock);
        
    }
    
    return 0;
}
예제 #2
0
extern int  My402ListPrepend(My402List* List, void* insData)
 {
   My402ListElem *newNode = (My402ListElem *) malloc(sizeof(My402ListElem));

   if(newNode != NULL)
    {
        newNode->obj = insData;
        if(My402ListEmpty(List))
            {
                List->anchor.next = newNode;
                List->anchor.prev = newNode;
                newNode->next = &(List->anchor);
                newNode->prev = &(List->anchor);
                (List->num_members)++;
                return TRUE;
            }
        else
            {
                My402ListElem *firstNode = My402ListFirst(List);
                List->anchor.next = newNode;
                newNode->next = firstNode;
                firstNode->prev = newNode;
                newNode->prev = &(List->anchor);
                (List->num_members)++;
                return TRUE;
            }
    }
     return FALSE;

 }
예제 #3
0
void server_procedure(struct command_line_args *object)
{
	struct packet *p;
	My402ListElem *elem = NULL;
	struct timespec tim;
	double time;
	long time_diff_in_nsec;
	int i = 0;
	while( i < object->no_of_packets && !EndServerThread) 
	{
		pthread_mutex_lock(&token_bucket);
		while(My402ListEmpty(&Q2PacketList)&&!EndServerThread)
			pthread_cond_wait(&is_q2_empty,&token_bucket);

		if(EndServerThread == 1)
		{
			pthread_mutex_unlock(&token_bucket);
			break;
		}

		elem = My402ListFirst(&Q2PacketList);
		if(elem == NULL)
		{
			pthread_mutex_unlock(&token_bucket);
			break;
		}
		p = (struct packet *)elem->obj;
		My402ListUnlink(&Q2PacketList, elem);

		pthread_mutex_unlock(&token_bucket);
	
		gettimeofday(&(p->Q2leaves), NULL);
		time = (TIME_IN_USEC(p->Q2leaves) - TIME_IN_USEC(GlobalStartTime))/1000;
		p->time_in_Q2 = (TIME_IN_USEC(p->Q2leaves) - TIME_IN_USEC(p->Q2timestamp))/1000;

		LOG(stdout, "%012.3fms: p%d begin service at S, time in Q2 = %.3fms\n",time,p->packet_id,p->time_in_Q2);
 
		time_diff_in_nsec = (long)((((p->precise_packet_service_time)/1000) - (p->service_time/1000))*1000000000L);
		tim.tv_sec = (p->service_time)/1000;
		tim.tv_nsec = time_diff_in_nsec;
	
		nanosleep(&tim, NULL);
	
		gettimeofday(&(p->Leaves_server), NULL);
		time = (TIME_IN_USEC(p->Leaves_server) - TIME_IN_USEC(GlobalStartTime))/1000;
		p->time_in_system = (TIME_IN_USEC(p->Leaves_server) - TIME_IN_USEC(p->Arrival_timestamp))/1000;
		p->precise_packet_service_time = (TIME_IN_USEC(p->Leaves_server) - TIME_IN_USEC(p->Q2leaves))/1000;
		LOG(stdout, "%012.3fms: p%d departs from S, service time = %.3fms, time in system = %.3fms\n",time,p->packet_id,p->precise_packet_service_time,p->time_in_system);
		completed_packets ++;
		calculate_stats(p);
		if((packet_count == object->no_of_packets) &&(completed_packets == (packet_count-discarded_packets)) && My402ListEmpty(&Q2PacketList))
		{
			EndServerThread = 1;
			pthread_cond_signal(&is_q2_empty);
		}
		i++;
	}
	pthread_exit(NULL);
	
}
예제 #4
0
void interrupt_main()
{
    //printf("<-----CTR+C RECIEVED------>\n");
    SERVER_DIE = 1;
    pthread_kill(TOKEN, SIGUSR1);
    pthread_kill(PACKET, SIGUSR2);

    pthread_mutex_lock(&m);
    //printf("Inside mutex of Man\n");
    while(!My402ListEmpty(Q2)){
        My402ListElem *elem = My402ListFirst(Q2);
        My402dataElem *topEle = (My402dataElem*)(elem->obj);
        My402ListUnlink(Q2, elem);

        TIME_AT_Q1 = diff_timeval(TIME_AT_Q1, topEle->q1duration);
    }
    /* Clear the list */
    My402ListUnlinkAll(Q1);
    pthread_mutex_unlock(&m);

    pthread_cond_broadcast(&cond_t);

    //printf("<-----MAIN DYING------>\n");
    pthread_exit(0);
}
void My402ListUnlink(My402List *pList, My402ListElem *elem){
	if(elem == NULL || My402ListEmpty(pList)) return;
	elem->prev->next = elem->next;
	elem->next->prev = elem->prev;
	free(elem);
	pList->num_members--;
}
예제 #6
0
void insert_list(My402List * list, My402TransData * data)
{
	if(My402ListEmpty(list))
		(void)My402ListAppend(list, (void*)data);
	else
	{
		My402ListElem * elem = My402ListFirst(list);
		while(elem)
		{
			My402TransData * temp = (My402TransData *)(elem -> obj);
			if(temp -> timestamp < data -> timestamp)
			{
				elem = My402ListNext(list, elem);
				if(!elem)
					(void)My402ListAppend(list, (void*)data);
			}
			else if(temp -> timestamp > data -> timestamp)
			{
				(void)My402ListInsertBefore(list, (void*)data, elem);
				break;
			}
			else
				print_error("two identical timestamp");
		}
	}
}
예제 #7
0
My402ListElem * My402ListLast(My402List * list)
{
    if(My402ListEmpty(list))
        return NULL;
    else
        return (list -> anchor).prev;
}
예제 #8
0
My402ListElem * My402ListFirst(My402List * list)
{
    if(My402ListEmpty(list))
        return NULL;
    else
        return (list -> anchor).next;
}
예제 #9
0
extern int  My402ListPrepend(My402List*list, void*item)
{
	My402ListElem *elem;
	elem=malloc(sizeof(struct tagMy402ListElem));
	elem->obj=item;
	if(My402ListEmpty(list)==1) //if list is empty
	{
		elem->next=&list->anchor;
		elem->prev=&list->anchor;
		list->anchor.next=elem;
		list->anchor.prev=elem;
		list->num_members++;
		return(1);
	}
	else
	{		
		elem->next=list->anchor.next;
		elem->prev=&list->anchor;
		list->anchor.next->prev=elem;
		list->anchor.next=elem;
		list->num_members++;
		return(1);
	}
	return(0);
}
예제 #10
0
extern int  My402ListAppend(My402List*list, void*item)	//DRAW AND CHECK THIS------------------------------------------
{
		My402ListElem *elem;
		elem=malloc(sizeof(struct tagMy402ListElem));
		elem->obj=item;
	if(My402ListEmpty(list)==1) //if list is empty
	{
		elem->next=&list->anchor;
		elem->prev=&list->anchor;
		list->anchor.next=elem;
		list->anchor.prev=elem;
		list->num_members++;
		//printf("appended %d when list is empty\n",(int*)elem->obj);
		return(1);
	}
	else
	{
		elem->next=&list->anchor;
		elem->prev=list->anchor.prev;
		list->anchor.prev->next=elem;//last element 
		list->anchor.prev=elem;
		list->num_members++;
		//printf("appended %d when list is not empty\n",(int*)elem->obj);
		return(1);
	}
	return(0);
}
My402ListElem *My402ListFirst(My402List *pList){
	if(My402ListEmpty(pList)){
		return NULL;
	}
	else{
		return pList->anchor.next;
	}
}
My402ListElem *My402ListLast(My402List *pList){
	if(My402ListEmpty(pList)){
		return NULL;
	}
	else{
		return pList->anchor.prev;
	}
}
예제 #13
0
/* Process the pakcets in Q1 and transfer to Q2 when enough tokens */
void ProcessPacket(){
    My402ListElem *find = NULL;
    Packet_desc *p = NULL;
    
    find=My402ListFirst(&Q1_node);
    
    if(find->obj == NULL){
        fprintf(stderr,"Error: Obj is NULL");
        pthread_exit(0);
    }
    
    p = (Packet_desc*)find->obj;
    
    
    if(p->tokens <= token_limit){
        // move this to Q2
        
        token_limit -= p->tokens;
        
        // total time in Q1
        
        p->total_Q1_time = GetMTimeOfDay()- p->Q1_time_enters;
        
        
        fprintf(stdout, "%012.3lfms: p%d leaves Q1, time in Q1 = %.3lfms, tokens bucket now has %d token\n",GetMTimeOfDay(),p->name_ID,p->total_Q1_time,token_limit);
        
        
        if(My402ListEmpty(&Q2_node)){
            // signal the condition about the queue not empty
            p->Q2_time_enters = GetMTimeOfDay();
            // Q2_time_enters[p->name_ID] = GetMTimeOfDay();
            fprintf(stdout, "%012.3lfms: p%d enters Q2\n",GetMTimeOfDay(),p->name_ID);
            
            My402ListAppend(&Q2_node, (void*)p);
            curr_q2_size = 1;
            /* signal the condition variable queue*/
            pthread_cond_signal(&serverQ);
            find = My402ListFind(&Q1_node, (void*)p);
            My402ListUnlink(&Q1_node, find);
            
        }else{
            p->Q2_time_enters = GetMTimeOfDay();
            
            //   Q2_time_enters[p->name_ID] = GetMTimeOfDay();
            
            fprintf(stdout, "%012.3lfms: p%d enters Q2\n",GetMTimeOfDay(),p->name_ID);
            
            My402ListAppend(&Q2_node, (void*)p);
            /* gaurd set true */
            curr_q2_size = 1;
            find = My402ListFind(&Q1_node, (void*)p);
            My402ListUnlink(&Q1_node, find);
            
        }
        
    }
}
예제 #14
0
void My402ListUnlink(My402List * list, My402ListElem * elem)
{
    if(My402ListEmpty(list))
        return;
    My402ListElem * prev = elem -> prev;
    My402ListElem * next = elem -> next;
    prev -> next = next;
    next -> prev = prev;
    list -> num_members--;
    free(elem);
}
예제 #15
0
extern My402ListElem *My402ListLast(My402List*list)
{
	if(My402ListEmpty(list)==1) //if list is empty
	{
		return(NULL);
	}
	else
	{
		return(list->anchor.prev);
	}
}
예제 #16
0
void DequePacket(Packet_desc *p,My402ListElem *first_elem){
    
    p->total_Q2_time = GetMTimeOfDay()- p->Q2_time_enters;
    
    fprintf(stdout, "%012.3lfms: p%d leaves Q2, time in Q2 = %.3lfms, begin service at S\n",GetMTimeOfDay(), p->name_ID,p->total_Q2_time);
    
    My402ListUnlink(&Q2_node, first_elem);
    
    if(My402ListEmpty(&Q2_node))
        curr_q2_size = 0;
    
}
예제 #17
0
int My402ListAppend(My402List* q, void* x)
{
    My402ListElem* temp = (My402ListElem*)malloc(sizeof(My402ListElem));
    My402ListElem* p = (My402ListElem*)malloc(sizeof(My402ListElem));
    p=&(q->anchor); //addr of anchor

    My402ListElem* a = (My402ListElem*)malloc(sizeof(My402ListElem));

    a=My402ListLast(q);

    //printf("im in append\n");
    if (temp==NULL)
    {
        return FALSE;
    }

    if(a==NULL)
    {

        a=p;
    }

    if (My402ListEmpty(q)==1)

    {
        temp->obj= x;
        temp->prev=p;
        temp->next=p;
        p->prev=temp;
        p->next=temp;


    }

    else
    {
        temp->obj=x;
        temp->next=p;
        temp->prev=a;
        a->next=temp;
        p->prev=temp;


    }

    //printf("im at append end\n");
    q->num_members++;
    return TRUE;



}
예제 #18
0
void My402ListUnlinkAll(My402List * list)
{
    if(My402ListEmpty(list))
        return;
    My402ListElem * cur = My402ListFirst(list);
    while(cur)
    {
        My402ListElem * del = cur;
        cur = My402ListNext(list, cur);
        My402ListUnlink(list, del);
    }
    (list -> anchor).next = &(list -> anchor);
    (list -> anchor).prev = &(list -> anchor);
}
예제 #19
0
int  My402ListPrepend(My402List* q, void* x)
{
    My402ListElem* temp1 = (My402ListElem*)malloc(sizeof(My402ListElem));
    My402ListElem* p = (My402ListElem*)malloc(sizeof(My402ListElem));
    p=&(q->anchor);
    My402ListElem* a = (My402ListElem*)malloc(sizeof(My402ListElem));
    a=My402ListFirst(q);

    if (temp1==NULL)
    {
        return FALSE;
    }

    if (a==NULL)
    {

        a=p;
    }

    if (My402ListEmpty(q)==1)
    {
        temp1->obj= x;
        temp1->prev=p;
        temp1->next=p;
        //temp1->next=p->next;
        q->anchor.next=temp1;
        q->anchor.prev=temp1;
        //(temp1->next)->prev=temp1;
    }
    else
    {
        temp1->obj=x;
        temp1->prev=p;
        q->anchor.next=temp1;
        //(temp1->prev)->next=temp1;
        temp1->next=a;
        a->prev=temp1;
        //(temp1->next)->prev=temp1;
    }
    q->num_members++;
    return TRUE;


}
int  My402ListPrepend(My402List *pList, void *obj){
	My402ListElem *elem = (My402ListElem *)malloc(sizeof(My402ListElem));
	if(elem == NULL) return FALSE;
	elem->obj = obj;
	if(My402ListEmpty(pList)){
		pList->anchor.next = elem;
		pList->anchor.prev = elem;
		elem->prev = &pList->anchor;
		elem->next = &pList->anchor;
	}
	else{
		elem->prev = &pList->anchor;
		elem->next = pList->anchor.next;
		pList->anchor.next->prev = elem;
		pList->anchor.next = elem;
	}
	pList->num_members++;
	return TRUE;
}
예제 #21
0
// Append the item to the list 
int  My402ListAppend(My402List* myList, void* elem) { 
	My402ListElem *newElement = NULL;
	My402ListElem *anchorElement = &myList->anchor;
	newElement = (My402ListElem *)malloc(sizeof(My402ListElem));
	if(newElement != NULL) {
		if(My402ListEmpty(myList)) {
			newElement->prev = anchorElement;
			newElement->next = anchorElement;
			anchorElement->next = newElement;
			anchorElement->prev = newElement;
			newElement->obj = elem;
			myList->num_members++;
			
			return TRUE;
		} else {
			return My402ListInsertAfter(myList,elem,My402ListLast(myList));		
		}
	} 
	return FALSE;
}
예제 #22
0
void move_packet_q1_to_q2(struct command_line_args *object, My402ListElem *elem, struct packet *p)
{
	double time;
	int isEmpty = 0;
	My402ListUnlink(&Q1PacketList, elem);
	gettimeofday(&(p->Q1leaves),NULL);
	time = (TIME_IN_USEC(p->Q1leaves) - TIME_IN_USEC(GlobalStartTime))/1000;
	p->time_in_Q1 = (TIME_IN_USEC(p->Q1leaves) - TIME_IN_USEC(p->Q1timestamp))/1000;
	LOG(stdout, "%012.3fms: p%d leaves Q1, time in Q1 = %.3fms, token bucket now has %d token%c\n",time,p->packet_id,p->time_in_Q1,tokens_in_bucket,(tokens_in_bucket > 1 ?'s':' '));	
	q1_temp_count++;
		
	isEmpty = My402ListEmpty(&Q2PacketList);
	My402ListAppend(&Q2PacketList, p);
	gettimeofday(&(p->Q2timestamp),NULL);
	time = (TIME_IN_USEC(p->Q2timestamp) - TIME_IN_USEC(GlobalStartTime))/1000;
	LOG(stdout, "%012.3fms: p%d enters Q2\n",time,p->packet_id);	
	if(isEmpty)
		pthread_cond_signal(&is_q2_empty);
		
}
static
void RandomShuffle(My402List *pList, int num_items)
{
    int i=0;
    My402List list2;
    My402ListElem *elem=NULL;

    memset(&list2, 0, sizeof(My402List));
    (void)My402ListInit(&list2);

    for (i=0; i < num_items; i++) {
        int j=0, idx=0, num_in_list=num_items-i;
        void *obj=NULL;

        idx = RandomIndex(num_in_list);
        for (elem=My402ListFirst(pList); elem != NULL; elem=My402ListNext(pList, elem)) {
            if (j == idx) {
                break;
            }
            j++;
        }
        if (elem == NULL) {
            fprintf(stderr, "Unrecoverable error in RandomShuffle().\n");
            exit(1);
        }
        obj = elem->obj;
        My402ListUnlink(pList, elem);
        (void)My402ListAppend(&list2, obj);
    }
    if (!My402ListEmpty(pList)) {
        fprintf(stderr, "List not empty in RandomShuffle().\n");
        exit(1);
    }
    for (elem=My402ListFirst(&list2); elem != NULL; elem=My402ListNext(&list2, elem)) {
        (void)My402ListAppend(pList, elem->obj);
    }
    My402ListUnlinkAll(&list2);
}
예제 #24
0
void *Service(void* arg){
    My402ListInit(&Q2_node);
    double time_in_system = 0.0;
    
    while(1){
        My402ListElem *first_elem = NULL ;
        Packet_desc *p = NULL;
        
        
        if(total_packets_prod == num && My402ListEmpty(&Q2_node) && My402ListEmpty(&Q1_node)){
        	pthread_cond_broadcast(&serverQ);
        	 break;
    
		}
           
        
        pthread_mutex_lock(&lock);
        
        while(curr_q2_size == 0 && !interrupt_called){
            pthread_cond_wait(&serverQ, &lock);
        }
        if((total_packets_prod == num && My402ListEmpty(&Q2_node) && My402ListEmpty(&Q1_node)) || interrupt_called){
            pthread_exit(0);
        }
        
        first_elem = My402ListFirst(&Q2_node);
        
        if(first_elem->obj == NULL){
            fprintf(stderr,"Error: Obj is NULL");
            pthread_exit(0);
        }
        
        p = (Packet_desc*)first_elem->obj;
        
        
        DequePacket(p,first_elem);
        p->S_time_enters = GetMTimeOfDay();
        pthread_mutex_unlock(&lock);
        
        
        usleep(p->ser_time*THOUSAND);
        
        pthread_mutex_lock(&lock);
        
        packet_served++;
        
        p->total_S_time = GetMTimeOfDay()- p->S_time_enters;
        time_in_system = GetMTimeOfDay()- p->Q1_time_enters;
        sys_variance += time_in_system * time_in_system ;
        
        /* Calculate total time for the packets served */
        total_ser_time += p->total_S_time;
        total_sys_time += time_in_system;
        time_in_Q1 += p->total_Q1_time;
        time_in_Q2 += p->total_Q2_time;
        
        
        fprintf(stdout, "%012.3lfms: p%d departs from S, service time = %.3fms, time in system = %.3fms\n",GetMTimeOfDay(), p->name_ID,p->total_S_time,time_in_system);
        
        free(p);
        
        pthread_mutex_unlock(&lock);
        
    }
    
    return 0;
}
예제 #25
0
void deterministic_packet_procedure(struct command_line_args *object)
{

	struct packet *p,*p2;
	int i = 0;
	double time, precise_inter_arrival_time, precise_service_time;
	int inter_arrival_time = 0, service_time = 0;
	struct timespec tim;
	struct timeval prev_packet_arrival_time, now, delta;
	long time_diff_in_nsec,delta_time;
	My402ListElem *elem = NULL;

	precise_inter_arrival_time = ((double)1/object->packet_rate);
	inter_arrival_time = (int)(precise_inter_arrival_time);
	if(inter_arrival_time > 10)
	{	
		precise_inter_arrival_time = 10;inter_arrival_time = 10;
	}
	time_diff_in_nsec = (long)((precise_inter_arrival_time - inter_arrival_time)*1000000000L);
	
	
	precise_service_time = ((double)1/object->serving_rate);
	service_time = (int)(precise_service_time);	
	
	if(service_time > 10)
	{	
		precise_service_time = 10;service_time = 10;
	}
	prev_packet_arrival_time.tv_sec = GlobalStartTime.tv_sec;
	prev_packet_arrival_time.tv_usec = GlobalStartTime.tv_usec;

	while(i < object->no_of_packets)
	{
		if((packet_count == object->no_of_packets) && (q1_temp_count == (packet_count-discarded_packets)) && My402ListEmpty(&Q1PacketList))
		{
			pthread_cancel(token_thread);
		}
		gettimeofday(&delta,NULL);
		delta_time = TIME_IN_USEC(delta) - TIME_IN_USEC(prev_packet_arrival_time);
		tim.tv_sec = inter_arrival_time - (delta_time/1000000);
		tim.tv_nsec = (time_diff_in_nsec - (delta_time*1000)) <= 0 ? time_diff_in_nsec : ((time_diff_in_nsec - (delta_time*1000)));
		nanosleep(&tim,NULL);

		packet_count++;
		p = create_packet((precise_inter_arrival_time*1000),(precise_service_time*1000),object->token_per_packet);
		gettimeofday(&(p->Arrival_timestamp), NULL);
		p->precise_packet_inter_arrival = ((TIME_IN_USEC(p->Arrival_timestamp) - TIME_IN_USEC(prev_packet_arrival_time)))/1000;
		time = (TIME_IN_USEC(p->Arrival_timestamp) - TIME_IN_USEC(GlobalStartTime))/1000;

		sum_packet_inter_arrival += p->precise_packet_inter_arrival;
		prev_packet_arrival_time = p->Arrival_timestamp;
		pthread_mutex_lock(&token_bucket);
		if(p->token_per_packet > object->bucket_depth)
		{
			gettimeofday(&now, NULL);
			p->time_in_system = (TIME_IN_USEC(now) - TIME_IN_USEC(p->Arrival_timestamp))/1000;

			LOG(stdout, "%012.3fms: packet p%d arrives, needs %d token%c, dropped\n",time, p->packet_id,p->token_per_packet,(p->token_per_packet > 1?'s':' '));
			free(p);
			discarded_packets++;
			pthread_mutex_unlock(&token_bucket);
			i++;
			continue;
		}
		LOG(stdout, "%012.3fms: p%d arrives, needs %d token%c, inter-arrival time = %.3fms\n",time,p->packet_id, p->token_per_packet,(p->token_per_packet > 1? 's':' ') ,p->precise_packet_inter_arrival);
		My402ListAppend(&Q1PacketList, p);
		gettimeofday(&(p->Q1timestamp), NULL);
		time = (TIME_IN_USEC(p->Q1timestamp) - TIME_IN_USEC(GlobalStartTime))/1000;
		LOG(stdout, "%012.3fms: p%d enters Q1\n",time,p->packet_id);
		elem = My402ListFirst(&Q1PacketList);
		p2 = (struct packet *)elem->obj;
		if(p2->token_per_packet <= tokens_in_bucket)
		{
			tokens_in_bucket -= p2->token_per_packet;
			move_packet_q1_to_q2(object,elem, p2);
		} 	
		
		pthread_mutex_unlock(&token_bucket);
		if((packet_count == object->no_of_packets) && (q1_temp_count == (packet_count-discarded_packets)) && My402ListEmpty(&Q1PacketList))
		{
			pthread_cancel(token_thread);
		}

		i++;
	}


	if((packet_count == object->no_of_packets) &&(q1_temp_count == (packet_count-discarded_packets)) && My402ListEmpty(&Q1PacketList))
	{
			pthread_cancel(token_thread);
	}

	if((packet_count == object->no_of_packets) &&(completed_packets == (packet_count - discarded_packets)) && My402ListEmpty(&Q2PacketList))
	{
		EndServerThread = 1;
		pthread_cond_signal(&is_q2_empty);
	}
}
예제 #26
0
파일: warmup2.c 프로젝트: adityadani/CS-402
void *arrivalThread(void *id)
{
	My402ListElem *elem;
	Packet *pkt;
	int i;
	long pkt_sleep, pkt_service;
	int pkt_token;
	long sleep_time;
	long prev_pkt_time=0, instant_time;
	long avg_ia=0;


	for (i=0;i<num_packets;i++) {


		getStatistics(&pkt_sleep,&pkt_service,&pkt_token,i);		
		if(pkt_sleep > 10000000)
			pkt_sleep = 10000000;
		if(pkt_service > 1000000)
			pkt_service = 10000000;
				
		taend=getinstanttime();
		sleep_time = pkt_sleep - (taend-tastart);
		usleep(sleep_time);
		
		// Creating the Packet
		
		pkt = (Packet *)malloc(sizeof(struct tagPacket));
		pkt->pkt_id = i;
		pkt->num_tokens = pkt_token;
		pkt->service_time = pkt_service;

		pkt->sys_enter = tastart = getinstanttime();
		if(pkt->num_tokens > B) {
			// Drop the packet
			pkts_to_arrive--;
			PrintStat(getinstanttime());
			fprintf(stdout, "p%d arrives, Invalid token requirement, p%d Dropped!!\n", 
				pkt->pkt_id, pkt->pkt_id);
			continue;
		}
		else {
			instant_time = getinstanttime();
			if(prev_pkt_time==0) {
				prev_pkt_time = pkt->inter_arrival_time = (instant_time - temulation_start);
				prev_pkt_time = instant_time;
			}
			else {
				pkt->inter_arrival_time = instant_time - prev_pkt_time;
				prev_pkt_time = instant_time;
			}
			PrintStat(instant_time);
			avg_ia += pkt->inter_arrival_time;
			fprintf(stdout, "p%d arrives, needs %d tokens, inter-arrival time = %.3fms\n",
				pkt->pkt_id,pkt->num_tokens,(double)(pkt->inter_arrival_time)/1000);
		}

		pthread_mutex_lock(&my_mutex);
		if(My402ListEmpty(&queue1)){
			My402ListAppend(&queue1,pkt);
			pkt->q1_enter = getinstanttime();
			PrintStat(getinstanttime());
			fprintf(stdout,"p%d enters Q1\n", pkt->pkt_id);
			if(!My402ListEmpty(&queue2)) {
				pthread_cond_signal(&queue2_cond);
			}
			else {
				if(token_bucket >= pkt->num_tokens) {
					elem = My402ListFirst(&queue1);
					pkt = (Packet *)elem->obj;					

					My402ListUnlink(&queue1,elem);
					pkt->q1_exit = getinstanttime();
					token_bucket-=pkt->num_tokens;
					PrintStat(getinstanttime());
					fprintf(stdout, "p%d leaves Q1, time in Q1 = %.3fms, token bucket now has %d tokens\n", 
						pkt->pkt_id, (double)(pkt->q1_exit - pkt->q1_enter)/1000, token_bucket);
					avg_pkt_q1 += (pkt->q1_exit - pkt->q1_enter);
					pkts_left_q1++;
					My402ListAppend(&queue2,pkt);
					pkt->q1_enter = 0;
					pkt->q1_exit = 0;
					pkt->q2_enter = getinstanttime();
					PrintStat(getinstanttime());
					fprintf(stdout,"p%d enters Q2\n", pkt->pkt_id);
					pthread_cond_signal(&queue2_cond);
				}
			}
		}
		else {
			My402ListAppend(&queue1,pkt);
			pkt->q1_enter = getinstanttime();
			PrintStat(getinstanttime());
			fprintf(stdout,"p%d enters Q1\n", pkt->pkt_id);
		}
		pthread_mutex_unlock(&my_mutex);
	}
	pthread_mutex_lock(&my_mutex);
	pthread_cond_signal(&queue2_cond); // This can also be a false signal just to wake up server, if
	pthread_mutex_unlock(&my_mutex);   // say last packet is dropped and there is no pkt to be queued to q2.
	if(i==-1) {
		avg_inter_arrival = 0;
		pkt_drop_prob = 0;
	}
	else {
		avg_inter_arrival = (double)((double)avg_ia/(double)((i+1)*1000000));
		pkt_drop_prob = (double)(num_packets - pkts_to_arrive)/(i+1);
	}
	pthread_exit(NULL);
}
예제 #27
0
파일: warmup2.c 프로젝트: adityadani/CS-402
void *serverThread(void *id)
{
	Packet *pkt;
	My402ListElem *elem;
	int i,pkt_processed = 0;
	long serv_start, serv_end, avg_st = 0, avg_pkst = 0,sys_time;
	double sys_avg = 0, sys_avg_sq = 0;
	double var_sys, var_sys_sq; 

	for(i=0;i<pkts_to_arrive;i++) {
		pthread_mutex_lock(&my_mutex);
		while(My402ListEmpty(&queue2) && server_die==0) {
			if(i==pkts_to_arrive)   // This is the case when the last packet is dropped. And the
				break; 		// server thread is waiting on q2 and no pkt is there to be queued to q2.
			pthread_cond_wait(&queue2_cond, &my_mutex);
		}
		if(i==pkts_to_arrive)
			server_die=1;
		if(server_die!=0) {
			My402ListUnlinkAll(&queue1);
			My402ListUnlinkAll(&queue2);
			pthread_mutex_unlock(&my_mutex);
			break;
		}
		elem=My402ListFirst(&queue2);
		pkt = (Packet *)elem->obj;
		My402ListUnlink(&queue2,elem);
		pkt->q2_exit = getinstanttime();
		PrintStat(getinstanttime());
		fprintf(stdout,"p%d begins service at S, time in Q2 = %.3fms\n", pkt->pkt_id,
			(double)(pkt->q2_exit - pkt->q2_enter)/1000);
		pthread_mutex_unlock(&my_mutex);
		avg_pkt_q2 += (pkt->q2_exit - pkt->q2_enter);
		serv_start = getinstanttime();
		usleep(pkt->service_time);
		pkt->sys_exit = serv_end = getinstanttime();
		pkt->serv_time = serv_end - serv_start;
		avg_st += pkt->serv_time;
		avg_pkst += (pkt->sys_exit - pkt->sys_enter);
		pkt_processed++;
		PrintStat(getinstanttime());
		sys_time = pkt->sys_exit - pkt->sys_enter;
		fprintf(stdout,"p%d departs from S, service time = %.3fms, time in system = %.3fms\n", pkt->pkt_id,
			(double)(pkt->serv_time)/1000,
			(double)(sys_time)/1000);
		avg_pkt_s += pkt->serv_time;
		sys_avg += (double)(sys_time)/1000000;
		sys_avg_sq += ((double)(sys_time)/1000000) * ((double)(sys_time)/1000000);

	}
	// Informing token thread to die.
	if(pkt_processed!=0) {
		avg_serv_time = (double)((double)avg_st/(double)(pkt_processed*1000000));
		avg_pkt_sys_time = (double)((double)avg_pkst/(double)(pkt_processed*1000000));
		var_sys = sys_avg/pkt_processed;
		var_sys_sq = sys_avg_sq/pkt_processed;
		std_deviation = sqrt(var_sys_sq - var_sys*var_sys);
	}
	else {
		avg_serv_time = 0;
		avg_pkt_sys_time = 0;
		var_sys = 0;
		var_sys_sq = 0;
		std_deviation = 0;		
	}
	token_die=1;
	pthread_exit(NULL);
}
void * server_thread_function(void *args){
    pthread_sigmask(SIG_BLOCK, &set, 0);

    long  local_total_packet_counter               = 0;
    float local_packet_service_time                = packet_service_time;
    float local_total_packet_time_in_S             = 0.0;
    float local_total_packet_time_in_Q2            = 0.0;
    float local_total_packet_service_time          = 0.0;
    float local_total_time_spent_in_system         = 0.0;
    float local_total_time_spent_in_system_squared = 0.0;
    struct timeval previous_time, current_time;

    while(1){
        
        /* Lock the mutex */
        pthread_mutex_lock(&mutex);

        /* wait for the queue-not-empty condition to be signaled */
        while(My402ListEmpty(&Q2) && !cntrl_c_signal){
            pthread_cond_wait(&condition_variable, &mutex);
            if(packet_arrival_thread_stop){
                break;
            }
            
        }
        
        if(!My402ListEmpty(&Q2)){
            My402ListElem * temp_server_thread_element = My402ListLast(&Q2);
            My402ListUnlink(&Q2, temp_server_thread_element);
            struct packet * temp_server_thread_packet =
	                     (struct packet *)(temp_server_thread_element->obj);
            
            if(is_trace_driven_mode){
                local_packet_service_time =
		                 temp_server_thread_packet->packet_service_time;
            }

            gettimeofday(&current_time, NULL);

            printf("%012.3fms: p%ld leaves Q2, time in Q2 = %.3fms, begin "
	           "service at S\n",
		   calculate_time_difference(current_time,emulation_start_time),
		   temp_server_thread_packet->id,
		   calculate_time_difference(current_time,
		                     temp_server_thread_packet->updation_time));
            
            local_total_packet_time_in_Q2 = local_total_packet_time_in_Q2 +
	                                calculate_time_difference(current_time,
				      temp_server_thread_packet->updation_time);
            
            gettimeofday(&temp_server_thread_packet->updation_time, NULL);
            
            /* Unlock the mutex */
            pthread_mutex_unlock(&mutex);
            
            gettimeofday(&previous_time, NULL);
            
            /* Sleep for needed service time */
            usleep(local_packet_service_time * 1000000.0);
            
            gettimeofday(&current_time, NULL);
            
            printf("%012.3fms: p%ld departs from S, service time = %.3fms, "
	           "time in system = %.3fms\n",
		   calculate_time_difference(current_time,emulation_start_time),
		   temp_server_thread_packet->id,
		   calculate_time_difference(current_time, previous_time),
		   calculate_time_difference(current_time,
		                     temp_server_thread_packet->creation_time));
            
            local_total_packet_service_time = local_total_packet_service_time +
	                 calculate_time_difference(current_time, previous_time);
            
            local_total_packet_time_in_S = local_total_packet_time_in_S +
	                 calculate_time_difference(current_time, previous_time);
            
            float temp = calculate_time_difference(current_time,
	                              temp_server_thread_packet->creation_time);
            
            local_total_time_spent_in_system =
	                                local_total_time_spent_in_system + temp;
            
            local_total_time_spent_in_system_squared =
	               local_total_time_spent_in_system_squared + (temp * temp);
            
            free(temp_server_thread_packet);
            local_total_packet_counter++;
        }
        else{
            pthread_mutex_unlock(&mutex);
        }

        //Check this condition
        if(cntrl_c_signal ||
	   (local_total_packet_counter == number_of_packets_put_in_Q1 &&
	                                          packet_arrival_thread_stop)){
            pthread_mutex_lock(&mutex);
            if(local_total_packet_counter !=0){
                average_packet_service_time = local_total_packet_service_time /
		                              (float)local_total_packet_counter;

                average_number_of_packets_in_Q2 = local_total_packet_time_in_Q2;

                average_number_of_packets_at_S = local_total_packet_time_in_S;

                average_time_a_packet_spent_in_system =
		                            local_total_time_spent_in_system /
					    (float)local_total_packet_counter;

                local_total_time_spent_in_system_squared =
		                     local_total_time_spent_in_system_squared /
				              (float)local_total_packet_counter;

                standard_deviation_for_time_spent_in_system =
		              sqrtf(local_total_time_spent_in_system_squared -
			      ( average_time_a_packet_spent_in_system *
			                average_time_a_packet_spent_in_system));
            }
            server_thread_stop = 1;
            pthread_mutex_unlock(&mutex);
            break;
        }
    }
    pthread_exit(0);
    return NULL;
}
void * packet_arrival_thread_function(void * args){
    pthread_sigmask(SIG_BLOCK, &set, 0);
    long local_packet_created_count = 0;
    long local_packet_added_count = 0;
    long local_packet_dropped_count = 0;
    float local_packet_arrival_time = 0.0;
    long local_tokens_needed_for_a_packet = 0;
    float local_packet_service_time = 0.0;
    float local_total_packet_arrival_time = 0.0;
    float local_total_packet_time_in_Q1 = 0.0;
    
    local_packet_arrival_time        = packet_arrival_time;
    local_packet_service_time        = packet_service_time;
    local_tokens_needed_for_a_packet = tokens_needed_for_a_packet;
    
    struct timeval previous_time, current_time;
    struct packet *local_arrival_thread_packet;
    
    int stop_flag = 0;
    
    while(1){
        
        if(is_trace_driven_mode){
            local_packet_arrival_time = **(tsfile_data +
	                                  local_packet_created_count) / 1000.0;

            local_packet_service_time = *(*(tsfile_data +
	                              local_packet_created_count) + 2) / 1000.0;
            local_tokens_needed_for_a_packet = *(*(tsfile_data +
	                                      local_packet_created_count) + 1);
        }
        
        gettimeofday(&previous_time, NULL);
        usleep(local_packet_arrival_time * 1000000.0);
        gettimeofday(&current_time, NULL);
        
        
        local_total_packet_arrival_time = local_total_packet_arrival_time +
	                 calculate_time_difference(current_time,previous_time);
        
        local_packet_created_count++;
        
        /* Create a new packet */
        local_arrival_thread_packet = malloc(sizeof(struct packet));

        local_arrival_thread_packet->id = local_packet_created_count;
        local_arrival_thread_packet->packet_arrival_time =
	                                              local_packet_arrival_time;
        local_arrival_thread_packet->packet_service_time =
	                                              local_packet_service_time;
        local_arrival_thread_packet->tokens_needed =
	                                       local_tokens_needed_for_a_packet;

        gettimeofday(&local_arrival_thread_packet->creation_time, NULL);
        gettimeofday(&local_arrival_thread_packet->updation_time, NULL);
        
        
        /* Lock the mutex */
        pthread_mutex_lock(&mutex);
        
        /*if(cntrl_c_signal){
            stop_flag = 1;
            
        }
        else{*/
	{
            
            
            if(local_tokens_needed_for_a_packet > bucket_capacity){
                
                printf("%012.3fms: p%ld arrives, needs %ld tokens, "
		       "inter-arrival time = %.3fms, dropped\n",
		       calculate_time_difference(current_time,emulation_start_time),
		       local_packet_created_count,local_tokens_needed_for_a_packet,
		       calculate_time_difference(current_time,previous_time));
                
                local_packet_dropped_count++;
                free(local_arrival_thread_packet);
            }
            else {
                
                printf("%012.3fms: p%ld arrives, needs %ld tokens, "
		       "inter-arrival time = %.3fms\n",
		       calculate_time_difference(current_time,emulation_start_time),
		       local_packet_created_count,local_tokens_needed_for_a_packet,
		       calculate_time_difference(current_time,previous_time));
                
                gettimeofday(&previous_time, NULL);
                
                /* Add the packet to Q1 */
                My402ListPrepend(&Q1, local_arrival_thread_packet);
                
                gettimeofday(&current_time, NULL);
                printf("%012.3fms: p%ld enters Q1\n",
		       calculate_time_difference(current_time,emulation_start_time),
		       local_packet_created_count);
                
                local_packet_added_count++;
            }
            
            local_arrival_thread_packet = NULL;
            
            if(!My402ListEmpty(&Q1)){
                My402ListElem * temp_arrival_thread_element = My402ListLast(&Q1);

                struct packet * temp_arrival_thread_packet =
		            (struct packet *)(temp_arrival_thread_element->obj);
                
                /* Move the first packet to q2 if there are enough tokens */
                if(number_of_tokens_in_bucket >=
		                    temp_arrival_thread_packet->tokens_needed){
                    
                    int is_empty = My402ListEmpty(&Q2);
                    
                    number_of_tokens_in_bucket = number_of_tokens_in_bucket -
		                     temp_arrival_thread_packet->tokens_needed;
                    
                    My402ListUnlink(&Q1,temp_arrival_thread_element);
                    
                    gettimeofday(&current_time, NULL);
                    printf("%012.3fms: p%ld leaves Q1, time in Q1 = %.3fms, "
		           "token bucket now has %ld token\n",
			   calculate_time_difference(current_time,
			                             emulation_start_time),
			   temp_arrival_thread_packet->id,
			   calculate_time_difference(current_time,
			            temp_arrival_thread_packet->updation_time),
			   number_of_tokens_in_bucket);
                    printf ("file is %s and function is %s\n", __FILE__,
		                                             __FUNCTION__);
                    
                    local_total_packet_time_in_Q1 =
		                              local_total_packet_time_in_Q1 +
		    calculate_time_difference(current_time,
		                     temp_arrival_thread_packet->updation_time);
                    
                    gettimeofday(&temp_arrival_thread_packet->updation_time,
		                 NULL);
                    My402ListPrepend(&Q2, temp_arrival_thread_packet);
                    
                    gettimeofday(&current_time, NULL);
                    printf("%012.3fms: p%ld enters Q2\n",
		           calculate_time_difference(current_time,
			                             emulation_start_time),
			   temp_arrival_thread_packet->id);
                    
                    if(is_empty){
                        pthread_cond_broadcast(&condition_variable);
                    }
                    
                }
                temp_arrival_thread_element = NULL;
                temp_arrival_thread_packet = NULL;
            }
        }
        pthread_mutex_unlock(&mutex);
        if(stop_flag || (local_packet_created_count == total_number_of_packets)){
            pthread_mutex_lock (&mutex);
            number_of_packets_put_in_Q1 = local_packet_added_count;
            if(local_total_packet_time_in_Q1 != 0.0){
                if(average_number_of_packets_in_Q1 == -1.0){
                    average_number_of_packets_in_Q1 = 0.0;
                }
                average_number_of_packets_in_Q1 = average_number_of_packets_in_Q1 +
		                                  local_total_packet_time_in_Q1;
            }
            if(local_packet_created_count !=0){
                average_packet_inter_arrival_time = local_total_packet_arrival_time / 
		                                    (float)local_packet_created_count;
                packet_drop_probability = (float)local_packet_dropped_count / 
		                          (float)local_packet_created_count;
            }
            packet_arrival_thread_stop = 1;
            pthread_mutex_unlock(&mutex);
            break;
            
        }
        
    }
    pthread_exit(0);
    return NULL;
}
예제 #30
0
파일: warmup2.c 프로젝트: adityadani/CS-402
void *tokenThread(void *id)
{
	long sleep_time;
	int queue2_empty;
	int token_drop=0;
	Packet *pkt;
	My402ListElem *elem;
	while(1) {

		if(token_die==1) {
			token_drop_prob = (double)token_drop/tokencount;
			pthread_exit(NULL);
		}

		ttend=getinstanttime();
		sleep_time = tokenarrival - (ttend-ttstart);
		usleep(sleep_time);	
		ttstart = getinstanttime();
		pthread_mutex_lock(&my_mutex);
		if(token_bucket<B) {
			token_bucket++;
			tokencount++;
			PrintStat(getinstanttime());
			fprintf(stdout,"token t%d arrives, token bucket now has %d tokens\n",tokencount,token_bucket);
		}
		else {
			PrintStat(getinstanttime());
			tokencount++;
			token_drop++;
			fprintf(stdout,"token t%d arrives, token bucket full, token dropped!!\n",tokencount);
		}
		
		if(!My402ListEmpty(&queue1)) {
			elem = My402ListFirst(&queue1);
			pkt = (Packet *)elem->obj;
			if(token_bucket >= pkt->num_tokens) {
				token_bucket-=pkt->num_tokens;
				My402ListUnlink(&queue1,elem);
				pkt->q1_exit = getinstanttime();
				PrintStat(getinstanttime());
				fprintf(stdout, "p%d leaves Q1, time in Q1 = %.3fms, token bucket now has %d tokens\n", 
					pkt->pkt_id, (double)(pkt->q1_exit - pkt->q1_enter)/1000, token_bucket);
				avg_pkt_q1 += (pkt->q1_exit - pkt->q1_enter);
				pkts_left_q1++;
				queue2_empty = My402ListEmpty(&queue2);
				My402ListAppend(&queue2,pkt);
				pkt->q2_enter = getinstanttime();
				PrintStat(getinstanttime());
				fprintf(stdout,"p%d enters Q2\n", pkt->pkt_id);

				if(queue2_empty==1)
					pthread_cond_signal(&queue2_cond);
			}
		}
		pthread_mutex_unlock(&my_mutex);
		if(pkts_left_q1 == pkts_to_arrive) {
			token_drop_prob = (double)token_drop/tokencount;
			pthread_exit(NULL);	
		}
	}
}