Coarse-grained reconfigurable array

A coarse-grained reconfigurable array or coarse-grained reconfigurable architecture (CGRA) is a class of spatial computing hardware built from a relatively large number of processing elements (PEs) connected through a programmable, statically or dynamically reconfigurable on-chip interconnect. By reconfiguring both the operation of each PE and the routing between PEs, a CGRA can be specialized to implement the dataflow graph of a computation, most often the body of a performance-critical loop. It sits between the adaptability of software-programmable processors and the energy efficiency of custom hardware.

Log-scale plot of energy efficiency against flexibility for hardware classes, with ASICs most efficient but least flexible, CPUs least efficient but most flexible, and CGRAs highlighted near the efficient, low-flexibility end.
Energy efficiency (MOPS/mW, log scale) versus flexibility for the principal hardware classes. Efficiency and flexibility trade off against each other, and CGRAs (highlighted) sit toward the ASIC end of the efficiency scale while remaining considerably more flexible.

The building blocks of a CGRA are fixed at the word level and reconfigured at a coarse granularity, distinguishing it from a field-programmable gate array (FPGA). FPGAs are reconfigurable at the level of individual bits and logic gates, which yields great flexibility at the cost of increased area, power, and configuration time overheads. General-purpose processors (CPUs and GPUs) are also highly flexible, but pay the energy cost of fetching and decoding an instruction stream for every operation, whereas an application-specific integrated circuit (ASIC) is the most energy-efficient option precisely because it is specialized to a single application and therefore the least flexible. By operating at word granularity, a CGRA retains much of the spatial, energy-efficient parallelism of custom hardware while remaining reprogrammable in software.

CGRAs were first envisioned in 1960 and took their modern shape in the mid-1990s. Since then, they have been applied to signal processing, wireless communication, and machine learning, and they appear in both academic prototypes and commercial silicon. Running a program on a CGRA depends on a specialized compiler that maps the program’s dataflow graph onto the array, a step that remains one of the main obstacles to wider adoption.

Background

Interest in CGRAs comes from a widening gap in the hardware landscape. As the end of Dennard scaling and the slowing of Moore’s law reduce the performance gains that general-purpose processors once delivered automatically, computer architecture turned toward specialization to keep improving performance per watt, pushed in part by demanding workloads such as neural networks. At one extreme, fixed-function ASICs achieve the highest efficiency but incur high non-recurring engineering costs and cannot be changed after fabrication. At the other end, von Neumann processors are fully programmable but energy-inefficient, with FPGAs sitting in a flexible but costly middle ground. As dataflow architecture is reconfigurable at the word level, CGRAs try to combine near-ASIC efficiency with post-fabrication programmability.

History

The idea of a machine whose structure can be reconfigured for a computation dates to the "fixed-plus-variable structure computer" proposed by Gerald Estrin in 1960. Coarse-grained arrays in the modern sense emerged in the mid-1990s, when several groups replaced the bit-level cells of an FPGA with word-level processing elements. The KressArray introduced a two-dimensional mesh of reconfigurable datapath units; MATRIX combined a word-level datapath with a configurable interconnect; RaPiD and PipeRench organized their cells as reconfigurable pipelines, with PipeRench reaching silicon; and MorphoSys paired a reconfigurable-cell mesh with a control processor for data-parallel media workloads.

Through the 2000s, the designs grew larger and more tightly integrated. ADRES coupled a VLIW processor with a reconfigurable matrix; TRIPS explored a polymorphous array capable of exploiting instruction-, thread-, and data-level parallelism; and PACT XPP offered a self-reconfiguring commercial fabric. From the 2010s onward, research emphasized data movement and system integration: HyCUBE introduced a single-cycle multi-hop interconnect, Plasticine organized computation around pattern compute and pattern memory units, and the stream-dataflow (Softbrain) model decoupled memory streaming from the spatial datapath. The same period saw an open-source ecosystem take shape, including ultra-low-power edge arrays such as OpenEdgeCGRA, which is integrated with the X-HEEP RISC-V microcontroller in the HEEPsilon platform to give a complete flow from C code to hardware.

