Initial commit of OpenSPARC T2 architecture model.

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

// ========== Copyright Header Begin ==========================================
// 
// OpenSPARC T2 Processor File: TsoNode.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 ============================================
/************************************************************************
**  
**  Copyright (C) 2002, Sun Microsystems, Inc.
**
**  Sun considers its source code as an unpublished, proprietary
**  trade secret and it is available only under strict license provisions.
**  This copyright notice is placed here only to protect Sun in the event 
**  the source is deemed a published work. Disassembly, decompilation,
**  or other means of reducing the object code to human readable form
**  is prohibited by the license agreement under which this code is
**  provided to the user or company in possession of this copy."
**
*************************************************************************/
#include "TsoNode.h"
#include <sstream>
#include "strings.h"
#include "stdio.h"

using namespace std;
using namespace Tso;
////////////////////////////////////////////////

TsoNode::TsoNode()
{

}

////////////////////////////////////////////////

TsoNode::TsoNode( const TsoNode & orig )
{
  strcpy(nodeName_, orig.nodeName_); 
  in_     = orig.in_;
  out_    = orig.out_;
  iseq_   = orig.iseq_; 
  commit_ = orig.commit_; 
  gobs_   = orig.gobs_; 
  retire_ = orig.retire_; 
  addr_   = orig.addr_; 
  data_   = orig.data_; 
  tid_    = orig.tid_; 
  itype_  = orig.itype_; 
  cmd_    = orig.cmd_; 
  dsrc_   = orig.dsrc_; 
  sizeV_  = orig.sizeV_; 
  lastLoad_ = orig.lastLoad_;
  lastStore_ = orig.lastStore_;
  old_    = orig.old_; 
  ncnt_   = orig.ncnt_; 
}

////////////////////////////////////////////////

TsoNode::TsoNode( const TsoCheckerCmd& cmd )
{
  iseq_ = cmd.getIseq(); 
  commit_ = cmd.getMacc();
  gobs_   = cmd.getGobs(); 
  retire_ = FOREVER; 
  addr_   = cmd.getAddr(); 
  data_   = cmd.getData(); 
  tid_    = cmd.getThrdId(); 
  itype_  = cmd.getItype(); 
  cmd_    = cmd.getCmd(); 
  dsrc_   = cmd.getDsrc(); 
  sizeV_  = cmd.getSizeV(); 
  lastLoad_ = false;
  lastStore_ = false;
  ncnt_   = 1; 
  old_    = 0; 

  sprintf (nodeName_, "t%0d_%0lld", tid_, iseq_); 
}

////////////////////////////////////////////////

TsoNode::~TsoNode()
{

}

////////////////////////////////////////////////

const TsoNode &
TsoNode::operator=( const TsoNode & rhs )
{
  strcpy(nodeName_, rhs.nodeName_); 
  //  in_     = rhs.in_;
  //  out_    = rhs.out_;
  iseq_   = rhs.iseq_; 
  commit_ = rhs.commit_; 
  gobs_   = rhs.gobs_; 
  retire_ = rhs.retire_; 
  addr_   = rhs.addr_; 
  data_   = rhs.data_; 
  tid_    = rhs.tid_; 
  itype_  = rhs.itype_; 
  cmd_    = rhs.cmd_; 
  dsrc_   = rhs.dsrc_; 
  sizeV_  = rhs.sizeV_; 
  lastLoad_ = rhs.lastLoad_;
  lastStore_ = rhs.lastStore_;
  old_    = rhs.old_; 
  ncnt_   = rhs.ncnt_; 

  return *this;
}

////////////////////////////////////////////////

bool
TsoNode::operator==( const TsoNode & rhs ) const
{ 
    return false;
}

////////////////////////////////////////////////

string
TsoNode::toString() const
{
    ostringstream os;
    os << "TsoNode: (";
    os << "tid="   << tid_; 
    os << " iseq=" << iseq_; 
    os << " i="    << mmitype[itype_]; 
    os << " e="    << mmcmd[cmd_];
    os << " a=0x"  << hex << addr_; 
    os << " d=0x"  << hex << data_; 
    os << " vb=0x" << hex << (int) sizeV_; 
    os << " o=0x"  << hex << (int) old_; 
    os << " dsrc=" << mmdsrc[dsrc_]; 
    os << " ncnt=" << dec << ncnt_; 
    os << " ma="   << dec << commit_; 
    os << " gl="   << dec << gobs_; 
    os << " r="    << retire_; 
    os << " ll="   << (int) lastLoad_;
    os << " ls="   << (int) lastStore_;
    os << ")" << endl;
    return os.str();
}

void
TsoNode::removeInEdges() 
{
  list<TsoEdge*>::iterator ei, ei2;
  TsoEdge                  *ep, *ep2;
  TsoNode                  *np;
  bool                     match;

  if (inSize() == 0) return;

  for (ei = inBegin(); ei != inEnd(); ei++) {
    ep = *ei;
    np = ep->getSrc(); 
    match = false; 
    for (ei2 = np->outBegin(); ei2 != np->outEnd(); ei2++) {
      ep2 = *ei2;
      if (ep2 == ep) {
	match = true; 
	np->outErase(ei2); 
	break;
      }
    }
    if (!match)
    {
      MS_ERROR("Remove edges in source node out_ list unsuccessful");
      return;
    }
    delete(ep); 
  }

  inClear(); 

  return;
}

void
TsoNode::removeOutEdges() 
{
  list<TsoEdge*>::iterator ei, ei2;
  TsoEdge                  *ep, *ep2;
  TsoNode                  *np;
  bool                     match;

  if (outSize() == 0) return;

  for (ei = outBegin(); ei != outEnd(); ei++) {
    ep = *ei;
    np = ep->getDst(); 
    match = false; 
    for (ei2 = np->inBegin(); ei2 != np->inEnd(); ei2++) {
      ep2 = *ei2;
      if (ep2 == ep) {
	match = true; 
	np->inErase(ei2); 
	break;
      }
    }
    if (!match)
    {
      MS_ERROR("Remove edges in destination node in_ list unsuccessful"); 
      return;
    }
    delete(ep); 
  }

  outClear(); 

  return;
}

void
TsoNode::removeEdges()
{
  removeInEdges();
  removeOutEdges();
}

bool
TsoNode::allEntriesArrive() {
  switch (itype_) {
  case ITYPE_LOAD:
  case ITYPE_STORE:
  case ITYPE_STORE_INIT:
    return (ncnt_ == 1); 
  case ITYPE_BLOCK_LOAD:
  case ITYPE_BLOCK_STORE:
    //    return (ncnt_ == 8); // when add membar implementation, block load/store should be one node
    return (ncnt_ == 1);       // current implementation, they have 8 nodes per instruction
  case ITYPE_DOUBLE_LOAD:
    return (ncnt_ == 1); 
  case ITYPE_ATOMIC:
  case ITYPE_QUAD_LOAD:
    return (ncnt_ == 2); 
  default:
    return (ncnt_ == 1); 
  }
}