failnix/scripts/build.pl

#!/usr/bin/env perl

use strict;
use warnings;
use diagnostics;

use FindBin;
use lib $FindBin::Bin;

use Util;
use TUI;

use POSIX qw(strftime);
use feature 'say';

my $local_root            = '/home/christoph/Notes/TU/MastersThesis/FailNix';
my $local_builds_dir      = "$local_root/builds";
my $local_experiments_dir = "$local_root/targets/wasm-module";
my $justbin               = "$local_root/just-bin/just";
my $justfile              = "$local_root/scripts/build.just";

my @targets = ( "fail", "linux", "linux-baremetal" );
my @modes   = ( "c",    "aot",   "interp" );

sub just {
    say
"Running: WAMR_USE_AOT_SECTION=$ENV{WAMR_USE_AOT_SECTION} WAMR_USE_MMAP=$ENV{WAMR_USE_MMAP} WAMR_USE_XIP=$ENV{WAMR_USE_XIP} just @_...";
    system("$justbin -d $local_root -f $justfile @_ >/dev/null 2>&1")
      and die "Build failed";
    sleep(1);
}

# Find and select experiments
my @experiments = map { s/\.cpp//r } Util::find_files($local_experiments_dir);
my @selected_experiments =
  TUI::select_from_list( "Select Experiments to Build", 1, @experiments );
die "No experiment selected" unless @selected_experiments;

# Select targets
my @selected_targets =
  TUI::select_from_list( "Select Target Platforms", 1, @targets );
die "No target selected" unless @selected_targets;

# Select modes
my @selected_modes =
  TUI::select_from_list( "Select Execution Modes", 1, @modes );
die "No mode selected" unless @selected_modes;

# Select .text.wamr_aot section variant
my @aot_section_variants = (
    "Place AOT array in .text.wamr_aot",
    "Let the linker decide where the AOT array is located",
);
my @selected_aot_variants =
  TUI::select_from_list( "Select WAMR Array.Text Variant",
    1, @aot_section_variants );
die "No AOT section variant selected" unless @selected_aot_variants;

# Select WAMR mmap variant
my @mmap_variants = (
    "Locate mmap_space in .text.wamr_mmap",
    "Let the linker decide where mmap_space is located"
);
my @selected_mmap_variants =
  TUI::select_from_list( "Select WAMR Mmap.Text Variant", 1, @mmap_variants );
die "No variant selected" unless @selected_mmap_variants;

# Select XIP variant
my @xip_variants = ( "Compile AOT with --xip", "Compile AOT without --xip" );
my @selected_xip_variants =
  TUI::select_from_list( "Select WAMRC XIP Variant", 1, @xip_variants );
die "No XIP variant selected" unless @selected_xip_variants;

# Select FAIL catch flags (written to runner_flags in each build dir, not a build loop)
my %catch_flag_map = (
    "--catch-outer" => "--catch-outerspace",
    "--catch-text"  => "--catch-write-textsegment",
);
my @selected_catch_tags =
  TUI::select_from_list( "Select FAIL Flags", 1, sort keys %catch_flag_map );

# Select 0.info contents
my $info = join " ", TUI::select_from_list(
    "Select '0.info' Contents for ",
    1,
    (
        # mmap, xip, wamr_aot, --catch-outer, --catch-text are auto-included from variant selections
        "baseline",
    )
);

# Build everything
# TODO: linux-baremetal target is broken
system( "mkdir", "-p", "$local_builds_dir" );
foreach my $experiment (@selected_experiments) {
    foreach my $target (@selected_targets) {
        foreach my $mode (@selected_modes) {
            foreach my $mmap_variant (@selected_mmap_variants) {
                foreach my $xip_variant (@selected_xip_variants) {
                    foreach my $aot_variant (@selected_aot_variants) {

                        # Skip redundant combinations where variants don't apply to this mode
                        # "c"     uses no WAMR at all
                        # "interp" uses mmap but no AOT
                        next
                          if $mode eq "c"
                          && ( $mmap_variant ne $mmap_variants[0]
                            || $xip_variant ne $xip_variants[0]
                            || $aot_variant ne $aot_section_variants[0] );
                        next
                          if $mode eq "interp"
                          && ( $xip_variant ne $xip_variants[0]
                            || $aot_variant ne $aot_section_variants[0] );

                        # These variables control which libiwasm, wamrc flags, and build options are used
                        local $ENV{WAMR_USE_MMAP} =
                          ( $mmap_variant eq
                              "Locate mmap_space in .text.wamr_mmap" )
                          ? "true"
                          : "false";
                        local $ENV{WAMR_USE_XIP} =
                          ( $xip_variant eq "Compile AOT with --xip" )
                          ? "true"
                          : "false";
                        local $ENV{WAMR_USE_AOT_SECTION} =
                          ( $aot_variant eq
                              "Place AOT array in .text.wamr_aot" )
                          ? "true"
                          : "false";

                        my $aot_info =
                          (      $mode eq "aot"
                              && $aot_variant eq
                              "Place AOT array in .text.wamr_aot" )
                          ? "wamr_aot"
                          : "";
                        my $mmap_info =
                          ( ( $mode eq "aot" || $mode eq "interp" )
                              && $mmap_variant eq
                              "Locate mmap_space in .text.wamr_mmap" )
                          ? "wamr_mmap"
                          : "";
                        my $xip_info =
                          (      $mode eq "aot"
                              && $xip_variant eq "Compile AOT with --xip" )
                          ? "xip"
                          : "";
                        my $flags_info = join " ", @selected_catch_tags;
                        my $info_str   = join " ",
                          grep { length } (
                            $mode,     $aot_info,   $mmap_info,
                            $xip_info, $flags_info, $info
                          );

                        # Build experiment
                        my $date = strftime( "%m-%d_%H-%M-%S", localtime );
                        just( "build", $experiment, $target, $mode );

                        # Write extra info for the menu
                        system(
                            "echo '$info_str' > $local_root/build-$experiment/0.info"
                        );

                 # Write runner_flags so runner.pl knows which FAIL flags to use
                        my $runner_flags_path =
                          "$local_root/build-$experiment/runner_flags";
                        open( my $rfh, '>', $runner_flags_path )
                          or die "Cannot write $runner_flags_path: $!";
                        print $rfh "$catch_flag_map{$_}\n"
                          for @selected_catch_tags;
                        close($rfh);

                        my $aot_name  = $aot_info  ? "_aot-text"  : "";
                        my $mmap_name = $mmap_info ? "_mmap-text" : "";
                        my $xip_name  = $xip_info  ? "_xip"       : "";
                        system(
                            join " ",
                            (
                                "mv",
                                "$local_root/build-$experiment",
                                "$local_builds_dir/${date}_${experiment}_${mode}_${target}${aot_name}${mmap_name}${xip_name}",
                            )
                        );
                    }
                }
            }
        }
    }
}