A handful of CGRAs have reached commercial silicon. Samsung’s Reconfigurable Processor (SRP), derived from ADRES, has appeared in systems-on-chip and in ultra-low-power biomedical variants; SambaNova commercialized its reconfigurable dataflow unit (RDU), a large dataflow accelerator built from pattern compute and pattern memory units and aimed at machine-learning training and inference.

Architecture

A CGRA fabric is typically organized as a two-dimensional array of processing elements, each built around an arithmetic logic unit (ALU) or functional unit, a small local register file or set of pipeline registers, and one or more configuration registers that determine, on a per-PE basis, which operation to execute and how operands are routed. The PEs are connected by a programmable interconnect (commonly a mesh, a torus, or, for smaller arrays, a crossbar switch) that lets operands produced by one PE reach its neighbors or, in richer designs, more distant PEs. Most CGRAs are not standalone; the array is coupled to a host or control processor, a role historically filled by a VLIW or ARM core and, in many recent open-source designs, by a RISC-V core. Depending on how closely the array is bound to the host, a CGRA is described as tightly coupled, sitting inside the processor datapath and invoked as a custom instruction, or loosely coupled, acting as a separate accelerator that communicates over an on-chip interconnect. The loosely coupled arrangement is the more common one in larger modern systems.

Three-panel schematic showing a controller-driven array attached to memory, a mesh of interconnected processing elements fed by a data manager, and the interior of one processing element with a functional unit, local memory and a crossbar.
A CGRA at three levels of detail: the array driven by a controller and coupled to memory (left), the mesh of processing elements fed by a data manager (center), and the internals of one PE, namely its functional unit, local memory, and crossbar interconnect (right).

Programming a CGRA means loading a configuration into the array’s configuration memory: for each PE, the configuration specifies its operation (for example, add, multiply, shift, or compare) and the routing of its inputs and outputs. Because this configuration is coarse-grained, a dedicated CGRA can switch to a new configuration in nanoseconds, orders of magnitude faster than an FPGA can reconfigure. A single configuration yields a single spatial "snapshot" of the dataflow graph (DFG) being executed. In spatial-only CGRAs, the DFG of a kernel is unrolled once across the array, and each PE keeps the same configuration for the whole execution, similar in spirit to a systolic array. In temporal or spatio-temporal CGRAs, each PE instead cycles through a short sequence of configurations held in local configuration memory, time-multiplexing several DFG nodes onto the same physical PE across successive cycles.

The literature further classifies CGRA execution by the number of configurations and data streams a PE array handles at once: single-configuration, single-data (SCSD); single-configuration, multiple-data (SCMD), in which one configuration is applied across the array; and multiple-configuration, multiple-data (MCMD), in which several distinct configurations run concurrently.

Comparison of CGRAs with other computing architectures
Architecture Flexibility Computation form Execution mechanism
Temporal Spatial Reconfiguration time Configuration-driven Dataflow-driven Instruction-driven
CGRA Domain Yes Yes ns–μs Yes Yes No
AI engine (a) Domain Yes Yes ns–μs Yes Yes Yes
FPGA General No(1) Yes ms–s Yes Yes No
ASIC Fixed No Yes No No(2) Yes No
CPU General Yes Yes N/a No No Yes
GPU General Yes Yes N/a No No Yes
Multi-core processor General Yes No N/a No Yes Yes

Notes:

A two-by-two chart plotting PE composition, from homogeneous to heterogeneous, against execution model, from spatial-only to spatio-temporal, with difficulty increasing toward the top-right corner.
The two-dimensional CGRA design space: PE composition (homogeneous ↔ heterogeneous) against execution model (spatial-only ↔ spatio-temporal). Specialization and mapping difficulty increase toward the top-right.

