hwcomponents-library 1.1.0.dev21__py3-none-any.whl

hwcomponents_library/library/jia.py

@@ -0,0 +1,232 @@
+"""
+@ARTICLE{9082159,
+  author={Jia, Hongyang and Valavi, Hossein and Tang, Yinqi and Zhang, Jintao and Verma, Naveen},
+  journal={IEEE Journal of Solid-State Circuits},
+  title={A Programmable Heterogeneous Microprocessor Based on Bit-Scalable In-Memory Computing},
+  year={2020},
+  volume={55},
+  number={9},
+  pages={2609-2621},
+  doi={10.1109/JSSC.2020.2987714}}
+"""
+
+from hwcomponents_library.base import LibraryEstimatorClassBase
+from hwcomponents.scaling import *
+from hwcomponents import actionDynamicEnergy
+
+
+# Original CSV contents:
+# tech_node,global_cycle_period,resolution,voltage,energy,area,action
+# 65nm,      540e-9,              8,         1.2,   2.25,   5000,read
+# 65nm,      540e-9,              8,         1.2,   1.2,    5000,leak
+# 65nm,      540e-9,              8,         1.2,   0,      5000,write|update
+class JiaShiftAdd(LibraryEstimatorClassBase):
+    """
+    The shift-and-add unit from Jia et al. JSSC 2020. This unit will sum and accumulate
+    values in a register, while also shifting the register contents to accept various
+    power-of-two scaling factors for the summed values.
+
+    Parameters
+    ----------
+    tech_node: float
+        Technology node in meters.
+    resolution: int
+        Resolution of the shift-and-add unit in bits. This is the number of bits of each
+        input value that is added to the register.
+    voltage: float
+        Voltage of the shift-and-add unit in volts.
+    """
+
+    component_name = "jia_shift_add"
+    priority = 0.9
+
+    def __init__(self, tech_node: float, resolution: int = 8, voltage: float = 1.2):
+        super().__init__(leak_power=2.22e-6, area=5000.0e-12)
+        self.tech_node: float = self.scale(
+            "tech_node",
+            tech_node,
+            65e-9,
+            tech_node_energy,
+            tech_node_area,
+            tech_node_leak,
+        )
+        self.resolution: int = self.scale(
+            "resolution", resolution, 8, pow_base(2), pow_base(2), pow_base(2)
+        )
+        self.voltage: float = self.scale("voltage", voltage, 1.2, noscale, quadratic, 1)
+
+    @actionDynamicEnergy
+    def shift_and_add(self) -> float:
+        """
+        Returns the energy consumed by a shift+add operation in Joules.
+
+        Returns
+        -------
+        float
+            The energy consumed by a shift+add operation in Joules.
+        """
+
+        return 2.25e-12
+
+    @actionDynamicEnergy
+    def write(self) -> float:
+        """
+        Returns the energy consumed by a shift+add operation in Joules.
+
+        Returns
+        -------
+        float
+            The energy consumed by a shift+add operation in Joules.
+        """
+        return self.shift_and_add()
+
+    @actionDynamicEnergy
+    def read(self) -> float:
+        """
+        Zero Joules to read
+
+        Returns
+        -------
+        float
+            Zero
+        """
+        return 0.0
+
+
+# Original CSV contents:
+# tech_node,global_cycle_period,rows,resolution,voltage,energy,area,action
+# 65nm,      540e-9,              1,   8,         1.2,   0.5,   174, read
+# 65nm,      540e-9,              1,   8,         1.2,   0.2,   174, leak
+# 65nm,      540e-9,              1,   8,         1.2,   0,     174, write|update
+class JiaZeroGate(LibraryEstimatorClassBase):
+    """
+    The zero gating unit from Jia et al. JSSC 2020. This unit gates analog voltages for
+    zero-valued inputs going into the rows of the crossbar array.
+
+    Parameters
+    ----------
+    tech_node: float
+        Technology node in meters.
+    rows: int
+        Number of rows in the crossbar array, equal to the number of checks done by the
+        zero gate.
+    resolution: int
+        Resolution of each input in bits.
+    voltage: float
+        Voltage of the zero gating unit in volts.
+    """
+
+    component_name = "jia_zero_gate"
+    priority = 0.9
+
+    def __init__(
+        self, tech_node: float, rows: int = 1, resolution: int = 8, voltage: float = 1.2
+    ):
+        super().__init__(leak_power=3.70e-7, area=174.0e-12)
+        self.tech_node: float = self.scale(
+            "tech_node",
+            tech_node,
+            65e-9,
+            tech_node_energy,
+            tech_node_area,
+            tech_node_leak,
+        )
+        self.rows: int = self.scale("rows", rows, 1, linear, noscale, noscale)
+        self.resolution: int = self.scale(
+            "resolution", resolution, 8, pow_base(2), pow_base(2), pow_base(2)
+        )
+        self.voltage: float = self.scale("voltage", voltage, 1.2, noscale, quadratic, 1)
+
+    @actionDynamicEnergy(bits_per_action="resolution")
+    def zero_gate(self) -> float:
+        """
+        Returns the energy consumed to zero gate & read an input in Joules.
+
+        Parameters
+        ----------
+        bits_per_action: int
+            The number of bits to check for zero.
+
+        Returns
+        -------
+        float
+            The energy consumed to zero gate & read an input in Joules.
+        """
+        return 0.5e-12
+
+    def read(self) -> float:
+        """
+        Returns the energy consumed to zero gate & read an input in Joules.
+
+        Parameters
+        ----------
+        bits_per_action: int
+            The number of bits to check for zero.
+
+        Returns
+        -------
+        float
+            The energy consumed to zero gate & read an input in Joules.
+        """
+        return self.zero_gate()
+
+
+# Original CSV contents:
+# tech_node,global_cycle_period,voltage,energy,area,  action
+# 65nm,      540e-9,              1.2,   12,     10535,read
+# 65nm,      540e-9,              1.2,   2.4,    10535,leak
+# 65nm,      540e-9,              1.2,   0,      10535,write|update
+class JiaDatapath(LibraryEstimatorClassBase):
+    """
+    The datapath in Jia et al. JSSC 2020. This datapath will perform quantization and
+    activation functions on accumulated ouputs.
+
+    Parameters
+    ----------
+    tech_node: float
+        Technology node in meters.
+    voltage: float
+        Voltage of the datapath in volts.
+
+    """
+
+    component_name = "jia_datapath"
+    priority = 0.9
+
+    def __init__(self, tech_node: float, voltage: float = 1.2):
+        super().__init__(leak_power=4.44e-6, area=10535.0e-12)
+        self.tech_node: float = self.scale(
+            "tech_node",
+            tech_node,
+            65e-9,
+            tech_node_energy,
+            tech_node_area,
+            tech_node_leak,
+        )
+        self.voltage: float = self.scale("voltage", voltage, 1.2, noscale, quadratic, 1)
+
+    @actionDynamicEnergy
+    def process(self) -> float:
+        """
+        Returns the energy consumed by the datapath to quantize and apply activation
+        functions on a single input.
+
+        Returns
+        -------
+        float
+            The energy consumed by the datapath to process an input in Joules.
+        """
+        return 2.4e-12
+
+    @actionDynamicEnergy
+    def read(self) -> float:
+        """
+        Returns the energy consumed by the datapath to quantize and apply activation
+        functions on a single input.
+
+        Returns
+        -------
+        float
+            The energy consumed by the datapath to process an input in Joules.
+        """
+        return self.process()

