#include "prog2.h"

void BSizeCSizeSim(CMemory* Memory);
void AssocSim(CMemory* Memory);

//===========================================================
//main method
int main(void)
{

  //seed the random number generator
  srand((unsigned)time(NULL));

  //memory will remain constant through the simulations
  CMemory Memory(MEM_SIZE);
  Memory.GenerateMemory();

  BSizeCSizeSim(&Memory);
  printf("\n\n");
  AssocSim(&Memory);

  return 0;
}
//===========================================================

//===========================================================
//simulate different cache sizes with different cache sizes
void BSizeCSizeSim(CMemory* Memory)
{
  int i=0, j=0;
  int associativity=0;

  printf("Cache Size:\tBlock Size:\tMiss Rate:\tAveAccess Time:\t\tMisses:\n");

  for(i=0; i<NUM_C_SIZES; i++)
  {
    for(j=0; j<NUM_B_SIZES; j++)
    {
      printf("%ld\t\t%ld\t\t", 
              (long int)(CacheSizes[i]/1024), BlockSizes[j]);

      //create cache
      CCache Cache(CacheSizes[i], BlockSizes[j]);
      //fully associative
      associativity=(CacheSizes[i]/BlockSizes[j]);
      //execute n cycles
      Cache.ExcecuteNCycles(300000, Memory, associativity);
    }
  }
}
//===========================================================

//===========================================================
void AssocSim(CMemory* Memory)
{
  int i=0, j=0;
  int associativity=0;
  CCache* Cache;

  printf("Cache Size:\tAssociativity:\tMiss Rate:\tAveAccess Time:\t\tMisses:\n");

  for(i=0; i<NUM_C_SIZES2; i++)
  {
    for(j=0; j<NUM_ASSOC; j++)
    {
      printf("%ld\t\t%ld\t\t", 
              (long int)(CacheSizes2[i]/1024), Associativity[j]);

      //create cache
      Cache = new CCache(CacheSizes2[i], AssocBlockSize);
      //execute n cycles
      Cache->ExcecuteNCycles(100000, Memory, Associativity[j]);

      delete Cache;
    }
  }
}
//===========================================================

//===========================================================
//CCache functions
CCache::CCache(void)
{}

CCache::CCache(long int csize, int bsize):
  CacheSize(csize),
  BlockSize(bsize),
  IsFull(false)
{
  CacheInstr = new struct Instruction[csize];

  for(long int i=0; i<csize; i++)
    CacheInstr[i].address=-1;
}

//execute N cycles from 0 from memory
CCache::ExcecuteNCycles(long int N, CMemory* memory, int associativity)
{
  int i=0, j=0;
  long int currindex=0, nextindex;
  long int curraddr=0, nextaddr;
  int cc=0;
  int misspenalty=(int)(log10(BlockSize)/log10(2));
  long int instrExec=0, cmisses=0;
  
  for(i=0; i<BlockSize; i++)
  {
    CacheInstr[i].address=memory->Instructions[currindex].address;
    CacheInstr[i].next=memory->Instructions[currindex].next;
    currindex++;
  }

  cc+=misspenalty;

  currindex=0;
  //go through N cycles
  for(instrExec=0; cc<N; instrExec++)
  {
    //go to next address
    nextaddr=CacheInstr[currindex].next;

    //see if the next address is the next index in cache
    if(nextaddr==CacheInstr[currindex+1].address)
    {
      cc++; currindex++;
    }
    else
    {
      nextindex=findAddress(nextaddr, associativity);
      if(nextindex==-1)
      {
        cc+=misspenalty;
        cmisses++;
        currindex=addAddress(nextaddr, memory, associativity);
      }
      else
      {
        cc++;
        currindex=nextindex;
      }
    }

    curraddr=nextaddr;
  }

  float missrate = (float)cmisses/instrExec;
  printf("%f\t", missrate);
  printf("%f\t\t%d\n", 1+(missrate*misspenalty), cmisses);
}

