all new benchmark scripts

fuzzers/FRET/benchmark/Snakefile

@@ -224,29 +224,7 @@ rule trace2gantt:
 
 rule quicktest:
     input:
-        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['feedgeneration100', 'stg'], target=['release', 'waters', 'copter'], variant=['_full', '_bytes', '_int'], num=range(0,int( 1 ))),
+        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['feedgeneration100', 'stg'], target=['copter'], variant=['_seq_full', '_par_full', '_seq_stateful_full', '_par_stateful_full', '_seq_dataflow_full'], num=range(0,int( 4 ))),
-        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['genetic100', 'frafl'], target=['release', 'waters', 'copter'], variant=['_full', '_bytes', '_int'], num=range(0,int( NUM_ITERS/2 ))),
-        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['random'], target=['release', 'waters', 'copter'], variant=['_full', '_bytes', '_int'], num=range(0,int( NUM_ITERS/2 ))),
-    
-rule critical_set:
-    input:
-        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['feedgeneration100', 'stg'], target=['release', 'waters', 'copter'], variant=['_seq_full'], num=range(0,int( 10 ))),
-        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['random'], target=['release', 'waters', 'copter'], variant=['_seq_full'], num=range(0,int( 1 ))),
-
-rule extended_set:
-    input:
-        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['feedgeneration100', 'stg'], target=['release', 'waters', 'copter'], variant=['_seq_full'], num=range(0,int( 10 ))),
-        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['feedgeneration100', 'stg'], target=['waters'], variant=['_seq_int','_seq_bytes'], num=range(0,int( 10 ))),
-        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['feedgeneration100', 'stg'], target=['copter'], variant=['_seq_bytes'], num=range(0,int( 10 ))),
-        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['random'], target=['copter', 'release', 'waters'], variant=['_seq_full'], num=range(0,int( 1 ))),
-        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['random'], target=['copter', 'waters'], variant=['_seq_full','_seq_int','_seq_bytes'], num=range(0,int( 1 ))),
-
-rule emergency_copter:
-    input:
-        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['feedgeneration100', 'stg', 'frafl'], target=['copter'], variant=['_seq_stateless_full'], num=range(0,int( 10 ))),
-        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['feedgeneration100', 'stg', 'frafl'], target=['copter'], variant=['_seq_full'], num=range(0,int( 10 ))),
-        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['random'], target=['copter'], variant=['_seq_full'], num=range(0,int( 10 ))),
-        expand("timedump/{fuzzer}/{target}{variant}#{num}.time", fuzzer=['random'], target=['copter'], variant=['_seq_stateless_full'], num=range(0,int( 10 ))),
 
 rule all_bins:
     input:

fuzzers/FRET/benchmark/build_all_demos.sh

@@ -1,61 +1,75 @@
-# Sequential inputs!
-export PARTITION_INPUT=0
-
 build () {
-    make -C ../../../../FreeRTOS/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC clean && make -C ../../../../FreeRTOS/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC $1=1 FUZZ_INT_ACTIVATION=$FUZZ_INT_ACTIVATION FUZZ_BYTES=$FUZZ_BYTES
+    make -C ../../../../FreeRTOS/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC clean && make -C ../../../../FreeRTOS/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC $1=1 IGNORE_INTERRUPTS=$IGNORE_INTERRUPTS IGNORE_BYTES=$IGNORE_BYTES IGNORE_INTERNAL_STATE=$IGNORE_INTERNAL_STATE
     cp ../../../../FreeRTOS/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/build/RTOSDemo.axf build/$(echo $1 | cut -d_ -f1 | tr '[:upper:]' '[:lower:]')$2.elf 
 }
 
-export DELETE_RNG_STATE=1
+# Sequential inputs!
-
+export PARTITION_INPUT=0
-# Only bytes
+unset SPECIAL_CFLAGS
-
-export FUZZ_INT_ACTIVATION=0 FUZZ_BYTES=1 SUFFIX="_seq_bytes"
 
+# Baseline
+## Don't keep rng states
+export IGNORE_INTERNAL_STATE=1
+### Only bytes
+export IGNORE_INTERRUPTS=1 IGNORE_BYTES=0 SUFFIX="_seq_bytes"
 build WATERS_DEMO $SUFFIX
 build RELEASE_DEMO $SUFFIX
