This procedure simulates soft errors that can occur during normal operation due to single event upsets (SEUs). SEUs are rare events, and are therefore difficult to test. After you instantiate the Fault Injection IP core into your design and configure your device, you can use the Intel® Quartus® Prime Fault Injection Debugger tool to induce intentional errors in the FPGA to test the system's response to these errors.
- Allows you to evaluate system response for mitigating single event functional interrupts (SEFI).
- Allows you to perform SEFI characterization in-house, eliminating the need for entire system beam testing. Instead, you can limit the beam testing to failures in time (FIT)/Mb measurement at the device level.
- Scale FIT rates according to the SEFI characterization that is relevant to your design architecture. You can randomly distribute fault injections throughout the entire device, or constrain them to specific functional areas to speed up testing.
- Optimize your design to reduce disruption caused by a single event upsets (SEU).
The Fault Injection IP core supports Intel® Arria® 10, Intel® Cyclone® 10 GX and Stratix® V family devices. The Cyclone® V family supports Fault Injection on devices with the -SC suffix in the ordering code. Contact your local sales representative for ordering information on -SC suffix Cyclone V devices.
|Stratix V A7||3,821||5,179||0||0|
The Intel® Quartus® Prime software installs IP cores in the following locations by default:
|<drive>:\intelFPGA_pro\quartus\ip\altera||Intel® Quartus® Prime Pro Edition||Windows®|
|<drive>:\intelFPGA\quartus\ip\altera||Intel® Quartus® Prime Standard Edition||Windows|
|<home directory>:/intelFPGA_pro/quartus/ip/altera||Intel® Quartus® Prime Pro Edition||Linux®|
|<home directory>:/intelFPGA/quartus/ip/altera||Intel® Quartus® Prime Standard Edition||Linux|
- Filter IP Catalog to Show IP for active device family or Show IP for all device families. If you have no project open, select the Device Family in IP Catalog.
- Type in the Search field to locate any full or partial IP core name in IP Catalog.
- Right-click an IP core name in IP Catalog to display details about supported devices, to open the IP core's installation folder, and for links to IP documentation.
- Click Search for Partner IP to access partner IP information on the web.
The parameter editor prompts you to specify an IP variation name, optional ports, and output file generation options. The parameter editor generates a top-level Intel® Quartus® Prime IP file (.ip) for an IP variation in Intel® Quartus® Prime Pro Edition projects.
The parameter editor generates a top-level Quartus IP file (.qip) for an IP variation in Intel® Quartus® Prime Standard Edition projects. These files represent the IP variation in the project, and store parameterization information.
|Top-level IP variation file that contains the parameterization of an IP core in your project. If the IP variation is part of a Platform Designer system, the parameter editor also generates a .qsys file.|
|<your_ip>.cmp||The VHDL Component Declaration (.cmp) file is a text file that contains local generic and port definitions that you use in VHDL design files.|
|<your_ip>_generation.rpt||IP or Platform Designer generation log file. Displays a summary of the messages during IP generation.|
|<your_ip>.qgsimc (Platform Designer systems only)||
Simulation caching file that compares the .qsys and .ip files with the current parameterization of the Platform Designer system and IP core. This comparison determines if Platform Designer can skip regeneration of the HDL.
|<your_ip>.qgsynth (Platform Designer systems only)||
Synthesis caching file that compares the .qsys and .ip files with the current parameterization of the Platform Designer system and IP core. This comparison determines if Platform Designer can skip regeneration of the HDL.
Contains all information to integrate and compile the IP component.
|<your_ip>.csv||Contains information about the upgrade status of the IP component.|
A symbol representation of the IP variation for use in Block Diagram Files (.bdf).
Input file that ip-make-simscript requires to generate simulation scripts. The .spd file contains a list of files you generate for simulation, along with information about memories that you initialize.
|<your_ip>.ppf||The Pin Planner File (.ppf) stores the port and node assignments for IP components you create for use with the Pin Planner.|
|<your_ip>_bb.v||Use the Verilog blackbox (_bb.v) file as an empty module declaration for use as a blackbox.|
|<your_ip>_inst.v or _inst.vhd||HDL example instantiation template. Copy and paste the contents of this file into your HDL file to instantiate the IP variation.|
|<your_ip>.regmap||If the IP contains register information, the Intel® Quartus® Prime software generates the .regmap file. The .regmap file describes the register map information of master and slave interfaces. This file complements the .sopcinfo file by providing more detailed register information about the system. This file enables register display views and user customizable statistics in System Console.|
Allows HPS System Debug tools to view the register maps of peripherals that connect to HPS within a Platform Designer system.
During synthesis, the Intel® Quartus® Prime software stores the .svd files for slave interface visible to the System Console masters in the .sof file in the debug session. System Console reads this section, which Platform Designer queries for register map information. For system slaves, Platform Designer accesses the registers by name.
|<your_ip>.v <your_ip>.vhd||HDL files that instantiate each submodule or child IP core for synthesis or simulation.|
Contains a msim_setup.tcl script to set up and run a simulation.
Contains a script rivierapro_setup.tcl to setup and run a simulation.
Contains a shell script vcs_setup.sh to set up and run a simulation.
Contains a shell script vcsmx_setup.sh and synopsys_sim.setup file to set up and run a simulation.
Contains a shell script ncsim_setup.sh and other setup files to set up and run an simulation.
Contains an Parallel simulator shell script xcelium_setup.sh and other setup files to set up and run a simulation.
|/submodules||Contains HDL files for the IP core submodule.|
|<IP submodule>/||Platform Designer generates /synth and /sim sub-directories for each IP submodule directory that Platform Designer generates.|
Integrated circuits and programmable logic devices such as FPGAs are susceptible to SEUs. SEUs are random, nondestructive events, caused by two major sources: alpha particles and neutrons from cosmic rays. Radiation can cause either the logic register, embedded memory bit, or a configuration RAM (CRAM) bit to flip its state, thus leading to unexpected device operation.
Intel® Arria® 10, Intel® Cyclone® 10 GX, Arria® V, Cyclone® V, Stratix® V and newer devices have the following CRAM capabilities:
- Error Detection Cyclical Redundance Checking (EDCRC)
- Automatic correction of an upset CRAM (scrubbing)
- Ability to create an upset CRAM condition (fault injection)
For more information about SEU mitigation in Intel FPGA devices, refer to the SEU Mitigation chapter in the respective device handbook.
The Fault Injection IP core includes the following I/O pins.
Input from Error Message Register Unloader Intel® FPGA IP (EMR Unloader IP). This signal is asserted when a CRC error has been detected by the device's EDCRC.
Error Message Register (EMR) contents. Refer to the appropriate device handbook for the EMR fields.
This input complies with the Avalon Streaming data interface signal.
|Indicates the emr_data inputs contain valid data. This is an Avalon Streaming valid interface signal.|
Module reset input.
Indicates an error was injected into CRAM as commanded via the JTAG interface.
Indicates the device scrubbing is complete as commanded via the JTAG interface.
|Optional output. The Fault Injection IP uses this clock, for example, to clock the EMR_unloader block.|
The Fault Injection Debugger works together with the Fault Injection IP core. First, you instantiate the IP core in your design, compile, and download the resulting configuration file into your device. Then, you run the Fault Injection Debugger from within the Intel® Quartus® Prime software or from the command line to simulate soft errors.
- The Fault Injection Debugger allows you to operate fault injection experiments interactively or by batch commands, and allows you to specify the logical areas in your design for fault injections.
- The command-line interface is useful for running the debugger via a script.
The Fault Injection Debugger communicates with the Fault Injection IP core via the JTAG interface. The Fault Injection IP accepts commands from the JTAG interface and reports status back through the JTAG interface.
You use the Fault Injection IP core with the following IP cores:
- The Error Message Register Unloader IP core, which reads and stores data from the hardened error detection circuitry in Intel FPGA devices.
- (Optional) The Advanced SEU Detection Intel® FPGA IP core, which compares single-bit error locations to a sensitivity map during device operation to determine whether a soft error affects it.
The Fault Injection and the EMR Unloader IP cores are available in Platform Designer and the IP Catalog. Optionally, you can instantiate them directly into your RTL design, using Verilog HDL, SystemVerilog, or VHDL.
You must use the EMR Unloader IP core with the ASD IP core. Therefore, if you use the ASD IP and the Fault Injection IP in the same design, they must share the EMR Unloader output via an Avalon® -ST splitter component. The following figure shows a Platform Designer system in which an Avalon® -ST splitter distributes the EMR contents to the ASD and Fault Injection IP cores.
The SMH file stores the coordinates of the device CRAM bits, their assigned region (ASD Region), and criticality. During the design process you use hierarchy tagging to create the region. Then, during compilation, the Intel® Quartus® Prime Assembler generates the SMH file. The Fault Injection Debugger limits error injections to specific device regions you define in the SMH file.
- Choose Assignments > Design Partitions Window.
- Right-click anywhere in the header row and turn on ASD Region to display the ASD Region column (if it is not already displayed).
Enter a value from 0 to 16 for any partition to assign it to a specific ASD
- ASD region 0 is reserved to unused portions of the device. You can assign a partition to this region to specify it as non-critical..
- ASD region 1 is the default region. All used portions of the device are assigned to this region unless you explicitly change the ASD Region assignment.
The SMH file contains the following information:
- If you are not using hierarchy tagging (i.e., the design has no explicit ASD Region assignments in the design hierarchy), the SMH file lists every CRAM bit and indicates whether it is sensitive for the design.
- If you have performed hierarchy tagging and changed default ASD Region assignments, the SMH file lists every CRAM bit and it's assigned ASD region.
The Fault Injection Debugger can limit injections to one or more specified regions.
- Choose Assignments > Device > Device and Pin Options > Error Detection CRC.
- Turn on the Generate SEU sensitivity map file (.smh) option.
To use the Fault Injection Debugger, you connect to your device via the JTAG interface. Then, configure the device and perform fault injection.
To configure your JTAG chain:
- Click Hardware Setup. The tool displays the programming hardware connected to your computer.
- Select the programming hardware you wish to use.
- Click Close.
- Click Auto Detect, which populates the device chain with the programmable devices found in the JTAG chain.
The following hardware and software is required to use the Fault Injection Debugger:
- FEATURE line in your Intel FPGA license that enables the Fault Injection IP core. For more information, contact your local Intel FPGA sales representative.
- Download cable ( Intel® FPGA Download Cable, Intel® FPGA Download Cable II, , or II).
- Intel FPGA development kit or user designed board with a JTAG connection to the device under test.
- (Optional) FEATURE line in your Intel FPGA license that enables the Advanced SEU Detection IP core.
The Software Object File (.sof) configures the FPGA. The .smh file defines the sensitivity of the CRAM bits in the device. If you do not provide an .smh file, the Fault Injection Debugger injects faults randomly throughout the CRAM bits.
To specify a .sof:
- Select the FPGA you wish to configure in the Device chain box.
- Click Select File.
- Navigate to the .sof and click OK. The Fault Injection Debugger reads the .sof.
(Optional) Select the SMH file.
If you do not specify an SMH file, the Fault Injection Debugger injects faults randomly across the entire device. If you specify an SMH file, you can restrict injections to the used areas of your device.
- Right-click the device in the Device chain box and then click Select SMH File.
- Select your SMH file.
- Click OK.
- Turn on Program/Configure.
- Click Start.
- Right-click the FPGA in the Device chain box, and click Show Device Sensitivity Map.
- Select the ASD region(s) for fault injection.
- Single errors (SE)
- Double-adjacent errors (DAE)
- Uncorrectable multi-bit errors (EMBE)
Intel FPGA devices can self-correct single and double-adjacent errors if the scrubbing feature is enabled. Intel FPGA devices cannot correct multi-bit errors. Refer to the chapter on mitigating SEUs for more information about debugging these errors.
- In the Fault Injection Debugger, choose Tools > Options.
- Drag the red controller to the mix of errors. Alternatively, you can specify the mix numerically.
- Specify the Injection interval time.
- Click OK.
- Inject one error on command
- Inject multiple errors on command
- Inject errors until commanded to stop
- Turn on the Inject Fault option.
- Choose whether you want to run error injection for a number of iterations
or until stopped:
- If you choose to run until stopped, the Fault Injection Debugger injects errors at the interval specified in the Tools > Options dialog box.
- If you want to run error injection for a specific number of iterations, enter the number.
- Click Start.Note: The Fault Injection Debugger runs for the specified number of iterations or until stopped.
The Intel® Quartus® Prime Messages window shows messages about the errors that are injected. For additional information on the injected faults, click Read EMR. The Fault Injection Debugger reads the device's EMR and displays the contents in the Messages window.
If, for example, an injected fault results in behavior you would like to replay, you can target that location for injection. You perform targeted injection using the Fault Injection Debugger command line interface.
You can run the Fault Injection Debugger at the command line with the quartus_fid executable, which is useful if you want to perform fault injection from a script.
Specify programming hardware or cable. (Required)
Specify the active device to inject fault. (Required)
Specify the number of errors to inject. The default value is 1. (Optional)
Interval time between injections. (Optional)
The following code provides examples using the Fault Injection Debugger command-line interface.
############################################ # # Find out which USB cables are available for this instance # The result shows that one cable is available, named "USB-Blaster" # $ quartus_fid --list . . . Info: Command: quartus_fid --list 1) USB-Blaster on sj-sng-z4 [USB-0] Info: Intel® Quartus® Prime 64-Bit Fault Injection Debugger was successful. 0 errors, 0 warning ############################################ # # Find which devices are available on USB-Blaster cable # The result shows two devices: a Stratix® V A7, and a MAX V CPLD. # $ quartus_fid --cable USB-Blaster -a Info: Command: quartus_fid --cable=USB-Blaster -a Info (208809): Using programming cable "USB-Blaster on sj-sng-z4 [USB-0]" 1) USB-Blaster on sj-sng-z4 [USB-0] 029030DD 5SGXEA7H(1|2|3)/5SGXEA7K1/.. 020A40DD 5M2210Z/EPM2210 Info: Intel® Quartus® Prime 64-Bit Fault Injection Debugger was successful. 0 errors, 0 warnings ############################################ # # Program the Stratix® V device # The --index option specifies operations performed on a connected device. # "=svgx.sof" associates a .sof file with the device # "#p" means program the device # $ quartus_fid --cable USB-Blaster --index "@1=svgx.sof#p" . . . Info (209016): Configuring device index 1 Info (209017): Device 1 contains JTAG ID code 0x029030DD Info (209007): Configuration succeeded -- 1 device(s) configured Info (209011): Successfully performed operation(s) Info (208551): Program signature into device 1. Info: Intel® Quartus® Prime 64-Bit Fault Injection Debugger was successful. 0 errors, 0 warnings ############################################ # # Inject a fault into the device. # The #i operator indicates to inject faults # -n 3 indicates to inject 3 faults # $ quartus_fid --cable USB-Blaster --index "@1=svgx.sof#i" -n 3 Info: Command: quartus_fid --cable=USB-Blaster --index=@1=svgx.sof#i -n 3 Info (208809): Using programming cable "USB-Blaster on sj-sng-z4 [USB-0]" Info (208521): Injects 3 error(s) into device(s) Info: Intel® Quartus® Prime 64-Bit Fault Injection Debugger was successful. 0 errors, 0 warnings ############################################ # # Interactive Mode. # Using the #i operation with -n 0 puts the debugger into interactive mode. # Note that 3 faults were injected in the previous session; # "E" reads the faults currently in the EMR Unloader IP core. # $ quartus_fid --cable USB-Blaster --index "@1=svgx.sof#i" -n 0 Info: Command: quartus_fid --cable=USB-Blaster --index=@1=svgx.sof#i -n 0 Info (208809): Using programming cable "USB-Blaster on sj-sng-z4 [USB-0]" Enter : 'F' to inject fault 'E' to read EMR 'S' to scrub error(s) 'Q' to quit E Info (208540): Reading EMR array Info (208544): 3 frame error(s) detected in device 1. Info (208545): Error #1 : Single error in frame 0x1028 at bit 0x21EA. Info (10914): Error #2 : Uncorrectable multi-bit error in frame 0x1116. Info (208545): Error #3 : Single error in frame 0x1848 at bit 0x128C. Enter : 'F' to inject fault 'E' to read EMR 'S' to scrub error(s) 'Q' to quit Q Info: Intel® Quartus® Prime 64-Bit Fault Injection Debugger was successful. 0 errors, 0 warnings Info: Peak virtual memory: 1522 megabytes Info: Processing ended: Mon Nov 3 18:50:00 2014 Info: Elapsed time: 00:00:29 Info: Total CPU time (on all processors): 00:00:13
The Fault Injection Debugger injects faults into the FPGA randomly. However, the Targeted Fault Injection feature allows you to inject faults into targeted locations in the CRAM. This operation may be useful, for example, if you noted an SEU event and want to test the FPGA or system response to the same event after modifying a recovery strategy.
You can specify that errors are injected from the command line or in prompt mode.
c:\Users\sng> quartus_fid -c 1 - i "@1= svgx.sof#i " -n 2 -user="@1= 0x2274 0x05EF 0x2264 0x0500"Where:
c 1 indicates that the fpga is controlled by the first cable on your computer.
i "@1= svgx.sof#i " indicates that the first device in the chain is loaded with the object file svgx.sof and will be injected with faults.
n 2 indicates that two faults will be injected.
user=”@1= 0x2274 0x05EF 0x2264 0x0500” is a user-specified list of faults to be injected. In this example, device 1 has two faults: at frame 0x2274, bit 0x05EF and at frame 0x2264, bit 0x0500.
|Prompt Mode Command||Description|
|F||Inject a fault|
|E||Read the EMR|
In prompt mode, you can issue the F command alone to inject a single fault in a random location in the device. In the following examples using the F command in prompt mode, three errors are injected.
F #3 0x12 0x34 0x56 0x78 * 0x9A 0xBC +
- Error 1 – Single bit error at frame 0x12, bit 0x34
- Error 2 – Uncorrectable error at frame 0x56, bit 0x78 (an * indicates a multi-bit error)
- Error 3 – Double-adjacent error at frame 0x9A, bit 0xBC (a + indicates a double bit error)
F 0x12 0x34 0x56 0x78 *
One (default) error is injected:
Error 1 – Single bit error at frame 0x12, bit 0x34. Locations after the first frame/bit location are ignored.
F #3 0x12 0x34 0x56 0x78 * 0x9A 0xBC + 0xDE 0x00
Three errors are injected:
- Error 1 – Single bit error at frame 0x12, bit 0x34
- Error 2 – Uncorrectable error at frame 0x56, bit 0x78
- Error 3 – Double-adjacent error at frame 0x9A, bit 0xBC
- Locations after the first 3 frame/bit pairs are ignored
During system testing, save the EMR contents reported by the Fault Injection Debugger when you detect an EDCRC fault.
First, you specify the mix of error types (single bit, double adjacent, and multi-bit uncorrectable) using the --weight <single errors>.<double adjacent errors>.<multi-bit errors> option. For example, for a mix of 50% single errors, 30% double adjacent errors, and 20% multi-bit uncorrectable errors, use the option --weight=50.30.20. Then, to target an ASD region, use the -smh option to include the SMH file and indicate the ASD region to target. For example:
$ quartus_fid --cable=USB-BlasterII --index "@1=svgx.sof#pi" --weight=100.0.0 --smh="@1=svgx.smh#2" --number=30
- Programs the device and injects faults (pi string)
- Injects 100% single-bit faults (100.0.0)
- Injects only into ASD_REGION 2 (indicated by the #2)
- Injects 30 faults
|Document Version||Intel® Quartus® Prime Version||Changes|
|2016.10.31||16.1||Updated device support.|