machine.c

Go to the documentation of this file.

// machine.c
//
// 3/4/98 WAH:  Separated from scheduler library; minor tweaking.

#include <iostream.h>
#include <string.h>
#include "legoUtil.H"
#include "lmdes.h"
#include "RU_manager.h"
#include "machine.h"
#include "l_alloc_new.h"
#include "mdes2.h"
#include "lmdes.h"

/* Debugging support, courtesy of Sumedh */
//#define       _MACHINE_DEBUG_
#ifdef _MACHINE_DEBUG_
#define derr(s)         cerr << s
#else
#define derr(s)
#endif

//#define GetOpFrequency(X)     (double) (X)->GetBlockId()

#define SchedLengthErrMsg(X,Y,Z)        \
      cerr << "\nERROR: machine::" << X << "\n";                        \
      cerr << "\tcycle " << (Y) << " >= RT size " << MaxScheduleLength  \
           << "\n";                                                     \
      cerr << "\tOp " << (Z) << "\n";                                   \
      exit( -1 )

#define ComputeNumBuses(X)      (X) < 1 ? totalSlots : (X)

enum TinkerOpType machine::TinkerOptype( legoOp *Op );
double GetSuperblockWeight( legoOp *RRTop, machine *m );

static char *FunctionName;

L_Alloc_Pool    *Operand_ready_pool = NULL;
  
// NewHandler: exception handling for 'new'
//static void NewHandler()
//{
//   cerr << "\nERROR: machine::" << FunctionName << " failed with w/'new'\n";
//   exit( -125 );
//}

// GetOpFrequency: takes an Op and returns the value of the "orig_wt"
static double GetOpFrequency( legoOp *op )
{
  attrs *wtattr;
  legoOprd *oprd;

  wtattr = FindLcAttribute ("orig_wt", op);
  if (wtattr == NULL) return -1.0;

  oprd = wtattr->GetAttrOprdPtr();
  if (oprd == NULL || oprd->GetOprdType() != OT_LITERAL_D) return -1.0;

  return oprd->GetLiteralDouble();
}

// Added by Emre

// opLatency: takes an opcode, returns the latency of the instruction
int machine::opLatency(int opCode )
{ 
  int alt_id,lat; 
  alt_id = mdes_heuristic_alt_id (opCode);
  
  return(mdes_max_completion_time (opCode, alt_id));
}

// opLatency: takes an Op, returns the latency of the instruction
int machine::opLatency( legoOp *Op )
{
  
  int opCode, alt_id; 
  RU_Info *ru_info; 
  //HZ: //opCode = Op->GetOpcode();
  opCode = Op->GetBaseOpcode();

  if (Op->GetSchedTime() == -1) {
    alt_id = mdes_heuristic_alt_id (opCode);
  }
  else {
    ru_info = Op->GetRUInfoPtr();               /* Pointer to Resource Usage */
    alt_id = RU_SELECTED_ALT_ID(ru_info);
  }

  return(mdes_max_completion_time (opCode, alt_id));
}


// TinkerOptype: given a REBEL opcode, return which type of TINKER Optype
//    it is. This file depends totally on #define values in legoMap.H.
enum TinkerOpType machine::TinkerOptype( int opcode )
{
   int lego_opc = opcode;

