Anabatic transient commit 18. Port of Kite (Katana), Yeah, Baby! Yeah!
* Bug: In Hurricane, in StaticObservable::getObserver(), if the slot
pointer is NULL, do not try to access the owner. Returns NULL, so
the caller can be aware of the situation...
* Change: In Hurricane, in BreakpointWidget & ExceptionWidget some
cosmetic changes (fonts and window sizes).
* Bug: In Anabatic, In AutoHorizontal::getConstraints(), take into account
the constraints from the source AutoContact, as it holds the constraints
transmitted by the RoutingPads and sets up by propageConstraintsFromRp().
It is likely to be a bug affecting the original Katabatic as well.
* Change: In Anabatic, in RawGCellsUnder(), check that the segment is not
completly oustside the cell abutment box and truncate the coordinates
to the part that is inside. Use the "shrink" if we reach the east/north
border.
* Change: In Anabatic, in Configuration, no more decorator because we will
use a true derived relationship. Katana *derives* from *Anabatic* and do
not *decorate* it, so the Configuration can do the same. It also implies
that we directly create a Katana engine, not an Anabatic one.
* Change: In Anabatic, in Session, do not allow the opening of the Session
in a standalone fashion (with a static method). Instead it must be opened
using the relevant method of the Anabatic/Katana engine. This ensure we
are opening the right Session type.
* Change: In Anabatic, in AutoSegment_Aligneds() collection the seed segment
is not part of the collection by default, but will be included if the
Flags::WithSelf is set.
* Change: In Configuration, all the flags value are now defined in two steps.
Declared in the header and initialized in the module. This is to prevent
the fact that on some cases, in relation with the Python "extern C" part
modules, we need a true allocated variable. It was causing weird linking
problems.
A side effect is that they can no longer be used as entry is switches,
have to replace them by if/else.
* New: In Anabatic, new GCell::getNeighborAt() utility function.
* Bug: In Anabatic, in GCell::doGrid(), tag all the GCells of the grid with
the grid type... Back annote all the edges capacity (north & east) with
the reserved local capacity.
* New: Complete portage of Kite over Anabatic. The new engine is christened
"Katana" for Kite-Analogic. When it's capabilities and performances
will be on a part with Kite, it is to completly replace it (and take
back the "Kite" name). Preliminary tests seems to show that, contrary
to intuition (because built on a more complex/slower grid), it is even
slightly faster than Kite 8-).
2016-08-15 09:30:13 -05:00
|
|
|
// -*- C++ -*-
|
|
|
|
//
|
|
|
|
// This file is part of the Coriolis Software.
|
|
|
|
// Copyright (c) UPMC 2010-2016, 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 : "./PyKatanaEngine.cpp" |
|
|
|
|
// +-----------------------------------------------------------------+
|
|
|
|
|
|
|
|
|
|
|
|
#include "hurricane/isobar/PyCell.h"
|
|
|
|
#include "hurricane/viewer/PyCellViewer.h"
|
|
|
|
#include "hurricane/viewer/ExceptionWidget.h"
|
|
|
|
#include "hurricane/Cell.h"
|
|
|
|
#include "katana/PyKatanaEngine.h"
|
|
|
|
#include <functional>
|
|
|
|
|
|
|
|
# undef ACCESS_OBJECT
|
|
|
|
# undef ACCESS_CLASS
|
|
|
|
# define ACCESS_OBJECT _baseObject._object
|
|
|
|
# define ACCESS_CLASS(_pyObject) &(_pyObject->_baseObject)
|
|
|
|
#define METHOD_HEAD(function) GENERIC_METHOD_HEAD(KatanaEngine,katana,function)
|
|
|
|
|
|
|
|
|
|
|
|
namespace Katana {
|
|
|
|
|
|
|
|
using std::cerr;
|
|
|
|
using std::endl;
|
|
|
|
using std::hex;
|
|
|
|
using std::ostringstream;
|
|
|
|
using Hurricane::tab;
|
|
|
|
using Hurricane::Exception;
|
|
|
|
using Hurricane::Bug;
|
|
|
|
using Hurricane::Error;
|
|
|
|
using Hurricane::Warning;
|
|
|
|
using Hurricane::ExceptionWidget;
|
|
|
|
using Isobar::ProxyProperty;
|
|
|
|
using Isobar::ProxyError;
|
|
|
|
using Isobar::ConstructorError;
|
|
|
|
using Isobar::HurricaneError;
|
|
|
|
using Isobar::HurricaneWarning;
|
|
|
|
using Isobar::ParseOneArg;
|
|
|
|
using Isobar::ParseTwoArg;
|
|
|
|
using Isobar::PyCell;
|
|
|
|
using Isobar::PyCell_Link;
|
|
|
|
using Isobar::PyCellViewer;
|
|
|
|
using Isobar::PyTypeCellViewer;
|
|
|
|
using CRL::PyToolEngine;
|
|
|
|
|
|
|
|
|
|
|
|
extern "C" {
|
|
|
|
|
|
|
|
#if defined(__PYTHON_MODULE__)
|
|
|
|
|
|
|
|
|
|
|
|
#define DirectVoidToolMethod(SELF_TYPE, SELF_OBJECT, FUNC_NAME) \
|
|
|
|
static PyObject* Py##SELF_TYPE##_##FUNC_NAME(Py##SELF_TYPE* self) \
|
|
|
|
{ \
|
|
|
|
cdebug_log(40,0) << "Py" #SELF_TYPE "_" #FUNC_NAME "()" << endl; \
|
|
|
|
HTRY \
|
|
|
|
METHOD_HEAD(#SELF_TYPE "." #FUNC_NAME "()") \
|
|
|
|
if (SELF_OBJECT->getViewer()) { \
|
|
|
|
if (ExceptionWidget::catchAllWrapper( std::bind(&KatanaEngine::FUNC_NAME,SELF_OBJECT) )) { \
|
|
|
|
PyErr_SetString( HurricaneError, #FUNC_NAME "() has thrown an exception (C++)." ); \
|
|
|
|
return NULL; \
|
|
|
|
} \
|
|
|
|
} else { \
|
|
|
|
SELF_OBJECT->FUNC_NAME(); \
|
|
|
|
} \
|
|
|
|
HCATCH \
|
|
|
|
Py_RETURN_NONE; \
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// +=================================================================+
|
|
|
|
// | "PyKatanaEngine" Python Module Code Part |
|
|
|
|
// +=================================================================+
|
|
|
|
|
|
|
|
|
|
|
|
static PyObject* PyKatanaEngine_get ( PyObject*, PyObject* args )
|
|
|
|
{
|
|
|
|
cdebug_log(40,0) << "PyKatanaEngine_get()" << endl;
|
|
|
|
|
|
|
|
KatanaEngine* katana = NULL;
|
|
|
|
|
|
|
|
HTRY
|
|
|
|
PyObject* arg0;
|
|
|
|
|
|
|
|
if (not ParseOneArg("Katana.get", args, CELL_ARG, &arg0)) return NULL;
|
|
|
|
katana = KatanaEngine::get(PYCELL_O(arg0));
|
|
|
|
HCATCH
|
|
|
|
|
|
|
|
return PyKatanaEngine_Link(katana);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static PyObject* PyKatanaEngine_create ( PyObject*, PyObject* args )
|
|
|
|
{
|
|
|
|
cdebug_log(40,0) << "PyKatanaEngine_create()" << endl;
|
|
|
|
|
|
|
|
KatanaEngine* katana = NULL;
|
|
|
|
|
|
|
|
HTRY
|
|
|
|
PyObject* arg0;
|
|
|
|
|
|
|
|
if (not ParseOneArg("Katana.get", args, CELL_ARG, &arg0)) return NULL;
|
|
|
|
|
|
|
|
Cell* cell = PYCELL_O(arg0);
|
|
|
|
katana = KatanaEngine::get(cell);
|
|
|
|
|
|
|
|
if (katana == NULL) {
|
|
|
|
katana = KatanaEngine::create(cell);
|
|
|
|
if (cmess1.enabled())
|
|
|
|
katana->getKatanaConfiguration()->print(cell);
|
|
|
|
} else
|
|
|
|
cerr << Warning("%s already has a Katana engine.",getString(cell).c_str()) << endl;
|
|
|
|
HCATCH
|
|
|
|
|
|
|
|
return PyKatanaEngine_Link(katana);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static PyObject* PyKatanaEngine_setViewer ( PyKatanaEngine* self, PyObject* args )
|
|
|
|
{
|
|
|
|
cdebug_log(40,0) << "PyKatanaEngine_setViewer ()" << endl;
|
|
|
|
|
|
|
|
HTRY
|
|
|
|
METHOD_HEAD( "KatanaEngine.setViewer()" )
|
|
|
|
|
|
|
|
PyObject* pyViewer = NULL;
|
|
|
|
if (not PyArg_ParseTuple(args,"O:EtesianEngine.setViewer()",&pyViewer)) {
|
|
|
|
PyErr_SetString( ConstructorError, "Bad parameters given to EtesianEngine.setViewer()." );
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (IsPyCellViewer(pyViewer)) {
|
|
|
|
katana->setViewer( PYCELLVIEWER_O(pyViewer) );
|
|
|
|
}
|
|
|
|
HCATCH
|
|
|
|
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-09-06 09:27:20 -05:00
|
|
|
PyObject* PyKatanaEngine_digitalInit ( PyKatanaEngine* self )
|
|
|
|
{
|
|
|
|
cdebug_log(40,0) << "PyKatanaEngine_digitalInit()" << endl;
|
|
|
|
|
|
|
|
HTRY
|
|
|
|
METHOD_HEAD("KatanaEngine.digitalInit()")
|
|
|
|
if (katana->getViewer()) {
|
|
|
|
if (ExceptionWidget::catchAllWrapper( std::bind(&KatanaEngine::digitalInit,katana) )) {
|
|
|
|
PyErr_SetString( HurricaneError, "KatanaEngine::digitalInit() has thrown an exception (C++)." );
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
katana->digitalInit();
|
|
|
|
}
|
|
|
|
HCATCH
|
|
|
|
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-05-09 11:33:55 -05:00
|
|
|
PyObject* PyKatanaEngine_runGlobalRouter ( PyKatanaEngine* self )
|
Anabatic transient commit 18. Port of Kite (Katana), Yeah, Baby! Yeah!
* Bug: In Hurricane, in StaticObservable::getObserver(), if the slot
pointer is NULL, do not try to access the owner. Returns NULL, so
the caller can be aware of the situation...
* Change: In Hurricane, in BreakpointWidget & ExceptionWidget some
cosmetic changes (fonts and window sizes).
* Bug: In Anabatic, In AutoHorizontal::getConstraints(), take into account
the constraints from the source AutoContact, as it holds the constraints
transmitted by the RoutingPads and sets up by propageConstraintsFromRp().
It is likely to be a bug affecting the original Katabatic as well.
* Change: In Anabatic, in RawGCellsUnder(), check that the segment is not
completly oustside the cell abutment box and truncate the coordinates
to the part that is inside. Use the "shrink" if we reach the east/north
border.
* Change: In Anabatic, in Configuration, no more decorator because we will
use a true derived relationship. Katana *derives* from *Anabatic* and do
not *decorate* it, so the Configuration can do the same. It also implies
that we directly create a Katana engine, not an Anabatic one.
* Change: In Anabatic, in Session, do not allow the opening of the Session
in a standalone fashion (with a static method). Instead it must be opened
using the relevant method of the Anabatic/Katana engine. This ensure we
are opening the right Session type.
* Change: In Anabatic, in AutoSegment_Aligneds() collection the seed segment
is not part of the collection by default, but will be included if the
Flags::WithSelf is set.
* Change: In Configuration, all the flags value are now defined in two steps.
Declared in the header and initialized in the module. This is to prevent
the fact that on some cases, in relation with the Python "extern C" part
modules, we need a true allocated variable. It was causing weird linking
problems.
A side effect is that they can no longer be used as entry is switches,
have to replace them by if/else.
* New: In Anabatic, new GCell::getNeighborAt() utility function.
* Bug: In Anabatic, in GCell::doGrid(), tag all the GCells of the grid with
the grid type... Back annote all the edges capacity (north & east) with
the reserved local capacity.
* New: Complete portage of Kite over Anabatic. The new engine is christened
"Katana" for Kite-Analogic. When it's capabilities and performances
will be on a part with Kite, it is to completly replace it (and take
back the "Kite" name). Preliminary tests seems to show that, contrary
to intuition (because built on a more complex/slower grid), it is even
slightly faster than Kite 8-).
2016-08-15 09:30:13 -05:00
|
|
|
{
|
|
|
|
cdebug_log(40,0) << "PyKatanaEngine_runGlobalRouter()" << endl;
|
|
|
|
|
|
|
|
HTRY
|
|
|
|
METHOD_HEAD("KatanaEngine.runGlobalRouter()")
|
2017-05-09 11:33:55 -05:00
|
|
|
if (katana->getViewer()) {
|
|
|
|
if (ExceptionWidget::catchAllWrapper( std::bind(&KatanaEngine::runGlobalRouter,katana) )) {
|
|
|
|
PyErr_SetString( HurricaneError, "KatanaEngine::runGlobalrouter() has thrown an exception (C++)." );
|
|
|
|
return NULL;
|
Anabatic transient commit 18. Port of Kite (Katana), Yeah, Baby! Yeah!
* Bug: In Hurricane, in StaticObservable::getObserver(), if the slot
pointer is NULL, do not try to access the owner. Returns NULL, so
the caller can be aware of the situation...
* Change: In Hurricane, in BreakpointWidget & ExceptionWidget some
cosmetic changes (fonts and window sizes).
* Bug: In Anabatic, In AutoHorizontal::getConstraints(), take into account
the constraints from the source AutoContact, as it holds the constraints
transmitted by the RoutingPads and sets up by propageConstraintsFromRp().
It is likely to be a bug affecting the original Katabatic as well.
* Change: In Anabatic, in RawGCellsUnder(), check that the segment is not
completly oustside the cell abutment box and truncate the coordinates
to the part that is inside. Use the "shrink" if we reach the east/north
border.
* Change: In Anabatic, in Configuration, no more decorator because we will
use a true derived relationship. Katana *derives* from *Anabatic* and do
not *decorate* it, so the Configuration can do the same. It also implies
that we directly create a Katana engine, not an Anabatic one.
* Change: In Anabatic, in Session, do not allow the opening of the Session
in a standalone fashion (with a static method). Instead it must be opened
using the relevant method of the Anabatic/Katana engine. This ensure we
are opening the right Session type.
* Change: In Anabatic, in AutoSegment_Aligneds() collection the seed segment
is not part of the collection by default, but will be included if the
Flags::WithSelf is set.
* Change: In Configuration, all the flags value are now defined in two steps.
Declared in the header and initialized in the module. This is to prevent
the fact that on some cases, in relation with the Python "extern C" part
modules, we need a true allocated variable. It was causing weird linking
problems.
A side effect is that they can no longer be used as entry is switches,
have to replace them by if/else.
* New: In Anabatic, new GCell::getNeighborAt() utility function.
* Bug: In Anabatic, in GCell::doGrid(), tag all the GCells of the grid with
the grid type... Back annote all the edges capacity (north & east) with
the reserved local capacity.
* New: Complete portage of Kite over Anabatic. The new engine is christened
"Katana" for Kite-Analogic. When it's capabilities and performances
will be on a part with Kite, it is to completly replace it (and take
back the "Kite" name). Preliminary tests seems to show that, contrary
to intuition (because built on a more complex/slower grid), it is even
slightly faster than Kite 8-).
2016-08-15 09:30:13 -05:00
|
|
|
}
|
|
|
|
} else {
|
2017-05-09 11:33:55 -05:00
|
|
|
katana->runGlobalRouter();
|
Anabatic transient commit 18. Port of Kite (Katana), Yeah, Baby! Yeah!
* Bug: In Hurricane, in StaticObservable::getObserver(), if the slot
pointer is NULL, do not try to access the owner. Returns NULL, so
the caller can be aware of the situation...
* Change: In Hurricane, in BreakpointWidget & ExceptionWidget some
cosmetic changes (fonts and window sizes).
* Bug: In Anabatic, In AutoHorizontal::getConstraints(), take into account
the constraints from the source AutoContact, as it holds the constraints
transmitted by the RoutingPads and sets up by propageConstraintsFromRp().
It is likely to be a bug affecting the original Katabatic as well.
* Change: In Anabatic, in RawGCellsUnder(), check that the segment is not
completly oustside the cell abutment box and truncate the coordinates
to the part that is inside. Use the "shrink" if we reach the east/north
border.
* Change: In Anabatic, in Configuration, no more decorator because we will
use a true derived relationship. Katana *derives* from *Anabatic* and do
not *decorate* it, so the Configuration can do the same. It also implies
that we directly create a Katana engine, not an Anabatic one.
* Change: In Anabatic, in Session, do not allow the opening of the Session
in a standalone fashion (with a static method). Instead it must be opened
using the relevant method of the Anabatic/Katana engine. This ensure we
are opening the right Session type.
* Change: In Anabatic, in AutoSegment_Aligneds() collection the seed segment
is not part of the collection by default, but will be included if the
Flags::WithSelf is set.
* Change: In Configuration, all the flags value are now defined in two steps.
Declared in the header and initialized in the module. This is to prevent
the fact that on some cases, in relation with the Python "extern C" part
modules, we need a true allocated variable. It was causing weird linking
problems.
A side effect is that they can no longer be used as entry is switches,
have to replace them by if/else.
* New: In Anabatic, new GCell::getNeighborAt() utility function.
* Bug: In Anabatic, in GCell::doGrid(), tag all the GCells of the grid with
the grid type... Back annote all the edges capacity (north & east) with
the reserved local capacity.
* New: Complete portage of Kite over Anabatic. The new engine is christened
"Katana" for Kite-Analogic. When it's capabilities and performances
will be on a part with Kite, it is to completly replace it (and take
back the "Kite" name). Preliminary tests seems to show that, contrary
to intuition (because built on a more complex/slower grid), it is even
slightly faster than Kite 8-).
2016-08-15 09:30:13 -05:00
|
|
|
}
|
|
|
|
HCATCH
|
|
|
|
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-08-27 09:02:22 -05:00
|
|
|
PyObject* PyKatanaEngine_loadGlobalRouting ( PyKatanaEngine* self, PyObject* args )
|
|
|
|
{
|
|
|
|
cdebug_log(40,0) << "PyKatanaEngine_loadGlobalRouting()" << endl;
|
|
|
|
|
|
|
|
HTRY
|
|
|
|
METHOD_HEAD("KatanaEngine.loadGlobalRouting()")
|
|
|
|
unsigned int flags = 0;
|
|
|
|
if (PyArg_ParseTuple(args,"I:KatanaEngine.loadGlobalRouting", &flags)) {
|
|
|
|
if (katana->getViewer()) {
|
|
|
|
if (ExceptionWidget::catchAllWrapper( std::bind(&KatanaEngine::loadGlobalRouting,katana,flags) )) {
|
|
|
|
PyErr_SetString( HurricaneError, "KatanaEngine::loadGlobalrouting() has thrown an exception (C++)." );
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
katana->loadGlobalRouting(flags);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
PyErr_SetString(ConstructorError, "KatanaEngine.loadGlobalRouting(): Invalid number/bad type of parameter.");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
HCATCH
|
|
|
|
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
Anabatic transient commit 18. Port of Kite (Katana), Yeah, Baby! Yeah!
* Bug: In Hurricane, in StaticObservable::getObserver(), if the slot
pointer is NULL, do not try to access the owner. Returns NULL, so
the caller can be aware of the situation...
* Change: In Hurricane, in BreakpointWidget & ExceptionWidget some
cosmetic changes (fonts and window sizes).
* Bug: In Anabatic, In AutoHorizontal::getConstraints(), take into account
the constraints from the source AutoContact, as it holds the constraints
transmitted by the RoutingPads and sets up by propageConstraintsFromRp().
It is likely to be a bug affecting the original Katabatic as well.
* Change: In Anabatic, in RawGCellsUnder(), check that the segment is not
completly oustside the cell abutment box and truncate the coordinates
to the part that is inside. Use the "shrink" if we reach the east/north
border.
* Change: In Anabatic, in Configuration, no more decorator because we will
use a true derived relationship. Katana *derives* from *Anabatic* and do
not *decorate* it, so the Configuration can do the same. It also implies
that we directly create a Katana engine, not an Anabatic one.
* Change: In Anabatic, in Session, do not allow the opening of the Session
in a standalone fashion (with a static method). Instead it must be opened
using the relevant method of the Anabatic/Katana engine. This ensure we
are opening the right Session type.
* Change: In Anabatic, in AutoSegment_Aligneds() collection the seed segment
is not part of the collection by default, but will be included if the
Flags::WithSelf is set.
* Change: In Configuration, all the flags value are now defined in two steps.
Declared in the header and initialized in the module. This is to prevent
the fact that on some cases, in relation with the Python "extern C" part
modules, we need a true allocated variable. It was causing weird linking
problems.
A side effect is that they can no longer be used as entry is switches,
have to replace them by if/else.
* New: In Anabatic, new GCell::getNeighborAt() utility function.
* Bug: In Anabatic, in GCell::doGrid(), tag all the GCells of the grid with
the grid type... Back annote all the edges capacity (north & east) with
the reserved local capacity.
* New: Complete portage of Kite over Anabatic. The new engine is christened
"Katana" for Kite-Analogic. When it's capabilities and performances
will be on a part with Kite, it is to completly replace it (and take
back the "Kite" name). Preliminary tests seems to show that, contrary
to intuition (because built on a more complex/slower grid), it is even
slightly faster than Kite 8-).
2016-08-15 09:30:13 -05:00
|
|
|
PyObject* PyKatanaEngine_layerAssign ( PyKatanaEngine* self, PyObject* args )
|
|
|
|
{
|
|
|
|
cdebug_log(40,0) << "PyKatanaEngine_layerAssign()" << endl;
|
|
|
|
|
|
|
|
HTRY
|
|
|
|
METHOD_HEAD("KatanaEngine.layerAssign()")
|
|
|
|
unsigned int flags = 0;
|
|
|
|
if (PyArg_ParseTuple(args,"I:KatanaEngine.layerAssign", &flags)) {
|
|
|
|
|
|
|
|
if (katana->getViewer()) {
|
|
|
|
bool failure = false;
|
|
|
|
//= ExceptionWidget::catchAllWrapper( std::bind(&KatanaEngine::balanceGlobalDensity,katana) );
|
|
|
|
if (not failure)
|
|
|
|
failure = ExceptionWidget::catchAllWrapper( std::bind(&KatanaEngine::layerAssign,katana,flags) );
|
|
|
|
|
|
|
|
if (failure) {
|
|
|
|
PyErr_SetString( HurricaneError, "EtesianEngine::place() has thrown an exception (C++)." );
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
//katana->balanceGlobalDensity();
|
|
|
|
katana->layerAssign (flags);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
PyErr_SetString(ConstructorError, "KatanaEngine.layerAssign(): Invalid number/bad type of parameter.");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
HCATCH
|
|
|
|
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static PyObject* PyKatanaEngine_runNegociatePreRouted ( PyKatanaEngine* self )
|
|
|
|
{
|
|
|
|
cdebug_log(40,0) << "PyKatanaEngine_runNegociatePreRouted()" << endl;
|
|
|
|
HTRY
|
|
|
|
METHOD_HEAD("KatanaEngine.runNegociatePreRouted()")
|
|
|
|
if (katana->getViewer()) {
|
|
|
|
if (ExceptionWidget::catchAllWrapper( std::bind(&KatanaEngine::runNegociate,katana,Flags::PreRoutedStage) )) {
|
|
|
|
PyErr_SetString( HurricaneError, "KatanaEngine::runNegociatePreRouted() has thrown an exception (C++)." );
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
katana->runNegociate( Flags::PreRoutedStage );
|
|
|
|
}
|
|
|
|
HCATCH
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static PyObject* PyKatanaEngine_runNegociate ( PyKatanaEngine* self )
|
|
|
|
{
|
|
|
|
cdebug_log(40,0) << "PyKatanaEngine_runNegociate()" << endl;
|
|
|
|
HTRY
|
|
|
|
METHOD_HEAD("KatanaEngine.runNegociate()")
|
|
|
|
if (katana->getViewer()) {
|
|
|
|
if (ExceptionWidget::catchAllWrapper( std::bind(&KatanaEngine::runNegociate,katana,0) )) {
|
|
|
|
PyErr_SetString( HurricaneError, "EtesianEngine::runNegociate() has thrown an exception (C++)." );
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
katana->runNegociate();
|
|
|
|
}
|
|
|
|
HCATCH
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Standart Accessors (Attributes).
|
|
|
|
DirectVoidToolMethod(KatanaEngine,katana,printConfiguration)
|
|
|
|
DirectVoidToolMethod(KatanaEngine,katana,finalizeLayout)
|
|
|
|
DirectVoidMethod(KatanaEngine,katana,dumpMeasures)
|
|
|
|
DirectGetBoolAttribute(PyKatanaEngine_getToolSuccess,getToolSuccess,PyKatanaEngine,KatanaEngine)
|
|
|
|
|
|
|
|
// Standart Destroy (Attribute).
|
|
|
|
DBoDestroyAttribute(PyKatanaEngine_destroy,PyKatanaEngine)
|
|
|
|
|
|
|
|
|
|
|
|
PyMethodDef PyKatanaEngine_Methods[] =
|
|
|
|
{ { "get" , (PyCFunction)PyKatanaEngine_get , METH_VARARGS|METH_STATIC
|
|
|
|
, "Returns the Katana engine attached to the Cell, None if there isnt't." }
|
|
|
|
, { "create" , (PyCFunction)PyKatanaEngine_create , METH_VARARGS|METH_STATIC
|
|
|
|
, "Create a Katana engine on this cell." }
|
|
|
|
, { "setViewer" , (PyCFunction)PyKatanaEngine_setViewer , METH_VARARGS
|
|
|
|
, "Associate a Viewer to this KatanaEngine." }
|
2016-09-06 09:27:20 -05:00
|
|
|
, { "digitalInit" , (PyCFunction)PyKatanaEngine_digitalInit , METH_NOARGS
|
|
|
|
, "Setup Katana for digital routing." }
|
Anabatic transient commit 18. Port of Kite (Katana), Yeah, Baby! Yeah!
* Bug: In Hurricane, in StaticObservable::getObserver(), if the slot
pointer is NULL, do not try to access the owner. Returns NULL, so
the caller can be aware of the situation...
* Change: In Hurricane, in BreakpointWidget & ExceptionWidget some
cosmetic changes (fonts and window sizes).
* Bug: In Anabatic, In AutoHorizontal::getConstraints(), take into account
the constraints from the source AutoContact, as it holds the constraints
transmitted by the RoutingPads and sets up by propageConstraintsFromRp().
It is likely to be a bug affecting the original Katabatic as well.
* Change: In Anabatic, in RawGCellsUnder(), check that the segment is not
completly oustside the cell abutment box and truncate the coordinates
to the part that is inside. Use the "shrink" if we reach the east/north
border.
* Change: In Anabatic, in Configuration, no more decorator because we will
use a true derived relationship. Katana *derives* from *Anabatic* and do
not *decorate* it, so the Configuration can do the same. It also implies
that we directly create a Katana engine, not an Anabatic one.
* Change: In Anabatic, in Session, do not allow the opening of the Session
in a standalone fashion (with a static method). Instead it must be opened
using the relevant method of the Anabatic/Katana engine. This ensure we
are opening the right Session type.
* Change: In Anabatic, in AutoSegment_Aligneds() collection the seed segment
is not part of the collection by default, but will be included if the
Flags::WithSelf is set.
* Change: In Configuration, all the flags value are now defined in two steps.
Declared in the header and initialized in the module. This is to prevent
the fact that on some cases, in relation with the Python "extern C" part
modules, we need a true allocated variable. It was causing weird linking
problems.
A side effect is that they can no longer be used as entry is switches,
have to replace them by if/else.
* New: In Anabatic, new GCell::getNeighborAt() utility function.
* Bug: In Anabatic, in GCell::doGrid(), tag all the GCells of the grid with
the grid type... Back annote all the edges capacity (north & east) with
the reserved local capacity.
* New: Complete portage of Kite over Anabatic. The new engine is christened
"Katana" for Kite-Analogic. When it's capabilities and performances
will be on a part with Kite, it is to completly replace it (and take
back the "Kite" name). Preliminary tests seems to show that, contrary
to intuition (because built on a more complex/slower grid), it is even
slightly faster than Kite 8-).
2016-08-15 09:30:13 -05:00
|
|
|
, { "printConfiguration" , (PyCFunction)PyKatanaEngine_printConfiguration , METH_NOARGS
|
|
|
|
, "Display on the console the configuration of Katana." }
|
|
|
|
, { "getToolSuccess" , (PyCFunction)PyKatanaEngine_getToolSuccess , METH_NOARGS
|
|
|
|
, "Returns True if the detailed routing has been successful." }
|
2017-05-09 11:33:55 -05:00
|
|
|
, { "runGlobalRouter" , (PyCFunction)PyKatanaEngine_runGlobalRouter , METH_NOARGS
|
2016-09-10 11:49:48 -05:00
|
|
|
, "Run the global router (Katana)." }
|
2016-08-27 09:02:22 -05:00
|
|
|
, { "loadGlobalRouting" , (PyCFunction)PyKatanaEngine_loadGlobalRouting , METH_VARARGS
|
|
|
|
, "Load global routing into the detailed router." }
|
Anabatic transient commit 18. Port of Kite (Katana), Yeah, Baby! Yeah!
* Bug: In Hurricane, in StaticObservable::getObserver(), if the slot
pointer is NULL, do not try to access the owner. Returns NULL, so
the caller can be aware of the situation...
* Change: In Hurricane, in BreakpointWidget & ExceptionWidget some
cosmetic changes (fonts and window sizes).
* Bug: In Anabatic, In AutoHorizontal::getConstraints(), take into account
the constraints from the source AutoContact, as it holds the constraints
transmitted by the RoutingPads and sets up by propageConstraintsFromRp().
It is likely to be a bug affecting the original Katabatic as well.
* Change: In Anabatic, in RawGCellsUnder(), check that the segment is not
completly oustside the cell abutment box and truncate the coordinates
to the part that is inside. Use the "shrink" if we reach the east/north
border.
* Change: In Anabatic, in Configuration, no more decorator because we will
use a true derived relationship. Katana *derives* from *Anabatic* and do
not *decorate* it, so the Configuration can do the same. It also implies
that we directly create a Katana engine, not an Anabatic one.
* Change: In Anabatic, in Session, do not allow the opening of the Session
in a standalone fashion (with a static method). Instead it must be opened
using the relevant method of the Anabatic/Katana engine. This ensure we
are opening the right Session type.
* Change: In Anabatic, in AutoSegment_Aligneds() collection the seed segment
is not part of the collection by default, but will be included if the
Flags::WithSelf is set.
* Change: In Configuration, all the flags value are now defined in two steps.
Declared in the header and initialized in the module. This is to prevent
the fact that on some cases, in relation with the Python "extern C" part
modules, we need a true allocated variable. It was causing weird linking
problems.
A side effect is that they can no longer be used as entry is switches,
have to replace them by if/else.
* New: In Anabatic, new GCell::getNeighborAt() utility function.
* Bug: In Anabatic, in GCell::doGrid(), tag all the GCells of the grid with
the grid type... Back annote all the edges capacity (north & east) with
the reserved local capacity.
* New: Complete portage of Kite over Anabatic. The new engine is christened
"Katana" for Kite-Analogic. When it's capabilities and performances
will be on a part with Kite, it is to completly replace it (and take
back the "Kite" name). Preliminary tests seems to show that, contrary
to intuition (because built on a more complex/slower grid), it is even
slightly faster than Kite 8-).
2016-08-15 09:30:13 -05:00
|
|
|
, { "layerAssign" , (PyCFunction)PyKatanaEngine_layerAssign , METH_VARARGS
|
|
|
|
, "Run the layer assigment stage." }
|
|
|
|
, { "runNegociatePreRouted", (PyCFunction)PyKatanaEngine_runNegociatePreRouted, METH_NOARGS
|
|
|
|
, "Run the negociation stage for pre-routed of the detailed router." }
|
|
|
|
, { "runNegociate" , (PyCFunction)PyKatanaEngine_runNegociate , METH_NOARGS
|
|
|
|
, "Run the negociation stage of the detailed router." }
|
|
|
|
, { "finalizeLayout" , (PyCFunction)PyKatanaEngine_finalizeLayout , METH_NOARGS
|
|
|
|
, "Revert to a pure Hurricane database, remove router's additionnal data structures." }
|
|
|
|
, { "dumpMeasures" , (PyCFunction)PyKatanaEngine_dumpMeasures , METH_NOARGS
|
|
|
|
, "Dump to disk lots of statistical informations about the routing." }
|
|
|
|
, { "destroy" , (PyCFunction)PyKatanaEngine_destroy , METH_NOARGS
|
|
|
|
, "Destroy the associated hurricane object. The python object remains." }
|
|
|
|
, {NULL, NULL, 0, NULL} /* sentinel */
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
DBoDeleteMethod(KatanaEngine)
|
|
|
|
PyTypeObjectLinkPyType(KatanaEngine)
|
|
|
|
|
|
|
|
|
|
|
|
#else // End of Python Module Code Part.
|
|
|
|
|
|
|
|
|
|
|
|
// +=================================================================+
|
|
|
|
// | "PyKatanaEngine" Shared Library Code Part |
|
|
|
|
// +=================================================================+
|
|
|
|
|
|
|
|
|
|
|
|
// Link/Creation Method.
|
|
|
|
PyTypeInheritedObjectDefinitions(KatanaEngine,PyToolEngine)
|
|
|
|
DBoLinkCreateMethod(KatanaEngine)
|
|
|
|
|
|
|
|
|
|
|
|
#endif // Shared Library Code Part.
|
|
|
|
|
|
|
|
} // extern "C".
|
|
|
|
|
|
|
|
} // Katana namespace.
|
|
|
|
|