static.C

Go to the documentation of this file.

// static.C
// 2/17/98 WAH:  Created - now angst-free!

#include "lego.H"
#include "legoUtil.H"
#include "static.H"

//#define STATIC_ESTIMATE_DEBUG

#ifdef STATIC_ESTIMATE_DEBUG

#define dprintf(s) fprintf s
#define OUTF stderr

//#define STATIC_ESTIMATE_DEBUG_VERBOSE
#ifdef STATIC_ESTIMATE_DEBUG_VERBOSE
#define dvprintf(s) fprintf s
#else
#define dvprintf(s)
#endif // STATIC_ESTIMATE_DEBUG_VERBOSE

#else
#define dprintf(s)
#define dvprintf(s)

#endif // STATIC_ESTIMATE_DEBUG

int 
IsTreeExitandDummyBr(legoOp *bottomop, legoTreegion *tree) {
  
  opList *leafopl;

  if (bottomop->IsDUMMYBROp() == false)
    return FALSE;
  for (leafopl = tree->GetExitOpsPtr(); leafopl != NULL;
       leafopl = leafopl->GetNextListPtr()) {
    if (bottomop == leafopl->GetOpPtr())
      return TRUE;
  }
  return FALSE;
  
}

/*
 * SchedTimeSpan
 *   fromop = op at which to start
 *   toop = op at which to stop
 *   returns: number of cycles between them, or -1 if error
 *
 * Returns the difference in schedule times between from and to, plus 1.
 * The ops MUST belong to the same block (bb, sb, or hb), and fromop must
 * come before toop.
 */
static int
SchedTimeSpan (legoOp *fromop, legoOp *toop)
{
  legoOp *walkop;
  int mintime, maxtime, currtime;
  legoRegion *parentblock = (legoRegion *) fromop->GetParentBlockPtr();

  if ((legoRegion *) toop->GetParentBlockPtr() != parentblock)
    {
      LegoNonFatal ("SchedTimeSpan", "Ops %d and %d belong to different "
                    "blocks.", fromop->GetOpId(), toop->GetOpId());
      return -1;
    } // end if

  mintime = maxtime = fromop->GetSchedTime();

  for (walkop = fromop;
       walkop != toop && walkop != NULL;
       walkop = walkop->GetNextLink())
    {
      currtime = walkop->GetSchedTime();
      if (currtime < mintime) mintime = currtime;
      if (currtime > maxtime) maxtime = currtime;
    } // end for
  // Catch toop as well.
  if (toop != fromop)
    {
      currtime = toop->GetSchedTime();
      if (currtime < mintime) mintime = currtime;
      if (currtime > maxtime) maxtime = currtime;
    } // end if

  if (walkop == NULL)
    {
      LegoNonFatal ("SchedTimeSpan", "Op %d does not follow op %d; estimate "
                    "is inaccurate.", toop->GetOpId(), fromop->GetOpId());
    } // end if

  return (maxtime - mintime + 1);
} // end SchedTimeSpan

static void
Estimate (legoBB *bb, static_stats *st)
{
  legoOp *topop, *bottomop;
  double timespan, weight;

  topop = bb->GetEntryOpsPtr()->GetOpPtr();
  bottomop = bb->GetExitOpsPtr()->GetOpPtr();

  timespan = (double) SchedTimeSpan (topop, bottomop);
  weight = bb->GetWeight();

  // # cycles = schedule length of bb * bb weight
  st->numCycles += timespan * weight;
  // # dynamic ops = # ops in bb * bb weight
  // Note that this OpCount differs slightly from the Treegion OpCount 
  // because Treegion estimator does not count pseudo ops
  st->numDynamicOps += bb->GetOpCount() * weight;

  dprintf ((OUTF, "Estimate BB %d\t%lf cycles\t%lf ops\n", bb->GetRegionId(),
            timespan * weight, bb->GetOpCount() * weight));
  return;
} // end Estimate (bb)

