hwcomponents-adc 0.1__tar.gz

hwcomponents_adc-0.1/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: hwcomponents-adc
+Version: 0.1
+Summary: A package for estimating the energy and area of Analog-Digital Converters
+Author-email: Tanner Andrulis <Andrulis@mit.edu>
+License: MIT
+Keywords: accelerator,hardware,energy,estimation,analog,adc
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: PyYAML
+Requires-Dist: numpy
+Requires-Dist: pandas
+
+# HWComponents-ADC
+HWComponents-ADC models the area and energy of Analog-Digital Converters (ADCs) for use
+in analog & mixed-signal accelerator designs.
+
+Models are based on statistical analysis of published ADC performance data in Boris
+Murmann's ADC Performance Survey [1]. The energy model is based on the observation that
+the maximum efficiency of an ADC is bounded by the sampling rate and the resolution [1],
+and the area model is based on regression analysis. Estimations are optimistic; they
+answer the question "what is the best possible ADC design for the given parameters?".
+
+## Installation
+Clone the repository and install with pip:
+
+```bash
+git clone https://github.com/Accelergy-Project/hwcomponents-adc.git
+cd hwcomponents-adc
+pip install .
+
+# Check that the installation is successful
+hwc --list | grep ADC
+```
+
+## Usage
+### Inerface
+
+This model introduces the ADC model. ADC models can be instantiated with the
+following parameters:
+- `n_bits`: the resolution of the ADC
+- `tech_node`: the technology node in meters
+- `n_adcs`: the number of ADCs working together, in the case of alternating
+  ADCs
+- `throughput`: the aggregate throughput of the ADCs, in samples per second
+
+ADCs support the following actions:
+- `read` or `convert`: Convert a single value from analog to digital. Note: if
+  there are multiple ADCs, this is a single conversion from a single ADC.
+
+### Exploring Tradeoffs
+There are several tradeoffs available around ADC design:
+- Lower-resolution ADCs are smaller and more energy-efficient.
+- Using more ADCs in parallel allows for a lower frequency, but increases the
+  area.
+- Using fewer ADCs in parallel allows for a higher frequency. Up to a point,
+  this will not increase the area or energy/area of the ADCs. However, at some
+  this will result in an exponential increase in energy/area.
+- Lower-resolution ADCs can run at higher frequencies before the exponential
+  increase in energy/area occurs.
+
+When the HWComponents-ADC runs, it will output a list of alternative design options.
+Each will report a number of ADCs and frequency needed to achieve the desired
+throughput, as well as the area and energy of the ADCs. You can then use this
+information to make tradeoffs between ADC resolution, frequency, and number of
+ADCs.
+
+HWComponents-ADC is the work of Tanner Andrulis & Ruicong Chen.
+
+## Updating the ADC Model
+The generated ADC model is based on the data in Boris Murmann's survey [1],
+included in the submodule. This survey is updated periodically. The model can
+be update to reflect the most recent data by running the following:
+
+```bash
+pip3 install scikit-learn
+pip3 install pandas
+pip3 install numpy
+git submodule update --init --recursive --remote
+python3 update_model.py
+```
+
+This is only necessary if more recent data is published. If the data here is
+out of date, please open an issue or pull request.
+
+## References
+[1] B. Murmann, "ADC Performance Survey 1997-2023," [Online]. Available:
+https://github.com/bmurmann/ADC-survey
+
+## License
+This work is licensed under the MIT license. See license.txt for details.
+
+## Citing HWComponents-ADC
+If you use this model in your work, please cite the following:
+
+```bibtex
+@misc{andrulis2024modelinganalogdigitalconverterenergyarea,
+      title={Modeling Analog-Digital-Converter Energy and Area for Compute-In-Memory Accelerator Design}, 
+      author={Tanner Andrulis and Ruicong Chen and Hae-Seung Lee and Joel S. Emer and Vivienne Sze},
+      year={2024},
+      eprint={2404.06553},
+      archivePrefix={arXiv},
+      primaryClass={cs.AR},
+      url={https://arxiv.org/abs/2404.06553}, 
+}
+```

hwcomponents_adc-0.1/README.md

