public hVoxelChunk(Accelerator device, Vec3 position, int width, int height, int depth, int maxViewDist, int[] materialIDs)
{
this.device = device;
this.position = position - new Vec3(width / 2f, 0, depth / 2f);
this.width = width;
this.depth = depth;
this.height = height;
this.maxViewDist = maxViewDist;
this.materialIDs = materialIDs;
tiles = new int[width, height, depth];
Random rng = new Random(5);
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
for (int z = 0; z < depth; z++)
{
tiles[x, y, z] = rng.NextDouble() < 0.25 ? rng.Next(1, materialIDs.Length) : 0;
}
}
}
d_tiles = device.Allocate <int>(new Index3(width, height, depth));
d_tiles.CopyFrom(tiles, new Index3(), new Index3(), d_tiles.Extent);
d_materialIDs = device.Allocate <int>(materialIDs.Length);
d_materialIDs.CopyFrom(materialIDs, 0, 0, materialIDs.Length);
}
public void Dispose()
{
_dataset?.Dispose();
_datasetV?.Dispose();
_datasetVByte?.Dispose();
_datasetV = null;
}
public void ConvertToByteRepresentation(ref WriteableBitmap bmp, short maxValue)
{
if (maxValue == 0)
{
return;
}
var d = _datasetVByte;
d?.Dispose();
_datasetVByte = null;
uint[] data;
(_datasetVByte, data) = CalculationWrappers.ConvertToByteRepresentation(_datasetV.View, maxValue);
bmp = new WriteableBitmap(new PixelSize(_datasetVByte.Width, _datasetVByte.Height), new Vector(1, 1), Avalonia.Platform.PixelFormat.Rgba8888);
if (data != null)
{
using (var buf = bmp.Lock())
{
IntPtr ptr = buf.Address;
Marshal.Copy((int[])(object)data, 0, ptr, data.Length);
}
}
}
internal static void WheightAdjustment(
Action <AcceleratorStream, Index2, ArrayView3D <float>, ArrayView2D <float>, ArrayView2D <float>, ArrayView2D <float>, ArrayView <float> > action,
Index2 extent, MemoryBuffer3D <float> weights, MemoryBuffer2D <float> error, MemoryBuffer2D <float> activatedPreviousLayer, MemoryBuffer2D <float> bias, MemoryBuffer <float> variables
)
{
action(accelerator.DefaultStream, extent, weights, error, activatedPreviousLayer, bias, variables);
}
internal static void SumCalculate(
Action <AcceleratorStream, Index2, ArrayView3D <float>, ArrayView2D <float>, ArrayView2D <float>, ArrayView2D <float>, ArrayView <float> > action,
Index2 extent, MemoryBuffer3D <float> weights, MemoryBuffer2D <float> outputPreviousLayerActivated, MemoryBuffer2D <float> sumInput, MemoryBuffer2D <float> bias, MemoryBuffer <float> variables
)
{
action(accelerator.DefaultStream, extent, weights, outputPreviousLayerActivated, sumInput, bias, variables);
}
public void LoadDatasetInVideoMemory()
{
int w = width,
h = height,
d = depth;
short[] buffer = new short[w * h * d];
var bands = Enumerable.Range(1, d).ToArray();
_dataset.ReadRaster(0, 0, w, h, buffer, w, h, d, bands, 0, 0, 0);
_datasetV = GpuContext.Instance.Accelerator.Allocate <short>(w, h, d);
_datasetV.CopyFrom(buffer, 0, Index3.Zero, buffer.Length);
}
public hVoxelChunk(Accelerator device, Vec3 position, int width, int depth, int height, int maxViewDist, int[] materialIDs, int[,,] tiles)
{
this.device = device;
this.position = position;
this.width = width;
this.depth = depth;
this.height = height;
this.tiles = tiles;
this.maxViewDist = maxViewDist;
this.materialIDs = materialIDs;
d_tiles = device.Allocate <int>(new Index3(width, height, depth));
d_tiles.CopyFrom(tiles, new Index3(), new Index3(), d_tiles.Extent);
}
/// <summary>
/// Saves a 3DMemoryBuffer.
/// </summary>
protected void SaveBuffer(StreamWriter writer, MemoryBuffer3D<float> buffer, int sliceIndex, string name) {
if (buffer.Equals(GPUHelper.dummyBuffer2D)) return;
writer.WriteLine("buffer3D: " + name + " sliceIndex: " + sliceIndex);
var arr = buffer.GetAs3DArray();
var xBound = arr.GetUpperBound(0) + 1; var yBound = arr.GetUpperBound(1) + 1; var zBound = arr.GetUpperBound(1) + 1;
writer.WriteLine("xBound: " + xBound + " yBound: " + yBound + " zBound: " + zBound);
for (int x = 0; x < xBound; x++) {
for (int y = 0; y < yBound; y++) {
for (int z = 0; z < zBound; z++) {
writer.Write(arr[x, y, z] + " ");
}
}
}
}
public RandomLayer2D(Layer2D prevLayer, int sliceCount, int maxConnectionsPerNeuron) : base(prevLayer, null, sliceCount)
{
var x = (int)prevLayer.GetActivatedBuffer(0).Extent.X;
var y = (int)prevLayer.GetActivatedBuffer(0).Extent.Y;
var fac = GetSuitableFactorForFunction(function, x * y);
var weightFactory = new RandomMatrixFactory(x, y, maxConnectionsPerNeuron, RandomMatrixFactory.GenerationType.Float);
var conFactory = new RandomMatrixFactory(x, y, maxConnectionsPerNeuron * 2, RandomMatrixFactory.GenerationType.Integer, maxConnectionsPerNeuron);
connectionInfo = new MemoryBuffer3D <int> [sliceCount];
newConnectionInfo = new MemoryBuffer3D <int> [sliceCount];
for (int i = 0; i < sliceCount; i++)
{
float[] source = { Config.learningRate, fac };
this.variable[i] = GPUHelper.CreateBuffer(source, 2);
this.bias[i] = GPUHelper.CreateBuffer(x, y);
this.activated[i] = GPUHelper.CreateBuffer(x, y);
this.sumInput[i] = GPUHelper.CreateBuffer(x, y);
this.error[i] = GPUHelper.CreateBuffer(x, y);
this.weight[i] = GPUHelper.CreateBuffer(x, y, maxConnectionsPerNeuron);
this.derived[i] = GPUHelper.CreateBuffer(x, y);
bool b = true;
while (b)
{
if (conFactory.intQueue3D.Count > 1)
{
b = false;
}
}
int[,,] arr;
conFactory.intQueue3D.TryDequeue(out arr);
this.connectionInfo[i] = GPUHelper.CreateBuffer(arr, x, y, maxConnectionsPerNeuron * 2);
conFactory.intQueue3D.TryDequeue(out arr);
this.newConnectionInfo[i] = GPUHelper.CreateBuffer(arr, x, y, maxConnectionsPerNeuron * 2);
}
var extent = connectionInfo[0].Extent;
}
public static void Execute(int[,] clusters)
{
using (MemoryBuffer2D <int> clusterBuff = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(clusters.GetLength(0), clusters.GetLength(1)))
{
clusterBuff.CopyFrom(clusters, Index2.Zero, Index2.Zero, clusterBuff.Extent);
using (MemoryBuffer3D <int> diffs = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(clusterBuff.Extent.X, clusterBuff.Extent.X, 5))
using (MemoryBuffer2D <int> bests = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(clusterBuff.Extent.X, 3 + clusterBuff.Extent.X))
{
bool change = true;
while (change)
{
change = false;
diffs.MemSetToZero();
bests.MemSetToZero();
kernel(new Index2(clusterBuff.Extent.X, clusterBuff.Extent.X), clusterBuff, diffs);
HardwareAcceleratorManager.GPUAccelerator.Synchronize();
kernelBests(bests.Extent.X, diffs, bests);
HardwareAcceleratorManager.GPUAccelerator.Synchronize();
int[,] best = new int[bests.Extent.X, bests.Extent.Y];
bests.CopyTo(best, Index2.Zero, Index2.Zero, bests.Extent);
int eq = -1;
int diffl = -1;
int ts = -1;
for (int i = 0; i < best.GetLength(0); i++)
{
if (best[i, 0] > eq)
{
eq = best[i, 0];
diffl = best[i, 1];
ts = best[i, 2];
}
else if (best[i, 0] == eq && best[i, 1] > diffl)
{
diffl = best[i, 1];
ts = best[i, 2];
}
else if (best[i, 0] == eq && best[i, 1] == diffl && ts < best[i, 2])
{
ts = best[i, 2];
}
}
if (eq >= 0)
{
change = true;
List <int> bestofbest = new List <int>();
List <int> bestofbestID = new List <int>();
for (int i = 0; i < best.GetLength(0); i++)
{
if (eq == best[i, 0] && diffl == best[i, 1] && ts == best[i, 2])
{
for (int j = 3; j < best.GetLength(1); j++)
{
if (best[i, j] < 0)
{
break;
}
else
{
bestofbest.Add(i);
bestofbestID.Add(best[i, j]);
}
}
}
}
int[] bob1 = bestofbest.ToArray();
int[] bob2 = bestofbestID.ToArray();
int[] bob3 = new int[bob1.Length];
bool repeated;
for (int i = 0, k = 0; i < bob1.Length; i++)
{
bob3[i] = bob1[i];
repeated = false;
for (int j = 0; j < i; j++)
{
if (bob3[i] == bob3[j])
{
repeated = true;
}
}
if (repeated)
{
for (int j = k; j < bob2.Length; j++)
{
repeated = false;
for (int q = 0; q < i; q++)
{
if (bob3[q] == bob2[j])
{
repeated = true;
break;
}
}
if (!repeated)
{
bob3[i] = bob2[j];
k = j;
break;
}
}
}
}
using (MemoryBuffer <int> bobbuff1 = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(bestofbest.Count))
using (MemoryBuffer <int> bobbuff2 = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(bestofbestID.Count))
using (MemoryBuffer <int> newPos = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(bestofbest.Count))
using (MemoryBuffer2D <int> newPals = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(bestofbestID.Count, clusterBuff.Extent.Y))
{
newPals.MemSetToZero();
bobbuff1.CopyFrom(bob1, 0, 0, bobbuff1.Extent);
bobbuff2.CopyFrom(bob2, 0, 0, bobbuff2.Extent);
newPos.CopyFrom(bob3, 0, 0, newPos.Extent);
kernelInvalidateCluster(bobbuff1.Extent, bobbuff1, bobbuff2, newPals, clusterBuff);
HardwareAcceleratorManager.GPUAccelerator.Synchronize();
kernelCopyNewPal(newPos.Extent, newPos, newPals, clusterBuff);
HardwareAcceleratorManager.GPUAccelerator.Synchronize();
kernelFilter(bobbuff1.Extent, bobbuff1, newPos, clusterBuff);
HardwareAcceleratorManager.GPUAccelerator.Synchronize();
kernelFilter(bobbuff2.Extent, bobbuff2, newPos, clusterBuff);
HardwareAcceleratorManager.GPUAccelerator.Synchronize();
}
kernelRemoveRepeated(new Index2(clusterBuff.Extent.X, clusterBuff.Extent.X), clusterBuff);
HardwareAcceleratorManager.GPUAccelerator.Synchronize();
}
}
}
clusterBuff.CopyTo(clusters, Index2.Zero, Index2.Zero, clusterBuff.Extent);
}
}
internal static void CreateAccelerator(Boolean debugMode)
{
context = new Context(
ContextFlags.EnableParallelCodeGenerationInFrontend
);
context.EnableAlgorithms();
List <Accelerator> accelerators = new List <Accelerator>();
Accelerator cpuAccl = null;
foreach (var acceleratorId in Accelerator.Accelerators)
{
accelerator = Accelerator.Create(context, acceleratorId);
accelerators.Add(accelerator);
if (accelerator.AcceleratorType == AcceleratorType.CPU)
{
cpuAccl = accelerator;
}
}
for (int i = 0; i < accelerators.Count; i++)
{
var accl = accelerators.ElementAt(i);
if (cpuAccl != accl)
{
accelerator = accl;
}
}
if (accelerator == null)
{
throw new Exception("No compitable device found.");
}
if (debugMode)
{
accelerator = cpuAccl;
}
if (debugMode)
{
Logger.WriteLine("Debug Mode - Enabled");
}
if (accelerator == cpuAccl)
{
Logger.WriteLine("Performing operations on CPU Accelerator");
}
else
{
Logger.WriteLine("Performing operations on " + accelerator.Name);
}
reusableInputBuffer = new Queue <MemoryBuffer2D <float> >();
reusableOutputBuffer = new Queue <MemoryBuffer2D <float> >();
kernels = new List <Kernel>();
buffers1DInt = new List <MemoryBuffer <int> >();
buffers2DInt = new List <MemoryBuffer2D <int> >();
buffers3DInt = new List <MemoryBuffer3D <int> >();
buffers1DFloat = new List <MemoryBuffer <float> >();
buffers2DFloat = new List <MemoryBuffer2D <float> >();
buffers3DFloat = new List <MemoryBuffer3D <float> >();
dummyBuffer1D = CreateBuffer(1);
dummyBuffer2D = GPUHelper.accelerator.Allocate <float>(1, 1);
dummyBuffer3D = GPUHelper.accelerator.Allocate <float>(1, 1, 1);
}
public static void Execute(ConcurrentDictionary <ConcurrentDictionary <Int32, int>, ConcurrentDictionary <TileKey, int> > tilesperPal, ConcurrentDictionary <TileKey, ConcurrentDictionary <Int32, int> > tilePals)
{
int l = 0;
TileKey[] tilespositions = new TileKey[tilePals.Count];
int i = 0;
foreach (var kvp in tilePals)
{
tilespositions[i] = kvp.Key;
i++;
}
foreach (var kvp in tilesperPal)
{
if (kvp.Key.Count > l)
{
l = kvp.Key.Count;
}
}
int[,] pals = new int[tilesperPal.Count, l];
Parallel.For(0, pals.GetLength(0), k =>
{
Parallel.For(0, pals.GetLength(1), q =>
{
pals[k, q] = 0;
});
});
i = 0;
int j;
int[,] tilepals = new int[tilePals.Count, l];
l = 0;
foreach (var kvp1 in tilesperPal)
{
j = 0;
foreach (var kvp2 in kvp1.Key)
{
pals[i, j] = kvp2.Key;
j++;
}
if (kvp1.Value.Count > l)
{
l = kvp1.Value.Count;
}
i++;
}
int[,] tilesPerPal = new int[tilesperPal.Count, l];
Parallel.For(0, tilepals.GetLength(0), k =>
{
Parallel.For(0, tilepals.GetLength(1), q =>
{
tilepals[k, q] = 0;
});
});
Parallel.For(0, tilesPerPal.GetLength(0), k =>
{
Parallel.For(0, tilesPerPal.GetLength(1), q =>
{
tilesPerPal[k, q] = -1;
});
});
i = 0;
foreach (var kvp1 in tilePals)
{
j = 0;
foreach (var kvp2 in kvp1.Value)
{
tilepals[i, j] = kvp2.Key;
j++;
}
i++;
}
i = 0;
foreach (var kvp1 in tilesperPal)
{
j = 0;
foreach (var kvp2 in kvp1.Value)
{
for (int k = 0; k < tilespositions.GetLength(0); k++)
{
if (kvp2.Key.X == tilespositions[k].X && kvp2.Key.Y == tilespositions[k].Y)
{
tilesPerPal[i, j] = k;
break;
}
}
j++;
}
i++;
}
int[,,] results = new int[pals.GetLength(0), pals.GetLength(0), 1 + pals.GetLength(1)];
int[,,] results2 = new int[pals.GetLength(0), pals.GetLength(0), tilesPerPal.GetLength(1)];
using (MemoryBuffer2D <int> palsBuff = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(pals.GetLength(0), pals.GetLength(1)))
using (MemoryBuffer2D <int> tilepalsBuff = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(tilepals.GetLength(0), tilepals.GetLength(1)))
using (MemoryBuffer2D <int> tilesPerPalBuff = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(tilesPerPal.GetLength(0), tilesPerPal.GetLength(1)))
using (MemoryBuffer3D <int> palres = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(pals.GetLength(0), pals.GetLength(0), 1 + pals.GetLength(1)))
using (MemoryBuffer3D <int> palres2 = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(pals.GetLength(0), pals.GetLength(0), tilesPerPal.GetLength(1)))
{
palsBuff.CopyFrom(pals, Index2.Zero, Index2.Zero, palsBuff.Extent);
tilepalsBuff.CopyFrom(tilepals, Index2.Zero, Index2.Zero, tilepalsBuff.Extent);
tilesPerPalBuff.CopyFrom(tilesPerPal, Index2.Zero, Index2.Zero, tilesPerPalBuff.Extent);
bool change = true;
while (change)
{
palres.MemSetToZero();
palres2.MemSetToZero();
change = false;
kernel(palres.Extent.XY, palres, palres2, palsBuff, tilepalsBuff, tilesPerPalBuff);
HardwareAcceleratorManager.GPUAccelerator.Synchronize();
kernelBestEach(palres.Extent.X, palres);
HardwareAcceleratorManager.GPUAccelerator.Synchronize();
palres.CopyTo(results, Index3.Zero, Index3.Zero, palres.Extent);
palres2.CopyTo(results2, Index3.Zero, Index3.Zero, palres2.Extent);
int bestOfBest = int.MaxValue;
List <int> inds = new List <int>();
List <int> inds2 = new List <int>();
for (i = 0; i < results.GetLength(0); i++)
{
if (results[i, i, 0] >= 0)
{
if (results[i, i, 1] < bestOfBest)
{
bestOfBest = results[i, i, 1];
inds2.Clear();
inds.Clear();
inds.Add(i);
inds2.Add(results[i, i, 0]);
}
else if (results[i, i, 1] == bestOfBest)
{
inds.Add(i);
inds2.Add(results[i, i, 0]);
}
}
}
if (inds.Count > 0)
{
change = true;
while (change)
{
change = false;
int addMax = 0;
int remIndex = 0;
int add = 0;
int curindex = 0;
foreach (var id1 in inds)
{
add = 0;
foreach (var id2 in inds2)
{
if (id1 == id2)
{
add++;
}
}
if (add > addMax)
{
addMax = add;
remIndex = curindex;
}
curindex++;
}
if (addMax > 0)
{
change = true;
inds.RemoveAt(remIndex);
inds2.RemoveAt(remIndex);
}
}
int[,] reduceInds = new int[inds.Count, 2];
IEnumerator <int> en1 = inds.GetEnumerator();
IEnumerator <int> en2 = inds2.GetEnumerator();
en1.Reset();
en2.Reset();
for (int en = 0; en < inds.Count; en++)
{
en1.MoveNext();
en2.MoveNext();
reduceInds[en, 0] = en1.Current;
reduceInds[en, 1] = en2.Current;
}
using (MemoryBuffer2D <int> indsbuff = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(reduceInds.GetLength(0), reduceInds.GetLength(1)))
{
indsbuff.CopyFrom(reduceInds, Index2.Zero, Index2.Zero, indsbuff.Extent);
kernelReduceColors(indsbuff.Extent.X, palres, palres2, palsBuff, indsbuff, tilesPerPalBuff);
HardwareAcceleratorManager.GPUAccelerator.Synchronize();
}
change = true;
}
else
{
palsBuff.CopyTo(pals, Index2.Zero, Index2.Zero, palsBuff.Extent);
tilesPerPalBuff.CopyTo(tilesPerPal, Index2.Zero, Index2.Zero, tilesPerPalBuff.Extent);
}
}
}
tilesperPal.Clear();
ConcurrentDictionary <Int32, int> curpal;
ConcurrentDictionary <TileKey, int> curtiles;
for (i = 0; i < tilesPerPal.GetLength(0); i++)
{
curpal = new ConcurrentDictionary <Int32, int>();
curtiles = new ConcurrentDictionary <TileKey, int>();
if (tilesPerPal[i, 0] >= 0)
{
for (j = 0; j < tilesPerPal.GetLength(1); j++)
{
if (tilesPerPal[i, j] >= 0)
{
curtiles.TryAdd(tilespositions[tilesPerPal[i, j]], 0);
}
}
for (j = 0; j < pals.GetLength(1); j++)
{
if (pals[i, j] != 0)
{
curpal.TryAdd(pals[i, j], 0);
}
}
tilesperPal.TryAdd(curpal, curtiles);
}
}
}
internal static void SumError(
Action <AcceleratorStream, Index2, ArrayView2D <float>, ArrayView2D <float>, ArrayView3D <float>, ArrayView2D <float>, ArrayView2D <float>, ArrayView <float> > action,
Index2 extent, MemoryBuffer2D <float> error, MemoryBuffer2D <float> errorNextLayer, MemoryBuffer3D <float> weightNextLayer, MemoryBuffer2D <float> derived, MemoryBuffer <float> variable
)
{
action(accelerator.DefaultStream, extent, error, errorNextLayer, weightNextLayer, derived, dummyBuffer2D, variable);
}
