SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2404.04815 · 2024

Allo: A Programming Model for Composable Accelerator Design

arXiv · PDF · Open in the Atlas

Code that ran

13 of 20 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 5 honoured the contract we drafted, 1 violated it and 0 have no contract verdict; 7 failures of our instrument; 7 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2404.04815.json · badge: /api/ran/2404.04815.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
cornell-zhang/allo canonical (classifier label)
classifier basis: census
9 ran · 7 no recorded run
cornell-zhang/allo-pldi24-artifact canonical (classifier label)
classifier basis: census
4 ran · 0 no recorded run
FunctionStatusWhere it lives
add Ran
ran, honoured the contract we drafted
cornell-zhang/allo/allo/dsl.py
code served (permissive licence) · get_code("156caede4d5f8d82")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# The add function takes two arguments (lhs, rhs) and an optional name parameter
# It simply adds them together, so they should be compatible with the + operator
# Let's use small tensors with distinct dimensions

lhs = torch.randn(2, 4)
rhs = torch.randn(2, 4)
name = "addition_result"

ARGS = {
    "lhs": lhs,
    "rhs": rhs,
    "name": name,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
atax_np Ran
ran, violated the contract we drafted
cornell-zhang/allo-pldi24-artifact/polybench/allo/atax/atax.py
code served (permissive licence) · get_code("4856dc783b43f8f1")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (3,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create small distinct-sized matrices for A and x
# A is 4x3 matrix, x is 3-element vector
A = np.random.randn(4, 3)
x = np.random.randn(3)

ARGS = {
    "A": A,
    "x": x,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (3,) — shape (3,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
bmm Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
cornell-zhang/allo/allo/dsl.py
code served (permissive licence) · get_code("f04e1226b2e866ab")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 3, dtype family float, shape (2, 4, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# The function performs batch matrix multiplication using einsum
# lhs shape: (batch, i, k)
# rhs shape: (batch, k, n)
# output shape: (batch, i, n)

# Create small numpy arrays with distinct dimensions
batch_size = 2
i_dim = 4
k_dim = 3
n_dim = 5

lhs = np.random.randn(batch_size, i_dim, k_dim)
rhs = np.random.randn(batch_size, k_dim, n_dim)

ARGS = {
    'lhs': lhs,
    'rhs': rhs,
    'name': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family float, shape (2, 4, 5) — shape (2, 4, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
find_live_out_variable Ran
ran; our contract draft was wrong, not the code
cornell-zhang/allo/allo/verify.py
code served (permissive licence) · get_code("7241067c56508906")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re
import tempfile
import os

# Create a temporary C code file for testing
c_code = """
void kernel_multiply(int* data, int* result) {
    result[0] = data[0] * 2;
}

void top_level(int* input, int* output) {
    kernel_multiply(input, output);
}
"""

# Write to a temporary file
temp_dir = tempfile.mkdtemp()
file_path = os.path.join(temp_dir, "test_kernel.c")
with open(file_path, 'w') as f:
    f.write(c_code)

ARGS = {
    "file_path": file_path,
    "top_function_name": "top_level"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
gemm_np Ran
ran, honoured the contract we drafted
cornell-zhang/allo-pldi24-artifact/polybench/allo/gemm/gemm.py
code served (permissive licence) · get_code("301f37bdadc8dd77")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create small numpy arrays for matrix multiplication
A = np.array([[1.0, 2.0, 3.0],
              [4.0, 5.0, 6.0]], dtype=np.float32)

B = np.array([[1.0, 2.0],
              [3.0, 4.0],
              [5.0, 6.0]], dtype=np.float32)

C = np.array([[0.5, 1.0],
              [1.5, 2.0]], dtype=np.float32)

beta = 2.0

ARGS = {
    "A": A,
    "B": B,
    "C": C,
    "beta": beta
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (2, 2) — shape (2, 2) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_np_pow2_type Ran
ran; our contract draft was wrong, not the code
cornell-zhang/allo/allo/utils.py
code served (permissive licence) · get_code("77a0e980d892d96c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned type. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Test case 1: bitwidth 8, signed
bitwidth_8_signed = 8
signed_true = True

# Test case 2: bitwidth 16, unsigned
bitwidth_16_unsigned = 16
signed_false = False

# Test case 3: bitwidth 32, signed
bitwidth_32_signed = 32

# Test case 4: bitwidth 64, unsigned
bitwidth_64_unsigned = 64

# Create ARGS dict with a reasonable test case
ARGS = {
    "bitwidth": 32,
    "signed": True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type type — a type output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a type output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_np_struct_type Ran
ran; our contract draft was wrong, not the code
cornell-zhang/allo/allo/utils.py
code served (permissive licence) · get_code("0f2fd8492c4e8145")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned VoidDType. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

ARGS = {
    'bitwidth': 16
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type VoidDType — a VoidDType output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a VoidDType output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
getsourcefile Ran
ran; our contract draft was wrong, not the code
cornell-zhang/allo/allo/customize.py
code served (permissive licence) · get_code("254427a75d1be10e")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import inspect
import torch
import torch.nn as nn

class SimpleModule(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 2)
    
    def forward(self, x):
        return self.linear(x)

def standalone_function():
    """A simple function to use as a test object"""
    pass

class StandaloneClass:
    """A simple class to use as a test object"""
    pass

# The function getsourcefile takes one parameter 'obj'
# It calls inspect.getsourcefile(obj) and inspect.getfile(obj)
# These functions work with any Python object, typically modules, classes, functions, or methods

# Create test objects
module_instance = SimpleModule()
function_obj = standalone_function
class_obj = StandaloneClass
builtin_obj = len

ARGS = {
    "obj": function_obj
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
matmul Ran
ran, honoured the contract we drafted
cornell-zhang/allo/allo/dsl.py
code served (permissive licence) · get_code("2d968c9e47547f7b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create two matrices for matrix multiplication
lhs = np.array([[1.0, 2.0, 3.0],
                [4.0, 5.0, 6.0]], dtype=np.float32)

rhs = np.array([[7.0, 8.0],
                [9.0, 10.0],
                [11.0, 12.0]], dtype=np.float32)

ARGS = {
    "lhs": lhs,
    "rhs": rhs,
    "name": None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (2, 2) — shape (2, 2) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
np_type_to_str Ran
ran; our contract draft was wrong, not the code
cornell-zhang/allo/allo/utils.py
code served (permissive licence) · get_code("53464a64bf0b1b81")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import ml_dtypes

np_supported_types = {'bf16': ml_dtypes.bfloat16, 'f16': np.float16, 'f32': np.float32, 'f64': np.float64, 'i8': np.int8, 'i16': np.int16, 'i32': np.int32, 'i64': np.int64, 'ui1': np.bool_, 'ui8': np.uint8, 'ui16': np.uint16, 'ui32': np.uint32, 'ui64': np.uint64}

def np_type_to_str(dtype):
    return list(np_supported_types.keys())[list(np_supported_types.values()).index(dtype)]

# The function takes a dtype and looks it up in np_supported_types
# It expects dtype to be one of the values in np_supported_types
# Let's pass a valid numpy dtype that exists in the supported types

ARGS = {
    'dtype': np.float32
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
ml_dtypes, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
three_mm_np Ran
ran, honoured the contract we drafted
cornell-zhang/allo-pldi24-artifact/polybench/allo/3mm/three_mm.py
code served (permissive licence) · get_code("4bd63c32dca4cf2a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create small numpy arrays with distinct dimensions for matrix multiplication
# A: 2x3, B: 3x4, C: 4x5, D: 5x2
# This ensures:
# out_AB = A @ B is 2x4
# out_CD = C @ D is 4x2
# out_ABC = out_AB @ out_CD is 2x2

A = np.random.randn(2, 3)
B = np.random.randn(3, 4)
C = np.random.randn(4, 5)
D = np.random.randn(5, 2)

ARGS = {
    "A": A,
    "B": B,
    "C": C,
    "D": D
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (2, 2) — shape (2, 2) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
two_mm_np Ran
ran, honoured the contract we drafted
cornell-zhang/allo-pldi24-artifact/polybench/allo/2mm/two_mm.py
code served (permissive licence) · get_code("98290762149375b8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create small numpy arrays with distinct dimensions for clarity
A = np.random.randn(2, 3)  # 2x3 matrix
B = np.random.randn(3, 4)  # 3x4 matrix
C = np.random.randn(4, 5)  # 4x5 matrix
D = np.random.randn(2, 5)  # 2x5 matrix (matches output shape of A @ B @ C)
alpha = 0.5  # scalar
beta = 2.0   # scalar

ARGS = {
    "A": A,
    "B": B,
    "C": C,
    "D": D,
    "alpha": alpha,
    "beta": beta,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (2, 5) — shape (2, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
wrapped_apply Ran
ran; our contract draft was wrong, not the code
cornell-zhang/allo/allo/customize.py
code served (permissive licence) · get_code("97c24ff209cfacb4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
from functools import wraps
from contextlib import contextmanager

torch.manual_seed(0)

# Mock MLIR-related imports and classes
class MockContext:
    def __enter__(self):
        return self
    
    def __exit__(self, *args):
        pass

class Location:
    @staticmethod
    def unknown():
        return MockContext()

class MockOperation:
    def __init__(self, name):
        self.name = MockName(name)

class MockName:
    def __init__(self, value):
        self.value = value

class MockFuncOp:
    def __init__(self, name):
        self.name = MockName(name)
        self.entry_block = MockBlock()

class MockBlock:
    pass

class MockBody:
    def __init__(self):
        self.operations = [MockFuncOp("test_func")]

class MockModule:
    def __init__(self):
        self.context = MockContext()
        self.body = MockBody()

class InsertionPoint:
    @staticmethod
    def at_block_terminator(block):
        return MockContext()

# Mock func_d module
class func_d:
    class FuncOp:
        pass

def _mlir_lower_pipeline(module):
    pass

# Mock schedule class
class MockSchedule:
    def __init__(self):
        self.module = MockModule()
        self.top_func_name = "test_func"
        self.top_func = None
        self.ip = None
        self.primitive_sequences = []

# Define the wrapped_apply decorator
def wrapped_apply(fn):
    @wraps(fn)
    def wrapper(*args, **kwargs):
        sch = args[0]
        with sch.module.context, Location.unknown():
            res = fn(*args, **kwargs)
        _mlir_lower_pipeline(sch.module)
        for op in sch.module.body.operations:
            if isinstance(op, MockFuncOp) and op.name.value == sch.top_func_name:
                sch.top_func = op
                break
        else:
            raise RuntimeError('Top function not found')
        sch.ip = InsertionPoint.at_block_terminator(sch.top_func.entry_block)
        if fn.__name__ != 'compose':
            sch.primitive_sequences.append((fn.__name__, list(args[1:]), kwargs))
        return res
    return wrapper

# Create a test function to be wrapped
@wrapped_apply
def test_transform(sch, param1, param2=None):
    return "result"

# Create arguments
schedule = MockSchedule()
param1_value = "test_param"
param2_value = {"key": "value"}

ARGS = {
    "fn": test_transform,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
analyze_arg_load_store_in_func Not yet run
unverified (harvested, no recorded run)
cornell-zhang/allo/allo/passes.py
code served (permissive licence) · get_code("f8d709d2cdd5d57c")
How it ran

no invocation recorded.

coalesce_memory_access Not yet run
unverified (harvested, no recorded run)
cornell-zhang/allo/allo/memory.py
code served (permissive licence) · get_code("b638b2ab66043fd2")
How it ran

no invocation recorded.

generate_input_output_buffers Not yet run
unverified (harvested, no recorded run)
cornell-zhang/allo/allo/passes.py
code served (permissive licence) · get_code("be739767a96a835c")
How it ran

no invocation recorded.

lower_linalg_and_attach_names Not yet run
unverified (harvested, no recorded run)
cornell-zhang/allo/allo/passes.py
code served (permissive licence) · get_code("15ab3d55edb1d040")
How it ran

no invocation recorded.

rewrite_output_variable Not yet run
unverified (harvested, no recorded run)
cornell-zhang/allo/allo/verify.py
code served (permissive licence) · get_code("c9b219fb1a29bdf8")
How it ran

no invocation recorded.

store_load_store_load_pattern Not yet run
unverified (harvested, no recorded run)
cornell-zhang/allo/allo/autoscheduler/passes.py
code served (permissive licence) · get_code("0c07f14ad62c090b")
How it ran

no invocation recorded.

verify Not yet run
unverified (harvested, no recorded run)
cornell-zhang/allo/allo/verify.py
code served (permissive licence) · get_code("aa240a45a4e178b7")
How it ran

no invocation recorded.

Also present in other papers' code

Of 20 samples lifted from this paper's linked repositories, 20 carry a function identity and 0 do not. Of the 20 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 20 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Special-purpose hardware accelerators are increasingly pivotal for sustaining performance improvements in emerging applications, especially as the benefits of technology scaling continue to diminish. However, designers currently lack effective tools and methodologies to construct complex, high-performance accelerator architectures in a productive manner. Existing high-level synthesis (HLS) tools often require intrusive source-level changes to attain satisfactory quality of results. Despite the introduction of several new accelerator design languages (ADLs) aiming to enhance or replace HLS, their advantages are more evident in relatively simple applications with a single kernel. Existing ADLs prove less effective for realistic hierarchical designs with multiple kernels, even if the design hierarchy is flattened. In this paper, we introduce Allo, a composable programming model for efficient spatial accelerator design. Allo decouples hardware customizations, including compute, memory, communication, and data type from algorithm specification, and encapsulates them as a set of customization primitives. Allo preserves the hierarchical structure of an input program by combining customizations from different functions in a bottom-up, type-safe manner. This approach facilitates holistic optimizations that span across function boundaries. We conduct comprehensive experiments on commonly-used HLS benchmarks and several realistic deep learning models. Our evaluation shows that Allo can outperform state-of-the-art HLS tools and ADLs on all test cases in the PolyBench. For the GPT2 model, the inference latency of the Allo generated accelerator is 1.7x faster than the NVIDIA A100 GPU with 5.4x higher energy efficiency, demonstrating the capability of Allo to handle large-scale designs.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2404.04815")
get_code_for_paper("2404.04815")
have("2404.04815")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2404.04815.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2404.04815.svg)](https://syntology.ai/paper/2404.04815)

Connect an agent — have() is free.