hwcomponents 1.0.81__py3-none-any.whl

hwcomponents/scaling/techscaling.py

@@ -0,0 +1,185 @@
+# CMOS scaling based on: Aaron Stillmaker, Bevan Baas, Scaling equations for the
+# accurate prediction of CMOS device performance from 180nm to 7nm, Integration,
+# Volume 58, 2017, Pages 74-81, ISSN 0167-9260,
+# https://doi.org/10.1016/j.vlsi.2017.02.002.
+# Scaling from tech node X to tech node Y involves multiplying area from
+# AREA_SCALING[X][Y].
+from math import ceil, floor
+from typing import Union
+
+
+TECH_NODES = [130e-9, 90e-9, 65e-9, 45e-9, 32e-9, 20e-9, 16e-9, 14e-9, 10e-9, 7e-9]
+AREA_SCALING = [
+    [1, 0.44, 0.23, 0.16, 0.072, 0.033, 0.03, 0.027, 0.016, 0.0092],
+    [2.3, 1, 0.53, 0.35, 0.16, 0.075, 0.067, 0.061, 0.036, 0.021],
+    [4.3, 1.9, 1, 0.66, 0.31, 0.14, 0.13, 0.12, 0.068, 0.039],
+    [6.4, 2.8, 1.5, 1, 0.46, 0.21, 0.19, 0.17, 0.1, 0.059],
+    [14, 6.1, 3.3, 2.2, 1, 0.46, 0.41, 0.38, 0.22, 0.13],
+    [30, 13, 7.1, 4.7, 2.2, 1, 0.89, 0.82, 0.48, 0.28],
+    [34, 15, 7.9, 5.3, 2.4, 1.1, 1, 0.91, 0.54, 0.31],
+    [37, 16, 8.7, 5.8, 2.7, 1.2, 1.1, 1, 0.59, 0.34],
+    [63, 28, 15, 9.8, 4.5, 2.1, 1.9, 1.7, 1, 0.58],
+    [110, 48, 25, 17, 7.8, 3.6, 3.2, 2.9, 1.7, 1],
+]
+
+# Scaling from tech node X to tech node Y involves multiplying energy by
+# ENERGY_SCALING[Y][0]Vdd^2+ENERGY_SCALING[Y][1]Vdd+ENERGY_SCALING[Y][2] and
+# dividing by
+# ENERGY_SCALING[X][0]Vdd^2+ENERGY_SCALING[X][1]Vdd+ENERGY_SCALING[X][2]
+ENERGY_SCALING = [
+    [7.171, -6.709, 2.904],
+    [4.762, -4.781, 2.092],
+    [3.755, -4.398, 1.975],
+    [1.103, -0.362, 0.2767],
+    [0.9559, -0.7823, 0.471],
+    [0.373, -0.1582, 0.04104],
+    [0.2958, -0.1241, 0.03024],
+    [0.2363, -0.09675, 0.02239],
+    [0.2068, -0.09311, 0.02375],
+    [0.1776, -0.09097, 0.02447],
+]
+
+
+def _get_technology_node_index(tech_node: float) -> float:
+    """Returns the index of the technology node in the TECH_NODES array.
+    Interpolates if necessary."""
+    larger_idx, smaller_idx = None, None
+    for i, t in enumerate(TECH_NODES):
+        if tech_node <= t:
+            larger_idx = i
+        if tech_node >= t:
+            smaller_idx = i
+            break
+
+    failed = larger_idx is None or smaller_idx is None
+
+    assert not failed, (
+        f"Technology node {tech_node} not supported. Ensure all technology "
+        f"nodes are in the range [{TECH_NODES[-1]}, {TECH_NODES[0]}]"
+    )
+    l_node, s_node = TECH_NODES[larger_idx], TECH_NODES[smaller_idx]
+    if larger_idx == smaller_idx:
+        return larger_idx
+    interp = (tech_node - s_node) / (l_node - s_node)
+    return larger_idx + (smaller_idx - larger_idx) * interp
+
+
+def _constrain_to_tech_nodes(tech_node: float):
+    if tech_node < min(TECH_NODES):
+        return min(TECH_NODES), tech_node / min(TECH_NODES)
+    if tech_node > max(TECH_NODES):
+        return max(TECH_NODES), tech_node / max(TECH_NODES)
+    return tech_node, 1
+
+
+def tech_node_area(to_node: float, from_node: float) -> float:
+    """
+    Returns the scaling factor for area from the technology node
+    `from_node` to the technology node `to_node`. Interpolates if necessary.
+
+    Args:
+        to_node: The technology node to scale to.
+        from_node: The technology node to scale from.
+    Returns:
+        The scaling factor for area.
+    """
+    from_node, x = _constrain_to_tech_nodes(from_node)
+    to_node, y = _constrain_to_tech_nodes(to_node)
+    scale = y / x
+
+    x = _get_technology_node_index(from_node)
+    y = _get_technology_node_index(to_node)
+
+    # Any unaccounted for scaling with "scale" variable is assumed to scale
+    # linearly with tech node based on IDRS 2016 and 2017 predicted estimated
+    # SoC area
+    return scale * sum(
+        [
+            AREA_SCALING[floor(x)][floor(y)] * (1 - x % 1) * (1 - y % 1),
+            AREA_SCALING[floor(x)][ceil(y)] * (1 - x % 1) * (y % 1),
+            AREA_SCALING[ceil(x)][floor(y)] * (x % 1) * (1 - y % 1),
+            AREA_SCALING[ceil(x)][ceil(y)] * (x % 1) * (y % 1),
+        ]
+    )
+
+
+def tech_node_energy(
+    to_node: float, from_node: float, vdd: Union[float, None] = None
+) -> float:
+    """Returns the scaling factor for energy from the technology node
+    `from_node` to the technology node `to_node`. Interpolates if necessary.
+
+    Args:
+        to_node: The technology node to scale to.
+        from_node: The technology node to scale from.
+        vdd: The voltage to scale by. If not provided, 0.8V is used.
+    Returns:
+        The scaling factor for energy.
+    """
+    # Based on IRDS 2022, energy stops scaling after 1nm
+    from_node = max(from_node, 1e-9)
+    to_node = max(to_node, 1e-9)
+
+    from_node, x = _constrain_to_tech_nodes(from_node)
+    to_node, y = _constrain_to_tech_nodes(to_node)
+    scale = (y / x) ** 0.5
+
+    x = _get_technology_node_index(from_node)
+    y = _get_technology_node_index(to_node)
+
+    if vdd is None:
+        vdd = 0.8
+    # Outer sum does linear interpolation
+    x_e_factor = sum(
+        [
+            # These sums do aVdd^2 + bVdd + c
+            sum(ENERGY_SCALING[floor(x)][i] * vdd ** (2 - i) for i in range(3))
+            * (1 - x % 1),
+            sum(ENERGY_SCALING[ceil(x)][i] * vdd ** (2 - i) for i in range(3))
+            * (x % 1),
+        ]
+    )
+    # Outer sum does linear interpolation
+    y_e_factor = sum(
+        [
+            # These sums do aVdd^2 + bVdd + c
+            sum(ENERGY_SCALING[floor(y)][i] * vdd ** (2 - i) for i in range(3))
+            * (1 - y % 1),
+            sum(ENERGY_SCALING[ceil(y)][i] * vdd ** (2 - i) for i in range(3))
+            * (y % 1),
+        ]
+    )
+
+    # Any unaccounted for scaling with "scale" variable is assumed to scale with
+    # square root of tech node based on IDRS 2016 and 2017 predicted estimated
+    # fJ/switch
+    return y_e_factor / x_e_factor * scale
+
+
+def tech_node_leak(
+    to_node: float, from_node: float, vdd: Union[float, None] = None
+) -> float:
+    """Returns the scaling factor for leakage power from the technology node
+    `from_node` to the technology node `to_node`. Interpolates if necessary.
+
+    Args:
+        to_node: The technology node to scale to.
+        from_node: The technology node to scale from.
+        vdd: The voltage to scale by. If not provided, 0.8V is used.
+    Returns:
+        The scaling factor for leakage power.
+    """
+    return tech_node_energy(to_node, from_node, vdd)
+
+
+def tech_node_latency(to_node: float, from_node: float) -> float:
+    """Returns the scaling factor for latency from the technology node
+    `from_node` to the technology node `to_node`. Interpolates if necessary.
+
+    Args:
+        to_node: The technology node to scale to.
+        from_node: The technology node to scale from.
+    Returns:
+        The scaling factor for latency.
+    """
+    return to_node / from_node

