Kite - Detailed Router


NegociateWindow.h
1 // -*- C++ -*-
2 //
3 // This file is part of the Coriolis Software.
4 // Copyright (c) UPMC 2008-2018, All Rights Reserved
5 //
6 // +-----------------------------------------------------------------+
7 // | C O R I O L I S |
8 // | K i t e - D e t a i l e d R o u t e r |
9 // | |
10 // | Author : Jean-Paul CHAPUT |
11 // | E-mail : Jean-Paul.Chaput@lip6.fr |
12 // | =============================================================== |
13 // | C++ Header : "./kite/NegociateWindow.h" |
14 // +-----------------------------------------------------------------+
15 
16 
17 #ifndef KITE_NEGOCIATE_WINDOW_H
18 #define KITE_NEGOCIATE_WINDOW_H
19 
20 #include <set>
21 #include <queue>
22 #include <vector>
23 
24 namespace Hurricane {
25  class Cell;
26 }
27 
28 #include "katabatic/Grid.h"
29 #include "kite/RoutingEventQueue.h"
30 #include "kite/RoutingEventHistory.h"
31 #include "kite/RoutingEventLoop.h"
32 
33 
34 namespace Kite {
35 
36  class TrackElement;
37  class KiteEngine;
38 
39 
40 // -------------------------------------------------------------------
41 // Class : "Statistics".
42 
43  class Statistics {
44  public:
45  inline Statistics ();
46  inline size_t getGCellsCount () const;
47  inline size_t getSegmentsCount () const;
48  inline size_t getEventsCount () const;
49  inline void setGCellsCount ( size_t );
50  inline void setSegmentsCount ( size_t );
51  inline void setEventsCount ( size_t );
52  inline void incGCellCount ( size_t );
53  inline void incSegmentsCount ( size_t );
54  inline void incEventsCount ( size_t );
55  inline Statistics& operator+= ( const Statistics& );
56  private:
57  size_t _gcellsCount;
58  size_t _segmentsCount;
59  size_t _eventsCount;
60 
61  };
62 
63 
64  inline Statistics::Statistics ()
65  : _gcellsCount (0)
66  , _segmentsCount (0)
67  , _eventsCount (0)
68  { }
69 
70  inline size_t Statistics::getGCellsCount () const { return _gcellsCount; }
71  inline size_t Statistics::getSegmentsCount () const { return _segmentsCount; }
72  inline size_t Statistics::getEventsCount () const { return _eventsCount; }
73  inline void Statistics::setGCellsCount ( size_t count ) { _gcellsCount = count; }
74  inline void Statistics::setSegmentsCount ( size_t count ) { _segmentsCount = count; }
75  inline void Statistics::setEventsCount ( size_t count ) { _eventsCount = count; }
76  inline void Statistics::incGCellCount ( size_t count ) { _gcellsCount += count; }
77  inline void Statistics::incSegmentsCount ( size_t count ) { _segmentsCount += count; }
78  inline void Statistics::incEventsCount ( size_t count ) { _eventsCount += count; }
79 
80  inline Statistics& Statistics::operator+= ( const Statistics& other )
81  {
82  _gcellsCount += other._gcellsCount;
83  _segmentsCount += other._segmentsCount;
84  _eventsCount += other._eventsCount;
85  return *this;
86  }
87 
88 
89 // -------------------------------------------------------------------
90 // Class : "Kite::NegociateWindow".
91 
93 
94  public:
95  enum Stage { Negociation = 1
96  , Packing = 2
97  };
98  public:
99  static NegociateWindow* create ( KiteEngine* );
100  void destroy ();
101  inline bool isInterrupted () const;
102  inline KiteEngine* getKiteEngine () const;
103  Hurricane::Cell* getCell () const;
104  inline const Katabatic::GCellVector& getGCells () const;
105  inline RoutingEventQueue& getEventQueue ();
107  inline RoutingEventLoop& getEventLoop ();
108  inline Stage getStage () const;
109  void setGCells ( const Katabatic::GCellVector& );
110  inline void setInterrupt ( bool );
111  inline void setStage ( Stage );
112  double computeWirelength ();
113  TrackElement* createTrackSegment ( AutoSegment*, unsigned int flags );
114  void addRoutingEvent ( TrackElement*, unsigned int level );
115  inline void rescheduleEvent ( RoutingEvent*, unsigned int level );
116  void run ( unsigned int flags );
117  void printStatistics () const;
118  void _createRouting ( Katabatic::GCell* );
119  void _pack ( size_t& count, bool last );
120  size_t _negociate ();
121  Hurricane::Record* _getRecord () const;
122  std::string _getString () const;
123  inline std::string _getTypeName () const;
124 
125  private:
126  // Attributes.
127  unsigned int _flags;
128  bool _interrupt;
129  KiteEngine* _kite;
130  Katabatic::GCellVector _gcells;
131  std::vector<TrackElement*> _segments;
132  RoutingEventQueue _eventQueue;
133  RoutingEventHistory _eventHistory;
134  RoutingEventLoop _eventLoop;
135  Statistics _statistics;
136 
137  // Constructors.
138  protected:
140  ~NegociateWindow ();
141  private:
142  NegociateWindow ( const NegociateWindow& );
143  NegociateWindow& operator= ( const NegociateWindow& );
144  };
145 
146 
147 // Inline Functions.
148  inline bool NegociateWindow::isInterrupted () const { return _interrupt; }
149  inline KiteEngine* NegociateWindow::getKiteEngine () const { return _kite; }
150  inline const Katabatic::GCellVector& NegociateWindow::getGCells () const { return _gcells; }
151  inline RoutingEventQueue& NegociateWindow::getEventQueue () { return _eventQueue; }
152  inline RoutingEventHistory& NegociateWindow::getEventHistory () { return _eventHistory; }
153  inline void NegociateWindow::setInterrupt ( bool state ) { _interrupt = state; }
154  inline void NegociateWindow::rescheduleEvent ( RoutingEvent* event, unsigned int level ) { event->reschedule(_eventQueue,level); }
155  inline std::string NegociateWindow::_getTypeName () const { return "NegociateWindow"; }
156 
157 
158 } // Kite namespace.
159 
160 
161 #endif // KITE_NEGOCIATE_WINDOW_H
Atomic Placement Request for a TrackSegment.
Definition: RoutingEvent.h:55
void setInterrupt(bool)
Definition: NegociateWindow.h:153
Definition: NegociateWindow.h:95
Definition: NegociateWindow.h:96
RoutingEventQueue & getEventQueue()
Definition: NegociateWindow.h:151
void rescheduleEvent(RoutingEvent *, unsigned int level)
Definition: NegociateWindow.h:154
const Katabatic::GCellVector & getGCells() const
Definition: NegociateWindow.h:150
RoutingEventLoop & getEventLoop()
void destroy()
Definition: NegociateWindow.cpp:185
void run(unsigned int flags)
Definition: NegociateWindow.cpp:557
RoutingEventHistory & getEventHistory()
Definition: NegociateWindow.h:152
TrackElement * createTrackSegment(AutoSegment *, unsigned int flags)
Definition: NegociateWindow.cpp:226
double computeWirelength()
Definition: NegociateWindow.cpp:317
Simple loop dectector for RoutingEvent.
Definition: RoutingEventLoop.h:32
void addRoutingEvent(TrackElement *, unsigned int level)
Definition: NegociateWindow.cpp:212
KiteEngine * getKiteEngine() const
Definition: NegociateWindow.h:149
bool isInterrupted() const
Definition: NegociateWindow.h:148
Perform the routing, main RoutingEvent manager.
Definition: NegociateWindow.h:92
The Kite Tool.
Definition: KiteEngine.h:60
History of RoutingEvent.
Definition: RoutingEventHistory.h:35
void setGCells(const Katabatic::GCellVector &)
Definition: NegociateWindow.cpp:193
Abstract Class for all Elements inserted inside a Track.
Definition: TrackElement.h:100
Stage getStage() const
Stage
Definition: NegociateWindow.h:95
The priority Queue of RoutingEvent.
Definition: RoutingEventQueue.h:35
Hurricane::Cell * getCell() const
Definition: NegociateWindow.cpp:189
The namespace dedicated to Kite.
Definition: Constants.h:22
static NegociateWindow * create(KiteEngine *)
Definition: NegociateWindow.cpp:174
void printStatistics() const
Definition: NegociateWindow.cpp:602


Generated by doxygen 1.8.14 on Mon Oct 28 2019 Return to top of page
Kite - Detailed Router Copyright © 2008-2016 UPMC. All rights reserved