static void
Estimate (legoRegion *hb, static_stats *st)
{
  legoOp *topop, *bottomop;
  //  legoOp *mintimeop;
  double timespan, weight;
  //  int lastbranchtime = -1;
  int lastpathcycle, opct;
#ifdef STATIC_ESTIMATE_DEBUG
  double nc = 0.0, ndo = 0.0;
#endif

  dvprintf ((OUTF, ". estimating superblock %d.\n", hb->GetRegionId()));

  // Iterate through each subblock of the superblock, treating each
  // like a basic block. A "subblock" means a basic block-like section
  // of a superblock, from a C_MERGE to a branch.
  topop = hb->GetEntryOpsPtr()->GetOpPtr();
  lastpathcycle = 0;
  while (topop != NULL)
    {
      dvprintf ((OUTF, "... lpc = %d, topop starts at %d.\n",
                 lastpathcycle, topop->GetOpId()));
      //      mintimeop = NULL;

      // topop begins the subblock. Find the next branch (bottomop).
      for (bottomop = topop->GetNextLink(), opct = 0;
           bottomop != NULL && bottomop->GetOutListPtr() == NULL;
           bottomop = bottomop->GetNextLink())  // step until branch
        {
          if (!(bottomop->IsDummy())) opct++;  // count real ops in subblock
          //      if (bottomop->GetSchedTime() <= lastpathcycle)
          //        continue;  // move on - either spec'd or simul. branch

          //      if ((mintimeop == NULL &&
          //           bottomop->GetSchedTime() > lastpathcycle) ||
          //          (mintimeop != NULL &&
          //           bottomop->GetSchedTime() < mintimeop->GetSchedTime()))
          //        mintimeop = bottomop;
        } // end for

      if (bottomop == NULL)
        {
          LegoNonFatal ("Estimate", "Couldn't find branch after op %d in "
                        "region %d.", topop->GetOpId(), hb->GetRegionId());
          return;
        } // end if
      if (!(bottomop->IsDummy())) opct++;  // catch bottomop for opct
      //      topop = mintimeop;  // first non-spec'd op in path (besides br.)
      //      dvprintf ((OUTF, "... scanned topop is %d.\n",
      //                 (topop == NULL ? 0 : topop->GetOpId())));
      //      if (topop == NULL) topop = bottomop;  // if all spec'd except br.
      dvprintf ((OUTF, "... bottomop is %d.\n", bottomop->GetOpId()));

      // One detail: if this branch was scheduled the same time as the
      // last branch (i.e., if topop becomes bottomop), ignore this subblock's
      // cycle time; its execution completely overlaps the last one's
      // (dynamic op count still matters though).
      //      if (bottomop->GetSchedTime() == lastbranchtime)
      //      if (bottomop->GetSchedTime() == topop->GetSchedTime())
      //      if (bottomop->GetSchedTime() == lastpathcycle)
      //        timespan = 0.0;
      //      else
        //      timespan = (double) SchedTimeSpan (topop, bottomop);
      timespan = (double) (bottomop->GetSchedTime() - lastpathcycle);

      weight = FindOpWeight (topop);  // NOT hb weight, but subblock weight

      // # cycles = schedule length of subblock * subblock weight
      st->numCycles += timespan * weight;
      // # dynamic ops = # ops in subblock * subblock weight
      st->numDynamicOps += ((double) opct) * weight;
#ifdef STATIC_ESTIMATE_DEBUG
      nc += timespan * weight;
      ndo += ((double) opct) * weight;
#endif

      dvprintf ((OUTF, "... timespan of %lf and weight of %lf gives %lf cycles.\n",
                 timespan, weight, timespan * weight));
      dvprintf ((OUTF, "... %d ops counted and weight of %lf gives %lf dynamic.\n",
                 opct, weight, ((double) opct) * weight));

      // Advance ...
      //      lastbranchtime = bottomop->GetSchedTime();
      lastpathcycle = bottomop->GetSchedTime();
      topop = bottomop->GetNextLink();
    } // end while

  dprintf ((OUTF, "Estimate HB %d\t%lf cycles\t%lf ops\n", hb->GetRegionId(),
            nc, ndo));
  return;
} // end Estimate (hb)

