Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / cpus / vonk / ss / lib / cpu / src / SS_Cpu.h

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: SS_Cpu.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 __SS_Cpu_h__
#define __SS_Cpu_h__

#include "SS_Types.h"
#include "SS_Node.h"
#include "SS_SnapShot.h"
#include "SS_MemErrDetector.h"

class SS_Strand;
class SS_Model;

class SS_Cpu : public SS_Node
{
 public:
   SS_Cpu( SS_Model& _model, const char* _name );

   SS_Model&  model;
   
   virtual void hard_reset() = 0;
   virtual void warm_reset(bool intp=true) = 0;
   virtual void xtrn_reset() = 0;

   // The current maximum number of strands per cpu is 64.
   // This limit comes from the CMP spec, and from the choise
   // we made to use uin64_t types as bitmaps to record which
   // strands are active, enabled, runnning, and stepping.

   // the upper limit has increased, so the change.
   enum { MAX_STRAND_COUNT = 128 };    
   
   // strand_cnt() returns the number of stands in the cpu object

   uint_t strand_cnt()                 { return strand_count; }

   SS_Strand* strand[MAX_STRAND_COUNT];

   // snapshot() is called to take a snapshot of the cpu and sibbling objects
  
   virtual void snapshot( SS_SnapShot& );

   // flush() propagates the flush from model to all strands in the cpu

   void flush( SS_Paddr pa );

   // flush() broadcasts the flush to all the strands in the cpu
   // that are actively stepping. It's processor specific still.
   // SS_Strand is the strand that issues the flush.

   void flush( SS_Strand* s, SS_Paddr pa, uint_t size );

   // ras_flush() propagates a call to flush RAS cache state from
   // model to all strands in the cpu

   void ras_flush( SS_Strand* requesting_strand, SS_Paddr pa, uint64_t size, SS_MemErrDetector::CacheType type );

   // clr_stepping() is called when a cpu is created by the sam virtual 
   // cpu interface. After this set_stepping() is called to enable 
   // individual strands. Initially all strands are stepping.

   void clr_stepping()                         
   { 
     strand_stepping[0] = 0ull; 
     strand_stepping[1] = 0ull; 
   }

   bool is_stepping( uint_t strand_id )
   {
     assert(strand_id < 128);
     return strand_stepping[strand_id >> 6] & (1ull << (strand_id & 63)); 
   }
   
   // set_stepping() marks strand with id strand_id as stepping, which
   // means that flush will consider it in the flush broadcast.

   virtual void set_stepping( uint_t strand_id )       
   {
     assert(strand_id < 128);
     strand_stepping[strand_id >> 6] |= 1ull << (strand_id & 63); 
   }

   // ras_enable() is called to enable ras features
  
   virtual void ras_enable(char* cmd);


 protected:
   // The stepping variable holds a bit per strands that tells if the strand
   // is stepping or not. Note that stepping does not mean that the strand is
   // running, nor does it mean the strand is halted. It just means that the
   // strand is actively part of the system setup.
  
   uint_t   strand_count;        // Number of strand objects available in strand
   uint64_t strand_stepping[2];  // Which strands are setup for stepping (bit vector)

   // change_running() is called whenever the cmp strand running status
   // changes value, to update the strandst hat receive flush oprations
 
   void change_running( uint64_t _strand_running_status )
   {
     // @@ha144505 remove me when done
   }
};

#endif