coriolis/katana/src/RoutingEvent.cpp

// -*- mode: C++; explicit-buffer-name: "RoutingEvent.cpp<katana>" -*-
//
// This file is part of the Coriolis Software.
// Copyright (c) UPMC 2008-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@lip6.fr              |
// | =============================================================== |
// |  C++ Module  :       "./RoutingEvent.cpp"                       |
// +-----------------------------------------------------------------+


#include <cstdlib>
#include <cmath>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include "vlsisapd/configuration/Configuration.h"
#include "hurricane/Bug.h"
#include "hurricane/DebugSession.h"
#include "hurricane/Breakpoint.h"
#include "hurricane/Net.h"
#include "hurricane/Layer.h"
#include "anabatic/AutoContact.h"
#include "katana/DataNegociate.h"
#include "katana/TrackSegment.h"
#include "katana/Track.h"
#include "katana/Tracks.h"
#include "katana/RoutingPlane.h"
#include "katana/RoutingEvent.h"
#include "katana/RoutingEventHistory.h"
#include "katana/RoutingEventQueue.h"
#include "katana/RoutingEventLoop.h"
#include "katana/NegociateWindow.h"
#include "katana/Session.h"
#include "katana/KatanaEngine.h"
#include "katana/Manipulator.h"
#include "katana/SegmentFsm.h"


namespace Katana {

  using std::cerr;
  using std::endl;
  using std::setw;
  using std::min;
  using std::ostringstream;
  using Hurricane::tab;
  using Hurricane::DebugSession;
  using Hurricane::Bug;
  using Hurricane::Error;
  using Hurricane::BaseFlags;
  using Hurricane::ForEachIterator;
  using Hurricane::Net;
  using Hurricane::Layer;
  using Anabatic::GCell;


// -------------------------------------------------------------------
// Class  :  "RoutingEvent::Compare".


  bool  RoutingEvent::Compare::operator() ( const RoutingEvent* lhs, const RoutingEvent* rhs ) const
  {
    if (lhs == rhs) return false;
    return RoutingEvent::Key::Compare()( lhs->getKey(), rhs->getKey() );
  }


// -------------------------------------------------------------------
// Class  :  "RoutingEvent::Key".


  bool  RoutingEvent::Key::Compare::operator() ( const RoutingEvent::Key& lhs, const RoutingEvent::Key& rhs ) const
  {
    if (lhs._eventLevel > rhs._eventLevel) return false;
    if (lhs._eventLevel < rhs._eventLevel) return true;

  //if (lhs._net->getName() != rhs._net->getName())
  //  return lhs._net->getName() < rhs._net->getName();

  // Process all M2 (terminal access) before any others.
  //if ((lhs._layerDepth == 1) and (rhs._layerDepth != 1)) return false;
  //if ((lhs._layerDepth != 1) and (rhs._layerDepth == 1)) return true;
    if (lhs._layerDepth > rhs._layerDepth) return true;
    if (lhs._layerDepth < rhs._layerDepth) return false;

    if (lhs._priority > rhs._priority) return false;
    if (lhs._priority < rhs._priority) return true;

    if (lhs._length > rhs._length) return false;
    if (lhs._length < rhs._length) return true;

    if ((lhs._segFlags & Anabatic::SegHorizontal) xor (rhs._segFlags & Anabatic::SegHorizontal))
      return (rhs._segFlags & Anabatic::SegHorizontal);

    if (lhs._axis > rhs._axis) return true;
    if (lhs._axis < rhs._axis) return false;

    if (lhs._sourceU > rhs._sourceU) return true;
    if (lhs._sourceU < rhs._sourceU) return false;

    if (lhs._net->getName() != rhs._net->getName())
      return lhs._net->getName() < rhs._net->getName();

    return lhs._id < rhs._id;
  }


  RoutingEvent::Key::Key ( const RoutingEvent* event )
    : _tracksNb    (event->getTracksNb())
    , _priority    (event->getPriority())
    , _eventLevel  (event->getEventLevel())
    , _segFlags    (event->getSegment()->base()->getFlags())
    , _layerDepth  (Session::getRoutingGauge()->getLayerDepth(event->getSegment()->getLayer()))
    , _length      (event->getSegment()->getLength())
    , _axis        (event->getSegment()->getAxis())
    , _sourceU     (event->getSegment()->getSourceU())
    , _net         (event->getSegment()->getNet())
    , _id          (event->getSegment()->getId())
  { }