   if((( lego_opc >= NO_OP ) && ( lego_opc <= XORCM_W )) ||
      (( lego_opc >= EXTS_B ) && ( lego_opc <= MOVE )) ||
      (( lego_opc >= LDCM ) && ( lego_opc <= CMPR_W_EV )) ||
      (( lego_opc >= CMPP ) && ( lego_opc <= CMPP_W_EV_AC_AC )) ||
      (( lego_opc >= PBRR ) && ( lego_opc <= PBRA )) ||
      lego_opc == DEFINE || lego_opc == ALLOC || lego_opc == LDPRED ||
      lego_opc == LIMM)// || lego_opc == COMMIT)
     return INT_OP;
   else if((( lego_opc >= FADD_S ) && ( lego_opc <= CONVDS )) ||
           (( lego_opc >= MOVEF_S ) && ( lego_opc <= MOVEF_D )) ||
           (( lego_opc >= FCMPR_S_FALSE ) && ( lego_opc <= FCMPR_D_TRUE )) ||   
           (( lego_opc >= FCMPP_S_FALSE_UN_UN ) && ( lego_opc <= FCMPP_D_TRUE_AC_AC )) || 
           lego_opc == FLIMM)
     return FP_OP;
   else if ((( lego_opc >= L_B_V1_V1 ) && ( lego_opc <= FDSLD_INC_D_C3_C3 )) ||
            (( lego_opc >= MOVEGF_L ) && ( lego_opc <= MOVEGF_U )) ||
            (( lego_opc >= MOVEGF_L ) && ( lego_opc <= MOVEPG )) ||
            (( lego_opc >= DVLD_B ) && ( lego_opc <= FDVLD_D )))
      return MEM_OP;
   else if (( lego_opc >= BRDVI ) && ( lego_opc <= BRDVF ) ||
            ( lego_opc >= BRU ) && ( lego_opc <= BRW_F_F_F ) ||
            lego_opc == CONTROL_MERGE || lego_opc == MERGE ||
            lego_opc == DUMMY_BR || lego_opc == C_MERGE)// || lego_opc == BORK) 
      return BR_OP;
   else {
      cerr << "TinkerOptype( opcode ): invalid opcode: " << lego_opc << "\n";
      exit(-1);
   }
}


// TinkerOptype: given an Op, return which type of TINKER Optype
//    it is. This file depends totally on #define values in legoMap.H.
enum TinkerOpType machine::TinkerOptype( legoOp *Op )
{
    if(Op->GetOpcodePtr() == NULL)
        return TinkerOptype( Op->GetOpcode() );
    else
    {
        //check the opcode class for the TINKER opcode type
        if(Op->IsIntegerOp() || Op->IsDEFINEOp() || Op->IsCompareOp())
            return INT_OP;
        else if(Op->IsFloatOp())
            return FP_OP;
        else if(Op->IsLDOp() || Op->IsSTOp())
            return MEM_OP;
        else if(Op->IsBranchOp() || Op->IsDUMMYBROp() || Op->IsCMERGEOp())
            return BR_OP;
        else 
        {
            cerr << "TinkerOptype( Op ): invalid base opcode: " <<
                    Op->GetBaseOpcode() << "\n";
            exit(-1);
        }              
    }
}

// isStoreOp: returns 1 if opcode is a store, 0 otherwise
//int machine::isStoreOp(int opCode)
//{

//   if ( opCode >= S_B_V1 && opCode <= FS_INC_D_C3 ) return 1;
//   else return 0;
//}



// isStoreOp: returns 1 if opcode is a store, 0 otherwise
int machine::isStoreOp( legoOp *Op )
{
    return (Op->IsSTOp());
//   int opCode;
//
//   opCode = Op->GetOpcode();
//   if ( opCode >= S_B_V1 && opCode <= FS_INC_D_C3 ) return 1;
//   else return 0;
}


// isLoadOp: returns 1 if opcode is a load, 0 otherwise
//int machine::isLoadOp(int opCode)
//{
//   if (( opCode >= DVLD_B && opCode <= FDVLD_D ) ||
//       ( opCode >= L_B_V1_V1 && opCode <= FL_INC_D_C3_C3 ) ||
//       ( opCode >= DSLD_B_V1_V1 && opCode <= FDSLD_INC_D_C3_C3 )) 
//     return 1;
//   else return 0;
//}


// isLoadOp: returns 1 if opcode is a load, 0 otherwise
int machine::isLoadOp( legoOp *Op )
{
    return (Op->IsLDOp());
//   int opCode;
//
//   opCode = Op->GetOpcode();
//   if (( opCode >= DVLD_B && opCode <= FDVLD_D ) ||
//       ( opCode >= L_B_V1_V1 && opCode <= FL_INC_D_C3_C3 ) ||
//       ( opCode >= DSLD_B_V1_V1 && opCode <= FDSLD_INC_D_C3_C3 )) 
//     return 1;
//   else return 0;
}


// isBranchOp: returns 1 if opcode is a branch, 0 otherwise
int machine::isBranchOp( legoOp *Op )
{
   if ( TinkerOptype( Op ) == BR_OP ) return 1;
   else return 0;
}


// isRealOp: returns 1 if opcode is an Op that occupies an issue slot
//    and machine resources
//int machine::isRealOp( int opCode )
//{
//   if ( opCode == C_MERGE || opCode == DUMMY_BR || opCode == DEFINE ||
//        opCode == PROLOGUE || opCode == EPILOGUE )
//      return 0;
//   else return 1;
//}