static void
Estimate (legoTreegion *tree, static_stats *st)
{
  legoOp *topop, *bottomop, *leafop, *walkop;
  opList *leafopl;
  edgeList *exits, *treeexits;
  opEdges *exitedge;
  legoRegion *block;
  regionList *rl, *path;
  opList *opl;
  double timespan, weight;
  //  int lastbranchtime;
  int opct, isRTS;
  int topop_s_time, bottomop_s_time, all_ops_speculated;
  char flag;
#ifdef STATIC_ESTIMATE_DEBUG
  double nc = 0.0, ndo = 0.0;
#endif

  // Treat each execution path in the treegion like a superblock, and
  // sum up over all paths. Use the weight of the path as the overall
  // weight when calculating op count and cycle time for a path.
  for (leafopl = tree->GetExitOpsPtr(); leafopl != NULL;
       leafopl = leafopl->GetNextListPtr())
    {
      leafop = leafopl->GetOpPtr();
      if (leafop == NULL)
        {
          LegoNonFatal ("Estimate", "Can't find leaf of treegion %d.",
                        tree->GetRegionId());
          continue;
        } // end if

      // For this exit op, iterate over each treegion exit that emanates
      // from it. If it's an RTS, assume the presence of one edge with
      // the frequency of the op.
      isRTS = (leafop->IsRETOp() ||
              leafop->IsBRLExitOp()); //HZ:
      if (isRTS)
        exits = NULL;
      else
        exits = ((legoRegion *) leafop->GetParentBlockPtr())->
          GetOutEdgesPtr();
      while (exits != NULL || isRTS)
        {
          if (exits != NULL)
            {
              exitedge = exits->GetEdgePtr();
              if (exitedge == NULL)
                {
                  LegoNonFatal ("Estimate", "Can't find exit edge of "
                                "treegion %d.", tree->GetRegionId());
                  exits = exits->GetNextListPtr();
                  continue;
                } // end if

              // Before using this edge, check that it's actually a
              // treegion exit edge and that it emanates from leafop.
              for (treeexits = tree->GetOutEdgesPtr(); treeexits != NULL;
                   treeexits = treeexits->GetNextListPtr())
                if (treeexits->GetEdgePtr() == exitedge) break;
              // (Use treeexits as a convenient way to flag that the
              // exit edge doesn't emanate from leafop.)
              if (exitedge->GetFromOpPtr() != leafop) treeexits = NULL;
              if (treeexits == NULL)
                {
                  exits = exits->GetNextListPtr();  // skip it
                  continue;
                } // end if

              // The path weight is the weight of the edge exiting.
              weight = (double) FindEdgeFrequency (exitedge);
            } // end if
          else
            {
              exitedge = NULL;
              weight = FindOpWeight (leafop);  // path weight = RTS weight
            } // end else

          dvprintf ((OUTF, ". beginning path to exit edge %d (op %d), weight "
                     "%lf.\n", (exitedge != NULL ? exitedge->GetEdgeId() :
                                0),
                     leafop->GetOpId(), weight));

          // Before going through all the rigamarole, if this path has
          // no weight, skip it completely.
          if (weight == 0)
            {
              dvprintf ((OUTF, ". path has zero weight - skipping!\n"));
              if (!isRTS)
                exits = exits->GetNextListPtr();
              isRTS = 0;
              continue;
            } // end if

          // Walk up the blocks from the leaf to the root, forming a list in
          // reverse order as you go.
          path = NULL;
          for (block = (legoRegion *) leafop->GetParentBlockPtr();
               block != NULL;
               block = block->GetParents()->GetRegionPtr())
            {
              rl = new regionList (block);
              if (path != NULL)
                path->Prepend (rl);
              path = rl;

              if (block == tree->GetRoot()) break;
            } // end for
          if (block == NULL)
            {
              LegoNonFatal ("Estimate", "Failed walking to root from op %d "
                            "in treegion %d.", leafop->GetOpId(),
                            tree->GetRegionId());
              if (!isRTS)
                exits = exits->GetNextListPtr();
              isRTS = 0;
              continue;
            } // end if

          // Now proceed down the path from root to leaf, calculating the 
          // timespan in op count for each BB in path.
          // Path now consists of BBs only as UnBindSB is assumed during 
          // treegion formation to improve treegions and also because 
          // the dag builder was handling SB incorrectly.
          for (rl = path; rl != NULL; rl = rl->GetNextListPtr())
            {
              block = rl->GetRegionPtr();
              dvprintf ((OUTF, "... looking at block %d.\n",
                         block->GetRegionId()));
              
              // mdj - 7/1/98 I am now assuming that UnBindSB is used during 
              // treegion formation so that treegions consist only of BBs.
              // Therefore, topop is the entry C_MERGE and bottomop is the 
              // exit branch (or DUMMY_BR). BBs have only one entry op and 
              // one exit op. 
              topop = block->GetEntryOpsPtr()->GetOpPtr();
              topop_s_time = topop->GetSchedTime();
              dvprintf ((OUTF, "... topop is %d.\n",
                         topop->GetOpId()));
              // Count the real ops in this block while stepping 
              // through to the bottomop branch (or DUMMY_BR)
              all_ops_speculated = TRUE;
              for (bottomop = topop->GetNextLink(), opct = 0;
                   bottomop != NULL && bottomop->GetOutListPtr() == NULL;
                   bottomop = bottomop->GetNextLink())  // until branch
                {
                  if (!(bottomop->IsDummy())) {
                    opct++;  // count real ops in block
                    if (bottomop->GetSchedTime() >= topop_s_time)
                      all_ops_speculated = FALSE;
                  }
                } // end for
              
              if (bottomop == NULL)
                {
                  LegoNonFatal ("Estimate", "Couldn't find branch after "
                                "op %d in region %d.", topop->GetOpId(),
                                block->GetRegionId());
                  return;
                } // end if
              bottomop_s_time = bottomop->GetSchedTime();
              if (!(bottomop->IsDummy())) opct++;  // bottomop for opct
              dvprintf ((OUTF, "... bottomop is %d.\n",
                         bottomop->GetOpId()));
              
              // Now calculate the timespan...
              if (topop_s_time == bottomop_s_time)  // possibly all ops 
                                                    // spec'd in BB
                {
                  if (all_ops_speculated) 
                    if (IsTreeExitandDummyBr(bottomop, tree)) {
                      timespan = 0.0;
                      // this BB can be removed
                    }
                    else {
                      timespan = 1.0;
                      // if bottomop is a DUMMY_BR and BB still has 
                      // all_ops_speculated even after speculative code 
                      // motion is implemented, this BB can then be 
                      // removed safely and then timespan = 0.0
                    }
                  else 
                    timespan = 1.0;
                } // end if
              else  // all ops NOT spec'd
                {
                  timespan = bottomop_s_time - topop_s_time + 1;
                } // end else
              
              // Remember we're using the path weight.
              // # cycles = schedule length of subblock * subblock weight
              st->numCycles += timespan * weight;
              // # dynamic ops = # ops in subblock * subblock weight
              st->numDynamicOps += ((double) opct) * weight;
#ifdef STATIC_ESTIMATE_DEBUG
              nc += timespan * weight;
              ndo += ((double) opct) * weight;
#endif
              dvprintf ((OUTF, "... path weight is %lf.\n", weight));
              dvprintf ((OUTF, "... timespan of %lf gives %lf cycles.\n",
                         timespan, timespan * weight));
              dvprintf ((OUTF, "... %d ops counted gives %lf dynamic.\n",
                         opct, ((double) opct) * weight));
              
            } // end for (each block in path)
          
          // Move to next path from this leaf.
          if (!isRTS)
            exits = exits->GetNextListPtr();  // go to next exit
          isRTS = 0;  // only do RTS once
          delete path;
        }  // end while (there's a path from the leaf)

    } // end for (each leaf)

  dprintf ((OUTF, "Estimate TREE %d\t%lf cycles\t%lf ops\n",
            tree->GetRegionId(), nc, ndo));
  return;
} // end Estimate (tree)