A further architectural distinction concerns whether the PEs across the array are identical or specialized. In a homogeneous CGRA, every PE supports the same set of operations, which simplifies placement and routing during compilation. In a heterogeneous CGRA, the PEs are specialized (for instance, only some implement a multiplier or a memory load/store unit, while the rest handle simpler arithmetic and logic operations). This reduces area and power for a given target workload, but at the cost of a harder mapping problem, since the compiler must place each operation on a PE that actually supports it. The homogeneous-versus-heterogeneous axis is independent of the spatial-versus-spatio-temporal distinction, giving a two-dimensional design space that runs from simple, easy-to-compile homogeneous-spatial arrays to complex, highly specialized heterogeneous-spatio-temporal ones.

Programming and compilation

Flowchart running from source code to a dataflow graph, then scheduling and place-and-route onto the array, producing a configuration, with a feedback arrow that raises the initiation interval when mapping fails.
Typical CGRA compilation flow: source code is reduced to a dataflow graph, which is scheduled and placed-and-routed onto the array to produce a configuration. On mapping failure the initiation interval (II) is increased and the kernel re-mapped.

Because a CGRA executes a spatial dataflow graph rather than a sequential instruction stream, its compiler must turn a program into a placed-and-routed configuration rather than into machine instructions. A typical flow starts from a high-level language, usually C or C++, identifies the performance-critical loops, and lowers each of them to a dataflow graph, commonly through an LLVM-based front end, despite some novel methodology uses MLIR. Loops that contain conditionals are made spatial by converting control dependencies into data dependencies through predication, whether partial or full, so that both sides of a branch are computed, and the correct result is then selected.

The core of the flow is the mapping problem: binding each DFG node to a PE and routing every data dependency through the interconnect, subject to the PEs’ operational capabilities, the interconnect topology, and timing constraints. This problem is NP-complete and is usually split into two coupled sub-problems: scheduling, which assigns each operation a time slot, and placement-and-routing, which binds operations to PEs and reserves interconnect resources. For pipelined loops, the key quality metric is the initiation interval (II), the number of cycles between the start of successive loop iterations, which sets the throughput. Software pipelining by modulo scheduling searches for a valid mapping at the smallest achievable II, raising the II and rescheduling whenever mapping fails. Mappers described in the literature use heuristics, simulated annealing, integer linear programming, graph-theoretic formulations such as maximal-clique search, and, more recently, learning-based and hierarchical methods.

Selected open-source CGRA design and compilation frameworks
FrameworkFirst releaseOriginInput / front endMappingRTL generationSimulationDistinguishing features
CGRA-ME2017 (v2.0, 2024)University of TorontoC via LLVM; custom architecture descriptionArchitecture-adaptive; ILP and simulated annealingVerilogYes (from v2.0)Models homogeneous spatio-temporal CGRAs; limited handling of control divergence
CCF2018Arizona State UniversityC with #pragma CGRA (Clang/LLVM)Graph-based; partial predicationNoCycle-accurate (gem5, CPU + CGRA)CPU-coupled accelerator; MiBench, Parboil and Rodinia benchmarks
OpenCGRA / CGRA-Flow2021Pacific Northwest National Laboratory / Northeastern UniversityC/C++ loop; optional GUIOperation-centric; supports control divergence, recurrences, multidimensional loopsVerilog (FPGA-synthesizable)Yes (user-provided test benches)GUI front end (CGRA-Flow); parameterizable interconnect generator
Morpher2022National University of SingaporeC via LLVMArchitecture-adaptive; heuristic, simulated annealing, and learning-based (LISA)Yes (via Pillars/Chisel)Cycle-accurate with automated validationLearning-based (LISA) mapping; automated validation flow

These frameworks differ mainly along four axes: whether they generate a DFG automatically from source or require the user to supply one; whether their mapper is architecture-adaptive (able to retarget a new interconnect or PE mix without code changes); whether they emit synthesizable RTL; and whether they include an integrated cycle-accurate simulator. Comparative studies typically report the achievable initiation interval, mapping success rate, and compilation time across standard loop-kernel benchmark suites such as PolyBench.

Challenges

