batchSwarmDriver.m

function batchSwarmDriver(config_filename, cpu_name, cpu_num, total_cpu_num, ...
        batch_name, debug_mode)
    %BATCHSWARMDRIVER performs batch runs of the search algorithm to compute
    % statistics
    %

    %% Setup
    close all
    setupPaths();
    disp(newline);

    % Generate parameters to batch
    if strcmpi(batch_name, "Batch Testing Out")
        [all_num_runs, all_config_settings] = generateRunMatrixBatchTestingOut();
    elseif strcmpi(batch_name, "Batch 1")
        [all_num_runs, all_config_settings] = GenerateRunMatrixBatch1();
    elseif strcmpi(batch_name, "Batch 2")
        [all_num_runs, all_config_settings] = GenerateRunMatrixBatch2();
    elseif strcmpi(batch_name, "Batch 2 Conventional")
        [all_num_runs, all_config_settings] = GenerateRunMatrixConventional2();
    elseif strcmpi(batch_name, "Batch 3")
        [all_num_runs, all_config_settings] = GenerateRunMatrixBatch3();
    elseif strcmpi(batch_name, "Batch 3 Conventional")
        [all_num_runs, all_config_settings] = GenerateRunMatrixConventional3();
    elseif strcmpi(batch_name, "Batch 4")
        [all_num_runs, all_config_settings] = generateRunMatrixBatch4();
    elseif strcmpi(batch_name, "Batch 4 Conventional")
        [all_num_runs, all_config_settings] = generateRunMatrixConventional4();
    elseif strcmpi(batch_name, "Batch 5 Experimental")
        [all_num_runs, all_config_settings] = generateRunMatrixExperimentalBatch5();
    elseif strcmpi(batch_name, "Batch 5 Conventional")
        [all_num_runs, all_config_settings] = generateRunMatrixConventionalBatch5();
    elseif strcmpi(batch_name, "Batch 6 Experimental")
        [all_num_runs, all_config_settings] = generateRunMatrixExperimentalBatch6();
    elseif strcmpi(batch_name, "Batch 6 Conventional")
        [all_num_runs, all_config_settings] = generateRunMatrixConventionalBatch6();
    elseif strcmpi(batch_name, "Batch 7 Experimental")
        [all_num_runs, all_config_settings] = generateRunMatrixExperimentalBatch7();
    elseif strcmpi(batch_name, "Batch 7 Conventional")
        [all_num_runs, all_config_settings] = generateRunMatrixConventionalBatch7();
    elseif strcmpi(batch_name, "Batch 8 Experimental")
        [all_num_runs, all_config_settings] = generateRunMatrixExperimentalBatch8();
    elseif strcmpi(batch_name, "Batch 8 Conventional")
        [all_num_runs, all_config_settings] = generateRunMatrixConventionalBatch8();
    else
        error("Invalid batch name");
    end

    % force batch mode
    for i=1:all_num_runs
        all_config_settings(i).runtime.run_mode = "batch";
        all_config_settings(i).runtime.exit_on_success = true;
    end

    % Allocate runs to do per available VM
    num_runs_per_cpu = floor(all_num_runs / total_cpu_num);
    all_cpu_runs_idx = 1:num_runs_per_cpu:all_num_runs;
    if ~isequal(all_cpu_runs_idx(end), all_num_runs)
        all_cpu_runs_idx = [all_cpu_runs_idx, all_num_runs];
    end

    % choosing settings to use
    cpu_idx = ...
        all_cpu_runs_idx(cpu_num) : all_cpu_runs_idx(cpu_num + 1) - 1;
    if isequal(total_cpu_num, cpu_num)
        cpu_idx = ...
            all_cpu_runs_idx(cpu_num) : all_num_runs;
    end
    if debug_mode
        limited_num_runs = 5;
        if length(cpu_idx) > limited_num_runs
            cpu_idx = cpu_idx(1:limited_num_runs);
        else
            cpu_idx = cpu_idx(1:end);
        end
    end
    num_runs = length(cpu_idx);
    config_settings = all_config_settings(cpu_idx);

    % initialize save folder
    start_date_time_normal = char(datetime("now"));
    start_date_time_folder_friendly = strrep(start_date_time_normal, ":", "-");
    start_date_time_folder_friendly = strrep(start_date_time_folder_friendly, " ", "-");
    batch_run_name_tag = fullfile("runs", batch_name);
    batch_run_name_instance = strcat(num2str(cpu_num), "-of-", num2str(total_cpu_num), "_", ...
        cpu_name, "_", start_date_time_folder_friendly);
    if debug_mode
        batch_run_name_instance = strcat("DEBUG-", batch_run_name_instance);
    end
    run_folder = fullfile(batch_run_name_tag, batch_run_name_instance);

    if ispc
        save_folder = fullfile("C:\Users\turbeam1\Desktop");
    else
        save_folder = fullfile("/Users/turbeam1/Desktop");
    end
    save_folder = fullfile(save_folder, run_folder);

    if ~isfolder(save_folder)
        mkdir(save_folder);
    end

    %% Batch
    % initalize parallel pool
    pool = gcp("nocreate");
    if isempty(pool)
        parpool();
    end

    % writing failed info to log file
    filename = strcat("batch_fail.log");
    fid_log_fail = fopen(filename, "w");
    failed_run_num_list = [];
    failed_message_list = [];

    % initialize cell arrays
    config = cell(num_runs, 2);
    stats_cell = cell(num_runs, 1);
    for i=1:num_runs
        config{i,2} = cpu_idx(i);
    end
    failed_runs = cell(num_runs, 1);

    % batch
    batch_time_start = tic;
    fprintf("\n");
    progressbarText(0);
    parfor i=1:num_runs
        progressbarText(i / num_runs);
        fprintf("Starting - Batch Run #%d\n", cpu_idx(i));
        try
            [stats_cell{i,1}, config{i,1}] = ...
                swarmDriver(config_filename, config_settings(i), save_folder, ...
                cpu_idx(i));
            fprintf("Success - Batch Run #%d\n", cpu_idx(i));
        catch ME
            warning(ME.message)
            fprintf("Failed - Batch Run #%d\n", cpu_idx(i));
            failed_runs{i} = struct("run", cpu_idx(i), "message", ME.message);
        end
    end

    % write failed runs to log file
    failed_runs = failed_runs(~cellfun("isempty", failed_runs));
    if ~isempty(failed_runs)
        fid_log_fail = fopen("batch_fail.log", "w");
        for i = 1:length(failed_runs)
            fprintf(fid_log_fail, "Failed: %d - %s\n", failed_runs{i}.run, failed_runs{i}.message);
        end
        fclose(fid_log_fail);
    end


    %% Tally and save data
    % Convert cell to a struct with a list and then save
    fn = fieldnames(stats_cell{1});
    for i=1:numel(fn)
        stats_all.(fn{i}) = zeros(num_runs, 1);
        for j=1:num_runs
            stats_all.(fn{i})(j) = stats_cell{j}.(fn{i});
        end
    end

    % adding run number information
    stats_all.run_num = zeros(size(stats_all.mission_success));
    for i=1:num_runs
        stats_all.run_num(i) = cpu_idx(i);
    end

    % saving results
    results_folder = fullfile(save_folder, "results");
    if ~isfolder(results_folder)
        mkdir(results_folder);
    end
    save(fullfile(results_folder, "stats_all.mat"), "stats_all");
    save(fullfile(results_folder, "config.mat"), "config");

    % Timing
    batch_time_elapsed = toc(batch_time_start);
    batch_time_elapsed_text = sprintf("%0.2f", batch_time_elapsed);
    output_text = strcat(start_date_time_normal, " ", cpu_name, " (", ...
        "run #", num2str(cpu_num), " of ", num2str(total_cpu_num), ")", ...
        " - ", batch_time_elapsed_text, " seconds.\n");
    fprintf(output_text);

    % writing output info to log file
    filename = strcat("batch_complete.log");
    fid_log_batch_complete = fopen(filename, "a");
    fprintf(fid_log_batch_complete, output_text);
    fclose(fid_log_batch_complete);

    %% Cleanup
    if debug_mode
        return;
    end

    % zip folder
    zip_save_folder = strcat(save_folder, ".zip");
    zip(zip_save_folder, save_folder);
    
    % save to network space
    try
        if ispc
            shared_space_folder = fullfile("U:\thesis", batch_run_name_tag);
        else
            shared_space_folder = fullfile("/Volumes/aplhome$/thesis", batch_run_name_tag);
        end
        if ~isfolder(shared_space_folder)
            mkdir(shared_space_folder);
        end
        copyfile(zip_save_folder, shared_space_folder, "f");
    catch
        warning(strcat("Save to network space failed. Results can be found at: ", save_folder));
    end