  void  RoutingEvent::Key::update ( const RoutingEvent* event )
  {
    if (not event) return;

    _tracksNb     = event->getTracksNb();
    _priority     = event->getPriority();
    _eventLevel   = event->getEventLevel();
    _segFlags     = event->getSegment()->base()->getFlags();
    _layerDepth   = Session::getRoutingGauge()->getLayerDepth(event->getSegment()->getLayer());
    _length       = event->getSegment()->getLength();
    _axis         = event->getSegment()->getAxis();
    _sourceU      = event->getSegment()->getSourceU();
    _id           = event->getSegment()->getId();
  }


// -------------------------------------------------------------------
// Class  :  "RoutingEvent".


  uint32_t  RoutingEvent::_idCounter  = 0;
  uint32_t  RoutingEvent::_stage      = RoutingEvent::Negociate;
  uint32_t  RoutingEvent::_allocateds = 0;
  uint32_t  RoutingEvent::_processeds = 0;
  uint32_t  RoutingEvent::_cloneds    = 0;


  uint32_t  RoutingEvent::getStage        () { return _stage; }
  uint32_t  RoutingEvent::getAllocateds   () { return _allocateds; }
  uint32_t  RoutingEvent::getProcesseds   () { return _processeds; }
  uint32_t  RoutingEvent::getCloneds      () { return _cloneds; }
  void      RoutingEvent::setStage        ( uint32_t stage ) { _stage = stage; }
  void      RoutingEvent::resetProcesseds () { _processeds = 0; }


  RoutingEvent::RoutingEvent ( TrackElement* segment, uint32_t mode )
    : _cloned              (false)
    , _processed           (false)
    , _disabled            (false)
    , _overConstrained     (false)
    , _minimized           (false)
    , _forceToHint         (false)
    , _ripedByLocal        (false)
    , _id                  (_idCounter++)
    , _segment             (segment)
    , _dataNegociate       (segment->getDataNegociate())
    , _axisHistory         (segment->getAxis())
    , _axisHint            (segment->getAxis())
    , _constraints         ()
    , _optimal             ()
    , _tracksNb            (0)
    , _tracksFree          (0)
    , _insertState         (0)
    , _mode                (mode)
    , _rippleState         (0)
    , _eventLevel          (0)
    , _key                 (this)
  {
    if (_idCounter == std::numeric_limits<uint32_t>::max()) {
      throw Error( "RoutingEvent::RoutingEvent(): Identifier counter has reached it's limit (%d bits)."
                 , std::numeric_limits<uint32_t>::digits );
    }

    DataNegociate* data = _segment->getDataNegociate();
    if (data) data->setRoutingEvent( this );

    cdebug_log(159,0) << "create: " << this << endl;
    cdebug_log(159,0) << "Initial setAxisHint @" << DbU::getValueString(getAxisHint()) << endl;

    if (_segment->getTrack()) {
      cerr << Bug( "RoutingEvent::create() - TrackElement is already inserted in a Track."
                   "\n      %s.", getString(_segment).c_str()
                 ) << endl;
    }
  }


  RoutingEvent* RoutingEvent::create ( TrackElement* segment, uint32_t mode )
  {
    // if (not dynamic_cast<TrackSegment*>(segment)) {
    //   cerr << Error( "RoutingEvent::create() Can only create event from TrackSegment:\n"
    //                  "        %s", getString(segment).c_str()
    //                ) << endl;
    // }

    RoutingEvent* event = new RoutingEvent ( segment, mode );
    ++_allocateds;

    return event;
  }


  RoutingEvent* RoutingEvent::clone () const
  {
    _cloned = true;

    RoutingEvent* clone = new RoutingEvent ( *this );
    ++_allocateds;
    ++_cloneds;

    clone->_cloned     = false;
    clone->_disabled   = false;
    clone->_eventLevel = 0;

    cdebug_log(159,0) << "RoutingEvent::clone() " << clone
                << " (from: " << ")" <<  endl;

    return clone;
  }


