MergeSortCooperatively()

void System.Linq.Parallel.SortHelper< TInputOutput, TKey >.MergeSortCooperatively ( )

inlineprivate

Definition at line 175 of file SortHelper.cs.

    {
        CancellationToken mergedCancellationToken = _groupState.CancellationState.MergedCancellationToken;
        int num = _sharedBarriers.Length;
        for (int i = 0; i < num; i++)
        {
            bool flag = i == num - 1;
            int num2 = ComputePartnerIndex(i);
            if (num2 >= _partitionCount)
            {
                continue;
            }
            int[] array = _sharedIndices[_partitionIndex];
            GrowingArray<TKey> growingArray = _sharedKeys[_partitionIndex];
            TKey[] internalArray = growingArray.InternalArray;
            TInputOutput[] array2 = _sharedValues[_partitionIndex];
            _sharedBarriers[i][Math.Min(_partitionIndex, num2)].SignalAndWait(mergedCancellationToken);
            if (_partitionIndex < num2)
            {
                int[] array3 = _sharedIndices[num2];
                TKey[] internalArray2 = _sharedKeys[num2].InternalArray;
                TInputOutput[] array4 = _sharedValues[num2];
                _sharedIndices[num2] = array;
                _sharedKeys[num2] = growingArray;
                _sharedValues[num2] = array2;
                int num3 = array2.Length;
                int num4 = array4.Length;
                int num5 = num3 + num4;
                int[] array5 = null;
                TInputOutput[] array6 = new TInputOutput[num5];
                if (!flag)
                {
                    array5 = new int[num5];
                }
                _sharedIndices[_partitionIndex] = array5;
                _sharedKeys[_partitionIndex] = growingArray;
                _sharedValues[_partitionIndex] = array6;
                _sharedBarriers[i][_partitionIndex].SignalAndWait(mergedCancellationToken);
                int num6 = (num5 + 1) / 2;
                int j = 0;
                int num7 = 0;
                int num8 = 0;
                for (; j < num6; j++)
                {
                    if ((j & 0x3F) == 0)
                    {
                        mergedCancellationToken.ThrowIfCancellationRequested();
                    }
                    if (num7 < num3 && (num8 >= num4 || _keyComparer.Compare(internalArray[array[num7]], internalArray2[array3[num8]]) <= 0))
                    {
                        if (flag)
                        {
                            array6[j] = array2[array[num7]];
                        }
                        else
                        {
                            array5[j] = array[num7];
                        }
                        num7++;
                    }
                    else
                    {
                        if (flag)
                        {
                            array6[j] = array4[array3[num8]];
                        }
                        else
                        {
                            array5[j] = num3 + array3[num8];
                        }
                        num8++;
                    }
                }
                if (!flag && num3 > 0)
                {
                    Array.Copy(array2, array6, num3);
                }
                _sharedBarriers[i][_partitionIndex].SignalAndWait(mergedCancellationToken);
                continue;
            }
            _sharedBarriers[i][num2].SignalAndWait(mergedCancellationToken);
            int[] array7 = _sharedIndices[_partitionIndex];
            TKey[] internalArray3 = _sharedKeys[_partitionIndex].InternalArray;
            TInputOutput[] array8 = _sharedValues[_partitionIndex];
            int[] array9 = _sharedIndices[num2];
            GrowingArray<TKey> growingArray2 = _sharedKeys[num2];
            TInputOutput[] array10 = _sharedValues[num2];
            int num9 = array8.Length;
            int num10 = array2.Length;
            int num11 = num9 + num10;
            int num12 = (num11 + 1) / 2;
            int num13 = num11 - 1;
            int num14 = num9 - 1;
            int num15 = num10 - 1;
            while (num13 >= num12)
            {
                if ((num13 & 0x3F) == 0)
                {
                    mergedCancellationToken.ThrowIfCancellationRequested();
                }
                if (num14 >= 0 && (num15 < 0 || _keyComparer.Compare(internalArray3[array7[num14]], internalArray[array[num15]]) > 0))
                {
                    if (flag)
                    {
                        array10[num13] = array8[array7[num14]];
                    }
                    else
                    {
                        array9[num13] = array7[num14];
                    }
                    num14--;
                }
                else
                {
                    if (flag)
                    {
                        array10[num13] = array2[array[num15]];
                    }
                    else
                    {
                        array9[num13] = num9 + array[num15];
                    }
                    num15--;
                }
                num13--;
            }
            if (!flag && array2.Length != 0)
            {
                growingArray2.CopyFrom(internalArray, array2.Length);
                Array.Copy(array2, 0, array10, num9, array2.Length);
            }
            _sharedBarriers[i][num2].SignalAndWait(mergedCancellationToken);
            break;
        }
    }

References System.Linq.Parallel.SortHelper< TInputOutput, TKey >._groupState, System.Linq.Parallel.SortHelper< TInputOutput, TKey >._keyComparer, System.Linq.Parallel.SortHelper< TInputOutput, TKey >._partitionCount, System.Linq.Parallel.SortHelper< TInputOutput, TKey >._partitionIndex, System.Linq.Parallel.SortHelper< TInputOutput, TKey >._sharedBarriers, System.Linq.Parallel.SortHelper< TInputOutput, TKey >._sharedIndices, System.Linq.Parallel.SortHelper< TInputOutput, TKey >._sharedKeys, System.Linq.Parallel.SortHelper< TInputOutput, TKey >._sharedValues, System.array, System.Linq.Parallel.QueryTaskGroupState.CancellationState, System.Collections.Generic.IComparer< in T >.Compare(), System.Linq.Parallel.SortHelper< TInputOutput, TKey >.ComputePartnerIndex(), System.Array.Copy(), System.Linq.Parallel.GrowingArray< T >.InternalArray, System.Linq.Parallel.CancellationState.MergedCancellationToken, System.Math.Min(), and System.Threading.Barrier.SignalAndWait().

Referenced by System.Linq.Parallel.SortHelper< TInputOutput, TKey >.Sort().