16 research outputs found
Efficient hardware debugging using parameterized FPGA reconfiguration
Functional errors and bugs inadvertently introduced at the RTL stage of the design process are responsible for the largest fraction of silicon IC re-spins. Thus, comprehensive func- tional verification is the key to reduce development costs and to deliver a product in time. The increasing demands for verification led to an increase in FPGA-based tools that perform emulation. These tools can run at much higher operating frequencies and achieve higher coverage than simulation. However, an important pitfall of the FPGA tools is that they suffer from limited internal signal observability, as only a small and preselected set of signals is guided towards (embedded) trace buffers and observed. This paper proposes a dynamically reconfigurable network of multiplexers that significantly enhance the visibility of internal signals. It allows the designer to dynamically change the small set of internal signals to be observed, virtually enlarging the set of observed signals significantly. These multiplexers occupy minimal space, as they are implemented by the FPGA’s routing infrastructure
Test set generation almost for free using a Run-Time FPGA reconfiguration technique
The most important step in the final testing of fabricated ASICs or the functional testing of ASIC and FPGA designs is the generation of a complete test set that is able to find the possible errors in the design. Automatic Test Pattern Generation (ATPG) is often done by fault simulation which is very time-consuming. Speed-ups in this process can be achieved by emulating the design on an FPGA and using the actual speed of the hardware implementation to run proposed tests. However, faults then have to be actually built in into the design, which induces area overhead as (part of) the design has to be duplicated to introduce both a faulty and a correct design. The area overhead can be mitigated by run-time reconfiguring the design, at the expense of large reconfiguration time overheads. In this paper, we leverage the parameterised reconfiguration of FPGAs to create an efficient Automatic Test Pattern Generator with very low overhead in both area and time. Experimental results demonstrate the practicality of the new technique as, compared to conventional tools, we obtain speedups of up to 3 orders of magnitude, 8X area reduction, and no increase in critical path delay
In-circuit debugging with dynamic reconfiguration of FPGA interconnects
In this work, a novel method for in-circuit debugging on FPGAs is introduced that allows the insertion of low-overhead debugging infrastructure by exploiting the technique of parameterized configurations. This allows the parameterization of the LUTs and the routing infrastructure to create a virtual network of debugging multiplexers. It aims to facilitate debugging, to increase the internal signal observability, and to reduce the debugging (area and reconfiguration) overhead. Signal ranking techniques are also introduced that classify signals that can be traced during debug. Finally, the results of the method are presented and compared with a commercial tool. The area and time results and the tradeoffs between internal signal observability and area and reconfiguration overhead are also explored
In-circuit fault tolerance for FPGAs using dynamic reconfiguration and virtual overlays
Reassuring fault tolerance in computing systems is an important problem in high-reliability applications. With the interest in commercial SRAM-based FPGAs in radiation environments, it is beneficial to provide runtime reconfigurable recovery from a failure. In this paper a virtual coarse-grained reconfigurable architecture is proposed, with an embedded on-demand fault-mitigation technique tailored for FPGA overlays. The proposed method performs spatial redundancy and run-time recovery. This approach can achieve up to 3 x faster runtime recovery with 20% less resources in FPGA devices, by providing integrated layers of fault mitigation
VHDL design tool flow for portable FPGA implementation
In Field-Programmable Gate Array (FPGA) design, the
coding style has a considerable impact on how an application
is implemented and how it performs. Many popular VeryHigh-Speed Integrated Circuits Hardware Description Language
(VHDL) logic synthesis tools like Vivado by Xilinx, Quartus II by
Altera, and IspLever by Lattice Semiconductor, have significantly
improved the optimization algorithm for FPGA synthesis. However, the designer still has to generate synthesizable VHDL code
that leads the synthesis tools and achieves the required result for a
given hardware architecture. To meet the required performance,
VHDL based hardware designers follow their own rules of thumb,
and there are many research papers which suggest best practices
for VHDL hardware designers. However, as many trade-offs have
to be made and results depend on the combination of optimized
implementations and optimized hardware architectures, final
implementation decisions may have to change over time. In this
paper, we present a VHDL design tool flow that makes portability
of the design to new design requirements easier. It helps to
generate automated portable VHDL design implementations and
customized portable VHDL design implementations. This tool
flow helps the VHDL hardware designers to generate a single
VHDL design file, with multiple design parameters. It also
helps the end-users of VHDL hardware designs in choosing the
right parameter settings for a given hardware architecture and
generating the right bit file corresponding to these parameter
settings, according to their requirements