hwcomponents_library/library/misc.py

@@ -0,0 +1,199 @@
+"""
+@ARTICLE{9131838,
+  author={Giterman, Robert and Shalom, Amir and Burg, Andreas and Fish, Alexander and Teman, Adam},
+  journal={IEEE Solid-State Circuits Letters},
+  title={A 1-Mbit Fully Logic-Compatible 3T Gain-Cell Embedded DRAM in 16-nm FinFET},
+  year={2020},
+  volume={3},
+  number={},
+  pages={110-113},
+  keywords={Random access memory;FinFETs;Temperature measurement;Leakage currents;Power demand;Voltage measurement;Embedded DRAM;gain cell (GC);low voltage;retention time;SRAM},
+  doi={10.1109/LSSC.2020.3006496}}
+"""
+
+from hwcomponents_library.base import LibraryEstimatorClassBase
+from hwcomponents.scaling import *
+from hwcomponents import actionDynamicEnergy
+from hwcomponents_cacti import SRAM
+from hwcomponents_library.library.aladdin import AladdinRegister, AladdinAdder
+
+# Original CSV contents:
+# tech_node,global_cycle_period,width|datawidth,depth,energy,area,action
+# 16nm,1e-9,1024,1024,2641.92,131570,read
+# 16nm,1e-9,1024,1024,2519.04,131570,write|update
+# 16nm,1e-9,1024,1024,0.381,131570,leak
+# # Read: 2.58 uW / MHz
+# # Write: 2.46 uW / MHz
+# # Leak + Refresh: (105uw leak) + (276uW refresh) = 381uW
+# # @ARTICLE{9131838,
+# #   author={Giterman, Robert and Shalom, Amir and Burg, Andreas and Fish, Alexander and Teman, Adam},
+# #   journal={IEEE Solid-State Circuits Letters},
+# #   title={A 1-Mbit Fully Logic-Compatible 3T Gain-Cell Embedded DRAM in 16-nm FinFET},
+# #   year={2020},
+# #   volume={3},
+# #   number={},
+# #   pages={110-113},
+# #   keywords={Random access memory;FinFETs;Temperature measurement;Leakage currents;Power demand;Voltage measurement;Embedded DRAM;gain cell (GC);low voltage;retention time;SRAM},
+# #   doi={10.1109/LSSC.2020.3006496}}
+class RaaamEDRAM(LibraryEstimatorClassBase):
+    """
+    RAAAM EDRAM from Giterman et al. LSSC 2020. This is a MB-class embedded DRAM unit.
+
+    Parameters
+    ----------
+    tech_node: float
+        Technology node in meters.
+    width: int
+        Width of the eDRAM in bits. This is the width of a read/write port. Total size =
+        width * depth.
+    depth: int
+        The number of entries in the eDRAM, each with `width` bits. Total size = width *
+        depth.
+    """
+
+    component_name = "raaam_edram"
+    priority = 0.9
+
+    def __init__(self, tech_node: float, width: int = 1024, depth: int = 1024):
+        super().__init__(leak_power=3.81e-4, area=131570.0e-12)
+        self.tech_node: float = self.scale(
+            "tech_node",
+            tech_node,
+            16e-9,
+            tech_node_energy,
+            tech_node_area,
+            tech_node_leak,
+        )
+        self.width: int = self.scale("width", width, 1024, linear, linear, linear)
+        self.depth: int = self.scale(
+            "depth", depth, 1024, linear, cacti_depth_energy, cacti_depth_energy
+        )
+
+    @actionDynamicEnergy(bits_per_action="width")
+    def read(self) -> float:
+        """
+        Returns the energy consumed by a read operation in Joules.
+
+        Parameters
+        ----------
+        bits_per_action: int
+            The number of bits to read.
+
+        Returns
+        -------
+        float
+            The energy consumed by a read operation in Joules.
+        """
+        return 2641.92e-12
+
+    @actionDynamicEnergy(bits_per_action="width")
+    def write(self) -> float:
+        """
+        Returns the energy consumed by a write operation in Joules.
+
+        Parameters
+        ----------
+        bits_per_action: int
+            The number of bits to write.
+
+        Returns
+        -------
+        float
+            The energy consumed by a write operation in Joules.
+        """
+        return 2519.04e-12
+
+
+class SmartBufferSRAM(LibraryEstimatorClassBase):
+    """
+    An SRAM with an address generator that sequentially reads addresses in the SRAM.
+
+    Parameters
+    ----------
+        tech_node: The technology node in meters.
+        width: The width of the read and write ports in bits. This is the number of bits
+            that are accssed by any one read/write. Total size = width * depth.
+        depth: The number of entries in the SRAM, each with `width` bits. Total size =
+            width * depth.
+        n_rw_ports: The number of read/write ports. Bandwidth will increase with more
+            ports.
+        n_banks: The number of banks. Bandwidth will increase with more banks.
+
+    Attributes
+    ----------
+        sram: The SRAM buffer.
+        address_reg: The register that holds the current address.
+        delta_reg: The register that holds the increment value.
+        adder: The adder that adds the increment value to the current address.
+    """
+    component_name = ["smart_buffer_sram", "smartbuffer_sram", "smartbuffersram"]
+    priority = 0.5
+
+    def __init__(
+            self,
+            tech_node: float,
+            width: int,
+            depth: int,
+            n_rw_ports: int=1,
+            n_banks: int=1,
+    ):
+        self.sram: SRAM = SRAM(
+            tech_node=tech_node,
+            width=width,
+            depth=depth,
+            n_rw_ports=n_rw_ports,
+            n_banks=n_banks,
+        )
+        self.address_bits = max(math.ceil(math.log2(depth)), 1)
+        self.width = width
+
+        self.address_reg = AladdinRegister(width=self.address_bits, tech_node=tech_node)
+        self.delta_reg = AladdinRegister(width=self.address_bits, tech_node=tech_node)
+        self.adder = AladdinAdder(width=self.address_bits, tech_node=tech_node)
+
+        super().__init__(subcomponents=[
+                self.sram,
+                self.address_reg,
+                self.delta_reg,
+                self.adder,
+        ])
+
+    @actionDynamicEnergy(bits_per_action="width")
+    def read(self) -> float:
+        """
+        Returns the energy consumed by a read operation in Joules.
+
+        Parameters
+        ----------
+        bits_per_action: int
+            The number of bits to read.
+
+        Returns
+        -------
+        float
+            The energy consumed by a read operation in Joules.
+        """
+        self.sram.read(bits_per_action=self.width)
+        self.address_reg.read()
+        self.delta_reg.read()
+        self.adder.add()
+
+    @actionDynamicEnergy(bits_per_action="width")
+    def write(self) -> float:
+        """
+        Returns the energy consumed by a write operation in Joules.
+
+        Parameters
+        ----------
+        bits_per_action: int
+            The number of bits to write.
+
+        Returns
+        -------
+        float
+            The energy consumed by a write operation in Joules.
+        """
+        self.sram.write(bits_per_action=self.width)
+        self.address_reg.write()
+        self.delta_reg.read()
+        self.adder.add()