@@ -0,0 +1,93 @@
+# HWComponents-ADC
+HWComponents-ADC models the area and energy of Analog-Digital Converters (ADCs) for use
+in analog & mixed-signal accelerator designs.
+
+Models are based on statistical analysis of published ADC performance data in Boris
+Murmann's ADC Performance Survey [1]. The energy model is based on the observation that
+the maximum efficiency of an ADC is bounded by the sampling rate and the resolution [1],
+and the area model is based on regression analysis. Estimations are optimistic; they
+answer the question "what is the best possible ADC design for the given parameters?".
+
+## Installation
+Clone the repository and install with pip:
+
+```bash
+git clone https://github.com/Accelergy-Project/hwcomponents-adc.git
+cd hwcomponents-adc
+pip install .
+
+# Check that the installation is successful
+hwc --list | grep ADC
+```
+
+## Usage
+### Inerface
+
+This model introduces the ADC model. ADC models can be instantiated with the
+following parameters:
+- `n_bits`: the resolution of the ADC
+- `tech_node`: the technology node in meters
+- `n_adcs`: the number of ADCs working together, in the case of alternating
+  ADCs
+- `throughput`: the aggregate throughput of the ADCs, in samples per second
+
+ADCs support the following actions:
+- `read` or `convert`: Convert a single value from analog to digital. Note: if
+  there are multiple ADCs, this is a single conversion from a single ADC.
+
+### Exploring Tradeoffs
+There are several tradeoffs available around ADC design:
+- Lower-resolution ADCs are smaller and more energy-efficient.
+- Using more ADCs in parallel allows for a lower frequency, but increases the
+  area.
+- Using fewer ADCs in parallel allows for a higher frequency. Up to a point,
+  this will not increase the area or energy/area of the ADCs. However, at some
+  this will result in an exponential increase in energy/area.
+- Lower-resolution ADCs can run at higher frequencies before the exponential
+  increase in energy/area occurs.
+
+When the HWComponents-ADC runs, it will output a list of alternative design options.
+Each will report a number of ADCs and frequency needed to achieve the desired
+throughput, as well as the area and energy of the ADCs. You can then use this
+information to make tradeoffs between ADC resolution, frequency, and number of
+ADCs.
+
+HWComponents-ADC is the work of Tanner Andrulis & Ruicong Chen.
+
+## Updating the ADC Model
+The generated ADC model is based on the data in Boris Murmann's survey [1],
+included in the submodule. This survey is updated periodically. The model can
+be update to reflect the most recent data by running the following:
+
+```bash
+pip3 install scikit-learn
+pip3 install pandas
+pip3 install numpy
+git submodule update --init --recursive --remote
+python3 update_model.py
+```
+
+This is only necessary if more recent data is published. If the data here is
+out of date, please open an issue or pull request.
+
+## References
+[1] B. Murmann, "ADC Performance Survey 1997-2023," [Online]. Available:
+https://github.com/bmurmann/ADC-survey
+
+## License
+This work is licensed under the MIT license. See license.txt for details.
+
+## Citing HWComponents-ADC
+If you use this model in your work, please cite the following:
+
+```bibtex
+@misc{andrulis2024modelinganalogdigitalconverterenergyarea,
+      title={Modeling Analog-Digital-Converter Energy and Area for Compute-In-Memory Accelerator Design}, 
+      author={Tanner Andrulis and Ruicong Chen and Hae-Seung Lee and Joel S. Emer and Vivienne Sze},
+      year={2024},
+      eprint={2404.06553},
+      archivePrefix={arXiv},
+      primaryClass={cs.AR},
+      url={https://arxiv.org/abs/2404.06553}, 
+}
+```

hwcomponents_adc-0.1/hwcomponents_adc/__init__.py

@@ -0,0 +1 @@
+from .main import ADC as ADC

hwcomponents_adc-0.1/hwcomponents_adc/adc_data/model.yaml

@@ -0,0 +1,40 @@
+frequency (Hz):
+  max value: 23.025850929940457
+FOMS_hf [dB]:
+  frequency (Hz): -2.8719030399529957
+  max value: 164.7143258245858
+  intercept: 213.7806687348118
+  max_by_enob:
+  - 128.3068287398817
+  - 131.52734025085925
+  - 134.7478517618368
+  - 137.96836327281437
+  - 141.18887478379193
+  - 144.4093862947695
+  - 147.62989780574708
+  - 150.85040931672464
+  - 154.0709208277022
+  - 157.29143233867975
+  - 160.5119438496573
+  - 163.73245536063487
+  - 166.95296687161243
+  - 170.17347838259
+  - 173.39398989356755
+  - 176.61450140454514
+  - 179.83501291552267
+  - 183.05552442650026
+  - 186.27603593747781
+  - 189.49654744845537
+  - 192.71705895943293
+  tech intercept: 26.0496215686518
+  tech slope: 1.8800369206815004
+  enob slope: -2.8291256050594527
+  energy (pJ/op) res: -1.4702022133784405
+comments: Tech node, area, and frequency are log-base-e-scaled. max_by_enob was also
+  considered for limiting the frequency of ADCs, but max ADC frequency was plenty
+  for realistic PIM settings at reasonable ADC resolutions.
+area (um^2):
+  tech node (nm): 0.9932794744745022
+  frequency (Hz): 0.18071538424508238
+  energy (pJ/op): 0.29912426192653485
+  intercept: 1.3461916439910742

hwcomponents_adc-0.1/hwcomponents_adc/headers.py

@@ -0,0 +1,68 @@
+"""
+This file includes constants and headers that are used across the different
+scripts in this plugin.
+"""
+
+import math
+import os
+
+# ==============================================================================
+# Design parameters
+# ==============================================================================
+FREQ = "frequency (Hz)"  # Hz
+TECH = "tech node (nm)"  # nm
+ENOB = "number of bits"  # bits
+DESIGN_PARAMS = [FREQ, TECH, ENOB]
+AREA = "area (um^2)"  # ln(um^2)
+ENRG = "energy (pJ/op)"  # pJ / op
+FOMS = "FOMS_hf [dB]"
+SNDR = "SNDR_plot [dB]"
+ALL_PARAMS = DESIGN_PARAMS + [AREA, ENRG, FOMS]
+AREA_CALCULATE_PARAMS = [TECH, FREQ, ENRG]
+LOGSCALE_PARAMS = [FREQ, TECH, AREA, ENRG]
+
+# For fitted energy / area
+ENRG_RESIDUAL = f"{ENRG} res"
+INTERCEPT = "intercept"  # Constant factor for fitting
+TECH_INTERCEPT = "tech intercept"
+TECH_SLOPE = "tech slope"
+ENOB_SLOPE = "enob slope"
+
+# ==============================================================================
+# Model file
+# ==============================================================================
+MIN = "min value"
+MAX = "max value"
+MAX_BY_ENOB = "max_by_enob"
+AREA_ENRG_TRADEOFF = "area/energy tradeoff"
+AREA_ENRG_MODEL = "model"
+AREA_COEFF = "area coeff"
+CONSTRAINTS = "constraints"
+DESIGN_PARAM_MODEL = "design param model"
+COMMENTS = "comments"
+AREA_QUANTILE = 0.1  # Use bottom 10% of area
+
+# ==============================================================================
+# Paths
+# ==============================================================================
+CURRENT_DIR = os.path.dirname(__file__)
+ADC_LIST_DEFAULT = os.path.join(CURRENT_DIR, "adc_data/adc_list.csv")
+MODEL_DEFAULT = os.path.join(CURRENT_DIR, "adc_data/model.yaml")
+
+
+# ==============================================================================
+# Helper functions
+# ==============================================================================
+def dict_key_true(dict_to_check: dict, key: str) -> bool:
+    """Returns true if key in is dict and is not none"""
+    return dict_to_check and key in dict_to_check and dict_to_check[key]
+
+
+def bits2sndr(bits: int) -> float:
+    """Calculates the SNDR of an ADC from its resolution"""
+    return bits * 20 * math.log(2, 10) + 10 * math.log(1.5, 10)
+
+
+def sndr2bits(sndr: float) -> float:
+    """Calculates the resolution of an ADC from its sndr"""
+    return (sndr - 10 * math.log(1.5, 10)) / (20 * math.log(2, 10))

