It actually does 2^cpus, as you saw. I’d have two comments for this, however. First, this was really just written as an example – I’m sure to get this completely optimal, you’d have to find the right balance here. I suspect that this does run faster with extra work (I picked those numbers after profiling) for reasons such as non-optimal pivots, uneven workloads in comparisons, and other similar issues.

That being said, it is often better to have more work items than processors. Depending on the work involved, even CPU intensive work often runs faster if given a few extra threads. It’s all about profiling your algorithm, and finding the right balance.

Given the potential lopsided-pivot problem of qsort(), is it sometimes better to choose more parallelism than CPUs “just in case” some of the problem sub-parts are much faster than the others?

The operating system will not change the affinity masks, ever. These exist so that you can explicitly tell the OS (which is now free to ignore this anyways) which processors to use. The only place where this would happen without your knowledge would be if a library set this, or if the user, as an administrator, overrides the affinity masks via the task manager or a similar tool (neither of which is likely). Personally, I think this is overkill unless you are explicitly messing with the affinity masks (which I don’t recommend doing…)

This will be the same as Environment.ProcessorCount, provided you didn’t explicitly change your processor affinity masks for your application. That being said, in general, I usually recommend leaving processor affinity alone, especially on modern operating systems (Vista & esp. W7).

The Windows process scheduler does a very good job of handling this…

While Environment.ProcessorCount does a good job at giving you the # of processors in the system, it will *not* give you the number of processors allocated to your process (which may change while the process is running!). I use this little chunk of code to give me the true number of cores my process can use:

//
// Copyright (c) 2008 All Rights Reserved
//
// Jesse C. Slicer
// jslicer@spamcop.net
// 2008-08-05
// Part of the Aesop.Diagnostics.dll assembly.

namespace Aesop.Diagnostics
{
#region Using Directives

// System namespaces
using System;
using System.Diagnostics;

#endregion

#region Class Definition : ProcessInfo

///
/// Privides a single property which gets the number of processor threads
/// available to the currently executing process.
///
internal static class ProcessInfo
{
#region Internal Static Properties

///
/// Gets the number of processors.
///
/// The number of processors.
internal static uint NumberOfProcessorThreads
{
get
{
using (Process currentProcess = Process.GetCurrentProcess())
{
uint result;

if (currentProcess == null)
{
result = (uint)Environment.ProcessorCount;
}
else
{
const uint BitsPerByte = 8;
uint loop = BitsPerByte * sizeof(uint);
uint processAffinityMask =
(uint)currentProcess.ProcessorAffinity;

result = 0;
while (loop != 0)
{
–loop;
result += processAffinityMask & 1;
processAffinityMask >>= 1;
}
}

return (result == 0) ? 1 : result;
}
}
}

#endregion
}

#endregion
}