Question

The Task Parallel Library and TPL Dataflow allow one to specify the maximum degree of parallelism. That value is a cap, not a guarantee. Indeed the TPL will determine the actual degree of parallelism based on a number of factors including system resources without exceeding any programmer-specified maximum.

Is there some mechanism to determine the choices that TPL has made for the degree of parallelism at a point in time?

I’m asking specifically because I ported some fairly complex code to use TPL Dataflow, and the overall throughput is much less than the original code. I would like to look at what choices TPL has made on my behalf to understand why it is much slower.

Answer 1

I ran into a very similar situation to yours. I ended up using my logging data to tell me roughly how many threads were being used per minute. This gave me a rough number but not exact.

I don’t believe TPL can give you telemetry on its use of threads. If you wanted to implement something more exact, I would recommend implementing logic in each Task/Thread to mark some shared list of the time it started and the time it finished. Here is an example of how I would approach it to start off.

public class DoSomeTPLWork
{
    public static void Start()
    {
        List<int> numberList = Enumerable.Range(1, 1000).ToList();

        Parallel.ForEach(numberList, number =>
            {
                ThreadTracking.ThreadStarted();

                int square = number * number;
                Console.WriteLine("Square of {0} is {1}", number, square);

                ThreadTracking.ThreadFinished();
            }
        );

        var threadInfo = ThreadTracking.GetThreadInfo();
    }
}

public class ThreadTracking
{
    private static ConcurrentBag<ThreadInfo> _threadInfo = new ConcurrentBag<ThreadInfo>();

    public static void ThreadStarted()
    {
        var threadInfo = new ThreadInfo(Thread.CurrentThread.ManagedThreadId);
        threadInfo.Start();
        _threadInfo.Add(threadInfo);
    }

    public static void ThreadFinished()
    {
        var threadInfo = _threadInfo.Where(ti => ti.ThreadId == Thread.CurrentThread.ManagedThreadId && !ti.Complete).SingleOrDefault();
        if(threadInfo != null)
        {
            threadInfo.Stop();
        }
    }

    public static List<ThreadInfo> GetThreadInfo()
    {
        return _threadInfo.ToList();
    }
}

public class ThreadInfo
{
    public bool Complete { get; set; }
    public int ThreadId { get; set; }
    public DateTime? TimeStarted { get; set; }
    public DateTime? TimeFinished { get; set; }

    public ThreadInfo(int threadId)
    {
        ThreadId = threadId;
    }

    public void Start()
    {
        TimeStarted = DateTime.Now;
        Complete = false;
    }

    public void Stop()
    {
        TimeFinished = DateTime.Now;
        Complete = true;
    }
}

Using the data, you can see how many threads are being used for any given second by adding on some more methods to query the data or just popping it in Excel to play with it.