Reconfigurable Computing

Slides:



Advertisements
Similar presentations
ECE 551 Digital System Design & Synthesis Lecture 08 The Synthesis Process Constraints and Design Rules High-Level Synthesis Options.
Advertisements

EELE 367 – Logic Design Module 2 – Modern Digital Design Flow Agenda 1.History of Digital Design Approach 2.HDLs 3.Design Abstraction 4.Modern Design Steps.
Integrated Circuits Laboratory Faculty of Engineering Digital Design Flow Using Mentor Graphics Tools Presented by: Sameh Assem Ibrahim 16-October-2003.
Graduate Computer Architecture I Lecture 15: Intro to Reconfigurable Devices.
In-System Integration. 2 Types of Integration ● Reconfigurable devices (RD) are usually used in three different ways: 1.Rapid prototyping 2.Non-frequently.
Design Flow – Computation Flow. 2 Computation Flow For both run-time and compile-time For some applications, must iterate.
Configurable System-on-Chip: Xilinx EDK
Foundation and XACTstepTM Software
CS 151 Digital Systems Design Lecture 38 Programmable Logic.
Digital System Design EEE344 Lecture 1 INTRODUCTION TO THE COURSE
© 2011 Xilinx, Inc. All Rights Reserved This material exempt per Department of Commerce license exception TSU Xilinx Tool Flow.
EKT303/4 PRINCIPLES OF PRINCIPLES OF COMPUTER ARCHITECTURE (PoCA)
ISE. Tatjana Petrovic 249/982/22 ISE software tools ISE is Xilinx software design tools that concentrate on delivering you the most productivity available.
Introduction to FPGA AVI SINGH. Prerequisites Digital Circuit Design - Logic Gates, FlipFlops, Counters, Mux-Demux Familiarity with a procedural programming.
ASIC/FPGA design flow. FPGA Design Flow Detailed (RTL) Design Detailed (RTL) Design Ideas (Specifications) Design Ideas (Specifications) Device Programming.
System Arch 2008 (Fire Tom Wada) /10/9 Field Programmable Gate Array.
Xilinx Development Software Design Flow on Foundation M1.5
Automated Design of Custom Architecture Tulika Mitra
J. Christiansen, CERN - EP/MIC
VHDL Project Specification Naser Mohammadzadeh. Schedule  due date: Tir 18 th 2.
IEEE ICECS 2010 SysPy: Using Python for processor-centric SoC design Evangelos Logaras Elias S. Manolakos {evlog, Department of Informatics.
Chonnam national university VLSI Lab 8.4 Block Integration for Hard Macros The process of integrating the subblocks into the macro.
Introduction to FPGA Created & Presented By Ali Masoudi For Advanced Digital Communication Lab (ADC-Lab) At Isfahan University Of technology (IUT) Department.
Anurag Dwivedi. Basic Block - Gates Gates -> Flip Flops.
Introductory project. Development systems Design Entry –Foundation ISE –Third party tools Mentor Graphics: FPGA Advantage Celoxica: DK Design Suite Design.
1 - CPRE 583 (Reconfigurable Computing): VHDL to FPGA: A Tool Flow Overview Iowa State University (Ames) CPRE 583 Reconfigurable Computing Lecture 5: 9/7/2011.
EKT303/4 PRINCIPLES OF PRINCIPLES OF COMPUTER ARCHITECTURE (PoCA)
Introduction to VHDL Simulation … Synthesis …. The digital design process… Initial specification Block diagram Final product Circuit equations Logic design.
Introduction to FPGA Tools
ECE-C662 Lecture 2 Prawat Nagvajara
FPGA CAD 10-MAR-2003.
Teaching Digital Logic courses with Altera Technology
ECE 448 Lecture 6 Finite State Machines State Diagrams vs. Algorithmic State Machine (ASM) Charts.
ASIC/FPGA design flow. Design Flow Detailed Design Detailed Design Ideas Design Ideas Device Programming Device Programming Timing Simulation Timing Simulation.
Introduction to Field Programmable Gate Arrays (FPGAs) EDL Spring 2016 Johns Hopkins University Electrical and Computer Engineering March 2, 2016.
George Mason University Finite State Machines Refresher ECE 545 Lecture 11.
SUBJECT : DIGITAL ELECTRONICS CLASS : SEM 3(B) TOPIC : INTRODUCTION OF VHDL.
EMT 351/4 DIGITAL IC DESIGN Week # 1 EDA & HDL.
Introduction to the FPGA and Labs
EET 1131 Unit 4 Programmable Logic Devices
Programmable Logic Devices
Sequential Logic Design
EGR 2131 Unit 4 Combinational Circuits: Analysis & Design
Programmable Hardware: Hardware or Software?
ASIC Design Methodology
EEE2135 Digital Logic Design Chapter 1. Introduction
Dept. of Electrical and Computer Engineering
EMT 351/4 DIGITAL IC DESIGN Week # Synthesis of Sequential Logic 10.
Topics Modeling with hardware description languages (HDLs).
Introduction Introduction to VHDL Entities Signals Data & Scalar Types
Electronics for Physicists
ECE 448 Lecture 6 Finite State Machines State Diagrams vs. Algorithmic State Machine (ASM) Charts.
Topics Modeling with hardware description languages (HDLs).
Programmable Logic Devices: CPLDs and FPGAs with VHDL Design
Introduction to cosynthesis Rabi Mahapatra CSCE617
Field Programmable Gate Array
Field Programmable Gate Array
Field Programmable Gate Array
Week 5, Verilog & Full Adder
IAY 0800 Digitaalsüsteemide disain
Embedded systems, Lab 1: notes
Lesson 4 Synchronous Design Architectures: Data Path and High-level Synthesis (part two) Sept EE37E Adv. Digital Electronics.
ECE-C662 Introduction to Behavioral Synthesis Knapp Text Ch
HIGH LEVEL SYNTHESIS.
Electronics for Physicists
THE ECE 554 XILINX DESIGN PROCESS
ECE 448 Lecture 6 Finite State Machines State Diagrams, State Tables, Algorithmic State Machine (ASM) Charts, and VHDL code ECE 448 – FPGA and ASIC Design.
Digital Designs – What does it take
ECE 448 Lecture 6 Finite State Machines State Diagrams vs. Algorithmic State Machine (ASM) Charts.
THE ECE 554 XILINX DESIGN PROCESS
Presentation transcript:

Reconfigurable Computing Dr. Christophe Bobda CSCE Department University of Arkansas

Chapter 3 Design and Integration

Agenda In System Integration Design Flow

In System Integration

1. Rapid Prototyping Reconfigurable devices (RD) are usually used in three different ways: Rapid Prototyping: The RD is used as emulator for a circuit to be produced later as ASIC. The emulation process allows for testing the correctness of the circuit, sometimes under real operating conditions before production. The APTIX-System Explorer and the ITALTEL Flexbench systems are two examples of emulation platforms. APTIX System Explorer ITALTEL FLEXBENCH

1. Non Frequent reconfiguration Non-frequently reconfigurable systems: The RD is used as application specific device similar to ASIC. However the possibility of upgrading the system by means of reconfiguration is given. Such systems are used as prototyping platform, but can be used as running environment as well. Examples are: The RABBIT System, the celoxica RC100, RC200, RC300, the Nallatech BenADIC. The Nallatech BenADIC The Celoxica RC200

1. Frequent reconfiguration Frequently reconfigurable systems: Usually coupled with a processor, the RD is used as an accelerator for time- critical parts of applications. The processor accesses the RD using function calls. The reconfigurable part is usually a PCI- board attached to the PCI-bus. The communication is useful for configuration and data exchange. Examples are the Raptor 2000, the celoxica RC1000 and RC2000, the Nallatech Ballynuey. More and more stand-alone frequently reconfigurable systems are appearing. The Celoxica RC1000 The Raptor 2000 The Nallatech Ballynuey

1. Static and dynamic Reconfiguration The three ways of using a reconfigurable systems can be classified in two big categories: Static reconfigurable systems. The computation and reconfiguration is defined once at compile time. This category encounters the rapid prototyping systems, the non- frequently reconfigurable systems as well as some frequently reconfigurable systems. Dynamic or run-time reconfigurable systems. The computation and reconfiguration sequences are not known at compile-time. The system reacts dynamically at run-time to computation and therefore, to reconfiguration requests. Some non-frequently reconfigurable systems as well as most frequently reconfigurable systems belong to this category.

1. Computation flow The computation in a reconfigurable system is usually done according to the figure aside. The processor controls the complete system. It first downloads data to be computed by the RD memory to the RD memory. Then the RD is configured to perform a given function over a period of time. The start signal is given to the RD to start computation. At this time, the processor also computes its data segment in parallel to the RD.

1. Computation flow Upon completion, the RD acknowledges the processor. The processor collects the computed data from the RD memory. If many reconfigurations have to be done, then some of the steps from 1) to 5) should be reiterated according to the application's need. A barrier synchronisation mechanism is usually used between the processor and the RD. Blocking access should also be used for the memory access between the two devices.

