//  Monitored array implementation.
//  In addition to the normal array operations, index and store,
//  maintain a count of memory faults in a private member.
//
//  This version maintains an LRU stack of page numbers
//  and puts out a vector of stack depths (one element for each memory fault).
//  sdb  July 2003

#include "array.h"

Node::Node (int page)
{	pageNum = page;
	next = NULL;
}

Node::~Node()				// destructor
{	if (next) delete next; }

const int TRUE = 1;
const int FALSE = 0;
extern int p;

MArray::MArray (int size) 		// constructor
	  {  ptr = new int [size];
	     sz = size;
	     fault = 0;
	     refs = 0;
	     prevPage = -1;		// first ref always causes a fault.
	     top = NULL;
	  }	

MArray::~MArray ()			// destructor
	  {  delete [] ptr;}

void MArray::reset()			// initialize this Marray for reuse
	{   delete top;
	    top = NULL;
	}

int& MArray::operator[] (int i)		// return an lvalue for assignment
	  { testFault(i);
	    refs++;
	    return ptr[i];
	  } 

void MArray::testFault(int i)		// test for a page fault
	  { int page = i/p;		// page number for ref to i
	    if (page != prevPage) 
		{  fault++;
	     	   prevPage =  page;
		}
	    lru (page);
	  }

void MArray::setName (char * fileName)
	  {	name = fileName;	// file name for output
	     	out.open(name);
	     	if (!out) 			// Output file opened?
		    cerr << "Output file failed to open: " 
		 	 << name << endl;
	  }

void MArray::closeFile ()		// close the output file
	{	out.close();	}

long MArray::getFault()	
	{ return fault;}

void MArray::setFault(long f)		// set value of fault to f.
	  {  fault = f; }

long MArray::getRefs()  { return refs;} // total number of refs.

void MArray::setRefs (long r)		// set value of refs to r.
	  {  refs = r; }

int MArray::getSize() { return sz;}

void MArray::setSize (int s)		// set value of sz to s.
	  {  sz = s; }

void MArray::dump()			// dump array to stdout
	  {  for (int i=0; i<sz; i++)
		{  cout << ptr[i] << " ";
		   if ((i+1)%20==0) cout << endl;
		}
	     cout << endl;
	  }

void MArray::setPrev (int n)		// set initial page value
	  {  prevPage = n; }


// Post:  Page number page is moved to the top (beginning) of the stack
void MArray::lru (int page)
{  Node * ptr = top;
   Node * trlr = NULL;
   int depth = 0;

   while (ptr && page!=ptr->pageNum)
      {	trlr = ptr;
      	ptr = ptr->next;
	depth++;
      }

   if (ptr)			// found page in the stack, move it to the top.
     if (trlr)
      {	trlr->next = ptr->next;
	ptr->next = top;
	top = ptr;
      }
     else   ;			// found page at top of stack, no action.
   else				// page not found, insert it at the top.
      {	ptr = new Node (page);
	ptr->next = top;
	top = ptr;
	depth = -1;		// infinite ?
      }

  out << depth << endl ;

}