Почему не делает моего потокового масштаба приложения .NET линейно при выделении больших объемов памяти?

Я столкнулся с чем-то странным об эффекте выделений памяти большой емкости на масштабируемости времени выполнения .NET. В моем тестовом приложении я создаю много строк в жестком цикле для постоянного числа циклов и выкладываю уровень повторений цикла в секунду. Странность входит, когда я выполняю этот цикл в нескольких потоках – кажется, что уровень не увеличивается линейно. Проблема становится еще хуже при создании больших строк.

Позвольте мне показать Вам результаты. Моя машина составляет 8 ГБ, поле с 8 ядрами, выполняющее Windows Server 2008 R1, 32-разрядный. Это имеет два процессора Intel Xeon 1.83ghz (E5320) с 4 ядрами. Выполненная "работа" является рядом переменных вызовов к ToUpper() и ToLower() на строке. Я запускаю тест для одного потока, двух потоков, и т.д. – до максимума. Столбцы в приведенной ниже таблице:

• Уровень: количество циклов через все потоки, разделенные на продолжительность.
• Линейный Уровень: идеальный уровень, если производительность должна была масштабироваться линейно. Это вычисляется как уровень, достигнутый одним потоком, умноженным на количество потоков для того теста.
• Различие: Вычисленный как процент, которым уровень не достигает линейного уровня.

Пример 1: 10 000 циклов, 8 потоков, 1 024 символа на строку

Первый пример начинается с одним потоком, затем два потока и в конечном счете запускает тест с восемью потоками. Каждый поток создает 10 000 строк 1 024 символов каждый:

Creating 10000 strings per thread, 1024 chars each, using up to 8 threads
GCMode = Server

Rate          Linear Rate   % Variance    Threads
--------------------------------------------------------
322.58        322.58        0.00 %        1
689.66        645.16        -6.90 %       2
882.35        967.74        8.82 %        3
1081.08       1290.32       16.22 %       4
1388.89       1612.90       13.89 %       5
1666.67       1935.48       13.89 %       6
2000.00       2258.07       11.43 %       7
2051.28       2580.65       20.51 %       8
Done.

Пример 2: 10 000 циклов, 8 потоков, 32 000 символов на строку

Во втором примере я увеличил число символов для каждой строки к 32 000.

Creating 10000 strings per thread, 32000 chars each, using up to 8 threads
GCMode = Server

Rate          Linear Rate   % Variance    Threads
--------------------------------------------------------
14.10         14.10         0.00 %        1
24.36         28.21         13.64 %       2
33.15         42.31         21.66 %       3
40.98         56.42         27.36 %       4
48.08         70.52         31.83 %       5
61.35         84.63         27.51 %       6
72.61         98.73         26.45 %       7
67.85         112.84        39.86 %       8
Done.

Заметьте различие в различии от линейного уровня; во второй таблице фактический уровень является на 39% меньше, чем линейный уровень.

Мой вопрос: Почему это приложение не масштабируется линейно?

Мои наблюдения

Ложное совместное использование

Я первоначально думал, что это могло произойти из-за Ложного Совместного использования, но, как Вы будете видеть в исходном коде, я не совместно использую наборов, и строки являются довольно большими. Единственное перекрытие, которое могло существовать, в начале одной строки и конца другого.

Сборщик "мусора" режима сервера

Я использую gcServer enabled=true так, чтобы каждое ядро получило свою собственную "кучу" и поток сборщика "мусора".

"Куча" для больших объектов

Я не думаю, что возражает, что я выделяю, отправляются в "Кучу" для больших объектов, потому что они находятся под большими 85 000 байтов.

Строковое интернирование

Я думал, что строковые значения могут, будучи совместно использованным под капотом из-за interningMSDN, таким образом, я пытался компилировать отключенное интернирование. Это привело к худшим результатам, чем показанные выше

Другие типы данных

Я попробовал тот же пример с помощью маленьких и больших целочисленных массивов, в которых я циклично выполняюсь через каждый элемент и изменяю значение. Это приводит к подобным результатам, после тенденции работать хуже с большими выделениями.