hwcomponents_library/library/newton.py

@@ -0,0 +1,127 @@
+"""
+@ARTICLE{8474954,
+  author={Nag, Anirban and Balasubramonian, Rajeev and Srikumar, Vivek and Walker, Ross and Shafiee, Ali and Strachan, John Paul and Muralimanohar, Naveen},
+  journal={IEEE Micro},
+  title={Newton: Gravitating Towards the Physical Limits of Crossbar Acceleration},
+  year={2018},
+  volume={38},
+  number={5},
+  pages={41-49},
+  doi={10.1109/MM.2018.053631140}}
+"""
+
+from hwcomponents_library.base import LibraryEstimatorClassBase
+from hwcomponents.scaling import *
+from hwcomponents import actionDynamicEnergy
+from .isaac import IsaacADC
+from .isaac import IsaacDAC
+from .isaac import IsaacEDRAM
+from .isaac import IsaacEDRAMBus
+from .isaac import IsaacRouter
+from .isaac import IsaacShiftAdd
+
+
+# Original CSV contents:
+# tech_node,global_cycle_period,resolution,energy,area,action
+# 32nm,1e-9,9,2.58333333333,1500,convert|read
+# 32nm,1e-9,9,0,1500,write|update|leak
+# # Energy: 3.1*10^-3 W / (1.2*10^9 ADC BW) * 10 ^ 12 J->pJ
+# # Newton's adapative ADC resolution table:
+# # 9,9,7,5,1,0,9,3
+# # 9,9,8,6,2,0,9,4
+# # 9,9,9,7,3,1,9,5
+# # 9,9,9,8,4,2,9,6
+# # 8,9,9,9,5,3,9,7
+# # 7,9,9,9,6,4,9,8
+# # 6,8,9,9,7,5,9,9
+# # 5,7,9,9,8,6,9,9
+# # 4,6,9,9,9,7,8,9
+# # 3,5,9,9,9,8,7,9
+# # 2,4,8,9,9,9,6,9
+# # 1,3,7,9,9,9,5,9
+# # 0,2,6,8,9,9,4,9
+# # 0,1,5,7,9,9,3,9
+# # 0,0,4,6,9,9,2,8
+# # 0,0,3,5,9,9,1,7
+# # Newton assumes a linear scaling: 9-bit ADC uses X/9 power for X-bit convert.
+# # Matches with the table above:
+# #    Sum of this table is 832. Sum of full-resolution (all table entries = 9)
+# #    is 1152. This is a 40% reduction, matching with the reported 40%
+# #    ADC power reduction in the paper.
+class NewtonADC(LibraryEstimatorClassBase):
+    """
+    The ADC from the Newton paper. This is a 9-bit ADC that can optionally stop
+    quantizing after a certain number of bits.
+
+    Parameters
+    ----------
+    tech_node: float
+        Technology node in meters.
+    resolution: int
+        Resolution of the ADC in bits.
+    """
+
+    component_name = "newton_adc"
+    priority = 0.9
+
+    def __init__(self, tech_node: float, resolution: int = 9):
+        super().__init__(leak_power=0.0, area=1500.0e-12)
+        self.tech_node: float = self.scale(
+            "tech_node",
+            tech_node,
+            32e-9,
+            tech_node_energy,
+            tech_node_area,
+            tech_node_leak,
+        )
+        self.resolution: int = self.scale(
+            "resolution", resolution, 9, pow_base(2), pow_base(2), pow_base(2)
+        )
+
+    @actionDynamicEnergy
+    def convert(self) -> float:
+        """
+        Returns the energy consumed by a convert operation in Joules.
+
+        Returns
+        -------
+        float
+            The energy consumed by a convert operation in Joules.
+        """
+        return 2.58333333333e-12
+
+    @actionDynamicEnergy
+    def read(self) -> float:
+        """
+        Returns the energy consumed by a convert operation in Joules.
+
+        Returns
+        -------
+        float
+            The energy consumed by a convert operation in Joules.
+        """
+        return 2.58333333333e-12
+
+
+class NewtonADC(IsaacADC):
+    pass
+
+
+class NewtonDAC(IsaacDAC):
+    pass
+
+
+class NewtonRouter(IsaacRouter):
+    pass
+
+
+class NewtonEDRAM(IsaacEDRAM):
+    pass
+
+
+class NewtonEDRAMBus(IsaacEDRAMBus):
+    pass
+
+
+class NewtonShiftAdd(IsaacShiftAdd):
+    pass

