🚀 go-pugleaf

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)