command_line_inputs.hpp

Go to the documentation of this file.

#ifndef COMMAND_LINE_INPUTS_HPP
#define COMMAND_LINE_INPUTS_HPP

#include <stdexcept>
#include <functional>
#include <vector>
#include <string>

template<typename T>
static T read_arg_after(int argc, char* argv[], int i, int* ierr);

template<>
int read_arg_after(int argc, char* argv[], int i, int* ierr){
    *ierr = 0;
    if (i + 1 < argc) { // Make sure we aren't at the end of argv!
        std::string arg = argv[i+1];
        try {
            std::size_t pos;
            int x = std::stoi(arg, &pos);
            if (pos >= arg.size()) {
                return x;
            }
        } catch(...){
            //
        }
    }
    *ierr = 1;
    return -1;
}

struct CommandLineInputs{
    public:
    bool run_particle_test;
    bool update_particle_test;
    bool run_moments_test;
    bool update_moments_test;
    bool do_dryrun;
    int dryrun_n_mpi_ranks;
    bool perf_barriers;
    bool debug;

    private:
    struct Option{
        std::string name;
        std::string explanation;
        Option(std::string name, std::string explanation) : name(name), explanation(explanation) {}
    };
    std::vector<Option> options;

    bool first_input;
    bool found;

    bool check(std::string input, std::string name, std::string explanation){
        options.push_back(Option(name, explanation));
        if (input==name){
            found=true;
            return true;
        }else{
            return false;
        }
    };

    void print_options(){
        std::string msg = "Available options are:\n";
        for(int j = 0; j < options.size(); j++)
            msg += "\t" + options[j].name + "\t" + options[j].explanation + "\n";
        printf("%s", msg.c_str());
    }

    void error(std::string msg){
        printf("ERROR: %s\n", msg.c_str());
        print_options();
        exit(1);
    }

    public:

    CommandLineInputs(int argc, char* argv[])
      : run_particle_test(false),
        update_particle_test(false),
        run_moments_test(false),
        update_moments_test(false),
        do_dryrun(false),
        perf_barriers(false),
        debug(false)
    {
        int ierr;
        first_input = true;
        // Loop through inputs
        for (int i = 1; i < argc; ++i) {
            std::string input = std::string(argv[i]);
            found = false;

            if(check(input,"--test","Checks particles against reference data")){
                run_particle_test=true;
            }
            if(check(input,"--update-test","Updates reference data used in particle test")){
                update_particle_test=true;
            }
            if(check(input,"--moments-test","Checks moments against reference data")){
                run_moments_test=true;
            }
            if(check(input,"--update-moments-test","Updates reference data used in moments test")){
                update_moments_test=true;
            }
            if(check(input,"--debug","Activates extra barriered checkpoints and validity checks (not intended for production)")){
                debug=true;
            }
            if(check(input,"--dryrun","Partially runs XGC setup to check for some common input errors")){
                do_dryrun=true;
                dryrun_n_mpi_ranks = -1; // default
            }
            if(check(input,"-n_ranks","Optional input if using --dryrun: Specify the number of MPI ranks you plan to use")){
                if(!do_dryrun){
                    error("-n_ranks can only be used with --dryrun");
                }
                dryrun_n_mpi_ranks = read_arg_after<int>(argc, argv, i, &ierr);
                if(ierr!=0) error("Expected integer after -n_ranks");
                i++;
            }
            if(check(input,"--perf-barriers","Adds MPI barriers to top-level timers to help identify load imbalance")){
                perf_barriers=true;
            }
            if(!found){
                error("Unknown command line argument " + input);
            }
            first_input = false;
        }
    }
};

#endif