Исходный код

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Diagnostics;
using System.Runtime;
using System.Runtime.CompilerServices;

namespace StackOverflowExample
{
  public class Program
  {
    private static int columnWidth = 14;

    static void Main(string[] args)
    {
      int loopCount, maxThreads, stringLength;
      loopCount = maxThreads = stringLength = 0;
      try
      {
        loopCount = args.Length != 0 ? Int32.Parse(args[0]) : 1000;
        maxThreads = args.Length != 0 ? Int32.Parse(args[1]) : 4;
        stringLength = args.Length != 0 ? Int32.Parse(args[2]) : 1024;
      }
      catch
      {
        Console.WriteLine("Usage: StackOverFlowExample.exe [loopCount] [maxThreads] [stringLength]");
        System.Environment.Exit(2);
      }

      float rate;
      float linearRate = 0;
      Stopwatch stopwatch;
      Console.WriteLine("Creating {0} strings per thread, {1} chars each, using up to {2} threads", loopCount, stringLength, maxThreads);
      Console.WriteLine("GCMode = {0}", GCSettings.IsServerGC ? "Server" : "Workstation");
      Console.WriteLine();
      PrintRow("Rate", "Linear Rate", "% Variance", "Threads"); ;
      PrintRow(4, "".PadRight(columnWidth, '-'));

      for (int runCount = 1; runCount <= maxThreads; runCount++)
      {
        // Create the workers
        Worker[] workers = new Worker[runCount];
        workers.Length.Range().ForEach(index => workers[index] = new Worker());

        // Start timing and kick off the threads
        stopwatch = Stopwatch.StartNew();
        workers.ForEach(w => new Thread(
          new ThreadStart(
            () => w.DoWork(loopCount, stringLength)
          )
        ).Start());

        // Wait until all threads are complete
        WaitHandle.WaitAll(
          workers.Select(p => p.Complete).ToArray());
        stopwatch.Stop();

        // Print the results
        rate = (float)loopCount * runCount / stopwatch.ElapsedMilliseconds;
        if (runCount == 1) { linearRate = rate; }

        PrintRow(String.Format("{0:#0.00}", rate),
          String.Format("{0:#0.00}", linearRate * runCount),
          String.Format("{0:#0.00} %", (1 - rate / (linearRate * runCount)) * 100),
          runCount.ToString()); 
      }
      Console.WriteLine("Done.");
    }

    private static void PrintRow(params string[] columns)
    {
      columns.ForEach(c => Console.Write(c.PadRight(columnWidth)));
      Console.WriteLine();
    }

    private static void PrintRow(int repeatCount, string column)
    {
      for (int counter = 0; counter < repeatCount; counter++)
      {
        Console.Write(column.PadRight(columnWidth));
      }
      Console.WriteLine();
    }
  }

  public class Worker
  {
    public ManualResetEvent Complete { get; private set; }

    public Worker()
    {
      Complete = new ManualResetEvent(false);
    }

    public void DoWork(int loopCount, int stringLength)
    {
      // Build the string
      string theString = "".PadRight(stringLength, 'a');
      for (int counter = 0; counter < loopCount; counter++)
      {
        if (counter % 2 == 0) { theString.ToUpper(); }
        else { theString.ToLower(); }
      }
      Complete.Set();
    }
  }

  public static class HandyExtensions
  {
    public static IEnumerable Range(this int max)
    {
      for (int counter = 0; counter < max; counter++)
      {
        yield return counter;
      }
    }

    public static void ForEach(this IEnumerable items, Action action)
    {
      foreach(T item in items)
      {
        action(item);
      }
    }
  }
}

Приложение. Конфигурация

Выполнение примера

Для выполнения StackOverflowExample.exe на поле назовите его с этими параметрами командной строки:

StackOverFlowExample.exe [loopCount] [maxThreads] [stringLength]

• loopCount: Количество раз каждый поток будет управлять строкой.
• maxThreads: Количество потоков для развития до.
• stringLength: количество символов для заполнения строки.