/// <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;
}
