Subversion Repositories openrisc

// ----------------------------------------------------------------------------

// Debug Unit memory cache: implementation

// Copyright (C) 2008  Embecosm Limited <info@embecosm.com>

// Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>

// This file is part of the GDB interface to the cycle accurate model of the

// OpenRISC 1000 based system-on-chip, ORPSoC, built using Verilator.

// This program 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 3 of the License, or (at your

// option) any later version.

// This program 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.

// You should have received a copy of the GNU Lesser General Public License

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ----------------------------------------------------------------------------

// $Id: MemCache.cpp 326 2009-03-07 16:47:31Z jeremy $

#include <cstring>

#include "MemCache.h"

//! Constructor

//! Allocate a closed hash table of the specified size and clear it.

//! @param[in] _tableSize  The desire hash table size. A prime number is

//!                         recommended.

MemCache::MemCache (int  _tableSize) :

  tableSize (_tableSize)

{

  tabIsValid = new bool [tableSize];

  tabKeyAddr = new uint32_t [tableSize];

  tabValue   = new uint32_t [tableSize];

  clear ();

}       // MemCache ()

//! Destructor

//! Free the hash table arrays

MemCache::~MemCache ()

{

  delete [] tabIsValid;

  delete [] tabKeyAddr;

  delete [] tabValue;

}       // ~MemCache ()

//! Empty the hash table

//! Only need to worry about the validity field

void

MemCache::clear ()

{

  memset (tabIsValid, false, sizeof (tabIsValid));

}       // clear ()

//! Write a new value into the hash table

//! Will trash anything already there.

//! @param[in] addr   The address being written to

//! @param[in] value  The value to write

void

MemCache::write (uint32_t  addr,

                 uint32_t  value)

{

  int  keyAddr = addr % tableSize;

  tabIsValid[keyAddr] = true;

  tabKeyAddr[keyAddr] = addr;

  tabValue[keyAddr]   = value;

}       // write ()

//! Try to read a value from the hash table

//! The entry must be valid and the address must match

//! @param[in]  addr   The address being read from

//! @param[out] value  The value read, if there was one there

//! @return  True if the value was found in the hash table

bool

MemCache::read (uint32_t  addr,

                uint32_t &value)

{

  int  keyAddr = addr % tableSize;

  if (tabIsValid[keyAddr] & (tabKeyAddr[keyAddr] == addr))

    {

      value = tabValue[keyAddr];

      return  true;

    }

  else

    {

      return  false;

    }

}       // read ()