//returns the index of addr in cache, -1 if not found
long int CCache::findAddress(long int addr, int associativity)
{
  long int i=0;
  int bindex=(addr%BlockSize);
  long int blockaddr=addr-bindex;
  long int blocknum=(blockaddr/BlockSize);
  long int numsets=(CacheSize/BlockSize)/associativity;
  int blockset=blocknum%numsets;

  long int setStartAddress = (blockset*associativity*BlockSize);
  long int setEndAddress = ((blockset+1)*associativity*BlockSize);

  //search by set and block
  for(i=setStartAddress; i<setEndAddress; i+=BlockSize)
  {
    if(CacheInstr[i].address==blockaddr)
      return (i+bindex);
  }

  return -1;
}

//add a block to the cache, return its index in cache
long int CCache::addAddress(long int addr, CMemory* memory, int associativity)
{
  long int i=0, j=0;
  int bindex=(addr%BlockSize);
  long int blockaddr=addr-bindex;
  long int blocknum=(blockaddr/BlockSize);
  long int numsets=(CacheSize/BlockSize)/associativity;
  int blocksperset=((CacheSize/BlockSize)/numsets);
  int blockset=blocknum%numsets;

  //search for an empty spot
  if(!IsFull)
  {
    IsFull=true;
    
    long int setStartAddress = (blockset*associativity*BlockSize);
    long int setEndAddress = ((blockset+1)*associativity*BlockSize);
    
    for(i=setStartAddress; i<setEndAddress; i+=BlockSize)
    {
      if(CacheInstr[i].address==-1)
      {
        IsFull=false;
        for(j=0; j<BlockSize; j++)
        {
          CacheInstr[i+j].address=memory->Instructions[blockaddr+j].address;
          CacheInstr[i+j].next=memory->Instructions[blockaddr+j].next;
        }
        return i+bindex;
      }
    }
  }
  
  //if there is no empty spot
  if(IsFull)
  {
    long int rnum=rand()%((CacheSize/BlockSize)/numsets);
    rnum=(blockset*blocksperset+rnum)*BlockSize;//(rnum%BlockSize);

    for(j=0; j<BlockSize; j++)
      CacheInstr[rnum+j]=memory->Instructions[blockaddr+j];
    return rnum+bindex;
  }

  IsFull=false;

  return -1;
}

//destructor
CCache::~CCache(void)
{
  delete[] CacheInstr;
}
//===========================================================

//===========================================================
//CMemory fcns
CMemory::CMemory(void):
  MemSize(MEM_SIZE)
{
  Instructions = new struct Instruction[MEM_SIZE];
}

CMemory::CMemory(long int msize):
  MemSize(msize)
{
  Instructions = new struct Instruction[msize];
}

CMemory::~CMemory(void)
{
  delete[] Instructions;
}
//===========================================================
//generate the Central Memory instructions according to 
//specifications
void CMemory::GenerateMemory(void)
{
  long int i=0; 
  int j=0, branches=0, reads=0, writes=0;
  int rnum = 0;
  float rprob = 0;

  printf("Randomly generating Central Memory Instructions...\n");

  for(i=0; i<MemSize; i++)
  {
    rnum = rand()%100;
    rprob = (float)rnum/100;
    
    Instructions[i].address=i;

    if(rprob<READ_PROB)
    {
      Instructions[i].next=i+1;
      reads++;
    }
    else
    {
      branches++;
      Instructions[i].next=genBranchAddress(i);
    }
  }

  //print out generation stats
  printf("Memory Instructions Generated:\n");
  printf("  Reads Generated:         %10d (%2.2f%%)\n", reads, ((float)reads/MemSize)*100);
  printf("  Branches Generated:      %10d (%2.2f%%)\n", branches, ((float)branches/MemSize)*100);

}


//===========================================================
//generate an address to branch to
long int CMemory::genBranchAddress(long int curraddr)
{
  int rnum = rand()%100;
  long int newaddress = 0;
  
  rnum=((rand()%OFFSET_RANGE)+MEM_OFFSET);
  
  if(rand()%2==0)
    newaddress = (curraddr-rnum);
  else
    newaddress = (curraddr+rnum);
  
  //make sure the value is in CM, if not, make it circular
  if(newaddress>=MemSize)
    newaddress -= MemSize;
  else if(newaddress<0)
    newaddress += MemSize;
  else; //don't do anything to newaddress, it's okay!

  return newaddress;

}