Hierarchical Transactions for Hardware/Software Cosynthesis

Modern heterogeneous devices provide of a variety of computationally diverse components holding tremendous performance and power capability. Hardware-software cosynthesis offers system-level synthesis and optimization opportunities to realize the potential of these evolving architectures. Efficiently coordinating high-throughput data to make use of available computational resources requires a myriad of distributed local memories, caching structures, and data motion resources. In fact, storage, caching, and data transfer components comprise the majority of silicon real estate. Conventional automated approaches, unfortunately, do not effectively represent applications in a way that captures data motion and state management which dictate dominant system costs. Consequently, existing cosynthesis methods suffer from poor utility of computational resources. Automated cosynthesis tailored towards memory-centric optimizations can address the challenge, adapting partitioning, scheduling, mapping, and binding techniques to maximize overall system utility.This research presents a novel hierarchical transaction model that formalizes state and control management through an abstract data/control encapsulation semantic. It is designed from the ground-up to enable efficient synthesis across heterogeneous system components, with an emphasis on memory capacity constraints. It intrinsically encourages a high degree of concurrency and latency tolerance, and provides verification tools to ensure correctness. A unique data/execution hierarchical encapsulation framework guarantees scalable analysis, supporting a novel concept of state and control mobility. A front-end language allows concise expression of designer intent, and is structured with synthesis in mind. Designers express families of valid executions in a minimal format through high-level dependencies, type systems, and computational relationships, allowing synthesis tools to manage lower-level details. This dissertation introduces and exercises the model, discussing language construction, demonstrating control and data-dominated applications, and presenting a synthesis path that exhibits near-linear scalability with problem size

A Multi-layer Fpga Framework Supporting Autonomous Runtime Partial Reconfiguration

Partial reconfiguration is a unique capability provided by several Field Programmable Gate Array (FPGA) vendors recently, which involves altering part of the programmed design within an SRAM-based FPGA at run-time. In this dissertation, a Multilayer Runtime Reconfiguration Architecture (MRRA) is developed, evaluated, and refined for Autonomous Runtime Partial Reconfiguration of FPGA devices. Under the proposed MRRA paradigm, FPGA configurations can be manipulated at runtime using on-chip resources. Operations are partitioned into Logic, Translation, and Reconfiguration layers along with a standardized set of Application Programming Interfaces (APIs). At each level, resource details are encapsulated and managed for efficiency and portability during operation. An MRRA mapping theory is developed to link the general logic function and area allocation information to the device related physical configuration level data by using mathematical data structure and physical constraints. In certain scenarios, configuration bit stream data can be read and modified directly for fast operations, relying on the use of similar logic functions and common interconnection resources for communication. A corresponding logic control flow is also developed to make the entire process autonomous. Several prototype MRRA systems are developed on a Xilinx Virtex II Pro platform. The Virtex II Pro on-chip PowerPC core and block RAM are employed to manage control operations while multiple physical interfaces establish and supplement autonomous reconfiguration capabilities. Area, speed and power optimization techniques are developed based on the developed Xilinx prototype. Evaluations and analysis of these prototype and techniques are performed on a number of benchmark and hashing algorithm case studies. The results indicate that based on a variety of test benches, up to 70% reduction in the resource utilization, up to 50% improvement in power consumption, and up to 10 times increase in run-time performance are achieved using the developed architecture and approaches compared with Xilinx baseline reconfiguration flow. Finally, a Genetic Algorithm (GA) for a FPGA fault tolerance case study is evaluated as a ultimate high-level application running on this architecture. It demonstrated that this is a hardware and software infrastructure that enables an FPGA to dynamically reconfigure itself efficiently under the control of a soft microprocessor core that is instantiated within the FPGA fabric. Such a system contributes to the observed benefits of intelligent control, fast reconfiguration, and low overhead

Logic Foundry: A Rapid Prototyping Tool for FPGA-based DSP Systems