-build INTERACT_DEMO $SUFFIX
+build COPTER_DEMO $SUFFIX
-
+### Only interrupts
-# Only interrupts
+export IGNORE_INTERRUPTS=0 IGNORE_BYTES=1 SUFFIX="_seq_int"
-
-export FUZZ_INT_ACTIVATION=1 FUZZ_BYTES=0 SUFFIX="_seq_int"
-
 build WATERS_DEMO $SUFFIX
 build RELEASE_DEMO $SUFFIX
-build INTERACT_DEMO $SUFFIX
+build COPTER_DEMO $SUFFIX
-
+### Full
-# Full
+export IGNORE_INTERRUPTS=0 IGNORE_BYTES=0 SUFFIX="_seq_full"
-
-export FUZZ_INT_ACTIVATION=1 FUZZ_BYTES=1 SUFFIX="_seq_full"
-
 build WATERS_DEMO $SUFFIX
 build RELEASE_DEMO $SUFFIX
-build INTERACT_DEMO $SUFFIX
-
-# Don't keep rng states
-export DELETE_RNG_STATE=1
-
-export FUZZ_INT_ACTIVATION=0 FUZZ_BYTES=1 SUFFIX="_seq_stateless_bytes"
-build COPTER_DEMO $SUFFIX
-export FUZZ_INT_ACTIVATION=1 FUZZ_BYTES=0 SUFFIX="_seq_stateless_int"
-build COPTER_DEMO $SUFFIX
-export FUZZ_INT_ACTIVATION=1 FUZZ_BYTES=1 SUFFIX="_seq_stateless_full"
 build COPTER_DEMO $SUFFIX
 
-# Keep rng states
+# Stateful -> presumably bad for us
-export DELETE_RNG_STATE=0
+## keep rng states
-
+export IGNORE_INTERNAL_STATE=0
-export FUZZ_INT_ACTIVATION=0 FUZZ_BYTES=1 SUFFIX="_seq_bytes"
+### Full
-build COPTER_DEMO $SUFFIX
+export IGNORE_INTERRUPTS=0 IGNORE_BYTES=0 SUFFIX="_seq_stateful_full"
-export FUZZ_INT_ACTIVATION=1 FUZZ_BYTES=0 SUFFIX="_seq_int"
+build WATERS_DEMO $SUFFIX
-build COPTER_DEMO $SUFFIX
+build RELEASE_DEMO $SUFFIX
-export FUZZ_INT_ACTIVATION=1 FUZZ_BYTES=1 SUFFIX="_seq_full"
 build COPTER_DEMO $SUFFIX
 
+# Paritioned inputs
 export PARTITION_INPUT=1
-export FUZZ_INT_ACTIVATION=0 FUZZ_BYTES=1 SUFFIX="_par_bytes"
+
+# Alternative input scheme
+## Don't keep rng states
+export IGNORE_INTERNAL_STATE=1
+### Only bytes
+export IGNORE_INTERRUPTS=1 IGNORE_BYTES=0 SUFFIX="_par_bytes"
+build WATERS_DEMO $SUFFIX
+build RELEASE_DEMO $SUFFIX
 build COPTER_DEMO $SUFFIX
-export FUZZ_INT_ACTIVATION=1 FUZZ_BYTES=0 SUFFIX="_par_int"
+### Only interrupts
+export IGNORE_INTERRUPTS=0 IGNORE_BYTES=1 SUFFIX="_par_int"
+build WATERS_DEMO $SUFFIX
+build RELEASE_DEMO $SUFFIX
 build COPTER_DEMO $SUFFIX
-export FUZZ_INT_ACTIVATION=1 FUZZ_BYTES=1 SUFFIX="_par_full"
+### Full
+export IGNORE_INTERRUPTS=0 IGNORE_BYTES=0 SUFFIX="_par_full"
+build WATERS_DEMO $SUFFIX
+build RELEASE_DEMO $SUFFIX
 build COPTER_DEMO $SUFFIX