  RoutingEvent::~RoutingEvent ()
  {
    cdebug_log(159,0) << "~RoutingEvent() " << endl;

    DataNegociate* data = _segment->getDataNegociate();
    if ( data and (data->getRoutingEvent() == this) )
      data->setRoutingEvent( NULL );
  }


  void  RoutingEvent::destroy ()
  {
    cdebug_log(159,0) << "RoutingEvent::destroy() " << this << endl;
    if (_allocateds > 0) --_allocateds;

    delete this;
  }


  bool  RoutingEvent::isUnimplemented () const
  { return getState() == DataNegociate::Unimplemented; }


  void  RoutingEvent::setMode ( uint32_t mode )
  { _mode = mode; }


  uint32_t  RoutingEvent::getState () const
  {
    DataNegociate* data = _segment->getDataNegociate();
    return (data) ? data->getState() : 0;
  }


  void  RoutingEvent::setState ( uint32_t state )
  {
    DataNegociate* data = _segment->getDataNegociate();
    if (data) data->setState( state );
  }


  void  RoutingEvent::setAxisHint ( DbU::Unit axis )
  {
    cdebug_log(159,0) << "setAxisHint @" << DbU::getValueString(axis) << " " << _segment << endl;
    _axisHint = axis;
  }


  void  RoutingEvent::setAxisHintFromParent ()
  {
    if (getStage() == Repair) return;

    TrackElement* parent = _segment->getParent();
    if (not parent) return;

    RoutingEvent* parentEvent = parent->getDataNegociate()->getRoutingEvent();
    if (parentEvent == this) {
      cbug << Error( "RoutingEvent::setAxisHintFromParent(): Parentage loop between\n"
                     "        this  :%p:%s\n        parent:%p:%s"
                   , _segment->base(),getString(_segment->base()).c_str()
                   , parent  ->base(),getString(parent  ->base()).c_str()
                   ) << endl;
      _axisHint = parent->getAxis();
      return;
    }
    _axisHint = parent->getAxis();

    cdebug_log(159,0) << "setAxisHintFromParent() - hint:" << DbU::getValueString(_axisHint)
                << " axis:" << DbU::getValueString(parent->getAxis()) << " parent:" << parent << endl;
    return;
  }


  RoutingEvent* RoutingEvent::reschedule ( RoutingEventQueue& queue, uint32_t eventLevel )
  {
    RoutingEvent* active = _segment->getDataNegociate()->getRoutingEvent();
    if (active != this) return active->reschedule( queue, eventLevel );

    RoutingEvent* fork = NULL;

    if ( (getStage() != Repair) and isUnimplemented() ) {
      cdebug_log(159,0) << "Reschedule: cancelled (Unimplemented) -> " << fork << endl;
      return NULL;
    }

    if (not isProcessed()) {
      fork = this;
      cdebug_log(159,0) << "Reschedule/Self: -> "
                        << eventLevel << ":" << fork << endl;
    } else {
      fork = clone();
      fork->_processed  = false;

      _segment->getDataNegociate()->setRoutingEvent( fork );

      cdebug_log(159,0) << "Reschedule/Fork: -> " << fork << endl;
    }

    if (fork->_eventLevel < eventLevel)
      fork->_eventLevel = eventLevel;

    if (getStage() == Repair) {
      fork->setMode( RoutingEvent::Repair );
      _segment->getDataNegociate()->setState( DataNegociate::Repair );
    } else if (getStage() == RoutingEvent::Pack) {
      fork->setMode( RoutingEvent::Pack );
    }

    queue.repush( fork );

    return fork;
  }


  void  RoutingEvent::setSegment ( TrackElement* segment )
  {
    if (_segment) _segment->getDataNegociate()->setRoutingEvent( NULL );
    _segment = segment;
    _segment->getDataNegociate()->setRoutingEvent( this );
  }


