Flowpaths: Compiling stack-based IR to hardware

  title={Flowpaths: Compiling stack-based IR to hardware},
  author={D. Hanna and R. Haskell},
  journal={Microprocess. Microsystems},
Abstract The performance of software executed on a microprocessor is adversely affected by the basic fetch–execute cycle. A further performance penalty results from the load–execute–store paradigm associated with the use of local variables in most high-level languages. Implementing the software algorithm directly in hardware such as on an FPGA can alleviate these performance penalties. Such implementations are normally developed in a hardware description language such as VHDL or Verilog. More… Expand
Implementing parallel algorithms on an FPGA directly from multithreaded Java using flowpaths
  • M. DuChene, D. Hanna
  • Computer Science
  • 48th Midwest Symposium on Circuits and Systems, 2005.
  • 2005
This paper describes a method to extend the flowpath architecture to generate hardware directly from Java byte codes representing Java threads, and shows that flowpaths perform within a factor of 2 of a minimal hand-crafted direct hardware implementation and orders of magnitude better than compiling the program to a microprocessor. Expand
Generating Hardware from Java Using Self-Propagating Flowpaths
microprocessor is adversely affected by the basic fetch-execute cycle. A further performance penalty results from the load-execute-store paradigm associated with the use of local variables in mostExpand
Java Flowpaths: Efficiently Generating Circuits for Embedded Systems from Java
This paper describes creating Java flowpaths, a general method of generating hardware directly from Java bytecodes that support basic operations, class instantiation, events, and multi-threaded applications that yield several orders of magnitude improvement in terms of speed for both sequential and multithreaded programs. Expand
Executing large algorithms on low-capacity FPGAs using flowpath partitioning and runtime reconfiguration
A new method of executing a software program on an FPGA for embedded systems using a new technique to compile Java programs directly to special-purpose processors that are called ''flowpaths''. Expand
Java bytecode to hardware made easy with bluespec system verilog
This paper presents a method for translation of Java bytecode sequences into synthesizable hardware, using the Bluespec System Verilog (BSV) environment, that is intended as an accelerator for existing Java processors, or even standalone hardware. Expand
Flexible Embedded System Design Using Flowpaths
or ASIC. Introduced in this paper is an extension to the flowpaths compiler to allow easier integration of system-components using object-oriented methodologies. System-components can be described byExpand
The SystemJ approach to system-level design
The strength of SystemJ comes from its ability to offer the data processing and encapsulation elegance of Java, Esterel-like reactivity and synchrony, and the asynchronous de-coupling of CSP all within the Java framework. Expand
Speedup using Flowpaths for a Finite Difference Solution of a 3D Parabolic PDE
This work uses a high-level programming language (Java) to behaviorally describe, and then implement, a finite difference solution of a parabolic PDE as a custom hardware circuit targeted to an FPGA and shows that the circuits can perform the calculations 1 to 2 orders of magnitude faster than commodity hardware. Expand


A VHDL--Forth Core for FPGAs
The design of a Forth core using VHDL that has been implemented on a Xilinx Spartan II FPGA is described and experiments show that an identical Forth program for the Sieve of Eratosthenes executes nearly 30 times faster on the FPGa Forth core than on a 68HC12 microcontroller at the same clock speed. Expand
Applying pointer analysis to the synthesis of hardware from C
This thesis presents a solution for efficiently mapping arbitrary C code with pointers and malloc/free into hardware, and an implementation using the SUIF compiler framework is presented. Expand
From C programs to the configure-execute model
Temporal partitioning is applied to furnish a set of configurations that reduces the reconfiguration overhead and thus may lead to performance gains and it is shown that when applications include a sequence of loops, the use of several configurations may be more beneficial than the mapping of the entire application onto a single configuration. Expand
The challenges of hardware synthesis from C-like languages
  • S. Edwards
  • Computer Science
  • Design, Automation and Test in Europe
  • 2005
The paper surveys several C-like hardware synthesis languages and looks at two of the fundamental challenges, concurrency and timing control. Expand
Reconfigurable models of finite state machines and their implementation in FPGAs
This paper examines some models of finite state machines (FSMs) that can be implemented in dynamically and statically reconfigurable FPGAs and shows that such reusable circuits require very limited FPGA resources and they can be reprogrammed in much the same way as for software development. Expand
A C compiler for a processor with a reconfigurable functional unit
This paper describes a C compiler for a mixed Processor/FPGA architecture where the FPGA is a Reconfigurable Functional Unit (RFU). It presents three compilation techniques that can extractExpand
Design of Embedded Systems Using 68HC12/11 Microcontrollers
The first five chapters of the text explain how to make the programming of the 68HC12 simple and interactive, and in the process develops the entire WHYP language from scratch, step by step. Expand
An Integrated Partitioning and Synthesis System for Dynamically Reconfigurable Multi-FPGA Architectures
An overview of SPARCS (Synthesis and Partitioning for Adaptive Reconfigurable Computing Systems) and the various algorithms used in the system are presented, along with a brief description of how a JPEG-like image compression algorithm is mapped to a Multi-FPGA board using SPAR CS. Expand
Hardware-software co-design of embedded systems: the POLIS approach
Embedded systems are informally defined as a collection of programmable parts surrounded by ASICs and other standard components, that interact continuously with an environment through sensors andExpand
Practical Java: Programming Language Guide
The Practical Java Programming Language Guide is intended for the intermediate to advanced Java programmer, and examines 68 key topics on how to improve your code, providing crisp, well-written examples and solutions. Expand