From 558b464c1a85ab43cd84b11f86fb508cf013a6b6 Mon Sep 17 00:00:00 2001 From: Alwin Berger Date: Wed, 12 Feb 2025 17:03:30 +0100 Subject: [PATCH] all new benchmark scripts --- fuzzers/FRET/benchmark/Snakefile | 24 +- fuzzers/FRET/benchmark/build_all_demos.sh | 100 ++++--- .../FRET/benchmark/number_cruncher/.gitignore | 1 + .../FRET/benchmark/number_cruncher/Cargo.toml | 11 + .../benchmark/number_cruncher/src/main.rs | 263 ++++++++++++++++++ fuzzers/FRET/benchmark/plot_sqlite.r | 79 ++++++ fuzzers/FRET/benchmark/target_symbols.csv | 55 ++-- 7 files changed, 450 insertions(+), 83 deletions(-) create mode 100644 fuzzers/FRET/benchmark/number_cruncher/.gitignore create mode 100644 fuzzers/FRET/benchmark/number_cruncher/Cargo.toml create mode 100644 fuzzers/FRET/benchmark/number_cruncher/src/main.rs create mode 100644 fuzzers/FRET/benchmark/plot_sqlite.r diff --git a/fuzzers/FRET/benchmark/Snakefile b/fuzzers/FRET/benchmark/Snakefile index 5fa30ca702..b5c0994ffc 100644 --- a/fuzzers/FRET/benchmark/Snakefile +++ b/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=['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 ))), + 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 ))), rule all_bins: input: diff --git a/fuzzers/FRET/benchmark/build_all_demos.sh b/fuzzers/FRET/benchmark/build_all_demos.sh index c425c464d4..68de7f8cba 100644 --- a/fuzzers/FRET/benchmark/build_all_demos.sh +++ b/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 - -# Only bytes - -export FUZZ_INT_ACTIVATION=0 FUZZ_BYTES=1 SUFFIX="_seq_bytes" +# Sequential inputs! +export PARTITION_INPUT=0 +unset SPECIAL_CFLAGS +# 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 - -# Only interrupts - -export FUZZ_INT_ACTIVATION=1 FUZZ_BYTES=0 SUFFIX="_seq_int" - +build COPTER_DEMO $SUFFIX +### Only interrupts +export IGNORE_INTERRUPTS=0 IGNORE_BYTES=1 SUFFIX="_seq_int" build WATERS_DEMO $SUFFIX build RELEASE_DEMO $SUFFIX -build INTERACT_DEMO $SUFFIX - -# Full - -export FUZZ_INT_ACTIVATION=1 FUZZ_BYTES=1 SUFFIX="_seq_full" - +build COPTER_DEMO $SUFFIX +### Full +export IGNORE_INTERRUPTS=0 IGNORE_BYTES=0 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 -export DELETE_RNG_STATE=0 - -export FUZZ_INT_ACTIVATION=0 FUZZ_BYTES=1 SUFFIX="_seq_bytes" -build COPTER_DEMO $SUFFIX -export FUZZ_INT_ACTIVATION=1 FUZZ_BYTES=0 SUFFIX="_seq_int" -build COPTER_DEMO $SUFFIX -export FUZZ_INT_ACTIVATION=1 FUZZ_BYTES=1 SUFFIX="_seq_full" +# Stateful -> presumably bad for us +## keep rng states +export IGNORE_INTERNAL_STATE=0 +### Full +export IGNORE_INTERRUPTS=0 IGNORE_BYTES=0 SUFFIX="_seq_stateful_full" +build WATERS_DEMO $SUFFIX +build RELEASE_DEMO $SUFFIX 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" -build COPTER_DEMO $SUFFIX \ No newline at end of file +### 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 \ No newline at end of file diff --git a/fuzzers/FRET/benchmark/number_cruncher/.gitignore b/fuzzers/FRET/benchmark/number_cruncher/.gitignore new file mode 100644 index 0000000000..9b1dffd90f --- /dev/null +++ b/fuzzers/FRET/benchmark/number_cruncher/.gitignore @@ -0,0 +1 @@ +*.sqlite diff --git a/fuzzers/FRET/benchmark/number_cruncher/Cargo.toml b/fuzzers/FRET/benchmark/number_cruncher/Cargo.toml new file mode 100644 index 0000000000..4d34d1ade2 --- /dev/null +++ b/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" diff --git a/fuzzers/FRET/benchmark/number_cruncher/src/main.rs b/fuzzers/FRET/benchmark/number_cruncher/src/main.rs new file mode 100644 index 0000000000..eca35735fb --- /dev/null +++ b/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> { + 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) -> 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 { + let sum = data.iter().sum::() as f64; + let count = data.len(); + + match count { + positive if positive > 0 => Some(sum / count as f64), + _ => None, + } +} + +fn median(data: &[usize]) -> Option { + 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 { + 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::() + / 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::().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::>(); + 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, ×tamps))) + .collect::>(); + 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::>(); + 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::>(); + 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::>(); + + // 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(); + } + } +} diff --git a/fuzzers/FRET/benchmark/plot_sqlite.r b/fuzzers/FRET/benchmark/plot_sqlite.r new file mode 100644 index 0000000000..913c5d9a8f --- /dev/null +++ b/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) diff --git a/fuzzers/FRET/benchmark/target_symbols.csv b/fuzzers/FRET/benchmark/target_symbols.csv index 057072c1cc..b0960b33e4 100644 --- a/fuzzers/FRET/benchmark/target_symbols.csv +++ b/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 -interact_int,main_interact,FUZZ_INPUT,4096,trigger_Qemu_break,NONE,0#1000 -interact_bytes,main_interact,FUZZ_INPUT,4096,trigger_Qemu_break,NONE, -waters_seq_full,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,1129,0#1000 -waters_seq_int,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,1129,0#1000 -waters_seq_bytes,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,1129, -waters_seq_full_seq,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,1129,0#1000 -release_seq_full,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000;2#2000;3#3000 -release_seq_int,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000;2#2000;3#3000 +waters_seq_full,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,0#1000 +waters_seq_int,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,0#1000 +waters_seq_bytes,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13, +waters_par_full,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,0#1000 +waters_par_int,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,0#1000 +waters_par_bytes,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13, +waters_seq_stateful_full,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,0#1000 +waters_seq_stateful_int,main_waters,FUZZ_INPUT,4096,trigger_Qemu_break,C13,0#1000 +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 -copter_par_full,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000 -copter_seq_int,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000 -copter_seq_bytes,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC, -copter_par_bytes,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC, -copter_seq_stateless_full,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000 -copter_seq_stateless_int,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC,0#20000 -copter_seq_stateless_bytes,main_osek,FUZZ_INPUT,4096,trigger_Qemu_break,FC, +release_par_full,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000 +release_par_int,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000 +release_par_bytes,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3, +release_seq_stateful_full,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000 +release_seq_stateful_int,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000 +release_seq_stateful_bytes,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3, +release_par_stateful_full,main_release,FUZZ_INPUT,4096,trigger_Qemu_break,T3,0#10000;1#5000 +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 \ No newline at end of file