static void
EstimateNew (legoTreegion *tree, static_stats *st)
{
  legoOp *branchop, *topop, *bottomop, *leafop, *walkop, *finalop;
  opList *leafopl, *branchops, *oplist;
  edgeList *exits, *treeexits;
  opEdges *exitedge;
  legoRegion *block;
  opList *opl;
  double timespan, weight;
  //  int lastbranchtime;
  int opct, isRTS;
  int topop_s_time, bottomop_s_time, all_ops_speculated;
  char flag;
#ifdef STATIC_ESTIMATE_DEBUG
  double nc = 0.0, ndo = 0.0;
#endif

  // Treat each execution path in the treegion like a superblock, and
  // sum up over all paths. Use the weight of the path as the overall
  // weight when calculating op count and cycle time for a path.
  for (leafopl = tree->GetExitOpsPtr(); leafopl != NULL;
       leafopl = leafopl->GetNextListPtr())
    {
      leafop = leafopl->GetOpPtr();
      if (leafop == NULL)
        {
          LegoNonFatal ("EstimateNew", "Can't find leaf of treegion %d.",
                        tree->GetRegionId());
          continue;
        } // end if

      // For this exit op, iterate over each treegion exit that emanates
      // from it. If it's an RTS, assume the presence of one edge with
      // the frequency of the op.
      isRTS = (leafop->IsRETOp() ||
              leafop->IsBRLExitOp()); //HZ: also consider the br.call exit
      if (isRTS)
        exits = NULL;
      else
        exits = ((legoRegion *) leafop->GetParentBlockPtr())->
          GetOutEdgesPtr();
      while (exits != NULL || isRTS)
        {
          if (exits != NULL)
            {
              exitedge = exits->GetEdgePtr();
              if (exitedge == NULL)
                {
                  LegoNonFatal ("EstimateNew", "Can't find exit edge of "
                                "treegion %d.", tree->GetRegionId());
                  exits = exits->GetNextListPtr();
                  continue;
                } // end if

              // Before using this edge, check that it's actually a
              // treegion exit edge and that it emanates from leafop.
              for (treeexits = tree->GetOutEdgesPtr(); treeexits != NULL;
                   treeexits = treeexits->GetNextListPtr())
                if (treeexits->GetEdgePtr() == exitedge) break;
              // (Use treeexits as a convenient way to flag that the
              // exit edge doesn't emanate from leafop.)
              if (exitedge->GetFromOpPtr() != leafop) treeexits = NULL;
              if (treeexits == NULL)
                {
                  exits = exits->GetNextListPtr();  // skip it
                  continue;
                } // end if

              // The path weight is the weight of the edge exiting.
              weight = (double) FindEdgeFrequency (exitedge);
            } // end if
          else
            {
              exitedge = NULL;
              if (FindLcAttribute( "orig_wt", leafop ) != NULL) {
                weight = FindLcAttribute( "orig_wt", leafop )->GetAttrOprdPtr()->GetLiteralDouble();
              }
              else {
                weight = FindOpWeight (leafop);  // path weight = RTS weight
              }
            } // end else

          dvprintf ((OUTF, ". beginning path to exit edge %d (op %d), weight "
                     "%lf.\n", (exitedge != NULL ? exitedge->GetEdgeId() :
                                0),
                     leafop->GetOpId(), weight));

          // Before going through all the rigamarole, if this path has
          // no weight, skip it completely.
          if (weight == 0)
            {
              dvprintf ((OUTF, ". path has zero weight - skipping!\n"));
              if (!isRTS)
                exits = exits->GetNextListPtr();
              isRTS = 0;
              continue;
            } // end if

          // Walk up the block branchops from the leafop to the root branchop, 
          // forming a opList in reverse order as you go.
          branchops = NULL;
          for (branchop = leafop;
               branchop != NULL;
               branchop = ((legoRegion *)branchop->GetParentBlockPtr())->GetInEdgesPtr()->GetEdgePtr()->GetFromOpPtr()) {
            oplist = new opList();
            oplist->SetOpPtr(branchop);
            oplist->SetValid(1); 
            if (branchops == NULL) {
              branchops = oplist;
            }
            else {
              oplist->SetNextListPtr(branchops); 
              branchops = oplist; 
            }
            if (branchop->GetParentBlockPtr() == tree->GetRoot()) break;
          }
          if (branchop == NULL)
            {
              LegoNonFatal ("EstimateNew", "Failed walking to root from op %d "
                            "in treegion %d.", leafop->GetOpId(),
                            tree->GetRegionId());
              if (!isRTS)
                exits = exits->GetNextListPtr();
              isRTS = 0;
              continue;
            } // end if

          // Now proceed down the path from root to leaf, calculating the 
          // timespan and op count for each BB in path.
          for (oplist = branchops; 
               oplist != NULL; 
               oplist = oplist->GetNextListPtr()) {

            branchop = oplist->GetOpPtr();
            block = (legoRegion *) branchop->GetParentBlockPtr();
            dvprintf ((OUTF, "... looking at block %d.\n",
                       block->GetRegionId()));
            
            topop = block->GetEntryOpsPtr()->GetOpPtr();
            topop_s_time = topop->GetSchedTime();
            dvprintf ((OUTF, "... topop is %d.\n",
                       topop->GetOpId()));
            // Count the real ops in this block while stepping 
            // through to branchop
            all_ops_speculated = TRUE;
            // finalop is the last op in branchop's multiop
            for (finalop = branchop;
                 ((finalop->GetNextLink() != NULL) &&  
                  (finalop->GetNextLink()->GetSchedTime() == 
                   branchop->GetSchedTime())); 
                 finalop = finalop->GetNextLink())
              ; // just increment finalop
            for (bottomop = topop->GetNextLink(), opct = 0;
                 bottomop != NULL && bottomop != finalop;
                 bottomop = bottomop->GetNextLink())  // until branchop multiop
              {
                if (!(bottomop->IsDummy())) {
                  opct++;  // count real ops in block
                  if (bottomop->GetSchedTime() >= topop_s_time)
                    all_ops_speculated = FALSE;
                }
              } // end for
            
            if (bottomop == NULL)
              {
                LegoNonFatal ("EstimateNew", "Couldn't find branch after "
                              "op %d in region %d.", topop->GetOpId(),
                              block->GetRegionId());
                return;
              } // end if
            bottomop_s_time = bottomop->GetSchedTime();
            if (!(bottomop->IsDummy())) opct++;  // bottomop for opct
            dvprintf ((OUTF, "... bottomop is %d.\n",
                       bottomop->GetOpId()));
            
            // Now calculate the timespan...
            if (topop_s_time == bottomop_s_time)  // possibly all ops 
              // spec'd in BB
              {
                if (all_ops_speculated) 
                  if (IsTreeExitandDummyBr(bottomop, tree)) {
                    timespan = 0.0;
                    // this BB can be removed
                  }
                  else {
                    timespan = 1.0;
                    // if bottomop is a DUMMY_BR and BB still has 
                    // all_ops_speculated even after speculative code 
                    // motion is implemented, this BB can then be 
                    // removed safely and then timespan = 0.0
                  }
                else 
                  timespan = 1.0;
              } // end if
            else  // all ops NOT spec'd
              {
                timespan = bottomop_s_time - topop_s_time + 1;
              } // end else
            
            // Remember we're using the path weight.
            // # cycles = schedule length of subblock * subblock weight
            st->numCycles += timespan * weight;
            // # dynamic ops = # ops in subblock * subblock weight
            st->numDynamicOps += ((double) opct) * weight;
#ifdef STATIC_ESTIMATE_DEBUG
            nc += timespan * weight;
            ndo += ((double) opct) * weight;
#endif
            dvprintf ((OUTF, "... path weight is %lf.\n", weight));
            dvprintf ((OUTF, "... timespan of %lf gives %lf cycles.\n",
                       timespan, timespan * weight));
            dvprintf ((OUTF, "... %d ops counted gives %lf dynamic.\n",
                       opct, ((double) opct) * weight));
            
          } // end for (each block in path)
          
          // Move to next path from this leaf.
          if (!isRTS)
            exits = exits->GetNextListPtr();  // go to next exit
          isRTS = 0;  // only do RTS once
          delete branchops;
        }  // end while (there's a path from the leaf)
      
    } // end for (each leaf)
  
  dprintf ((OUTF, "EstimateNew TREE %d\t%lf cycles\t%lf ops\n",
            tree->GetRegionId(), nc, ndo));
  return;
} // end EstimateNew (tree)

