HeDLa : a strongly typed, component-based embedded hardware description language

Over the past years, various techniques for the embedding of hardware description languages within general purpose languages have been developed and explored. In particular, numerous HDLs embedded in strongly typed functional languages have been developed and used for different applications. A common trait of most of these languages is that they treat hardware components as functions or relations between the inputs and outputs of the circuit. The alternative view, of viewing the circuits as components which can be instantiated, composed and transformed has been a relatively less well explored area in this context. In this paper we present HeDLa, a component-based hardware description language embedded in Haskell, and show how features such as strong-typing and higher-order functions enable us to design and compose circuits in a safer and more abstract fashion. Furthermore, the component-based approach allows access to circuit structure directly, enabling us to reason about non-functional aspects of the component, such as placement, area and power consumption more easily. Finally, we discuss some initial experiments in multi-level simulation of circuits which enable testing and more effective simulation of large circuits.peer-reviewe

Synchronous Digital Circuits as Functional Programs

Functional programming techniques have been used to describe synchronous digital circuits since the early 1980s and have proven successful at describing certain types of designs. Here we survey the systems and formal underpinnings that constitute this tradition. We situate these techniques with respect to other formal methods for hardware design and discuss the work yet to be done

Arrows for knowledge-based circuits

Knowledge-based programs (KBPs) are a formalism for directly relating agents' knowledge and behaviour in a way that has proven useful for specifying distributed systems. Here we present a scheme for compiling KBPs to executable automata in finite environments with a proof of correctness in Isabelle/HOL. We use Arrows, a functional programming abstraction, to structure a prototype domain-specific synchronous language embedded in Haskell. By adapting our compilation scheme to use symbolic representations we can apply it to several examples of reasonable size