Coverage for klayout_pex/klayout/lvsdb_extractor.py: 70%
223 statements
« prev ^ index » next coverage.py v7.8.0, created at 2025-03-31 19:36 +0000
1#
2# --------------------------------------------------------------------------------
3# SPDX-FileCopyrightText: 2024 Martin Jan Köhler and Harald Pretl
4# Johannes Kepler University, Institute for Integrated Circuits.
5#
6# This file is part of KPEX
7# (see https://github.com/martinjankoehler/klayout-pex).
8#
9# This program is free software: you can redistribute it and/or modify
10# it under the terms of the GNU General Public License as published by
11# the Free Software Foundation, either version 3 of the License, or
12# (at your option) any later version.
13#
14# This program is distributed in the hope that it will be useful,
15# but WITHOUT ANY WARRANTY; without even the implied warranty of
16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17# GNU General Public License for more details.
18#
19# You should have received a copy of the GNU General Public License
20# along with this program. If not, see <http://www.gnu.org/licenses/>.
21# SPDX-License-Identifier: GPL-3.0-or-later
22# --------------------------------------------------------------------------------
23#
24from __future__ import annotations
26from dataclasses import dataclass
27from functools import cached_property
28import tempfile
29from typing import *
31from klayout.dbcore import PolygonWithProperties
32from rich.pretty import pprint
34import klayout.db as kdb
36import klayout_pex_protobuf.tech_pb2 as tech_pb2
37from ..log import (
38 console,
39 debug,
40 info,
41 warning,
42 error,
43 rule
44)
46from ..tech_info import TechInfo
49GDSPair = Tuple[int, int]
51LayerIndexMap = Dict[int, int] # maps layer indexes of LVSDB to annotated_layout
52LVSDBRegions = Dict[int, kdb.Region] # maps layer index of annotated_layout to LVSDB region
55@dataclass
56class KLayoutExtractedLayerInfo:
57 index: int
58 lvs_layer_name: str # NOTE: this can be computed, so gds_pair is preferred
59 gds_pair: GDSPair
60 region: kdb.Region
63@dataclass
64class KLayoutMergedExtractedLayerInfo:
65 source_layers: List[KLayoutExtractedLayerInfo]
66 gds_pair: GDSPair
69@dataclass
70class KLayoutDeviceTerminal:
71 id: int
72 name: str
73 regions_by_layer_name: Dict[str, kdb.Region]
74 net_name: str
76 # internal data access
77 net_terminal_ref: Optional[kdb.NetTerminalRef]
78 net: Optional[kdb.Net]
81@dataclass
82class KLayoutDeviceTerminalList:
83 terminals: List[KLayoutDeviceTerminal]
86@dataclass
87class KLayoutDeviceInfo:
88 id: str
89 name: str # expanded name
90 class_name: str
91 abstract_name: str
93 terminals: KLayoutDeviceTerminalList
94 params: Dict[str, str]
96 # internal data access
97 device: kdb.Device
100@dataclass
101class KLayoutExtractionContext:
102 lvsdb: kdb.LayoutToNetlist
103 tech: TechInfo
104 dbu: float
105 layer_index_map: LayerIndexMap
106 lvsdb_regions: LVSDBRegions
107 cell_mapping: kdb.CellMapping
108 annotated_top_cell: kdb.Cell
109 annotated_layout: kdb.Layout
110 extracted_layers: Dict[GDSPair, KLayoutMergedExtractedLayerInfo]
111 unnamed_layers: List[KLayoutExtractedLayerInfo]
113 @classmethod
114 def prepare_extraction(cls,
115 lvsdb: kdb.LayoutToNetlist,
116 top_cell: str,
117 tech: TechInfo,
118 blackbox_devices: bool) -> KLayoutExtractionContext:
119 dbu = lvsdb.internal_layout().dbu
120 annotated_layout = kdb.Layout()
121 annotated_layout.dbu = dbu
122 top_cell = annotated_layout.create_cell(top_cell)
124 # CellMapping
125 # mapping of internal layout to target layout for the circuit mapping
126 # https://www.klayout.de/doc-qt5/code/class_CellMapping.html
127 # ---
128 # https://www.klayout.de/doc-qt5/code/class_LayoutToNetlist.html#method18
129 # Creates a cell mapping for copying shapes from the internal layout to the given target layout
130 cm = lvsdb.cell_mapping_into(annotated_layout, # target layout
131 top_cell,
132 not blackbox_devices) # with_device_cells
134 lvsdb_regions, layer_index_map = cls.build_LVS_layer_map(annotated_layout=annotated_layout,
135 lvsdb=lvsdb,
136 tech=tech,
137 blackbox_devices=blackbox_devices)
139 # NOTE: GDS only supports integer properties to GDS,
140 # as GDS does not support string keys,
141 # like OASIS does.
142 net_name_prop = "net"
144 # Build a full hierarchical representation of the nets
145 # https://www.klayout.de/doc-qt5/code/class_LayoutToNetlist.html#method14
146 # hier_mode = None
147 hier_mode = kdb.LayoutToNetlist.BuildNetHierarchyMode.BNH_Flatten
148 # hier_mode = kdb.LayoutToNetlist.BuildNetHierarchyMode.BNH_SubcircuitCells
150 lvsdb.build_all_nets(
151 cmap=cm, # mapping of internal layout to target layout for the circuit mapping
152 target=annotated_layout, # target layout
153 lmap=lvsdb_regions, # maps: target layer index => net regions
154 hier_mode=hier_mode, # hier mode
155 netname_prop=net_name_prop, # property name to which to attach the net name
156 circuit_cell_name_prefix="CIRCUIT_", # NOTE: generates a cell for each circuit
157 net_cell_name_prefix=None, # NOTE: this would generate a cell for each net
158 device_cell_name_prefix=None # NOTE: this would create a cell for each device (e.g. transistor)
159 )
161 extracted_layers, unnamed_layers = cls.nonempty_extracted_layers(lvsdb=lvsdb,
162 tech=tech,
163 annotated_layout=annotated_layout,
164 layer_index_map=layer_index_map,
165 blackbox_devices=blackbox_devices)
167 return KLayoutExtractionContext(
168 lvsdb=lvsdb,
169 tech=tech,
170 dbu=dbu,
171 annotated_top_cell=top_cell,
172 layer_index_map=layer_index_map,
173 lvsdb_regions=lvsdb_regions,
174 cell_mapping=cm,
175 annotated_layout=annotated_layout,
176 extracted_layers=extracted_layers,
177 unnamed_layers=unnamed_layers
178 )
180 @staticmethod
181 def build_LVS_layer_map(annotated_layout: kdb.Layout,
182 lvsdb: kdb.LayoutToNetlist,
183 tech: TechInfo,
184 blackbox_devices: bool) -> Tuple[LVSDBRegions, LayerIndexMap]:
185 # NOTE: currently, the layer numbers are auto-assigned
186 # by the sequence they occur in the LVS script, hence not well defined!
187 # build a layer map for the layers that correspond to original ones.
189 # https://www.klayout.de/doc-qt5/code/class_LayerInfo.html
190 lvsdb_regions: LVSDBRegions = {}
191 layer_index_map: LayerIndexMap = {}
193 if not hasattr(lvsdb, "layer_indexes"):
194 raise Exception("Needs at least KLayout version 0.29.2")
196 for layer_index in lvsdb.layer_indexes():
197 lname = lvsdb.layer_name(layer_index)
199 computed_layer_info = tech.computed_layer_info_by_name.get(lname, None)
200 if computed_layer_info and blackbox_devices:
201 match computed_layer_info.kind:
202 case tech_pb2.ComputedLayerInfo.Kind.KIND_DEVICE_RESISTOR:
203 continue
204 case tech_pb2.ComputedLayerInfo.Kind.KIND_DEVICE_CAPACITOR:
205 continue
207 gds_pair = tech.gds_pair_for_computed_layer_name.get(lname, None)
208 if not gds_pair:
209 li = lvsdb.internal_layout().get_info(layer_index)
210 if li != kdb.LayerInfo():
211 gds_pair = (li.layer, li.datatype)
213 if gds_pair is not None:
214 annotated_layer_index = annotated_layout.layer() # creates new index each time!
215 # Creates a new internal layer! because multiple layers with the same gds_pair are possible!
216 annotated_layout.set_info(annotated_layer_index, kdb.LayerInfo(*gds_pair))
217 region = lvsdb.layer_by_index(layer_index)
218 lvsdb_regions[annotated_layer_index] = region
219 layer_index_map[layer_index] = annotated_layer_index
221 return lvsdb_regions, layer_index_map
223 @staticmethod
224 def nonempty_extracted_layers(lvsdb: kdb.LayoutToNetlist,
225 tech: TechInfo,
226 annotated_layout: kdb.Layout,
227 layer_index_map: LayerIndexMap,
228 blackbox_devices: bool) -> Tuple[Dict[GDSPair, KLayoutMergedExtractedLayerInfo], List[KLayoutExtractedLayerInfo]]:
229 # https://www.klayout.de/doc-qt5/code/class_LayoutToNetlist.html#method18
230 nonempty_layers: Dict[GDSPair, KLayoutMergedExtractedLayerInfo] = {}
232 unnamed_layers: List[KLayoutExtractedLayerInfo] = []
233 lvsdb_layer_indexes = lvsdb.layer_indexes()
234 for idx, ln in enumerate(lvsdb.layer_names()):
235 li = lvsdb_layer_indexes[idx]
236 if li not in layer_index_map:
237 continue
238 li = layer_index_map[li]
239 layer = kdb.Region(annotated_layout.top_cell().begin_shapes_rec(li))
240 layer.enable_properties()
241 if layer.count() >= 1:
242 computed_layer_info = tech.computed_layer_info_by_name.get(ln, None)
243 if not computed_layer_info:
244 warning(f"Unable to find info about extracted LVS layer '{ln}'")
245 gds_pair = (1000 + idx, 20)
246 linfo = KLayoutExtractedLayerInfo(
247 index=idx,
248 lvs_layer_name=ln,
249 gds_pair=gds_pair,
250 region=layer
251 )
252 unnamed_layers.append(linfo)
253 continue
255 if blackbox_devices:
256 match computed_layer_info.kind:
257 case tech_pb2.ComputedLayerInfo.Kind.KIND_DEVICE_RESISTOR:
258 continue
259 case tech_pb2.ComputedLayerInfo.Kind.KIND_DEVICE_CAPACITOR:
260 continue
262 gds_pair = (computed_layer_info.layer_info.drw_gds_pair.layer,
263 computed_layer_info.layer_info.drw_gds_pair.datatype)
265 linfo = KLayoutExtractedLayerInfo(
266 index=idx,
267 lvs_layer_name=ln,
268 gds_pair=gds_pair,
269 region=layer
270 )
272 entry = nonempty_layers.get(gds_pair, None)
273 if entry:
274 entry.source_layers.append(linfo)
275 else:
276 nonempty_layers[gds_pair] = KLayoutMergedExtractedLayerInfo(
277 source_layers=[linfo],
278 gds_pair=gds_pair,
279 )
281 return nonempty_layers, unnamed_layers
283 def top_cell_bbox(self) -> kdb.Box:
284 b1: kdb.Box = self.annotated_layout.top_cell().bbox()
285 b2: kdb.Box = self.lvsdb.internal_layout().top_cell().bbox()
286 if b1.area() > b2.area():
287 return b1
288 else:
289 return b2
291 def shapes_of_net(self, gds_pair: GDSPair, net: kdb.Net) -> Optional[kdb.Region]:
292 lyr = self.extracted_layers.get(gds_pair, None)
293 if not lyr:
294 return None
296 shapes = kdb.Region()
297 shapes.enable_properties()
299 def add_shapes_from_region(source_region: kdb.Region):
300 iter, transform = source_region.begin_shapes_rec()
301 while not iter.at_end():
302 shape = iter.shape()
303 net_name = shape.property('net')
304 if net_name == net.name:
305 shapes.insert(transform * # NOTE: this is a global/initial iterator-wide transformation
306 iter.trans() * # NOTE: this is local during the iteration (due to sub hierarchy)
307 shape.polygon)
308 iter.next()
310 match len(lyr.source_layers):
311 case 0:
312 raise AssertionError('Internal error: Empty list of source_layers')
313 case _:
314 for sl in lyr.source_layers:
315 add_shapes_from_region(sl.region)
317 return shapes
319 def shapes_of_layer(self, gds_pair: GDSPair) -> Optional[kdb.Region]:
320 lyr = self.extracted_layers.get(gds_pair, None)
321 if not lyr:
322 return None
324 shapes: kdb.Region
326 match len(lyr.source_layers):
327 case 0:
328 raise AssertionError('Internal error: Empty list of source_layers')
329 case 1:
330 shapes = lyr.source_layers[0].region
331 case _:
332 # NOTE: currently a bug, for now use polygon-per-polygon workaround
333 # shapes = kdb.Region()
334 # for sl in lyr.source_layers:
335 # shapes += sl.region
336 shapes = kdb.Region()
337 shapes.enable_properties()
338 for sl in lyr.source_layers:
339 iter, transform = sl.region.begin_shapes_rec()
340 while not iter.at_end():
341 p = PolygonWithProperties(iter.shape().polygon, {'net': iter.shape().property('net')})
342 shapes.insert(transform * # NOTE: this is a global/initial iterator-wide transformation
343 iter.trans() * # NOTE: this is local during the iteration (due to sub hierarchy)
344 p)
345 iter.next()
347 return shapes
349 def pins_of_layer(self, gds_pair: GDSPair) -> kdb.Region:
350 pin_gds_pair = self.tech.layer_info_by_gds_pair[gds_pair].pin_gds_pair
351 pin_gds_pair = pin_gds_pair.layer, pin_gds_pair.datatype
352 lyr = self.extracted_layers.get(pin_gds_pair, None)
353 if lyr is None:
354 return kdb.Region()
355 if len(lyr.source_layers) != 1:
356 raise NotImplementedError(f"currently only supporting 1 pin layer mapping, "
357 f"but got {len(lyr.source_layers)}")
358 return lyr.source_layers[0].region
360 def labels_of_layer(self, gds_pair: GDSPair) -> kdb.Texts:
361 labels_gds_pair = self.tech.layer_info_by_gds_pair[gds_pair].label_gds_pair
362 labels_gds_pair = labels_gds_pair.layer, labels_gds_pair.datatype
364 lay: kdb.Layout = self.lvsdb.internal_layout()
365 label_layer_idx = lay.find_layer(labels_gds_pair) # sky130 layer dt = 5
366 if label_layer_idx is None:
367 return kdb.Texts()
369 sh_it = lay.begin_shapes(self.lvsdb.internal_top_cell(), label_layer_idx)
370 labels: kdb.Texts = kdb.Texts(sh_it)
371 return labels
373 @cached_property
374 def top_circuit(self) -> kdb.Circuit:
375 return self.lvsdb.netlist().top_circuit()
377 @cached_property
378 def devices_by_name(self) -> Dict[str, KLayoutDeviceInfo]:
379 dd = {}
381 for d in self.top_circuit.each_device():
382 # https://www.klayout.de/doc-qt5/code/class_Device.html
383 d: kdb.Device
385 param_defs = d.device_class().parameter_definitions()
386 params_by_name = {pd.name: d.parameter(pd.id()) for pd in param_defs}
388 terminals: List[KLayoutDeviceTerminal] = []
390 for td in d.device_class().terminal_definitions():
391 n: kdb.Net = d.net_for_terminal(td.id())
392 if n is None:
393 warning(f"Skipping terminal {td.name} of device {d.expanded_name()} ({d.device_class().name}) "
394 f"is not connected to any net")
395 terminals.append(
396 KLayoutDeviceTerminal(
397 id=td.id(),
398 name=td.name,
399 regions_by_layer_name={},
400 net_name='',
401 net_terminal_ref=None,
402 net=None
403 )
404 )
405 continue
407 for nt in n.each_terminal():
408 nt: kdb.NetTerminalRef
410 if nt.device().expanded_name() != d.expanded_name():
411 continue
412 if nt.terminal_id() != td.id():
413 continue
415 shapes_by_lyr_idx = self.lvsdb.shapes_of_terminal(nt)
417 def layer_name(idx: int) -> str:
418 lyr_info: kdb.LayerInfo = self.annotated_layout.layer_infos()[self.layer_index_map[idx]]
419 return self.tech.canonical_layer_name_by_gds_pair[lyr_info.layer, lyr_info.datatype]
421 shapes_by_lyr_name = {layer_name(idx): shapes for idx, shapes in shapes_by_lyr_idx.items()}
423 terminals.append(
424 KLayoutDeviceTerminal(
425 id=td.id(),
426 name=td.name,
427 regions_by_layer_name=shapes_by_lyr_name,
428 net_name=n.name,
429 net_terminal_ref=nt,
430 net=n
431 )
432 )
434 dd[d.expanded_name()] = KLayoutDeviceInfo(
435 id=d.id(),
436 name=d.expanded_name(),
437 class_name=d.device_class().name,
438 abstract_name=d.device_abstract.name,
439 params=params_by_name,
440 terminals=KLayoutDeviceTerminalList(terminals=terminals),
441 device=d
442 )
444 return dd