static_stats *
StaticEstimate (legoRegion *region)
{
  static_stats *st, *cst;
  unsigned i;

  st = new static_stats;

  switch (region->GetRegionType())
    {
    case RT_BB:
      Estimate ((legoBB *) region, st);
      break;
    case RT_SB:
    case RT_HB:
      Estimate (region, st);
      break;
    case RT_TREE:
//      Estimate ((legoTreegion *) region, st);
      EstimateNew ((legoTreegion *) region, st);
      break;
    case RT_TRACE:  // not an estimate for trace scheduling!
    case RT_LOOP:
    case RT_LOOPBODY:
    case RT_PROC:
    case RT_MODULE:
      // Do the components.
      for (i = 0; i < region->GetCount(); i++)
        {
          cst = StaticEstimate ((legoRegion *) region->GetItem (i));
          st->numCycles += cst->numCycles;
          st->numDynamicOps += cst->numDynamicOps;
          delete cst;
        } // for
      break;
    default:
      LegoNonFatal ("StaticEstimate", "Estimation of region type %d is not "
                    "done yet.", region->GetRegionType());
      break;
    } // end switch

  if (region->GetRegionType() == RT_PROC)
    dprintf ((OUTF, "Estimate PROC %s:\n%lf cycles\t\t%lf ops\n",
              ((legoProc *) region)->GetProcName(), st->numCycles,
              st->numDynamicOps));
  //  if (region->GetRegionType() == RT_MODULE)
  //    dprintf ((OUTF, "Estimate for module:\n%lf cycles\t\t%lf ops\n",
  //          ((legoModule *) region)->GetModuleName(), st->numCycles,
  //          st->numDynamicOps));
  return st;
} // end StaticEstimate

---