+
+# Stateful -> presumably bad for us
+## keep rng states
+export IGNORE_INTERNAL_STATE=0
+### Full
+export IGNORE_INTERRUPTS=0 IGNORE_BYTES=0 SUFFIX="_par_stateful_full"
+build WATERS_DEMO $SUFFIX
+build RELEASE_DEMO $SUFFIX
+build COPTER_DEMO $SUFFIX
+
+# stateless + dataflow
+export PARTITION_INPUT=0
+export IGNORE_INTERNAL_STATE=1
+export IGNORE_INTERRUPTS=0 IGNORE_BYTES=0 SUFFIX="_seq_dataflow_full"
+export SPECIAL_CFLAGS="-DCOPTER_DATAFLOW=1"
+build COPTER_DEMO $SUFFIX 
+unset SPECIAL_CFLAGS

fuzzers/FRET/benchmark/number_cruncher/.gitignore

@@ -0,0 +1 @@
+*.sqlite

fuzzers/FRET/benchmark/number_cruncher/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "number_cruncher"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+clap = { version = "4.5.28", features = ["derive"] }
+itertools = "0.14.0"
+rayon = "1.10.0"
+regex = "1.11.1"
+rusqlite = "0.33.0"

fuzzers/FRET/benchmark/number_cruncher/src/main.rs