Despite their efficiency advantages, CGRAs remain an open research question, with limitations in programmability and productivity yet to be solved.

Mapping and scheduling

Mapping a kernel’s dataflow graph onto the array and routing its dependencies through the interconnect is a hard combinatorial problem. The compiler must simultaneously satisfy PE-capability, routing/adjacency, and timing constraints, and the difficulty compounds when the PEs are heterogeneous or the interconnect topology is irregular. A mapping that succeeds for one kernel may fail for a slightly different one on the same fabric.

Control flow

CGRAs map most naturally onto affine, loop-dominated, data-parallel kernels expressed as dataflow graphs. Irregular control flow, such as data-dependent branches, function calls, and pointer chasing, does not translate cleanly onto a spatial fabric, whether that fabric is statically or dynamically scheduled, and handling it efficiently remains an active research problem.

Configuration memory overhead

Temporal and spatio-temporal designs need sufficient on-chip configuration (context) memory to hold every configuration a PE cycles through. Keeping several distinct configurations resident at once (the multiple-configuration, multiple-data, or MCMD, execution model) costs more of this memory than sharing a single configuration across the array, as in the single-configuration, multiple-data (SCMD) model. That capacity translates directly into area and power, a cost that must be weighed against the execution model a given workload actually needs.

Toolchain fragmentation

Unlike CPUs and GPUs, CGRAs have no standard, widely adopted compiler or hardware-description ecosystem. Most academic and industrial designs still rely on bespoke, architecture-specific toolchains, which limit reproducibility and slow adoption beyond the group that built a given fabric.

Applications

CGRAs are best suited to compute-intensive, loop-dominated kernels with regular dataflow, and their application history reflects this. Early arrays targeted digital signal processing, multimedia, and image and video processing, where the same operations are applied to streams of data. Related work applied them to wireless baseband and software-defined radio, using reconfigurability to switch between standards.

More recently, the dominant driver has been machine learning. CGRAs and CGRA-like dataflow accelerators are used for deep neural network inference and training, from large commercial systems that run transformer and large-language-model workloads down to ultra-low-power arrays at the edge. Other domains include scientific and high-performance computing, embedded bio-signal processing for wearable and near-sensor devices, and error-tolerant workloads addressed through approximate computing variants that trade accuracy for energy.

Notable implementations

The following table lists representative CGRA and CGRA-like designs from academia and industry, spanning the eras described in the History section.

Representative CGRA implementations
SystemYearOriginTypeNotable for
RaPiD1996University of WashingtonAcademicLinear, pipelined reconfigurable datapath
ADRES2003IMECAcademicVLIW host tightly coupled to a reconfigurable matrix
PACT XPP2003PACT XPP TechnologiesCommercialSelf-reconfiguring dataflow fabric
TRIPS2004University of Texas at AustinAcademicPolymorphous array (ILP/TLP/DLP)
Samsung SRP2010sSamsungCommercialADRES-derived; used in systems-on-chip
DySER2012University of Wisconsin–MadisonAcademicReconfigurable array embedded in a processor pipeline
HyCUBE2017National University of SingaporeAcademicSingle-cycle multi-hop interconnect
Plasticine2017Stanford UniversityAcademicPattern compute and pattern memory units
Renesas DRP2018RenesasCommercialDynamically reconfigurable processor for embedded AI
SambaNova RDU2021SambaNovaCommercialPlasticine-derived AI dataflow accelerator
OpenEdgeCGRA2023EPFLAcademicResizable ultra-low-power edge array (HEEPsilon / X-HEEP)
UbitiumCGRA 2026 Ubitium Commercial First CGRA to run Linux without a processor as controller

See also