hwcomponents_library/library/raella.py

@@ -0,0 +1,89 @@
+"""
+@inproceedings{10.1145/3579371.3589062,
+author = {Andrulis, Tanner and Emer, Joel S. and Sze, Vivienne},
+title = {RAELLA: Reforming the Arithmetic for Efficient, Low-Resolution, and Low-Loss Analog PIM: No Retraining Required!},
+year = {2023},
+isbn = {9798400700958},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+url = {https://doi.org/10.1145/3579371.3589062},
+doi = {10.1145/3579371.3589062},
+abstract = {Processing-In-Memory (PIM) accelerators have the potential to efficiently run Deep Neural Network (DNN) inference by reducing costly data movement and by using resistive RAM (ReRAM) for efficient analog compute. Unfortunately, overall PIM accelerator efficiency is limited by energy-intensive analog-to-digital converters (ADCs). Furthermore, existing accelerators that reduce ADC cost do so by changing DNN weights or by using low-resolution ADCs that reduce output fidelity. These strategies harm DNN accuracy and/or require costly DNN retraining to compensate.To address these issues, we propose the RAELLA architecture. RAELLA adapts the architecture to each DNN; it lowers the resolution of computed analog values by encoding weights to produce near-zero analog values, adaptively slicing weights for each DNN layer, and dynamically slicing inputs through speculation and recovery. Low-resolution analog values allow RAELLA to both use efficient low-resolution ADCs and maintain accuracy without retraining, all while computing with fewer ADC converts.Compared to other low-accuracy-loss PIM accelerators, RAELLA increases energy efficiency by up to 4.9\texttimes{} and throughput by up to 3.3\texttimes{}. Compared to PIM accelerators that cause accuracy loss and retrain DNNs to recover, RAELLA achieves similar efficiency and throughput without expensive DNN retraining.},
+booktitle = {Proceedings of the 50th Annual International Symposium on Computer Architecture},
+articleno = {27},
+numpages = {16},
+keywords = {processing in memory, compute in memory, analog, neural networks, accelerator, architecture, slicing, ADC, ReRAM},
+location = {Orlando, FL, USA},
+series = {ISCA '23}
+}
+"""
+
+from hwcomponents_library.base import LibraryEstimatorClassBase
+from hwcomponents.scaling import *
+from hwcomponents import actionDynamicEnergy
+
+
+# Original CSV contents:
+# tech_node,global_cycle_period,energy,area,n_instances,action
+# 40nm,1e-9,0.25,0,1,multiply|read,
+# 40nm,1e-9,0,0,1,update|leak|write,
+# # Assuming multiplication energy scales linearly with input, weight, and output energy
+# # Efficient processing of DNNs (Sze, 2020): 8b*8b->16b multiply 0.2pJ
+# # 16b * 8b -> 8b multiply: 0.2 pJ
+# # We do this at the L2 (large) tile level, so area will be negligible
+class RaellaQuantMultiplier(LibraryEstimatorClassBase):
+    """
+    The quantization & multipliler from the RAELLA paper. This unit will multiply a
+    partial sum value by a quantization scale to apply linear quntization.
+
+    Parameters
+    ----------
+    tech_node: float
+        Technology node in meters.
+    """
+
+    component_name = "raella_quant_multiplier"
+    priority = 0.9
+
+    def __init__(self, tech_node: float, resolution: int=16):
+        super().__init__(leak_power=0.0, area=0.0e-12)
+        self.tech_node: float = self.scale(
+            "tech_node",
+            tech_node,
+            40e-9,
+            tech_node_energy,
+            tech_node_area,
+            tech_node_leak,
+        )
+        self.resolution: int = self.scale(
+            "resolution",
+            resolution,
+            16,
+            linear,
+            linear,
+            linear
+        )
+
+    @actionDynamicEnergy
+    def multiply(self) -> float:
+        """
+        Returns the energy consumed by a multiply operation in Joules.
+
+        Returns
+        -------
+        float
+            The energy consumed by a multiply operation in Joules.
+        """
+        return 0.25e-12
+
+    @actionDynamicEnergy
+    def read(self) -> float:
+        """
+        Returns the energy consumed by a multiply operation in Joules.
+
+        Returns
+        -------
+        float
+            The energy consumed by a multiply operation in Joules.
+        """
+        return 0.25e-12