Unexpected Bitstream Size Increase after Fault Injection in Partial Bitstream using ConfigArray in RapidWright

[Mehmoonagul]

Hi! I am using RapidWright to perform Single Event Upset (SEU) fault injections on a partial bitstream. My workflow involves reading the bitstream using the configuration array model (configureArray()), injecting faults by flipping a specific bit, and then writing the modified bitstream back using writeBitstream(out_file).
However, I have noticed an unexpected behavior: after writing the modified partial bitstream, its file size increases noticeably. Given that the modification involves only a single bit flip, I would not anticipate such an increase in the bitstream size.
This issue does not occur when working with a full bitstream—the file size remains unchanged after similar modifications.

Code Snippet Used:

bs = Bitstream.readBitstream(input_bitstream)
configArray = bs.configureArray()

// Inject faults into configArray here...

bs.updatePacketsFromConfigArray()
bs.writeBitstream(out_file)

Expected Behavior: The bitstream file size should remain essentially unchanged, given the minimal nature of the modification (a single bit flip).

Query: Could anyone clarify why the partial bitstream file size increases significantly after minor bit-level modifications using RapidWright's configuration model, while the full bitstream does not exhibit this issue.

Thanks in advance for your assistance!

[clavin-xlnx]

@Mehmoonagul thanks for the question! I believe the issue that you are experiencing is being caused by the method Bitstream.updatePacketsFromConfigArray(). This method assumes that you want to write a full bitstream and will populate the bitstream with a full set of packet writes to configure the entire configuration array. It sounds like you would just like to generate packets to write to just the frames of the device that you have modified. This is certainly possible with the RapidWright tools, but, unfortunately, we don't have an API that will automatically generate a partial bitstream from a set of modified frames.

How many frames are you hoping to change per bitstream? If it is only one, you could presumably create a special single frame write bitstream and then simply update the frame data in the package and the FAR address it writes to as you sweep the configuration array.

[Mehmoonagul]

Thank you for the detailed response!

Could you kindly guide me on how to create a single-frame write bitstream using RapidWright? Additionally, I would be grateful for any guidance on how to update the frame data accordingly

[clavin-xlnx]

Could you kindly guide me on how to create a single-frame write bitstream using RapidWright? Additionally, I would be grateful for any guidance on how to update the frame data accordingly

We don't have APIs to do this automatically. Eventually, we may add that capability but it may take some time. To generate such a bitstream, you would probably want to understand the entire set of packets (see https://docs.amd.com/r/en-US/ug570-ultrascale-configuration/Bitstream-Composition). One way would be to get Vivado to generate a similar enough bitstream (one that only wrote a few frames) that you could then use RapidWright to analyze the packet sequence and then re-use that packet sequence for the bitstream you wanted to write, but change the FAR address and frame data and such. For example, suppose you had a small cell in a design, you could use write_bitstream -cell to generate a small partial bitstream. This would likely use the Type 1 frame write sequence (or a series of them) rather than the regular Type 2 sequence (see https://docs.amd.com/r/en-US/ug570-ultrascale-configuration/Packet-Types).

You could dump the packet sequence from a bitstream to inspect it with some code like this:

Bitstream b = Bitstream.readBitstream("your.bit");
for (Packet p : b.getPackets()){ 
    System.out.println(p);
}

From there, you should be able to modify the packet list to fit your needs, update the packet data (with the appropriate frame data) and FAR address fields using the RapidWright APIs.

To get the frame data, the easiest way is to configure the ConfigArray, insert the bit flip you want and then read out the data from the frame of interest and put it into the appropriate packet payload:

ConfigArray ca = b.configureArray();
FAR far = new FAR(ca);
far.setFAR(/*the FAR Address of the frame of interest here */);
Frame f = ca.getFrame(far);
f.setBit(/*index*/, /*value*/);
f.updateECCBits();
Packet frameWritingPacket = b.getPackets(/*you have to look for the right packet*/);
frameWritingPacket.setData(f.getWords());

At the very end, you probably want to run Bitstream.updateCRCPackets() to make the CRCs consistent with the new packet and data changes.