Hurricane VLSI Database


Layer.h
1
2// -*- C++ -*-
3//
4// Copyright (c) BULL S.A. 2000-2022, All Rights Reserved
5//
6// This file is part of Hurricane.
7//
8// Hurricane is free software: you can redistribute it and/or modify
9// it under the terms of the GNU Lesser General Public License as
10// published by the Free Software Foundation, either version 3 of the
11// License, or (at your option) any later version.
12//
13// Hurricane is distributed in the hope that it will be useful, but
14// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN-
15// TABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the Lesser GNU
16// General Public License for more details.
17//
18// You should have received a copy of the Lesser GNU General Public
19// License along with Hurricane. If not, see
20// <http://www.gnu.org/licenses/>.
21//
22// +-----------------------------------------------------------------+
23// | H U R R I C A N E |
24// | V L S I B a c k e n d D a t a - B a s e |
25// | |
26// | Author : Remy Escassut |
27// | E-mail : Jean-Paul.Chaput@lip6.fr |
28// | =============================================================== |
29// | C++ Header : "./hurricane/Layer.h" |
30// +-----------------------------------------------------------------+
31
32
33#pragma once
34#include "hurricane/Mask.h"
35#include "hurricane/DBo.h"
36#include "hurricane/Layers.h"
37#include "hurricane/DbU.h"
38#include "hurricane/Box.h"
39#include "hurricane/BasicLayers.h"
40
41
42namespace Hurricane {
43
44
45 class Technology;
46
47
48// -------------------------------------------------------------------
49// Class : "Hurricane::ParallelSpacings".
50
51
52 class ParallelSpacings {
53 public:
54 inline ParallelSpacings ();
55 inline size_t size () const;
56 inline DbU::Unit spacing ( size_t i ) const;
57 inline DbU::Unit parallelLength ( size_t i ) const;
58 inline DbU::Unit maxSpacing () const;
59 inline DbU::Unit maxParallelLength () const;
60 inline void push_back ( DbU::Unit spacing, DbU::Unit parallelLength );
61 private:
62 std::vector< std::pair<DbU::Unit,DbU::Unit> > _spacings;
63 };
64
65
66 inline ParallelSpacings::ParallelSpacings ()
67 : _spacings()
68 { }
69
70 inline size_t ParallelSpacings::size () const { return _spacings.size(); }
71 inline DbU::Unit ParallelSpacings::spacing ( size_t i ) const { return (i < size()) ? _spacings[i].first : 0; }
72 inline DbU::Unit ParallelSpacings::parallelLength ( size_t i ) const { return (i < size()) ? _spacings[i].second : 0; }
73 inline DbU::Unit ParallelSpacings::maxSpacing () const { return _spacings.back().first ; }
74 inline DbU::Unit ParallelSpacings::maxParallelLength () const { return _spacings.back().second; }
75 inline void ParallelSpacings::push_back ( DbU::Unit spacing, DbU::Unit parallelLength )
76 { _spacings.push_back( make_pair( spacing, parallelLength )); }
77
78
79// -------------------------------------------------------------------
80// Class : "Hurricane::SpacingRule".
81
82
83 class SpacingRules {
84 friend class ParallelSpacings;
85 public:
86 inline SpacingRules ( const Layer* );
87 inline size_t parallelsSize () const;
88 inline size_t widthsSize () const;
89 inline const std::vector<DbU::Unit>& parallelLengths () const;
90 const std::vector<DbU::Unit>& widthsRow ( DbU::Unit width ) const;
91 inline DbU::Unit minimalSpacing () const;
92 void print ( std::ostream& ) const;
93 void addSpacingRule ( DbU::Unit minimalSpacing, DbU::Unit width, DbU::Unit parallelLength );
94 void _onDbuChange ( float scale );
95 ParallelSpacings parallelSpacings ( const Box&, bool isHorizontal ) const;
96 private:
97 SpacingRules ( const SpacingRules& ) = delete;
98 private:
99 const Layer* _layer;
100 std::map< DbU::Unit, std::vector<DbU::Unit> > _table;
101 };
102
103
104 inline SpacingRules::SpacingRules ( const Layer* layer )
105 : _layer(layer)
106 , _table()
107 {
108 _table.emplace( -1, std::vector<DbU::Unit>() );
109 }
110
111 inline const std::vector<DbU::Unit>& SpacingRules::parallelLengths () const { return _table.begin()->second; }
112 inline size_t SpacingRules::parallelsSize () const { return parallelLengths().size(); }
113 inline size_t SpacingRules::widthsSize () const { return _table.size() - 1; }
114 inline DbU::Unit SpacingRules::minimalSpacing () const { return (_table.size() < 2) ? 0 : (++_table.begin())->second[0]; }
115
116
117// -------------------------------------------------------------------
118// Class : "Hurricane::Layer".
119
120 class Layer : public DBo {
121 public:
122 typedef DBo Super;
123 typedef Hurricane::Mask<boost::multiprecision::uint128_t> Mask;
124 public:
125 static const uint32_t NoFlags = 0;
126 static const uint32_t EnclosureH = (1 << 0);
127 static const uint32_t EnclosureV = (1 << 1);
128 static const uint32_t EnclosureMax = (1 << 2);
129 static const uint32_t ExtensionCap = (1 << 3);
130 static const uint32_t ExtensionWidth = (1 << 4);
131
132 public:
133 // Accessors.
134 inline void printSpacingTable () const;
135 inline Technology* getTechnology () const;
136 inline const Name& getName () const;
137 inline const Mask& getMask () const;
138 inline const Mask& getExtractMask () const;
139 inline DbU::Unit getMinimalSize () const;
140 DbU::Unit getMinimalSpacing () const;
141 inline ParallelSpacings getParallelSpacings ( const Box&, bool isHorizontal ) const;
142 virtual BasicLayers getBasicLayers () const = 0;
143 virtual const Layer* getBlockageLayer () const;
144 virtual const Layer* getRoutingLayer () const;
145 virtual const Layer* getCut () const;
146 virtual const Layer* getTop () const;
147 virtual const Layer* getBottom () const;
148 virtual const Layer* getOpposite ( const Layer* ) const;
149 Layer* getMetalAbove ( bool useSymbolic=true ) const;
150 Layer* getMetalBelow ( bool useSymbolic=true ) const;
151 Layer* getCutAbove ( bool useSymbolic=true ) const;
152 Layer* getCutBelow ( bool useSymbolic=true ) const;
153 virtual DbU::Unit getEnclosure ( uint32_t flags ) const;
154 virtual DbU::Unit getExtentionCap () const;
155 virtual DbU::Unit getExtentionWidth () const;
156 virtual DbU::Unit getEnclosure ( const BasicLayer* layer, uint32_t flags ) const;
157 virtual DbU::Unit getExtentionCap ( const BasicLayer* layer ) const;
158 virtual DbU::Unit getExtentionWidth ( const BasicLayer* layer ) const;
159 virtual DbU::Unit getTopEnclosure ( uint32_t flags ) const;
160 virtual DbU::Unit getBottomEnclosure ( uint32_t flags ) const;
161 virtual double getMinimalArea () const;
162 // Predicates
163 inline bool above ( const Layer* layer ) const;
164 inline bool below ( const Layer* layer ) const;
165 bool contains ( const Layer* layer ) const;
166 bool intersect ( const Layer* layer ) const;
167 inline bool isSymbolic () const;
168 inline bool isBlockage () const;
169 // Updators
170 void setName ( const Name& name );
171 inline void setSymbolic ( bool );
172 inline void setBlockage ( bool );
173 void setMinimalSize ( DbU::Unit minimalSize );
174 void setMinimalSpacing ( DbU::Unit minimalSpacing, DbU::Unit width, DbU::Unit parallelLength );
175 virtual void setEnclosure ( const BasicLayer* layer, DbU::Unit, uint32_t flags );
176 virtual void setExtentionCap ( const BasicLayer* layer, DbU::Unit );
177 virtual void setExtentionWidth ( const BasicLayer* layer, DbU::Unit );
178 virtual void setMinimalArea ( double );
179 // Hurricane Managment.
180 virtual void _toJson ( JsonWriter* ) const;
181 virtual string _getString () const;
182 virtual Record* _getRecord () const;
183 inline Layer* _getNextOfTechnologyLayerMap () const;
184 inline void _setMask ( const Mask& mask );
185 inline void _setExtractMask ( const Mask& extractMask );
186 inline void _setNextOfTechnologyLayerMap ( Layer* layer );
187 virtual void _onDbuChange ( float scale );
188 static const Name& _sgetName ( const Layer* );
189
190 private:
191 // Internal: Attributes
192 Technology* _technology;
193 Name _name;
194 Mask _mask;
195 Mask _extractMask;
196 DbU::Unit _minimalSize;
197 SpacingRules _spacingRules;
198 Layer* _nextOfTechnologyLayerMap;
199 bool _symbolic;
200 bool _blockage;
201 double _minimalArea;
202
203 protected:
204 // Internal: Constructors & Destructors.
205 Layer ( Technology* technology
206 , const Name& name
207 , const DbU::Unit& minimalSize = 0
208 , const DbU::Unit& minimalSpacing = 0
209 , const DbU::Unit& pitch = 0
210 );
211 virtual void _postCreate ();
212 virtual void _preDestroy ();
213
214 public:
215 struct CompareByMask {
216 inline bool operator() ( const Layer* lhs, const Layer* rhs ) const;
217 };
218 };
219
220
221// Inline Functions.
222 inline void Layer::printSpacingTable () const { return _spacingRules.print( std::cout ); }
223 inline ParallelSpacings Layer::getParallelSpacings ( const Box& bb, bool isHorizontal ) const { return _spacingRules.parallelSpacings(bb,isHorizontal); }
224 inline bool Layer::isSymbolic () const { return _symbolic; }
225 inline bool Layer::isBlockage () const { return _blockage; }
226 inline bool Layer::above ( const Layer* layer ) const { return _mask > layer->getMask(); }
227 inline bool Layer::below ( const Layer* layer ) const { return _mask < layer->getMask(); }
228 inline Technology* Layer::getTechnology () const { return _technology; }
229 inline const Name& Layer::getName () const { return _name; }
230 inline const Layer::Mask& Layer::getMask () const { return _mask; }
231 inline const Layer::Mask& Layer::getExtractMask () const { return _extractMask; }
232 inline DbU::Unit Layer::getMinimalSize () const { return _minimalSize; }
233 inline void Layer::setSymbolic ( bool state ) { _symbolic = state; }
234 inline void Layer::setBlockage ( bool state ) { _blockage = state; }
235 inline Layer* Layer::_getNextOfTechnologyLayerMap () const { return _nextOfTechnologyLayerMap; }
236 inline void Layer::_setMask ( const Mask& mask ) { _mask = mask; }
237 inline void Layer::_setExtractMask ( const Mask& extractMask ) { _extractMask = extractMask; }
238 inline void Layer::_setNextOfTechnologyLayerMap ( Layer* layer ) { _nextOfTechnologyLayerMap = layer; }
239
240 inline bool Layer::CompareByMask::operator() ( const Layer* lhs, const Layer* rhs ) const
241 { return (lhs?lhs->getMask():Layer::Mask()) < (rhs?rhs->getMask():Layer::Mask()); }
242
243
244// -------------------------------------------------------------------
245// Class : "Hurricane::JsonLayer".
246
247 class JsonLayer : public JsonDBo {
248 public:
249 JsonLayer ( unsigned long flags );
250 Technology* lookupTechnology ( JsonStack&, const string& fname ) const;
251 };
252
253
254} // Hurricane namespace.
255
256
257INSPECTOR_P_SUPPORT(Hurricane::Layer);
258INSPECTOR_PR_SUPPORT(Hurricane::Layer::Mask);
Hurricane::BasicLayer
BasicLayer description (API)
Definition BasicLayer.h:42
Hurricane::Box
Box description (API)
Definition Box.h:30
Hurricane::DbU::Unit
std::int64_t Unit
Definition DbU.h:67
Hurricane::Layer
Layer description (API)
Definition Layer.h:120
Hurricane::Layer::setEnclosure
virtual void setEnclosure(const BasicLayer *layer, DbU::Unit, uint32_t flags)
Hurricane::Layer::below
bool below(const Layer *layer) const
Definition Layer.h:227
Hurricane::Layer::setMinimalSpacing
void setMinimalSpacing(DbU::Unit minimalSpacing, DbU::Unit width, DbU::Unit parallelLength)
Hurricane::Layer::getMask
const Mask & getMask() const
Definition Layer.h:230
Hurricane::Layer::getOpposite
virtual const Layer * getOpposite(const Layer *) const
Hurricane::Layer::setExtentionWidth
virtual void setExtentionWidth(const BasicLayer *layer, DbU::Unit)
Hurricane::Layer::getName
const Name & getName() const
Definition Layer.h:229
Hurricane::Layer::getMetalBelow
Layer * getMetalBelow(bool useSymbolic=true) const
Hurricane::Layer::getTop
virtual const Layer * getTop() const
Hurricane::Layer::getBasicLayers
virtual BasicLayers getBasicLayers() const =0
Hurricane::Layer::setExtentionCap
virtual void setExtentionCap(const BasicLayer *layer, DbU::Unit)
Hurricane::Layer::Mask
Hurricane::Mask< boost::multiprecision::uint128_t > Mask
Definition Layer.h:123
Hurricane::Layer::getCutBelow
Layer * getCutBelow(bool useSymbolic=true) const
Hurricane::Layer::getBottom
virtual const Layer * getBottom() const
Hurricane::Layer::getMinimalSize
DbU::Unit getMinimalSize() const
Definition Layer.h:232
Hurricane::Layer::setName
void setName(const Name &name)
Hurricane::Layer::above
bool above(const Layer *layer) const
Definition Layer.h:226
Hurricane::Layer::setMinimalSize
void setMinimalSize(DbU::Unit minimalSize)
Hurricane::Layer::getMetalAbove
Layer * getMetalAbove(bool useSymbolic=true) const
Hurricane::Layer::getCutAbove
Layer * getCutAbove(bool useSymbolic=true) const
Hurricane::Layer::intersect
bool intersect(const Layer *layer) const
Hurricane::Layer::getTechnology
Technology * getTechnology() const
Definition Layer.h:228
Hurricane::Layer::getMinimalSpacing
DbU::Unit getMinimalSpacing() const
Hurricane::Layer::getExtractMask
const Mask & getExtractMask() const
Definition Layer.h:231
Hurricane::Layer::contains
bool contains(const Layer *layer) const
Hurricane::Name
Name description (API)
Definition Name.h:35
Hurricane::Technology
Technological rules description (API).
Definition Technology.h:62
Hurricane
Contains Almost Everything.
Definition BasicLayer.h:39

Generated by doxygen 1.13.2 on Fri Sep 27 2024 Return to top of page
Hurricane VLSI Database Copyright © 2000-2020 Bull S.A. All rights reserved