coriolis/kite/doc/NegociateWindow.dox

97 lines
4.2 KiB
Plaintext
Raw Normal View History

2013-12-03 20:51:02 -06:00
// -*- 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.
}