Subversion Repositories openrisc

// ----------------------------------------------------------------------------
 
// Debug Unit SPR 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: SprCache.cpp 331 2009-03-12 17:01:48Z jeremy $
 
#include <iostream>
#include <cstring>
 
#include "SprCache.h"
 
 
//-----------------------------------------------------------------------------
//! Constructor
 
//! Allocate tables and clear the cache
 
//! @param[in] _tableSize  The desire hash table size. A prime number is
//!                         recommended.
//-----------------------------------------------------------------------------
SprCache::SprCache (int _tableSize) :
  tableSize (_tableSize)
{
  sprIsValid = new bool [tableSize];
  sprKeyNum  = new uint16_t [tableSize];
  sprValue   = new uint32_t [tableSize];
 
  clear ();
 
}	// SprCache ()
 
 
//-----------------------------------------------------------------------------
//! Destructor
 
//! Free up the tables
//-----------------------------------------------------------------------------
SprCache::~SprCache ()
{
  delete [] sprValue;
  delete [] sprKeyNum;
  delete [] sprIsValid;
 
}	// ~SprCache ()
 
 
//! Empty the hash table
 
//! Only need to worry about the validity field
void
SprCache::clear ()
{
  memset (sprIsValid, false, tableSize);
 
  // No more than 70% full
  maxToUse = tableSize * 7 / 10;
 
}	// clear ()
 
 
//-----------------------------------------------------------------------------
//! Write a new value into the cache
 
//! If the hash table is full silently does nothing, unless the force
//! parameter is set to TRUE. Under this circumstance the value WILL be
//! written into the hash table. This is safe, because the table is never more
//! than 70% full, and force is used only for NPC.
 
//! @param[in] spr    The SPR being written to
//! @param[in] value  The value to write
//! @param[in] force  If TRUE the value will be written to the hash table,
//!                   even if it is too full.
//-----------------------------------------------------------------------------
void
SprCache::write (uint16_t  sprNum,
		 uint32_t  value,
		 bool      force)
{
  if (maxToUse <= 0)
    {
      return;				// Table is full
    }
 
  int  hv = sprNum % tableSize;
 
  // We can use the slot if either it is empty, or it is full and the key
  // number matches.
  while (sprIsValid[hv] && (sprKeyNum[hv] != sprNum))
    {
      hv = (hv + 1) % tableSize;
    }
 
  sprIsValid[hv] = true;
  sprKeyNum[hv]  = sprNum;
  sprValue[hv]   = value;
  maxToUse--;
 
}	// write ()
 
 
//-----------------------------------------------------------------------------
//! Try to read a value from the cache
 
//! The entry must be valid.
 
//! @param[in]  sprNum  The SPR being read from
//! @param[out] value   The value read. Will be written, even if the value is
//!                     not valid.
 
//! @return  True if the value was found in the hash table
//-----------------------------------------------------------------------------
bool
SprCache::read (uint16_t  sprNum,
		uint32_t &value)
{
  int  hv = sprNum % tableSize;
 
  // Look for either an empty slot (we are not there) or a matching key (we
  // are there)
  while (sprIsValid[hv] && (sprKeyNum[hv] != sprNum))
    {
      hv = (hv + 1) % tableSize;
    }
 
  value = sprValue[hv];
  return  sprIsValid[hv];
 
}	// read ()