hwcomponents/select_models.py

@@ -0,0 +1,466 @@
+import logging
+import copy
+from typing import Any, Callable, Dict, List, Tuple
+from hwcomponents.model import ComponentModel
+from hwcomponents._logging import (
+    get_logger,
+    pop_all_messages,
+    log_all_lines,
+    clear_logs,
+)
+from hwcomponents._model_wrapper import (
+    ComponentModelWrapper,
+    ModelQuery,
+    Estimation,
+    EstimatorError,
+    ModelEstimation,
+    FloatEstimation,
+)
+from hwcomponents.find_models import installed_models
+
+
+def _indent_list_text_block(prefix: str, list_to_print: List[str]):
+    if not list_to_print:
+        return ""
+    return "\n| ".join(
+        [f"{prefix}"] + [str(l).replace("\n", "\n|  ") for l in list_to_print]
+    )
+
+
+def _call_model(
+    model: ComponentModelWrapper,
+    query: ModelQuery,
+    target_func: Callable,
+) -> Estimation:
+    # Clear the logger
+    pop_all_messages(model.logger)
+    try:
+        estimation = target_func(query)
+    except Exception as e:
+        estimation = FloatEstimation(0, success=False, model_name=model.get_name())
+        model.logger.error(f"{type(e).__name__}: {e}")
+        # Add the full traceback
+        import traceback
+
+        estimation.add_messages(traceback.format_exc().split("\n"))
+        return estimation
+
+    # Add message logs
+    estimation.add_messages(pop_all_messages(model.logger))
+    estimation.model_name = model.get_name()
+
+    # See if this estimation matches user requested model and min priority
+    attrs = query.component_attributes
+    prefix = f"Model {estimation.model_name} did not"
+    if attrs.get("model", estimation.model_name) != estimation.model_name:
+        estimation.fail(f"{prefix} match requested model {attrs['model']}")
+    if attrs.get("min_priority", -float("inf")) > model.model_cls.priority:
+        estimation.fail(f"{prefix} meet min_priority {attrs['min_priority']}")
+    return estimation
+
+
+def _get_energy_estimation(
+    model: ComponentModelWrapper, query: ModelQuery
+) -> FloatEstimation:
+    e = _call_model(model, query, model.get_action_energy_latency)
+    if e.success:
+        e.value = e.value[0]
+    return e
+
+
+def _get_latency_estimation(
+    model: ComponentModelWrapper, query: ModelQuery
+) -> FloatEstimation:
+    e = _call_model(model, query, model.get_action_energy_latency)
+    if e.success:
+        e.value = e.value[1]
+    return e
+
+
+def _get_area_estimation(
+    model: ComponentModelWrapper, query: ModelQuery
+) -> FloatEstimation:
+    e = _call_model(model, query, model.get_area)
+    return e
+
+
+def _get_leak_power_estimation(
+    model: ComponentModelWrapper, query: ModelQuery
+) -> FloatEstimation:
+    e = _call_model(model, query, model.get_leak_power)
+    return e
+
+
+def _select_model(
+    model: ComponentModelWrapper,
+    query: ModelQuery,
+) -> ModelEstimation:
+    for required_action in query.required_actions:
+        if required_action not in model.get_action_names():
+            e = ModelEstimation(0, success=False, model_name=model.get_name())
+            e.fail(
+                f"Model {model.get_name()} does not support action {required_action}"
+            )
+            return e
+    callfunc = lambda x: ModelEstimation(
+        model.get_initialized_subclass(x),
+        success=True,
+        model_name=model.get_name(),
+    )
+    return _call_model(model, query, callfunc)
+
+
+def _wrap_model(
+    model: ComponentModel | ComponentModelWrapper,
+) -> ComponentModelWrapper:
+    if isinstance(model, ComponentModelWrapper):
+        return model
+    return ComponentModelWrapper(model, model.__name__)
+
+
+def _get_best_estimate(
+    query: ModelQuery,
+    target: str,
+    models: List[ComponentModelWrapper] | List[ComponentModel] = None,
+    _return_estimation_object: bool = False,
+    _relaxed_component_name_selection: bool = False,
+) -> FloatEstimation | ComponentModel:
+    if models is None:
+        models = installed_models(_return_wrappers=True)
+
+    models = [_wrap_model(m) for m in models]
+
+    if target == "energy":
+        est_func = _get_energy_estimation
+    elif target == "latency":
+        est_func = _get_latency_estimation
+    elif target == "area":
+        est_func = _get_area_estimation
+    elif target == "model":
+        est_func = _select_model
+    elif target == "leak_power":
+        est_func = _get_leak_power_estimation
+    else:
+        raise ValueError(f"Invalid target: {target}")
+
+    logging.getLogger("").info(f"{target} estimation for {query}")
+
+    estimations = []
+
+    def _get_supported_models(relaxed_component_name_selection: bool):
+        supported_models = []
+        init_errors = []
+        for model in models:
+            try:
+                if not model.is_component_supported(
+                    query, relaxed_component_name_selection
+                ):
+                    continue
+                supported_models.append(model)
+            except Exception as e:
+                init_errors.append((model, e))
+        return supported_models, init_errors
+
+    supported_models, init_errors = _get_supported_models(
+        _relaxed_component_name_selection
+    )
+
+    if not supported_models:
+        if not models:
+            raise EstimatorError(
+                f"No models found. Please install hwcomponents models."
+            )
+        supported_classes = set.union(*[set(p.get_component_names()) for p in models])
+
+        err_str = []
+        if not _relaxed_component_name_selection:
+            near_supported, _ = _get_supported_models(True)
+            if near_supported:
+                err_str.append(
+                    f"Some component models have similar names to the given component "
+                    f"name. Did you mean any of the following?\n\t"
+                )
+                for model in near_supported:
+                    err_str.append(f"\t{model.get_name()}")
+
+        if init_errors:
+            err_str.append(
+                f"Component {query.component_name} is supported by models, but the "
+                f"following models could could not be initialized."
+            )
+            for model, err in init_errors:
+                err_str.append(f"\t{model.get_name()}")
+                err_str.append(f"\t{str(err).replace("\n", "\n\t")}")
+            raise EstimatorError("\n".join(err_str))
+
+        e = (
+            f"Component {query.component_name} is not supported by any models. "
+            f"Supported components: " + ", ".join(sorted(supported_classes))
+        )
+        if err_str:
+            e += "\n" + "\n".join(err_str)
+        raise EstimatorError(e)
+
+    estimation = None
+    for model in supported_models:
+        estimation = est_func(model, copy.deepcopy(query))
+        logger = get_logger(model.get_name())
+        if not estimation.success:
+            estimation.add_messages(pop_all_messages(logger))
+            estimations.append((model.priority, estimation))
+        else:
+            log_all_lines(
+                f"HWComponents",
+                "info",
+                f"{estimation.model_name} returned "
+                f"{estimation} with priority {model.priority}. "
+                + _indent_list_text_block("Messages:", estimation.messages),
+            )
+            break
+    else:
+        estimation = None
+
+    full_logs = [
+        _indent_list_text_block(
+            f"{e.model_name} with priority {a} estimating value: ", e.messages
+        )
+        for a, e in estimations
+    ]
+    fail_reasons = [
+        f"{e.model_name} with priority {a} estimating value: " f"{e.lastmessage()}"
+        for a, e in estimations
+    ]
+
+    if full_logs:
+        log_all_lines(
+            "HWComponents",
+            "debug",
+            _indent_list_text_block("Model logs:", full_logs),
+        )
+    if fail_reasons:
+        log_all_lines(
+            "HWComponents",
+            "debug",
+            _indent_list_text_block("Why models did not estimate:", fail_reasons),
+        )
+    if fail_reasons:
+        log_all_lines(
+            "HWComponents",
+            "info",
+            _indent_list_text_block(
+                "Models provided accuracy but failed to estimate:",
+                fail_reasons,
+            ),
+        )
+
+    clear_logs()
+
+    if estimation is not None and estimation.success:
+        if _return_estimation_object:
+            return estimation
+        return estimation.value
+
+    clear_logs()
+
+    raise RuntimeError(
+        f"Can not find an {target} model for {query}\n"
+        f'{_indent_list_text_block("Logs for models that could estimate query:", full_logs)}\n'
+        f'{_indent_list_text_block("Why models did not estimate:", fail_reasons)}\n'
+        f'\n.\n.\nTo see a list of available component models, run "hwc --list".'
+    )
+
+
+def get_energy(
+    component_name: str,
+    component_attributes: Dict[str, Any],
+    action_name: str,
+    action_arguments: Dict[str, Any],
+    models: List[ComponentModelWrapper] = None,
+    _return_estimation_object: bool = False,
+    _relaxed_component_name_selection: bool = False,
+) -> float | Estimation:
+    """
+    Finds the energy using the best-matching model. "Best" is defined as the
+    highest-priority model that has all required attributes specified in
+    component_attributes and a matching action with all required arguments specified
+    in action_arguments.
+
+    Parameters
+    ----------
+        component_name: The name of the component.
+        component_attributes: The attributes of the component.
+        action_name: The name of the action.
+        action_arguments: The arguments of the action.
+        models: The models to use.
+        _return_estimation_object: Whether to return the estimation object instead of
+            the energy value.
+        _relaxed_component_name_selection: Whether to relax the component name
+            selection. Relaxed selection ignores underscores in the component name.
+
+    Returns
+    -------
+        The energy in Joules.
+    """
+    query = ModelQuery(
+        component_name.lower(), component_attributes, action_name, action_arguments
+    )
+    return _get_best_estimate(
+        query,
+        "energy",
+        models,
+        _return_estimation_object,
+        _relaxed_component_name_selection,
+    )
+
+
+def get_latency(
+    component_name: str,
+    component_attributes: Dict[str, Any],
+    action_name: str,
+    action_arguments: Dict[str, Any],
+    models: List[ComponentModelWrapper] = None,
+    _return_estimation_object: bool = False,
+    _relaxed_component_name_selection: bool = False,
+) -> float | Estimation:
+    """
+    Finds the latency using the best-matching model. "Best" is defined as the
+    highest-priority model that has all required attributes specified in
+    component_attributes and a matching action with all required arguments specified
+    in action_arguments.
+
+    Parameters
+    ----------
+        component_name: The name of the component.
+        component_attributes: The attributes of the component.
+        action_name: The name of the action.
+        action_arguments: The arguments of the action.
+        models: The models to use.
+        _return_estimation_object: Whether to return the estimation object instead of
+            the latency value.
+        _relaxed_component_name_selection: Whether to relax the component name
+            selection. Relaxed selection ignores underscores in the component name.
+
+    Returns
+    -------
+        The latency in seconds.
+    """
+    query = ModelQuery(
+        component_name.lower(), component_attributes, action_name, action_arguments
+    )
+    return _get_best_estimate(
+        query,
+        "latency",
+        models,
+        _return_estimation_object,
+        _relaxed_component_name_selection,
+    )
+
+
+def get_area(
+    component_name: str,
+    component_attributes: Dict[str, Any],
+    models: List[ComponentModelWrapper] = None,
+    _return_estimation_object: bool = False,
+    _relaxed_component_name_selection: bool = False,
+) -> float | Estimation:
+    """
+    Finds the area using the best-matching model. "Best" is defined as the
+    highest-priority model that has all required attributes specified in
+    component_attributes.
+
+    Parameters
+    ----------
+        component_name: The name of the component.
+        component_attributes: The attributes of the component.
+        models: The models to use.
+        _return_estimation_object: Whether to return the estimation object instead of
+            the area value.
+        _relaxed_component_name_selection: Whether to relax the component name
+            selection. Relaxed selection ignores underscores in the component name.
+
+    Returns
+    -------
+        The area in m^2.
+    """
+    query = ModelQuery(component_name.lower(), component_attributes, None, None)
+    return _get_best_estimate(
+        query,
+        "area",
+        models,
+        _return_estimation_object,
+        _relaxed_component_name_selection,
+    )
+
+
+def get_leak_power(
+    component_name: str,
+    component_attributes: Dict[str, Any],
+    models: List[ComponentModelWrapper] = None,
+    _return_estimation_object: bool = False,
+    _relaxed_component_name_selection: bool = False,
+) -> float | Estimation:
+    """
+    Finds the leak power using the best-matching model. "Best" is defined as the
+    highest-priority model that has all required attributes specified in
+    component_attributes.
+
+    Parameters
+    ----------
+        component_name: The name of the component.
+        component_attributes: The attributes of the component.
+        models: The models to use.
+        _relaxed_component_name_selection: Whether to relax the component name
+            selection. Relaxed selection ignores underscores in the component name.
+
+    Returns
+    -------
+        The leak power in Watts.
+    """
+    query = ModelQuery(component_name.lower(), component_attributes, None, None)
+    return _get_best_estimate(
+        query,
+        "leak_power",
+        models,
+        _return_estimation_object,
+        _relaxed_component_name_selection,
+    )
+
+
+def get_model(
+    component_name: str,
+    component_attributes: Dict[str, Any],
+    required_actions: List[str] = (),
+    models: List[ComponentModelWrapper] = None,
+    _return_estimation_object: bool = False,
+    _relaxed_component_name_selection: bool = False,
+) -> ComponentModelWrapper:
+    """
+    Finds the best model for the given component. "Best" is defined as the
+    highest-priority model that has all required attributes specified in
+    component_attributes, and has actions for all of required_actions.
+
+    Parameters
+    ----------
+        component_name: The name of the component.
+        component_attributes: The attributes of the component.
+        required_actions: The actions that are required for the component.
+        models: The models to use.
+        _return_estimation_object: Whether to return the estimation object instead of
+            the model wrapper.
+        _relaxed_component_name_selection: Whether to relax the component name
+            selection. Relaxed selection ignores underscores in the component name.
+
+    Returns
+    -------
+        The best model wrapper.
+    """
+    query = ModelQuery(
+        component_name.lower(), component_attributes, None, None, required_actions
+    )
+    return _get_best_estimate(
+        query,
+        "model",
+        models,
+        _return_estimation_object,
+        _relaxed_component_name_selection,
+    )