hwcomponents_adc-0.1/hwcomponents_adc/main.py

@@ -0,0 +1,222 @@
+import logging
+import sys
+import os
+import re
+from typing import Dict, List
+import yaml
+from hwcomponents_adc.headers import *
+from .optimizer import ADCRequest
+from hwcomponents import EnergyAreaModel, actionDynamicEnergy
+
+SCRIPT_DIR = os.path.abspath(os.path.dirname(__file__))
+
+MODEL_FILE = os.path.join(SCRIPT_DIR, "adc_data/model.yaml")
+
+CLASS_NAMES = [
+    "adc",
+    "pim_adc",
+    "sar_adc",
+    "array_adc",
+    "pim_array_adc",
+    "cim_array_adc",
+    "cim_adc",
+]
+ACTION_NAMES = ["convert", "drive", "read", "sample", "leak", "activate"]
+
+# ==============================================================================
+# Input Parsing
+# ==============================================================================
+
+
+def adc_attr_to_request(attributes: Dict, logger: logging.Logger) -> ADCRequest:
+    """Creates an ADC Request from a list of attributes"""
+
+    def checkerr(attr, numeric):
+        assert attr in attributes, f"No attribute found: {attr}"
+        if numeric and isinstance(attributes[attr], str):
+            v = re.findall(r"(\d*\.?\d+|\d+\.?\d*)", attributes[attr])
+            assert v, f"No numeric found for attribute: {attr}"
+            return float(v[0])
+        return attributes[attr]
+
+    try:
+        n_adcs = int(checkerr("n_adcs", numeric=True))
+    except AssertionError:
+        n_adcs = 1
+
+    def try_check(keys, numeric):
+        for k in keys[:-1]:
+            try:
+                return checkerr(k, numeric)
+            except AssertionError:
+                pass
+        return checkerr(keys[-1], numeric)
+
+    resolution_names = []
+    for x0 in ["adc", ""]:
+        for x1 in ["resolution", "bits", "n_bits"]:
+            for x2 in ["adc", ""]:
+                x = "_".join([x for x in [x0, x1, x2] if x != ""])
+                resolution_names.append(x)
+    resolution_names.append("resolution")
+
+    r = ADCRequest(
+        bits=try_check(resolution_names, numeric=True),
+        tech=float(checkerr("tech_node", numeric=True)),
+        throughput=float(checkerr("throughput", numeric=True)),
+        n_adcs=n_adcs,
+        logger=logger,
+    )
+    return r
+
+
+def dict_to_str(attributes: Dict) -> str:
+    """Converts a dictionary into a multi-line string representation"""
+    s = "\n"
+    for k, v in attributes.items():
+        s += f"\t{k}: {v}\n"
+    return s
+
+
+class ADC(EnergyAreaModel):
+    """
+    Analog digital converter (ADC) model based on https://arxiv.org/abs/2404.06553.
+
+    Args:
+        n_bits: The number of bits of the ADC. For those who are not familiar with ADCs,
+           ignore the following: this is assumed to be the effective number of bits
+           (ENOB), not the bit precision of the output.
+        tech_node: The technology node of the ADC in meters.
+        throughput: The throughput of the ADC in samples per second.
+        n_adcs: The number of ADCs. If there is >1 ADC, then throughput is the total
+           throughput of all ADCs.
+
+    Attributes:
+        n_bits: The number of bits of the ADC.
+        tech_node: The technology node of the ADC in meters.
+        throughput: The throughput of the ADC in samples per second.
+        n_adcs: The number of ADCs.
+    """
+    component_name = [
+        "adc",
+        "pim_adc",
+        "sar_adc",
+        "array_adc",
+        "pim_array_adc",
+        "cim_array_adc",
+        "cim_adc",
+    ]
+    priority = 0.75
+
+    def __init__(self, n_bits: int, tech_node: float, throughput: float, n_adcs=1):
+        self.n_bits = n_bits
+        self.tech_node = tech_node
+        self.throughput = throughput
+        self.n_adcs = n_adcs
+
+        self._model = self.make_model()
+
+        assert self.n_bits >= 4, f"Bits must be >= 4"
+
+        area = self._get_area()
+        # Assume leakage is 20% of the total energy
+        leak_power = self.get_energy() * self.throughput * 0.2
+        super().__init__(leak_power=leak_power, area=area)
+
+    def make_model(self):
+        if not os.path.exists(MODEL_FILE):
+            self.logger.info(f'python3 {os.path.join(SCRIPT_DIR, "run.py")} -g')
+            os.system(f'python3 {os.path.join(SCRIPT_DIR, "run.py")} -g')
+        if not os.path.exists(MODEL_FILE):
+            self.logger.error(f"ERROR: Could not find model file: {MODEL_FILE}")
+            self.logger.error(
+                f'Try running: "python3 {os.path.join(SCRIPT_DIR, "run.py")} '
+                f'-g" to generate a model.'
+            )
+        with open(MODEL_FILE, "r") as f:
+            self._model = yaml.safe_load(f)
+        return self._model
+
+    def _get_area(self) -> float:
+        """
+        Returns the area of the ADC in um^2
+        """
+        request = adc_attr_to_request(
+            {
+                "n_bits": self.n_bits,
+                "tech_node": self.tech_node,
+                "throughput": self.throughput,
+                "n_adcs": self.n_adcs,
+            },
+            self.logger,
+        )
+        return request.area(self._model) * 1e-12  # um^2 -> m^2
+
+    def get_energy(self):
+        """
+        Returns the energy for one ADC conversion in Joules.
+
+        Returns:
+            The energy for one ADC conversion in Joules.
+        """
+        request = adc_attr_to_request(
+            {
+                "n_bits": self.n_bits,
+                "tech_node": self.tech_node,
+                "throughput": self.throughput,
+                "n_adcs": self.n_adcs,
+            },
+            self.logger,
+        )
+        return request.energy_per_op(self._model) * 1e-12  # pJ -> J
+
+    @actionDynamicEnergy
+    def convert(self):
+        """
+        Returns the energy for one ADC conversion in Joules.
+
+        Returns:
+            The energy for one ADC conversion in Joules.
+        """
+        # Assume leakage is 20% of the total energy
+        return self.get_energy() * 0.8
+
+    @actionDynamicEnergy
+    def drive(self):
+        """
+        Returns the energy for one ADC conversion in Joules.
+
+        Returns:
+            The energy for one ADC conversion in Joules.
+        """
+        return self.convert()
+
+    @actionDynamicEnergy
+    def read(self):
+        """
+        Returns the energy for one ADC conversion in Joules.
+
+        Returns:
+            The energy for one ADC conversion in Joules.
+        """
+        return self.convert()
+
+    @actionDynamicEnergy
+    def sample(self):
+        """
+        Returns the energy for one ADC conversion in Joules.
+
+        Returns:
+            The energy for one ADC conversion in Joules.
+        """
+        return self.convert()
+
+    @actionDynamicEnergy
+    def activate(self):
+        """
+        Returns the energy for one ADC conversion in Joules.
+
+        Returns:
+            The energy for one ADC conversion in Joules.
+        """
+        return self.convert()

