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 ()