riscv
/
coriolis
mirror of https://gitlab.lip6.fr/vlsi-eda/coriolis.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
coriolis/katana/src/Configuration.cpp

259 lines
12 KiB
C++
Raw Blame History

// -*- mode: C++; explicit-buffer-name: "Configuration.cpp<katana>" -*-
//
// This file is part of the Coriolis Software.
// Copyright (c) UPMC 2008-2018, All Rights Reserved
//
// +-----------------------------------------------------------------+
// | C O R I O L I S |
// | K i t e - D e t a i l e d R o u t e r |
// | |
// | Author : Jean-Paul CHAPUT |
// | E-mail : Jean-Paul.Chaput@asim.lip6.fr |
// | =============================================================== |
// | C++ Module : "./Configuration.cpp" |
// +-----------------------------------------------------------------+
#include <string>
#include "hurricane/configuration/Configuration.h"
#include "hurricane/Cell.h"
#include "crlcore/Utilities.h"
#include "katana/Configuration.h"
#include "katana/KatanaEngine.h"
namespace Katana {
using std::cout;
using std::cerr;
using std::endl;
using std::ostringstream;
using Hurricane::tab;
using Hurricane::Error;
using Hurricane::Technology;
// -------------------------------------------------------------------
// Class : "Katana::Configuration".
Configuration::Configuration ()
: Anabatic::Configuration()
, _postEventCb ()
, _searchHalo (Cfg::getParamInt ("katana.searchHalo" , 1)->asInt())
, _longWireUpThreshold1(Cfg::getParamInt ("katana.longWireUpThreshold1" , 60)->asInt())
, _longWireUpReserve1 (Cfg::getParamDouble("katana.longWireUpReserve1" , 1.0)->asDouble())
, _hTracksReservedLocal(Cfg::getParamInt ("katana.hTracksReservedLocal" , 3)->asInt())
, _vTracksReservedLocal(Cfg::getParamInt ("katana.vTracksReservedLocal" , 3)->asInt())
, _termSatReservedLocal(Cfg::getParamInt ("katana.termSatReservedLocal" , 9)->asInt())
, _hTracksReservedMin (Cfg::getParamInt ("katana.hTracksReservedMin" , 1)->asInt())
, _vTracksReservedMin (Cfg::getParamInt ("katana.vTracksReservedMin" , 1)->asInt())
, _termSatThreshold (Cfg::getParamInt ("katana.termSatThreshold" , 8)->asInt())
, _ripupLimits ()
, _ripupCost (Cfg::getParamInt ("katana.ripupCost" , 3)->asInt())
, _eventsLimit (Cfg::getParamInt ("katana.eventsLimit" ,4000000)->asInt())
, _bloatOverloadAdd (Cfg::getParamInt ("katana.bloatOverloadAdd" , 4)->asInt())
, _trackFill (Cfg::getParamInt ("katana.trackFill" , 0)->asInt())
, _flags (0)
, _profileEventCosts (Cfg::getParamBool ("katana.profileEventCosts" ,false )->asBool())
, _runRealignStage (Cfg::getParamBool ("katana.runRealignStage" ,true )->asBool())
, _disableStackedVias (Cfg::getParamBool ("katana.disableStackedVias" ,false )->asBool())
{
_ripupLimits[StrapRipupLimit] = Cfg::getParamInt("katana.strapRipupLimit" ,16)->asInt();
_ripupLimits[LocalRipupLimit] = Cfg::getParamInt("katana.localRipupLimit" , 7)->asInt();
_ripupLimits[GlobalRipupLimit] = Cfg::getParamInt("katana.globalRipupLimit" , 5)->asInt();
_ripupLimits[LongGlobalRipupLimit] = Cfg::getParamInt("katana.longGlobalRipupLimit" , 5)->asInt();
_ripupLimits[ShortNetRipupLimit] = Cfg::getParamInt("katana.shortNetRipupLimit" ,16)->asInt();
if (Cfg::getParamBool("katana.useGlobalEstimate" ,false)->asBool()) _flags |= UseGlobalEstimate;
if (Cfg::getParamBool("katana.useStaticBloatProfile",true )->asBool()) _flags |= UseStaticBloatProfile;
// for ( size_t i=0 ; i<MaxMetalDepth ; ++i ) {
// ostringstream paramName;
// paramName << "katana.metal" << (i+1) << "MinBreak";
// int threshold = 29*50;
// switch ( i ) {
// case 0:
// case 1:
// threshold = 2*50;
// break;
// default:
// threshold = 30*50;
// break;
// }
// Cfg::getParamDouble(paramName.str())->setDouble(threshold);
// _globalMinBreaks[i] = DbU::lambda (Cfg::getParamDouble(paramName.str())->asDouble());
// }
}
Configuration::Configuration ( const Configuration& other )
: Anabatic::Configuration(*other.base())
, _postEventCb (other._postEventCb)
, _searchHalo (other._searchHalo)
, _longWireUpThreshold1(other._longWireUpThreshold1)
, _longWireUpReserve1 (other._longWireUpReserve1)
, _hTracksReservedLocal(other._hTracksReservedLocal)
, _vTracksReservedLocal(other._vTracksReservedLocal)
, _termSatReservedLocal(other._termSatReservedLocal)
, _hTracksReservedMin (other._hTracksReservedMin)
, _vTracksReservedMin (other._vTracksReservedMin)
, _termSatThreshold (other._termSatThreshold)
, _ripupLimits ()
, _ripupCost (other._ripupCost)
, _eventsLimit (other._eventsLimit)
, _bloatOverloadAdd (other._bloatOverloadAdd)
, _trackFill (other._trackFill)
, _flags (other._flags)
, _profileEventCosts (other._profileEventCosts)
, _runRealignStage (other._runRealignStage)
, _disableStackedVias (other._disableStackedVias)
{
_ripupLimits[StrapRipupLimit] = other._ripupLimits[StrapRipupLimit];
_ripupLimits[LocalRipupLimit] = other._ripupLimits[LocalRipupLimit];
_ripupLimits[GlobalRipupLimit] = other._ripupLimits[GlobalRipupLimit];
_ripupLimits[LongGlobalRipupLimit] = other._ripupLimits[LongGlobalRipupLimit];
}
Configuration::~Configuration ()
{ }
Configuration* Configuration::clone () const
{ return new Configuration(*this); }
void Configuration::setRipupLimit ( uint32_t type, uint32_t limit )
{
if ( type >= RipupLimitsTableSize ) {
cerr << Error("setRipupLimit(): Bad ripup limit index: %ud (> %ud)."
,type,RipupLimitsTableSize) << endl;
return;
}
_ripupLimits [ type ] = limit;
}
void Configuration::setHTracksReservedLocal ( uint32_t reserved )
{
// if (reserved > getHEdgeCapacity())
// throw Error( "Configuration::setHTracksReservedLocal(): tracks reserved for local routing (%d) is greater than edge capacity %d."
// , reserved, getHEdgeCapacity() );
_hTracksReservedLocal = reserved;
}
void Configuration::setVTracksReservedLocal ( uint32_t reserved )
{
// if (reserved > 1.0)
// throw Error( "Configuration::setVTracksReservedLocal(): tracks reserved for local routing (%d) is greater than edge capacity %d."
// , reserved, getVEdgeCapacity() );
_vTracksReservedLocal = reserved;
}
void Configuration::setHTracksReservedMin ( uint32_t reserved )
{ _hTracksReservedMin = reserved; }
void Configuration::setVTracksReservedMin ( uint32_t reserved )
{ _vTracksReservedMin = reserved; }
uint32_t Configuration::getRipupLimit ( uint32_t type ) const
{
if ( type >= RipupLimitsTableSize ) {
cerr << Error("getRipupLimit(): Bad ripup limit index: %u (> %u)."
,type,RipupLimitsTableSize) << endl;
return 0;
}
return _ripupLimits[type];
}
void Configuration::print ( Cell* cell ) const
{
if (not cmess1.enabled()) return;
cout << " o Configuration of ToolEngine<Katana> for Cell <" << cell->getName() << ">" << endl;
cout << Dots::asString(" - Net builder style" ,getNetBuilderStyle()) << endl;
cout << Dots::asString(" - Routing style" ,getRoutingStyle().asString()) << endl;
cout << Dots::asUInt (" - Dijkstra GR search halo" ,getSearchHalo()) << endl;
cout << Dots::asBool (" - Use GR density estimate" ,useGlobalEstimate()) << endl;
cout << Dots::asBool (" - Use static bloat profile" ,useStaticBloatProfile()) << endl;
cout << Dots::asInt (" - GCell terminal(RP) saturate number" ,getSaturateRp()) << endl;
cout << Dots::asDouble(" - GCell saturate ratio (LA)" ,getSaturateRatio()) << endl;
cout << Dots::asUInt (" - Long wire threshold1 for move up" ,_longWireUpThreshold1) << endl;
cout << Dots::asDouble(" - Long wire reserved1 for move up" ,_longWireUpReserve1) << endl;
cout << Dots::asUInt (" - Edge min H reserved local" ,_hTracksReservedMin) << endl;
cout << Dots::asUInt (" - Edge min V reserved local" ,_vTracksReservedMin) << endl;
cout << Dots::asUInt (" - Edge max H reserved local" ,_hTracksReservedLocal) << endl;
cout << Dots::asUInt (" - Edge max V reserved local" ,_vTracksReservedLocal) << endl;
cout << Dots::asUInt (" - Terminal saturated edge capacity" ,_termSatReservedLocal) << endl;
cout << Dots::asUInt (" - Terminal saturated GCell threshold" ,_termSatThreshold) << endl;
cout << Dots::asULong (" - Events limit (iterations)" ,_eventsLimit) << endl;
cout << Dots::asUInt (" - Ripup limit, straps & unbreakables" ,_ripupLimits[StrapRipupLimit]) << endl;
cout << Dots::asUInt (" - Ripup limit, locals" ,_ripupLimits[LocalRipupLimit]) << endl;
cout << Dots::asUInt (" - Ripup limit, globals" ,_ripupLimits[GlobalRipupLimit]) << endl;
cout << Dots::asUInt (" - Ripup limit, long globals" ,_ripupLimits[LongGlobalRipupLimit]) << endl;
cout << Dots::asUInt (" - Bloat overload additional penalty" ,_bloatOverloadAdd) << endl;
cout << Dots::asUInt (" - Fill every nth track" ,_trackFill) << endl;
Super::print( cell );
}
string Configuration::_getTypeName () const
{ return "Configuration"; }
string Configuration::_getString () const
{
ostringstream os;
os << "<" << _getTypeName() << " " << getRoutingGauge()->getName() << ">";
return os.str();
}
Record* Configuration::_getRecord () const
{
Record* record = Super::_getRecord();
if ( record ) {
record->add ( getSlot("_searchHalo" ,_searchHalo ) );
record->add ( getSlot("_longWireUpThreshold1" ,_longWireUpThreshold1 ) );
record->add ( getSlot("_longWireUpReserved1" ,_longWireUpReserve1 ) );
record->add ( getSlot("_hTracksReservedLocal" ,_hTracksReservedLocal ) );
record->add ( getSlot("_vTracksReservedLocal" ,_vTracksReservedLocal ) );
record->add ( getSlot("_hTracksReservedMin" ,_hTracksReservedMin ) );
record->add ( getSlot("_vTracksReservedMin" ,_vTracksReservedMin ) );
record->add ( getSlot("_ripupCost" ,_ripupCost ) );
record->add ( getSlot("_eventsLimit" ,_eventsLimit ) );
record->add ( getSlot("_ripupLimits[StrapRipupLimit]" ,_ripupLimits[StrapRipupLimit] ) );
record->add ( getSlot("_ripupLimits[LocalRipupLimit]" ,_ripupLimits[LocalRipupLimit] ) );
record->add ( getSlot("_ripupLimits[GlobalRipupLimit]" ,_ripupLimits[GlobalRipupLimit] ) );
record->add ( getSlot("_ripupLimits[LongGlobalRipupLimit]" ,_ripupLimits[LongGlobalRipupLimit]) );
// for ( size_t i=0 ; i<MaxMetalDepth ; ++i ) {
// ostringstream paramName;
// paramName << "metal" << (i+1) << "MinBreak";
// record->add ( DbU::getValueSlot(paramName.str(),&_globalMinBreaks[i]) );
// }
}
return record;
}
} // Katana namespace.
Reference in New Issue View Git Blame Copy Permalink