97 lines
4.2 KiB
C++
97 lines
4.2 KiB
C++
|
|
// -*- C++ -*-
|
|
|
|
namespace Kite {
|
|
|
|
/*! \class NegociateWindow
|
|
* \brief Perform the routing, main RoutingEvent manager.
|
|
*
|
|
* This object perform the routing. That is creates all the
|
|
* initial RoutingEvent, load them into the queue and then
|
|
* process the queue until it is empty, that is, the routing
|
|
* is finished.
|
|
*
|
|
* This object is the owner of the RoutingEventQueue,
|
|
* RoutingEventHistory and RoutingEventLoop used all troughout
|
|
* RoutingEvent and SegmentFsm.
|
|
*/
|
|
|
|
//! \enum NegociateWindow::Stage
|
|
//! The state under which the router is operating.
|
|
|
|
//! \var NegociateWindow::Negociation
|
|
//! The normal mode, priority negociation with ripup.
|
|
|
|
//! \var NegociateWindow::Packing
|
|
//! Try to find a better placement for segment but just by
|
|
//! looking for other fully free spaces. No ripup is performed.
|
|
|
|
|
|
//! \function NegociateWindow::create ( KiteEngine* kite );
|
|
//! The publicly avalaible contructor. Route the whole are defined
|
|
//! by the Kite associated Cell abutment box.
|
|
|
|
//! \function void NegociateWindow::destroy ();
|
|
//! The publicly avalaible destructor.
|
|
|
|
//! \function bool NegociateWindow::isInterrupted () const;
|
|
//! \sreturn \true if the NegociateWindow has received an interrupt request.
|
|
|
|
//! \function KiteEngine* NegociateWindow::getKiteEngine () const;
|
|
//! \sreturn The associated KiteEngine.
|
|
|
|
//! \function Hurricane::Cell* NegociateWindow::getCell () const;
|
|
//! \sreturn The associated Cell.
|
|
|
|
//! \function const Katabatic::GCellVector& NegociateWindow::getGCells () const;
|
|
//! \sreturn A Copy of the vector of GCell from KatabaticEngine. The vector
|
|
//! is copied but not the GCell themselves (shallow copy).
|
|
|
|
//! \function RoutingEventQueue& NegociateWindow::getEventQueue ();
|
|
//! \sreturn The RoutingEventQueue.
|
|
|
|
//! \function RoutingEventHistory& NegociateWindow::getEventHistory ();
|
|
//! \sreturn The RoutingEventHistory.
|
|
|
|
//! \function RoutingEventLoop& NegociateWindow::getEventLoop ();
|
|
//! \sreturn The RoutingEventLoop.
|
|
|
|
//! \function Stage NegociateWindow::getStage () const;
|
|
//! \sreturn The stage (NegicateWindow::Stage) into which the NegociateWindow is running.
|
|
|
|
//! \function void NegociateWindow::setGCells ( const Katabatic::GCellVector& v );
|
|
//! Sets the GCell vector from KatabaticEngine (perform a shallow copy).
|
|
|
|
//! \function void NegociateWindow::setInterrupt ( bool state );
|
|
//! Sets or unset the interruption flag.
|
|
|
|
//! \function void NegociateWindow::setStage ( Stage stage );
|
|
//! Set the stage (NegociateWindow::Stage) under which we are running.
|
|
|
|
//! \function double NegociateWindow::computeWirelength ();
|
|
//! Compute the total wirelength of the circuit. It is not completly
|
|
//! accurate because overlaps are not took into accounts.
|
|
|
|
//! \function TrackElement* NegociateWindow::createTrackSegment ( AutoSegment*, unsigned int flags );
|
|
//! Build a TrackSegment from the Katabatic::AutoSegment. If \c flags contains
|
|
//! Kite::KtLoadingStage then assume that we are in the initial loading stage
|
|
//! (constructor).
|
|
|
|
//! \function void NegociateWindow::addRoutingEvent ( TrackElement*, unsigned int level );
|
|
//! Create a new RoutingEvent from TrackElement (if it doesn't already exists)
|
|
//! and insert it into the queue with priority \c level.
|
|
|
|
//! \function void NegociateWindow::rescheduleEvent ( RoutingEvent*, unsigned int level );
|
|
//! Reschedule an event into the queue, with priority \c level.
|
|
|
|
//! \function void NegociateWindow::run ( int slowMotion=0 );
|
|
//! Perform the routing.
|
|
//!
|
|
//! \red{\c slowMotion is not implemented yet.}
|
|
|
|
//! \function void NegociateWindow::printStatistics () const
|
|
//! Display some statistics about the routing, compute the internal
|
|
//! complete statistics.
|
|
|
|
}
|