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 $compile_pl            = "$local_root/scripts/compile.pl";

sub compile {
    my ( $module, $target, $mode ) = @_;
    say "Running: WAMR_USE_AOT_IN_TEXT=$ENV{WAMR_USE_AOT_IN_TEXT}",
      " WAMR_USE_MMAP_IN_TEXT=$ENV{WAMR_USE_MMAP_IN_TEXT}",
      " WAMR_USE_XIP=$ENV{WAMR_USE_XIP}",
      " WAMR_USE_ALLOCATOR=$ENV{WAMR_USE_ALLOCATOR}",
      " compile.pl $module $target $mode";

    system( 'perl', $compile_pl, $module, $target, $mode ) == 0
      or die "Build failed\n";
    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 @targets = ( "fail", "linux", "linux-baremetal" );
my @selected_targets =
  TUI::select_from_list( "Select Target Platforms", 1, @targets );
die "No target selected" unless @selected_targets;

# Select modes
my @modes = ( "c", "aot", "interp" );
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_variant) =
  TUI::select_from_list( "Select WAMR Array.Text Variant",
    0, @aot_section_variants );
die "No AOT section variant selected" unless $selected_aot_variant;
local $ENV{WAMR_USE_AOT_IN_TEXT} =
  ( $selected_aot_variant eq $aot_section_variants[0] )
  ? "true"
  : "false";

# Select WAMR mmap variant
my @mmap_variants = (
    "Place mmap_space in .text.wamr_mmap",
    "Let the linker decide where mmap_space is located"
);
my ($selected_mmap_variant) =
  TUI::select_from_list( "Select WAMR Mmap.Text Variant", 0, @mmap_variants );
die "No variant selected" unless $selected_mmap_variant;
local $ENV{WAMR_USE_MMAP_IN_TEXT} =
  ( $selected_mmap_variant eq $mmap_variants[0] )
  ? "true"
  : "false";

# Select WAMR allocator variant
my @allocator_variants = (
    "Pool allocator (Alloc_With_Pool)",
    "Allocator with usage (Alloc_With_Allocator)",
);
my ($selected_allocator_variant) =
  TUI::select_from_list( "Select WAMR Allocator Variant",
    0, @allocator_variants );
die "No allocator variant selected" unless $selected_allocator_variant;
local $ENV{WAMR_USE_ALLOCATOR} =
  ( $selected_allocator_variant eq $allocator_variants[0] )
  ? "false"
  : "true";

# Select XIP variant
my @xip_variants = ( "Compile AOT with --xip", "Compile AOT without --xip" );
my ($selected_xip_variant) =
  TUI::select_from_list( "Select WAMRC XIP Variant", 0, @xip_variants );
die "No XIP variant selected" unless $selected_xip_variant;
local $ENV{WAMR_USE_XIP} =
  ( $selected_xip_variant eq $xip_variants[0] )
  ? "true"
  : "false";

# Select FAIL catch flags (written to runner_flags in each build dir)
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 );

# 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) {

            my $aot_info =
              (      $mode eq "aot"
                  && $selected_aot_variant eq $aot_section_variants[0] )
              ? "wamr_aot"
              : "";
            my $mmap_info =
              ( ( $mode eq "aot" || $mode eq "interp" )
                  && $selected_mmap_variant eq $mmap_variants[0] )
              ? "wamr_mmap"
              : "";
            my $allocator_info =
              ( ( $mode eq "aot" || $mode eq "interp" )
                  && $selected_allocator_variant eq $allocator_variants[0] )
              ? "alloc_pool"
              : "alloc_usage";
            my $xip_info =
              ( $mode eq "aot" && $selected_xip_variant eq $xip_variants[0] )
              ? "xip"
              : "";
            my $flags_info = join " ", @selected_catch_tags;
            my $info_str   = join " ",
              grep { length } (
                $mode,           $aot_info, $mmap_info,
                $allocator_info, $xip_info, $flags_info
              );

            # Build experiment
            my $date = strftime( "%m-%d_%H-%M-%S", localtime );
            compile( $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 $fhandle, '>', $runner_flags_path )
              or die "Cannot write $runner_flags_path: $!";
            print $fhandle "$catch_flag_map{$_}\n" for @selected_catch_tags;
            close($fhandle);

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