ac_mem.cpp

Go to the documentation of this file.

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

/*  ArchC Cache Library for 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 memory 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                         */
/********************************************************/

/************************************************
 * Author: Pablo Viana
 ************************************************/


#include "ac_mem.H"
#include "ac_resources.H"

  ac_word ac_mem::read( unsigned address ) /*const*/
  {
      return (ac_storage::read(address));
  }

  unsigned char ac_mem::read_byte( unsigned address )
  {
      return (ac_storage::read_byte(address));
  }

  ac_Hword ac_mem::read_half( unsigned address )
  {
      return (ac_storage::read_half(address));
  }


  void ac_mem::write( unsigned address, ac_word datum )
  {
       this->ac_storage::write(address, datum);
  }


  void ac_mem::write_byte( unsigned address, unsigned char datum )
  {
       this->ac_storage::write_byte(address, datum);
  }


  void ac_mem::write_half( unsigned address, unsigned short datum )
  {
      this->ac_storage::write_half(address, datum);
  }


  ac_mem::ac_mem( char *n, unsigned s) :
    ac_storage(n, s)
  {
    request_block_event = false;
    request_write_block_event = false;
    request_write_event = false;
        next_level = NULL;
        previous_level = NULL;
//    request_buffer = new char[block_size*(AC_WORDSIZE/8)];
    datum_ref = new char[4];
  }




  ac_mem::~ac_mem()
  {
//      delete[] request_buffer;
      delete[] datum_ref;
  }

//  void ac_mem::bindTo(ac_mem& lower){  //were ac_mem
//       this->next_level = &lower;
//       lower.previous_level = this;
//  }


/*
################################################################################
##############           PROCESSOR STALLING              #######################
################################################################################
*/
  void ac_mem::stall(){
      ac_resources::ac_wait();
//       cout << "Wait "<< this->get_name() << endl;      
  }


  void ac_mem::ready(){
      ac_resources::ac_release();
//      this->replace_status = 0;
//       cout << "Ready "<< this->get_name() << endl;
  }


/*
################################################################################
##############                 INTERFACE                 #######################
################################################################################
*/

  void ac_mem::request_block(ac_cache_if* client, unsigned address, unsigned size_bytes)
  {
//          cout << "requesting from" << this->get_name() << endl;
//          cout << "size in bytes: " << size_bytes << endl;
       client_global = client;
       request_buffer = new char[size_bytes*(AC_WORDSIZE/8)];
//       cout << "request block em MEM no address: " << address << endl;
       for (unsigned offset_word = 0; offset_word < size_bytes; offset_word+=AC_WORDSIZE/8)
       {
          *(ac_word *)(request_buffer + offset_word) = this->read(address + offset_word);
//           cout << " bloco requisitado" << *(ac_word *)(request_buffer + offset_word) << " from: " << (address + offset_word) << endl;
       }
       request_block_event = true;
       //client->response_block(request_buffer);

   }

  void ac_mem::process_request() {
       if (request_block_event) {
          request_block_event = false;
          client_global->response_block(request_buffer);
       }else if (request_write_block_event) {
          request_write_block_event = false;
//          cout << "respondendo write_block " << this->name << endl;
          client_global->response_write_block();
       }else if (request_write_event) {
          request_write_event = false;
          client_global->response_write();
       }
       //while (true)
       //{
       //            wait(request_block_event);
       //      client_global->response_block(request_buffer);
       //}
  }

  void ac_mem::request_write_byte(ac_cache_if* client, unsigned address, unsigned char datum)
  {
           client_global = client;
       ac_mem::write_byte(address, datum);
       request_write_event = true;
       //notify(SC_ZERO_TIME, request_write_event);
       //client->response_write();
  }

  void ac_mem::request_write_half(ac_cache_if* client, unsigned address, unsigned short datum)
  {
           client_global = client;
       ac_mem::write_half(address, datum);
       request_write_event = true;
       //notify(SC_ZERO_TIME, request_write_event);
       //client->response_write();
  }

  void ac_mem::request_write(ac_cache_if* client, unsigned address, ac_word datum)
  {
           client_global = client;
       ac_mem::write(address, datum);
       request_write_event = true;
//       cout << " mem escrita Write: " << read(address) << endl;
       //client->response_write();
  }

  void ac_mem::request_write_block(ac_cache_if* client, unsigned address, char* datum, unsigned size_bytes)
  {

           client_global = client;
           for (unsigned offset_word = 0; offset_word < size_bytes; offset_word+=AC_WORDSIZE/8)
//         for (unsigned offset_word = 0; offset_word < size; offset_word++)
           {
           write(address + offset_word, *(ac_word*)(datum + offset_word));
//           cout << "buffer recebido em " << (int)datum << endl;
//           cout << " mem escrita Block: " << read(address + offset_word) << endl;
//           cout << "Data stored: " << hex << read(address + offset_word) << " Address: " << (address + offset_word) << endl;
       }
//       cout << "Guardei o bloco no proximo nivel" << endl;
       request_write_block_event = true;
       //client->response_write_block();

  }

  void ac_mem::response_block(char* block)
  {
/*       *(slot_tag) = address_tag;
       *(slot_valid) = true;
       *(slot_dirty) = false;
       for (unsigned offset_word = 0; offset_word < block_size; offset_word++)
       {
           *(ac_word *)(slot_data + offset_word*AC_WORDSIZE/8) = *(ac_word *)(block + offset_word*(AC_WORDSIZE/8));
       }
       replace_status++;
       if(read_access_type)
            this->replaceBlockRead(requested_address);
       else
            this->replaceBlockWrite();
*/
       delete[] block;

  }


  void ac_mem::response_write_byte()
  {
//       this->ready(requested_address);
  }

  void ac_mem::response_write_half()
  {
//       this->ready(requested_address);
  }

  void ac_mem::response_write()
  {
       this->ready();
  }

  void ac_mem::response_write_block()
  {
/*      replace_status++;
       if(read_access_type)
            this->replaceBlockRead(requested_address);
       else
            this->replaceBlockWrite();
*/
  }





  void ac_mem::bindToNext(ac_cache_if& next)
  {
       this->next_level = &next;
  }

  void ac_mem::bindToPrevious(ac_cache_if& previous)
  {
//       this->previous_level = (ac_mem&)&previous;
  }

---