Exocompilation for productive programming of hardware accelerators

Ikarashi, Yuka; Bernstein, Gilbert; Reinking, Alex; Genç, Hasan; Ragan-Kelley, Jonathan

doi:10.1145/3519939.3523446

Cited by 22 publications

(5 citation statements)

References 31 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Recent work by Liu et al (2022) shows that carefully choosing high-level rewriting rules on schedules allows optimizing tensor programs beyond what is currently possible in these languages. Exo allows for expressing schedules for different hardware targets through composable rewrites and user-defined hardware abstractions (Ikarashi et al, 2022). Ikarashi et al (2022) note that adding support for new hardware using a library approach (as in Exo) appears to require one order of magnitude less development time than in systems like Halide or TVM.…”

Section: Discussion and Related Workmentioning

confidence: 99%

“…Exo allows for expressing schedules for different hardware targets through composable rewrites and user-defined hardware abstractions (Ikarashi et al, 2022). Ikarashi et al (2022) note that adding support for new hardware using a library approach (as in Exo) appears to require one order of magnitude less development time than in systems like Halide or TVM. In our system, schedules are fully specified by the developer-similarly to the work of Ikarashi et al (2022).…”

Section: Discussion and Related Workmentioning

confidence: 99%

“…Ikarashi et al (2022) note that adding support for new hardware using a library approach (as in Exo) appears to require one order of magnitude less development time than in systems like Halide or TVM. In our system, schedules are fully specified by the developer-similarly to the work of Ikarashi et al (2022). Compared to the approach taken by Halide or TVM, the developer has full control over how their computations are executed, but incur a higher implementation cost when no scheduling algorithm exists for their particular flavor of target hardware architecture.…”

Section: Discussion and Related Workmentioning

confidence: 99%

See 2 more Smart Citations

P3 problem and Magnolia language: Specializing array computations for emerging architectures

Chetioui

Larnøy²,

Järvi³

et al. 2022

Front. Comput. Sci.

View full text Add to dashboard Cite

The problem of producing portable high-performance computing (HPC) software that is cheap to develop and maintain is called the P3 (performance, portability, productivity) problem. Good solutions to the P3 problem have been achieved when the performance profiles of the target machines have been similar. The variety of HPC architectures is, however, large and can be expected to grow larger. Software for HPC therefore needs to be highly adaptable, and there is a pressing need to provide developers with tools to produce software that can target machines with vastly different profiles. Multi-dimensional array manipulation constitutes a core component of numerous numerical methods, such as finite difference solvers of Partial Differential Equations (PDEs). The efficiency of these computations is tightly connected to traversing and distributing array data in a hardware-friendly way. The Mathematics of Arrays (MoA) allows for formally reasoning about array computations and enables systematic transformations of array-based programs, e.g., to use data layouts that fit to a specific architecture. This paper presents a programming methodology aimed for tackling the P3 problem in domains that are well-explored using Magnolia, a language designed to embody generic programming. The Magnolia programmer can restrict the semantic properties of abstract generic types and operations by defining so-called axioms. Axioms can be used to produce tests for concrete implementations of specifications, for formal verification, or to perform semantics-preserving program transformations. We leverage Magnolia's semantic specification facilities to extend the Magnolia compiler with a term rewriting system. We implement MoA's transformation rules in Magnolia, and demonstrate through a case study on a finite difference solver of PDEs how our rewriting system allows exploring the space of possible optimizations.

show abstract

Section: Discussion and Related Workmentioning

confidence: 99%

Section: Discussion and Related Workmentioning

confidence: 99%

Section: Discussion and Related Workmentioning

confidence: 99%

See 1 more Smart Citation

P3 problem and Magnolia language: Specializing array computations for emerging architectures

Chetioui

Larnøy²,

Järvi³

et al. 2022

Front. Comput. Sci.

View full text Add to dashboard Cite

show abstract

“…Halide has also been extended to other computing units such as DSPs [85], push memory [86] and TensorCore [87]. To support accelerators while considering computation scheduling functions, DSLs for directly generating native language code (e.g., C and C++) rather than extending the DSL are also emerging, such as Exo Language [88] 17 .…”

Section: Dsl For Image Processingmentioning

confidence: 99%

SlidingConv: Domain-Specific Description of Sliding Discrete Cosine Transform Convolution for Halide

Kanetaka,

Takagi,

Maeda

et al. 2024

IEEE Access

View full text Add to dashboard Cite

“…JVMs provide the Java Native Interface and other VMs have typically similar mechanisms. Another approach, exocompilation, [15] allows abstracting data processing algorithms from scheduling. This simplifies generating efficient machine code that targets varying hardware instructions and architectures.…”

Section: Case Study 3: Simd Optimizations (Compo)mentioning

confidence: 99%

Live Objects All The Way Down: Removing the Barriers between Applications and Virtual Machines

Pimás,

Marr,

Garbervetsky

2023

Programming

View full text Add to dashboard Cite

Object-oriented languages often use virtual machines (VMs) that provide mechanisms such as just-in-time (JIT) compilation and garbage collection (GC). These VM components are typically implemented in a separate layer, isolating them from the application. While this approach brings the software engineering benefits of clear separation and decoupling, it introduces barriers for both understanding VM behavior and evolving the VM implementation. For example, the GC and JIT compiler are typically fixed at VM build time, limiting arbitrary adaptation at run time. Furthermore, because of this separation, the implementation of the VM cannot typically be inspected and debugged in the same way as application code, enshrining a distinction in easy-to-work-with application and hard-to-work-with VM code. These characteristics pose a barrier for application developers to understand the engine on top of which their own code runs, and fosters a knowledge gap that prevents application developers to change the VM.We propose Live Metacircular Runtimes (LMRs) to overcome this problem. LMRs are language runtime systems that seamlessly integrate the VM into the application in live programming environments. Unlike classic metacircular approaches, we propose to completely remove the separation between application and VM. By systematically applying object-oriented design to VM components, we can build live runtime systems that are small and flexible enough, where VM engineers can benefit of live programming features such as short feedback loops, and application developers with fewer VM expertise can benefit of the stronger causal connections between their programs and the VM implementation.To evaluate our proposal, we implemented Bee/LMR, a live VM for a Smalltalk-derivative environment in 22,057 lines of code. We analyze case studies on tuning the garbage collector, avoiding recompilations by the just-in-time compiler, and adding support to optimize code with vector instructions to demonstrate the trade-offs of extending exploratory programming to VM development in the context of an industrial application used in production. Based on the case studies, we illustrate how our approach facilitates the daily development work of a small team of application developers.Our approach enables VM developers to gain access to live programming tools traditionally reserved for application developers, while application developers can interact with the VM and modify it using the high-level tools they use every day. Both application and VM developers can seamlessly inspect, debug, understand, and modify the different parts of the VM with shorter feedback loops and higher-level tools.

show abstract

Exocompilation for productive programming of hardware accelerators

Cited by 22 publications

References 31 publications

P3 problem and Magnolia language: Specializing array computations for emerging architectures

P3 problem and Magnolia language: Specializing array computations for emerging architectures

SlidingConv: Domain-Specific Description of Sliding Discrete Cosine Transform Convolution for Halide

Live Objects All The Way Down: Removing the Barriers between Applications and Virtual Machines

Contact Info

Product

Resources

About