hwcomponents-1.0.81.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: hwcomponents
+Version: 1.0.81
+Summary: Hardware Component Area, Energy, Latency, and Leak Power Models
+Author-email: Tanner Andrulis <andrulis@mit.edu>
+License-Expression: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# HWComponents
+The HWComponents (Hardware Components) package, part of the
+[CiMLoop](https://github.com/mit-emze/cimloop) project, provides an interface for the
+estimation of area, energy, latency, and leak power of hardware components in hardware
+architectures. Key features in HWComponents include:
+
+[Information about the package is available on the hwcomponents website](https://accelergy-project.github.io/hwcomponents/).
+
+## Citing HWComponents
+
+If you use this package in your work, please cite the CiMLoop project:
+
+```bibtex
+@INPROCEEDINGS{cimloop,
+  author={Andrulis, Tanner and Emer, Joel S. and Sze, Vivienne},
+  booktitle={2024 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS)},
+  title={CiMLoop: A Flexible, Accurate, and Fast Compute-In-Memory Modeling Tool},
+  year={2024},
+  volume={},
+  number={},
+  pages={10-23},
+  keywords={Performance evaluation;Accuracy;Computational modeling;Computer architecture;Artificial neural networks;In-memory computing;Data models;Compute-In-Memory;Processing-In-Memory;Analog;Deep Neural Networks;Systems;Hardware;Modeling;Open-Source},
+  doi={10.1109/ISPASS61541.2024.00012}
+}
+```

hwcomponents-1.0.81.dist-info/RECORD

@@ -0,0 +1,19 @@
+hwcomponents/__init__.py,sha256=1rdj62DTJFkSr74oWZ2Ih3oRLqkSAP_VjcOQqg6vmB4,266
+hwcomponents/_logging.py,sha256=ReXxWW3rBRCTOQnGiq1LoEfd7PRlQ0WaIA95K_WqD9k,2923
+hwcomponents/_model_wrapper.py,sha256=XJCWH8SrvaWEIy9dPsLbC8C5iJNxzl5WWmSjgGauEgU,16410
+hwcomponents/_util.py,sha256=HNYhpipunPhtxSH682HGnhvSSFiUvj4LCSBUX2aSNM8,528
+hwcomponents/_version.py,sha256=lpdkpSPBg6TUZ9qwEnA5xz_PjPJuagx6OfQbHGcX8R0,706
+hwcomponents/_version_scheme.py,sha256=INbPbxvnFHVM3tWJy8k_Ozfxj73nrOL286DB2-lKuHE,605
+hwcomponents/find_models.py,sha256=iVrEWShdMg3ZydwDaLoDMqo8GZcZkMqGOWsIcU_i7mM,8035
+hwcomponents/hwcomponents.py,sha256=9h43D0IE_9LzVQOQboE3U_t6_lUhgtCpxR1vHAZhrg8,2000
+hwcomponents/model.py,sha256=6ZJ7Lk748hv66IgYvMpduvU5COMiaaA4BzlBq3Obfgk,21865
+hwcomponents/select_models.py,sha256=Q3J44kgKq5eMk-35yjAfy3ASzJ307sTM5Fn_UfhDzlA,15302
+hwcomponents/scaling/__init__.py,sha256=wAAgWFe9D-IWWD8xyYS11Yls3Xiqw-m_T632OTooQyE,180
+hwcomponents/scaling/scalefuncs.py,sha256=rcJkbuA8-1lsdb0qQbCw962SCI71hWZsV8z97ch5hcc,3398
+hwcomponents/scaling/techscaling.py,sha256=EJ0lzMhv2H_71uqKTa2Yic4kREdK7u5BUisGxH-0iwk,6658
+hwcomponents-1.0.81.dist-info/METADATA,sha256=cckcPQ3ladMfRRZXios9-gv_D6kbMNOjfQ2kjgwn3RQ,1438
+hwcomponents-1.0.81.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hwcomponents-1.0.81.dist-info/entry_points.txt,sha256=ezk1BAMA2WFaiNmzICB9YuUE2x6fSgkmvPR28KV4_B4,103
+hwcomponents-1.0.81.dist-info/top_level.txt,sha256=V_QIQX2zOOFe59WghKgnGJ6CFPVQvz16tByOrlnwvrs,13
+hwcomponents-1.0.81.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+hwcomponents-1.0.81.dist-info/RECORD,,