baseannealer.cxx

Go to the documentation of this file.

/**************************************************************************
***    
*** Copyright (c) 1995-2000 Regents of the University of California,
***               Andrew E. Caldwell, Andrew B. Kahng and Igor L. Markov
*** Copyright (c) 2000-2004 Regents of the University of Michigan,
***               Saurabh N. Adya, Jarrod A. Roy and Igor L. Markov
***
***  Contact author(s): abk@cs.ucsd.edu, imarkov@umich.edu
***  Original Affiliation:   UCLA, Computer Science Department,
***                          Los Angeles, CA 90095-1596 USA
***
***  Permission is hereby granted, free of charge, to any person obtaining 
***  a copy of this software and associated documentation files (the
***  "Software"), to deal in the Software without restriction, including
***  without limitation 
***  the rights to use, copy, modify, merge, publish, distribute, sublicense, 
***  and/or sell copies of the Software, and to permit persons to whom the 
***  Software is furnished to do so, subject to the following conditions:
***
***  The above copyright notice and this permission notice shall be included
***  in all copies or substantial portions of the Software.
***
*** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
*** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
*** OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
*** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
*** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
*** OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
*** THE USE OR OTHER DEALINGS IN THE SOFTWARE.
***
***
***************************************************************************/
















#include "baseannealer.h"
#include "CommandLine.h"
#include "DB.h"
#include "AnalytSolve.h"

#ifdef _MSC_VER
#ifndef srand48
#define srand48 srand
#endif
#endif

const int BaseAnnealer::UNINITIALIZED=-1;
const unsigned int BaseAnnealer::UNSIGNED_UNINITIALIZED=0;
const int BaseAnnealer::FREE_OUTLINE=-9999;
const int BaseAnnealer::NOT_FOUND=-1;
   
// --------------------------------------------------------
BaseAnnealer::BaseAnnealer(const parquetfp::Command_Line *const params,
                           parquetfp::DB *const db)
   : _db(db),
     _params(params),
     _analSolve(new parquetfp::AnalytSolve(
                   const_cast<parquetfp::Command_Line*>(params),
                   const_cast<parquetfp::DB*>(db)))
{
   // set the random seed for each invokation of the Annealer
   int rseed;
   if(_params->getSeed)
      rseed = int(time((time_t *)NULL));
   else
      rseed = _params->seed;
   
   srand(rseed);        //seed for rand function
   srand48(rseed);      //seed for random_shuffle function
   if(_params->verb.forMajStats > 0)
      cout << "The random seed for this run is: " << rseed << endl;
   
   const char* baseName = _params->inFileName;
   strcpy(_baseFileName, baseName);
   annealTime = 0.0;
}
// --------------------------------------------------------
BaseAnnealer::~BaseAnnealer()
{
   if (_analSolve != NULL)
      delete _analSolve;
}
// --------------------------------------------------------
void BaseAnnealer::solveQP()  
{
   _analSolve->solveSOR();
   _db->updatePlacement(_analSolve->getXLocs(), _analSolve->getYLocs());
}
// --------------------------------------------------------
void BaseAnnealer::postHPWLOpt()
{
//    parquetfp::Point offset = _analSolve->getDesignOptLoc();
//    cout << "offset.x " << offset.x
//         << " offset.y " << offset.y << endl;
   
//    double initHPWL = _db->evalHPWL();
//    cout << "initHPWL: " << initHPWL << endl;
//    _db->shiftDesign(offset);
   
//    double afterHPWL = _db->evalHPWL();
//    cout << "afterHPWL: " << afterHPWL << endl;      
//    if(afterHPWL > initHPWL)
//    {
//       cout << "shifting not done." << endl;
//       offset.x *= -1;
//       offset.y *= -1;
//       _db->shiftDesign(offset);
//    }
//    else
//       cout << "shifting is done." << endl;

   // only shift in "fixed-outline" mode
   if (_params->reqdAR != FREE_OUTLINE)
   {
      double blocksArea = _db->getNodesArea();
      double reqdAR = _params->reqdAR;
      double reqdArea = blocksArea * (1 + _params->maxWS/100.0);
      double reqdWidth = sqrt(reqdArea * reqdAR);
      double reqdHeight = sqrt(reqdArea / reqdAR);
      
//       printf("blocksArea: %.2f reqdWidth: %.2f reqdHeight: %.2f\n",
//              blocksArea, reqdWidth, reqdHeight);
      _db->shiftOptimizeDesign(reqdWidth, reqdHeight);
   }
}
// --------------------------------------------------------
void BaseAnnealer::printResults(const Timer& tm,
                                const SolutionInfo& curr) const
{
   double timeReqd = tm.getUserTime();
   double realTime = tm.getRealTime();

   double blocksArea = _db->getNodesArea();
   double currArea = curr.area;
   double currWidth = curr.width;
   double currHeight = curr.height;
   double currAR = currWidth / currHeight; 
   double whiteSpace = 100 * (currArea - blocksArea) / blocksArea;
   double HPWL = curr.HPWL;

   cout.precision(6);
   if(_params->verb.forSysRes > 0)
      cout << "realTime:" << realTime << "\tuserTime:" << timeReqd << endl;
   if(_params->verb.forMajStats > 0)
      cout << "Final Area: " << currArea << " WhiteSpace " << whiteSpace
           << "%" << " AR " << currAR << " HPWL " << HPWL << endl;

   double reqdAR = _params->reqdAR;
   double reqdArea = blocksArea * (1 + _params->maxWS/100.0);
   double reqdWidth = sqrt(reqdArea * reqdAR);
   double reqdHeight = sqrt(reqdArea / reqdAR);
   
   if(_params->verb.forMajStats > 0)
   {
      if (_params->dontClusterMacros && _params->solveTop)
         cout << "width w/ macros only: "
              << _db->getXSizeWMacroOnly() << " ";
      else
         cout << "width:  " << currWidth << " ";

      if (_params->reqdAR != FREE_OUTLINE)
         cout << "(outline width:  " << reqdWidth << ") ";
      cout << endl;
      
      if (_params->dontClusterMacros && _params->solveTop)
         cout << "height w/ macros only: "
              << _db->getYSizeWMacroOnly() << " ";
      else
         cout << "height: " << currHeight << " ";

      if (_params->reqdAR != FREE_OUTLINE)
          cout << "(outline height: " << reqdHeight << ") ";
      cout << endl;
      
      cout << "area utilization (wrt. total current area): "
           << (blocksArea / currArea) * 100 << "%." << endl;
      cout << "whitespace       (wrt. total current area): " 
           << (1 - (blocksArea/currArea)) * 100 << "% " << endl;
   }
}
// --------------------------------------------------------

---