Pith. sign in

REVIEW 4 major objections 6 minor 49 references

Re-thinking Memory-Bound Limitations in CGRAs

T0 review · 4 major / 6 minor · reviewed 2026-08-05 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read This paper claims that CGRAs can run irregular-memory workloads at scratchpad-only performance with a cache hierarchy that is only 1.27% the storage, by adding runahead execution and per-PE cache reconfiguration.

desk verdict Plausible CGRA runahead + reconfigurable-cache design with real potential, but the multi-cache coherence assumption is stated rather than proven, and the evaluation lacks released artifacts and a CASCADE baseline. read the letter →

arxiv 2508.09570 v2 pith:SBTI7G5Y submitted 2025-08-13 cs.AR

Xiangfeng Liu , Zhe Jiang , Anzhen Zhu , Xiaomeng Han , Mingsong Lyu , Qingxu Deng , Nan Guan This is my paper · ORCID
classification cs.AR
keywords CGRAirregularmemoryaccesssubsystemrunaheadexecutioncachereconfigurationscratchpadprefetchingcoarse-grainedreconfigurablearray
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper tries to establish that coarse-grained reconfigurable arrays can be freed from their scratchpad-memory bottleneck. For graph, database, and sparse HPC kernels, irregular data-dependent accesses can push CGRA utilization below 1.5%; the authors argue this is not an intrinsic limitation but an artifact of the SPM-only memory model. They report that replacing most SPM storage with a small cache hierarchy plus a CGRA-specific runahead mechanism reaches performance comparable to a much larger SPM-only system at 1.27% of the storage, with an average 3.04x speedup over the cache-only baseline and up to 6.91x. The central wager is that cache-miss stall cycles can be turned into useful prefetching: save the CGRA state, run ahead on dummy values, track the dummy data precisely, and restore when the miss resolves.

What carries the argument

The load-bearing mechanism is the CGRA-specific runahead state machine: backup registers for state save/restore, a dummy-data flag bit propagated through each ALU by a single OR gate, non-blocking caches with MSHRs and a load/store table, and a temporary SPM partition for redirected writes. Around it sit two supporting structures: a multi-L1-cache subsystem grouped into virtual SPMs that eliminates inter-cache coherence by compile-time data partitioning, and a cache reconfiguration controller that maximizes the product of per-cache hit rates---equivalently maximizing $\sum_i \log H_i(S_i)$ subject to a total-way budget---by allocating cache ways and merging physical lines into virtual cache

What would settle it

Instrument the runahead-enabled simulator to flag any runahead write of a dummy-derived value to an address that is later read by normal execution before the state restore, and run a deliberately RAW-heavy kernel such as a histogram or bucket sort alongside the paper's suite; a mismatch against a non-runahead golden run would break the correctness premise.

Watch

Extended reading notes

Core claim

The central claim is that memory-bound CGRAs can be rescued by a redesigned memory subsystem whose key piece is runahead execution tailored to the CGRA's deterministic, dataflow-style execution. On a 4x4 HyCUBE, the paper shows that a hybrid SPM-plus-cache hierarchy already beats an equal-storage SPM-only design by 10x, then adds the runahead mechanism: on a cache miss, the CGRA saves its state, substitutes dummy values for missing data, propagates a dummy-tracking flag through the ALU, converts valid reads into precise prefetches, redirects valid writes to a temporary store, and restores state when the miss returns. The authors report that prefetched blocks are almost 100% useful on their b

Load-bearing premise

The central bet is that during runahead, memory never receives a dummy-based value that is later read back as if it were real data; the paper argues that CGRA dataflow routing makes such memory round-trips rare, but it gives no proof or full count for all kernels.

Editorial extensions

If this is right

  • If correct, CGRAs become usable for irregular graph, database, and unstructured-mesh kernels that currently leave utilization near 1.7%.
  • A cache-plus-SPM design that matches SPM-only performance at 1.27% of the storage implies substantial area and energy savings for the same compute capability.
  • Runahead turns cache-miss stalls into precise prefetching, so future CGRA memory subsystems should include non-blocking caches with roughly 16 MSHR entries per cache.
  • Cache reconfiguration yields a further 6.02% average improvement by giving regular and irregular access streams their own cache ways and line sizes.
  • Because the added hardware is confined to uniform PEs and the cache controller, the approach transfers to other CGRA designs without changing the interconnect.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The 1.27% storage comparison is a controlled single-kernel experiment (Cora), so it is a demonstration of the mechanism, not a general law; a sweep across datasets and array sizes would test how the ratio holds.
  • The eviction of useful prefetched lines, visible in the grad and rgb kernels, sets a floor on runahead gains for very large random working sets; combining reconfiguration with eviction-aware prefetching is a natural next step not fully explored in the paper.
  • The save-state/run-dummy/prefetch template could transfer to other statically scheduled dataflow accelerators, such as systolic arrays or VLIW pipelines, wherever memory addresses become known only after data arrives.
  • The strongest test of the correctness premise would be to run kernels deliberately built to force a dummy-derived value through memory and read it back before state restore; the paper does not quantify how often such read-after-write-through-memory cases occur.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 6 minor