hwcomponents_adc-0.1/hwcomponents_adc/model.py

@@ -0,0 +1,289 @@
+from typing import Dict, Tuple
+import yaml
+
+from hwcomponents_adc.headers import *
+import logging
+import math
+
+logger = logging.getLogger(__name__)
+
+
+def foms_sndr2energy(foms: float, sndr: float) -> float:
+    """Calculates the energy of an ADC from its Schreier FOM and SNDR"""
+    return 1 / ((10 ** ((foms - sndr) / 10)) * 2)
+
+
+def get_area(params: Dict, model: Dict) -> float:
+    """
+    Returns the energy/convert of an ADC given its design parameters.
+    """
+    params = params.copy()
+    params[INTERCEPT] = 1  # Multiply model intercept by 1
+    assert all(k in params for k in model[AREA].keys()), (
+        f"Design parameters and model parameters do not match. Please "
+        f"regenergate ADC model."
+    )
+    return math.exp(sum(params[k] * model[AREA][k] for k in model[AREA].keys()))
+
+
+def get_energy(params: Dict, model: Dict, allow_extrapolation: bool) -> float:
+    """
+    Returns the energy/convert of an ADC given its design parameters.
+    """
+    params = params.copy()
+    params[INTERCEPT] = 1  # Multiply model intercept by 1
+    warning_txt = (
+        f"Frequency {math.exp(params[FREQ]):2E} is greater than the maximum "
+        f"frequency {math.exp(model[FREQ][MAX]):2E} in the model."
+    )
+    err_txt = warning_txt + " Please use a lower frequency ADC or enable extrapolation."
+    if not allow_extrapolation:
+        assert params[FREQ] <= model[FREQ][MAX], err_txt
+    elif params[FREQ] > model[FREQ][MAX]:
+        logger.warning(warning_txt)
+
+    foms = sum(params[k] * model[FOMS][k] for k in [INTERCEPT, FREQ])
+    foms_max_by_enob = model[FOMS][MAX_BY_ENOB]
+    foms_max = foms_max_by_enob[
+        max(min(math.ceil(params[ENOB]), len(foms_max_by_enob) - 1), 0)
+    ]
+    foms = min(foms, foms_max)
+    energy = foms_sndr2energy(foms, bits2sndr(params[ENOB]))
+
+    return energy * math.exp(
+        model[FOMS][TECH_INTERCEPT]
+        + model[FOMS][TECH_SLOPE] * (params[TECH])
+        + model[FOMS][ENOB_SLOPE] * math.log(params[ENOB])
+        + model[FOMS][ENRG_RESIDUAL]
+    )
+
+
+def mvgress(
+    x: "pd.DataFrame", y: "pd.Series"
+) -> Tuple["pd.Series", "np.ndarray", float]:
+    """
+    Returns the residuals, coeffs, and intercept of a multivariate linear
+    regression.
+    """
+    from sklearn import linear_model
+    import pandas as pd
+
+    if isinstance(x, pd.Series):
+        x = pd.DataFrame(x)
+    lm = linear_model.LinearRegression()
+    x_ = x
+    lm.fit(x_, y)
+    logger.info(f"Correlation: {lm.score(x_, y)}")
+    return y - lm.predict(x_), lm.coef_, lm.intercept_
+
+
+def get_pareto(
+    x: "pd.Series",
+    y: "pd.Series",
+    x_positive=True,
+    y_positive=True,
+    allow_interior_points: int = 1,
+) -> "pd.DataFrame":
+    """
+    Returns the pareto set of x, y.
+    """
+    assert len(x) == len(y), "x and y must be the same length"
+
+    def more_value(a, b, pos):
+        return a >= b if pos else a <= b
+
+    chosen = []
+    for i in range(len(x)):
+        if (
+            len(x)
+            - sum(
+                more_value(x[i], x[j], x_positive) or more_value(y[i], y[j], y_positive)
+                for j in range(len(x))
+            )
+            < allow_interior_points
+        ):
+            chosen.append(i)
+
+    return x[chosen], y[chosen]
+
+
+def build_model(
+    source_data: "pd.DataFrame", output_file: str, show_pretty_plot=False
+) -> Dict:
+    import numpy as np
+    import pandas as pd
+
+    # Ensure adc_data is valid
+    logger.info("Building model. Source adc_data:")
+    logger.info(source_data.head(5))
+    for c in ALL_PARAMS:
+        assert c in source_data, f"Missing adc_data column {c}!"
+    for index, row in source_data.iterrows():
+        for c in ALL_PARAMS:
+            assert isinstance(
+                row[c], float
+            ), f"Invalid value in row {index} column {c}: {row[c]}"
+
+    # Log columns
+    logscale_data = source_data.copy()
+    for c in LOGSCALE_PARAMS:
+        logscale_data[c] = np.log(source_data[c])
+
+    # Remove outliers
+    OUTLIER_THRESHOLD = 0.8
+
+    # Adjust the FOMS by tech node
+    residual, coeffs, intercept = mvgress(logscale_data[ENOB], logscale_data[TECH])
+    logscale_data["FOMS_ADJUSTED"] = (
+        logscale_data[FOMS] - coeffs[0] * logscale_data[TECH] - intercept
+    )
+    logscale_data["log ENOB"] = np.log(logscale_data[ENOB])
+    logscale_data = logscale_data.dropna().reset_index(drop=True)
+
+    # ENERGY
+    foms_max = logscale_data["FOMS_ADJUSTED"].quantile(OUTLIER_THRESHOLD)
+    print(f"Maximum FOMS: {foms_max}")
+
+    residuals, coeffs, intercept = mvgress(
+        logscale_data[ENOB], logscale_data["FOMS_ADJUSTED"]
+    )
+    intercept += pd.Series(residuals).quantile(OUTLIER_THRESHOLD)
+    foms_max_by_enob_x = np.arange(math.ceil(np.max(logscale_data[ENOB]) + 1)).reshape(
+        -1, 1
+    )
+    foms_max_by_enob = [float(intercept + coeffs[0] * x) for x in foms_max_by_enob_x]
+
+    freq_max = np.log(1e10)  # logscale_data[FREQ].quantile(TH3)
+    fr = logscale_data[FREQ]
+    fs = logscale_data["FOMS_ADJUSTED"]
+    freq_for_pareto = fr[(fs <= fs.quantile(OUTLIER_THRESHOLD))].reset_index(drop=True)
+    foms_for_pareto = fs[(fs <= fs.quantile(OUTLIER_THRESHOLD))].reset_index(drop=True)
+    pgroup_freq, pgroup_foms = get_pareto(
+        freq_for_pareto,
+        foms_for_pareto,
+        allow_interior_points=round(len(freq_for_pareto) * 0.05),
+    )
+    _, foms_coeffs, foms_intercept = mvgress(pgroup_freq, pgroup_foms)
+
+    def get_max_foms(enob, freq):
+        max_by_enob = foms_max_by_enob[round(enob)]
+        max_by_freq = foms_coeffs[0] * freq + foms_intercept
+        return min(max_by_enob, max_by_freq)
+
+    max_foms = logscale_data.apply(lambda x: get_max_foms(x[ENOB], x[FREQ]), axis=1)
+    pred_energy = foms_sndr2energy(max_foms, bits2sndr(logscale_data[ENOB]))
+    error = np.log(np.exp(logscale_data[ENRG]) / pred_energy)
+    logscale_data["log ENOB"] = np.log(logscale_data[ENOB])
+    tech_energy_residuals, tech_energy_coeffs, tech_energy_intercept = mvgress(
+        logscale_data[[TECH, "log ENOB"]], error
+    )
+    print(
+        f"Residuals-tech correlation: {np.corrcoef(logscale_data[TECH], tech_energy_residuals)[0, 1]}"
+    )
+    print(
+        f"Predicted-actual energy correlation: {np.corrcoef(logscale_data[ENRG], np.log(pred_energy))[0, 1]}"
+    )
+    pred_energy = pred_energy * np.exp(
+        tech_energy_intercept
+        + tech_energy_coeffs[0] * logscale_data[TECH]
+        + tech_energy_coeffs[1] * logscale_data["log ENOB"]
+    )
+    print(
+        f"Predicted-actual energy correlation: {np.corrcoef(logscale_data[ENRG], np.log(pred_energy))[0, 1]}"
+    )
+    with open("energy_correlation.csv", "w") as f:
+        f.write("Actual energy (pJ/op),Predicted energy (pJ/op)\n")
+        for i in range(len(pred_energy)):
+            f.write(f"{np.exp(logscale_data[ENRG].iloc[i])},{pred_energy.iloc[i]}\n")
+    energy_residual = tech_energy_residuals.quantile(1 - OUTLIER_THRESHOLD)
+
+    freqmodel = {MAX: freq_max}
+    fomsmodel = {
+        FREQ: foms_coeffs[0],
+        MAX: foms_max,
+        INTERCEPT: foms_intercept,
+        MAX_BY_ENOB: foms_max_by_enob,
+        TECH_INTERCEPT: tech_energy_intercept,
+        TECH_SLOPE: tech_energy_coeffs[0],
+        ENOB_SLOPE: tech_energy_coeffs[1],
+        ENRG_RESIDUAL: energy_residual,
+    }
+    model = {
+        FREQ: freqmodel,
+        FOMS: fomsmodel,
+        COMMENTS: "Tech node, area, and frequency are log-base-e-scaled. "
+        "max_by_enob was also considered for limiting the frequency of "
+        "ADCs, but max ADC frequency was plenty for realistic PIM "
+        "settings at reasonable ADC resolutions.",
+    }
+    # AREA
+    area_data = logscale_data.copy()
+    ar_residual, ar_coeffs, ar_intercept = mvgress(
+        area_data[AREA_CALCULATE_PARAMS], area_data[AREA]
+    )
+    ar_intercept -= ar_residual.quantile(1 - AREA_QUANTILE)
+
+    areamodel = {a: ar_coeffs[i] for i, a in enumerate(AREA_CALCULATE_PARAMS)}
+    areamodel["intercept"] = ar_intercept
+    model[AREA] = areamodel
+
+    for k in model:
+        if isinstance(model[k], dict):
+            m = model[k]
+        else:
+            m = model
+        for k2 in m:
+            try:
+                m[k2] = float(m[k2])
+            except (ValueError, TypeError):
+                pass
+
+    logger.info(f'Writing model to "{output_file}"')
+    with open(output_file, "w") as outfile:
+        yaml.dump(model, outfile, default_flow_style=False, sort_keys=False)
+
+    return model
+
+
+def read_input_data(path: str) -> "pd.DataFrame":
+    """Loads input adc_data from path"""
+    import pandas as pd
+
+    if ".xls" == path[-4:] or ".xlsx" == path[-5:]:
+        data = pd.read_excel(path)
+    else:
+        data = pd.read_csv(path)
+    return data
+
+
+if __name__ == "__main__":
+    with open("./adc_data/model.yaml", "r") as f:
+        model = yaml.safe_load(f)
+
+    prev = 1
+    prev2 = 1
+    for r in range(4, 12):
+        for f in [1e8, 2.5e8, 5e8, 1e9, 2e9]:
+            f_active = f
+            params = {FREQ: math.log(f_active), ENOB: r, TECH: math.log(32)}
+            e = get_energy(params, model, True)
+            params[ENRG] = e
+            a = get_area(params, model)
+            p = e * f_active
+            print(f"{r}, {f_active:.2E}, {a:.2E}")
+            prev = e
+            prev2 = get_area(params, model)
+
+    resolutions = [x for x in range(4, 12)]
+    frequencies = [1e7] + [5e7] + [1e8 * x for x in range(1, 21)]
+    print("," + ",".join([f"{x/1e6}" for x in frequencies]))
+    for r in resolutions:
+        energies = []
+        areas = []
+        for f in frequencies:
+            params = {FREQ: math.log(f), ENOB: r, TECH: math.log(32)}
+            params[ENRG] = math.log(get_energy(params, model, True) * 1e12)
+            energies.append(math.exp(params[ENRG]))
+            areas.append(get_area(params, model))
+
+        print(f"{r}," + ",".join([f"{e:.2E}" for e in areas]))

