.

include/wfr/scheduling/scheduler/maxmin/MaxMinScheduler.h

@@ -0,0 +1,38 @@
+
+#pragma once
+
+
+#include <wfr/scheduling/AbstractScheduler.h>
+#include <wfr/prediction/PredictionManager.h>
+#include <wfr/scheduling/scheduler/minmin/MinMinScheduler.h>
+
+
+namespace wfr {
+namespace wep {
+class AtomicWepNode;
+class WEPnode;
+}
+namespace wfs {
+class AtomicActivityType;
+}
+}
+
+
+namespace wfr {
+namespace scheduling {
+
+class MaxMinScheduler: public MinMinScheduler {
+protected:
+	virtual std::pair<wep::AtomicWepNode*, ECTEntry> _getNextTaskToSchedule(std::map<wep::AtomicWepNode*, ECTEntry>& estimatedTaskCompletionTimes) override;
+
+
+public:
+	MaxMinScheduler(resource::ResourceManager& resourceManager, prediction::PredictionManager& predictionManager)
+			: MinMinScheduler(resourceManager, predictionManager) {}
+
+	~MaxMinScheduler() {}
+};
+
+} /* namespace scheduling */
+} /* namespace wfr */
+

include/wfr/scheduling/scheduler/minmin/MinMinScheduler.h

@@ -0,0 +1,51 @@
+
+#pragma once
+
+
+#include <wfr/scheduling/AbstractScheduler.h>
+#include <wfr/prediction/PredictionManager.h>
+
+
+namespace wfr {
+namespace wep {
+class AtomicWepNode;
+class WEPnode;
+}
+namespace wfs {
+class AtomicActivityType;
+}
+}
+
+
+namespace wfr {
+namespace scheduling {
+
+class MinMinScheduler: public wfr::scheduling::SchedulerBase {
+protected:
+	resource::ResourceManager& resourceManager;
+	prediction::PredictionManager& predictionManager;
+
+	std::map<resource::ComputingResource*, std::vector<std::shared_ptr<SchedulingDecision>>> scheduledTasks;
+
+	typedef std::map<resource::ComputingResourceType*, std::pair<wfs::AtomicActivityImplementation*, prediction::ExecutionTimeResult>> ImplementationCacheInnerMap;
+	std::map<wfs::AtomicActivityType*, ImplementationCacheInnerMap> implementationCache;
+
+	double _getResourceEstimatedAvailableTime(resource::ComputingResource* resource);
+
+	typedef std::tuple<resource::ComputingResource*, wfs::AtomicActivityImplementation*, double, prediction::ExecutionTimeResult> ECTEntry;
+	virtual std::pair<wep::AtomicWepNode*, ECTEntry> _getNextTaskToSchedule(std::map<wep::AtomicWepNode*, ECTEntry>& estimatedTaskCompletionTimes);
+
+
+public:
+	MinMinScheduler(resource::ResourceManager& resourceManager, prediction::PredictionManager& predictionManager)
+			: resourceManager(resourceManager), predictionManager(predictionManager) {}
+
+	~MinMinScheduler() {}
+
+	virtual void _notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set<wep::AtomicWepNode*> readyToExecute, std::unique_lock<std::mutex>& schedulerLock) override;
+	virtual void _notifySchedulingDecisionStatusUpdate(WepMapEntry& wepe, std::shared_ptr<SchedulingDecision> sd, std::unique_lock<std::mutex>& schedulerLock) override;
+};
+
+} /* namespace scheduling */
+} /* namespace wfr */
+

include/wfr/scheduling/scheduler/peft/PEFTScheduler.h

