Hurricane VLSI Database


DbU.h
1 // -*- C++ -*-
2 //
3 // Copyright (c) BULL S.A. 2000-2018, All Rights Reserved
4 //
5 // This file is part of Hurricane.
6 //
7 // Hurricane is free software: you can redistribute it and/or modify
8 // it under the terms of the GNU Lesser General Public License as
9 // published by the Free Software Foundation, either version 3 of the
10 // License, or (at your option) any later version.
11 //
12 // Hurricane is distributed in the hope that it will be useful, but
13 // WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN-
14 // TABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the Lesser GNU
15 // General Public License for more details.
16 //
17 // You should have received a copy of the Lesser GNU General Public
18 // License along with Hurricane. If not, see
19 // <http://www.gnu.org/licenses/>.
20 //
21 // +-----------------------------------------------------------------+
22 // | H U R R I C A N E |
23 // | V L S I B a c k e n d D a t a - B a s e |
24 // | |
25 // | Author : Remy Escassut |
26 // | E-mail : Jean-Paul.Chaput@lip6.fr |
27 // | =============================================================== |
28 // | C++ Header : "./hurricane/DbU.h" |
29 // +-----------------------------------------------------------------+
30 
31 
32 #pragma once
33 #include <cstdint>
34 #include <cmath>
35 #include "hurricane/Commons.h"
36 
37 
38 namespace Hurricane {
39 
40  class DataBase;
41 
42 
43  class DbU {
44  friend class DataBase;
45  public:
46  enum FunctionFlags { NoFlags = 0
47  , NoTechnoUpdate = (1<<0)
48  };
49  enum UnitPower { Pico = 1
50  , Nano
51  , Micro
52  , Milli
53  , Unity
54  , Kilo
55  };
56  enum StringMode { Db = (1<<0)
57  , Grid = (1<<1)
58  , Symbolic = (1<<2)
59  , Physical = (1<<3)
60  , SmartTruncate = (1<<4)
61  };
62  enum SnapMode { Inferior = 1
63  , Superior = 2
64  , Nearest = 4
65  };
66  public:
67  typedef std::int64_t Unit;
68 
69  public:
70  static void checkGridBound ( double value );
71  static void checkLambdaBound ( double value );
72  static void checkPhysicalBound ( double value, UnitPower p );
73  // User to DB Converters.
74  static inline Unit fromDb ( Unit value );
75  static inline Unit fromGrid ( double value );
76  static inline Unit fromLambda ( double value );
77  static inline Unit fromPhysical ( double value, UnitPower p );
78  static inline Unit fromMicrons ( double value );
79  static inline Unit fromNanos ( double value );
80  // Old naming scheme (was not very clear).
81  static inline Unit db ( Unit value );
82  static inline Unit grid ( double value );
83  static inline Unit lambda ( double value );
84  static inline Unit physicalToDbu ( double value, UnitPower p );
85  // Precision & Resolution Managment.
86  static unsigned int getPrecision ();
87  static unsigned int getMaximalPrecision ();
88  static double getResolution ();
89  static void setPrecision ( unsigned int precision, unsigned int flags=NoFlags );
90  // Foundry Grid Managment.
91  static double getUnitPower ( UnitPower p );
92  static void setPhysicalsPerGrid ( double gridsPerLambda, UnitPower p );
93  static double getPhysicalsPerGrid ();
94  static double physicalToGrid ( double physical, UnitPower p );
95  // Huge Polygon Step Managment.
96  static inline DbU::Unit getPolygonStep ();
97  static inline void setPolygonStep ( DbU::Unit );
98  // Lamba Managment.
99  static void setGridsPerLambda ( double gridsPerLambda, unsigned int flags=NoFlags );
100  static double getGridsPerLambda ();
101  // Snap Grid Managment.
102  static DbU::Unit getRealSnapGridStep ();
103  static DbU::Unit getOnRealSnapGrid ( DbU::Unit u, SnapMode mode=Nearest );
104  static inline void setRealSnapGridStep ( DbU::Unit step );
105  static DbU::Unit getSymbolicSnapGridStep ();
106  static DbU::Unit getOnSymbolicSnapGrid ( DbU::Unit u, SnapMode mode=Nearest );
107  static inline void setSymbolicSnapGridStep ( DbU::Unit step );
108  static DbU::Unit getOnCustomGrid ( DbU::Unit u, DbU::Unit step, SnapMode mode=Nearest );
109  static inline DbU::Unit getOnPhysicalGrid ( DbU::Unit u, SnapMode mode=Superior );
110  static inline DbU::Unit toCeil ( DbU::Unit u, DbU::Unit step );
111  static inline DbU::Unit toFloor ( DbU::Unit u, DbU::Unit step );
112  // Conversions.
113  static inline Unit toDb ( Unit u );
114  static inline double toGrid ( Unit u );
115  static inline double toGrid ( double u );
116  static inline double toLambda ( Unit u );
117  static inline double toLambda ( double u );
118  static inline double toPhysical ( Unit u, UnitPower p );
119  static inline double toPhysical ( double u, UnitPower p );
120  static inline double toMicrons ( Unit u );
121  static inline double toNanos ( Unit u );
122  // Old naming scheme (not very clear).
123  static inline Unit getDb ( Unit u );
124  static inline double getGrid ( Unit u );
125  static inline double getGrid ( double u );
126  static inline double getLambda ( Unit u );
127  static inline double getLambda ( double u );
128  static inline double getPhysical ( Unit u, UnitPower p );
129  static inline double getPhysical ( double u, UnitPower p );
130  static string getValueString ( Unit u, int mode=SmartTruncate );
131  static string getValueString ( double u, int mode=SmartTruncate );
132  static Record* getValueRecord ( const Unit* u );
133  static Slot* getValueSlot ( const string& name, const Unit* u );
134  static void setStringMode ( unsigned int mode, UnitPower p=Nano );
135  static void getStringMode ( unsigned int& mode, UnitPower& p );
136  private:
137  static void _updateBounds ();
138 
139  public:
140  // Static Attributes: constants.
141  static const Unit Min;
142  static const Unit Max;
143  static Unit oneGrid;
144  static Unit twoGrid;
145  private:
146  // Internal: Static Attributes.
147  static const unsigned int _maximalPrecision;
148  static unsigned int _precision;
149  static double _resolution;
150  static double _gridsPerLambda;
151  static double _physicalsPerGrid;
152  static unsigned int _stringMode;
153  static DbU::UnitPower _stringModeUnitPower;
154  static DbU::Unit _realSnapGridStep;
155  static DbU::Unit _symbolicSnapGridStep;
156  static DbU::Unit _polygonStep;
157  static double _gridMax;
158  static double _lambdaMax;
159  static double _physicalMax;
160  };
161 
162 
163 // Inline Functions.
164 // New converter naming scheme.
165  inline DbU::Unit DbU::fromDb ( DbU::Unit value ) { return value; }
166  inline DbU::Unit DbU::fromGrid ( double value ) { checkGridBound (value); return (Unit)rint( value/_resolution ); }
167  inline DbU::Unit DbU::fromLambda ( double value ) { checkLambdaBound (value); return fromGrid(value*_gridsPerLambda); }
168  inline DbU::Unit DbU::fromPhysical ( double value, UnitPower p ) { checkPhysicalBound(value,p); return fromGrid((value*getUnitPower(p))/_physicalsPerGrid); }
169  inline DbU::Unit DbU::fromMicrons ( double value ) { return fromPhysical(value,UnitPower::Micro); }
170  inline DbU::Unit DbU::fromNanos ( double value ) { return fromPhysical(value,UnitPower::Nano); }
171  inline DbU::Unit DbU::toDb ( DbU::Unit u ) { return u; }
172  inline double DbU::toGrid ( DbU::Unit u ) { return _resolution*(double)u; }
173  inline double DbU::toGrid ( double u ) { return _resolution*u; }
174  inline double DbU::toLambda ( DbU::Unit u ) { return toGrid(u)/_gridsPerLambda; }
175  inline double DbU::toLambda ( double u ) { return toGrid(u)/_gridsPerLambda; }
176  inline double DbU::toPhysical ( DbU::Unit u, UnitPower p ) { return (_physicalsPerGrid*_resolution*(double)u)/getUnitPower(p); }
177  inline double DbU::toPhysical ( double u, UnitPower p ) { return (_physicalsPerGrid*_resolution*u)/getUnitPower(p); }
178  inline double DbU::toMicrons ( Unit u ) { return toPhysical(u,UnitPower::Micro); }
179  inline double DbU::toNanos ( Unit u ) { return toPhysical(u,UnitPower::Nano); }
180  inline DbU::Unit DbU::getPolygonStep () { return _polygonStep; }
181 
182 // Old converter naming scheme.
183  inline DbU::Unit DbU::db ( DbU::Unit value ) { return fromDb(value); }
184  inline DbU::Unit DbU::grid ( double value ) { return fromGrid(value); }
185  inline DbU::Unit DbU::lambda ( double value ) { return fromLambda(value); }
186  inline DbU::Unit DbU::physicalToDbu ( double value, UnitPower p ) { return fromPhysical(value,p); }
187  inline DbU::Unit DbU::getDb ( DbU::Unit u ) { return toDb(u); }
188  inline double DbU::getGrid ( DbU::Unit u ) { return toGrid(u); }
189  inline double DbU::getGrid ( double u ) { return toGrid(u); }
190  inline double DbU::getLambda ( DbU::Unit u ) { return toLambda(u); }
191  inline double DbU::getLambda ( double u ) { return toLambda(u); }
192  inline double DbU::getPhysical ( DbU::Unit u, UnitPower p ) { return toPhysical(u,p); }
193  inline double DbU::getPhysical ( double u, UnitPower p ) { return toPhysical(u,p); }
194 
195  inline void DbU::setRealSnapGridStep ( DbU::Unit step ) { _realSnapGridStep = step; }
196  inline void DbU::setSymbolicSnapGridStep ( DbU::Unit step ) { _symbolicSnapGridStep = step; }
197  inline void DbU::setPolygonStep ( DbU::Unit step ) { _polygonStep = step; }
198  inline DbU::Unit DbU::getOnPhysicalGrid ( DbU::Unit u, SnapMode mode ) { return getOnCustomGrid(u, grid(1), mode); }
199 
200  inline DbU::Unit DbU::toCeil ( DbU::Unit u, DbU::Unit step )
201  { DbU::Unit modulo = u % step; return (modulo) ? (u + step - modulo) : u; }
202 
203  inline DbU::Unit DbU::toFloor ( DbU::Unit u, DbU::Unit step )
204  { DbU::Unit modulo = u % step; return (modulo) ? (u - modulo) : u; }
205 
206 
207 } // End of Hurricane namespace.
208 
209 
210 // inline void jsonWriteDbU ( JsonWriter* w, const std::string& key, long* value )
211 // { w->key( key ); w->write( value ); }
212 
213 
214 template<>
215 inline std::string getString ( const std::pair<Hurricane::DbU::Unit,Hurricane::DbU::Unit>& p )
216 {
217  return "const std::pair<DbU::Unit,DbU::Unit>";
218 }
219 
220 
221 template<>
222 inline Hurricane::Record* getRecord ( const std::pair<Hurricane::DbU::Unit,Hurricane::DbU::Unit>& p )
223 {
224  Hurricane::Record* record = NULL;
225  record = new Hurricane::Record ( "const std::pair<DbU::Unit,DbU::Unit>" );
226  record->add( Hurricane::DbU::getValueSlot("first" , &p.first ) );
227  record->add( Hurricane::DbU::getValueSlot("second", &p.second) );
228  return record;
229 }
230 
231 
232 template<>
233 inline std::string getString ( const std::array<Hurricane::DbU::Unit*,3>& a )
234 {
235  return "const array<DbU::Unit*,3>";
236 }
237 
238 
239 template<>
240 inline Hurricane::Record* getRecord ( const std::array<Hurricane::DbU::Unit*,3>& a )
241 {
242  Hurricane::Record* record = NULL;
243  record = new Hurricane::Record ( "const array<DbU::Unit*,3>" );
244 
245  for ( size_t i=0 ; i<a.size() ; ++i ) {
246  std::string label = "[" + getString(i) + "] ";
247  record->add( Hurricane::DbU::getValueSlot(label, a[i]) );
248  }
249  return record;
250 }
251 
252 
253 template<>
254 inline std::string getString ( const std::vector<Hurricane::DbU::Unit>* v )
255 {
256  std::string name = "const std::vector<DbU::Unit>:";
257  return name + getString<size_t>(v->size());
258 }
259 
260 
261 template<>
262 inline Hurricane::Record* getRecord ( const std::vector<Hurricane::DbU::Unit>* v )
263 {
264  Hurricane::Record* record = NULL;
265  record = new Hurricane::Record ( "const vector<DbU::Unit>" );
266 
267  for ( size_t i=0 ; i<v->size() ; ++i ) {
268  std::string label = "[" + getString(i) + "] ";
269  record->add( Hurricane::DbU::getValueSlot(label, &(*v)[i]) );
270  }
271  return record;
272 }
Hurricane::DataBase
The whole DataBase (API).
Definition: DataBase.h:40
Hurricane::DbU
DataBase Unit managment (API).
Definition: DbU.h:43
Hurricane::DbU::getRealSnapGridStep
static DbU::Unit getRealSnapGridStep()
Hurricane::DbU::SnapMode
SnapMode
Definition: DbU.h:62
Hurricane::DbU::Nearest
@ Nearest
Definition: DbU.h:64
Hurricane::DbU::Inferior
@ Inferior
Definition: DbU.h:62
Hurricane::DbU::Superior
@ Superior
Definition: DbU.h:63
Hurricane::DbU::fromPhysical
static Unit fromPhysical(double value, UnitPower p)
Definition: DbU.h:168
Hurricane::DbU::getResolution
static double getResolution()
Hurricane::DbU::grid
static Unit grid(double value)
Definition: DbU.h:184
Hurricane::DbU::setRealSnapGridStep
static void setRealSnapGridStep(DbU::Unit step)
Definition: DbU.h:195
Hurricane::DbU::toGrid
static double toGrid(Unit u)
Definition: DbU.h:172
Hurricane::DbU::fromGrid
static Unit fromGrid(double value)
Definition: DbU.h:166
Hurricane::DbU::getDb
static Unit getDb(Unit u)
Definition: DbU.h:187
Hurricane::DbU::toLambda
static double toLambda(Unit u)
Definition: DbU.h:174
Hurricane::DbU::fromLambda
static Unit fromLambda(double value)
Definition: DbU.h:167
Hurricane::DbU::Unit
std::int64_t Unit
Definition: DbU.h:67
Hurricane::DbU::UnitPower
UnitPower
Definition: DbU.h:49
Hurricane::DbU::Nano
@ Nano
Definition: DbU.h:50
Hurricane::DbU::Pico
@ Pico
Definition: DbU.h:49
Hurricane::DbU::Kilo
@ Kilo
Definition: DbU.h:54
Hurricane::DbU::Micro
@ Micro
Definition: DbU.h:51
Hurricane::DbU::Milli
@ Milli
Definition: DbU.h:52
Hurricane::DbU::Unity
@ Unity
Definition: DbU.h:53
Hurricane::DbU::getPrecision
static unsigned int getPrecision()
Hurricane::DbU::getSymbolicSnapGridStep
static DbU::Unit getSymbolicSnapGridStep()
Hurricane::DbU::StringMode
StringMode
Definition: DbU.h:56
Hurricane::DbU::Symbolic
@ Symbolic
Definition: DbU.h:58
Hurricane::DbU::Db
@ Db
Definition: DbU.h:56
Hurricane::DbU::Grid
@ Grid
Definition: DbU.h:57
Hurricane::DbU::getOnCustomGrid
static DbU::Unit getOnCustomGrid(DbU::Unit u, DbU::Unit step, SnapMode mode=Nearest)
Hurricane::DbU::getOnRealSnapGrid
static DbU::Unit getOnRealSnapGrid(DbU::Unit u, SnapMode mode=Nearest)
Hurricane::DbU::getMaximalPrecision
static unsigned int getMaximalPrecision()
Hurricane::DbU::setStringMode
static void setStringMode(unsigned int mode, UnitPower p=Nano)
Hurricane::DbU::getOnPhysicalGrid
static DbU::Unit getOnPhysicalGrid(DbU::Unit u, SnapMode mode=Superior)
Definition: DbU.h:198
Hurricane::DbU::getGridsPerLambda
static double getGridsPerLambda()
Hurricane::DbU::setSymbolicSnapGridStep
static void setSymbolicSnapGridStep(DbU::Unit step)
Definition: DbU.h:196
Hurricane::DbU::lambda
static Unit lambda(double value)
Definition: DbU.h:185
Hurricane::DbU::toPhysical
static double toPhysical(Unit u, UnitPower p)
Definition: DbU.h:176
Hurricane::DbU::setGridsPerLambda
static void setGridsPerLambda(double gridsPerLambda, unsigned int flags=NoFlags)
Hurricane::DbU::db
static Unit db(Unit value)
Definition: DbU.h:183
Hurricane::DbU::setPrecision
static void setPrecision(unsigned int precision, unsigned int flags=NoFlags)
Hurricane::DbU::getOnSymbolicSnapGrid
static DbU::Unit getOnSymbolicSnapGrid(DbU::Unit u, SnapMode mode=Nearest)
Hurricane::DbU::getGrid
static double getGrid(Unit u)
Definition: DbU.h:188
Hurricane::DbU::getValueString
static string getValueString(Unit u, int mode=SmartTruncate)
Hurricane::DbU::getLambda
static double getLambda(Unit u)
Definition: DbU.h:190
Hurricane::DbU::toDb
static Unit toDb(Unit u)
Definition: DbU.h:171
Hurricane::DbU::fromDb
static Unit fromDb(Unit value)
Definition: DbU.h:165
Hurricane
Contains Almost Everything.
Definition: BasicLayer.h:39

Generated by doxygen 1.9.1 on Wed Nov 20 2024 Return to top of page
Hurricane VLSI Database Copyright © 2000-2020 Bull S.A. All rights reserved