Configurable REC (original) (raw)

A minimal, extensible, drag-and-drop implementation of the C programming language

Proceedings of the 2011 conference on Information technology education - SIGITE '11, 2011

Block languages are visual programming languages based on the metaphor of programming bricks. Block languages such as Scratch, StarLogo and Alice, are becoming fundamental tools to get children interested in computer programming. These environments and environments derived from them, such as BYOB, have all the features needed to be strong candidates for introductory computer science courses and are starting to be used in some introductory university courses. Nonetheless, some computer science educators at college and university level feel that block languages are too toylike to be used in regular computer science curricula. Standard programming languages, such as C or Java, are still thought of as more appropriate. In this work I will describe a third way to programming languages that can be used for introductory computer science: the visual implementations of relevant subsets of standard programming languages such as C. An initial evaluation showing excellent student acceptance is reported in this paper.

From C programs to the configure-execute model

2003

Abstract The emergence of run-time reconfigurable architectures makes feasible the configure-execute paradigm. Compilation of behavioral descriptions (in, eg, C, Java, etc.), apart from mapping the computational structures onto the available resources on the device, must split the program in temporal sections if it needs more resources than physically available.

An integrated environment for reuse reengineering C code

1998

The paper presents an integrated environment implemented in Prolog for reuse reengineering existing C systems. Different tools developed in the RE2 project are integrated in the environment through sharing a fine-grained representation for C programs, the Combined C Graph (CCG). Different views of a system can be abstracted and visualised from the data-base of Prolog facts implementing its CCG representation.

Programmability and efficiency in reconfigurable computer systems

2003

It has become commonly accepted that higher abstraction programming languages are necessary for a wider acceptance of reconfigurable computing technology by application developers. Anytime the abstraction level is increased, a tradeoff must be made between programmability and efficiency. This paper reports on the quantitative evaluation of this tradeoff using the SA-C language and VHDL. It relies on four benchmark codes ranging from the trivially simple to the complex. The results show a slowdown in execution by a factor less than two an increase in programmability by a factor as large as 10.

Varv: Reprogrammable Interactive Software as a Declarative Data Structure

CHI Conference on Human Factors in Computing Systems

Figure 1: Varv Examples: (a) A todo list web application that is inherently extensible. Here, a basic todo list is extended with the ability to complete and delete todos by adding two new concept defnitions and new modifed template defnitions. (b) A board game toolkit that defnes abstractions for board game logic. The games "Checkers" and "Othello" were implemented with the toolkit and then merged into a new "Checkers-O-Thello" game with the addition of a short concept defnition. As Varv applications are represented as data structures, higher-level tooling can be developed including a block-based editor (right), an inspector to go from an element in the view to the corresponding template or data (context menu to the left), and a data inspector for live editing application state (middle).

Parallel programming of high-performance reconfigurable computing systems with Unified Parallel C

2008

through an interconnection network and system software into a parallel architecture. For domain scientists who lack the hardware design experience, programming these machines is near impossible. Existing high-level programming tools such as C-tohardware tools only address designs on one chip. Other tools require the programmer to create separate hardware and software program modules.

Weaves: A Framework for Reconfigurable Programming

International Journal of Parallel Programming, 2005

This paper presents a language independent runtime framework-called Weaves-for object based composition of unmodified code modules that enables selective sharing of state between multiple control flows through a process. Furthermore, the framework allows dynamic instantiation of code modules and control flows through them. In effect, weaves create intra-process modules (similar to objects in OOP) from code written in any language. Applications can be built by instantiating Weaves to form Tapestries of dynamically interacting code. The framework enables objects to be arbitrarily shared-it is a true superset of both processes as well as threads, with code sharing and fast context switching time similar to threads. Weaves does not require any special support from either the language or application code-practically any code can be weaved. Weaves also include support runtime loading and linking of object modules enabling the next generation of highly dynamic applications. This paper presents the elements of the Weaves framework and its implementation on the Linux platform over source-code independent ELF object files. The current implementation has been validated over Sweep3D, a benchmark for 3D discrete ordinates neutron transport (Koch et al. Trans. Am. Nucl. Soc. 65 (198) [1992]), and a user-level port of the Linux 2.4 family kernel TCP/IP protocol stack.

Programming Tools for Reconfigurable Processors

Processor Design, 2007

The capability to tailor the processor instruction set architecture (ISA) around the computational requirements of a given application is proposed today as the most appealing way to match performance with very short time-to-market, accomplishing the reduction of non-recurring engineering (NRE) costs. From Mask-Time Configurable Processors (MTCPs) to Run-Time Reconfigurable Processors (RTRPs), the ISA customization is performed "moving" kernels of initial code from software to hardware, thus introducing a design space exploration problem involving skills in both software and hardware design. Since adaptive processors appear as the natural extension of Digital Signal Processors (DSPs), programming tools for customizable processors need to be as similar as possible to standard software development environments, in order to enable the adaptive computing to the wide audience of DSP programmers. While fast design-space explorations can be performed using high-level description languages, programmers proficient in hardware design can further improve the performance through "structural" descriptions involving, for example, the direct utilization of macro-operators or the possibility of balancing critical paths through register insertion. The widespread knowledge of the ANSI C among developers suggests its usage as main entry language for both configurable and reconfigurable architectures, thus introducing the problem of translating C codes (or C dialects) into some kind of hardware description, be it HDL in case of MTCPs or bit-stream for RTRPs. In this context, Data-Flow Graphs (DFGs) can be efficiently used to close the gap between hardware and software design, thus representing the most natural bridge between the hardware and software descriptions. Furthermore, standard ANSI C can be used by the programmer for the management of the application control flow on the processor core, embedding custom-designed instructions in

Component design of retargetable program analysis tools that reuse intermediate representations

Proceedings of the 2000 International Conference on Software Engineering. ICSE 2000 the New Millennium, 2000

Interactive program analysis tools are often tailored to one particular representation of programs, making adaptation to a new language costly. One way to ease adaptability is to introduce an intermediate abstraction-an adaptation layerbetween an existing language representation and the program analysis tool. This adaptation layer translates the tool's queries into queries on the particular representation. Our experiments with this approach on the StarTool program analysis tool resulted in low-cost retargets for C, Tcl/Tk, and Ada. Required adjustments to the approach, however, led to insights for improving a client's retargetability. First, retargeting was eased by having our tool import a tool-centric (i.e., client-centric) interface rather than a general-purpose, language-neutral representation interface. Second, our adaptation layer exports two interfaces, a representation interface supporting queries on the represented program and a language interface that the client queries to configure itself suitably for the given language. Straightforward object-oriented extensions enhance reuse and ease the development of multilanguage tools.