Initial commit

include/wfr/scheduling/scheduler/dummy/DummyScheduler.h

@@ -0,0 +1,33 @@
+
+#pragma once
+
+
+#include <wfr/scheduling/AbstractScheduler.h>
+
+
+namespace wfr {
+namespace wep {
+class AtomicWepNode;
+class WEPnode;
+}
+}
+
+
+namespace wfr {
+namespace scheduling {
+
+class DummyScheduler: public wfr::scheduling::SchedulerBase {
+private:
+	resource::ResourceManager& resourceManager;
+	prediction::PredictionManager& predictionManager;
+
+public:
+	DummyScheduler(resource::ResourceManager& resourceManager, prediction::PredictionManager& predictionManager)
+			: resourceManager(resourceManager), predictionManager(predictionManager) {}
+
+	virtual void _notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set<wep::AtomicWepNode*> readyToExecute, std::unique_lock<std::mutex>& schedulerLock);
+};
+
+} /* namespace scheduling */
+} /* namespace wfr */
+

include/wfr/scheduling/scheduler/heft/HEFTScheduler.h

@@ -0,0 +1,104 @@
+
+#pragma once
+
+
+#include <wfr/scheduling/AbstractScheduler.h>
+#include <wfr/prediction/PredictionManager.h>
+#include <wfr/common/resource/Resource.h>
+#include <wfr/common/resource/ResourceManager.h>
+#include <wfr/common/types/WfrTypes.h>
+#include <mutex>
+#include <thread>
+#include <vector>
+#include <queue>
+#include <map>
+#include <set>
+#include <iostream>
+#include <condition_variable>
+
+namespace wfr {
+
+namespace wfs {
+class AtomicActivityInstance;
+}
+
+namespace wep {
+class AtomicWepNode;
+class AbstractWepNode;
+}
+namespace resource {
+class ResourceManager;
+}
+namespace prediction {
+class PredictionManager;
+}
+}
+
+
+namespace wfr {
+namespace scheduling {
+
+
+
+
+class HEFTScheduler: public scheduling::SchedulerBase {
+protected:
+	struct InstanceUserData {
+		bool isComplete = false;
+		bool isScheduled = false;
+		NumericalMeasurement rank;
+		NumericalMeasurement averageComputingCost;
+		// resourceName => (fastest implementation, prediction);
+		std::map<resource::ComputingResourceType*, std::tuple<wfs::AtomicActivityImplementation*, prediction::ExecutionTimeResult>> predictions;
+	};
+	struct SchedulingQueueEntry {
+		InstanceUserData* instanceData = nullptr;
+		wfs::AtomicActivityInstance* instance = nullptr;
+		wep::AbstractWepNode* node = nullptr;
+	};
+	struct _SchedulingQueueEntryComparison {
+		bool operator()(const SchedulingQueueEntry& e1, const SchedulingQueueEntry& e2) {
+			if (e1.instanceData && !e2.instanceData) {
+				return false;
+			} else if (!e1.instanceData && e2.instanceData) {
+				return true;
+			} else if (e1.instanceData && e2.instanceData) {
+				return e1.instanceData->rank.getValue() < e2.instanceData->rank.getValue();
+			} else {
+				return false;
+			}
+		}
+	};
+	std::priority_queue<SchedulingQueueEntry, std::vector<SchedulingQueueEntry>, _SchedulingQueueEntryComparison> schedulingPriorityQueue;
+
+
+
+	resource::ResourceManager& resourceManager;
+	prediction::PredictionManager& predictionManager;
+
+	std::vector<std::string> debugLines;
+	wfr_size_t debugIteration = 0;
+
+
+
+	NumericalMeasurement getRank(wfs::AtomicActivityInstance& ai, InstanceUserData* instanceData, const std::vector<resource::ComputingResourceType*>& resourceTypes, const std::vector<resource::ComputingResource*>& resources);
+	NumericalMeasurement getAverageExecutionCost(wfs::AtomicActivityInstance& ai, InstanceUserData* instanceData, const std::vector<resource::ComputingResourceType*>& resources);
+	NumericalMeasurement getMaxSuccValue(wfs::AtomicActivityInstance& ai, InstanceUserData* instanceData, const std::vector<resource::ComputingResourceType*>& resourceTypes, const std::vector<resource::ComputingResource*>& resources);
+
+public:
+	HEFTScheduler(resource::ResourceManager& resourceManager, prediction::PredictionManager& predictionManager)
+			: resourceManager(resourceManager), predictionManager(predictionManager) {}
+
+	~HEFTScheduler() {
+		/*for (auto s : debugLines) {
+			std::cout << s << std::endl;
+		}*/
+	}
+
+	virtual void _notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set<wep::AtomicWepNode*> readyToExecute, std::unique_lock<std::mutex>& schedulerLock);
+};
+
+} /* namespace scheduling */
+} /* namespace wfr */
+
+

include/wfr/scheduling/scheduler/justintime/JustInTimeScheduler.h

@@ -0,0 +1,34 @@
+
+#pragma once
+
+
+#include <wfr/scheduling/AbstractScheduler.h>
+
+
+namespace wfr {
+namespace wep {
+class AtomicWepNode;
+class WEPnode;
+}
+}
+
+
+namespace wfr {
+namespace scheduling {
+
+class JustInTimeScheduler: public wfr::scheduling::SchedulerBase {
+private:
+	resource::ResourceManager& resourceManager;
+	prediction::PredictionManager& predictionManager;
+	std::set<wep::AtomicWepNode*> nodeQueue;
+
+public:
+	JustInTimeScheduler(resource::ResourceManager& resourceManager, prediction::PredictionManager& predictionManager)
+			: resourceManager(resourceManager), predictionManager(predictionManager) {}
+
+	virtual void _notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set<wep::AtomicWepNode*> readyToExecute, std::unique_lock<std::mutex>& schedulerLock);
+};
+
+} /* namespace scheduling */
+} /* namespace wfr */
+

include/wfr/scheduling/scheduler/random/RandomScheduler.h

@@ -0,0 +1,34 @@
+
+#pragma once
+
+
+#include <wfr/scheduling/AbstractScheduler.h>
+
+
+namespace wfr {
+namespace wep {
+class AtomicWepNode;
+class WEPnode;
+}
+}
+
+
+namespace wfr {
+namespace scheduling {
+
+class RandomScheduler: public wfr::scheduling::SchedulerBase {
+private:
+	resource::ResourceManager& resourceManager;
+	prediction::PredictionManager& predictionManager;
+	std::set<wep::AtomicWepNode*> nodeQueue;
+
+public:
+	RandomScheduler(resource::ResourceManager& resourceManager, prediction::PredictionManager& predictionManager)
+			: resourceManager(resourceManager), predictionManager(predictionManager) {}
+
+	virtual void _notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set<wep::AtomicWepNode*> readyToExecute, std::unique_lock<std::mutex>& schedulerLock);
+};
+
+} /* namespace scheduling */
+} /* namespace wfr */
+