// isRealOp: returns 1 if opcode is an Op that occupies an issue slot
//    and machine resources
int machine::isRealOp( legoOp *Op )
{
    return Op->IsRealOp();
//   int opCode = Op->GetOpcode();

//   return isRealOp( opCode );
}


// setIssueConfig: allocate issue slots for the ops
void machine::setIssueConfig()
{
   int i, j;


   FunctionName = "setIssueConfig";

   // Get a count of the total # issue slots
   totalSlots = mdes_total_slots();

   // Allocate 2-d array as the RRT for the schedule. Allocate an extra
   // slot to hold info to aid in debugging.
   RRT = new int[ totalSlots ][ MaxScheduleLength ];

   // sumedh: this is aid the static estimation process:
   RRTop = new legoOp*[totalSlots][MaxScheduleLength];

   // Init the statuses
   for ( i = 0; i < MaxScheduleLength; i++ ) 
     for ( j = 0; j < totalSlots; j++ ) {
       RRT[ j ][ i ] = EMPTY;
       RRTop[j][i] = NULL;      // sumedh: to aid static estimation
     }

   // mark that the RRT has been allocated:
   allocated = TRUE;
}


// adjustIssueStatus: given an opCode, allocate an issue slot for that type
//    of Op in 'cycle', if one is available
void machine::adjustIssueStatus( legoOp *Op, int cycle, int slot )
{
   int start, stop, i, OpId;
   enum TinkerOpType opType;


   OpId = Op->GetOpId();
   if ( cycle >= MaxScheduleLength ) {
      SchedLengthErrMsg( "adjustIssueStatus", cycle, Op->GetOpId() );
   }

   derr( ">> machine::adjustIssueStatus "
         << ", cycle " << cycle << "\n" );

   RRT[ slot ][ cycle ] = OpId;
   RRTop[ slot ][ cycle ] = Op;
   LastIssueCycle = LastIssueCycle < cycle ? cycle : LastIssueCycle;
   derr( "   placing " << OpId << " into slot " << slot << " <<\n" );
   return;
}


// adjustWritebackStatus:
void machine::adjustWritebackStatus( legoOp *Op, int cycle )
{
   LastWritebackCycle = LastWritebackCycle < cycle ? cycle : LastWritebackCycle;
}


// resetIssueSlots: sets the status of issue slots to EMPTY in cluster
void machine::resetIssueStatus( int cycle, int cluster )
{
   int i;

   if ( cycle >= MaxScheduleLength ) {
      cerr << "\nERROR: machine::resetIssueStatus\n";
      cerr << "\tcycle " << cycle << " >= RT size " << MaxScheduleLength
           << "\n";
      exit( -1 );
   }

   for ( i = 0; i < totalSlots; i++ )
      RRT[ i ][ cycle ] = EMPTY;
}


// resetIssueSlots: sets the status of issue slots to EMPTY
// sanjeev - fix this, 9/4/96
void machine::resetIssueStatus( int cycle )
{
   int i;


   if ( cycle >= MaxScheduleLength ) {
      cerr << "\nERROR: machine::resetIssueStatus\n";
      cerr << "\tcycle " << cycle << " >= RT size " << MaxScheduleLength
           << "\n";
      exit( -1 );
   }

   if ( cycle < MaxScheduleLength )
      for ( i = 0; i < totalSlots; i++ )
         RRT[ i ][ cycle ] = EMPTY;
}


// resetMachine: clear the RRTs
void machine::resetMachine()
{
  int i, j;
  
  LastIssueCycle = LastWritebackCycle = 0;
  for ( i = 0; i < totalSlots; i++ )
    for ( j = 0; j < MaxScheduleLength; j++ ) {
      RRT[ i ][ j ] = EMPTY;
      RRTop[ i ][ j ] = NULL;        // sumedh: to aid static estimation
    }
}


// showIssueStatus: shows what Ops are to be issued in cycle
void machine::showIssueStatus( int cycle )
{
   int i;


   if ( cycle >= MaxScheduleLength ) {
      cerr << "\nERROR: machine::showIssueStatus\n";
      cerr << "\tcycle " << cycle << " >= RT size " << MaxScheduleLength
           << "\n";
      exit( -1 );
   }

   for ( i = 1; i < totalSlots; i++ ) {
      cerr.width( 5 );
      if ( RRT[ i ][ cycle ] == EMPTY ) cerr << "N";
      else cerr << RRT[ i ][ cycle ] ;
   }
   cerr << "   |\n";
}


