如何在当前线程上启动任务（强制内联）

Question

Here's the situation: I have a computation pipeline, in a WPF application, which is full of small nodes that makes different calculations. It is in fact a tree of those nodes which computations depends on the results of other nodes' computations. Each node, when its dependencies changes, will trigger a recomputation by starting a task. So if I have a 1000 nodes in my graph. When one of the nodes changes at the bottom of the tree, it could happen that all the nodes need to recompute, each starting a task and waiting for the results of its child nodes to complete.

Symptoms: In certain situations, the computation pipeline seems to be "hanging" and taking a very long time to do simple calculation (normally would take less than a second, but could take from 30 seconds to 15 minutes) By profiling, I noticed that the CPU is quite available, and that all the threads are simply waiting for the results of the child nodes. No one is doing calculation when having a breakpoint.

In my limited knowledge of the ThreadPool and TaskScheduler, is seems that the tasks that would be doing work are just far away in the queue, and thus everyone is just waiting. Doesn't look like a deadlock, since it will resume at some point. I guess I need to start less tasks, or to boost the ThreadPool's number of min thread to like 400 and then the problem disappears (but I prefer obviously the first solution)

Here's a quick glance on how I request the node's result (not actual code, since mine is bigger with thread safety and basic plumbing).

public T GetOrComputeValue()
{
    return GetOrComputeValueAsync().Result;
}

public Task<T> GetOrComputeValueAsync()
{
     // If we are not flagged as dirty, then we can return the last 
     // computation-task, which is either waiting to be started yet, 
     // still busy computing or might already have finished long ago. 
     if (!IsDirty && (_computationTask != null))
         return _pendingRecomputationTask ?? _computationTask;

     IsDirty = false;
     _computationTask = Task.Run( _computationFunc);
 }

So notice that a synchronous call will just call the Async version, which starts a new Task and wait for the result. We made it like this so that if we have a synchronous "Get" call, followed by an Async call (before the sync call finished), we want to return the Synchronous Task's result.

The basic usage is from the UI Thread, we call the Async version of the top Computation Nodes (very few calls) and those nodes, in Tasks, will call the Synchronous version.

So, the origin of my question:
- Let's say a node's Task is already in a different thread than the UI thread, and it requests the result of a child node, can I ask that this child's task be inlined in the current thread instead of scheduling it? Thus reducing the number of tasks sent to the TaskScheduler?

Or any other ideas? Or I'm missing the point completely?!

Answer 1

The fact that you are sending allot of tasks to the scheduler is not the problem, the problem is that you are (if I understand your scenario correctly) letting asynchronous code block synchronously to wait for the result of another asynchronous call, which in fact could cause a deadlock if your thread pool gets depleted.

My recommendation would be to make _computationFunc be of type Func<Task<T>> and it would immediately eliminate the need to call the synchronous GetOrComputeValue within a child node. If the child (leaf) node has no need to be an asynchronous calculation you could simple return its result with Task.FromResult

I would also suggest you use the async and await coding pattern to make your life much easier.

EDIT: Regarding to your question about inlining the tasks on the current thread: in my opinion you should not be needing to if you follow my suggestion. But in order to inline a task would require writing your own task scheduler , but even then you will only be able to inline tasks that are not executing already (you cannot inline something that is already running)