No abstact submitted. (Also UMIACS-TR-2002-29

A hardware-software codesign framework for cellular computing

Until recently, the ever-increasing demand of computing power has been met on one hand by increasing the operating frequency of processors and on the other hand by designing architectures capable of exploiting parallelism at the instruction level through hardware mechanisms such as super-scalar execution. However, both these approaches seem to have reached a plateau, mainly due to issues related to design complexity and cost-effectiveness. To face the stabilization of performance of single-threaded processors, the current trend in processor design seems to favor a switch to coarser-grain parallelization, typically at the thread level. In other words, high computational power is achieved not only by a single, very fast and very complex processor, but through the parallel operation of several processors, each executing a different thread. Extrapolating this trend to take into account the vast amount of on-chip hardware resources that will be available in the next few decades (either through further shrinkage of silicon fabrication processes or by the introduction of molecular-scale devices), together with the predicted features of such devices (e.g., the impossibility of global synchronization or higher failure rates), it seems reasonable to foretell that current design techniques will not be able to cope with the requirements of next-generation electronic devices and that novel design tools and programming methods will have to be devised. A tempting source of inspiration to solve the problems implied by a massively parallel organization and inherently error-prone substrates is biology. In fact, living beings possess characteristics, such as robustness to damage and self-organization, which were shown in previous research as interesting to be implemented in hardware. For instance, it was possible to realize relatively simple systems, such as a self-repairing watch. Overall, these bio-inspired approaches seem very promising but their interest for a wider audience is problematic because their heavily hardware-oriented designs lack some of the flexibility achievable with a general purpose processor. In the context of this thesis, we will introduce a processor-grade processing element at the heart of a bio-inspired hardware system. This processor, based on a single-instruction, features some key properties that allow it to maintain the versatility required by the implementation of bio-inspired mechanisms and to realize general computation. We will also demonstrate that the flexibility of such a processor enables it to be evolved so it can be tailored to different types of applications. In the second half of this thesis, we will analyze how the implementation of a large number of these processors can be used on a hardware platform to explore various bio-inspired mechanisms. Based on an extensible platform of many FPGAs, configured as a networked structure of processors, the hardware part of this computing framework is backed by an open library of software components that provides primitives for efficient inter-processor communication and distributed computation. We will show that this dual software–hardware approach allows a very quick exploration of different ways to solve computational problems using bio-inspired techniques. In addition, we also show that the flexibility of our approach allows it to exploit replication as a solution to issues that concern standard embedded applications

Algoritmos para sintese de sistemas embutidos tolerantes a falhas empregando reconfiguração dinamica de FPGAs

Orientador: Alice Maria B. H. TokarniaDissertação (mestrado) - Universidade Estadual de Campinas, Faculdade de Engenharia Eletrica e de ComputaçãoMestrad

Goal-oriented hardware design

Thesis (S.M.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2008.Includes bibliographical references (p. 145-146).This thesis presents Fide, a hardware design system that uses Goal-oriented programming. Goal-oriented programming is a programming framework to specify open-ended decision logic. This approach relies on two fundamental concepts-Goals and Techniques. Goals encode decision points and Techniques are scripts that describe how to satisfy Goals. In Fide, Goals represent the functional requirements (e.g., addition of two 32-bit binary integers) of the target circuit. Techniques represent hardware implementation alternatives that fulfill the functions. Techniques may declare their own subgoals, allowing a hierarchical decomposition of the functions. A Planner selects among Techniques based on the Goals declared to generate an implementation of the target circuit automatically. Users' preferences can be added to generate circuits for different scenarios: for different hardware environments, under different circuit constraints, or different implementation criteria etc. A Beta processor is implemented using Fide. The quality of the implementation is comparable to those optimized manually.by Man Ping Grace Chau.S.M

Communicatiebewuste plaatsing van data in een gedistribueerd rekensysteem

Het uitgangspunt van dit doctoraatsproefschrift is de vaststelling dat communicatie cruciaal is in gedistribueerde rekensystemen. Door de evolutie naar een steeds groeiend aantal rekenkernen op één enkele chip, wordt communicatie tussen die kernen steeds belangrijker. Binnen een dergelijk gedistribueerd rekensysteem verloopt de communicatie op verschillende niveaus, elk met hun eigen karakteristieke prestatiekenmerken. Draden die op dezelfde kern worden uitgevoerd, kunnen communiceren via gedeeld geheugen in een cache of in een extern geheugen dat enkel via het netwerk bereikt kan worden. Draden die op verschillende kernen uitgevoerd worden, kunnen enkel informatie uitwisselen via een relatief trage netwerkverbinding. De verhouding tussen interne en externe communicatie heeft een fundamentele impact op de uiteindelijke prestaties wanneer een programma wordt opgesplitst over de verschillende rekenkernen in het systeem. Een geschikte verdeling van zowel de berekeningen als de data over de verschillende rekenkernen, is dan ook uitermate belangrijk om tot een efficiënt resultaat te komen. Communicatie optimaliseren begint met communicatie opmeten. Om een goed beeld te krijgen van hoeveel communicatie er nodig is, heb ik een profileerder ontwikkeld die communicatieprofielen opmeet van Java-programma's. Daarin wordt de informatie over datastromen in het programma gecombineerd met de dynamische oproepgraaf van het programma. Hierbij wordt een onderscheid gemaakt tussen twee types communicatieprofielen: een eerste dat enkel de inherente communicatie bevat tussen methodes in het programma zonder rekening te houden met de datastructuren die daarvoor gebruikt worden en een tweede profiel dat expliciet de communicatie opmeet tussen methodes en datastructuren. Beide profielen hebben hun eigen specifieke toepassingen. Het eerste communicatieprofiel kan door de ontwerper gebruikt worden als aanzet voor de partitionering van functionaliteit van programma's over meerdere rekenkernen of parallelle draden. De communicatie in een systeem is immers onafhankelijk van de specifieke implementatie en de inherente communicatie opgemeten in de geprofileerde, initiële implementatie, is dan ook een goede maat voor de communicatie in de uiteindelijke implementatie op een gedistribueerd rekensysteem. Het tweede communicatieprofiel meet de communicatie van en naar datastructuren in Java. Het levert een goed beeld op van het gebruik van Java-objecten doorheen het programma en geeft dus meer informatie over concrete optimalisaties van de datalayout. Dit profiel vormt de basis voor mijn zelflerende algoritme om de plaatsing van objecten te optimaliseren. Profileren brengt onvermijdelijk een vertraging met zich mee. Zeker voor het opmeten van het eerste type communicatieprofiel is de toename van de uitvoeringstijd enorm omdat er een grote boekhouding moet worden bijgehouden van alle lees- en schrijfoperaties en van een schaduwobject voor elk object in het geheugen. De profilering kan fors versneld worden door gebruik te maken van bemonstering, maar dat kan dan weer nadelig zijn voor de kwaliteit van het opgemeten communicatieprofiel. In dit proefschrift gebruik ik met succes een bemonsteringstechniek uit de oude doos, reservoir sampling}, om de overlast van het profileren te reduceren met een factor 9, met behoud van een aanvaardbare, en vooraf statistisch vastgelegde, nauwkeurigheid. Dit resultaat werd gevalideerd aan de hand van een hele reeks benchmarkprogramma's uit de SPECjvm benchmark suite. De communicatieprofielen vormen de basis voor een communicatiebewuste partitionering van de functionaliteit van programma's waarbij de verhouding tussen interne en externe communicatie als eerste criterium wordt gebruikt. Hierbij focus ik op een specifieke vorm van partitionering, met name het identificeren van delen van de functionaliteit van een systeem die geschikt zijn om ze af te zonderen van de kern van het systeem. Dit wordt uitgewerkt in het kader van de hardwareversnelde JVM waarbij een klassieke processor de initiële, hoofdpartitie, voor zijn rekening neemt en één of meerdere hardwareversnellers op een FPGA als co-processor de afgezonderde partities voor hun rekening nemen. Faes et al toonden immers aan dat een dergelijke aanpak voor de samenwerking tussen hardware en software interessante resultaten oplevert in de context van Java en de hardwareversnelde JVM. Ik heb twee methodes uitgewerkt om programma's functioneel te partitioneren op basis van de opgemeten communicatieprofielen: statische partitionering en dynamische partitionering. Beide types hebben hun duidelijke voor- en nadelen en hun specifieke toepassingen. Statische partitionering is bedoeld als ondersteuning voor een ontwerper die met de hand een programma partitioneert. In de oproepgraaf selecteert men een aantal methodes die geschikt zijn voor hardwareversnelling, bijvoorbeeld omdat ze veel intern parallellisme bevatten, en een aantal methodes die absoluut niet op de hardware uitgevoerd mogen worden, bijvoorbeeld omdat ze complexe controlestructuren bevatten. De statische partitionering gaat dan incrementeel op zoek naar een communicatiebewuste partitionering die een geschikte grens tussen hardware en software vastlegt. Typisch worden dan niet enkel de aangeduide methodes overgeheveld naar de co-processor, maar worden ook enkele omliggende methodes mee verplaatst. Wanneer die omliggende methodes zeer veel data uitwisselen met de hardwareversnelde methodes, is het immers beter dat die communicatie volledig op de co-processor kan gebeuren. Dynamische partitionering is een uitbreiding van het statische algoritme voor gebruik in de hardwareversnelde JVM. De JIT-compilatie in deze JVM opent immers perspectieven om hardwareversnelling te beschouwen als een bijkomende stap in het compilatieproces. Dit heeft een aantal voordelen. Zo is in een aantal toepassingen en voor een aantal methodes de verhouding tussen berekeningen en communicatie invoerafhankelijk. Een dynamische aanpak kan hier adequaat op reageren en in de ene uitvoering een concrete methode wel en in de andere uitvoering niet afleiden naar de co-processor op de FPGA. Transparant hardware/software co-ontwerp. De hardwareversnelde JVM maakt het mogelijk om op een transparante manier aan hardware/software co-ontwerp te doen op een gemengd platform met een generieke processor en hardwareversnellers op FPGA als co-processor. Om de prestaties te verbeteren beschikken zowel de hoofdprocessor als de hardwareversneller over hun eigen lokale geheugen. Beide fysieke geheugens zijn verenigd in het gedeelde-geheugenmodel van de JVM. Deze transparante hardwareversnelde JVM beheert de toegang tot alle objecten in het geheugen, ongeacht hun fysieke locatie. De hardwareversneller is meestal via een relatief traag communicatiemedium verbonden met de hoofdprocessor en het hoofdgeheugen. Daarom worden geheugentoegangen naar 'het andere geheugen' erg duur. Die moeten dus zo veel mogelijk vermeden worden. Een belangrijke taak van de JVM is het zoeken van de meest geschikte geheugenlocatie van elk object in de gedistribueerde Java heap. De objecten zitten best in het geheugen dat het dichtst staat bij de processor (of versneller) die de data het vaakst gebruikt. Gegevens die enkel binnen een draad gebruikt worden, zullen zich dan steeds in het lokale geheugen bevinden met een minimalisatie van de externe communicatie tot gevolg. Voor data die gedeeld wordt tussen uitvoeringsdraden wordt gestreefd naar een communicatiebewuste geheugenallocatie. Ik heb verschillende technieken voorgesteld om communicatiebewust geheugen toe te wijzen. Dynamisch bepaalt de JVM voor elk Java-object, de optimale geheugenlocatie. Mijn zelflerende aanpak probeert de gebruikspatronen voor elk object te schatten op basis van gemeten patronen voor objecten die eerder werden toegewezen. Op basis hiervan kan het object geplaatst worden in het meest geschikte geheugen. Mijn strategieën voor het plaatsen van data in de geheugens leiden tot een vermindering van de hoeveelheid externe geheugentoegangen tot 86% (49% gemiddeld) voor de SPECjvm en DaCapo benchmarks

Hardware-Software Cosynthesis for Run-time Incrementally Reconfigurable FPGAs

This paper presents a method for hardware-software cosynthesis with run-time incrementally reconfigurable FPGAs. To reduce the run-time overhead of reconfiguring FPGAs, we present a concept called early partial reconfiguration (EPR) which minimizes the overhead by performing reconfiguration for an operation (or a task in our terms) mapped to an FPGA as early as possible so that the operation is ready to start when its execution is requested. For further reduction of the overhead, we integrate the incremental reconfiguration (IR) of FPGAs with the EPR concept. We present an ILP formulation and an efficient heuristic algorithm based on the EPR and IR concepts. Experiments on embedded system examples and synthetic examples show the efficiency of the proposed metho