hwcomponents_adc-0.1/hwcomponents_adc/murmannsurvey.py

@@ -0,0 +1,53 @@
+"""
+This script downloads Boris Murmann's ADC survey and packages it into a .CSV
+ADC list for user use.
+"""
+
+# Data source:
+# B. Murmann, "ADC Performance Survey 1997-2023," [Online].
+# Available: https://github.com/bmurmann/ADC-survey.
+
+import logging
+
+import pandas as pd
+
+from hwcomponents_adc.headers import *
+
+logger = logging.getLogger(__name__)
+
+
+XLS_FILE = "adc_data/ADC-survey/xls/ADCsurvey_latest.xls"
+
+
+def get_csv(outfile: str):
+    """Converts survey adc_data to a CSV file"""
+    xls_path = os.path.join(os.path.dirname(__file__), XLS_FILE)
+    if not os.path.exists(xls_path):
+        xls_path += "x"
+    isscc = pd.read_excel(xls_path, sheet_name="ISSCC")
+    vsli = pd.read_excel(xls_path, sheet_name="VLSI")
+    xls = pd.concat([isscc, vsli])
+
+    csv = pd.DataFrame()
+    numeric_cols = [
+        "fs [Hz]",
+        "AREA [mm^2]",
+        "TECHNOLOGY",
+        "P [W]",
+        "P/fsnyq [pJ]",
+        FOMS,
+        SNDR,
+    ]
+    for c in numeric_cols:
+        xls = xls[pd.to_numeric(xls[c], errors="coerce").notnull()]
+    csv[FREQ] = xls["fs [Hz]"]
+    csv[TECH] = xls["TECHNOLOGY"] * 10**3  # um >> nm
+    csv[AREA] = xls["AREA [mm^2]"] * 10**6  # mm^2 -> um^2
+    csv[ENRG] = xls["P/fsnyq [pJ]"]
+    csv[SNDR] = xls[SNDR]
+    csv[ENOB] = xls[SNDR].apply(sndr2bits)
+    csv[FOMS] = xls[FOMS]
+    csv.reset_index(inplace=True, drop=True)
+    if os.path.exists(outfile):
+        os.remove(outfile)
+    csv.to_csv(outfile)

