int main(int argc, char **argv)
{
double time = 0;
struct command_line_args object;
memset(&object,0,sizeof(struct command_line_args));
parse_command_line(argc,argv,&object);
Initialize();
gettimeofday(&GlobalStartTime,0);
LOG(stdout, "%012.3fms: emulation begins\n",time);
pthread_sigmask(SIG_BLOCK,&signal_set,NULL);
if(TraceDriven){
pthread_create(&packet_thread, 0, (void *)tracedriven_packet_procedure, &object);
} else
pthread_create(&packet_thread, 0, (void *)&deterministic_packet_procedure, &object);
pthread_create(&token_thread, 0,(void *)&token_bucket_procedure,&object);
pthread_create(&server_thread, 0,(void *)&server_procedure,&object);
pthread_create(&interrupt_thread, 0,(void *)&handler,NULL);
pthread_join(packet_thread,0);
pthread_join(token_thread,0);
pthread_join(server_thread,0);
join_interrupt = 1;
pthread_join(interrupt_thread, 0);
gettimeofday(&GlobalEndTime,0);
Statistics(&object);
My402ListUnlinkAll(&Q1PacketList);
My402ListUnlinkAll(&Q2PacketList);
return 0;
}
static
void DoTest()
{
int num_items=64;
My402List list, list2;
memset(&list, 0, sizeof(My402List));
memset(&list2, 0, sizeof(My402List));
(void)My402ListInit(&list);
(void)My402ListInit(&list2);
CreateTestList(&list, num_items);
RandomShuffle(&list, num_items);
FindAllInList(&list, num_items);
CopyTestList(&list, &list2);
BubbleSortForwardList(&list, num_items);
if (gnDebug > 0) PrintTestList(&list, num_items);
BubbleSortBackwardList(&list2, num_items);
if (gnDebug > 0) PrintTestList(&list2, num_items);
CompareTestList(&list, &list2, num_items);
My402ListUnlinkAll(&list);
My402ListUnlinkAll(&list2);
}
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 RemoveAllMemoryAllocated()
{
My402ListElem *elem;
PacketData *data;
for(elem = My402ListFirst(PacketDetailsList) ; elem != NULL ; elem = My402ListNext(PacketDetailsList, elem))
{
data = (PacketData *)elem->obj;
free(data);
data = NULL;
}
My402ListUnlinkAll(PacketDetailsList);
elem = NULL;
}
int removeTokens(int num)
{
int i;
if(!num) {
My402ListUnlinkAll(&tokList);
return 1;
}
My402ListElem *tempTok, *tempTok1;
tempTok = My402ListFirst(&tokList);
for(i = 0; i<num ; i++) {
tempTok1 = tempTok;
tempTok = My402ListNext(&tokList, tempTok);
My402ListUnlink(&tokList, tempTok1);
}
return 1;
}
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);
}
int main(int argc, char *argv[])
{
int res = 0;
/*
* Check if the number of arguments passed
* if less than 2 return error with the
* expected format.
*/
if(argc < 2 ){
fprintf(stderr, "Missing the sort command\n");
return 0;
}
/*
* Make sure the second argument
* is sort
*/
if(strncmp(argv[1], "sort", 4)){
fprintf(stderr, "Wrong command, please enter \"warmup1 sort [tfile]\"\n");
return 0;
}
/*
* If file is given:
* Check if the file is
* Accessible
* Valid
* Not a directory
*/
if(argc == 3){
if(argv[2]){
if(!checkFile(argv[2])){
return 0;
}
}
}
/*
* Initialize the circular list
*/
My402List list;
memset(&list, 0, sizeof(My402List));
res = My402ListInit(&list);
if(!res) {
fprintf(stderr, "Error during Initialization of the list\n");
exit(0);
}
/*
* We will now call the parse function
*/
if(!Input(&list, argv[2])) {
FreeObjMem(&list);
My402ListUnlinkAll(&list);
exit(0);
}
/*
* Output the balance
*/
Output(&list);
/*
* free the memory space used for all the
* objects
*/
FreeObjMem(&list);
/*
* Unlink all the list elements
*/
My402ListUnlinkAll(&list);
exit(0);
}
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 cleanup(My402List* list)
{
My402ListUnlinkAll(list);
free(list);
}
void ParseFile(FILE *file){
char buffer[1024];
memset(buffer, 0, sizeof(buffer));
transaction *obj = NULL;
My402List list;
memset(&list, 0, sizeof(My402List));
(void)My402ListInit(&list);
while(fgets(buffer, sizeof(buffer), file) != NULL){
obj = (transaction*)malloc(sizeof(transaction));
if(obj == NULL){
fprintf(stderr, "%s\n", strerror(errno));
}
else{
char *start_ptr = buffer;
char *tab_ptr = strchr(start_ptr, '\t');
int noofptr = 0;
while(tab_ptr != NULL){
noofptr++;
tab_ptr++;
start_ptr = tab_ptr;
tab_ptr = strchr(start_ptr, '\t');
}
if(noofptr > 3){
fprintf(stderr, "Too many tabs, Clearing memory and Quiting Program\n");
free(obj);
My402ListUnlinkAll(&list);
exit(0);
}
if(noofptr < 3){
fprintf(stderr, "Format Malformed, Clearing memory and Quiting Program\n");
free(obj);
My402ListUnlinkAll(&list);
exit(0);
}
start_ptr = buffer;
tab_ptr = strchr(start_ptr, '\t');
if(Transaction_Type(obj, start_ptr, tab_ptr) == 0){
fprintf(stderr, "Transaction Type failed, Clearing Memory and Quiting Program\n");
free(obj);
My402ListUnlinkAll(&list);
exit(0);
}
tab_ptr++;
start_ptr = tab_ptr;
tab_ptr = strchr(start_ptr, '\t');
if(Transaction_TimeStamp(obj, start_ptr, tab_ptr) == 0){
fprintf(stderr, "Transaction Time failed, Clearing Memory and Quiting Program\n");
free(obj);
My402ListUnlinkAll(&list);
exit(0);
}
tab_ptr++;
start_ptr = tab_ptr;
tab_ptr = strchr(start_ptr, '\t');
if(Transaction_Amount(obj, start_ptr, tab_ptr) == 0){
fprintf(stderr, "Transaction Amount failed, Clearing Memory and Quiting Program\n");
free(obj);
My402ListUnlinkAll(&list);
exit(0);
}
tab_ptr++;
start_ptr = tab_ptr;
tab_ptr = strchr(start_ptr, '\n');
Transaction_Description(obj, start_ptr, tab_ptr);
//Now the struct is filled with the string fields read from the first line of the file
if(My402ListLength(&list) == 0)
(void)My402ListPrepend(&list, obj);
else{
My402ListElem *elem = NULL;
for(elem = My402ListFirst(&list); elem != NULL; elem=My402ListNext(&list, elem)){
if((((transaction*)(elem->obj))->trans_time == obj->trans_time)){
fprintf(stderr, "Error - Two entry at same time, Quiting program\n");
free(obj);
My402ListUnlinkAll(&list);
exit(0);
}
if((((transaction*)(elem->obj))->trans_time > obj->trans_time)){
(void)My402ListInsertBefore(&list, obj, elem);
break;
}
if(My402ListNext(&list, elem) == NULL){
(void)My402ListAppend(&list, obj);
break;
}
}
}
}
}
PrintTransactionList(&list);
My402ListUnlinkAll(&list);
}
