/// <summary> /// Waits for tasks to finish, executes post-functions and then returns control to Unity and the rest of KSP /// </summary> /// <param name="group">Threading group being waited on</param> void WaitForTheadingGroupToFinish(KSPTSThreadingGroup group) { _threadPool.SetUrgent(group); int numPostFuncsRemaining = _postFunctionsRemaining[group]; Queue <KSPTSParametrizedPostFunction> postFunctionQueue = _postFunctions[group]; while (numPostFuncsRemaining > 0) { KSPTSParametrizedPostFunction tmp; lock (locker) { while (postFunctionQueue.Count == 0) { Monitor.Wait(locker); } tmp = postFunctionQueue.Dequeue(); } numPostFuncsRemaining--; if (tmp.postFunction != null) { tmp.postFunction(tmp.parameter); } } }
//This is used for setting ACROSS_LOOP updates to finish by the end of the frame, but is set up to accept any switching internal void SwapQueues(KSPTSThreadingGroup group1, KSPTSThreadingGroup group2) { Queue <KSPTSParametrizedTask> tmpQueue = taskQueues[group1]; taskQueues[group1] = taskQueues[group2]; taskQueues[group2] = tmpQueue; }
internal void SwapQueues(KSPTSThreadingGroup group1, KSPTSThreadingGroup group2) { lock(locker) { _tasks.SwapQueues(group1, group2); } }
internal void SetUrgent(KSPTSThreadingGroup urgentGroup) { lock (locker) { _tasks.SetUrgent(urgentGroup); } }
internal void SwapQueues(KSPTSThreadingGroup group1, KSPTSThreadingGroup group2) { lock (locker) { _tasks.SwapQueues(group1, group2); } }
internal void SetUrgent(KSPTSThreadingGroup urgentGroup) { lock (locker) { _tasks.SetUrgent(urgentGroup); } }
internal KSPTSParametrizedTask(Func <object, object> func, object parameter, Action <object> postFunction, KSPTSThreadingGroup threadingGroup) { this.action = func; this.parameter = parameter; this.postFunction = postFunction; this.threadingGroup = threadingGroup; }
internal KSPTSParametrizedTask(Func<object, object> func, object parameter, Action<object> postFunction, KSPTSThreadingGroup threadingGroup) { this.action = func; this.parameter = parameter; this.postFunction = postFunction; this.threadingGroup = threadingGroup; }
internal void EnqueueNewTask(Func<object, object> newTask, object newParameter, Action<object> newPostFunction, KSPTSThreadingGroup group) { KSPTSParametrizedTask _paraAction = new KSPTSParametrizedTask(newTask, newParameter, newPostFunction, group); lock(locker) { _tasks.Enqueue(_paraAction, group); Monitor.Pulse(locker); } }
/// <summary> /// Attempts to unregister threadedTask from the specified threadingGroup /// </summary> /// <param name="threadingGroup">Determines which loop to synchronize with and when</param> /// <param name="threadedTask">Task that takes an object as a parameter and returns an object</param> /// <returns>Success?</returns> public static bool TryUnregisterThreadTask(KSPTSThreadingGroup threadingGroup, Func<object, object> threadedTask) { KSPTSRegisteredTasks registeredTasks = KSPTSThreadController.instance.registeredTasks; List<KSPTSTaskGroup> taskGroupList = null; if(registeredTasks._groupTasks.TryGetValue(threadingGroup, out taskGroupList)) return TryRemoveThreadedTask(taskGroupList, threadedTask); Debug.LogError("KSPTS Error: Could not find specified Threading Group Task List"); return false; }
/// <summary> /// Attempts to unregister threadedTask from the specified threadingGroup /// </summary> /// <param name="threadingGroup">Determines which loop to synchronize with and when</param> /// <param name="threadedTask">Task that takes an object as a parameter and returns an object</param> /// <returns>Success?</returns> public static bool TryUnregisterThreadTask(KSPTSThreadingGroup threadingGroup, Func <object, object> threadedTask) { KSPTSRegisteredTasks registeredTasks = KSPTSThreadController.instance.registeredTasks; List <KSPTSTaskGroup> taskGroupList = null; if (registeredTasks._groupTasks.TryGetValue(threadingGroup, out taskGroupList)) { return(TryRemoveThreadedTask(taskGroupList, threadedTask)); } Debug.LogError("KSPTS Error: Could not find specified Threading Group Task List"); return(false); }
/// <summary> /// Queues up all registered tasks and sends them to the thread pool to be processed /// </summary> /// <param name="group">Threading group to queue tasks for</param> void QueueThreadingGroupTasks(KSPTSThreadingGroup group) { List <KSPTSTaskGroup> tmpTaskGroupList = registeredTasks._groupTasks[group]; for (int i = 0; i < tmpTaskGroupList.Count; i++) { KSPTSTaskGroup tmpTaskGroup = tmpTaskGroupList[i]; object tmpObject = null; if (tmpTaskGroup.preFunction != null) { tmpObject = tmpTaskGroup.preFunction(); } _threadPool.EnqueueNewTask(tmpTaskGroup.threadedTask, tmpObject, tmpTaskGroup.postFunction, group); } _postFunctionsRemaining[group] = tmpTaskGroupList.Count; }
internal void EnqueueNewTask(Func <object, object> newTask, object newParameter, Action <object> newPostFunction, KSPTSThreadingGroup group) { KSPTSParametrizedTask _paraAction = new KSPTSParametrizedTask(newTask, newParameter, newPostFunction, group); lock (locker) { _tasks.Enqueue(_paraAction, group); Monitor.Pulse(locker); } }
/// <summary> /// Internal task registration method /// </summary> /// <param name="threadingGroup">Determines which loop to synchronize with and when</param> /// <param name="newTaskGroup">Class holding all pre-function, threadedTask, and post-function data</param> internal static void RegisterNewThreadTask(KSPTSThreadingGroup threadingGroup, KSPTSTaskGroup newTaskGroup) { KSPTSRegisteredTasks registeredTasks = KSPTSThreadController.instance.registeredTasks; registeredTasks._groupTasks[threadingGroup].Add(newTaskGroup); }
/// <summary> /// Register a task with a pre-function to run in the main Unity thread before starting the threadedTask and a post-function to run in the main Unity thread after finishing the threadedTask /// </summary> /// <param name="threadingGroup">Determines which loop to synchronize with and when</param> /// <param name="preFunction">Method that returns an object passed to the threadedTask as a parameter; run in the main Unity thread before threadedTask is started</param> /// <param name="threadedTask">Task that takes an object as a parameter and returns an object</param> /// <param name="postFunction">Void Method that takes an object as a parameter and is run in the main Unity thread after threadedTask completes</param> public static void RegisterNewThreadTask(KSPTSThreadingGroup threadingGroup, Func<object> preFunction, Func<object, object> threadedTask, Action<object> postFunction) { KSPTSTaskGroup newTaskGroup = new KSPTSTaskGroup(preFunction, threadedTask, postFunction); RegisterNewThreadTask(threadingGroup, newTaskGroup); }
internal void SetUrgent(KSPTSThreadingGroup urgentGroup) { urgentQueue = urgentGroup; urgent = true; }
/// <summary> /// Waits for tasks to finish, executes post-functions and then returns control to Unity and the rest of KSP /// </summary> /// <param name="group">Threading group being waited on</param> void WaitForTheadingGroupToFinish(KSPTSThreadingGroup group) { _threadPool.SetUrgent(group); int numPostFuncsRemaining = _postFunctionsRemaining[group]; Queue<KSPTSParametrizedPostFunction> postFunctionQueue = _postFunctions[group]; while (numPostFuncsRemaining > 0) { KSPTSParametrizedPostFunction tmp; lock (locker) { while (postFunctionQueue.Count == 0) Monitor.Wait(locker); tmp = postFunctionQueue.Dequeue(); } numPostFuncsRemaining--; if (tmp.postFunction != null) tmp.postFunction(tmp.parameter); } }
/// <summary> /// Queues up post-function with relevant data for execution in WaitForTheadingGroupToFinish() /// </summary> /// <param name="postFunction">function to be executed using data from completed threadedTask</param> /// <param name="parameter">data from completed threadedTask</param> /// <param name="group">this function's thread group</param> internal void EnqueuePostFunction(Action<object> postFunction, object parameter, KSPTSThreadingGroup group) { KSPTSParametrizedPostFunction tmpPostFunc = new KSPTSParametrizedPostFunction(postFunction, parameter); Queue<KSPTSParametrizedPostFunction> tmpQueue = _postFunctions[group]; lock(locker) { tmpQueue.Enqueue(tmpPostFunc); Monitor.Pulse(locker); } }
internal void SetUrgent(KSPTSThreadingGroup urgentGroup) { urgentQueue = urgentGroup; urgent = true; }
/// <summary> /// Register a task with a post-function to run in the main Unity thread after finishing the threadedTask /// </summary> /// <param name="threadingGroup">Determines which loop to synchronize with and when</param> /// <param name="threadedTask">Task that takes an object as a parameter and returns an object</param> /// <param name="postFunction">Void Method that takes an object as a parameter and is run in the main Unity thread after threadedTask completes</param> public static void RegisterNewThreadTask(KSPTSThreadingGroup threadingGroup, Func <object, object> threadedTask, Action <object> postFunction) { RegisterNewThreadTask(threadingGroup, null, threadedTask, postFunction); }
internal void Enqueue(KSPTSParametrizedTask newTask, KSPTSThreadingGroup group) { taskQueues[group].Enqueue(newTask); _hasTasks = true; }
/// <summary> /// Queues up post-function with relevant data for execution in WaitForTheadingGroupToFinish() /// </summary> /// <param name="postFunction">function to be executed using data from completed threadedTask</param> /// <param name="parameter">data from completed threadedTask</param> /// <param name="group">this function's thread group</param> internal void EnqueuePostFunction(Action <object> postFunction, object parameter, KSPTSThreadingGroup group) { KSPTSParametrizedPostFunction tmpPostFunc = new KSPTSParametrizedPostFunction(postFunction, parameter); Queue <KSPTSParametrizedPostFunction> tmpQueue = _postFunctions[group]; lock (locker) { tmpQueue.Enqueue(tmpPostFunc); Monitor.Pulse(locker); } }
internal void Enqueue(KSPTSParametrizedTask newTask, KSPTSThreadingGroup group) { taskQueues[group].Enqueue(newTask); _hasTasks = true; }
/// <summary> /// Internal task registration method /// </summary> /// <param name="threadingGroup">Determines which loop to synchronize with and when</param> /// <param name="newTaskGroup">Class holding all pre-function, threadedTask, and post-function data</param> internal static void RegisterNewThreadTask(KSPTSThreadingGroup threadingGroup, KSPTSTaskGroup newTaskGroup) { KSPTSRegisteredTasks registeredTasks = KSPTSThreadController.instance.registeredTasks; registeredTasks._groupTasks[threadingGroup].Add(newTaskGroup); }
/// <summary> /// Register a task with a pre-function to run in the main Unity thread before starting the threadedTask and a post-function to run in the main Unity thread after finishing the threadedTask /// </summary> /// <param name="threadingGroup">Determines which loop to synchronize with and when</param> /// <param name="preFunction">Method that returns an object passed to the threadedTask as a parameter; run in the main Unity thread before threadedTask is started</param> /// <param name="threadedTask">Task that takes an object as a parameter and returns an object</param> /// <param name="postFunction">Void Method that takes an object as a parameter and is run in the main Unity thread after threadedTask completes</param> public static void RegisterNewThreadTask(KSPTSThreadingGroup threadingGroup, Func <object> preFunction, Func <object, object> threadedTask, Action <object> postFunction) { KSPTSTaskGroup newTaskGroup = new KSPTSTaskGroup(preFunction, threadedTask, postFunction); RegisterNewThreadTask(threadingGroup, newTaskGroup); }
/// <summary> /// Register a task with a pre-function to run in the main Unity thread before starting the threadedTask /// </summary> /// <param name="threadingGroup">Determines which loop to synchronize with and when</param> /// <param name="preFunction">Method that returns an object passed to the threadedTask as a parameter; run in the main Unity thread before threadedTask is started</param> /// <param name="threadedTask">Task that takes an object as a parameter and returns an object</param> public static void RegisterNewThreadTask(KSPTSThreadingGroup threadingGroup, Func<object> preFunction, Func<object, object> threadedTask) { RegisterNewThreadTask(threadingGroup, preFunction, threadedTask, null); }
/// <summary> /// Queues up all registered tasks and sends them to the thread pool to be processed /// </summary> /// <param name="group">Threading group to queue tasks for</param> void QueueThreadingGroupTasks(KSPTSThreadingGroup group) { List<KSPTSTaskGroup> tmpTaskGroupList = registeredTasks._groupTasks[group]; for (int i = 0; i < tmpTaskGroupList.Count; i++) { KSPTSTaskGroup tmpTaskGroup = tmpTaskGroupList[i]; object tmpObject = null; if (tmpTaskGroup.preFunction != null) tmpObject = tmpTaskGroup.preFunction(); _threadPool.EnqueueNewTask(tmpTaskGroup.threadedTask, tmpObject, tmpTaskGroup.postFunction, group); } _postFunctionsRemaining[group] = tmpTaskGroupList.Count; }
/// <summary> /// Register a task with a post-function to run in the main Unity thread after finishing the threadedTask /// </summary> /// <param name="threadingGroup">Determines which loop to synchronize with and when</param> /// <param name="threadedTask">Task that takes an object as a parameter and returns an object</param> /// <param name="postFunction">Void Method that takes an object as a parameter and is run in the main Unity thread after threadedTask completes</param> public static void RegisterNewThreadTask(KSPTSThreadingGroup threadingGroup, Func<object, object> threadedTask, Action<object> postFunction) { RegisterNewThreadTask(threadingGroup, null, threadedTask, postFunction); }
/// <summary> /// Register a task with a pre-function to run in the main Unity thread before starting the threadedTask /// </summary> /// <param name="threadingGroup">Determines which loop to synchronize with and when</param> /// <param name="preFunction">Method that returns an object passed to the threadedTask as a parameter; run in the main Unity thread before threadedTask is started</param> /// <param name="threadedTask">Task that takes an object as a parameter and returns an object</param> public static void RegisterNewThreadTask(KSPTSThreadingGroup threadingGroup, Func <object> preFunction, Func <object, object> threadedTask) { RegisterNewThreadTask(threadingGroup, preFunction, threadedTask, null); }
//This is used for setting ACROSS_LOOP updates to finish by the end of the frame, but is set up to accept any switching internal void SwapQueues(KSPTSThreadingGroup group1, KSPTSThreadingGroup group2) { Queue<KSPTSParametrizedTask> tmpQueue = taskQueues[group1]; taskQueues[group1] = taskQueues[group2]; taskQueues[group2] = tmpQueue; }