Abstract
A method is described for synthesizing asynchronouscircuits based on the Handshake Circuit paradigm but employinga data-driven, rather than a control-driven, style. This approachattempts to combine the performance advantages of data-drivenasynchronous design styles with the handshake circuit style of constructionused in existing syntax-directed synthesis. The methodis demonstrated on a significant design—a 32-bit microprocessor.This example shows that the data-driven circuit style providesbetter performance than control-driven synthesized circuits.This paper extends previous reported work by illustrating howconditional execution, oft-cited as a problem for data-drivendescriptions, is handled within the system, and by a more detailedanalysis of the design example.
Index Terms—Asynchronous design, Balsa, circuit synthesis,data-driven, digital design, handshake circuits, syntax-directed.
I. INTRODUCTION
BEFORE asynchronous synthesis techniques will be seriouslyconsidered over their synchronous counterparts,they must demonstrate that they can achieve competitive performance.The research reported here aims to improve the performanceof large synthesized asynchronous circuits. The focusof the approach is on a handshake circuit representation of thecircuit; that is to say, an abstract representation of the structureof the circuit which is independent of technologies, protocols,data encodings, or any other details of the actual circuit implementation.The handshake circuit paradigm allows the construction oflarge scale circuits by the composition of small handshake componentsthat are straightforward to implement in isolation. Hardwaredescriptions are written in a high-level language and compiledin a syntax-directed fashion into the handshake circuitrepresentation. This means the structure of the resulting circuitis directly related to the source code, allowing optimizationsand tradeoffs to be made at the source code level. Furthermore,writing circuit descriptions in languages such as Balsa [1], [2],[8], and Haste1 is relatively straightforward, even for novices.However, control overhead in the conventional control-drivenstyle of handshake circuit synthesis is a major obstacle to performance. Previouswork [32], [33] gives details of howthe control overheadarises in a conventional control-driven synthesis style, anoverview of previous attempts to mitigate its effects [4]–[6],[10], [13], [22] and an in-depth justification for a data-drivenapproach. For definitive background material on handshake circuitcompilation, see [3].Essentially there are the following three principal effects contributingto the control overhead.
• All inputs are synchronized with each other before any operationswithin a block can proceed because only controlmay activate processing operations and therefore it is necessaryfor the control to know that the inputs it will use areavailable
.• Reads and writes are sequenced to ensure that variables arenot written and read concurrently.
• Data processing operations only begin after the control initiatesthem due to the pull style of operation.
If the dataprocessing were to operate in parallel with the control thenthe overhead of the control should be reduced.Data-driven asynchronous design styles are thus much lessprone to the problem of control overhead, however, attempts toautomate transformations to existing Balsa handshake circuitsto produce more efficient structures along the lines of existingdataflow style compilation strategies [34], [35], [37] were notsuccessful because it was not clear what the result of suchoptimization should look like and it was very difficult to guaranteethe resulting circuit would behave in the same fashionas the original. Techniques such as data-driven decomposition(DDD) [37] rely on pipelining sequential programs and producemodified circuit behavior. A Balsa designer may depend onthe design behaving in the manner it was written which couldeasily not be the case after optimization; indeed if a DDD-typestrategy were to have been applied to the SPA processor [21]the memory interface would have broken.The approach presented here attempts to combine the benefitsof a data-driven style with the convenience and flexibility of thehandshake circuit paradigm which allows the robust synthesis oflarge circuits. To this end, the handshake circuit structures of thecontrol-driven Balsa synthesis method have been examined anddata-driven alternatives are proposed. To generate these structures,a data-driven description style is proposed and a compilerhas been developed to compile these description into a handshakecircuit representation. This compiler is integrated into theBalsa design flow enabling the use of existing Balsa tools formoving from the handshake circuit representation to a gate-levelcircuit.The organization of this paper is as follows. Section II reviewsother related work. Section III examines how “classic”Balsa handshake circuit templates can be more efficiently replacedby data-driven variants.


Download full report
ftp.ftp.cs.man.ac.uk/pub/apt/papers/ST_TVLSI09.pdf