1. Computation flow Devices like the Xilinx Virtex II/II-Pro and the Altera Excalibur feature one or more soft or hard-macro processors. the complete system can be integrated in only one device. The reconfiguration process can be: Full: The complete device have to be reconfigured. (Operation interruption occurs) Partial: Only part of the device is configured while the rest keeps running.

1. Computation flow Full reconfiguration devices function to be downloaded at run-time are developed and store in a database. No geometrical constraints restriction are required for the function. Partial reconfiguration capabilities modules represented as rectangular boxes, are pre-computed and stored in a data base. With relocation, the modules are assigned to a position on the device at run-time In the two cases, modules to be downloaded at run-time are digital circuit modules development is done according to digital circuit design rules task 2 task 1 task N Services Task Request Module Database Scheduler M1 M4 M2 M3 Placer O.S. T2 T N T1 Reconfigurable Device

Design Flow

2. Hardware/software partitioning The implementation of a reconfigurable system is a Hardware/software co- design process which determines: The software part, that is the code- segment to be executed on the processor. The development is done in a software language with common tools. We will not pay much attention to this part. The hardware part, that is the part to be executed on the RD. This is the target of this section. The interface between software and hardware. This part is not in the scope of this course. Interface Software C, C++, Java etc ... Hardware VHDL, Verilog HandelC, etc..

