Question

I am currently developing a small simulation utility, using the Task Parallel Library to improve the speed at which results are produced. The simulation itself is a long, cpu intensive job which is essentially made up of thousands of smaller jobs running a simulation with different variables.

However, the resources used by each task are not released until everything has completed, leading to memory leaks and out of memory exceptions if enough variables are used. Forcing a GC at the end of each task releases resources, but my understanding is that this needs to interrupt all threads to execute, and as such results in close to single thread performance!

How can I release resources during long operations like this?

By ‘resources’ in this context I’m referring to arrays of doubles… just a lot of them.

public List<AnalysisTask> Questions; //Each variable combination is added as a Q

//Create a task for each simulation
Task<SimulationResults>[] tasks = new Task<SimulationResults>[Questions.Count]; 
foreach(var q in Questions)
{
    AnalysisTask temp = q
    tasks[taskCount] = Task.Factory.StartNew((t) =>
             {
                var result = EvaluateRules(temp);
                if(reults.Value > Leader[0].Value)
                    Leader[0] = result;
                else
                {
                    result.Dispose();
                    //This releases resources but interrupts threads
                    //GC.Collect(2, GCCollectionMode.Forced); 
                    return null;
                }
                return result;

             }
}

//Completion task
Task.Factory.ContinueWhenAll(tasks, (ant) =>
       {
          DoSomethingWithAnswer(Leader[0]);
       }

Perhaps I’ve taken the wrong approach in setting up the tasks? I’ll be grateful for any advice or direction 🙂

Answer 1

Your current implementation has a couple issues. One is that when an exchange is made with Leader[0], the previous leader’s reference is lost and it is never disposed. This could be the source of your memory leak. The second is that the comparison and assignment to Leader[0] are not done atomically. It is possible to have this sequence of events: thread 1 compares to Leader[0] and gets true with a result.Value of 1, thread 2 compares to Leader[0] and gets true with a result.Value of 2, thread 2 writes to Leader[0], thread 1 writes to Leader[0]. The result is that Leader[0] has a value of 1 when the maximal value was 2.

So if we properly dispose of references you might not need to force garbage collection. The code below fixes those issues by taking out a lock when modifying Leader and storing a reference to the previous Leader[0]. Then either the unused result or previous leader is disposed. Presumably EvaluateRules will take some time so there shouldn’t be much lock contention.

tasks[taskCount] = Task.Factory.StartNew(() =>
     {
        var result = EvaluateRules(temp);

        var toBeDisposed = result;
        lock(Leader) // should be locking on a private object
        {
           if (result.Value > Leader[0].Value)
           {
             toBeDisposed = Leader[0];
             Leader[0] = result;
           }
        }

        toBeDisposed.Dispose();       

     });

Also, do you need to be returning result from each task? You seem to only need Leader[0] for your continuation task. By returning result you are storing a reference that cannot be gc’d until the tasks themselves are gc’d.