mapper_interface_tests.cpp

Go to the documentation of this file.

/*******************************************************************************
 * The software programs comprising "CGRA-ME" and the documentation provided
 * with them are copyright by its authors and the University of Toronto. Only
 * non-commercial, not-for-profit use of this software is permitted without ex-
 * plicit permission. This software is provided "as is" with no warranties or
 * guarantees of support. See the LICENCE for more details. You should have re-
 * ceived a copy of the full licence along with this software. If not, see
 * <http://cgra-me.ece.utoronto.ca/license/>.
 ******************************************************************************/
 
#include <CGRA/Mapper.h>
 
#include <catch2/catch.hpp>
 
namespace {
    struct DummyMapper : Mapper {
        int II = 0;
        DummyMapper(std::shared_ptr<CGRA> cgra, int timelimit) : Mapper(cgra, timelimit) {}
        Mapping mapOpGraph(std::shared_ptr<OpGraph> opgraph, int II, const MRRG& mrrg, std::unordered_map<std::string, std::string> fix_port) {
            this->II = II;
            return Mapping(cgra, II, opgraph);
        }
    };
 
    void runArgsTest(ConfigStore in_args, ConfigStore expcected_out_args, bool expect_pass, bool is_composite);
    void runArgsTest_Success(ConfigStore in_args, ConfigStore expcected_out_args) { return runArgsTest(in_args, expcected_out_args, true, false); }
    void runArgsTest_Failure(ConfigStore in_args, ConfigStore expcected_out_args) { return runArgsTest(in_args, expcected_out_args, false, false); }
    void runArgsTest_Composite_Success(ConfigStore in_args, ConfigStore expcected_out_args) { return runArgsTest(in_args, expcected_out_args, true, true); }
    void runArgsTest_Composite_Failure(ConfigStore in_args, ConfigStore expcected_out_args) { return runArgsTest(in_args, expcected_out_args, false, true); }
 
    void runArgsFilterTest(std::vector<std::string> in_args, std::vector<std::string> required_args, std::vector<std::string> optional_regexes, bool expect_pass);
    void runArgsFilterTest_Success(std::vector<std::string> in_args, std::vector<std::string> required_args, std::vector<std::string> optional_regexes) { return runArgsFilterTest(in_args, required_args, optional_regexes, true); }
    void runArgsFilterTest_Failure(std::vector<std::string> in_args, std::vector<std::string> required_args, std::vector<std::string> optional_regexes) { return runArgsFilterTest(in_args, required_args, optional_regexes, false); }
};
 
