218 lines
11 KiB
C++
218 lines
11 KiB
C++
// -*- C++ -*-
|
|
|
|
|
|
namespace Kite {
|
|
|
|
/*! \class DataNegociate
|
|
* \brief Algorimthmic datas associated the TrackSegment
|
|
*
|
|
* The DataNegociate object contains all the informations the negociation
|
|
* algorithm needs to know about a TrackSegment. Those informations
|
|
* mostly describe the slackening and ripup state of that segment.
|
|
*
|
|
* <b>State related datas:</b>
|
|
* - The ripup count in the current state. The count is reset
|
|
* to zero at each state transition.
|
|
* - The slackening state (see DataNegociate::SlackState). The state
|
|
* indicate the \b next topological modification to be applied on
|
|
* the segment should the ripup count reach it's maximal value.
|
|
* - The associated RoutingEvent. If no RoutingEvent is present, it
|
|
* means the segment has been either successufully placed or the
|
|
* algorithm has given up trying to. If present, it is a \e pending
|
|
* request for placement.
|
|
*
|
|
* <b>Topological related datas:</b>
|
|
* - \c leftMinExtend, the potential minimal position of the segment
|
|
* left extension. May not be reachable due to other topological
|
|
* constraints.
|
|
* - \c rightMinExtend, the potential minimal position of the segment
|
|
* right extension.
|
|
* - \c terminals, the number of terminals attached to this segment.
|
|
* - \c attractors, a table of coordinates of the end points of the
|
|
* perpandiculars to this segment. Used to compute the wiring delta
|
|
* if we move the axis of the segment.
|
|
* - \c perpandiculars, a \c vector of the perpandicular TrackElement.
|
|
* This is a fast-access cache. It must be updated each time the
|
|
* topology of the net is modificated.
|
|
* - \c perpandicularFree, the free interval defined by the perpandiculars,
|
|
* that is for the sgement axis.
|
|
*
|
|
*
|
|
* \section secAttractorsComputation Perpandiculars, Free, Attractors & Wiring Delta
|
|
*
|
|
* All those informations are computed and updated by the
|
|
* DataNegociate::update() method, which relies on:
|
|
* - AutoSegment::getTopologicalInfos()
|
|
* - AutoSegment::getTerminalCount()
|
|
*
|
|
* \red{They must be reviewed as they do not take advantage of the new}
|
|
* \red{AutoSegment structuration.}
|
|
*
|
|
* For every perpandicular set of AutoSegment to the TrackSegment
|
|
* we want to place, get the coordinates of the extremity not connected
|
|
* to the segment and put that coordinate into a table associated with
|
|
* it's \e spin. The \e spin tells if the extremity is attracting the
|
|
* segment \e up or \e down (for an horizontal segment). The \e spin
|
|
* is incremented for up and decremented for down. After all the
|
|
* extremities have been processeds, we took into account only the
|
|
* coordinates with a non-zero spin, which means they truly attract
|
|
* the segment (whatever the direction).
|
|
*
|
|
* \image html DataNegociate-1.png "Fig 1: Attractors Computation"
|
|
*
|
|
* The <em>wiring delta</em> is the total wire length needed to connect
|
|
* from the attractors to the segment, should it be placed on \c axis.
|
|
*
|
|
* \image html DataNegociate-2.png "Fig 2: Wiring Delta"
|
|
*
|
|
*
|
|
* \section secDataNegociateModifications Modifications History
|
|
*
|
|
* Main changes in DataNegociate class design:
|
|
* - Merge in the separate class \c Cost.
|
|
* - Suppress the \c SlackState::Desalignate, due to the simplificated
|
|
* structure of the AutoSegment/AutoContacts (no more collapseds, or
|
|
* forced alignements).
|
|
*/
|
|
|
|
//! \enum DataNegociate::SlackState
|
|
//! Describe the various stages of a TrackSegment slackening.
|
|
//! The numerical values are choosen so we can increment them
|
|
//! as a counter.
|
|
|
|
//! \var DataNegociate::RipupPerpandiculars
|
|
//! Force perpandiculars to be riped up as well as the TrackSegment,
|
|
//! then schedule the placement of the TrackSegment \e before it's perpandiculars.
|
|
|
|
// \var DataNegociate::Desalignate
|
|
//! If the TrackSegment is made of multiple TrackSegments with a forced
|
|
//! alignement, suppress the alignement constraint.
|
|
//!
|
|
//! \red{This should be deprecated now}.
|
|
|
|
//! \var DataNegociate::Minimize
|
|
//! Try to displace the perpandiculars so the TrackSegment is
|
|
//! reduced to it's minimal length.
|
|
|
|
//! \var DataNegociate::Dogleg
|
|
//! Break the segment into two smaller ones.
|
|
|
|
//! \var DataNegociate::Slacken
|
|
//! Create additional wiring so threre is no more contraints transmitted
|
|
//! by the perpandiculars or the terminal contacts.
|
|
|
|
//! \var DataNegociate::ConflictSolveByHistory
|
|
//! Try to solve a conflict between a set of global segments by
|
|
//! analysing the event/ripup history. See SegmentFsm::conflictSolveByHistory().
|
|
|
|
//! \var DataNegociate::ConflictSolveByPlaceds
|
|
//! Try to solve a conflict between a set of global segments by
|
|
//! analysing the current track context. See SegmentFsm::conflictSolveByPlaceds().
|
|
|
|
//! \var DataNegociate::LocalVsGlobal
|
|
//! \red{To be reviewed}.
|
|
|
|
//! \var DataNegociate::MoveUp
|
|
//! The segment is to be moved up (if possible).
|
|
|
|
//! \var DataNegociate::MaximumSlack
|
|
//! The final state, topological modifications are exhausteds, if it
|
|
//! cannot place at this point, it never will.
|
|
|
|
//! \var DataNegociate::Unimplemented
|
|
//! Used only during the development stage, telling that the state is
|
|
//! not available yet.
|
|
|
|
//! \var DataNegociate::Repair
|
|
//! The router is in repair mode.
|
|
|
|
//! \function bool DataNegociate::hasRoutingEvent () const;
|
|
//! \sreturn \true if there is a pending RoutingEvent for this TrackSegment.
|
|
|
|
//! \function RoutingEvent* DataNegociate::getRoutingEvent () const;
|
|
//! \sreturn The pending RoutingEvent. \c NULL will be returned if there is no
|
|
//! pending event, meaning that the segment has been placed.
|
|
|
|
//! \function TrackSegment* DataNegociate::getTrackSegment () const;
|
|
//! \sreturn The associated TrackSegment.
|
|
|
|
//! \function Track* DataNegociate::getTrack () const;
|
|
//! \sreturn A proxy accessor for the segment's track.
|
|
|
|
//! \function DbU::Unit DataNegociate::getLeftMinExtend () const;
|
|
//! \sreturn The minimum extend possible of the segment's source (left) ending.
|
|
//! Computed by DataNegociate::update().
|
|
|
|
//! \function DbU::Unit DataNegociate::getRightMinExtend () const;
|
|
//! \sreturn The minimum extend possible of the segment's target (right) ending.
|
|
//! Computed by DataNegociate::update().
|
|
|
|
//! \function unsigned int DataNegociate::getTerminals () const;
|
|
//! \sreturn The number of terminal to which this segment is connected
|
|
//! Computed by DataNegociate::update().
|
|
//!
|
|
//! \red{Must be refined: direct or indirect?}.
|
|
|
|
//! \function Net* DataNegociate::getNet () const;
|
|
//! \sreturn A cached accessor to the segment's net (for faster access).
|
|
|
|
//! \function unsigned int DataNegociate::getState () const;
|
|
//! \sreturn The current state (see DataNegociate::SlackState).
|
|
|
|
//! \function unsigned int DataNegociate::getStateCount () const;
|
|
//! \sreturn The number of times we have reached the ripup limit while in
|
|
//! this stage.
|
|
|
|
//! \function unsigned int DataNegociate::getRipupCount () const;
|
|
//! \sreturn The number of times the segment has been riped up in this stage.
|
|
|
|
//! \function unsigned int DataNegociate::getStateAndRipupCount () const;
|
|
//! \return A composite number combining the state and the ripup count:
|
|
//! <code>(state<<4)+ripup</code>.
|
|
|
|
//! \function DbU::Unit DataNegociate::getWiringDelta ( DbU::Unit axis ) const;
|
|
//! \sreturn The wiring length needed to connect to the attractors if the segment
|
|
//! is put on \c axis. The lower, the better...
|
|
|
|
//! \function const Interval& DataNegociate::getPerpandicularFree () const;
|
|
//! \sreturn The range of legal positions generated only by the perpandiculars.
|
|
|
|
//! \function void DataNegociate::setState ( unsigned int state, unsigned int flags=0 );
|
|
//! Set or reset the slacking state (see SlackState). If the \c state is the
|
|
//! same as the current one, the state count is incremented. If the new state
|
|
//! changes or \c flags contain KtReset, the state count is reset to one.
|
|
|
|
//! \function void DataNegociate::setRoutingEvent ( RoutingEvent* event );
|
|
//! Associate \c event to this TrackSegment.
|
|
|
|
//! \function void DataNegociate::setRipupCount ( unsigned int count );
|
|
//! Directly sets the ripup count to \c count.
|
|
|
|
//! \function void DataNegociate::incRipupCount ();
|
|
//! Increment the ripup count. No check is performed for bound limit.
|
|
|
|
//! \function void DataNegociate::decRipupCount ();
|
|
//! Decrement the ripup count (will never go below zero).
|
|
|
|
//! \function void DataNegociate::resetRipupCount ();
|
|
//! Reset the ripup count to zero.
|
|
|
|
//! \function void DataNegociate::resetStateCount ();
|
|
//! Reset the state count to zero.
|
|
|
|
// \function void DataNegociate::invalidate ( unsigned int flags=0 );
|
|
// Invalidate the associated RoutingEvent.
|
|
//
|
|
// Possible values for \c flags :
|
|
// - Kite::KtWithPerpands
|
|
// - Kite::KtWithConstraints
|
|
|
|
//! \function void DataNegociate::update ();
|
|
//! Recompute \c leftMinExtend, \c righMinExtend, number of terminals and
|
|
//! attractors positions.
|
|
//!
|
|
//! \remark The constructor do not calls it. It is to the algorithm responsability
|
|
//! to call it before using the computed datas.
|
|
|
|
}
|