@@ -0,0 +1,263 @@
+use clap::parser::ValueSource;
+use clap::Parser;
+use itertools::Group;
+use itertools::Itertools;
+use rayon::iter::ParallelBridge;
+use rayon::prelude::*;
+use std::fs;
+use std::fs::File;
+use std::io::Write;
+use std::io::{self, BufRead, BufReader};
+use std::path::Path;
+use std::path::PathBuf;
+use rusqlite::{params, Connection, Result};
+
+#[derive(Parser)]
+struct Config {
+    /// Input
+    #[arg(short, long, value_name = "DIR")]
+    input: PathBuf,
+
+    /// Output
+    #[arg(short, long, value_name = "FILE", default_value = "out.sqlite")]
+    output: PathBuf,
+}
+fn visit_dirs(
+    dir: &Path,
+    results: &mut Vec<(PathBuf, String, String, String)>,
+) -> std::io::Result<()> {
+    if dir.is_dir() {
+        for entry in fs::read_dir(dir)? {
+            let entry = entry?;
+            let path = entry.path();
+            if path.is_dir() {
+                visit_dirs(&path, results)?;
+            } else if path.extension().and_then(|s| s.to_str()) == Some("time") {
+                if let Some(file_name) = path.file_name().and_then(|s| s.to_str()) {
+                    let re = regex::Regex::new(r".*#[0-9]+\.time$").unwrap();
+                    if re.is_match(file_name) {
+                        if let Some(dir_name) = path
+                            .parent()
+                            .and_then(|p| p.file_name())
+                            .and_then(|s| s.to_str())
+                        {
+                            {
+                                let mut file_stem =
+                                    path.file_stem().unwrap().to_str().unwrap().split("#");
+                                let case_name = file_stem.next().unwrap();
+                                let case_number = file_stem.next().unwrap();
+                                results.push((
+                                    path.clone(),
+                                    dir_name.to_string(),
+                                    case_name.to_string(),
+                                    case_number.to_string(),
+                                ));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn maxpoints_of_file(file_path: &Path) -> io::Result<Vec<(usize, usize)>> {
+    let file = File::open(file_path)?;
+    let reader = BufReader::new(file);
+
+    let mut results = Vec::new();
+    let mut watermark = 0;
+    let mut last_timestamp = 0;
+
+    for line in reader.lines() {
+        let line = line?;
+        let mut parts = line.split(',');
+
+        if let (Some(first_str), Some(second_str)) = (parts.next(), parts.next()) {
+            let first: usize = first_str.trim().parse().unwrap();
+            let second: usize = second_str.trim().parse().unwrap();
+
+            if first > watermark {
+                results.push((first, second));
+                watermark = first;
+            }
+            last_timestamp = second;
+        }
+    }
+    if results.len() > 1 {
+        results[0].1 = 0;
+        results.push((results[results.len() - 1].0, last_timestamp));
+    }
+
+    Ok(results)
+}
+
+fn sample_maxpoints(points: &Vec<(usize, usize)>, samples: &Vec<usize>) -> Vec<(usize, usize)> {
+    let mut todo = samples.iter().peekable();
+    let mut ret = Vec::new();
+    for i in 0..points.len() {
+        if todo.peek().is_none() {
+            // Done
+            break;
+        }
+        while let Some(&&peek) = todo.peek() {
+            if peek >= points[i].1 && (i+1 >= points.len() || peek < points[i+1].1) {
+                // End or inside the interval
+                ret.push((points[i].0, peek));
+                todo.next();
+            } else if peek < points[i].1 {
+                if i == 0 {
+                    // Before the first interval, just take the first
+                    ret.push((points[i].0, peek));
+                    todo.next();
+                } else {
+                    // Already passed
+                    eprintln!("WARNING Skipped: {}", todo.next().unwrap());
+                }
+            } else {
+                // Not yet
+                break;
+            }
+        }
+    }
+    ret
+}
+
+// https://rust-lang-nursery.github.io/rust-cookbook/science/mathematics/statistics.html
+fn mean(data: &[usize]) -> Option<f64> {
+    let sum = data.iter().sum::<usize>() as f64;
+    let count = data.len();
+
+    match count {
+        positive if positive > 0 => Some(sum / count as f64),
+        _ => None,
+    }
+}
+
+fn median(data: &[usize]) -> Option<f64> {
+    let mut data = data.to_vec();
+    data.sort();
+    let size = data.len();
+    if size == 0 {
+        return None;
+    }
+
+    match size {
+        even if even % 2 == 0 => {
+            let fst_med = data[(even / 2) - 1];
+            let snd_med = data[even / 2];
+
+            fst_med.checked_add(snd_med).map(|x| x as f64 / 2.0)
+        },
+        odd => data.get(odd / 2).map(|x| *x as f64)
+    }
+}
+
+// https://rust-lang-nursery.github.io/rust-cookbook/science/mathematics/statistics.html
+fn std_deviation(data: &[usize]) -> Option<f64> {
+    match (mean(data), data.len()) {
+        (Some(data_mean), count) if count > 0 => {
+            let variance = data
+                .iter()
+                .map(|value| {
+                    let diff = data_mean - (*value as f64);
+
+                    diff * diff
+                })
+                .sum::<f64>()
+                / count as f64;
+
+            Some(variance.sqrt())
+        }
+        _ => None,
+    }
+}
+
+fn main() {
+    let conf = Config::parse();
+
+    let mut results = Vec::new();
+
+    if let Err(e) = visit_dirs(&conf.input, &mut results) {
+        eprintln!("Error reading directories: {}", e);
+    }
+
+    println!("Files: {:?}", results);
+    let mut connection = Connection::open(conf.output).unwrap();
+    connection.execute("DROP TABLE IF EXISTS combos", ()).unwrap();
+    connection.execute("CREATE TABLE IF NOT EXISTS combos (casename TEXT, toolname TEXT, fullname TEXT PRIMARY KEY)", ()).unwrap();
+
+    let mut points: Vec<_> = results
+        .par_iter()
+        .map(|(path, fuzzer, case, n)| {
+            (
+                case,
+                fuzzer,
+                n.parse::<usize>().unwrap(),
+                maxpoints_of_file(path).unwrap(),
+            )
+        })
+        .collect();
+    points.sort_by_key(|x| x.0); // by case for grouping
+    for (case, casegroup) in &points.into_iter().chunk_by(|x| x.0) {
+        let casegroup = casegroup.collect::<Vec<_>>();
+        println!("Processing case {}: {}", case, casegroup.len());
+        let mut timestamps = Vec::new();
+        for (_, _, _, points) in &casegroup {
+            timestamps.extend(points.iter().map(|(_, t)| *t));
+        }
+        timestamps.sort();
+        timestamps.dedup();
+        let mut maxpoints_per_tool = casegroup
+            .par_iter()
+            .map(|g| (g.0, g.1, g.2, sample_maxpoints(&g.3, &timestamps)))
+            .collect::<Vec<_>>();
+        maxpoints_per_tool.sort_by_key(|x| x.1); // by tool
+        for (tool, toolgroup) in &maxpoints_per_tool.into_iter().chunk_by(|x| x.1) {
+            let toolgroup = toolgroup.collect::<Vec<_>>();
+            println!("Processing tool {}: {}", tool, toolgroup.len());
+            let lowest_common_length = toolgroup
+                .iter()
+                .map(|(_, _, _, points)| points.len())
+                .min()
+                .unwrap();
+            let time_min_max_med_mean_sdiv : Vec<(usize,usize,usize,f64,f64,f64)> = (0..lowest_common_length)
+                .into_par_iter()
+                .map(|i| {
+                    let slice = toolgroup.iter().map(|(_, _, _, p)| p[i].0).collect::<Vec<_>>();
+                    assert_eq!(slice.len(), toolgroup.len());
+                    (
+                        toolgroup[0].3[i].1,
+                        *slice.iter().min().unwrap_or(&0),
+                        *slice.iter().max().unwrap_or(&0),
+                        median(&slice).unwrap_or(0.0),
+                        mean(&slice).unwrap_or(0.0),
+                        std_deviation(&slice).unwrap_or(0.0),
+                    )
+                })
+                .collect::<Vec<_>>();
+
+            // Save to db
+            connection.execute("INSERT INTO combos (casename, toolname, fullname) VALUES (?, ?, ?)", (case, tool, format!("{}${}",case, tool))).unwrap();
+            connection.execute(&format!("DROP TABLE IF EXISTS {}${}", case, tool), ()).unwrap();
+            connection.execute(&format!("CREATE TABLE IF NOT EXISTS {}${} (timestamp INTEGER PRIMARY KEY, min INTEGER, max INTEGER, median REAL, mean REAL, sdiv REAL)", case, tool), ()).unwrap();
+
+            // Start a transaction
+            let transaction = connection.transaction().unwrap();
+
+            let mut stmt = transaction.prepare(&format!(
+                "INSERT INTO {}${} (timestamp , min , max , median , mean , sdiv ) VALUES (?, ?, ?, ?, ?, ?)",
+                case, tool
+            )).unwrap();
+
+            for (timestamp, min, max, median, mean, sdiv) in time_min_max_med_mean_sdiv {
+                stmt.execute([(timestamp as i64).to_string(), (min as i64).to_string(), (max as i64).to_string(), median.to_string(), mean.to_string(), sdiv.to_string()]).unwrap();
+            }
+            drop(stmt);
+
+            // Commit the transaction
+            transaction.commit().unwrap();
+        }
+    }
+}

fuzzers/FRET/benchmark/plot_sqlite.r

@@ -0,0 +1,79 @@
+library("mosaic")
+library("dplyr")
+library("DBI")
+
+args = commandArgs(trailingOnly=TRUE)
+
+# Read the first command line argument as an sqlite file
+if (length(args) > 0) {
+  sqlite_file <- args[1]
+  con <- dbConnect(RSQLite::SQLite(), sqlite_file)
+  
+} else {
+  stop("No sqlite file provided")
+}
+
+combos <- dbGetQuery(con, "SELECT * FROM combos")
+casenames <- dbGetQuery(con, "SELECT casename FROM combos GROUP BY casename")
+toolnames <- dbGetQuery(con, "SELECT toolname FROM combos GROUP BY toolname")
+
+ml2lines <- function(ml) {
+  lines = NULL
+  last = 0
+  for (i in seq_len(dim(ml)[1])) {
+    lines = rbind(lines, cbind(X=last, Y=ml[i,1]))
+    lines = rbind(lines, cbind(X=ml[i,2], Y=ml[i,1]))
+    last = ml[i,2]
+  }
+  return(lines)
+}
+
+draw_plot <- function(data) {
+  MY_COLORS <- c("green", "blue", "red", "magenta", "orange", "cyan", "pink", "gray", "orange", "black", "yellow","brown")
+  LEGEND_POS="bottomright"
+
+  # draw limits
+  max_x <- max(sapply(data, function(tbl) max(tbl$timestamp, na.rm = TRUE)))
+  max_y <- max(sapply(data, function(tbl) max(tbl$max, na.rm = TRUE)))
+  min_y <- min(sapply(data, function(tbl) min(tbl$min, na.rm = TRUE)))
+
+  # plot setup
+  h_ = 380
+  w_ = h_*4/3
+  png(file=sprintf("test.png"), width=w_, height=h_)
+  par(mar=c(4,4,1,1))
+  par(oma=c(0,0,0,0))
+  plot(c(0,max_x),c(min_y,max_y), col='white', xlab="Time [h]", ylab="WCRT estimate [insn]", pch='.')
+
+  # plot data
+  for (n in seq_len(length(data))) {
+    d <- data[[n]]
+    malines = ml2lines(d[c('max','timestamp')])
+    lines(malines, col=MY_COLORS[[n]], lty='dashed')
+    medlines = ml2lines(d[c('median','timestamp')])
+    lines(medlines, col=MY_COLORS[[n]], lty='solid')
+    milines = ml2lines(d[c('min','timestamp')])
+    lines(milines, col=MY_COLORS[[n]], lty='dashed')
+  }
+
+  legend(LEGEND_POS, legend=names(data),#"bottomright",
+        col=c(MY_COLORS[1:length(data)],"black"),
+        lty=c(rep("solid",length(data)),"dotted"))
+
+  par(las = 2, mar = c(10, 5, 1, 1)) 
+  dev.off()
+}
+
+for (c in casenames) {
+  tables <- dbGetQuery(con, sprintf("SELECT * FROM combos WHERE casename == '%s'", c))
+  table_list <- list()
+  for (row in 1:nrow(tables)) {
+    table_name <- tables[row, 'fullname']
+    tool_name <- tables[row, 'toolname']
+    table_data <- dbGetQuery(con, sprintf("SELECT * FROM '%s'", table_name))
+    table_list[[tool_name]] <- table_data
+  }
+  draw_plot(table_list)
+}
+
+dbDisconnect(con)

fuzzers/FRET/benchmark/target_symbols.csv

@@ -1,19 +1,40 @@
 kernel,main_function,input_symbol,input_size,return_function,select_task,interrupts
-interact_full,main_interact,FUZZ_INPUT,4096,trigger_Qemu_break,NONE,0#1000
+waters_seq_full,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,0#1000
-interact_int,main_interact,FUZZ_INPUT,4096,trigger_Qemu_break,NONE,0#1000
+waters_seq_int,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,0#1000
-interact_bytes,main_interact,FUZZ_INPUT,4096,trigger_Qemu_break,NONE,
+waters_seq_bytes,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,
-waters_seq_full,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,1129,0#1000
+waters_par_full,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,0#1000
-waters_seq_int,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,1129,0#1000
+waters_par_int,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,0#1000
-waters_seq_bytes,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,1129,
+waters_par_bytes,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,
-waters_seq_full_seq,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,1129,0#1000
+waters_seq_stateful_full,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,0#1000
-release_seq_full,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000;2#2000;3#3000
+waters_seq_stateful_int,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,0#1000
-release_seq_int,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000;2#2000;3#3000
+waters_seq_stateful_bytes,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,
+waters_par_stateful_full,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,0#1000
+waters_par_stateful_int,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,0#1000
+waters_par_stateful_bytes,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,
+release_seq_full,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000
+release_seq_full,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000
+release_seq_int,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000
 release_seq_bytes,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,
-copter_seq_full,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000
+release_par_full,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000
-copter_par_full,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000
+release_par_int,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000
-copter_seq_int,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000
+release_par_bytes,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,
-copter_seq_bytes,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,
+release_seq_stateful_full,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000
-copter_par_bytes,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,
+release_seq_stateful_int,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000
-copter_seq_stateless_full,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000
+release_seq_stateful_bytes,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,
-copter_seq_stateless_int,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000
+release_par_stateful_full,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000
-copter_seq_stateless_bytes,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,
+release_par_stateful_int,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000
+release_par_stateful_bytes,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,
+coptere_seq_full,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000
+coptere_seq_full,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000
+coptere_seq_int,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000
+coptere_seq_bytes,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,
+coptere_par_full,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000
+coptere_par_int,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000
+coptere_par_bytes,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,
+coptere_seq_stateful_full,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000
+coptere_seq_stateful_int,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000
+coptere_seq_stateful_bytes,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,
+coptere_par_stateful_full,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000
+coptere_par_stateful_int,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000
+coptere_par_stateful_bytes,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,
+coptere_seq_dataflow_full,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000