// printSchedule: print out all assignments to 'Cycle' in the schedule
void machine::printSchedule( int Cycle )
{
   if ( Cycle >= MaxScheduleLength ) {
      cerr << "\nERROR: machine::printSchedule\n";
      cerr << "\tcycle " << Cycle << " >= RT size " << MaxScheduleLength
           << "\n";
      exit( -1 );
   }

   PrintSchedule( Cycle );
}


// printSchedule: print out all assignments to this point in the schedule
void machine::printSchedule()
{
   PrintSchedule( LastWritebackCycle );
}


// PrintSchedule: print out all assignments in the schedule up to LastCycle
void machine::PrintSchedule( int LastCycle )
{
   int i;
   char *OutputStr;

   cerr << "\nSlot assignments are in the order they are defined in the hmdes file. \n"
        << "For example: \n"
        << "$def !num_IALUs 2 \n$def !num_mem_units 1 \n$def !num_branch_units 1 \n"
        << "results in slot 1: IALU, slot 2: IALU, slot 3: MEM, and slot 4: BR \n";
   cerr << "         Slot\n";
   cerr << " Cycle  ";
   for ( i = 1; i < totalSlots; i++ ) {
      cerr << " ";
      cerr.width( 4 );
      cerr << i;
   }
   cerr << "\n";
   
   for ( i = 1; i <= totalSlots; i++ )
      cerr << "-------";
   cerr << "--\n";
   for ( i = 1; i <= LastCycle; i++ ) {
      cerr << "* ";
      cerr.width( 4 );
      cerr << i << "  ";
      showIssueStatus( i );
   }
   for ( i = 1; i <= totalSlots; i++ )
      cerr << "-------";
   cerr << "--\n";
}