SCENARIO ("MapperRegistry Test -- Direct args, success", "[mapper registry]") {
    runArgsTest_Success(
        { // in
            {"checker.arg1", 1},
            {"checker.arg2", 2},
        }, { // expected
            {"arg1", 1},
            {"arg2", 2},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Direct args, failure", "[mapper registry]") {
    runArgsTest_Failure(
        { // in
            {"checker.arg1", 1},
            {"checker.arg2", 3},
        }, { // expected
            {"arg1", 1},
            {"arg2", 2},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Direct args to another mapper", "[mapper registry]") {
    runArgsTest_Success(
        { // in
            {"not_the_checker.arg1", 1},
            {"not_the_checker.arg2", 2},
        }, { // expected
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- AllMappers args", "[mapper registry]") {
    runArgsTest_Success(
        { // in
            {"AllMappers.arg1", 1},
            {"AllMappers.arg2", 2},
        }, { // expected
            {"arg1", 1},
            {"arg2", 2},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- AllMappers + Direct args", "[mapper registry]") {
    runArgsTest_Success(
        { // in
            {"AllMappers.arg1", 1},
            {"checker.arg2", 2},
        }, { // expected
            {"arg1", 1},
            {"arg2", 2},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- AllMappers + Direct args to wrong mapper", "[mapper registry]") {
    runArgsTest_Success(
        { // in
            {"AllMappers.arg1", 1},
            {"not_the_checker.arg2", 2},
        }, { // expected
            {"arg1", 1}
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Composite -- Direct args, success", "[mapper registry]") {
    runArgsTest_Composite_Success(
        { // in
            {"checker.arg1", 1},
            {"checker.arg2", 2},
        }, { // expected
            {"checker.arg1", 1},
            {"checker.arg2", 2},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Composite -- Direct args, failure", "[mapper registry]") {
    runArgsTest_Composite_Failure(
        { // in
            {"checker.arg1", 1},
            {"checker.arg2", 3},
        }, { // expected
            {"checker.arg1", 1},
            {"checker.arg2", 2},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Composite -- Direct args to another mapper", "[mapper registry]") {
    runArgsTest_Composite_Success(
        { // in
            {"not_the_checker.arg1", 1},
            {"not_the_checker.arg2", 2},
        }, { // expected
            {"not_the_checker.arg1", 1},
            {"not_the_checker.arg2", 2},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Composite -- AllMappers args", "[mapper registry]") {
    runArgsTest_Composite_Success(
        { // in
            {"AllMappers.arg1", 1},
            {"AllMappers.arg2", 2},
        }, { // expected
            {"AllMappers.arg1", 1},
            {"AllMappers.arg2", 2},
            {"checker.arg1", 1},
            {"checker.arg2", 2},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Composite -- nested args", "[mapper registry]") {
    runArgsTest_Composite_Success(
        { // in
            {"checker.nested.arg1", 1},
        }, { // expected
            {"checker.nested.arg1", 1},
            {"nested.arg1", 1},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Composite -- doubly nested arg overwrites", "[mapper registry]") {
    runArgsTest_Composite_Success(
        { // in
            {"checker.nested.arg1", 1},
            {"checker.checker.nested.arg1", 1},
        }, { // expected
            {"nested.arg1", 1},
            {"checker.nested.arg1", 1},
            {"checker.checker.nested.arg1", 1},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Composite -- AllMappers + Direct args", "[mapper registry]") {
    runArgsTest_Composite_Success(
        { // in
            {"AllMappers.arg1", 1},
            {"checker.arg2", 2},
        }, { // expected
            {"AllMappers.arg1", 1},
            {"checker.arg1", 1},
            {"checker.arg2", 2},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Composite -- AllMappers + Direct arg override", "[mapper registry]") {
    runArgsTest_Composite_Success(
        { // in
            {"AllMappers.arg1", 1},
            {"checker.arg1", 7},
            {"checker.arg2", 2},
        }, { // expected
            {"AllMappers.arg1", 1},
            {"checker.arg1", 7},
            {"checker.arg2", 2},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Composite -- AllMappers + Direct args to wrong mapper", "[mapper registry]") {
    runArgsTest_Composite_Success(
        { // in
            {"AllMappers.arg1", 1},
            {"not_the_checker.arg2", 2},
        }, { // expected
            {"AllMappers.arg1", 1},
            {"not_the_checker.arg2", 2},
            {"checker.arg1", 1}
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Arg Checking -- no args & none given", "[mapper registry]") {
    runArgsFilterTest_Success(
        { // in
        }, { // required
        }, { // optional regexes
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Arg Checking -- one required arg expected & given", "[mapper registry]") {
    runArgsFilterTest_Success(
        { // in
            {"arg1"},
        }, { // required
            {"arg1"},
        }, { // optional regexes
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Arg Checking -- two required args expected & given", "[mapper registry]") {
    runArgsFilterTest_Success(
        { // in
            {"arg1"},
            {"arg2"},
        }, { // required
            {"arg1"},
            {"arg2"},
        }, { // optional regexes
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Arg Checking -- one required arg expected & none given", "[mapper registry]") {
    runArgsFilterTest_Failure(
        { // in
        }, { // required
            {"arg1"},
        }, { // optional regexes
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Arg Checking -- two required args expected & one given", "[mapper registry]") {
    runArgsFilterTest_Failure(
        { // in
            {"arg1"},
        }, { // required
            {"arg1"},
            {"arg2"},
        }, { // optional regexes
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Arg Checking -- one optional arg allowed & none given", "[mapper registry]") {
    runArgsFilterTest_Success(
        { // in
        }, { // required
        }, { // optional regexes
            {"arg1"},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Arg Checking -- one optional arg allowed & given -- non-regex", "[mapper registry]") {
    runArgsFilterTest_Success(
        { // in
            {"arg1"},
        }, { // required
        }, { // optional regexes
            {"arg1"},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Arg Checking -- one optional arg allowed & given", "[mapper registry]") {
    runArgsFilterTest_Success(
        { // in
            {"arg1"},
        }, { // required
        }, { // optional regexes
            {"arg.*"},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Arg Checking -- two optional args allowed & given", "[mapper registry]") {
    runArgsFilterTest_Success(
        { // in
            {"arg1"},
            {"barg1"},
        }, { // required
        }, { // optional regexes
            {"arg.*"},
            {"barg.*"},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- Arg Checking -- one optional arg allowed & non-matching given", "[mapper registry]") {
    runArgsFilterTest_Failure(
        { // in
            {"barg1"},
        }, { // required
        }, { // optional regexes
            {"arg.*"},
        }
    );
}
 
SCENARIO ("MapperRegistry Test -- INI printing", "[mapper registry]") {
    MapperRegistry mr({
        {"common1", 1, "a common1 arg\n\ntesting common1"},
        {"common2", 2, "a common2 arg\n\ntesting common2"},
    });
 
    mr.registerMapper("checker", nullptr, false, "a checker", {
        {"arg1", 11, "the arg1\n\narg1 long description"},
        {"arg2", 22, "the arg2"},
        {"common1", 1, ""},
    }, {
        {"regex.*", "a regex"},
    });
 
    mr.registerMapper("checker2", nullptr, false, "a checker", {
        {"arg2", 22, "the arg2"},
        {"arg3", 33, ""},
        {"common1", 1, ""},
    }, {
        {"regex.*", "a regex"},
    });
 
    mr.registerMapper("checker3", nullptr, false, "a checker", {
        {"common1", 2, ""},
        {"common2", 2, "means something special"},
    }, {
        {"regex.*", "a regex"},
    });
 
    std::stringstream ini_dump_ss;
    mr.printDefaultsAsINI(ini_dump_ss);
 
    const auto expected = std::string(
        "#\n"
        "# Gobal settings & defaults\n"
        "#\n"
        "\n"
        "[AllMappers]\n"
        "# a common1 arg\n"
        "common1 = 1\n"
        "# a common2 arg\n"
        "common2 = 2\n"
        "\n"
        "#\n"
        "# The rest are mapper-specific & overrides\n"
        "#\n"
        "\n"
        "[checker]\n"
        "# the arg1\n"
        "arg1 = 11\n"
        "# the arg2\n"
        "arg2 = 22\n"
        "\n"
        "[checker2]\n"
        "# the arg2\n"
        "arg2 = 22\n"
        "arg3 = 33\n"
        "\n"
        "[checker3]\n"
        "common1 = 2\n"
        "# means something special\n"
        "common2 = 2\n"
    );
 
    CHECK(ini_dump_ss.str() == expected);
}
 
namespace {
 
void runArgsTest(ConfigStore in_args, ConfigStore expcected_out_args, bool expect_pass, bool is_composite) {
    MapperRegistry mr({});
    ConfigStore out_args;
 
    mr.registerMapper("checker", [&](auto&& cgra, int timeout, const ConfigStore& args) {
        out_args = args;
        return std::unique_ptr<Mapper>(std::make_unique<DummyMapper>(cgra, timeout));
    }, is_composite, "a checker", {}, { {"arg.*", ""} });
 
    auto cgra = std::make_shared<CGRA>();
    mr.createMapper("checker", cgra, 0, in_args);
 
    if (expect_pass) {
        CHECK(out_args == expcected_out_args);
    } else {
        CHECK(out_args != expcected_out_args);
    }
}
 
void runArgsFilterTest(std::vector<std::string> in_args, std::vector<std::string> required_args, std::vector<std::string> optional_regexes, bool expect_pass) {
    std::vector<ImplicitTuple<std::string, ImplicitlyToString, std::string>> required_arg_names_defaults_and_descriptions;
    for (const auto& arg : required_args) {
        required_arg_names_defaults_and_descriptions.push_back({arg, "dflt", ""});
    }
 
    std::vector<std::pair<std::string, std::string>> optional_arg_regexes_and_descriptions;
    for (const auto& regex : optional_regexes) {
        optional_arg_regexes_and_descriptions.push_back({regex, ""});
    }
 
    ConfigStore in_args_cs;
    for (const auto& arg : in_args) {
        in_args_cs.setString("checker." + arg, "in");
    }
 
    auto do_test = [&](bool is_composite) {
        WHEN ("Testing a " << (is_composite ? "" : "non-") << "composite mapper") {
            MapperRegistry mr({});
            mr.registerMapper("checker", [&](auto&& cgra, int timeout, const ConfigStore& args) {
                return std::unique_ptr<Mapper>(std::make_unique<DummyMapper>(cgra, timeout));
            }, is_composite, "a checker", required_arg_names_defaults_and_descriptions, optional_arg_regexes_and_descriptions);
 
            auto cgra = std::make_shared<CGRA>();
            if (expect_pass) {
                mr.createMapper("checker", cgra, 0, in_args_cs);
            } else {
                CHECK_THROWS(mr.createMapper("checker", cgra, 0, in_args_cs));
            }
        }
    };
 
    do_test(false);
    do_test(true);
}
 
} // end anon namespace