Summary. The paper addresses memory-bound execution in CGRAs under irregular memory access patterns. It replaces the pure SPM memory model with an SPM-plus-cache hierarchy, adds a CGRA-specific runahead execution mechanism that prefetches during cache-miss stalls, proposes a multi-L1-cache design with a shared L2, and introduces a hardware/software cache reconfiguration scheme based on access-pattern classification and a DP allocation (Eq. 1--3). Evaluation uses a cycle-accurate HyCUBE-based simulator on GNN, sorting, CFD, and multimedia kernels. Headline results are a 1.27% storage requirement relative to an SPM-only system, an average 3.04x runahead speedup (up to 6.91x), and an additional 6.02% improvement from cache reconfiguration.

Significance. If the results hold, this would be a meaningful step for CGRAs in irregular-memory domains: the paper identifies a real utilization collapse (1.43% in Fig. 2), proposes a concrete runahead mechanism adapted to CGRAs, and presents a clean optimization formulation for cache-way allocation. The area-synthesis overhead analysis (14.78% for the CGRA) and the breadth of benchmarks are also strengths. However, the experimental evidence needs substantial reinforcement: the multi-cache coherence argument is unproven, the runahead correctness argument is asserted rather than demonstrated, the headline configurations are tuned on the same benchmarks used for evaluation, and the simulator is neither released nor validated against real hardware. The central idea is promising, but the current support is not yet sufficient for publication as-is.

major comments (4)
  1. [Sec. 3.3 / Listing 1 / Fig. 17] The multi-cache design eliminates coherence by asserting that compile-time data allocation and static scheduling partition data among virtual SPMs with no overlap. This is load-bearing for the 8x8 Reconfig results and the scalability claim, but no compiler pass, graph preprocessing, runtime check, or coherence fallback is described. For the GCN kernel in Listing 1, output_data[edge_start[i]] and feature[edge_end[i]] are indirect accesses; data-dependent addresses can cause two PEs behind different L1 caches to access the same output_data line, and read-only sharing of feature across PEs is not ruled out. Without a proof or a concrete partition scheme, the evaluation may be for an incorrect machine. Please provide either the static partition algorithm and its correctness argument, or add a coherence mechanism / conservative handling of shared lines.
  2. [Sec. 3.2 / Sec. 4.3, Accuracy paragraph] The runahead mechanism's correctness and prefetch-quality argument are incomplete. The paper admits in Sec. 3.2 that if a dummy-affected write is skipped and the address is later read and used, 'the execution may become inconsistent.' The response -- that most RAW dependencies resolve through the CGRA interconnect -- is not quantified or proved for any of the evaluated kernels. Figure 15's 'useless' fraction measures prefetched blocks that the program never needs; it does not capture the effect of stale reads caused by skipped dependent writes, which can create wrong-address prefetches. Please provide a per-kernel analysis or a formal invariant showing that runahead never changes committed state and that dummy-tainted values cannot cause useful data to be evicted or incorrect lines to be fetched.
  3. [Sec. 4.2--4.4 / Table 3] The reported speedups are based on cache configurations selected by sweeping parameters on the same benchmarks on which the speedups are then reported. The paper repeatedly calls these 'relatively optimal' configurations (Sec. 4.3, 4.4), but no train/test split, cross-validation, or robustness analysis is given. The 3.04x runahead speedup and the 6.02% reconfiguration gain are therefore at risk of overfitting to the evaluation set. Please report results for fixed, a-priori configurations, or show sensitivity across a range of configurations and describe how the configurations generalize.
  4. [Sec. 4, general methodology] The paper's experimental claims rest entirely on a cycle-accurate simulator that is not released, not validated against real HyCUBE hardware, and not compared against the original CGRA-ME/HyCUBE framework. No working-set sizes are reported relative to L1/L2 capacity, and the 1.27% storage claim in Fig. 12f is based on a matched-performance experiment whose SPM size is not shown. I recommend releasing the simulator or an artifact, validating against a hardware prototype or a published reference model, and reporting working-set characteristics so that the absolute speedup and storage-efficiency numbers can be independently checked.