// estimate the execution time etc. statically
void machine::estimateSchedule (double *TotalOps, double *TotalCycles,
                                int assumeDP = 0)
{
  int i, j;
  int lastbranchcycle = 0;
  int nextlastbranchcycle = 0;
  int lastcycle;
  double totalcycles = 0.0;
  double retiredops  = 0.0;
  double regionweight = 0.0, totalweight;
  opList *opl;
  int region_type;


  derr( ">> machine::estimateSchedule\n" );

  lastcycle = Bypass == TRUE ? LastIssueCycle : LastWritebackCycle;
  if ( Bypass == TRUE ) derr( "   Bypass TRUE\n" );
  derr( "   lastcycle = " << lastcycle << "\n" );
  for (i=1; i <= lastcycle; i++) {

    double max_br_weight = 0.0;
    int ignore;

    derr( "\ncycle=" << i << "\n" );
    derr( "-----\n" );

    for (j=1; j < totalSlots; j++) {

      attrList *atl;
      attrs *a;
      int attr_count;

      derr( "   [j=" << j << "] " );

      derr( "   Processing op " << RRTop[j][i]->GetOpId() << "\n" );
      ignore = FindLcAttribute( "ignore-static-estimate", RRTop[j][i] ) == NULL 
               ?  0 : 1;

      if (RRT[j][i] != EMPTY && ignore == 0 ) {
        legoRegion* tttt = (legoRegion*)(RRTop[j][i]->GetParentBlockPtr());

        derr( "   Doing op " << RRTop[j][i]->GetOpId() );
        if ( !isRealOp( RRTop[ j ][ i ] ) ) {
           derr( "...skipping psuedo-op\n" );
           continue;
        }
        derr( "\n" );

        // 6/5/97 WAH
        // Find the proper profile weight for RRTop[j][i].
        //cerr << "DuplicateOpsPtr for " << j << " " << i << " " <<
        //  (RRTop[j][i])->GetOpId() << " is " <<
        //  (RRTop[j][i])->GetDuplicateOpsPtr() << "\n";
        if (assumeDP && ((RRTop[j][i])->GetDuplicateOpsPtr() != NULL))
          {
            double maxdupweight = 0.0;
            totalweight = 0.0;

            derr( "   DP: Scanning Op " << (RRTop[j][i])->GetOpId() << "\n" );
            for (opl = (RRTop[j][i])->GetDuplicateOpsPtr(); opl != NULL;
                 opl = opl->GetNextListPtr())
              {
                if (!(opl->GetValid()))
                  {
                    derr( "   " << opl->GetOpId() << " is invalid.\n" );
                    continue;
                  }
                if (((legoRegion *) opl->GetOpPtr()->GetParentBlockPtr())
                    ->GetParentPtr() !=
                    ((legoRegion *) (RRTop[j][i])->GetParentBlockPtr())
                    ->GetParentPtr())
                  {
                    derr( "   " << opl->GetOpId()
                          << " is not in the same treegion.\n" );
                    continue;
                  }
                if (opl->GetOpPtr()->GetSchedTime() != i)
                  {
                    derr( "   " << opl->GetOpId() << " is not scheduled in "
                          << i << "\n" );
                    continue;
                  }

                regionweight = GetOpFrequency (opl->GetOpPtr());
                if (regionweight < 0.0)
                if ( (region_type=tttt->GetRegionType()) == RT_SB ||
                     ( region_type == RT_HB && 
                      FindFlag( SB, (legoRegion *) 
                               opl->GetOpPtr()->GetParentBlockPtr() ) != NULL ) )
                    regionweight = GetSuperblockWeight (opl->GetOpPtr(), this);
                else
                    regionweight = ((legoRegion *)
                                    (opl->GetOpPtr()->GetParentBlockPtr()))
                      ->GetWeight();
                if (regionweight > maxdupweight)
                  maxdupweight = regionweight;
                totalweight += regionweight;
                derr( "      Total weight is now " << totalweight << " from op "
                      << opl->GetOpPtr()->GetOpId() << "\n" );
              } // end for
            regionweight = maxdupweight;
            derr( "   Done scanning.\n" );
          } // end if
        else
          {
            regionweight = GetOpFrequency (RRTop[j][i]);
            if (regionweight < 0.0)
              if (tttt->GetRegionType() == RT_BB)
                regionweight = tttt->GetWeight();
              else // it's a superblock or a hyperblock
                regionweight = GetSuperblockWeight (RRTop[j][i], this);
            totalweight = regionweight;
          } // end else

        // Get the number of dynamic ops actually retired
        retiredops += totalweight;
        derr ( "   Retired ops now at " << retiredops << "\n" );
        // Should the line above actually count how many Ops are in the
        // region?

        derr( "   Region weight now " << regionweight << "\n" );

        // branch dependent information
        if (TinkerOptype (RRTop[j][i]) == BR_OP &&
            RRTop[j][i]->IsBRLOp() == false  &&
            RRTop[j][i]->IsCMERGEOp() == false) {
          // get the weight of the maximum of n branches
          if (regionweight > max_br_weight)
            max_br_weight = regionweight;

          // set the cycle number of the last branch(es) seen:
          if (lastbranchcycle < i)
            nextlastbranchcycle = i;

          derr( "   lastbranchcycle=" << lastbranchcycle
                << ", nextlastbranchcycle=" << nextlastbranchcycle << "\n" );
        }
      }

    }

    derr( "   (1) max_br_weight=" <<  max_br_weight << "\n" );
    // There are blocks that end in a DUMMY_BR and contain real Ops. Treat
    // these branches as real branches. I assume that this only happens in
    // a basic block.
    if ( i == lastcycle && max_br_weight == 0 ) max_br_weight = regionweight;
    derr( "   (2) max_br_weight=" <<  max_br_weight << "\n" );
    totalcycles += (i-lastbranchcycle)*max_br_weight;
    derr( "   Total cycles " << totalcycles << ", total Ops " << retiredops
          << "\n" );
    lastbranchcycle = nextlastbranchcycle;
  }

  (*TotalOps) = retiredops;
  (*TotalCycles) = totalcycles;

  // print them out:
  derr( "   ESTIMATE:retired Ops=" << retiredops << ", Total cycles="
        << totalcycles << ", OPC=" << retiredops/totalcycles << "\n" );
  derr( "<< machine::estimateSchedule\n" );
}


// ShowParameters: gets the various knobs settings and displays them in
//    formatted output
machine::ShowParameters( knobs *Knobs )
{
   char flag, *string, uu;
   int latency = 0;


   Knobs->SetDefaultPanel( "machine" );
   Knobs->Read( "PlayDoh", flag );
   if ( (int ) flag ) cout << "> PlayDoh machine\n";
   Knobs->SetDefaultPanel( "machine" );
   Knobs->Read( "lmdesfile", string );
   cout << "> Machine model (lmdes file) : ";
   cout << string;
   cout << "\n";
   Knobs->Read( "bypass", flag );
   if ( (int) flag ) cout << "Full bypass";
   cout << "\n";
}


