.

include/wfr/common/wfs/Workflow.h

@@ -66,6 +66,9 @@ private:
 	wfr::wfr_timestamp_sc_t startTime;
 	wfr::wfr_timestamp_sc_t endTime;
 
+	unsigned lastWepNodeCount = 0;
+	wfr::wfr_timestamp_sc_t wepCompletedTime;
+
 	#ifdef WFR_ENABLE_STATISTICS
 		std::mutex statMutex;
 
@@ -190,10 +193,13 @@ public:
 	const wfr::wfr_timestamp_sc_t& getStartTime() const noexcept { return startTime; }
 	const wfr::wfr_timestamp_sc_t& getEndTime() const noexcept { return endTime; }
 	wfr::wfr_duration_sc_t getWorkflowDuration() const noexcept { return endTime - startTime; };
+	wfr::wfr_duration_sc_t getTimeTillWepCompletion() const noexcept { return wepCompletedTime - startTime; };
 	wfr::wfr_duration_sc_t getMakespan() const noexcept { return endTime - createTime; };
 
 	#ifdef WFR_ENABLE_STATISTICS
 
+		void updateWepStatistics() noexcept;
+
 		wfr::wfr_duration_sc_t getEnactmentTime() const noexcept { return enactmentTime; }
 		void addToEnactmentTime(wfr::wfr_duration_sc_t time) {
 			std::lock_guard<std::mutex> lock(statMutex);

include/wfr/scheduling/scheduler/cpop/CPOPScheduler.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 CPOPScheduler: public scheduling::SchedulerBase {
+protected:
+	resource::ResourceManager& resourceManager;
+	prediction::PredictionManager& predictionManager;
+
+	struct TaskRankEntry {
+		double rankU = 0;
+		double rankD = 0;
+		double priority = 0;
+		bool finalizedU = false;
+		bool finalizedD = false;
+
+		wfs::AtomicActivityImplementation** fastestImplementations;
+		prediction::ExecutionTimeResult* fastestExecutionTimes;
+		double averageExecutionTime = 0.0;
+
+		TaskRankEntry(wfr_size_t resourceCount) : fastestImplementations(new wfs::AtomicActivityImplementation*[resourceCount]),
+				fastestExecutionTimes(new prediction::ExecutionTimeResult[resourceCount]) {}
+	};
+
+	std::set<wep::AtomicWepNode*> readySet;
+
+	void calcTaskRankD(wep::ActivityWepNode& node, std::vector<resource::ComputingResource*>& resources);
+
+	void calcTaskRankU(wep::ActivityWepNode& node, std::vector<resource::ComputingResource*>& resources);
+
+	void scheduleReadySet(WepMapEntry& wepe, std::set<wep::ActivityWepNode*>& cpTasks, resource::ComputingResource* cpResource,
+			std::vector<resource::ComputingResource*>& resources, std::unique_lock<std::mutex>& schedulerLock);
+
+public:
+	CPOPScheduler(resource::ResourceManager& resourceManager, prediction::PredictionManager& predictionManager)
+			: resourceManager(resourceManager), predictionManager(predictionManager) {}
+
+	~CPOPScheduler() {}
+
+	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;
+	virtual void _unregisterWEP(WepMapEntry& wepe, std::unique_lock<std::mutex>& schedulerLock) override;
+};
+
+} /* namespace scheduling */
+} /* namespace wfr */
+
+

include/wfr/scheduling/scheduler/hcpt/HCPTScheduler.h

@@ -0,0 +1,81 @@
+
+#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 HCPTScheduler: public scheduling::SchedulerBase {
+protected:
+	resource::ResourceManager& resourceManager;
+	prediction::PredictionManager& predictionManager;
+
+	struct TaskRankEntry {
+		double aest = 0;
+		double alst = 0;
+		bool aestFinalized = false;
+		bool alstFinalized = false;
+
+		wfs::AtomicActivityImplementation** fastestImplementations;
+		prediction::ExecutionTimeResult* fastestExecutionTimes;
+		double averageExecutionTime = 0.0;
+
+		TaskRankEntry(wfr_size_t resourceCount) : fastestImplementations(new wfs::AtomicActivityImplementation*[resourceCount]),
+				fastestExecutionTimes(new prediction::ExecutionTimeResult[resourceCount]) {}
+	};
+
+	std::set<wep::AtomicWepNode*> readySet;
+
+	void calcTaskRanks(wep::ActivityWepNode& node, std::vector<resource::ComputingResource*>& resources);
+
+	void scheduleReadySet(WepMapEntry& wepe, std::vector<resource::ComputingResource*>& resources, std::unique_lock<std::mutex>& schedulerLock);
+
+public:
+	HCPTScheduler(resource::ResourceManager& resourceManager, prediction::PredictionManager& predictionManager)
+			: resourceManager(resourceManager), predictionManager(predictionManager) {}
+
+	~HCPTScheduler() {}
+
+	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;
+	virtual void _unregisterWEP(WepMapEntry& wepe, std::unique_lock<std::mutex>& schedulerLock) override;
+};
+
+} /* namespace scheduling */
+} /* namespace wfr */
+
+

include/wfr/scheduling/scheduler/justintime2/JustInTime2Scheduler.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 JustInTime2Scheduler: public wfr::scheduling::SchedulerBase {
+private:
+	resource::ResourceManager& resourceManager;
+	prediction::PredictionManager& predictionManager;
+	std::set<wep::AtomicWepNode*> nodeQueue;
+
+public:
+	JustInTime2Scheduler(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/wep/utils/WepSearch.h

@@ -17,15 +17,23 @@ namespace wep {
 
 template<typename VisitType>
 void wepDepthFirstSearch(wfr::wep::AbstractWepNode* startNode, const VisitType& visitFunction,
-		std::set<wfr::wep::AbstractWepNode*>& visitedNodes = std::set<wfr::wep::AbstractWepNode*>()) {
-	visitedNodes.insert(startNode);
+		std::set<wfr::wep::AbstractWepNode*>* visitedNodes = nullptr) {
+	bool deleteVisitedNodeSet = false;
+	if (visitedNodes == nullptr) {
+		visitedNodes = new std::set<wfr::wep::AbstractWepNode*>();
+		deleteVisitedNodeSet = true;
+	}
+	visitedNodes->insert(startNode);
 	if (visitFunction(startNode)) {
 		for (auto c : startNode->getSuccessors()) {
-			if (visitedNodes.find(c) == visitedNodes.end()) {
+			if (visitedNodes->find(c) == visitedNodes->end()) {
 				wepDepthFirstSearch(c, visitFunction, visitedNodes);
 			}
 		}
 	}
+	if (deleteVisitedNodeSet) {
+		delete visitedNodes;
+	}
 }