Result visualization

When you executed some attacks on your board, you can use the results to draw a plot or visualize them with the F4PGA Database Visualizer.

Plot bitflips - logs2plot.py

This script can plot graphs based on generated logs. It can generate two different types of graphs:

  1. Distribution of bitflips across rows and columns. For example, you can generate graphs by calling:

       (venv) $ python logs2plot.py your_error_summary.json

    One graph will be generated for every attack. So if you attacked two row pairs (A, B), (C, D) with two different read counts each (X, Y), for a total of 4 attacks, you will get 4 plots:

    • read count: X and pair: (A, B)

    • read count: X and pair: (C, D)

    • read count: Y and pair: (A, B)

    • read count: Y and pair: (C, D)

    You can control the number of displayed columns with --plot-columns. For example if your module has 1024 columns and you provide --plot-columns 16, then the DRAM columns will be displayed in groups of 64.

  2. Distribution of rows affected by bitflips when targeting single rows. For example, you can generate a graph by calling:

       (venv) $ python logs2plot.py --aggressors-vs-victims your_error_summary.json

    One graph will be generated with victims on the X axis and aggressors on the Y axis. The colors of the tiles indicate how many bitflips occurred for each victim.

    You can enable additional annotation with --annotate bitflips so that the number of occurred bitflips will be explicitly labeled on top of each victim tile.

    Annotated plot

    Fig. 11 Example plot generated with annotation enabled

    You can zoom in on interesting parts by using matplotlib’s zoom tool (in the bottom left corner):

    Annotation zoom

    Fig. 12 Zooming in on the plot

    This type of plot has built-in DQ per pad statistics for each attack. After clicking a specific tile you will see a new pop-up window with a plot:

    Per pad statistics

    Fig. 13 Per pad statistics

Plot per DQ pad - logs2dq.py

This script allows you to visualize bitflips and group them per DQ pad. Pads themselves are grouped using colors to differentiate modules. With this script, you can visualize and check which module is failing the most.

By default, it displays mean bitflips across all attacks with standard deviation.

First, run rowhammer.py or hw_rowhammer.py with the --log-dir log_directory flag.

Then run:

python3 logs2dq.py log_directory/your_error_summary.json

You can also pass optional arguments:

  • --dq DQ - how many pads are connected to one module

  • --per-attack - allows you to also view DQ groupings for each attacked pair of rows

Use F4PGA Visualizer - logs2vis.py

Similarly as in logs2plot.py, you can generate visualizations using the F4PGA Database Visualizer.

To view results using the visualizer you need to:

  1. Clone and build the visualizer:

    git clone https://github.com/chipsalliance/f4pga-database-visualizer
cd f4pga-database-visualizer
npm run build

  2. Run rowhammer.py or hw_rowhammer.py with --log-dir log_directory.

  3. Generate JSON files for the visualizer:

    python3 logs2vis.py log_directory/your_error_summary.json vis_directory

  4. Copy generated JSON files from vis_directory to /path/to/f4pga-database-visualizer/dist/production/

  5. Start a simple HTTP server inside the production directory:

    python -m http.server 8080

An example output generated with the --aggresors-vs-victims flag looks like so:

Aggressors vs. victims output

Fig. 14 Agressors vs. victims flag output example

Last update: 2024-12-18