@@ -0,0 +1,85 @@
+
+#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 ActivityWepNode;
+class AbstractWepNode;
+}
+namespace resource {
+class ResourceManager;
+}
+namespace prediction {
+class PredictionManager;
+}
+}
+
+
+namespace wfr {
+namespace scheduling {
+
+
+class PEFTScheduler: public scheduling::SchedulerBase {
+protected:
+	resource::ResourceManager& resourceManager;
+	prediction::PredictionManager& predictionManager;
+
+	struct OptimisticCostTableEntry {
+		wfr_size_t resourceCount;
+		double* values;
+		double rank = 0;
+		bool finalized = false;
+
+		wfs::AtomicActivityImplementation** fastestImplementations;
+		prediction::ExecutionTimeResult* fastestExecutionTimes;
+
+		OptimisticCostTableEntry(wfr_size_t resourceCount) : resourceCount(resourceCount),
+				values(new double[resourceCount]), fastestImplementations(new wfs::AtomicActivityImplementation*[resourceCount]),
+				fastestExecutionTimes(new prediction::ExecutionTimeResult[resourceCount]) {}
+		~OptimisticCostTableEntry() {
+			delete[] values;
+		}
+	};
+
+	//std::map<wep::ActivityWepNode*, std::shared_ptr<OptimisticCostTableEntry>> optimisticCostTable;
+
+	std::set<wep::AtomicWepNode*> readySet;
+
+	void calcOptimisticCosts(wep::ActivityWepNode& node, std::vector<resource::ComputingResource*>& resources);
+
+	void scheduleReadySet(WepMapEntry& wepe, std::vector<resource::ComputingResource*>& resources, std::unique_lock<std::mutex>& schedulerLock);
+
+public:
+	PEFTScheduler(resource::ResourceManager& resourceManager, prediction::PredictionManager& predictionManager)
+			: resourceManager(resourceManager), predictionManager(predictionManager) {}
+
+	~PEFTScheduler() {}
+
+	virtual void _notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set<wep::AtomicWepNode*> readyToExecute, std::unique_lock<std::mutex>& schedulerLock) override;
+	virtual void _notifySchedulingDecisionStatusUpdate(WepMapEntry& wepe, std::shared_ptr<SchedulingDecision> sd, std::unique_lock<std::mutex>& schedulerLock) override;
+};
+
+} /* namespace scheduling */
+} /* namespace wfr */
+
+

include/wfr/scheduling/scheduler/sufferage/SufferageScheduler.h

@@ -0,0 +1,51 @@
+
+#pragma once
+
+
+#include <wfr/scheduling/AbstractScheduler.h>
+#include <wfr/prediction/PredictionManager.h>
+
+
+namespace wfr {
+namespace wep {
+class AtomicWepNode;
+class WEPnode;
+}
+namespace wfs {
+class AtomicActivityType;
+}
+}
+
+
+namespace wfr {
+namespace scheduling {
+
+class SufferageScheduler: public wfr::scheduling::SchedulerBase {
+protected:
+	resource::ResourceManager& resourceManager;
+	prediction::PredictionManager& predictionManager;
+
+	std::map<resource::ComputingResource*, std::vector<std::shared_ptr<SchedulingDecision>>> scheduledTasks;
+
+	typedef std::map<resource::ComputingResourceType*, std::pair<wfs::AtomicActivityImplementation*, prediction::ExecutionTimeResult>> ImplementationCacheInnerMap;
+	std::map<wfs::AtomicActivityType*, ImplementationCacheInnerMap> implementationCache;
+
+	double _getResourceEstimatedAvailableTime(resource::ComputingResource* resource);
+
+	typedef std::tuple<resource::ComputingResource*, wfs::AtomicActivityImplementation*, double, prediction::ExecutionTimeResult> ECTEntry;
+	std::pair<wep::AtomicWepNode*, ECTEntry> _getNextTaskToSchedule(std::map<wep::AtomicWepNode*, ECTEntry>& estimatedTaskCompletionTimes);
+
+
+public:
+	SufferageScheduler(resource::ResourceManager& resourceManager, prediction::PredictionManager& predictionManager)
+			: resourceManager(resourceManager), predictionManager(predictionManager) {}
+
+	~SufferageScheduler() {}
+
+	virtual void _notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set<wep::AtomicWepNode*> readyToExecute, std::unique_lock<std::mutex>& schedulerLock) override;
+	virtual void _notifySchedulingDecisionStatusUpdate(WepMapEntry& wepe, std::shared_ptr<SchedulingDecision> sd, std::unique_lock<std::mutex>& schedulerLock) override;
+};
+
+} /* namespace scheduling */
+} /* namespace wfr */
+