  void  RoutingEvent::process ( RoutingEventQueue&   queue
                              , RoutingEventHistory& history
                              , RoutingEventLoop&    loop
                              )
  {
    loop.update( _segment->getId() );
    if (loop.isLooping()) {
        loop.erase( _segment->getId() );
        setState( DataNegociate::Unimplemented );

#if LOOP_DEBUG
      if (loop.getMaxCount() > 500) {
        cbug << Error("Loop detected, removing event %s.",_getString().c_str()) << endl;

        ostringstream message;
        message << "Katana has detected a loop between the following Segments:\n<tt>";

        const vector<RoutingEventLoop::Element>& elements = loop.getElements();
        for ( size_t i=0 ; i<elements.size() ; ++i ) {
          message << setw(2) << elements[i]._count << "| id:"
                  << elements[i]._id << "\n";
        }
        message << "</tt>";

        throw Error( message.str().c_str() );
      }
#else
      ostringstream message;
      message << "[BUG] Katana has detected a loop between the following Segments:";

      const vector<RoutingEventLoop::Element>& elements = loop.getElements();
      for ( size_t i=0 ; i<elements.size() ; ++i ) {
        message << "\n" << setw(10) << elements[i]._count << "| id:" << elements[i]._id;
      }
      cbug << message.str() << endl;
#endif
    }

    DebugSession::open( _segment->getNet(), 155, 160 );

    cdebug_log(9000,0) << "Deter| Event "
                     <<         getProcesseds()
                     << ","  << getEventLevel()
                     << ","  << setw(6) << getPriority()
                     << ": " << _segment << endl;
    _processeds++;

    cdebug_tabw(159,1);
    cdebug_log(159,0) << "State: *before* "
                      << DataNegociate::getStateString(_segment->getDataNegociate())
                      << " ripup:" << _segment->getDataNegociate()->getRipupCount()
                      << endl;
    cdebug_log(159,0) << "Level: " << getEventLevel()
                      << ", area: " << _segment->getFreedomDegree() << endl;

  //_preCheck( _segment );
    _eventLevel = 0;

    if (_mode != Pack) history.push( this );

    if ( isProcessed() or isDisabled() ) {
      cdebug_log(159,0) << "Already processed or disabled." << endl;
    } else {
      if (_segment->hasSymmetric()) {
      }

      setProcessed();
      setTimeStamp( _processeds );

      switch ( _mode ) {
        case Negociate: _processNegociate( queue, history ); break;
        case Pack:      _processPack     ( queue, history ); break;
        case Repair:    _processRepair   ( queue, history ); break;
        default:
          cerr << Bug( "RoutingEvent::process() - Unknown mode value:%d.", _mode ) << endl;
          break;
      }
    }
    cdebug_tabw(159,-1);

    queue.repushInvalidateds();
    Session::revalidate();
    queue.commit();

  //_postCheck( _segment );
#if defined(CHECK_DATABASE)
    Session::getKatanaEngine()->_check( _segment->getNet() );
#endif
    DebugSession::close();

    if (Session::getKatanaEngine()->getPostEventCb() != NULL)
      Session::getKatanaEngine()->getPostEventCb()();
  }


