Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / cpus / vonk / ss / api / sam / src / SS_VirtualCpu.cc

// ========== Copyright Header Begin ==========================================
// 
// OpenSPARC T2 Processor File: SS_VirtualCpu.cc
// 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 ============================================

#include "SS_VirtualCpu.h"

uint_t         SS_VirtualCpu::id = 0;
SS_VirtualCpu* SS_VirtualCpu::list = 0;

SS_VirtualCpu::SS_VirtualCpu( SS_Model* model )/*{{{*/
:
 next(0),
 cpu(model->cpu[id]),
 strand(new SS_VirtualStrand[cpu->strand_cnt()])
{
 cpu->clr_stepping();

 // The virtual cpu id (vid) numbers from 0 to N-1.
 // The strand id associated with vid X is sid X
 // if the id is not overwritten in the rc file.
 
 for (int s=0; s < cpu->strand_cnt(); s++) 
   strand[s].strand = cpu->strand[s];

 ++id;
}
/*}}}*/

SS_VirtualStrand* SS_VirtualCpu::create( SS_Model* (*model)(), Sam::VCPU_Config* config, Sam::VCPU_ImpIntf* interface )/*{{{*/
{
 SS_VirtualCpu* pntr;
 uint_t base_id = 0;

 // Get the strand with strand_id() number config->id . 
 // Whilst locating the strand create any missing cpu instances.
 
 if (list == 0)
 {
   SS_Model* ss = (model)();
   ss->create_cpu(1);
   list = new SS_VirtualCpu(ss);
 }

 for (pntr = list; config->id >= (pntr->cpu->strand_cnt() + base_id) ; pntr = pntr->next)
 {
   base_id += pntr->cpu->strand_cnt();

   if (pntr->next == 0)
   {
     SS_Model* ss = (model)();
     ss->create_cpu(1);
     pntr->next = new SS_VirtualCpu(ss);
   }
 }

 uint_t i = config->id - base_id;      

 // Connect the strand to the "outside" world

 pntr->strand[i].strand->io->set_access_io(interface->access_io);
 pntr->strand[i].strand->memory = interface->mem;
 pntr->strand[i].strand->asi_ext_obj = &pntr->strand[i];
 pntr->strand[i].strand->asi_ext_ld64_fp = ss_asi_ext_ld64;
 pntr->strand[i].strand->asi_ext_st64_fp = ss_asi_ext_st64;
 pntr->strand[i].config   = *config; 
 pntr->strand[i].sys_intf = *interface; 

 // Make the strand active in step().

 pntr->cpu->set_stepping(i);

 // Return the virtual cpu instance.

 return &pntr->strand[i];
}
/*}}}*/

void SS_VirtualCpu::remove( SS_Model* ss )/*{{{*/
{
 while (list)
 {
   SS_VirtualCpu* hlp = list;
   list = list->next;
   delete hlp;
 }

 delete ss;
}
/*}}}*/

int SS_VirtualCpu::snapshot( SS_Model* model, const char* dir_name, const char* file_name, bool load )/*{{{*/
{
 char name[1024];
 name[0] = 0;
 if (dir_name)
   strcat(name,dir_name);
 strcat(name,file_name);

 FILE* file = fopen(name,load ? "r" : "w");
 if (file == 0)
   return -1;

 SS_SnapShot ss(file,load);

 model->snapshot(ss);

 if (fclose(file) == 0)
   return -1;

 return 0;
}
/*}}}*/

int SS_VirtualCpu::cycle( uint64_t nn )
{   
 assert(nn==1); 
 
 SS_VirtualStrand *vcpu = SS_VirtualCpu::list ? SS_VirtualCpu::list->strand : NULL;
 if ( vcpu && vcpu->config.trace_on && vcpu->config.execution_driven )  
 {
   vcpu->sys_intf.vtrace->cycle();
 }
 return 0;
}


SS_AsiSpace::Error SS_VirtualCpu::ss_asi_ext_ld64( SS_Node*, void* asi_ptr, SS_Strand* s, SS_Vaddr va, uint64_t* data )/*{{{*/
{
 int     sid = s->strand_id();
 uint8_t asi = *((uint8_t *)asi_ptr);
 SS_VirtualStrand *v = (SS_VirtualStrand *)s->asi_ext_obj;
 int ok = v->sys_intf.access_asi(sid, Sam::VCPU_LOAD_OP, asi, va, 8, (*data));
       
 return SS_AsiSpace::Error(ok);
}
/*}}}*/
SS_AsiSpace::Error SS_VirtualCpu::ss_asi_ext_st64( SS_Node*, void* asi_ptr, SS_Strand* s, SS_Vaddr va, uint64_t data )/*{{{*/
{
 int     sid = s->strand_id();
 uint8_t asi = *((uint8_t *)asi_ptr);
 SS_VirtualStrand *v = (SS_VirtualStrand *)s->asi_ext_obj;
 int ok = v->sys_intf.access_asi(sid, Sam::VCPU_STORE_OP, asi, va, 8, data);
 return SS_AsiSpace::Error(ok);
}
/*}}}*/