hwcomponents_adc-0.1/hwcomponents_adc/optimizer.py

@@ -0,0 +1,104 @@
+import logging
+from typing import Dict
+from hwcomponents_adc.headers import *
+from .model import get_energy, get_area
+import math
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ADCRequest:
+    def __init__(
+        self,
+        bits: float,  # Resolution (bits)
+        tech: float,  # Tech node (nm)
+        throughput: float = 0,  # ops/channel/second
+        n_adcs: int = 1,  # Number of ADCs. Fractions allowed
+        logger: logging.Logger = None,
+    ):
+        self.bits = bits
+        self.tech = tech
+        self.throughput = throughput
+        self.n_adcs = n_adcs
+        self.logger = logger
+        assert self.bits >= 4, "Resolution must be >= 4 bits"
+
+    def energy_per_op(self, model: Dict) -> float:
+        """Returns energy per operation in Joules."""
+        design_params = {
+            ENOB: self.bits,
+            TECH: math.log(self.tech),
+            FREQ: math.log(self.throughput / self.n_adcs),
+        }
+        e_per_op = get_energy(design_params, model, True)
+
+        self.logger.info("\tAlternative designs:")
+        for n_adcs in range(max(self.n_adcs - 5, 1), self.n_adcs + 5):
+            f = self.throughput / n_adcs
+            design_params[FREQ] = math.log(f)
+            try:
+                e = get_energy(design_params, model, True)
+                a = self.area(model, n_adcs)
+                l = "\tCHOSEN > " if n_adcs == self.n_adcs else "\t         "
+                self.logger.info(
+                    f"{l}{n_adcs:2f} ADCs running at {f:2E}Hz: "
+                    f"{e:2E}pJ/op, {a/1e6:2E}mm^2"
+                )
+            except AssertionError:
+                pass
+        self.logger.info("")
+        return e_per_op
+
+    def area(self, model: Dict, n_adc_override=-1) -> float:
+        """Returns area in um^2."""
+        n_adcs = self.n_adcs if n_adc_override == -1 else n_adc_override
+        design_params = {
+            ENOB: self.bits,
+            TECH: math.log(self.tech),
+            FREQ: math.log(self.throughput / n_adcs),
+        }
+        design_params[ENRG] = math.log(get_energy(design_params, model, True))
+        return get_area(design_params, model) * n_adcs
+
+
+CACHED_MODEL = None
+
+
+def quick_get_area(
+    bits: float, tech: float, throughput: float, n_adcs: int, energy=None
+):
+    """Returns area in um^2. For testing purposes."""
+    global CACHED_MODEL
+    if CACHED_MODEL is None:
+        import main
+        import yaml
+
+        CACHED_MODEL = yaml.load(open(main.MODEL_FILE).read(), Loader=yaml.SafeLoader)
+    design_params = {
+        ENOB: bits,
+        TECH: math.log(tech),
+        FREQ: math.log(throughput / n_adcs),
+    }
+    design_params[ENRG] = math.log(
+        energy or get_energy(design_params, CACHED_MODEL, True)
+    )
+    return get_area(design_params, CACHED_MODEL) * n_adcs
+
+
+def quick_get_energy(
+    bits: float, tech: float, throughput: float, n_adcs: int, energy=None
+):
+    """Returns area in um^2. For testing purposes."""
+    global CACHED_MODEL
+    if CACHED_MODEL is None:
+        import main
+        import yaml
+
+        CACHED_MODEL = yaml.load(open(main.MODEL_FILE).read(), Loader=yaml.SafeLoader)
+    design_params = {
+        ENOB: bits,
+        TECH: math.log(tech),
+        FREQ: math.log(throughput / n_adcs),
+    }
+    return get_energy(design_params, CACHED_MODEL)

