ac_cache.H

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/*  ArchC Cache Library for the ArchC architecture simulators
    Copyright (C) 2002-2004  The ArchC Team

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.
*/

/********************************************************/
/* The ArchC cache simulation class.                    */
/* Author:  Pablo Viana (CIn-UFPE)                      */
/* Contact: pvs@cin.ufpe.br                             */
/*                                                      */
/* The ArchC Team                                       */
/* Computer Systems Laboratory (LSC)                    */
/* IC-UNICAMP                                           */
/* http://www.lsc.ic.unicamp.br                         */
/********************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <list>
#include "ac_storage.H"
#include "ac_cache_if.H"

#include <string>
#include "fstream"



#ifndef _AC_CACHE_H
#define _AC_CACHE_H


//#ifndef AC_DETAIL
//#define AC_DETAIL
//#endif


#define WRITE_THROUGH true
//#define AC_TRACE true
//#define AC_DETAIL true

#ifndef RAND_MAX
  #define RAND_MAX 1024;
#endif

#define RANDOM 0
#define LRU 1
#define DEFAULT 2

#define W_WORD 4
#define W_HALF 2
#define W_BYTE 1





class ac_cache: /*public sc_module,*/ public ac_storage , public ac_cache_if{

  unsigned block_size;           
  unsigned num_blocks;           
  unsigned set_size;
  unsigned num_sets;
  unsigned * tag;                
  bool * valid;                  
  bool * dirty;
  unsigned codeSize;
  unsigned *  chosen;             
  unsigned * tracker;            
  int strategy;
//  ac_storage* next_level;       //!Next lower level of the hierarchy
//  ac_storage* previous_level;   //!Previous upper level of the hierarchy
  ac_cache_if* next_level;       
  ac_cache_if* previous_level;   


private:

      unsigned offset;
      unsigned set;
      unsigned address_tag;

      char *slot_data;
      unsigned *slot_tag;
      bool *slot_valid;
      bool *slot_dirty;
      unsigned element; //set' s line used

      unsigned char write_policy; //byte register with the write setup |7|6|5|4|3|2|1|0|
      // bit 0 - if set is write-through      // bit 4 - if set is write-allocate
      // bit 1 - if set is write-back         // bit 5 - if set is write-around
      // bit 2 - not used                     // bit 6 - not used
      // bit 3- not used                      // bit 7 - not used

       char *request_buffer;
       int write_size;
       bool read_access_type;
       char* datum_ref;
       ac_cache_if* client_global;
       bool request_block_event;
       bool request_write_block_event;
       bool request_write_event;




#ifdef  AC_TRACE  
      char padding;
      char access_type;
      short size_ref;
#endif

      int hit;       // reset the hit event

      unsigned char replace_status;
      unsigned requested_address;

      void ac_cache::addressing(unsigned address);               //slicing the address field
      void ac_cache::tracing(unsigned address, unsigned type);  //access trace file writing
//      void ac_cache::requestFromNext(unsigned address);         //request data from next storage level

      void ac_cache::replaceBlockWrite();            //replace the block with the required data
      void ac_cache::replaceBlockRead(unsigned address);            //replace the block with the required data

      void ac_cache::writingBack();              //write back to the lower level the modified blocks

      bool ac_cache::isWriteThrough();        //Checks the write-through policy
      bool ac_cache::isWriteBack();           //Checks the write-back policy
      bool ac_cache::isWriteAllocate();       //Checks the write-allocate policy
      bool ac_cache::isWriteAround();         //Checks the write-around policy


public:
#ifdef AC_TRACE
  ofstream trace;
#endif
//  FILE* trace;
  //
  virtual ac_word ac_cache::read( unsigned address );

  //


  virtual unsigned char ac_cache::read_byte( unsigned address );


  virtual ac_Hword ac_cache::read_half( unsigned address );



  virtual void ac_cache::write( unsigned address, ac_word datum );

  //
  virtual void ac_cache::write_byte( unsigned address, unsigned char datum );

  //

  virtual void ac_cache::write_half( unsigned address, unsigned short datum );

  //
  ac_cache::ac_cache( char *n, unsigned bs, unsigned nb, unsigned ss, unsigned st, unsigned char wp = 0x11);



  ac_cache::~ac_cache();

  //
  void ac_cache::bindTo(ac_cache& lower);

  void ac_cache::set_codeSize( unsigned s);

/*  void ac_cache::initialize(){
    ac_storage::initialize((unsigned)block_size*num_blocks);
    chosen = new char[this->num_sets];
    tracker = new char[this->set_size * this->num_sets];
    tag = new char[num_blocks*AC_WORDSIZE/8];
    valid = new bool[num_blocks];
    *valid = false;
    codeSize = 0;
  }
*/


  unsigned ac_cache::get_chosen(unsigned s);

  void ac_cache::update(unsigned s, unsigned e);

  unsigned ac_cache::get_codeSize();

  void ac_cache::stall();

//  void ac_cache::ready();
  void ac_cache::ready();


  void request_block(ac_cache_if* client, unsigned address, unsigned size_bytes);
  void request_write_byte(ac_cache_if* client, unsigned address, unsigned char datum);
  void request_write_half(ac_cache_if* client, unsigned address, unsigned short datum);
  void request_write(ac_cache_if* client, unsigned address, ac_word datum);
  void request_write_block(ac_cache_if* client, unsigned address, char* datum, unsigned size_bytes);

  void response_block(char* block);
  void response_write_byte();
  void response_write_half();
  void response_write();
  void response_write_block();

  void bindToNext(ac_cache_if& next);
  void bindToPrevious(ac_cache_if& previous);

//       SC_HAS_PROCESS(ac_cache);
  void process_request();

};
#endif

---