/// <summary>
/// Creates a new page-locked 1D array.
/// </summary>
/// <param name="accelerator">The parent accelerator.</param>
/// <param name="extent">The number of elements to allocate.</param>
/// <param name="uninitialized">True, to allocate an uninitialized array.</param>
internal unsafe PageLockedArray1D(
Accelerator accelerator,
LongIndex1D extent,
bool uninitialized)
{
if (extent < 0L)
{
throw new ArgumentOutOfRangeException(nameof(extent));
}
#if NET5_0
array = uninitialized
? GC.AllocateUninitializedArray <T>(extent.ToIntIndex(), pinned: true)
: GC.AllocateArray <T>(extent.ToIntIndex(), pinned: true);
fixed(T *ptr = array)
Initialize(accelerator, new IntPtr(ptr), extent);
#else
Trace.WriteLineIf(
uninitialized,
RuntimeErrorMessages.NotSupportedUninitalizedArrayInitialization);
array = new T[extent];
handle = GCHandle.Alloc(array, GCHandleType.Pinned);
Initialize(accelerator, handle.AddrOfPinnedObject(), extent);
#endif
}
/// <summary>
/// Computes the required number of temp-storage elements of type
/// <typeparamref name="T"/> for a unique operation and the given data length.
/// </summary>
/// <param name="accelerator">The accelerator.</param>
/// <param name="dataLength">The number of data elements to scan.</param>
/// <returns>
/// The required number of temp-storage elements in 32 bit ints.
/// </returns>
public static LongIndex1D ComputeUniqueTempStorageSize <T>(
this Accelerator accelerator,
LongIndex1D dataLength)
where T : unmanaged
{
// 1 int for SequentialGroupExecutor.
return(1);
}
public readonly void Execute(LongIndex1D linearIndex)
{
if (linearIndex >= Source.Length)
{
return;
}
Target[linearIndex] = Transformer.Transform(Source[linearIndex]);
}
public readonly void Execute(LongIndex1D linearIndex)
{
if (linearIndex >= View.Length)
{
return;
}
View[linearIndex] = Value;
}
public readonly void Execute(LongIndex1D linearIndex)
{
if (linearIndex >= Data.Length)
{
return;
}
Data[linearIndex] = ToLong((ulong)Data[linearIndex]);
}
public void Execute(LongIndex1D linearIndex)
{
if (linearIndex >= Input.Length)
{
return;
}
ReducedValue = GetReduction().Apply(ReducedValue, Input[linearIndex]);
}
internal static void ArrayViewLongLeaIndexKernel(
Index1D index,
ArrayView1D <int, Stride1D.Dense> data,
ArrayView1D <int, Stride1D.Dense> source)
{
LongIndex1D longIndex = index;
data[longIndex] = source[longIndex];
}
/// <summary>
/// Computes the required number of temp-storage elements of type <typeparamref name="T"/>
/// for a scan operation and the given data length.
/// </summary>
/// <param name="accelerator">The accelerator.</param>
/// <param name="dataLength">The number of data elements to scan.</param>
/// <returns>The required number of temp-storage elements in 32 bit ints.</returns>
public static LongIndex1D ComputeScanTempStorageSize <T>(
this Accelerator accelerator,
LongIndex1D dataLength)
where T : unmanaged
{
return(accelerator.AcceleratorType switch
{
AcceleratorType.CPU => 1,
AcceleratorType.Cuda => ComputeNumIntElementsForSinglePassScan <T>(),
_ => Interop.ComputeRelativeSizeOf <int, T>(accelerator.MaxNumGroupsExtent.Item1 + 1),
});
public SequenceImplementation(
LongIndex1D sequenceLength,
LongIndex1D sequenceBatchLength,
ArrayView1D <T, TStride> view,
TSequencer sequencer)
{
SequenceLength = sequenceLength;
SequenceBatchLength = sequenceBatchLength;
View = view;
Sequencer = sequencer;
}
public readonly void Execute(LongIndex1D linearIndex)
{
if (linearIndex >= View.Length)
{
return;
}
long sequenceIndex = (linearIndex / SequenceBatchLength)
% SequenceLength;
View[linearIndex] = Sequencer.ComputeSequenceElement(sequenceIndex);
}
/// <summary>
/// Computes a new sequence of batched values of length sequenceBatchLength, and
/// writes the computed values to the given view. Afterwards, the target view will
/// contain the following values:
/// - [0, sequenceBatchLength - 1] = 0,,
/// - [sequenceBatchLength, sequenceBatchLength * 2 -1] = 1,
/// - ...
/// </summary>
/// <typeparam name="T">The element type.</typeparam>
/// <typeparam name="TSequencer">The type of the sequencer to use.</typeparam>
/// <param name="accelerator">The accelerator.</param>
/// <param name="stream">The accelerator stream.</param>
/// <param name="view">The target view.</param>
/// <param name="sequenceBatchLength">The length of a single batch.</param>
/// <param name="sequencer">The used sequencer.</param>
public static void BatchedSequence <T, TSequencer>(
this Accelerator accelerator,
AcceleratorStream stream,
ArrayView <T> view,
LongIndex1D sequenceBatchLength,
TSequencer sequencer)
where T : unmanaged
where TSequencer : struct, ISequencer <T> =>
accelerator.CreateBatchedSequencer <T, Stride1D.Dense, TSequencer>()(
stream,
view,
sequenceBatchLength,
sequencer);
/// <summary>
/// Computes a new repeated sequence of values from 0 to sequenceLength, from 0 to
/// sequenceLength, ... and writes the computed values to the given view.
/// Afterwards, the target view will contain the following values:
/// - [0, sequenceLength - 1] = [0, sequenceLength]
/// - [sequenceLength, sequenceLength * 2 -1] = [0, sequenceLength]
/// - ...
/// </summary>
/// <typeparam name="T">The element type.</typeparam>
/// <typeparam name="TStride">The 1D stride of the view.</typeparam>
/// <typeparam name="TSequencer">The type of the sequencer to use.</typeparam>
/// <param name="accelerator">The accelerator.</param>
/// <param name="stream">The accelerator stream.</param>
/// <param name="view">The target view.</param>
/// <param name="sequenceLength">The length of a single sequence.</param>
/// <param name="sequencer">The used sequencer.</param>
public static void RepeatedSequence <T, TStride, TSequencer>(
this Accelerator accelerator,
AcceleratorStream stream,
ArrayView1D <T, TStride> view,
LongIndex1D sequenceLength,
TSequencer sequencer)
where T : unmanaged
where TStride : struct, IStride1D
where TSequencer : struct, ISequencer <T> =>
accelerator.CreateRepeatedSequencer <T, TStride, TSequencer>()(
stream,
view,
sequenceLength,
sequencer);
/// <summary cref="ISequencer{T}.ComputeSequenceElement(LongIndex1D)" />
public readonly double ComputeSequenceElement(LongIndex1D sequenceIndex) =>
sequenceIndex;
/// <summary cref="ISequencer{T}.ComputeSequenceElement(LongIndex1D)" />
public readonly float ComputeSequenceElement(LongIndex1D sequenceIndex) =>
sequenceIndex;
/// <summary cref="ISequencer{T}.ComputeSequenceElement(LongIndex1D)" />
public readonly Half ComputeSequenceElement(LongIndex1D sequenceIndex) =>
(Half)sequenceIndex.X;
/// <summary cref="ISequencer{T}.ComputeSequenceElement(LongIndex1D)" />
public readonly Index1D ComputeSequenceElement(LongIndex1D sequenceIndex) =>
(Index1D)sequenceIndex;
/// <summary> /// Returns the i-th element of the attached <see cref="ViewSource"/>. /// </summary> public readonly T ComputeSequenceElement(LongIndex1D sequenceIndex) => ViewSource[sequenceIndex];
internal ScanProvider(Accelerator accelerator, LongIndex1D dataLength)
: base(accelerator)
{
tempBuffer = accelerator.Allocate1D <int>(dataLength);
}
/// <summary>
/// Constructs a new custom sequencer.
/// </summary>
/// <param name="secondOffset">The base offset for the second element.</param>
public CustomSequencer(LongIndex1D secondOffset)
{
SecondOffset = secondOffset;
}
/// <summary cref="ISequencer{T}.ComputeSequenceElement(Index1)"/>
public int ComputeSequenceElement(LongIndex1D sequenceIndex) => MaxValue - sequenceIndex.ToIntIndex();
/// <summary>
/// Creates a new page-locked 1D array.
/// </summary>
/// <param name="accelerator">The parent accelerator.</param>
/// <param name="extent">The number of elements to allocate.</param>
internal PageLockedArray1D(Accelerator accelerator, LongIndex1D extent)
: this(accelerator, extent, false)
{
}
/// <summary>
/// Computes the sequence element for the corresponding <paramref name="sequenceIndex"/>.
/// </summary>
/// <param name="sequenceIndex">The sequence index for the computation of the corresponding value.</param>
/// <returns>The computed sequence value.</returns>
public CustomStruct ComputeSequenceElement(LongIndex1D sequenceIndex) =>
new CustomStruct()
{
First = sequenceIndex,
Second = SecondOffset + sequenceIndex
};
/// <summary>
/// Creates a page locked array in CPU memory optimized for GPU data exchange.
/// </summary>
/// <typeparam name="T">The element type.</typeparam>
/// <param name="accelerator">The associated accelerator.</param>
/// <param name="extent">The number of elements.</param>
/// <param name="uninitialized">True, to skip data initialization.</param>
/// <returns>The allocated array.</returns>
public static PageLockedArray1D <T> AllocatePageLockedArray1D <T>(
this Accelerator accelerator,
LongIndex1D extent,
bool uninitialized)
where T : unmanaged =>
new PageLockedArray1D <T>(accelerator, extent, uninitialized);
/// <summary> /// Returns a reference to the i-th element on the CPU. /// </summary> /// <param name="index">The element index.</param> /// <returns>A reference to the i-th element on the CPU.</returns> public ref T this[LongIndex1D index] => ref CPUView[index];