hwcomponents_adc-0.1/hwcomponents_adc/update_model.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+
+import murmannsurvey
+import model
+from hwcomponents_adc.headers import *
+
+if __name__ == "__main__":
+    murmannsurvey.get_csv(ADC_LIST_DEFAULT)
+    data = model.read_input_data(ADC_LIST_DEFAULT)
+    model.build_model(data, MODEL_DEFAULT, False)

hwcomponents_adc-0.1/hwcomponents_adc.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: hwcomponents-adc
+Version: 0.1
+Summary: A package for estimating the energy and area of Analog-Digital Converters
+Author-email: Tanner Andrulis <Andrulis@mit.edu>
+License: MIT
+Keywords: accelerator,hardware,energy,estimation,analog,adc
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: PyYAML
+Requires-Dist: numpy
+Requires-Dist: pandas
+
+# HWComponents-ADC
+HWComponents-ADC models the area and energy of Analog-Digital Converters (ADCs) for use
+in analog & mixed-signal accelerator designs.
+
+Models are based on statistical analysis of published ADC performance data in Boris
+Murmann's ADC Performance Survey [1]. The energy model is based on the observation that
+the maximum efficiency of an ADC is bounded by the sampling rate and the resolution [1],
+and the area model is based on regression analysis. Estimations are optimistic; they
+answer the question "what is the best possible ADC design for the given parameters?".
+
+## Installation
+Clone the repository and install with pip:
+
+```bash
+git clone https://github.com/Accelergy-Project/hwcomponents-adc.git
+cd hwcomponents-adc
+pip install .
+
+# Check that the installation is successful
+hwc --list | grep ADC
+```
+
+## Usage
+### Inerface
+
+This model introduces the ADC model. ADC models can be instantiated with the
+following parameters:
+- `n_bits`: the resolution of the ADC
+- `tech_node`: the technology node in meters
+- `n_adcs`: the number of ADCs working together, in the case of alternating
+  ADCs
+- `throughput`: the aggregate throughput of the ADCs, in samples per second
+
+ADCs support the following actions:
+- `read` or `convert`: Convert a single value from analog to digital. Note: if
+  there are multiple ADCs, this is a single conversion from a single ADC.
+
+### Exploring Tradeoffs
+There are several tradeoffs available around ADC design:
+- Lower-resolution ADCs are smaller and more energy-efficient.
+- Using more ADCs in parallel allows for a lower frequency, but increases the
+  area.
+- Using fewer ADCs in parallel allows for a higher frequency. Up to a point,
+  this will not increase the area or energy/area of the ADCs. However, at some
+  this will result in an exponential increase in energy/area.
+- Lower-resolution ADCs can run at higher frequencies before the exponential
+  increase in energy/area occurs.
+
+When the HWComponents-ADC runs, it will output a list of alternative design options.
+Each will report a number of ADCs and frequency needed to achieve the desired
+throughput, as well as the area and energy of the ADCs. You can then use this
+information to make tradeoffs between ADC resolution, frequency, and number of
+ADCs.
+
+HWComponents-ADC is the work of Tanner Andrulis & Ruicong Chen.
+
+## Updating the ADC Model
+The generated ADC model is based on the data in Boris Murmann's survey [1],
+included in the submodule. This survey is updated periodically. The model can
+be update to reflect the most recent data by running the following:
+
+```bash
+pip3 install scikit-learn
+pip3 install pandas
+pip3 install numpy
+git submodule update --init --recursive --remote
+python3 update_model.py
+```
+
+This is only necessary if more recent data is published. If the data here is
+out of date, please open an issue or pull request.
+
+## References
+[1] B. Murmann, "ADC Performance Survey 1997-2023," [Online]. Available:
+https://github.com/bmurmann/ADC-survey
+
+## License
+This work is licensed under the MIT license. See license.txt for details.
+
+## Citing HWComponents-ADC
+If you use this model in your work, please cite the following:
+
+```bibtex
+@misc{andrulis2024modelinganalogdigitalconverterenergyarea,
+      title={Modeling Analog-Digital-Converter Energy and Area for Compute-In-Memory Accelerator Design}, 
+      author={Tanner Andrulis and Ruicong Chen and Hae-Seung Lee and Joel S. Emer and Vivienne Sze},
+      year={2024},
+      eprint={2404.06553},
+      archivePrefix={arXiv},
+      primaryClass={cs.AR},
+      url={https://arxiv.org/abs/2404.06553}, 
+}
+```