References

  1. 1 2 3 4 5 6 7 8 9 10 11 12 Liu, Leibo; Zhu, Jianfeng; Li, Zhaoshi; Lu, Yanan; Deng, Yangdong; Han, Jie; Yin, Shouyi; Wei, Shaojun (2019). "A Survey of Coarse-Grained Reconfigurable Architecture and Design: Taxonomy, Challenges, and Applications". ACM Computing Surveys. 52 (6): 118:1–118:39. doi:10.1145/3357375.
  2. 1 2 3 4 Podobas, Artur; Sano, Kentaro; Matsuoka, Satoshi (2020). "A Survey on Coarse-Grained Reconfigurable Architectures From a Performance Perspective". IEEE Access. 8: 146719–146743. arXiv:2004.04509. Bibcode:2020IEEEA...8n6719P. doi:10.1109/ACCESS.2020.3012084. ISSN 2169-3536.
  3. 1 2 3 Silvano, Cristina; Ielmini, Daniele; Ferrandi, Fabrizio; Fiorin, Leandro; Curzel, Serena; Benini, Luca; Conti, Francesco; Garofalo, Angelo; Zambelli, Cristian; Calore, Enrico; Schifano, Sebastiano; Palesi, Maurizio; Ascia, Giuseppe; Patti, Davide; Petra, Nicola (2025). "A Survey on Deep Learning Hardware Accelerators for Heterogeneous HPC Platforms". ACM Computing Surveys. 57 (11): 286:1–286:39. arXiv:2306.15552. doi:10.1145/3729215. hdl:11585/1025795. ISSN 0360-0300.
  4. 1 2 Estrin, Gerald (1960). Organization of computer systems: the fixed plus variable structure computer. Papers Presented at the May 3–5, 1960, Western Joint IRE-AIEE-ACM Computer Conference (IRE-AIEE-ACM '60 (Western)). New York: Association for Computing Machinery. pp. 33–40. doi:10.1145/1460361.1460365.
  5. 1 2 3 Wijtvliet, Mark; Waeijen, Luc; Corporaal, Henk (2016). Coarse grained reconfigurable architectures in the past 25 years: Overview and classification. 2016 International Conference on Embedded Computer Systems: Architectures, Modeling and Simulation (SAMOS). Agios Konstantinos, Samos Island, Greece: IEEE. pp. 235–244. doi:10.1109/SAMOS.2016.7818353. ISBN 978-1-5090-3076-7.
  6. ↑ Singh, Hartej; Lee, Ming-Hau; Lu, Guangming; Kurdahi, Fadi J.; Bagherzadeh, Nader; Chaves Filho, Eliseu M. (2000). "MorphoSys: an integrated reconfigurable system for data-parallel and computation-intensive applications". IEEE Transactions on Computers. 49 (5): 465–481. Bibcode:2000ITCmp..49..465S. doi:10.1109/12.859540.
  7. 1 2 Mei, Bingfeng; Vernalde, Serge; Verkest, Diederik; De Man, Hugo; Lauwereins, Rudy (2003). "ADRES: An Architecture with Tightly Coupled VLIW Processor and Coarse-Grained Reconfigurable Matrix". Field Programmable Logic and Application (FPL 2003). Lecture Notes in Computer Science. Vol. 2778. Springer. pp. 61–70. doi:10.1007/978-3-540-45234-8_7. ISBN 978-3-540-45234-8.
  8. 1 2 Sankaralingam, Karthikeyan; Nagarajan, Ramadass; Liu, Haiming; Kim, Changkyu; Huh, Jaehyuk; Ranganathan, Nitya; Burger, Doug; Keckler, Stephen W.; McDonald, Robert G.; Moore, Charles R. (2004). "TRIPS: A polymorphous architecture for exploiting ILP, TLP, and DLP". ACM Transactions on Architecture and Code Optimization. 1 (1): 62–93. doi:10.1145/980152.980156.
  9. 1 2 Baumgarte, V.; Ehlers, G.; May, F.; Nückel, A.; Vorbach, M.; Weinhardt, M. (2003). "PACT XPP—A Self-Reconfigurable Data Processing Architecture". The Journal of Supercomputing. 26 (2): 167–184. doi:10.1023/A:1024499601571. ISSN 1573-0484.
  10. 1 2 Karunaratne, Manupa; Mohite, Aditi Kulkarni; Mitra, Tulika; Peh, Li-Shiuan (2017). HyCUBE: A CGRA with reconfigurable single-cycle multi-hop interconnect. Proceedings of the 54th Annual Design Automation Conference (DAC '17). ACM. pp. 1–6. doi:10.1145/3061639.3062262. ISBN 978-1-4503-4927-7.
  11. 1 2 Prabhakar, Raghu; Zhang, Yaqi; Koeplinger, David; Feldman, Matt; Zhao, Tian; Hadjis, Stefan; Pedram, Ardavan; Kozyrakis, Christos; Olukotun, Kunle (2017). Plasticine: A Reconfigurable Architecture for Parallel Patterns. Proceedings of the 44th Annual International Symposium on Computer Architecture (ISCA '17). ACM. pp. 389–402. doi:10.1145/3079856.3080256. ISBN 978-1-4503-4892-8.
  12. ↑ Nowatzki, Tony; Gangadhar, Vinay; Ardalani, Newsha; Sankaralingam, Karthikeyan (2017). Stream-dataflow acceleration. Proceedings of the 44th Annual International Symposium on Computer Architecture (ISCA '17). ACM. pp. 416–429. doi:10.1145/3079856.3080255. ISBN 978-1-4503-4892-8.
  13. ↑ Rodríguez Álvarez, Rubén; Denkinger, Benoît Walter; Sapriza, Juan; Miranda Calero, José Angel; Ansaloni, Giovanni; Atienza, David (2023). An Open-Hardware Coarse-Grained Reconfigurable Array for Edge Computing. Proceedings of the 20th ACM International Conference on Computing Frontiers (CF '23). ACM. pp. 391–392. doi:10.1145/3587135.3591437. ISBN 979-8-4007-0140-5.
  14. 1 2 Machetti, Simone; Schiavone, Pasquale Davide; Ansaloni, Giovanni; Peón-Quirós, Miguel; Atienza, David (2025). X-HEEP: An Open-Source, Configurable and Extendible RISC-V Platform for TinyAI Applications. 2025 IEEE Computer Society Annual Symposium on VLSI (ISVLSI). Kalamata, Greece: IEEE. pp. 1–6. doi:10.1109/ISVLSI65124.2025.11130281. ISBN 979-8-3315-3477-6.
  15. 1 2 Kim, Changmoo; Chung, Mookyoung; Cho, Yeongon; Konijnenburg, Mario; Ryu, Soojung; Kim, Jeongwook (2014). "ULP-SRP: Ultra Low-Power Samsung Reconfigurable Processor for Biomedical Applications". ACM Transactions on Reconfigurable Technology and Systems. 7 (3): 22:1–22:15. doi:10.1145/2629610.
  16. ↑ Park, Young-Hwan; Kim, Jaehyun; Kim, Minsoo; Lee, Wonchang; Lee, Shihwa (2015). "Programmable multimedia platform based on reconfigurable processor for 8K UHD TV". IEEE Transactions on Consumer Electronics. 61 (4): 516–523. Bibcode:2015ITCE...61..516P. doi:10.1109/TCE.2015.7389807.
  17. 1 2 Prabhakar, Raghu; Sivaramakrishnan, Ram; Gandhi, Darshan; Du, Yun; Wang, Mingran; Song, Xiangyu; et al. (2024). "SambaNova SN40L: Scaling the AI Memory Wall with Dataflow and Composition of Experts". 2024 57th IEEE/ACM International Symposium on Microarchitecture (MICRO). Austin, TX, USA: IEEE. pp. 1353–1366. arXiv:2405.07518. doi:10.1109/MICRO61859.2024.00100. ISBN 979-8-3503-5057-9.
  18. ↑ Abarajithan, G.; Ma, Zhenghua; Munasinghe, Ravidu; Restuccia, Francesco; Kastner, Ryan (2026). "CGRA4ML: A Hardware/Software Framework to Implement Neural Networks for Scientific Edge Computing". ACM Transactions on Reconfigurable Technology and Systems. 19 (2): 1–33. arXiv:2408.15561. doi:10.1145/3801097. ISSN 1936-7406.
  19. ↑ Sorrentino, Giuseppe; Galfano, Paolo S.; Di Salvo, Claudio; D’Arnese, Eleonora; Conficconi, Davide (2026). Adaptive AIE–PL Systems for Efficient End-to-End Pyramidal 3D Image Registration. 2026 IEEE 34th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). IEEE. pp. 194–203. doi:10.1109/FCCM68464.2026.00037. hdl:11311/1328665. ISBN 979-8-3315-5815-4.
  20. ↑ Juneja, Rohan; Dangi, Pranav; Bandara, Thilini Kaushalya; Li, Zhaoying; Wijerathne, Dhananjaya; Peh, Li-Shiuan; Mitra, Tulika (2025). Building an Open CGRA Ecosystem for Agile Innovation. 2025 IEEE/ACM International Conference on Computer-Aided Design (ICCAD). Munich, Germany: IEEE. pp. 1–9. doi:10.1109/ICCAD66269.2025.11240628. ISBN 979-8-3315-1561-4.
  21. ↑ Luo, Yixuan; Tan, Cheng; Agostini, Nicolas Bohm; Li, Ang; Tumeo, Antonino; Dave, Nirav; Geng, Tong (July 2023). "ML-CGRA: An Integrated Compilation Framework to Enable Efficient Machine Learning Acceleration on CGRAs". 2023 60th ACM/IEEE Design Automation Conference (DAC). pp. 1–6. Bibcode:2023dac..conf...98L. doi:10.1109/DAC56929.2023.10247873. ISBN 979-8-3503-2348-1.
  22. ↑ Yu, Tianyi; Ragheb, Omar; Wicklund, Stephen; Anderson (July 2024). "MLIR-to-CGRA: A Versatile MLIR-Based Compiler Framework for CGRAs". 2024 IEEE 35th International Conference on Application-specific Systems, Architectures and Processors (ASAP). pp. 184–192. Bibcode:2024asap.conf...44Y. doi:10.1109/ASAP61560.2024.00045. ISBN 979-8-3503-4963-4.
  23. ↑ Wijerathne, Dhananjaya; Li, Zhaoying; Karunaratne, Manupa; Peh, Li-Shiuan; Mitra, Tulika (2022). Morpher: An Open-Source Integrated Compilation and Simulation Framework for CGRA (PDF). Fifth Workshop on Open-Source EDA Technology (WOSET). Retrieved 2026-07-01.
  24. ↑ Dave, Shail; Shrivastava, Aviral (2018). CCF: A CGRA Compilation Framework (PDF). Design, Automation and Test in Europe Conference (DATE) 2018, University Booth (University Booth demonstration). Tempe, AZ: Compiler Microarchitecture Lab, Arizona State University. Retrieved 2026-07-01.
  25. ↑ Chin, S. Alexander; Sakamoto, Noriaki; Rui, Allan; Zhao, Jim; Kim, Jin Hee; Hara-Azumi, Yuko; Anderson, Jason (2017). CGRA-ME: A unified framework for CGRA modelling and exploration. 2017 IEEE 28th International Conference on Application-specific Systems, Architectures and Processors (ASAP). IEEE. pp. 184–189. doi:10.1109/ASAP.2017.7995277. ISBN 978-1-5090-4826-7.
  26. ↑ Ragheb, Omar; Wicklund, Stephen; Walker, Matthew; Beidas, Rami; Ragab, Adham; Yu, Tianyi; Anderson, Jason (2024). CGRA-ME 2.0: A Research Framework for Next-Generation CGRA Architectures and CAD. 2024 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW). IEEE. pp. 642–649. doi:10.1109/IPDPSW63119.2024.00124. ISBN 979-8-3503-6461-3.
  27. 1 2 Tan, Cheng; Bohm Agostini, Nicolas; Zhang, Jeff; Minutoli, Marco; Castellana, Vito Giovanni; Xie, Chenhao; Geng, Tong; Li, Ang; Barker, Kevin; Tumeo, Antonino (2021). OpenCGRA: Democratizing Coarse-Grained Reconfigurable Arrays. 2021 IEEE 32nd International Conference on Application-specific Systems, Architectures and Processors (ASAP). IEEE. pp. 149–155. doi:10.1109/ASAP52443.2021.00029. ISBN 978-1-6654-2702-9.
  28. ↑ Walter, Dominik; Halm, Marita; Seidel, Daniel; Ghosh, Indrayudh; Heidorn, Christian; Hannig, Frank; Teich, Jürgen (2026). Modeling and Mapping of Regular Nested Loops on Processor Arrays: CGRAs vs. TCPAs. 29. Workshop Methoden und Beschreibungssprachen zur Modellierung und Verifikation von Schaltungen und Systemen (MBMV 2026). Würzburg, Germany: VDE Verlag.
  29. ↑ Li, Shangkun; Ge, Jinming; Tao, Diyuan; Li, Zeyu; Liang, Jiawei; Du, Linfeng; Xu, Jiang; Zhang, Wei; Tan, Cheng (2026). "NEURA: A Unified and Retargetable Compilation Framework for Coarse-Grained Reconfigurable Architectures". Proceedings of the ACM on Programming Languages. 10 (PLDI): 953–979. doi:10.1145/3808285. ISSN 2475-1421.
  30. ↑ Duch, Loris; Basu, Soumya; Peón-Quirós, Miguel; Ansaloni, Giovanni; Pozzi, Laura; Atienza, David (2019). "i-DPs CGRA: An Interleaved-Datapaths Reconfigurable Accelerator for Embedded Bio-Signal Processing". IEEE Embedded Systems Letters. 11 (2): 50–53. Bibcode:2019IESL...11...50D. doi:10.1109/LES.2018.2849267. ISSN 1943-0663.
  31. ↑ Akbari, Omid; Kamal, Mehdi; Afzali-Kusha, Ali; Pedram, Massoud; Shafique, Muhammad (2018). PX-CGRA: Polymorphic approximate coarse-grained reconfigurable architecture. 2018 Design, Automation & Test in Europe Conference & Exhibition (DATE). IEEE. pp. 413–418. doi:10.23919/DATE.2018.8342045. ISBN 978-1-5386-6942-6.
  32. ↑ Ebeling, Carl; Cronquist, Darren C.; Franklin, Paul (1996). Hartenstein, Reiner W.; Glesner, Manfred (eds.). RaPiD – Reconfigurable pipelined datapath. Field-Programmable Logic: Smart Applications, New Paradigms and Compilers (FPL '96). Lecture Notes in Computer Science. Vol. 1142. Darmstadt, Germany: Springer. pp. 126–135. doi:10.1007/3-540-61730-2_13. ISBN 978-3-540-61730-3.
  33. ↑ Govindaraju, Venkatraman; Ho, Chen-Han; Nowatzki, Tony; Chhugani, Jatin; Satish, Nadathur; Sankaralingam, Karthikeyan; Kim, Changkyu (2012). "DySER: Unifying Functionality and Parallelism Specialization for Energy-Efficient Computing". IEEE Micro. 32 (5). IEEE: 38–51. Bibcode:2012IMicr..32e..38G. doi:10.1109/MM.2012.51.
  34. ↑ Fujii, Taro; Toi, Takao; Tanaka, Teruhito; Togawa, Katsumi; Kitaoka, Toshiro; Nishino, Kengo; Nakamura, Noritsugu; Nakahara, Hiroki; Motomura, Masato (2018). New Generation Dynamically Reconfigurable Processor Technology for Accelerating Embedded AI Applications. 2018 IEEE Symposium on VLSI Circuits. IEEE. pp. 41–42. doi:10.1109/VLSIC.2018.8502438.
  35. ↑ "Ubitium Becomes the World's First CGRA to Execute Linux Without a Host – Ubitium". 2026-04-27. Retrieved 2026-07-02.