//  get MDES load stuff going    
void machine::initialize_lmdes(knobs *Knobs)
{
  char *lmdesfile;
  
  if (!lmdes_initialized()) {
    
    Knobs->SetDefaultPanel ("machine");
    Knobs->Read ("lmdesfile", lmdesfile);
    
    L_init_lmdes(lmdesfile, 1, 2, 3, 1);
    
    Operand_ready_pool = L_create_alloc_pool ("operand_ready_times",
                                              mdes_latency_count()*sizeof(int), 100);
  }
  
  setIssueConfig();
  clustering = FALSE;
  BusLatency = 0;
  
}


// SetKnobs: set internal values, based on the kbobs file
void machine::SetKnobs( knobs* Knobs )
{
   char flag;
   char *string;

   Knobs->SetDefaultPanel( "machine" );
   Knobs->Read( "bypass", flag );
   Bypass = (int) flag;
   derr( "   Bypass: " << Bypass << "\n" );

   //  get MDES load stuff going    
   initialize_lmdes(Knobs);
   
}


// Constructor
machine::machine( knobs* Knobs )
{
   allocated = FALSE;
   Bypass = TRUE;
   NumClusters = 1;
   ClusterWidth = 0;
//   set_new_handler( NewHandler );
   SetKnobs( Knobs );
   K = Knobs;
}


// Default constructor
machine::machine()
{
   int i;

   allocated = FALSE;
   Bypass = TRUE;
   NumClusters = 1;
   ClusterWidth = 0;
//   set_new_handler( NewHandler );
}

// Default destructor
machine::~machine()
{
   if ( allocated == TRUE ) {

      int i;

      // sanjeev - is this the right way to delete a 2-d array??
#if 0
      for ( i = 0; i < totalSlots; i++ ) {
         delete [] RRT[ i ];
         delete [] RRTop[ i ];
      }
      if ( clustering == TRUE )
         for ( i = 0; i < NumBuses; i++ )
            delete [] BusRRT[ i ];
#else
      delete [] RRT;
      delete [] RRTop;
      if ( clustering == TRUE ) delete [] BusRRT;
#endif
   }
}


/******************************** End of machine class *********************/

// GetSuperBlockWeight: Gets the weights for an Op in a superblock
double GetSuperblockWeight( legoOp *RRTop, machine *m )
{
  legoOp *blockop, *prevblockop;
  opList *opl;

  // Am I at the top of the block?
  if ( RRTop->GetPrevLink() == NULL )
      return ((legoRegion *) (RRTop->GetParentBlockPtr()))->GetWeight();

  // walk backwards to the last branch or the top of the block
  for (prevblockop = RRTop, blockop = RRTop->GetPrevLink();
       (m->TinkerOptype (blockop) != BR_OP || blockop->IsBRLOp()
        || blockop->IsCMERGEOp()) &&
         blockop->GetPrevLink() != NULL;
       prevblockop = blockop,
         blockop = blockop->GetPrevLink()) /* do nothing */;

  derr( "Stopped walk at ops " << blockop->GetOpId() << " and "
        << prevblockop->GetOpId() << "\n" );
  if (m->TinkerOptype (blockop) == BR_OP && blockop->IsCMERGEOp() == false
      && blockop->IsBRLOp() == false)
    {  // found branch - get weight of opList pointing into block

      for (opl = blockop->GetOutListPtr(); opl != NULL;
           opl = opl->GetNextListPtr())
        if (opl->GetOpId() == prevblockop->GetOpId())
          {
            derr( "Found branch weight " << opl->GetWeight() << "\n" );
            return opl->GetWeight();
          } // end if (, for)
      if (opl == NULL)
        cerr << "Can't find oplist from " << blockop->GetOpId()
             << " to " << prevblockop->GetOpId() << "\n";
    } // end if
  else  // hit top of block - use block weight
    {
      derr( "Hit top - using weight " << ((legoRegion *) (blockop->GetParentBlockPtr()))->GetWeight()<< "\n" );
      return ((legoRegion *) (blockop->GetParentBlockPtr()))->GetWeight();
    }
  return 0.0;
} // end GetSuperblockWeight

---