2. Coarse-grained RC The implementation of a coarse-grained RD is done with vendor specific language and tools. Usually a C-like language with the corresponding behavioral or structural compilers. For the coarse-grained architectures presented in the previous chapter, the languages and tools are summarised in the table below.

2. FPGA Design Flow The implementation flow of an FPGA designs is shown on the figure aside. It is a modifiedASIC design implementation divided in 5 steps. The steps (design entry, functional simulation, place and route) are the same for almost all digital circuits. Therefore, they will be presented only briefly. FPGA-synthesis differs from other synthesis process in the technology mapping step We will therefore consider some details of FPGA- synthesis, in particular the LUT-technology mapping which is proper to the FPGAs.

2. FPGA Design Flow - Design entry The design entry can be done with A schematic editor: Selection components from a (target device) and graphically connecting them together to build complex modules. Finite State machine (FSM) can also be entered by drawing the states and transitions either as graph or as table. A Hardware Description Language (HDL) structural as well as behavioral description of complex circuits. Behavioral description: useful for designs containing loops, Bit-vectors, ADT, FSMs. Structural description: emphasizes the hierarchy in a given design.

2. FPGA Design Flow – Functional Simulation After the design entry, the functional simulation is used to logically test the functionality of the design. A testbench provides the design under test with inputs for which the reaction of the design is known. The outputs of the circuit are observed on a waveform and compared to the expected values. For simulation purpose, many operations can be used (mod, div, etc...) in the design description. However only part of the code which is used for simulation can be synthesized later. The most used HDLs are: VHDL (behavioral, structural) Verilog (behavioral, structural) Some C/C++-like languages (SystemC, HandelC, etc...)

2. FPGA Design Flow – Synthesis The design is compiled and optimized. All non- synthesizable data types and operations must be replace by equivalent synthesizable code. The design is first translate into a set of Boolean equations which are then minimized. Technology mapping is used to assigned the functional modules to library elements. The technology mapping on FPGAs is called LUT- technology mapping. The result of the technology mapping is a netlist which provides a list of components used in the circuit as well as their interconnections. There exist many formats to describe a netlist. The most popular is the EDIF (Electronic Design Interchange Format). Vendor specific netlist also exists. Example: XNF (Xilinx Netlist Format)

2. FPGA Design Flow – Place and route The Netlist provides only informations about the components and their interconnections in a given design. The place and route must be used to: Assign locations to the components. Provide communication paths to the interconnections. The place and route steps are optimization problems for which some cost must be minimized. The most important factors are: The clock frequency. The signal latency. The routing congestion. Etc...

2. FPGA Design Flow – Configuration bitstream The Last step in the design process is the generation of the configuration stream also known as bitstream. A Bitstream describes: The value of each LUT, that is the set of bits used to configure the function of a LUT. The interconnections configuration describes: The inputs and outputs of the LUTs The value of the multiplexers how the switches should be set in the interconnection matrix All informations regarding the functionality of LUTs, multiplexers and switches are available after the place and route step

2. FPGA Design Flow – Example Implements a Modulo 10-counter on a symetrical array FPGA with a 2x2 Logic Block (LB) . The structure of the LBs is given in the picture aside. It consists of: 2 2-inputs LUT. 2 edge triggered T-Flipflop. Your result should minimize The area The latency

2. FPGA Design Flow – Example Truth table of the modulo 10 counter The z describe the states while the T describe the inputs of the T-FFs Karnaugh-minimization of the functions T1, T2, T3, and T4

2. FPGA Design Flow – Example

2. FPGA Design Flow – Example