  void  RoutingEvent::_processNegociate ( RoutingEventQueue& queue, RoutingEventHistory& history )
  {
    cdebug_log(159,0) << "* Mode:Negociation." << endl;

    SegmentFsm fsm ( this, queue, history );

    if (fsm.getState() == SegmentFsm::MissingData) {
      cbug << Error("RoutingEvent::process() - Missing datas.") << endl;
      return;
    }

    cdebug_tabw(159,1);

    fsm.incRipupCount();

    cdebug_log(159,0) << "| Candidate Tracks:" << endl;
    size_t itrack = 0;
    for ( itrack = 0 ; itrack < fsm.getCosts().size() ; itrack++ )
      cdebug_log(159,0) << "| " << itrack << ":" << fsm.getCost(itrack) << endl;

    itrack = 0;
    if ( (not isOverConstrained()) and fsm.canRipup() ) {
      if (fsm.getCosts().size() and fsm.getCost(itrack).isFree()) {
        cdebug_log(159,0) << "Insert in free space " << this << endl;
        fsm.bindToTrack( itrack );
      } else {
      // Do ripup.
        if (fsm.getState() == SegmentFsm::EmptyTrackList) {
          fsm.ripupPerpandiculars();
        } else {
          if (fsm.canRipup(Manipulator::NotOnLastRipup)) {
            if (cdebug.enabled(9000)) {
              for ( itrack=0 ; itrack<fsm.getCosts().size() ; itrack++ ) {
                cdebug_log(9000,0) << "Deter| | Candidate Track: " << fsm.getCost(itrack) << endl;
              }
            }
            for ( itrack=0 ; itrack<fsm.getCosts().size() ; itrack++ ) {
              cdebug_log(159,0) << "Trying Track: " << itrack << endl;
              if (fsm.getCost(itrack).isInfinite()) break;
              if (fsm.insertInTrack(itrack)) break;
              resetInsertState();
            } // Next ripup is possible.
          }

          if (fsm.getState() != SegmentFsm::OtherRipup) {
            fsm.slackenTopology();
          }
        }
      }
    } else {
    // Ripup limit has been reached.
      if (isOverConstrained()) {
        cdebug_log(159,0) << "Immediate slackening due to overconstraint" << endl;
        fsm.setDataState( DataNegociate::Slacken );
      }
      if (not fsm.slackenTopology()) {
        fsm.setState( SegmentFsm::SelfMaximumSlack );
      }
    }

    fsm.doActions();

    if (itrack < fsm.getCosts().size()) {
      cdebug_log(159,0) << "Placed: @" << DbU::getValueString(fsm.getCost(itrack).getTrack()->getAxis())
                  << " " << this << endl;
    }

    cdebug_tabw(159,-1);
  }


  void  RoutingEvent::_processPack ( RoutingEventQueue& queue, RoutingEventHistory& history )
  {
    cdebug_log(159,0) << "* Mode:Pack." << endl;

    if (not _segment->isUTurn()) return;

    SegmentFsm fsm ( this, queue, history );
    if (fsm.getState() == SegmentFsm::MissingData   ) return;
    if (fsm.getState() == SegmentFsm::EmptyTrackList) return;

    cdebug_tabw(159,1);
    for ( size_t i = 0 ; i < fsm.getCosts().size() ; i++ )
      cdebug_log(159,0) << "| " << fsm.getCost(i) << endl;
    cdebug_tabw(159,-1);

    if (    _segment->getTrack()
       and  fsm.getCosts().size()
       and  fsm.getCost(0).isFree()
       and (fsm.getCost(0).getTrack() != _segment->getTrack()) ) {

      cerr << "_processPack(): move to " << fsm.getCost(0).getTrack() << endl;
      fsm.moveToTrack( 0 );
    }
  }


  void  RoutingEvent::_processRepair ( RoutingEventQueue& queue, RoutingEventHistory& history )
  {
    cdebug_log(159,0) << "* Mode:Repair." << endl;

    if ( _segment->getTrack() != NULL ) {
      cdebug_log(159,0) << "* Cancel: already in Track." << endl;
      return;
    }

    SegmentFsm fsm ( this, queue, history );
    if (fsm.getState() == SegmentFsm::MissingData   ) return;
    if (fsm.getState() == SegmentFsm::EmptyTrackList) return;
    if (fsm.isSymmetric()) return;

    cdebug_tabw(159,1);
    for ( size_t i = 0 ; i < fsm.getCosts().size() ; i++ )
      cdebug_log(159,0) << "| " << fsm.getCost(i) << endl;
    cdebug_tabw(159,-1);

    if (fsm.getCosts().size() and fsm.getCost(0).isFree()) {
      cdebug_log(159,0) << "Insert in free space." << endl;
      fsm.bindToTrack( 0 );
    } else {
      switch ( fsm.getData()->getStateCount() ) {
        case 1:
        // First try: minimize.
          Manipulator(_segment,fsm).minimize ();
          fsm.addAction( _segment, SegmentAction::SelfInsert );
          fsm.doActions();
          queue.commit();
          break;
        case 2:
        // Second try: failed re-inserted first.
          Manipulator(_segment,fsm).repackPerpandiculars ();
          fsm.addAction( _segment, SegmentAction::SelfInsert );
          fsm.doActions();
          queue.commit();
          break;
        default:
          cdebug_log(159,0) << "Repair failed." << endl;
          break;
      }
    }
  }


