dwf%hope@LANL.GOV (David W. Forslund) (10/19/89)
I found the following problem with the 10/17/89 version of g++.xtar on
labrea.stanford.edu running on a 3/470 and OS4.0.3:
Script started on Wed Oct 18 13:10:40 1989
satchmo% make
g++ -c -g bank1.C
bank1.C: In function int main ():
bank1.C:131: The following insn was not recognizable:
(insn 126 125 127 (set (reg:SI 78)
(mem:SF (plus:SI (reg:SI 14)
(const_int -20)))) -1 (nil)
(nil))
g++: Program cc1plus got fatal signal 6.
*** Error code 1
make: Fatal error: Command failed for target `bank1.o'
satchmo% ^D
script done on Wed Oct 18 13:11:04 1989
Here is the code:
#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create:
# cust.h
# list.h
# queue.h
# server.h
# time.h
# bank1.C
# This archive created: Wed Oct 18 13:11:34 1989
export PATH; PATH=/bin:/usr/bin:$PATH
if test -f 'cust.h'
then
echo shar: "will not over-write existing file 'cust.h'"
else
cat << \SHAR_EOF > 'cust.h'
// Interface to clas customer
//File cust.h
class customer
{
friend class customer_queue;
private:
float arrival_time; // time when customer joins line
};
SHAR_EOF
fi
if test -f 'list.h'
then
echo shar: "will not over-write existing file 'list.h'"
else
cat << \SHAR_EOF > 'list.h'
// This code defines a class for a singly linked list.
// File list.h
#include <stdio.h>
class node
{
friend class slist;
private:
node* next;
char* contents; // contents dynamically allocated
};
class slist
{
private:
node* head; // Head of list
int size; // Number of bytes for contents
public:
slist(int s) { head=0; size=s;}
void insert(char* a); // Add to the head of the list.
void append(char *a); // Add to the tail of the list.
char *get(); // Remove the head of the list.
void clear(); // Remove all the nodes in list.
~slist(){ clear();}
};
SHAR_EOF
fi
if test -f 'queue.h'
then
echo shar: "will not over-write existing file 'queue.h'"
else
cat << \SHAR_EOF > 'queue.h'
// Interface to dynamic queue class
// This queue is derived from a generic list class
// There is no limitation on the queue size except the size
// of the heap
// file queue.h
#include "list.h"
#include "time.h"
#include "cust.h"
class queue: slist
// A private derived class to serve only class customer_queue
{
friend class customer_queue;
// The operations of put and get are accessible only
// by the friend class customer queue.
private:
void put(customer *c) {slist::append((char*)c);}
customer *get() {return (customer *)slist::get();}
public:
queue(): (sizeof(customer)){}
};
class customer_queue
{
private:
queue q; // A private queue derived from a generic list
float last_event_time; //Time of last customer
// arrival or departure
int cum_customers; // Cumulative number of customers
int current_queue_size;
int peak_queue;
float cum_queue_size_time; // cumulative sum of products
// of size of queue x time
float cum_wait_time; // Cumulative wait time for
// all patrons
public:
void insert(mytime t);
void remove(mytime t);
customer_queue();
int total_customers(){return cum_customers;}
float average_queue_size(mytime t)
{
return (cum_queue_size_time / t.get_time());
}
int size() {return current_queue_size;}
int maximum_queue_size() { return peak_queue;}
float average_queue_wait_time()
{
return (cum_wait_time / cum_customers);
}
float total_wait_time() { return cum_wait_time;}
};
SHAR_EOF
fi
if test -f 'server.h'
then
echo shar: "will not over-write existing file 'server.h'"
else
cat << \SHAR_EOF > 'server.h'
// Interface for class server
// File server.h
#include <stdio.h>
#include <math.h>
const float large = 999999.9;
extern float rand_real();
extern "C" double drand48();
class server
{
private:
int available; // 1 if server is free, otherwise 0
float cum_service_time; // Cumulative service time
float next_available; // time when server is free
int total_customers_served;
float av_service_time;
public:
server()
{
cum_service_time = 0.0;
total_customers_served = 0;
next_available = large;
available = 1;
}
void add_to_total_served() { total_customers_served++;}
void set_server_free()
{
available = 1;
next_available = large;
}
void set_server_busy() { available = 0;}
int busy()
{
if(available)
return 0;
else
return 1;
}
int get_total_served() {return total_customers_served;}
void add_to_service_time (float t)
{
cum_service_time += t;
}
float fraction_of_time_service (mytime t)
{
return(cum_service_time/ (t.get_time()));
}
void set_next_available(float t) {next_available = t;}
float get_next_available() {return next_available;}
void serve_cust(mytime t)
{
float r = -av_service_time * log(rand_real());
set_next_available(t.get_time() + r);
add_to_service_time(r);
add_to_total_served();
set_server_busy();
}
void set_av_service_time(float average_service_time)
{
av_service_time = average_service_time;
}
};
float rand_real()
{
return(drand48());
}
SHAR_EOF
fi
if test -f 'time.h'
then
echo shar: "will not over-write existing file 'time.h'"
else
cat << \SHAR_EOF > 'time.h'
// Interace to class time
// File ltime.h
#ifndef TIME_H
#define TIME_H
class mytime
{
private:
float current_time;
public:
mytime()
{
current_time=0.0;
};
float get_time() { return current_time;};
void set_time(float t) {current_time = t;};
};
#endif TIME_H
SHAR_EOF
fi
if test -f 'bank1.C'
then
echo shar: "will not over-write existing file 'bank1.C'"
else
cat << \SHAR_EOF > 'bank1.C'
// Main bank simulation program
// This program simulates a bank with one waiting line
// and n servers. When one or more servers is free,
// the server is chosen randomly
// File bank1.c
#include "queue.h"
#include "server.h"
extern random2(int,int);
extern "C" double drand48();
float average_iat; // Average interarraival time
float simulation_time; // Time, in minutes, bank is open
int number_servers; // Number of servers in system
float *average_service_time; // Array of av_serv_times
float arrival_time;
//Object declarations
customer_queue q;
mytime t;
server *s; //Array of servers
void get_input()
{
printf("\nEnter the number of servers:");
scanf("%d",&number_servers);
average_service_time = new float[number_servers];
s = new server[number_servers];
for (int z=0 ; z<number_servers ; z++)
{
printf("\nEnter average service time for server %d:", z+1);
scanf("%f",&average_service_time[z]);
s[z].set_av_service_time(average_service_time[z]);
}
printf("\nEnter the average interarrival time:");
scanf("%f",&average_iat);
printf("\nNumber of minutes for the simulation:");
scanf("%f",&simulation_time);
printf("\n");
}
main()
{
extern int get_next_event(float &n_event_time);
extern int server_avail(int &n);
extern void report_stats(customer_queue q);
extern void title();
extern float generate_iat(mytime t);
float next_event_time;
int next_event;
int server_no;
get_input();
title();
printf("Simulating...\n");
arrival_time= generate_iat(t);
do
{
//During business hours...
//Determine the next event
next_event = get_next_event(next_event_time);
#ifdef debug
printf("\nThe next event = %d",next_event);
printf("next_event_time|%f",next_event_time);
#endif
if(next_event_time <= simulation_time)
{
t.set_time(next_event_time);
if(next_event > 0 && q.size() > 0)
{ //Take a customer from the queue
q.remove(t);
s[next_event -1].serve_cust(t);
#ifdef debug
printf("\nThe queue size = %d\n\n",q.size());
#endif
}
else if (next_event> 0 && q.size() == 0)
{
s[next_event -1].set_server_free();
#ifdef debug
printf("\nThe queue size = %d\n\n",q.size();
#endif
}
else //Next event is a customer arrival
{
if (q.size() == 0 && server_avail(server_no))
{ // Customer goes directly to server server_no
q.insert(t);
q.remove(t); // Insert and remove to update stats
s[server_no].serve_cust(t);
#ifdef debug
printf("\nThe queue size = %d\n\n",q.size());
#endif
}
else //customer joins queue
{
q.insert(t);
#ifdef debug
printf("\nThe queue size = %d\n\n",q.size());
#endif
}
arrival_time = generate_iat(t);
}
}
} while (next_event_time <= simulation_time);
arrival_time = large; //Bank is now closed
next_event = get_next_event(next_event_time);
#ifdef debug
printf("\nBank closed\n");
printf("\nThe next_event = %d", next_event);
printf("\nnext_event_time = %f",next_event_time);
printf("\nCurrent queue size = %d",q.size());
#endif
// Determine wither all servers are free
while (next_event !=0)
{
t.set_time(next_event_time);
if (q.size() > 0)
{
q.remove(t);
s[next_event -1].serve_cust(t);
}
else
s[next_event-1].set_server_free();
next_event = get_next_event(next_event_time);
}
report_stats(q);
}
float generate_iat(time t)
{ //Exponential distribution with mean given by av_
// interarrival_time
return(-average_iat *log(rand_real() ) + t.get_time());
}
int get_next_event(float&n_event_time)
{
float min = arrival_time;
int choice = 0;
float temp;
for (int i=1;i<=number_servers; i++)
{
if (( temp=s[i-1].get_next_available())<min)
{
choice =i;
min =temp;
}
}
n_event_time = min;
return choice;
}
int server_avail(int &n)
{
// Returns 0 if no server is available
// otherwise returns 1 and number of available server
int choice[30];
int number_free = 0;
for (int i = 0; i<number_servers;i++)
{
if (!s[i].busy())
{
choice[number_free] = i;
number_free++;
}
}
if (number_free == 0 )
return 0;
else
{
// Choose a random server among available servers
n = choice[random2(0,number_free-1)];
return 1;
}
}
void report_stats(customer_queue q)
{
printf("\nOutput Statistics");
printf("\n--------------------");
printf("\n\nAverage queue size :%-8.3f",
q.average_queue_size(t));
printf("\n\nAverage queue wait time :%-8.3f",
q.average_queue_wait_time());
printf("\n\nMaximum queue size :%-d",q.maximum_queue_size());
printf("\n\nTotal customers :%-d",q.total_customers());
for (int i = 0; i<number_servers;i++)
{
printf("\n\nServer %d service time: %-8.3f%c",
i+1,s[i].fraction_of_time_service(t) *100,37);
printf("\n\nServer %d total served: %-d\n",i+1,s[i].get_total_served());
}
}
void title()
{
printf("Discrete Event Simulation of Bank Queue");
printf("\n-------------------------------------------\n");
}
int random2(int first,int number)
{
return(first + (int) (drand48()*number));
}
SHAR_EOF
fi
exit 0
# End of shell archive
David Forslund
MS E531
Los Alamos National Laboratory
Los Alamos, NM 87545
(505) 665-1907
(dwf@lanl.gov)