public void CopyFrom <T>(T source, Index sourceIndex)
where T : struct
{
var ptr = Interop.GetAddress(ref source);
var view = new ArrayView <T>(ptr, 1);
cache.CopyFromView(view.Cast <byte>(), AcceleratorType.CPU, sourceIndex);
}
public void CopyTo <T>(out T target, Index targetIndex)
where T : struct
{
target = default(T);
var ptr = Interop.GetAddress(ref target);
var view = new ArrayView <T>(ptr, 1);
cache.CopyToView(view.Cast <byte>(), AcceleratorType.CPU, targetIndex);
}
public unsafe void CopyFrom <T>(AcceleratorStream stream, T source, Index sourceIndex)
where T : struct
{
using (var wrapper = ViewPointerWrapper.Create(ref source))
{
var view = new ArrayView <T>(wrapper, 0, 1);
cache.CopyFromView(stream, view.Cast <byte>(), sourceIndex);
}
}
static void UnsafeAccess(ArrayView <int> view)
{
// Cast int view to a double view.
// Note that the length of the view is adapted accordingly.
var doubleView = view.Cast <double>();
Debug.Assert(doubleView.Length * sizeof(double) == view.Length * sizeof(int));
doubleView[0] = double.NaN;
// Unsafe Bitcast int view to a byte view.
// Note that the length of the view is adapted accordingly.
var byteView = view.Cast <byte>();
Debug.Assert(byteView.Length * sizeof(byte) == view.Length * sizeof(int));
for (int i = 0; i < sizeof(double); ++i)
{
Console.WriteLine($"DoubleAsByte[{i}] = {byteView[i]}");
}
}
public unsafe void CopyTo <T>(AcceleratorStream stream, out T target, Index targetIndex)
where T : struct
{
target = default;
using (var wrapper = ViewPointerWrapper.Create(ref target))
{
var view = new ArrayView <T>(wrapper, 0, 1);
cache.CopyToView(stream, view.Cast <byte>(), targetIndex);
}
}
private static void IlGpuKernelLocalMemory(
ArrayView2D <Real> mSquaredDistances,
ArrayView <Real> mCoordinates,
SpecializedValue <int> dimX,
SpecializedValue <int> c,
int n)
{
// Same as KernelConstants, but use both local and shared memory to increase the effective shared memory.
var coordinatesI = SharedMemory.Allocate <Real>(c * dimX);
var coordinatesJ = new IlReal2[c.Value];
var bI = Grid.IdxY * dimX;
var bJ = Grid.IdxX * dimX;
var line = Group.IdxX / (dimX / 2);
var tid = Group.IdxX % (dimX / 2);
var isActive = bJ + tid * 2 < n;
for (int k = 0; k != c.Value; ++k)
{
if (bI + Group.IdxX < n)
{
coordinatesI[k * dimX + Group.IdxX] = mCoordinates[k * n + bI + Group.IdxX];
}
if (isActive)
{
var mCoordinates2 = mCoordinates.Cast <IlReal2>();
coordinatesJ[k] = mCoordinates2[(k * n + bJ) / 2 + tid];
}
}
Group.Barrier();
if (isActive)
{
for (int i = line; i < dimX && bI + i < n; i += 2)
{
var dist = default(IlReal2);
for (int k = 0; k != c.Value; ++k)
{
var coord1 = coordinatesI[k * dimX + i];
var coord2 = coordinatesJ[k];
var diff = new IlReal2(coord1 - coord2.X, coord1 - coord2.Y);
dist += diff * diff;
}
var dst = mSquaredDistances.Cast <IlReal2>();
dst[bJ / 2 + tid, bI + i] = dist;
}
}
}
internal static void ArrayViewCastLargerKernel(
Index1 index,
ArrayView <long> data,
ArrayView <int> length,
ArrayView <int> source)
{
var subView = source.Cast <long>();
data[index] = subView[0];
length[index] = subView.IntLength;
}
internal static void ArrayViewCastSmallerKernel(
Index1 index,
ArrayView <byte> data,
ArrayView <int> length,
ArrayView <int> source)
{
var subView = source.Cast <byte>();
data[index] = subView[0];
length[index] = subView.IntLength;
}