hwcomponents_adc-0.1/hwcomponents_adc.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+hwcomponents_adc/__init__.py
+hwcomponents_adc/headers.py
+hwcomponents_adc/main.py
+hwcomponents_adc/model.py
+hwcomponents_adc/murmannsurvey.py
+hwcomponents_adc/optimizer.py
+hwcomponents_adc/update_model.py
+hwcomponents_adc.egg-info/PKG-INFO
+hwcomponents_adc.egg-info/SOURCES.txt
+hwcomponents_adc.egg-info/dependency_links.txt
+hwcomponents_adc.egg-info/requires.txt
+hwcomponents_adc.egg-info/top_level.txt
+hwcomponents_adc/adc_data/model.yaml

hwcomponents_adc-0.1/hwcomponents_adc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hwcomponents_adc-0.1/hwcomponents_adc.egg-info/requires.txt

@@ -0,0 +1,3 @@
+PyYAML
+numpy
+pandas

hwcomponents_adc-0.1/hwcomponents_adc.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+build
+dist
+hwcomponents_adc

hwcomponents_adc-0.1/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hwcomponents-adc"
+version = "0.1"
+description = "A package for estimating the energy and area of Analog-Digital Converters"
+readme = "README.md"
+requires-python = ">=3.12"
+license = {text = "MIT"}
+authors = [
+    {name = "Tanner Andrulis", email = "Andrulis@mit.edu"}
+]
+keywords = ["accelerator", "hardware", "energy", "estimation", "analog", "adc"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)",
+]
+dependencies = [
+    "PyYAML",
+    "numpy",
+    "pandas",
+]
+
+[tool.setuptools]
+packages = {find = {}}
+include-package-data = true
+py-modules = ["hwcomponents_adc"]
+
+[tool.setuptools.package-data]
+hwcomponents_adc = [
+    "adc_data/model.yaml",
+]

hwcomponents_adc-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+