minor comments (6)
  1. [Fig. 1] The caption and the extracted figure text contain duplicated/garbled arrays (e.g., repeated '1 2 1 2 7 2 5 8 1 2'). Please regenerate the figure so it is legible.
  2. [Fig. 7] The x-axis and y-axis labels appear to be corrupted in the text ('x-𝑎𝑥𝑖𝑠 : Time', etc.). Please ensure all axis labels render correctly.
  3. [Sec. 3.4.2] Eq. (1)--(3) is an integer optimization problem solved by DP (Algorithm 1), not a linear program. The text should call it an integer program or dynamic programming formulation.
  4. [Sec. 4.1] The sentence 'Cache+SPM achieves a 10x speedup over the size-equivalent SPM-only design' is ambiguous: Fig. 11a normalizes execution time, not speedup, and the reader must infer the baseline direction. Please state the comparison explicitly.
  5. [Sec. 5.2] The routing complexity claim 'grows proportionally to 2n' is too vague. Please specify whether this is the number of wires, ports, or crossbar width, and define n consistently with the n x n CGRA notation.
  6. [Abstract / Fig. 12f] The 1.27% storage claim should state the exact SPM-only size used for the match and the configured cache/SPM sizes in the main text, not only in a figure caption.

Circularity Check

1 steps flagged · score 2.0 of 10

Minor definitional circularity in the prefetch-accuracy metric; central performance claims are simulator measurements and not circular.

  1. self definitional [Section 4.3, 'Accuracy' paragraph and Figure 15 discussion]
    "The CGRA runahead mechanism achieves precise prefetching through the meticulous tracking of dummy data, retaining only effective prefetch behaviors. This approach ensures that all prefetched data will be utilized in future computations, resulting in a prefetch accuracy of nearly 100% for our CGRA runahead mechanism."

    The prefetch-accuracy claim is partly true by construction: the mechanism is described as 'retaining only effective prefetch behaviors,' so the subset of prefetches counted as accurate is defined to exclude ineffective ones. The subsequent 'near-zero useless blocks' observation is therefore not an independent empirical confirmation; it is an artifact of the tracking/filtering policy. This circularity is minor, however, because the headline 3.04x/6.02% results are actual simulator execution-time measurements, not quantities derived from this accuracy metric.

full rationale

The paper's central performance claims are based on cycle-accurate simulation comparisons: Cache+SPM vs SPM-only, Runahead vs Cache+SPM, and Reconfig vs static cache configurations. These are measurements, not predictions produced by equations that already contain the target speedups. The cache-reconfiguration optimization (Eqs. 1-3) is a self-contained resource-allocation heuristic whose input is sampled hit-rate data; its 6.02% runtime improvement is then measured in simulation. The choice of 'relatively optimal' cache parameters by sweeping on the same benchmarks is a methodology/overfitting concern, but it does not make the measured speedup logically equivalent to the fitted parameter values. The multi-cache coherence argument in Sec. 3.3 rests on an unproven compile-time data-partitioning assumption; this is a correctness/scalability risk, not a circular derivation, since the disjointness is assumed rather than derived from the result. The only concrete circularity found is the prefetch-accuracy claim, where filtering prefetches to 'effective' ones makes near-100% accuracy definitional. This does not support the main speedup claims, so the overall circularity score is low.

Assumptions & free parameters 3 free parameters · 4 assumptions · 3 invented entities

The central claim rests on the simulator's fidelity, on a correctness assumption about dummy-tainted writes during runahead, and on a static data-partitioning assumption that removes cache coherence. These are not external benchmarks; they are assumptions internal to the paper, so correctness risk is concentrated there.

free parameters (3)
  • L1/L2 cache size, line size, associativity, MSHR entries used in Cache+SPM and Runahead evaluations = 4KB L1, 4-way, 64B line, 16 MSHR; 128KB L2, 64B line (Table 3, Runahead)
    These values are obtained by sweeping each parameter on the same benchmark kernels in Sec 4.2, then used for the headline 3.04x runahead evaluation in Sec 4.3.
  • SPM-only storage size matched to Cache+SPM performance = 242,172 bytes vs 3,072 bytes (Sec 4.2, Fig 12f)
    The 1.27% storage claim comes from scaling up the SPM-only SPM until its execution time matches Cache+SPM on the Cora kernel; the matched size is a fitted quantity, not a design constraint.
  • Cache reconfiguration observation window and miss-rate threshold = not specified
    The hardware monitor/tracker behavior depends on a configurable observation window and threshold (Sec 3.4) whose values are never given, so the 6.02% reconfiguration gain is not pinned to a reproducible setting.
