GEEKING

Base/include/rbx/Tasks/Coordinator.h

@@ -0,0 +1,99 @@
+
+#pragma once
+
+#include "rbx/TaskScheduler.h"
+#include <map>
+
+namespace RBX
+{
+	namespace Tasks
+	{
+		// Prevents jobs from running according to some coordination logic.
+		// Generally a Coordinator will affect execution order but not
+		// affect parallelism. It may be more efficient to enforce resource
+		// locks by specializing the TaskScheduler. See the DataModel scheduler.
+		class RBXBaseClass Coordinator
+		{
+		public:
+			// These functions must be written in a thread-safe manner
+			// However, no 2 threads will call a function with the same job
+
+			virtual bool isInhibited(TaskScheduler::Job* job) = 0;
+			virtual void onPreStep(TaskScheduler::Job* job) {}	
+			virtual void onPostStep(TaskScheduler::Job* job) {}
+			virtual void onAdded(TaskScheduler::Job* job) {}
+			virtual void onRemoved(TaskScheduler::Job* job) {}
+		};
+
+		// Prevents jobs from running in parallel
+		class Exclusive : public Coordinator
+		{
+			volatile TaskScheduler::Job* runningJob;
+		public:
+			Exclusive():runningJob(NULL) {}
+			virtual bool isInhibited(TaskScheduler::Job* job);
+			virtual void onPreStep(TaskScheduler::Job* job);
+			virtual void onPostStep(TaskScheduler::Job* job);
+			virtual void onAdded(TaskScheduler::Job* job) {}
+			virtual void onRemoved(TaskScheduler::Job* job) {}
+		};
+
+		// Requires that all coordinated jobs finish stepping before any job steps again.
+		// It is the task-equivalent of a thread barrier.
+		class Barrier : public Coordinator
+		{
+			unsigned int counter;
+			unsigned int remainingTasks;
+			RBX::mutex mutex;
+			std::map<TaskScheduler::Job*, unsigned int> jobs;
+
+			void releaseBarrier();
+		public:
+			Barrier():counter(0),remainingTasks(0) {}
+			virtual bool isInhibited(TaskScheduler::Job* job);
+			virtual void onPostStep(TaskScheduler::Job* job);
+			virtual void onAdded(TaskScheduler::Job* job);
+			virtual void onRemoved(TaskScheduler::Job* job);
+		};
+
+		class SequenceBase : public Coordinator 
+		{
+		private:
+			unsigned int nextJobIndex;
+			RBX::mutex mutex;
+			std::vector<TaskScheduler::Job*> jobs;
+		protected:
+			void advance();
+		public:
+			SequenceBase():nextJobIndex(0) {}
+			virtual bool isInhibited(TaskScheduler::Job* job);
+			virtual void onAdded(TaskScheduler::Job* job);
+			virtual void onRemoved(TaskScheduler::Job* job);
+		};		
+		
+		// Requires that all coordinated jobs execute in sequence.
+		// Jobs are allowed to run in parallel, but they must start
+		// execution in the sequence in which they are added to the
+		// coordinator
+		class Sequence : public SequenceBase
+		{
+		public:
+			virtual void onPreStep(TaskScheduler::Job* job) {
+				advance();
+			}
+		};
+
+		// Requires that all coordinated jobs execute in sequence.
+		// Jobs are *not* allowed to run in parallel.
+		// This is equivalent to Exclusive and Sequence combined
+		class ExclusiveSequence : public SequenceBase
+		{
+		public:
+			virtual void onPostStep(TaskScheduler::Job* job) {
+				advance();
+			}
+		};
+
+
+	}
+}