Esempio n. 1
0
        JobHandle MergeSortedLists(JobHandle inputDeps, int sortedCount, int outputBuffer)
        {
            var pairCount           = m_Source.Length / (sortedCount * 2);
            var mergeSortedPairsJob = new MergeSortedPairs
            {
                buffer       = m_Buffer,
                source       = m_Source,
                sortedCount  = sortedCount,
                outputBuffer = outputBuffer
            };
            var mergeSortedPairsJobHandle = mergeSortedPairsJob.Schedule(pairCount, (pairCount + 1) / 8, inputDeps);
            var remainder = m_Source.Length - (pairCount * sortedCount * 2);

            if (remainder > sortedCount)
            {
                var mergeRemainderPairJob = new MergeRemainderPair
                {
                    startIndex   = pairCount * sortedCount * 2,
                    buffer       = m_Buffer,
                    source       = m_Source,
                    leftCount    = sortedCount,
                    rightCount   = remainder - sortedCount,
                    outputBuffer = outputBuffer
                };

                // There's no overlap, but write to the same array, so extra dependency:
                var mergeRemainderPairJobHandle = mergeRemainderPairJob.Schedule(mergeSortedPairsJobHandle);
                return(mergeRemainderPairJobHandle);
            }

            if (remainder > 0)
            {
                var copyRemainderPairJob = new CopyRemainder
                {
                    startIndex   = pairCount * sortedCount * 2,
                    buffer       = m_Buffer,
                    source       = m_Source,
                    outputBuffer = outputBuffer
                };

                // There's no overlap, but write to the same array, so extra dependency:
                var copyRemainderPairJobHandle = copyRemainderPairJob.Schedule(remainder, (pairCount + 1) / 8, mergeSortedPairsJobHandle);
                return(copyRemainderPairJobHandle);
            }

            return(mergeSortedPairsJobHandle);
        }
        private JobHandle MergeSortedLists(JobHandle inputDeps, int sortedCount, int sortBufferIndex)
        {
            var pairCount = m_SourceBuffer.Length / (sortedCount * 2);

            var mergeSortedPairsJobHandle = inputDeps;

            if (pairCount <= 4)
            {
                for (var i = 0; i < pairCount; i++)
                {
                    var mergeRemainderLeftJob = new MergeLeft
                    {
                        startIndex      = i * sortedCount * 2,
                        workingBuffer   = m_WorkingBuffer,
                        sourceBuffer    = m_SourceBuffer,
                        leftCount       = sortedCount,
                        rightCount      = sortedCount,
                        sortBufferIndex = sortBufferIndex
                    };
                    // There's no overlap, but write to the same array, so extra dependency:
                    mergeSortedPairsJobHandle =
                        mergeRemainderLeftJob.Schedule(sortedCount, 64, mergeSortedPairsJobHandle);

                    var mergeRemainderRightJob = new MergeRight
                    {
                        startIndex      = i * sortedCount * 2,
                        workingBuffer   = m_WorkingBuffer,
                        sourceBuffer    = m_SourceBuffer,
                        leftCount       = sortedCount,
                        rightCount      = sortedCount,
                        sortBufferIndex = sortBufferIndex
                    };
                    // There's no overlap, but write to the same array, so extra dependency:
                    mergeSortedPairsJobHandle =
                        mergeRemainderRightJob.Schedule(sortedCount, 64, mergeSortedPairsJobHandle);
                }
            }
            else
            {
                var mergeSortedPairsJob = new MergeSortedPairs
                {
                    workingBuffer   = m_WorkingBuffer,
                    sourceBuffer    = m_SourceBuffer,
                    sortedCount     = sortedCount,
                    sortBufferIndex = sortBufferIndex
                };
                mergeSortedPairsJobHandle = mergeSortedPairsJob.Schedule(pairCount, (pairCount + 1) / 8, inputDeps);
            }

            var remainder = m_SourceBuffer.Length - pairCount * sortedCount * 2;

            if (remainder > sortedCount)
            {
                var mergeRemainderLeftJob = new MergeLeft
                {
                    startIndex      = pairCount * sortedCount * 2,
                    workingBuffer   = m_WorkingBuffer,
                    sourceBuffer    = m_SourceBuffer,
                    leftCount       = sortedCount,
                    rightCount      = remainder - sortedCount,
                    sortBufferIndex = sortBufferIndex
                };
                // There's no overlap, but write to the same array, so extra dependency:
                var mergeLeftJobHandle = mergeRemainderLeftJob.Schedule(sortedCount, 64, mergeSortedPairsJobHandle);

                var mergeRemainderRightJob = new MergeRight
                {
                    startIndex      = pairCount * sortedCount * 2,
                    workingBuffer   = m_WorkingBuffer,
                    sourceBuffer    = m_SourceBuffer,
                    leftCount       = sortedCount,
                    rightCount      = remainder - sortedCount,
                    sortBufferIndex = sortBufferIndex
                };
                // There's no overlap, but write to the same array, so extra dependency:
                var mergeRightJobHandle =
                    mergeRemainderRightJob.Schedule(remainder - sortedCount, 64, mergeLeftJobHandle);
                return(mergeRightJobHandle);
            }

            if (remainder > 0)
            {
                var copyRemainderPairJob = new CopyRemainder
                {
                    startIndex      = pairCount * sortedCount * 2,
                    workingBuffer   = m_WorkingBuffer,
                    sourceBuffer    = m_SourceBuffer,
                    sortBufferIndex = sortBufferIndex
                };

                // There's no overlap, but write to the same array, so extra dependency:
                var copyRemainderPairJobHandle =
                    copyRemainderPairJob.Schedule(remainder, (pairCount + 1) / 8, mergeSortedPairsJobHandle);
                return(copyRemainderPairJobHandle);
            }

            return(mergeSortedPairsJobHandle);
        }