assumptions (4)
  • domain assumption Runahead state save/restore plus dummy-data tracking preserves correctness even though dummy-tainted writes can be read later.
    Sec 3.2 concedes an incorrect state is possible if a dummy-updated write is later read; the paper argues the risk is low because dataflow interconnect bypasses memory, but no proof is provided.
  • domain assumption A compiler can statically partition all data across virtual SPMs with no overlap, so multi-cache coherence is unnecessary.
    Sec 3.3 states data is fully partitioned and each cache handles only its partition; for indirect accesses such as edge_start[i] and edge_end[i], addresses depend on runtime values, so disjoint partition is not guaranteed.
  • ad hoc to paper The cycle-accurate HyCUBE-based simulator faithfully models the CGRA, SPM, cache hierarchy, and DRAM latencies.
    All headline numbers come from this closed simulator; no validation against real hardware or another published simulator is reported.
  • domain assumption L2 cache line size matches the maximum L1 line size, so virtual cache lines yield only full hits or full misses.
    Invoked in Sec 3.4.1 to justify treating a virtual cache line as a single replacement unit.
invented entities (3)
  • Virtual SPM (one crossbar plus its private SPM-cache pair as a coherent unit)
    purpose: Eliminate multi-cache coherence by statically partitioning data among crossbar-attached memory partitions.
    Described in Sec 3.3; no independent evidence outside simulation, and it relies on a compiler partition not demonstrated for indirect-access kernels.
  • Dummy-data flag bit propagated through the ALU by an OR gate
    purpose: Track tainted data during runahead so invalid reads and writes can be discarded or redirected.
    Sec 5.1; the claimed near-100% prefetch accuracy depends on this scheme but is only evaluated in the simulator.
  • Temporary storage as a partition of the SPM for runahead writes
    purpose: Prevent dummy-derived writes from corrupting cache or SPM state during runahead.
    Chosen over repurposing cache space in Sec 3.2.1 without a quantitative comparison.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Re-thinking Memory-Bound Limitations in CGRAs." pith.science (2026). https://pith.science/paper/SBTI7G5Y

@misc{pith2026250809570,
  author       = {Pith},
  title        = {Pith review of: Re-thinking Memory-Bound Limitations in CGRAs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/SBTI7G5Y}},
  note         = {Machine review of arXiv:2508.09570}
}
read the original abstract

Coarse-Grained Reconfigurable Arrays (CGRAs) are specialized accelerators commonly employed to boost performance in workloads with iterative structures. Existing research typically focuses on compiler or architecture optimizations aimed at improving CGRA performance, energy efficiency, flexibility, and area utilization, under the idealistic assumption that kernels can access all data from Scratchpad Memory (SPM). However, certain complex workloads-particularly in fields like graph analytics, irregular database operations, and specialized forms of high-performance computing (e.g., unstructured mesh simulations)-exhibit irregular memory access patterns that hinder CGRA utilization, sometimes dropping below 1.5%, making the CGRA memory-bound. To address this challenge, we conduct a thorough analysis of the underlying causes of performance degradation, then propose a redesigned memory subsystem and refine the memory model. With both microarchitectural and theoretical optimization, our solution can effectively manage irregular memory accesses through CGRA-specific runahead execution mechanism and cache reconfiguration techniques. Our results demonstrate that we can achieve performance comparable to the original SPM-only system while requiring only 1.27% of the storage size. The runahead execution mechanism achieves an average 3.04x speedup (up to 6.91x), with cache reconfiguration technique providing an additional 6.02% improvement, significantly enhancing CGRA performance for irregular memory access patterns.

Figures

Figures reproduced from arXiv: 2508.09570 by the authors.

