Оптимизация запросов Parallel Linq

Ответ 1

Здесь происходит пара вещей:

• PLINQ более эффективно распараллеливает коллекции, чем несанкционированные IEnumerables. Если у вас есть массив, он делит длину массива на ваше количество ядер процессора и выполняет их задачи равномерно. Но если у вас есть IEnumerable с неизвестной длиной, он делает тупой экспоненциальный тип разгона, где задачи будут обрабатывать элементы 1, 2, 4, 8 и т.д., Пока он не достигнет конца IEnumerable.
• Распараллеливая все ваши запросы, вы разбиваете работу на крошечные куски. Если у вас есть M параллельных запросов по N элементам, вы получаете задачи M * N. В этом больше накладных расходов, чем если бы вы просто распараллеливали последний запрос, и в этом случае у вас будет только N задач.
• PLINQ лучше всего подходит, когда каждая задача занимает примерно одинаковое количество времени для обработки. Таким образом, он может разделить их равномерно между ядрами. Распараллеливая каждый из ваших запросов с разными характеристиками производительности, у вас есть задачи M * N, которые занимают разные промежутки времени, а PLINQ не может запланировать их оптимально (поскольку он не знает заранее, сколько времени может пройти каждый).

Итак, общее руководство здесь: убедитесь, что перед запуском у вас есть массив, если это возможно, и только перед тем, как оценивать, поместите только AsParallel по самому последнему запросу. Итак, что-то вроде следующего должно работать очень хорошо:

var firstQuery = someDictionary.SelectMany().ToArray().Select(FirstTransformation);
var secondQuery = firstQuery.Select(SecondTransformation);
var thirdQuery = secondQuery.Select(ThirdTransformation).AsParallel().Where(SomeConditionCheck).ToArray();
var finalQuery = thirdQuery.Select(FinalTransformation).AsParallel().Where(x => x != null);

Ответ 2

Почти невозможно сказать, не видя фактического кода. Но в качестве общего руководства вы должны учитывать, чтобы избежать P/LINQ во время сложного числа хруста, потому что делегат и IEnumerable накладные расходы слишком высоки. Скорость, которую вы получаете с помощью потоков, очень вероятно съедена удобными абстракциями, которые предоставляет LINQ.

Вот некоторый код, который вычисляет сумму из 2 целых списков, делает некоторое int для сравнения с плавающей точкой, а затем вычисляет cos из него. Довольно простые вещи, которые можно хорошо сделать с помощью LINQ.Zip-оператора... или старомодным способом с циклом for.

Обновление 1 с обновленным ParallelLinq на моей основной машине Haswell 8

• Linq 0,95s
• Linq Parallel 0,19s
• Оптимизированный 0,45s
• Оптимизированный параллельный 0,08 с

Обновить 1 конец

• LINQ 1,65s
• Оптимизировано 0,64 с
• Оптимизированный параллельный 0,40 с

Разница во времени - это почти фактор 3 из-за IEnumerable лень и вызов вызова метода (я использовал режим Release x32 Windows 7,.NET 4 dual core). Я попытался использовать AsParallel в версии LINQ, но он действительно стал медленнее (2,3s). Если вы управляете данными, вы должны использовать конструкцию Parallel.For, чтобы получить хорошую масштабируемость. IEnumerable сам по себе является плохим кандидатом для распараллеливания, поскольку

• Вы не знаете, сколько у вас есть работы, прежде чем вы перечислили до конца.
• Вы не можете делать горячие фрагменты, потому что не знаете, как быстро IEnumerable вернет следующий элемент (может быть вызов веб-службы или доступ к индексу массива).

Ниже приведен пример кода для иллюстрации этой точки. Если вы хотите оптимизировать больше в сторону голого металла, вам нужно сначала избавиться от абстракций, которые стоят слишком дорого за каждый предмет. Доступ к массиву намного дешевле по сравнению с неинтерминированными вызовами MoveNext() и Current method.

    class Program
    {
        static void Main(string[] args)
        {
            var A = new List<int>(Enumerable.Range(0, 10*1000*1000));
            var B = new List<int>(Enumerable.Range(0, 10*1000*1000));

            double[] Actual = UseLinq(A, B);
            double[] pActual = UseLinqParallel(A, B);

            var other = Optimized(A, B);
            var pother = OptimizedParallel(A, B);
        }

        private static double[] UseLinq(List<int> A, List<int> B)
        {
            var sw = Stopwatch.StartNew();
            var Merged = A.Zip(B, (a, b) => a + b);
            var Converted = A.Select(a => (float)a);

            var Result = Merged.Zip(Converted, (m, c) => Math.Cos((double)m / ((double)c + 1)));

            double[] Actual = Result.ToArray();
            sw.Stop();

            Console.WriteLine("Linq {0:F2}s", sw.Elapsed.TotalSeconds);
            return Actual;
        }

    private static double[] UseLinqParallel(List<int> A, List<int> B)
    {
        var sw = Stopwatch.StartNew();
        var x = A.AsParallel();
        var y = B.AsParallel();

        var Merged = x.Zip(y, (a, b) => a + b);
        var Converted = x.Select(a => (float)a);

        var Result = Merged.Zip(Converted, (m, c) => Math.Cos((double)m / ((double)c + 1)));

        double[] Actual = Result.ToArray();
        sw.Stop();

        Console.WriteLine("Linq Parallel {0:F2}s", sw.Elapsed.TotalSeconds);
        return Actual;
    }        

        private static double[] OptimizedParallel(List<int> A, List<int> B)
        {
            double[] result = new double[A.Count];
            var sw = Stopwatch.StartNew();
            Parallel.For(0, A.Count, (i) =>
            {
                var sum = A[i] + B[i];
                result[i] = Math.Cos((double)sum / ((double)((float)A[i]) + 1));
            });
            sw.Stop();

            Console.WriteLine("Optimized Parallel {0:F2}s", sw.Elapsed.TotalSeconds);
            return result;
        }

        private static double[] Optimized(List<int> A, List<int> B)
        {
            double[] result = new double[A.Count];
            var sw = Stopwatch.StartNew();
            for(int i=0;i<A.Count;i++)
            {
                var sum = A[i] + B[i];
                result[i] = Math.Cos((double)sum / ((double)((float)A[i]) + 1));
            }
            sw.Stop();

            Console.WriteLine("Optimized {0:F2}s", sw.Elapsed.TotalSeconds);
            return result;
        }
    }
}