Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / rst / rstzip3 / rstzip_v2 / VCache.h

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: VCache.h
* Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
* 
* The above named program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License version 2 as published by the Free Software Foundation.
* 
* The above named 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
* General Public License for more details.
* 
* You should have received a copy of the GNU General Public
* License along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
* 
* ========== Copyright Header End ============================================
*/
#ifndef INCLUDED_VALUECACHE_H
#define INCLUDED_VALUECACHE_H
#include <sys/types.h>
#include <assert.h>
#include <stdio.h>

struct VCEntry {
   VCEntry() : valid( false ), counter( 0 )
   {}

   void invalidate() { valid = false; }
   void incCounter() { ++counter; }
   bool hit( uint64_t v ) { ++counter; return valid && value == v; }
   void insert( uint64_t d ) { value = d; valid = true; counter = 1; }

   uint64_t value;
   bool valid; 
   uint32_t counter;
};

class InvalidIndexException {
   
   public:
       InvalidIndexException( int i ) : idx( i )
       {}

   int idx;

};

class VCache {

   public:
       typedef uint16_t IdxT;
       typedef int16_t DiffT;
       enum { VALUE_NOT_FOUND = -1 };

       VCache( unsigned size = 65535 ) : evictions(0), vcacheSize(size) 
       {
           cache = new VCEntry[vcacheSize];
       }

       ~VCache()
       {
           delete [] cache;
       }

       void reset()
       {
           for( IdxT i = 0; i < vcacheSize; ++i ){
               cache[i].invalidate();
           }
       }

       bool hit( uint64_t d, IdxT &idx )
       {
           idx = hash( d );

           return cache[idx].hit( d );
       }

       // compatability w/ existing code
       int hit( uint64_t d )
       {
           IdxT i;

           if( hit( d, i ) ){
               return i;
           } else {
               return -1;
           }
       }

       IdxT insert( uint64_t d )
       {
           IdxT idx = hash( d );

           if( cache[idx].valid ){
               ++evictions;
           }

           cache[idx].insert( d );

           return idx;
       }


       IdxT hash( uint64_t d )
       {
           //return (d ^ (d & 0x0FUL)) % vcacheSize;
           return (IdxT)(d % vcacheSize);
       }

       uint64_t operator[](IdxT idx)
       {
           assert( idx >= 0 && idx < vcacheSize );
           
           if ( !cache[idx].valid ) {
               throw InvalidIndexException( idx );
           }

           return cache[idx].value;
       }

       int conflicts(){ return evictions; }

   private:
       unsigned vcacheSize;
       VCEntry *cache;
       int evictions;
};

#endif /* INCLUDED_VALUECACHE_H */