Software Support for the Integration of Reconfigurable Computing with Networks of Workstations Miriam Leeser and Elias Manolakos Dept of Electrical and Computer Engineering Northeastern University, Boston MA 02115 Reid Porter Space and Remote Sensing Sciences Group, Los Alamos National Laboratory, Los Alamos, NM 87545 Abstract: Networks of Workstations (NOWs) and reconfigurable computing platforms are two different approaches for speeding up applications that exhibit parallelism. Our research aims to integrate these two distinct platforms by providing a generic development environment for reconfigurable hardware within networks of workstations. We have developed JavaPorts [1], a framework for managing the communications between tasks (concurrent threads) in a task graph. These tasks can all execute on the same host or be partitioned between several hosts. The assignment of tasks to hosts is done by the user. We extend this model to handle tasks to be run on reconfigurable hardware. These tasks may make use of reconfigurable components designed in JHDL[2] and templates provided as part of the JavaPorts framework to program a reconfigurable board. Reconfigurable hardware has been shown to exhibit speedup over a PC for compute-intensive applications such as image processing. Existing tools to support the programming of reconfigurable systems assume one PC with a reconfigurable computing platform. The assumption is that the user of reconfigurable hardware is sitting in front of the PC that contains that reconfigurable hardware. High performance reconfigurable computing platforms often cost many times that of the host PC. For these reasons, a site using reconfigurable computing typically has many PCs connected in a network, but only one or two reconfigurable computing platforms. An example of an application that would benefit from the integration of the management of reconfigurable hardware with a network of workstations is the Genetic Image Exploitation (Genie) system [3] developed at Los Alamos National Laboratory. Genie uses a genetic algorithm to evolve an image processing pipeline for identifying a particular feature in an image. To accomplish this, many different image processing pipelines must be evaluated for fitness. In this application the image stays local to the hardware or workstation platform. Information about the image operations to perform must be communicated to the platform, and the fitness evaluation is communicated back to the host/server. This is a very compute-intensive task that exhibits both coarse-grain parallelism (many independent image processing algorithms) as well as fine-grain parallelism (each image processing pipeline). Such a task is ideally suited to acceleration through a combination of NOWs and reconfigurable hardware. Our approach is to use JavaPorts to support the communication in this heterogeneous environment. JavaPorts [1] is a framework for component-based, parallel and distributed computing. JavaPorts provides a user friendly environment for the rapid prototyping of parallel and distributed applications on NOWs, and helps to generate high quality code where task coordination and low level details of communication are hidden from the application designer. Our approach differs from others in that it enables the developer to conceptualize and describe from the beginning the application as a collection of concurrent communicating tasks with clearly marked boundaries. This is similar to the hierarchical design methodologies used for specifying complex hardware systems with hardware description languages, such as VHDL. The JavaPorts environment provides tools for capturing how the task partitions of an application should be distributed to the processors in a network. In other words, the control over what-goes-where is given to the application designer. Once the task configuration has been decided, the JavaPorts system automatically generates reusable software components which may exchange messages in a simple, unified manner irrespective of whether they are allocated to the same or different processors. A configuration of operators can be captured as a JavaPorts task graph. In such a graph, Tasks are allocated to compute Nodes and may communicate via Ports. A Port is a software abstraction that appears as a mailbox to a task which may write to it (or read from it) in order to send (or receive) a message to another task. Its realization, which is not a responsibility of the application developer, guarantees the safe and reliable point-to-point communication between two interconnected tasks. Writes to (as well as reads from) a port are anonymous, i.e. the name of the task that should receive (has sent) the message should not be known to the sending (receiving) task. After specifying the task graph, the system can automatically create Java program templates, one for each task. In these templates the part of the code required to create and register the ports is automatically included. If at some point the user decides to modify the allocation of tasks to nodes, or to add new ports to a task, the JavaPorts tool can be used to parse again the modified graph and update all affected templates, without touching any user-added part of the code. In this fashion, software components for distributed applications may be built incrementally and reused in a very simple and natural manner. We are also working on techniques for mapping algorithms onto Field Programmable Gate Arrays (FPGAs). The goal of one of these projects is to generate efficient implementations of image processing algorithms onto an Annapolis Wildstar board. We are using JHDL to implement a library of image processing components. This image processing library currently consists of convolutions with many different masks and a median filter. We are extending it with a richer set of operators. Mapping a task to a workstation with reconfigurable hardware requires more than generating JHDL for the imaging components. In addition, an application must be partitioned between software running on the workstation and the hardware implementations for the FPGAs, and communication between the two must be managed. We will use JavaPorts as the front end for managing the partitioning of tasks and the communications. The designer starts with a task graph, and manually partitions the design between hardware and software. A special port for communication with the configurable hardware board will be designed. Similarly, there will be a precompiled configurable hardware implementation for each task in the task graph that corresponds to the image processing component to be mapped to hardware. When the distributed application is launched, the appropriate hardware component of the allocated task will be instantiated along with the special port to allow data exchanges between the software and hardware entities. The goal is to facilitate this integration while hiding the low level details from the application developer. We will report on this more fully at the meeting. References 1. D.G. Galatopoullos and E.S. Manolakos, "Developing parallel applications using the JavaPorts environment," International Parallel Processing Symposium, Workshop on Java for Parallel and Distributed Computing, Lecture Notes on Computer Science, Vol. 1586, pp. 813-828, Springer 1999. 2. Peter Bellows and Brad Hutchings, "JHDL: an HDL for Reconfigurable Systems," in Symposium on Field-Programmable Custom Computing Machines, April 1998. 3. James Theiler, et al. "Evolving Retrieval Algorithms with a Genetic Programming Scheme," in Proceedings of the SPIE, Volume 3753, 1999.