Initial commit

src/scheduling/SchedulerManager.cpp

@@ -0,0 +1,107 @@
+
+#include <wfr/scheduling/SchedulerManager.h>
+#include <wfr/scheduling/AbstractScheduler.h>
+#include <wfr/common/exceptions/exceptions.h>
+#include <iostream>
+#include <boost/program_options.hpp>
+#include <boost/format.hpp>
+#include <wfr/prediction/PredictionManager.h>
+#include <wfr/common/resource/ResourceManager.h>
+#include <wfr/scheduling/scheduler/dummy/DummyScheduler.h>
+#include <wfr/scheduling/scheduler/heft/HEFTScheduler.h>
+#include <wfr/scheduling/scheduler/random/RandomScheduler.h>
+#include <wfr/scheduling/scheduler/justintime/JustInTimeScheduler.h>
+
+namespace wfr {
+namespace scheduling {
+
+
+SchedulerManager* SchedulerManager::singleton = nullptr;
+
+
+void SchedulerManager::init(int argc, char** argv) {
+    std::string defaultScheduler = "dummy";
+
+    boost::program_options::options_description opts("SchedulerFactory Options");
+    opts.add_options()
+    	    ("help", "Print help message.")
+    	    ("list-schedulers", "List available schedulers.")
+    		("default-scheduler", boost::program_options::value<std::string>(), "Set the default scheduler.");
+    boost::program_options::variables_map vm;
+    auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run();
+    boost::program_options::store(parsed, vm);
+    boost::program_options::notify(vm);
+    if (vm.count("help")) {
+    	std::cerr << opts << std::endl;
+    	return;
+    }
+    if (vm.count("default-scheduler")) {
+    	defaultScheduler = vm["default-scheduler"].as<std::string>();
+    	std::cerr << "Default scheduler is set to \""<< defaultScheduler << "\"." << std::endl;
+    }
+
+	singleton = new SchedulerManager(defaultScheduler);
+
+	if (vm.count("list-schedulers")) {
+		std::cerr << "Available schedulers:" << std::endl;
+		for (auto item : singleton->schedulerFactories) {
+			std::cerr << "\t" << item.first << std::endl;
+		}
+		exit(0);
+	}
+}
+
+void SchedulerManager::finish() {
+	if (singleton != nullptr) {
+		delete singleton;
+		singleton = nullptr;
+	}
+}
+
+SchedulerManager& SchedulerManager::getInstance() {
+	if (singleton == nullptr) {
+		throw wfr::exception::wfr_missing_instance("ResourceManager instance not found.");
+	}
+	return *singleton;
+}
+
+
+SchedulerManager::SchedulerManager(std::string defaultScheduler) : defaultScheduler(defaultScheduler) {
+    schedulerFactories.insert(factoryMap_t::value_type("dummy", []()->AbstractScheduler* {
+    	return new DummyScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
+    }));
+    schedulerFactories.insert(factoryMap_t::value_type("heft", []()->AbstractScheduler* {
+    	return new HEFTScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
+    }));
+    schedulerFactories.insert(factoryMap_t::value_type("random", []()->AbstractScheduler* {
+    	return new RandomScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
+    }));
+    schedulerFactories.insert(factoryMap_t::value_type("jit", []()->AbstractScheduler* {
+    	return new JustInTimeScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
+    }));
+    if (schedulerFactories.find(defaultScheduler) == schedulerFactories.end()) {
+    	throw wfr::exception::wfr_fatal_error((boost::format("Default scheduler \"%1%\" does not exist.") % defaultScheduler).str());
+    }
+}
+
+AbstractScheduler* SchedulerManager::getDefaultScheduler() {
+	return getSchedulerByName(defaultScheduler);
+}
+
+AbstractScheduler* SchedulerManager::getSchedulerByName(std::string& name) {
+	auto scheduler = schedulerFactories.find(name);
+	if (scheduler != schedulerFactories.end()) {
+		return scheduler->second();
+	} else {
+		throw wfr::exception::wfr_illegal_argument((boost::format("Could not find scheduler \"%1%\".") % name).str());
+	}
+}
+
+void SchedulerManager::markSchedulerForDeletion(AbstractScheduler* scheduler) {
+	delete scheduler;
+}
+
+} /* namespace scheduling */
+} /* namespace wfr */
+
+