131 lines
4.8 KiB
C++
131 lines
4.8 KiB
C++
|
|
// -*- C++ -*-
|
|
|
|
|
|
namespace Kite {
|
|
|
|
/*! \class TrackCost
|
|
* \brief Insertion cost of a \TrackSegment in a \Track.
|
|
*
|
|
*
|
|
* The \TrackCost is not computed by itself. It has to be build by
|
|
* whoever has created it. For example Track::getOverlapCost().
|
|
*
|
|
*
|
|
* \section secTrackCostOrdering Sorting Track costs
|
|
*
|
|
* The \TrackCost is composed of the following criterions :
|
|
* <ol>
|
|
* <li>boolean \c _infinite : infinite.
|
|
* <li>count \c _terminals : number of terminals.
|
|
* <li>length \c _delta : overlap between requested interval and
|
|
* \TrackSegment of the \Track.
|
|
* <li>length \c _deltaPerpand : length of perpandicular wiring needed to
|
|
* connect to this \Track.
|
|
* </ol>
|
|
* Criterions are listed above in decreasing lexicographical weigh order.
|
|
*
|
|
* There is also special partial ordering functor : TrackCost::CompareByDelta.
|
|
*/
|
|
|
|
/*! \function TrackCost::TrackCost ( Track* track, const Interval& interval, size_t begin, size_t end );
|
|
* \param track The track on which the cost is performed.
|
|
* \param interval The interval for which we want a cost.
|
|
* \param begin The index of the first overlaping \TrackSegment in the \Track.
|
|
* \param end The index of the last overlaping \TrackSegment in the \Track.
|
|
*
|
|
* Create a \TrackCost object. Constructor parameters cannot be changed
|
|
* after creation.
|
|
*
|
|
* \remark The cost is not computed by the constructor. It is computed afterward
|
|
* by any flavor of Track::getOverlapCost().
|
|
*/
|
|
|
|
/*! \function bool TrackCost::isInfinite () const;
|
|
* \Return The overlap include a \TrackSegment from a \GCellRoutingSet of
|
|
* higher priority, must'nt be overlaped.
|
|
*/
|
|
|
|
/*! \function bool TrackCost::isHardOverlap () const;
|
|
* \Return The overlaped \TrackSegment cannot be shrunk to create a sufficent
|
|
* free space. See the bound interval of \TrackSegmentCost.
|
|
*/
|
|
|
|
/*! \function bool TrackCost::isOverlap () const;
|
|
* \Return The overlaped \TrackSegment could be shrunk to create a suitable
|
|
* free space.
|
|
*/
|
|
|
|
/*! \function bool TrackCost::isFree () const;
|
|
* \Return There is enough free space to insert the \TrackSegment.
|
|
*/
|
|
|
|
/*! \function Track* TrackCost::getTrack () const;
|
|
* \Return The associated \Track.
|
|
*/
|
|
|
|
/*! \function const Interval& TrackCost::getInterval () const;
|
|
* \Return The interval for which we want to compute a cost.
|
|
*/
|
|
|
|
/*! \function size_t TrackCost::getBegin () const;
|
|
* \Return The index of the first overlaping \TrackSegment in \Track.
|
|
*/
|
|
|
|
/*! \function size_t TrackCost::getEnd () const;
|
|
* \Return The index of the last overlaping \TrackSegment in \Track.
|
|
*/
|
|
|
|
/*! \function unsigned int TrackCost::getTerminals () const;
|
|
* \Return The number of terminal in the interval, see TrackSegmentCost::getTerminals().
|
|
*/
|
|
|
|
/*! \function DbU::Unit TrackCost::getDelta () const;
|
|
* \Return The amount of overlaping between the interval and the \TrackSegments
|
|
* already in the \Track.
|
|
*/
|
|
|
|
/*! \function DbU::Unit TrackCost::getDeltaPerpand () const;
|
|
* \Return The amount of perpandicular wirelength needed to put the to be
|
|
* inserted \TrackSegment in this \Track.
|
|
*/
|
|
|
|
/*! \function void TrackCost::setInfinite ();
|
|
* Raise the infinite flag.
|
|
*/
|
|
|
|
/*! \function void TrackCost::setHardOverlap ();
|
|
* Raise the hard overlap flag.
|
|
*/
|
|
|
|
/*! \function void TrackCost::setOverlap ();
|
|
* Raise the soft overlap flag.
|
|
*/
|
|
|
|
/*! \function void TrackCost::incTerminals ( unsigned int number );
|
|
* \param number The number of terminal to adds.
|
|
*/
|
|
|
|
/*! \function void TrackCost::incDelta ( DbU::Unit delta );
|
|
* \param delta The amount of length to add to the overlap.
|
|
*/
|
|
|
|
/*! \function void TrackCost::incDeltaPerpand ( DbU::Unit delta );
|
|
* \param delta Increments the perpandicular delta.
|
|
*/
|
|
|
|
/*! \function bool operator< ( const TrackCost& lhs, const TrackCost& rhs );
|
|
* \param lhs the left hand side operand.
|
|
* \param rhs the right hand side operand.
|
|
* \return \true if <code>lhs < rhs</code>, see \ref secTrackCostOrdering.
|
|
*/
|
|
|
|
|
|
/*! \class TrackCost::CompareByDelta
|
|
* \brief Partial compare function for \TrackCost.
|
|
*
|
|
* Allow \TrackCost sorting on the \c _delta criterion alone.
|
|
*/
|
|
|
|
} // End of Kite namespace.
|