scripts/python-skywater-pdk/skywater_pdk/sizes.py - skywater-pdk - Git at Google

 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 #
 # Copyright 2020 SkyWater PDK Authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     https://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # SPDX-License-Identifier: Apache-2.0

 import abc
 import os
 import operator

 from dataclasses import dataclass
 from dataclasses_json import dataclass_json


 def parse_size(s):
     """

     >>> parse_size('_1')
     CellSizeNumeric(units=1)

     >>> parse_size('a2111o_1')
     CellSizeNumeric(units=1)

     >>> parse_size('sky130_fd_sc_ms__sdfrtp_1.v')
     CellSizeNumeric(units=1)

     >>> parse_size('libraries/sky130_fd_sc_ms/v0.0.1/cells/sdfrtp/sky130_fd_sc_ms__sdfrtp_1.v')
     CellSizeNumeric(units=1)

     >>> parse_size('libraries/sky130_fd_sc_ms/v0.0.1/cells/sdfrtp/sky130_fd_sc_ms__sdfrtp_1.bb.blackbox.v')
     CellSizeNumeric(units=1)

     >>> parse_size('libraries/sky130_fd_sc_ms/v0.0.1/cells/sdfrtp/sky130_fd_sc_ms__sdfrtp.v')
     >>> parse_size('sky130_fd_sc_ms__sdfrtp.v')
     >>> parse_size('_blah')
     """
     dirname, s = os.path.split(s)
     if '.' in s:
         s = s.split('.', 1)[0]
     if s.count('_') > 0:
         s = '_' + (s.rsplit('_', 1)[-1])
     if not s or s == '_':
         return None
     try:
         return CellSize.from_suffix(s)
     except InvalidSuffixError as e:
         return None


 class InvalidSuffixError(ValueError):
     def __init__(self, s):
         ValueError.__init__(self, "Invalid suffix: {}".format(s.strip()))


 class CellSize(abc.ABC):
     """Drive strength variants of a given cell.

     See Also
     --------
     skywater_pdk.base.Cell
     skywater_pdk.sizes.CellSizeNumeric
     skywater_pdk.sizes.CellSizeLowPower
     skywater_pdk.sizes.CellSizeMinimum

     Examples
     --------
     >>> d1 = CellSize.from_suffix("_1")
     >>> d2 = CellSize.from_suffix("_lp")
     >>> d3 = CellSize.from_suffix("_m")
     >>> d4 = CellSize.from_suffix("_2")
     >>> CellSize.from_suffix("_abc")
     Traceback (most recent call last):
         ...
     InvalidSuffixError: Invalid suffix: _abc
     >>> l = [d1, d2, d3, d4]
     >>> l
     [CellSizeNumeric(units=1), CellSizeLowPower(lp_variant=0), CellSizeMinimum(), CellSizeNumeric(units=2)]
     >>> l.sort()
     >>> l
     [CellSizeNumeric(units=1), CellSizeNumeric(units=2), CellSizeLowPower(lp_variant=0), CellSizeMinimum()]
     """

     @abc.abstractmethod
     def describe(self):
         raise NotImplementedError

     @property
     @abc.abstractmethod
     def suffix(self):
         raise NotImplementedError

     @classmethod
     def from_suffix(cls, s):
         errors = []
         for subcls in cls.__subclasses__():
             try:
                 return subcls.from_suffix(s)
             except (ValueError, AssertionError) as e:
                 errors.append((subcls.__name__, e))
         assert errors, ("Unknown error!?", s)
         msg = [s, '']
         for cls_name, e in errors:
             if isinstance(e, ValueError):
                 continue
             msg.append("{} failed with: {}".format(cls_name, e))
         raise InvalidSuffixError("\n".join(msg))

     def __str__(self):
         return "with size {}".format(self.describe())

     def _cmp(self, op, o):
         if not isinstance(o, CellSize):
             return False
         return op(self.suffix, o.suffix)

     # Comparison operators
     def __lt__(self, o):
         return self._cmp(operator.lt, o)

     def __le__(self, o):
         return self._cmp(operator.le, o)

     def __eq__(self, o):
         return self._cmp(operator.eq, o)

     def __ne__(self, o):
         return self._cmp(operator.ne, o)

     def __ge__(self, o):
         return self._cmp(operator.ge, o)

     def __gt__(self, o):
         return self._cmp(operator.gt, o)


 @dataclass_json
 @dataclass(frozen=True)
 class CellSizeNumeric(CellSize):
     """

     See Also
     --------
     skywater_pdk.base.Cell
     skywater_pdk.sizes.CellSize
     skywater_pdk.sizes.CellSizeLowPower
     skywater_pdk.sizes.CellSizeMinimum

     Examples
     --------
     >>> s1 = CellSizeNumeric.from_suffix("_1")
     >>> s2 = CellSizeNumeric.from_suffix("_2")
     >>> s3 = CellSizeNumeric.from_suffix("_3")
     >>> CellSizeNumeric.from_suffix("_-1")
     Traceback (most recent call last):
         ...
     InvalidSuffixError: Invalid suffix: _-1
     >>> s1
     CellSizeNumeric(units=1)
     >>> s2
     CellSizeNumeric(units=2)
     >>> s3
     CellSizeNumeric(units=3)
     >>> str(s1)
     'with size of 1 units'
     >>> str(s2)
     'with size of 2 units'
     >>> str(s3)
     'with size of 3 units (invalid?)'
     >>> s1.describe()
     'of 1 units'
     >>> s2.describe()
     'of 2 units'
     >>> s3.describe()
     'of 3 units (invalid?)'
     >>> s1.suffix
     '_1'
     >>> s2.suffix
     '_2'
     >>> s3.suffix
     '_3'
     """
     units: int

     VALID_UNIT_VALUES = (0, 1, 2, 4, 8, 6, 12, 14, 16, 20, 32)

     def describe(self):
         suffix = ""
         if self.units not in self.VALID_UNIT_VALUES:
             suffix = " (invalid?)"

         return "of {} units{}".format(self.units, suffix)

     @property
     def suffix(self):
         return "_{}".format(self.units)

     @classmethod
     def from_suffix(cls, s):
         if not s.startswith("_"):
             raise InvalidSuffixError(s)
         i = int(s[1:])
         if i < 0:
             raise InvalidSuffixError(s)
         return cls(i)


 @dataclass_json
 @dataclass(frozen=True)
 class CellSizeLowPower(CellSize):
     """

     See Also
     --------
     skywater_pdk.base.Cell
     skywater_pdk.sizes.CellSize
     skywater_pdk.sizes.CellSizeNumeric
     skywater_pdk.sizes.CellSizeMinimum

     Examples
     --------
     >>> lp = CellSizeLowPower.from_suffix("_lp")
     >>> lp2 = CellSizeLowPower.from_suffix("_lp2")
     >>> lp3 = CellSizeLowPower.from_suffix("_lp3")
     >>> CellSizeLowPower.from_suffix("_ld")
     Traceback (most recent call last):
         ...
     InvalidSuffixError: Invalid suffix: _ld
     >>> lp
     CellSizeLowPower(lp_variant=0)
     >>> lp2
     CellSizeLowPower(lp_variant=1)
     >>> lp3
     CellSizeLowPower(lp_variant=2)
     >>> str(lp)
     'with size for low power'
     >>> str(lp2)
     'with size for low power (alternative)'
     >>> str(lp3)
     'with size for low power (extra alternative 0)'
     >>> lp.describe()
     'for low power'
     >>> lp2.describe()
     'for low power (alternative)'
     >>> lp3.describe()
     'for low power (extra alternative 0)'
     >>> lp.suffix
     '_lp'
     >>> lp2.suffix
     '_lp2'
     >>> lp3.suffix
     '_lp3'
     """
     lp_variant: int = 0

     def describe(self):
         if self.lp_variant == 0:
             suffix = ""
         elif self.lp_variant == 1:
             suffix = " (alternative)"
         else:
             assert self.lp_variant >= 2, self.lp_variant
             suffix = " (extra alternative {})".format(self.lp_variant-2)
         return "for low power"+suffix

     @property
     def suffix(self):
         if self.lp_variant == 0:
             return "_lp"
         else:
             assert self.lp_variant > 0, self.lp_variant
             return "_lp{}".format(self.lp_variant+1)

     @classmethod
     def from_suffix(cls, s):
         if not s.startswith("_lp"):
             raise InvalidSuffixError(s)
         if s == "_lp":
             return cls()
         elif s == "_lp2":
             return cls(1)
         else:
             try:
                 i = int(s[3:])
             except ValueError as e:
                 raise InvalidSuffixError(s)
             assert i > 2, (s, i)
             return cls(i-1)


 class CellSizeMinimum(CellSize):
     """

     See Also
     --------
     skywater_pdk.base.Cell
     skywater_pdk.sizes.CellSize
     skywater_pdk.sizes.CellSizeNumeric
     skywater_pdk.sizes.CellSizeLowPower


     Examples
     --------
     >>> m = CellSizeMinimum.from_suffix("_m")
     >>> CellSizeMinimum.from_suffix("_m2")
     Traceback (most recent call last):
         ...
     InvalidSuffixError: Invalid suffix: _m2
     >>> m
     CellSizeMinimum()
     >>> str(m)
     'with size minimum'
     >>> m.describe()
     'minimum'
     >>> m.suffix
     '_m'

     >>> m1 = CellSizeMinimum()
     >>> m2 = CellSizeMinimum()
     >>> assert m1 is m2
     """
     _object = None
     def __new__(cls):
         if cls._object is None:
             cls._object = object.__new__(cls)
         return cls._object

     def __repr__(self):
         return "CellSizeMinimum()"

     def describe(self):
         return "minimum"

     @property
     def suffix(self):
         return "_m"

     @classmethod
     def from_suffix(cls, s):
         if s != "_m":
             raise InvalidSuffixError(s)
         return cls()

     def __hash__(self):
         return id(self)

     def to_dict(self):
         return {'minimum': None}


 CellSizeMinimum._object = CellSizeMinimum()


 if __name__ == "__main__":
     import doctest
     doctest.testmod()
	#!/usr/bin/env python3
	# -- coding: utf-8 --
	#
	# Copyright 2020 SkyWater PDK Authors
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# https://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.
	#
	# SPDX-License-Identifier: Apache-2.0

	import abc
	import os
	import operator

	from dataclasses import dataclass
	from dataclasses_json import dataclass_json


	def parse_size(s):
	"""

	>>> parse_size('_1')
	CellSizeNumeric(units=1)

	>>> parse_size('a2111o_1')
	CellSizeNumeric(units=1)

	>>> parse_size('sky130_fd_sc_ms__sdfrtp_1.v')
	CellSizeNumeric(units=1)

	>>> parse_size('libraries/sky130_fd_sc_ms/v0.0.1/cells/sdfrtp/sky130_fd_sc_ms__sdfrtp_1.v')
	CellSizeNumeric(units=1)

	>>> parse_size('libraries/sky130_fd_sc_ms/v0.0.1/cells/sdfrtp/sky130_fd_sc_ms__sdfrtp_1.bb.blackbox.v')
	CellSizeNumeric(units=1)

	>>> parse_size('libraries/sky130_fd_sc_ms/v0.0.1/cells/sdfrtp/sky130_fd_sc_ms__sdfrtp.v')
	>>> parse_size('sky130_fd_sc_ms__sdfrtp.v')
	>>> parse_size('_blah')
	"""
	dirname, s = os.path.split(s)
	if '.' in s:
	s = s.split('.', 1)[0]
	if s.count('_') > 0:
	s = '_' + (s.rsplit('_', 1)[-1])
	if not s or s == '_':
	return None
	try:
	return CellSize.from_suffix(s)
	except InvalidSuffixError as e:
	return None


	class InvalidSuffixError(ValueError):
	def __init__(self, s):
	ValueError.__init__(self, "Invalid suffix: {}".format(s.strip()))


	class CellSize(abc.ABC):
	"""Drive strength variants of a given cell.

	See Also
	--------
	skywater_pdk.base.Cell
	skywater_pdk.sizes.CellSizeNumeric
	skywater_pdk.sizes.CellSizeLowPower
	skywater_pdk.sizes.CellSizeMinimum

	Examples
	--------
	>>> d1 = CellSize.from_suffix("_1")
	>>> d2 = CellSize.from_suffix("_lp")
	>>> d3 = CellSize.from_suffix("_m")
	>>> d4 = CellSize.from_suffix("_2")
	>>> CellSize.from_suffix("_abc")
	Traceback (most recent call last):
	...
	InvalidSuffixError: Invalid suffix: _abc
	>>> l = [d1, d2, d3, d4]
	>>> l
	[CellSizeNumeric(units=1), CellSizeLowPower(lp_variant=0), CellSizeMinimum(), CellSizeNumeric(units=2)]
	>>> l.sort()
	>>> l
	[CellSizeNumeric(units=1), CellSizeNumeric(units=2), CellSizeLowPower(lp_variant=0), CellSizeMinimum()]
	"""

	@abc.abstractmethod
	def describe(self):
	raise NotImplementedError

	@property
	@abc.abstractmethod
	def suffix(self):
	raise NotImplementedError

	@classmethod
	def from_suffix(cls, s):
	errors = []
	for subcls in cls.__subclasses__():
	try:
	return subcls.from_suffix(s)
	except (ValueError, AssertionError) as e:
	errors.append((subcls.__name__, e))
	assert errors, ("Unknown error!?", s)
	msg = [s, '']
	for cls_name, e in errors:
	if isinstance(e, ValueError):
	continue
	msg.append("{} failed with: {}".format(cls_name, e))
	raise InvalidSuffixError("\n".join(msg))

	def __str__(self):
	return "with size {}".format(self.describe())

	def _cmp(self, op, o):
	if not isinstance(o, CellSize):
	return False
	return op(self.suffix, o.suffix)

	# Comparison operators
	def __lt__(self, o):
	return self._cmp(operator.lt, o)

	def __le__(self, o):
	return self._cmp(operator.le, o)

	def __eq__(self, o):
	return self._cmp(operator.eq, o)

	def __ne__(self, o):
	return self._cmp(operator.ne, o)

	def __ge__(self, o):
	return self._cmp(operator.ge, o)

	def __gt__(self, o):
	return self._cmp(operator.gt, o)


	@dataclass_json
	@dataclass(frozen=True)
	class CellSizeNumeric(CellSize):
	"""

	See Also
	--------
	skywater_pdk.base.Cell
	skywater_pdk.sizes.CellSize
	skywater_pdk.sizes.CellSizeLowPower
	skywater_pdk.sizes.CellSizeMinimum

	Examples
	--------
	>>> s1 = CellSizeNumeric.from_suffix("_1")
	>>> s2 = CellSizeNumeric.from_suffix("_2")
	>>> s3 = CellSizeNumeric.from_suffix("_3")
	>>> CellSizeNumeric.from_suffix("_-1")
	Traceback (most recent call last):
	...
	InvalidSuffixError: Invalid suffix: _-1
	>>> s1
	CellSizeNumeric(units=1)
	>>> s2
	CellSizeNumeric(units=2)
	>>> s3
	CellSizeNumeric(units=3)
	>>> str(s1)
	'with size of 1 units'
	>>> str(s2)
	'with size of 2 units'
	>>> str(s3)
	'with size of 3 units (invalid?)'
	>>> s1.describe()
	'of 1 units'
	>>> s2.describe()
	'of 2 units'
	>>> s3.describe()
	'of 3 units (invalid?)'
	>>> s1.suffix
	'_1'
	>>> s2.suffix
	'_2'
	>>> s3.suffix
	'_3'
	"""
	units: int

	VALID_UNIT_VALUES = (0, 1, 2, 4, 8, 6, 12, 14, 16, 20, 32)

	def describe(self):
	suffix = ""
	if self.units not in self.VALID_UNIT_VALUES:
	suffix = " (invalid?)"

	return "of {} units{}".format(self.units, suffix)

	@property
	def suffix(self):
	return "_{}".format(self.units)

	@classmethod
	def from_suffix(cls, s):
	if not s.startswith("_"):
	raise InvalidSuffixError(s)
	i = int(s[1:])
	if i < 0:
	raise InvalidSuffixError(s)
	return cls(i)


	@dataclass_json
	@dataclass(frozen=True)
	class CellSizeLowPower(CellSize):
	"""

	See Also
	--------
	skywater_pdk.base.Cell
	skywater_pdk.sizes.CellSize
	skywater_pdk.sizes.CellSizeNumeric
	skywater_pdk.sizes.CellSizeMinimum

	Examples
	--------
	>>> lp = CellSizeLowPower.from_suffix("_lp")
	>>> lp2 = CellSizeLowPower.from_suffix("_lp2")
	>>> lp3 = CellSizeLowPower.from_suffix("_lp3")
	>>> CellSizeLowPower.from_suffix("_ld")
	Traceback (most recent call last):
	...
	InvalidSuffixError: Invalid suffix: _ld
	>>> lp
	CellSizeLowPower(lp_variant=0)
	>>> lp2
	CellSizeLowPower(lp_variant=1)
	>>> lp3
	CellSizeLowPower(lp_variant=2)
	>>> str(lp)
	'with size for low power'
	>>> str(lp2)
	'with size for low power (alternative)'
	>>> str(lp3)
	'with size for low power (extra alternative 0)'
	>>> lp.describe()
	'for low power'
	>>> lp2.describe()
	'for low power (alternative)'
	>>> lp3.describe()
	'for low power (extra alternative 0)'
	>>> lp.suffix
	'_lp'
	>>> lp2.suffix
	'_lp2'
	>>> lp3.suffix
	'_lp3'
	"""
	lp_variant: int = 0

	def describe(self):
	if self.lp_variant == 0:
	suffix = ""
	elif self.lp_variant == 1:
	suffix = " (alternative)"
	else:
	assert self.lp_variant >= 2, self.lp_variant
	suffix = " (extra alternative {})".format(self.lp_variant-2)
	return "for low power"+suffix

	@property
	def suffix(self):
	if self.lp_variant == 0:
	return "_lp"
	else:
	assert self.lp_variant > 0, self.lp_variant
	return "_lp{}".format(self.lp_variant+1)

	@classmethod
	def from_suffix(cls, s):
	if not s.startswith("_lp"):
	raise InvalidSuffixError(s)
	if s == "_lp":
	return cls()
	elif s == "_lp2":
	return cls(1)
	else:
	try:
	i = int(s[3:])
	except ValueError as e:
	raise InvalidSuffixError(s)
	assert i > 2, (s, i)
	return cls(i-1)


	class CellSizeMinimum(CellSize):
	"""

	See Also
	--------
	skywater_pdk.base.Cell
	skywater_pdk.sizes.CellSize
	skywater_pdk.sizes.CellSizeNumeric
	skywater_pdk.sizes.CellSizeLowPower


	Examples
	--------
	>>> m = CellSizeMinimum.from_suffix("_m")
	>>> CellSizeMinimum.from_suffix("_m2")
	Traceback (most recent call last):
	...
	InvalidSuffixError: Invalid suffix: _m2
	>>> m
	CellSizeMinimum()
	>>> str(m)
	'with size minimum'
	>>> m.describe()
	'minimum'
	>>> m.suffix
	'_m'

	>>> m1 = CellSizeMinimum()
	>>> m2 = CellSizeMinimum()
	>>> assert m1 is m2
	"""
	_object = None
	def __new__(cls):
	if cls._object is None:
	cls._object = object.__new__(cls)
	return cls._object

	def __repr__(self):
	return "CellSizeMinimum()"

	def describe(self):
	return "minimum"

	@property
	def suffix(self):
	return "_m"

	@classmethod
	def from_suffix(cls, s):
	if s != "_m":
	raise InvalidSuffixError(s)
	return cls()

	def __hash__(self):
	return id(self)

	def to_dict(self):
	return {'minimum': None}


	CellSizeMinimum._object = CellSizeMinimum()


	if __name__ == "__main__":
	import doctest
	doctest.testmod()