accelforge 0.0.1__tar.gz

accelforge-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Tanner Andrulis and Michael Gilbert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

accelforge-0.0.1/MANIFEST.in

@@ -0,0 +1,10 @@
+include README.md
+include requirements.txt
+include LICENSE
+include *.yaml
+include *.yml
+include *.md
+recursive-include accelforge *.py
+recursive-include tests *.py
+recursive-include notebooks *.ipynb
+recursive-include hwcomponents *.py

accelforge-0.0.1/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: accelforge
+Version: 0.0.1
+Summary: AccelForge
+Author-email: Michael Gilbert <gilbertm@mit.edu>, Tanner Andrulis <andrulis@mit.edu>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.2.0
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: scipy>=1.15.0
+Requires-Dist: tqdm>=4.67.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic_core>=2.33.0
+Requires-Dist: ruamel.yaml>=0.18.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: islpy>=2025.0.0
+Requires-Dist: sympy>=1.14.0
+Requires-Dist: paretoset>=1.2.5
+Requires-Dist: matplotlib>=3.10.0
+Requires-Dist: plotly>=6.1.0
+Requires-Dist: pydot>=4.0.0
+Requires-Dist: platformdirs>=4.3.0
+Requires-Dist: joblib>=1.5.1
+Requires-Dist: hwcomponents
+Requires-Dist: hwcomponents-adc
+Requires-Dist: hwcomponents-cacti
+Requires-Dist: hwcomponents-library
+Requires-Dist: hwcomponents-neurosim
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Dynamic: license-file
+
+# AccelForge
+
+AccelForge is a framework to design and model tensor algebra accelerators. It includes
+models of components, architectures, and workloads, as well as a fast-and-optimal mapper
+to program the workloads onto the architectures.
+
+To learn more, see the [AccelForge
+documentation](https://accelergy-project.github.io/accelforge/).
+
+## Installation
+
+### Native
+
+AccelForge is available on PyPI:
+
+```bash
+pip install accelforge
+```
+
+### Docker
+
+TODO
+
+## Notebooks and Examples
+
+Examples can be found in the [`notebooks`](notebooks) directory. Examples of the input
+files can be found in the [`examples`](examples) directory.

accelforge-0.0.1/README.md

@@ -0,0 +1,27 @@
+# AccelForge
+
+AccelForge is a framework to design and model tensor algebra accelerators. It includes
+models of components, architectures, and workloads, as well as a fast-and-optimal mapper
+to program the workloads onto the architectures.
+
+To learn more, see the [AccelForge
+documentation](https://accelergy-project.github.io/accelforge/).
+
+## Installation
+
+### Native
+
+AccelForge is available on PyPI:
+
+```bash
+pip install accelforge
+```
+
+### Docker
+
+TODO
+
+## Notebooks and Examples
+
+Examples can be found in the [`notebooks`](notebooks) directory. Examples of the input
+files can be found in the [`examples`](examples) directory.

accelforge-0.0.1/accelforge/__init__.py

@@ -0,0 +1,21 @@
+from accelforge.frontend import arch
+from accelforge.frontend import config
+from accelforge.frontend import mapping
+from accelforge.frontend import renames
+from accelforge.frontend import spec
+from accelforge.frontend import variables
+from accelforge.frontend import workload
+from accelforge.frontend.spec import Spec, Spec
+from accelforge.mapper.FFM import Metrics
+from accelforge.util import set_n_parallel_jobs
+from accelforge.util import LiteralString
+import accelforge.mapper as mapper
+from accelforge.examples import examples
+
+from accelforge.frontend.variables import Variables
+from accelforge.frontend.arch import Arch
+from accelforge.frontend.config import Config
+from accelforge.frontend.mapping import Mapping
+from accelforge.frontend.renames import Renames
+from accelforge.frontend.spec import Spec
+from accelforge.frontend.workload import Workload

accelforge-0.0.1/accelforge/_accelerated_imports.py

@@ -0,0 +1,16 @@
+import os
+
+os.environ["ACCELFORGE_ACCELERATED_IMPORTS"] = "0"
+
+if os.environ.get("ACCELFORGE_ACCELERATED_IMPORTS", "0") == "1":
+    import cudf as pd
+    import cupy as np
+    import cupy as scipy
+
+    ACCELERATED = True
+else:
+    import pandas as pd
+    import numpy as np
+    import scipy
+
+    ACCELERATED = False

accelforge-0.0.1/accelforge/_deprecate/_simanneal/evalmapping.py

@@ -0,0 +1,271 @@
+from collections import defaultdict
+import itertools
+import time
+from fastfusion._accelerated_imports import pd
+from fastfusion.mapper.FFM._join_pmappings.sim import PmappingGroup, Loop, Compatibility
+from fastfusion.mapper.FFM._join_pmappings.pmapping_group import PmappingDataframe
+from fastfusion.mapper.simanneal.mapspaceglobals import MapspaceGlobals
+from fastfusion.util._frozenset import fzs
+
+
+def mapping2sims(einsum_to_result: Compatibility):
+    r = {}
+    for einsum_name, compat_dict in einsum_to_result.items():
+        r[einsum_name] = [paretofy(k, v) for k, v in compat_dict.items()]
+    return list(r.values())
+
+
+def get_possible_translations(
+    t: Compatibility,
+    pairwise_equivalent_rank_variables: dict[str, set[str]],
+    full_equivalent_rank_variables: dict[str, set[str]],
+    right_rank_variables: set[str],
+):
+    # Fused ranks should be transitive, but if a fused loop indexes into two
+    # different ranks in the next Einsum, we can't fuse becuase it will tile in
+    # multiple directions.
+    #
+    # The first union checks what loops we CAN fuse with in the next Einsum. The
+    # second union checks what loops MUST index into in the next
+    #
+    # Einsum. If we alias into multiple ranks, we can't fuse. Otherwise, try out
+    # each possible rank.
+    def translate_loop(l: Loop):
+        compatible_rank_variables = (
+            set.union(
+                *(full_equivalent_rank_variables[n] for n in l.rank_variable_names)
+            )
+            & right_rank_variables
+        )
+        pairwise_compatible_rank_variables = (
+            set.union(
+                *(pairwise_equivalent_rank_variables[n] for n in l.rank_variable_names)
+            )
+            & right_rank_variables
+        )
+        if len(pairwise_compatible_rank_variables) > 1:
+            return
+        for n in compatible_rank_variables:
+            yield Loop(fzs((n,)), l.bound, l.is_spatial)
+
+    for loops in itertools.product(*map(translate_loop, t.loops)):
+        yield t.update(loops=loops)
+
+
+prev_time = 0
+total_time = defaultdict(int)
+
+
+def init_print_time():
+    global prev_time, total_time
+    prev_time = time.time()
+    total_time = defaultdict(int)
+
+
+def print_time(what: str):
+    global prev_time
+    t = time.time() - prev_time
+    print(f"{what}: {t:.2f} seconds")
+    total_time[what] += t
+    prev_time = time.time()
+
+
+def print_total_time():
+    print(f"\n======== Total time ========")
+    for k, v in total_time.items():
+        print(f"{k}: {v:.2f} seconds")
+    total = sum(total_time.values())
+    if total > 60:
+        print(f"\nTotal: {total:.2f} seconds ({total/60:.2f} minutes)")
+    else:
+        print(f"\nTotal: {total:.2f} seconds")
+    print(f"============================\n")
+
+
+class PmappingsOneEinsum:
+    def __init__(self, einsum_name: str, pm_group_list: list[PmappingGroup]):
+        self.einsum_name: str = einsum_name
+        self.pmapping_groups: list[PmappingGroup] = pm_group_list
+        self.tensor_names: set[str] = set(pm_group_list[0].tensor_names)
+
+    def __getitem__(self, i):
+        return self.pmapping_groups[i]
+
+
+def make_full_equivalent_rank_variables(pairwise_equivalent_rank_variables):
+    full_equivalent_rank_variables = {
+        k: set(v) for k, v in pairwise_equivalent_rank_variables.items()
+    }
+    changed = True
+    while changed:
+        changed = False
+        for r in full_equivalent_rank_variables:
+            for r2 in list(full_equivalent_rank_variables[r]):
+                for r3 in list(full_equivalent_rank_variables[r2]):
+                    if r3 in full_equivalent_rank_variables[r]:
+                        continue
+                    changed = True
+                    full_equivalent_rank_variables[r].add(r3)
+    return full_equivalent_rank_variables
+
+
+def quick_join(
+    pmapping_groups: dict[str, PmappingGroup],
+    mapspace_globals: MapspaceGlobals,
+):
+    resource2capacity = mapspace_globals.resource2capacity
+    pairwise_equivalent_rank_variables = mapspace_globals.pairwise_equivalent_ranks
+    aliased_tensors = mapspace_globals.aliased_tensors
+    full_equivalent_rank_variables = mapspace_globals.full_equivalent_ranks
+
+    n_mappings = {}
+    runtime = {}
+    nbuckets = []
+
+    n_evaluations = 0
+
+    pmapping_groups = list(pmapping_groups.items())
+
+    init_print_time()
+
+    pmapping_groups = [PmappingsOneEinsum(*s) for s in pmapping_groups]
+
+    if not pmapping_groups:
+        raise ValueError("No PmappingGroups to join")
+
+    # ======================================================================
+    # Initial consolidate and group all PmappingGroups
+    # ======================================================================
+    for i, sim_holder in enumerate(pmapping_groups):
+        right_tensors = set.union(
+            set(), *[s.tensor_names for s in pmapping_groups[i + 1 :]]
+        )
+        if i == 0:
+            sim_holder.pmapping_groups = PmappingGroup.left_consolidate(
+                sim_holder.pmapping_groups,
+                right_tensors,
+            )
+            continue
+        t0 = time.time()
+        left_tensors = set.union(set(), *[s.tensor_names for s in pmapping_groups[:i]])
+        live_tensors = right_tensors
+        shared_tensors = left_tensors & sim_holder.tensor_names
+        sim_holder.pmapping_groups = sorted(
+            sim_holder.pmapping_groups, key=lambda x: len(x.mappings.data), reverse=True
+        )
+        sim_holder.pmapping_groups = PmappingGroup.right_consolidate(
+            sim_holder.pmapping_groups,
+            live_tensors,
+            shared_tensors,
+        )
+        sim_holder.pmapping_groups = PmappingGroup.combine_combineable(
+            sim_holder.pmapping_groups,
+            left_tensors | right_tensors,
+        )
+        if i > 0:
+            sim_holder.pmapping_groups = PmappingGroup.group_right(
+                sim_holder.pmapping_groups, left_tensors, drop_tags=True
+            )
+        einsum, prev_einsum = sim_holder.einsum_name, pmapping_groups[i - 1].einsum_name
+        runtime[f"{prev_einsum} → {einsum}"] = time.time() - t0
+        t0 = time.time()
+
+    n_iterations = 0
+    total_iterations = len(pmapping_groups)
+
+    def grab_sim_holder() -> (
+        tuple[dict[Compatibility, list[PmappingGroup]], str, set[str]]
+    ):
+        nonlocal n_iterations
+        n_iterations += 1
+        holder = pmapping_groups.pop(0)
+        return holder.pmapping_groups, holder.einsum_name, holder.tensor_names
+
+    if pmapping_groups:
+        left, left_einsum, left_tensors = grab_sim_holder()
+
+    partial_mapping_size = 1
+    while pmapping_groups:
+        t0 = time.time()
+        # ======================================================================
+        # Grab new Einsum from the right. Record logging data and find still
+        # tensors that will be live after this Einsum.
+        # ======================================================================
+        nbuckets.append(len(left))
+        # nmappings.append(sum(len(s.mappings.data) for s in left))
+        right, right_einsum, right_tensors = grab_sim_holder()
+        right_rank_variables = mapspace_globals.einsum2ranks[right_einsum]
+
+        partial_mapping_size += 1
+
+        live_tensors = set.union(set(), *[s.tensor_names for s in pmapping_groups])
+        shared_tensors = set(left_tensors) & set(right_tensors)
+        live_tensors_with_right = live_tensors | right_tensors
+
+        # ======================================================================
+        # Clean up the previously-combined PmappingGroups. Consolidate, combine, group
+        # them into buckets.
+        # ======================================================================
+
+        left = PmappingGroup.combine_combineable(
+            left,
+            live_tensors | right_tensors,
+        )
+
+        # Group left and right into buckets
+        left = PmappingGroup.group_left(left, right_tensors, drop_tags=True)
+
+        # ======================================================================
+        # Remove dead tensors from left and right. This happens after grouping
+        # because we only reserve space for shared tensors after it's dead. This
+        # is in case the tensor lifetime extends beyond the Einsums for which it
+        # is used.
+        # ======================================================================
+        PmappingGroup.remove_dead_tensors(
+            [s for lr in [left, right] for v in lr.values() for s in v], live_tensors
+        )
+
+        # ======================================================================
+        # Merge the left and right buckets.
+        # ======================================================================
+        combined: list[PmappingGroup] = []
+        for k in left:
+            for k_translated in get_possible_translations(
+                k,
+                pairwise_equivalent_rank_variables,
+                full_equivalent_rank_variables,
+                right_rank_variables,
+            ):
+                for a, b in itertools.product(left[k], right.get(k_translated, [])):
+                    if a.compatibility.tags.are_compatible_with(b.compatibility.tags):
+                        combined.append(
+                            a.merge_next(
+                                b,
+                                live_tensors,
+                                live_tensors_with_right,
+                                aliased_tensors,
+                                resource2capacity,
+                                delay=False,
+                            )
+                        )
+
+        if not combined:
+            raise ValueError("No match found for any group")
+
+        # ======================================================================
+        # Update left for the next iteration.
+        # =================================================================
+        left = combined
+        left_einsum = right_einsum
+        left_tensors |= right_tensors
+
+    # ======================================================================
+    # Final consolidate and group
+    # ======================================================================
+    t0 = time.time()
+    left = PmappingGroup.left_consolidate(left, None)
+    s_final = PmappingGroup.combine_combineable(left, set(), drop_tags=True)
+    assert len(s_final) == 1
+    mappings = s_final[0].mappings
+
+    return mappings