Why would I be getting such poor performance from the code below?
The following command line uses 16 threads, with a load of 60. On my machine this takes approximately 31 seconds to finish (with some slight variations if you rerun)
testapp.exe 16 60
Using a load of 60, on Microsoft Windows Server 2008 R2 Enterprise SP1, running on 16 Intel Xeon E5-2670 @ 2.6 GHz CPUs I get the following performance:
1 cpu - 305 seconds
2 cpus - 155 seconds
4 cpus - 80 seconds
8 cpus - 45 seconds
10 cpus - 41 seconds
12 cpus - 37 seconds
14 cpus - 34 seconds
16 cpus - 31 seconds
18 cpus - 27 seconds
20 cpus - 24 seconds
22 cpus - 23 seconds
24 cpus - 21 seconds
26 cpus - 20 seconds
28 cpus - 19 seconds
After this it flat-lines ...
I get approximately the same performance using .Net 3.5, 4, 4.5 or 4.5.1.
I understand the drop-off in performance after 22 cpus, as I only have 16 on the box. What I don't understand is the poor performance after 8 cpus. Can anyone explain? Is this normal?
private static void Main(string[] args)
{
int threadCount;
if (args == null || args.Length < 1 || !int.TryParse(args[0], out threadCount))
threadCount = Environment.ProcessorCount;
int load;
if (args == null || args.Length < 2 || !int.TryParse(args[1], out load))
load = 1;
Console.WriteLine("ThreadCount:{0} Load:{1}", threadCount, load);
List<Thread> threads = new List<Thread>();
for (int i = 0; i < threadCount; i++)
{
int i1 = i;
threads.Add(new Thread(() => DoWork(i1, threadCount, load)));
}
Stopwatch timer = Stopwatch.StartNew();
foreach (var thread in threads)
{
thread.Start();
}
foreach (var thread in threads)
{
thread.Join();
}
timer.Stop();
Console.WriteLine("Time:{0} seconds", timer.ElapsedMilliseconds/1000.0);
}
static void DoWork(int seed, int threadCount, int load)
{
double[,] mtx = new double[3,3];
for (int i = 0; i < ((100000 * load)/threadCount); i++)
{
for (int j = 0; j < 100; j++)
{
mtx = new double[3,3];
for (int k = 0; k < 3; k++)
{
for (int l = 0; l < 3; l++)
{
mtx[k, l] = Math.Sin(j + (k*3) + l + seed);
}
}
}
}
}
new double[,]arrays in the starting thread, pass each one to each child thread and then reuse it instead of reallocating it in the loop or (2)stackallocadouble[3 * 3]in the loops and use that. Otherwise, you may be accidentally benchmarking the performance of the memory allocator or the garbage collector under rapid allocations, instead of your code per se.