Figure 2
Figure 2. The absence of data in the SPM causes a sig [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. Overview of the Proposed Architecture: (a) Multi-Cache Memory Subsystem: This design illustrates [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figure 4
Figure 4. Overall CGRA architecture and the DFG for listing [PITH_FULL_IMAGE:figures/full_fig_p004_4.png] view at source ↗
Figures from the paper (12 more)
Figure 5
Figure 5. Figure 5: Proportion of irregular memory access among all memory accesses for various workloads (Table [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]
Figure 6
Figure 6. Figure 6: Integration of cache mechanisms into the CGRA and addition of state save and restore logic. [PITH_FULL_IMAGE:figures/full_fig_p006_6.png]
Figure 7
Figure 7. Figure 7: Memory Access Patterns from Benchmark: Top-left shows regular accesses; bottom-left shows irregular [PITH_FULL_IMAGE:figures/full_fig_p009_7.png]
Figure 8
Figure 8. Figure 8: The top-level architecture of the memory subsystem supports cache reconfiguration via hardware [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]
Figure 9
Figure 9. Figure 9: MSHR and Load/Store Table Cache Size Reconfiguration. As shown in Figure 8b, each cache way is assigned a permission register that specifies its associated virtual SPM. By distributing cache ways among different virtual SPMs, we enable reconfiguration of cache size and…
Figure 10
Figure 10. Figure 10: Illustration of DP Table Con￾struction (cache count = 1 & 2) cycle. Therefore, the objective is to maximize the product of hit rates across all caches1 . Taking the logarithm of the product converts this into a sum, thereby simplifying the original problem into a line…
Figure 11
Figure 11. Figure 11: Normalized Benchmark Execution Time and Memory Access Statistics [PITH_FULL_IMAGE:figures/full_fig_p014_11.png]
Figure 12
Figure 12. Figure 12: Execution Time is Normalized. The cache configuration significantly affects the execution time, with [PITH_FULL_IMAGE:figures/full_fig_p015_12.png]
Figure 13
Figure 13. Figure 13: The runahead mechanism achieves to an average performance improvement of 3.04× (up to 6.91×), with particularly significant gains in kernels exhibiting weaker locality. 0 5 10 15 20 25 30 L1 MSHR Size (Entries) 2 4 6 Speedup[x] 2 4 1 2 citeseer cora ogbn_arxiv pubmed …
Figure 15
Figure 15. Figure 15: Distribution of prefetched cache blocks categorized as "Used" (useful blocks successfully utilized [PITH_FULL_IMAGE:figures/full_fig_p018_15.png]
Figure 16
Figure 16. Figure 16: Percentage of memory accesses covered by [PITH_FULL_IMAGE:figures/full_fig_p019_16.png]
Figure 18
Figure 18. Figure 18: Area breakdown of the system configured according to Table [PITH_FULL_IMAGE:figures/full_fig_p020_18.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

49 extracted references · 31 canonical work pages

  1. [1]

    Arm Limited. 2025. Documentation – Arm Developer. https://developer.arm.com/documentation/100095/0003/ Introduction/Features. [Accessed 29-03-2025]

    work page 2025

  2. [2]

    Thilini Kaushalya Bandara, Dhananjaya Wijerathne, Tulika Mitra, and Li-Shiuan Peh. 2022. REV AMP: A Systematic Framework for Heterogeneous CGRA Realization . https://doi.org/10.5281/zenodo.5848404

    work page doi:10.5281/zenodo.5848404 2022

  3. [3]

    Spyros Blanas, Yinan Li, and Jignesh M. Patel. 2011. Design and evaluation of main memory hash join algorithms for multi-core CPUs. In Proceedings of the 2011 ACM SIGMOD International Conference on Management of Data (Athens, Greece) (SIGMOD ’11). Association for Computing Machinery, New York, NY, USA, 37–48. doi:10.1145/1989323.1989328

    work page arXiv 2011

  4. [4]

    Alexander Chin, Noriaki Sakamoto, Allan Rui, Jim Zhao, Jin Hee Kim, Yuko Hara-Azumi, and Jason Anderson

    S. Alexander Chin, Noriaki Sakamoto, Allan Rui, Jim Zhao, Jin Hee Kim, Yuko Hara-Azumi, and Jason Anderson. 2017. CGRA-ME: A unified framework for CGRA modelling and exploration. In 2017 IEEE 28th International Conference on Application-specific Systems, Architectures and Processors (ASAP) . 184–189. doi:10.1109/ASAP.2017.7995277

    arXiv 2017

  5. [5]

    Jason Cong, Hui Huang, Chunyue Liu, and Yi Zou. 2011. A reuse-aware prefetching scheme for scratchpad memory. In 2011 48th ACM/EDAC/IEEE Design Automation Conference (DAC). 960–965. ACM Trans. Embedd. Comput. Syst., Vol. 1, No. 1, Article 1. Publication date: January 2025. 1:24 Xiangfeng Liu, Zhe Jiang, Anzhen Zhu, Xiaomeng Han, Mingsong Lyu, Qingxu Deng,...

    work page 2011

  6. [6]

    Jason Cong, Hui Huang, Chiyuan Ma, Bingjun Xiao, and Peipei Zhou. 2014. A Fully Pipelined and Dynamically Composable Architecture of CGRA. In 2014 IEEE 22nd Annual International Symposium on Field-Programmable Custom Computing Machines. 9–16. doi:10.1109/FCCM.2014.12

    doi:10.1109/fccm.2014.12 2014

  7. [7]

    Chris Cummins, Volker Seeker, Dejan Grubisic, Mostafa Elhoushi, Youwei Liang, Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, Kim Hazelwood, Gabriel Synnaeve, and Hugh Leather. 2023. Large Language Models for Compiler Optimization. arXiv:2309.07062 [cs.PL] https://arxiv.org/abs/2309.07062

    arXiv 2023

  8. [8]

    Shail Dave and Aviral Shrivastava. 2018. Ccf: A cgra compilation framework. In Proc. 21st Design Autom. Test Europe (DATE). 1

    work page 2018

Show all 49 references
  1. [9]

    James Dundas and Trevor Mudge. 1997. Improving data cache performance by pre-executing instructions under a cache miss. In Proceedings of the 11th International Conference on Supercomputing (Vienna, Austria) (ICS ’97). Association for Computing Machinery, New York, NY, USA, 68...

    1997

  2. [10]

    Matthias Fey and Jan Eric Lenssen. 2019. Fast graph representation learning with PyTorch Geometric. arXiv preprint arXiv:1903.02428 (2019)

    2019 arXiv

  3. [11]

    Graham Gobieski, Ahmet Oguz Atli, Kenneth Mai, Brandon Lucia, and Nathan Beckmann. 2021. Snafu: an ultra-low- power, energy-minimal cgra-generation framework and architecture. In 2021 ACM/IEEE 48th Annual International Symposium on Computer Architecture (ISCA) . IEEE, 1027–1040

    2021

  4. [12]

    Yijiang Guo and Guojie Luo. 2020. Pillars: An integrated CGRA design framework. In Third Workshop on Open-Source EDA Technology (WOSET). 1–5

    2020

  5. [13]

    Guthaus, J.S

    M.R. Guthaus, J.S. Ringenberg, D. Ernst, T.M. Austin, T. Mudge, and R.B. Brown. 2001. MiBench: A free, commercially representative embedded benchmark suite. InProceedings of the Fourth Annual IEEE International Workshop on Workload Characterization. WWC-4 (Cat. No.01EX538). 3–...

    2001

  6. [14]

    Michael Allen Heroux and Jack Dongarra. 2013. Toward a new metric for ranking high performance computing systems. Technical Report. Sandia National Lab.(SNL-NM), Albuquerque, NM (United States); University of

    2013

  7. [15]

    Charles Hong, Sahil Bhatia, Alvin Cheung, and Yakun Sophia Shao. 2025. Autocomp: LLM-Driven Code Optimization for Tensor Accelerators. arXiv:2505.18574 [cs.PL] https://arxiv.org/abs/2505.18574

    2025

  8. [16]

    Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec

  9. [17]

    Audsley, and Zheng Dong

    Zhe Jiang, Kecheng Yang, Nathan Fisher, Nan Guan, Neil C. Audsley, and Zheng Dong. 2024. Hopscotch: A Hardware- Software Co-Design for Efficient Cache Resizing on Multi-Core SoCs. IEEE Transactions on Parallel and Distributed Systems 35, 1 (2024), 89–104. doi:10.1109/TPDS.2023.3332711

    2024

  10. [18]

    Manupa Karunaratne, Aditi Kulkarni Mohite, Tulika Mitra, and Li-Shiuan Peh. 2017. HyCUBE: A CGRA with reconfigurable single-cycle multi-hop interconnect. In 2017 54th ACM/EDAC/IEEE Design Automation Conference (DAC). 1–6. doi:10.1145/3061639.3062262

    2017

  11. [19]

    Youngbin Kim, Kyoungwoo Lee, and Aviral Shrivastava. 2019. Static Function Prefetching for Efficient Code Man- agement on Scratchpad Memory. In 2019 IEEE 37th International Conference on Computer Design (ICCD) . 350–358. doi:10.1109/ICCD46524.2019.00056

    2019

  12. [20]

    Mingyang Kou, Jiangyuan Gu, Shaojun Wei, Hailong Yao, and Shouyi Yin. 2020. TAEM: Fast Transfer-Aware Effective Loop Mapping for Heterogeneous Resources on CGRA. In 2020 57th ACM/IEEE Design Automation Conference (DAC) . 1–6. doi:10.1109/DAC18072.2020.9218668

    2020

  13. [21]

    Chris Lattner, Mehdi Amini, Uday Bondhugula, Albert Cohen, Andy Davis, Jacques Pienaar, River Riddle, Tatiana Shpeisman, Nicolas Vasilache, and Oleksandr Zinenko. 2020. MLIR: A Compiler Infrastructure for the End of Moore’s Law. arXiv:2002.11054 [cs.PL] https://arxiv.org/abs/2...

    2020 arXiv

  14. [22]

    Chris Lattner, Mehdi Amini, Uday Bondhugula, Albert Cohen, Andy Davis, Jacques Pienaar, River Riddle, Tatiana Shpeisman, Nicolas Vasilache, and Oleksandr Zinenko. 2021. MLIR: Scaling Compiler Infrastructure for Domain Specific Computation. In 2021 IEEE/ACM International Sympos...

    2021

  15. [23]

    Hongsik Lee, Dong Nguyen, and Jongeun Lee. 2015. Optimizing stream program performance on CGRA-based systems?. In 2015 52nd ACM/EDAC/IEEE Design Automation Conference (DAC). 1–6. doi:10.1145/2744769.2744884

    2015

  16. [24]

    Zhaoying Li, Dhananjaya Wijerathne, Xianzhang Chen, Anuj Pathania, and Tulika Mitra. 2022. ChordMap: Automated Mapping of Streaming Applications Onto CGRA. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 41, 2 (2022), 306–319. doi:10.1109/TCAD.202...

    2022

  17. [25]

    Dajiang Liu, Yuxin Xia, Jiaxing Shang, Jiang Zhong, Peng Ouyang, and Shouyi Yin. 2024. E2EMap: End-to-End Reinforcement Learning for CGRA Compilation via Reverse Mapping. In 2024 IEEE International Symposium on High-Performance Computer Architecture (HPCA). 46–60. doi:10.1109/...

    2024

  18. [26]

    Yixuan Luo, Cheng Tan, Nicolas Bohm Agostini, Ang Li, Antonino Tumeo, Nirav Dave, and Tong Geng. 2023. ML- CGRA: An Integrated Compilation Framework to Enable Efficient Machine Learning Acceleration on CGRAs. In 2023 60th ACM/IEEE Design Automation Conference (DAC). 1–6. doi:1...

    2023

  19. [27]

    Bingfeng Mei, Serge Vernalde, Diederik Verkest, Hugo De Man, and Rudy Lauwereins. 2003. ADRES: An Architecture with Tightly Coupled VLIW Processor and Coarse-Grained Reconfigurable Matrix. In International Conference on Field-Programmable Logic and Applications. https://api.se...

    2003

  20. [28]

    Mutlu, Hyesoon Kim, J

    O. Mutlu, Hyesoon Kim, J. Stark, and Y.N. Patt. 2005. On Reusing the Results of Pre-Executed Instructions in a Runahead Execution Processor. IEEE Computer Architecture Letters 4, 1 (2005), 2–2. doi:10.1109/L-CA.2005.1

    2005 doi

  21. [29]

    Mutlu, J

    O. Mutlu, J. Stark, C. Wilkerson, and Y.N. Patt. 2003. Runahead execution: an alternative to very large instruction windows for out-of-order processors. InThe Ninth International Symposium on High-Performance Computer Architecture,

    2003

  22. [30]

    Jones, and Lieven Eeckhout

    Ajeya Naithani, Sam Ainsworth, Timothy M. Jones, and Lieven Eeckhout. 2021. Vector Runahead. In 2021 ACM/IEEE 48th Annual International Symposium on Computer Architecture (ISCA) . 195–208. doi:10.1109/ISCA52012.2021.00024

    2021

  23. [31]

    Jones, and Lieven Eeckhout

    Ajeya Naithani, Jaime Roelandts, Sam Ainsworth, Timothy M. Jones, and Lieven Eeckhout. 2023. Decoupled Vector Runahead. In 2023 56th IEEE/ACM International Symposium on Microarchitecture (MICRO) . 17–31

    2023

  24. [32]

    Brandon Reagen, Robert Adolf, Yakun Sophia Shao, Gu-Yeon Wei, and David Brooks. 2014. MachSuite: Benchmarks for accelerator design and customized architectures. In 2014 IEEE International Symposium on Workload Characterization (IISWC). 110–119. doi:10.1109/IISWC.2014.6983050

    2014

  25. [33]

    Reza Salkhordeh, Shahriar Ebrahimi, and Hossein Asadi. 2018. ReCA: An Efficient Reconfigurable Cache Architecture for Storage Systems with Online Workload Characterization. IEEE Transactions on Parallel and Distributed Systems 29, 7 (2018), 1605–1620. doi:10.1109/TPDS.2018.2796100

    2018

  26. [34]

    Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Gallagher, and Tina Eliassi-Rad. 2008. Collective Classification in Network Data. In The AI Magazine. https://api.semanticscholar.org/CorpusID:62016134

    2008

  27. [35]

    Harold Herbert Seward. 1954. Information sorting in the application of electronic digital computers to business operations . Ph. D. Dissertation. Massachusetts Institute of Technology. Department of Electrical Engineering

    1954

  28. [36]

    Kurdahi, and Eliseu M

    Hartej Singh, Ming-Hau Lee, Guangming Lu, Nader Bagherzadeh, Fadi J. Kurdahi, and Eliseu M. Chaves Filho. 2000. MorphoSys: An Integrated Reconfigurable System for Data-Parallel and Computation-Intensive Applications. IEEE Trans. Comput. 49, 5 (may 2000), 465–481. doi:10.1109/12.859540

    2000 doi

  29. [37]

    Nathan T Slingerland and Alan Jay Smith. 2002. Design and characterization of the Berkeley multimedia workload. Multimedia Systems 8, 4 (2002), 315–327

    2002

  30. [38]

    Barker, and Antonino Tumeo

    Cheng Tan, Nicolas Bohm Agostini, Tong Geng, Chenhao Xie, Jiajia Li, Ang Li, Kevin J. Barker, and Antonino Tumeo

  31. [39]

    Barker, and Antonino Tumeo

    Cheng Tan, Chenhao Xie, Ang Li, Kevin J. Barker, and Antonino Tumeo. 2020. OpenCGRA: An Open-Source Unified Framework for Modeling, Testing, and Evaluating CGRAs. In 2020 IEEE 38th International Conference on Computer Design (ICCD). 381–388. doi:10.1109/ICCD50377.2020.00070

    2020

  32. [40]

    Christopher Torng, Peitian Pan, Yanghui Ou, Cheng Tan, and Christopher Batten. 2021. Ultra-Elastic CGRAs for Irregular Loop Specialization. In2021 IEEE International Symposium on High-Performance Computer Architecture (HPCA). 412–425. doi:10.1109/HPCA51647.2021.00042

    2021

  33. [41]

    Dhananjaya Wijerathne, Zhaoying Li, Manupa Karunarathne, Anuj Pathania, and Tulika Mitra. 2019. CASCADE: High Throughput Data Streaming via Decoupled Access-Execute CGRA. ACM Trans. Embed. Comput. Syst. 18, 5s, Article 50 (Oct. 2019), 26 pages. doi:10.1145/3358177

    2019 doi

  34. [42]

    Dhananjaya Wijerathne, Zhaoying Li, Manupa Karunaratne, Li-Shiuan Peh, and Tulika Mitra. 2022. Morpher: An open- source integrated compilation and simulation framework for cgra. In Fifth Workshop on Open-Source EDA Technology (WOSET)

    2022

  35. [43]

    Jackson Woodruff, Thomas Koehler, Alexander Brauckmann, Chris Cummins, Sam Ainsworth, and Michael F. P. O’Boyle. 2023. Rewriting History: Repurposing Domain-Specific CGRAs. CoRR abs/2309.09112 (2023). doi:10.48550/ ARXIV.2309.09112 arXiv:2309.09112

    2023 doi arXiv

  36. [44]

    Chuanjun Zhang, Frank Vahid, and Roman Lysecky. 2004. A self-tuning cache architecture for embedded systems. ACM Trans. Embed. Comput. Syst. 3, 2 (may 2004), 407–425. doi:10.1145/993396.993405

    2004

  37. [45]

    Zhongyuan Zhao, Weiguang Sheng, Qin Wang, Wenzhi Yin, Pengfei Ye, Jinchao Li, and Zhigang Mao. 2020. Towards Higher Performance and Robust Compilation for CGRA Modulo Scheduling. IEEE Transactions on Parallel and Distributed Systems 31, 9 (2020), 2201–2219. doi:10.1109/TPDS.20...

    2020

  38. [46]

    Jie Zhou, Ganqu Cui, Shengding Hu, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, Lifeng Wang, Changcheng Li, and Maosong Sun. 2020. Graph neural networks: A review of methods and applications. AI Open 1 (2020), 57–81. doi:10.1016/j.aiopen.2021.01.001 ACM Trans. Embedd. Comput. Syst...

    2020 doi

  39. [2003]

    Proceedings

    HPCA-9 2003. Proceedings. 129–140. doi:10.1109/HPCA.2003.1183532

    2003 arXiv

  40. [2020]

    In Proceedings of the 34th International Conference on Neural Information Processing Systems (Vancouver, BC, Canada) (NIPS ’20)

    Open graph benchmark: datasets for machine learning on graphs. In Proceedings of the 34th International Conference on Neural Information Processing Systems (Vancouver, BC, Canada) (NIPS ’20). Curran Associates Inc., Red Hook, NY, USA, Article 1855, 16 pages

  41. [2022]

    In 2022 IEEE International Symposium on High-Performance Computer Architecture (HPCA)

    DRIPS: Dynamic Rebalancing of Pipelined Streaming Applications on CGRAs. In 2022 IEEE International Symposium on High-Performance Computer Architecture (HPCA) . 304–316. doi:10.1109/HPCA53966.2022.00030

    2022

Pith tools

Reviewed August 5, 2026 · model on record in the stance chip above.