createMappingGraphFromConfig_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/Mapping.h>
#include <CGRA/MappingProcedures.h>
#include <CGRA/Module.h>
 
#include "testutils/OpGraphsForTesting.hpp"
 
#include <iostream>
 
#include <catch2/catch.hpp>
 
SCENARIO("createMappingGraphFromConfig tests") {
    GIVEN("an empty mapping") {
        std::shared_ptr<OpGraph> og = std::make_shared<OpGraph>(makeDFG_Linear3Node()); // Simple DFG a -> b -> c
 
        Mapping mapping(nullptr, 1, og);
 
        MRRG mrrg(1);
        Module fillerMod("Mod", "");
 
        auto m1 = mrrg.insert(MRRGNode::make_function(&fillerMod, 32, 0, "m1", 0, {})).first;
        auto m2 = mrrg.insert(MRRGNode::make_routing(&fillerMod, 32, 0, "m2", 0)).first;
        auto m3 = mrrg.insert(MRRGNode::make_function(&fillerMod, 32, 0, "m3", 0, {})).first;
        auto m4 = mrrg.insert(MRRGNode::make_function(&fillerMod, 32, 0, "m4", 0, {})).first;
        auto m5 = mrrg.insert(MRRGNode::make_function(&fillerMod, 32, 0, "m5", 0, {})).first;
 
        WHEN("a simple config graph is given") {
            ConfigGraph cg;
            auto v1 = cg.insert("m1",
            {
                {"maps_to_op", "op_a"},
                {"name", "m1"},
                {"cycle", "0"}
            }).first;
            auto v2 = cg.insert("m2",
            {
                {"maps_to_val", "op_a_out"},
                {"name", "m2"},
                {"cycle", "0"}
            }).first;
            auto v3 = cg.insert("m3",
            {
                {"maps_to_val", "op_a_out"},
                {"name", "m3"},
                {"cycle", "0"}
            }).first;
            auto v4 = cg.insert("m4",
            {
                {"maps_to_op", "op_b"},
                {"name", "m4"},
                {"cycle", "0"}
            }).first;
 
            cg.link(v1, v2);
            cg.link(v2, v3);
            cg.link(v3, v4);
 
            auto cmg = createMappingGraphFromConfig(mapping, cg, *og, mrrg);
 
            THEN("Mapping should be as expected") {
                // Check Mapping
                CHECK(mapping.getMapping().size() == 3);
                CHECK(mapping.getSingleMapping(og->getOp("op_a")) == m1);
 
                std::set<MRRG::NodeDescriptor> expected = std::set<MRRG::NodeDescriptor>{m2, m3};
                const auto actual = std::set<MRRG::NodeDescriptor>(mapping.getMapping()[og->getVal("op_a_out")].begin(), mapping.getMapping()[og->getVal("op_a_out")].end());
                CHECK(expected == actual);
 
                CHECK(mapping.getSingleMapping(og->getOp("op_b")) == m4);
 
                // Check links
                CHECK(cmg.mg.fanout(cmg.fromMRRG[m1])[0] == cmg.fromMRRG[m2]);
                CHECK(cmg.mg.fanout(cmg.fromMRRG[m2])[0] == cmg.fromMRRG[m3]);
                CHECK(cmg.mg.fanout(cmg.fromMRRG[m3])[0] == cmg.fromMRRG[m4]);
            }
        }
    }
}