  void  RoutingEvent::revalidate ()
  {
    DebugSession::open( _segment->getNet(), 156, 160 );

    cdebug_log(159,1) << "RoutingEvent::revalidate() - " << this << endl;

  //_dataNegociate->update();

    setAxisHintFromParent();
    cdebug_log(159,0) << "axisHint:" << DbU::getValueString(getAxisHint()) << endl;

    _overConstrained = false;
    _segment->base()->getConstraints( _constraints );
    _segment->base()->getOptimal    ( _optimal );

    cdebug_log(159,0) << "Stage:" << RoutingEvent::getStage() << endl;
    if (RoutingEvent::getStage() == RoutingEvent::Repair) {
      if (_segment->isStrongTerminal(Flags::Propagate)) {
        cdebug_log(159,0) << "Not expanding on Terminals:" << _constraints << endl;
      } else {
        cdebug_log(159,0) << "Expanding:" << _constraints << endl;
        _constraints.inflate( Session::getSliceHeight() );
        cdebug_log(159,0) << "Expanding (after):" << _constraints << endl;
      }
    }
    cdebug_log(159,0) << "| Raw Track Constraint: " << _constraints
                      << " [" << _constraints.getVMin()
                      <<  "," << _constraints.getVMax() << "]" << endl;

    _tracksNb = 0;

    Interval perpandicular = _constraints;
    perpandicular.intersection( getPerpandicularFree());
    cdebug_log(159,0) << "| Perpandicular Free: " << perpandicular << endl;

    if (not perpandicular.isEmpty()) {
      RoutingPlane* plane   = Session::getKatanaEngine()->getRoutingPlaneByLayer(_segment->getLayer());
      Track*        track   = plane->getTrackByPosition(perpandicular.getVMin());

      if ( track and (track->getAxis() < perpandicular.getVMin()) ) track = track->getNextTrack();
      for ( ; track and (track->getAxis() <= perpandicular.getVMax())
            ; track = track->getNextTrack(), _tracksNb++ );
    }
    if (not _tracksNb) {
      cdebug_log(159,0) << "| Reverting to pure constraints." << endl;
      RoutingPlane* plane   = Session::getKatanaEngine()->getRoutingPlaneByLayer(_segment->getLayer());
      Track*        track   = plane->getTrackByPosition(_constraints.getVMin());

      if ( track && (track->getAxis() < _constraints.getVMin()) ) track = track->getNextTrack();
      for ( ; track && (track->getAxis() <= _constraints.getVMax())
            ; track = track->getNextTrack(), _tracksNb++ );
    }
    if (not _tracksNb) {
      cdebug_log(159,0) << "| Pure constraints are too tight." << endl;
      if (_segment->base())
        _overConstrained =     _segment->base()->getAutoSource()->isTerminal()
                           and _segment->base()->getAutoTarget()->isTerminal();
    }

    _segment->computePriority();

    cdebug_log(159,0) << _segment << " has " << (int)_tracksNb << " choices " << perpandicular << endl;
    cdebug_tabw(159,-1);

    DebugSession::close();
  }


  string  RoutingEvent::_getTypeName () const
  { return "RoutingEvent"; }


  string  RoutingEvent::_getString () const
  {
    string s = "<" + _getTypeName();

    s += " "  + getString(_eventLevel);
    s += ","  + getString((long)getPriority());
    s += " @" + DbU::getValueString(getAxisHistory());
    s += ":"  + getString(_segment);
    s += " "  + getString(_segment->getDataNegociate()->getRipupCount());
    s += " ";
    s +=        (isCloned       ()?"C":"-");
    s +=        (isDisabled     ()?"d":"-");
    s +=        (isUnimplemented()?"u":"-");
    s += ">";

    return s;
  }


  Record* RoutingEvent::_getRecord () const
  {
    Record* record = new Record ( getString(this) );
    record->add ( getSlot ( "_segment"   , _segment    ) );
    record->add ( getSlot ( "_processed" , _processed  ) );
                                     
    return record;
  }


} // Katana namespace.