static void Main(string[] args)
{
int[] r1 = new int[]
{ 8, 2, 3, 4 };
int[] r2 = new int[]
{ 4, 3, 2, 5 };
int[] r3 = new int[4];
int rowSize = r1.Length;
// pick first platform
ComputePlatform platform = ComputePlatform.Platforms[0];
// create context with all gpu devices
ComputeContext context = new ComputeContext(ComputeDeviceTypes.Gpu,
new ComputeContextPropertyList(platform), null, IntPtr.Zero);
// create a command queue with first gpu found
ComputeCommandQueue queue = new ComputeCommandQueue(context,
context.Devices[0], ComputeCommandQueueFlags.None);
// load opencl source and
// create program with opencl source
ComputeProgram program = new ComputeProgram(context, CalculateKernel);
// compile opencl source
program.Build(null, null, null, IntPtr.Zero);
// load chosen kernel from program
ComputeKernel kernel = program.CreateKernel("Calc");
// allocate a memory buffer with the message (the int array)
ComputeBuffer <int> row1Buffer = new ComputeBuffer <int>(context,
ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, r1);
// allocate a memory buffer with the message (the int array)
ComputeBuffer <int> row2Buffer = new ComputeBuffer <int>(context,
ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, r2);
// allocate a memory buffer with the message (the int array)
ComputeBuffer <int> resultBuffer = new ComputeBuffer <int>(context,
ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, new int[4]);
kernel.SetMemoryArgument(0, row1Buffer); // set the integer array
kernel.SetMemoryArgument(1, row2Buffer); // set the integer array
kernel.SetValueArgument(2, rowSize); // set the array size
kernel.SetMemoryArgument(3, resultBuffer); // set the integer array
// execute kernel
queue.ExecuteTask(kernel, null);
// wait for completion
queue.Finish();
GCHandle arrCHandle = GCHandle.Alloc(r3, GCHandleType.Pinned);
queue.Read <int>(resultBuffer, true, 0, r3.Length, arrCHandle.AddrOfPinnedObject(), null);
Console.WriteLine("display result from gpu buffer:");
for (int i = 0; i < r3.Length; i++)
{
Console.WriteLine(r3[i]);
}
arrCHandle.Free();
row1Buffer.Dispose();
row2Buffer.Dispose();
kernel.Dispose();
program.Dispose();
queue.Dispose();
context.Dispose();
Console.WriteLine("Finished");
Console.ReadKey();
}
public void SetDevice(int deviceIndx)
{
if ((deviceIndx < 0) || (deviceIndx >= oclDevices.Count))
{
throw new IndexOutOfRangeException("Invalid OpenCL device index.");
}
if (oclContext != null)
{
oclContext.Dispose();
oclContext = null;
}
if (oclCommandQueue != null)
{
oclCommandQueue.Dispose();
oclCommandQueue = null;
}
if (oclKernel != null)
{
oclKernel.Dispose();
oclKernel = null;
}
ComputeProgram oclProgram = null;
try
{
oclContext = new ComputeContext(new ComputeDevice[] { oclDevices[deviceIndx] },
new ComputeContextPropertyList(oclDevices[deviceIndx].Platform), null, IntPtr.Zero);
oclCommandQueue = new ComputeCommandQueue(oclContext, oclDevices[deviceIndx],
ComputeCommandQueueFlags.None);
oclProgram = new ComputeProgram(oclContext,
Encoding.Default.GetString(Properties.Resources.Test));
oclProgram.Build(new ComputeDevice[] { oclDevices[deviceIndx] }, "", null, IntPtr.Zero);
oclKernel = oclProgram.CreateKernel("Test");
}
catch (BuildProgramFailureComputeException ex)
{
string buildLog = oclProgram.GetBuildLog(oclDevices[deviceIndx]);
throw new Exception(buildLog, ex);
}
catch (Exception)
{
throw;
}
finally
{
if (oclProgram != null)
{
oclProgram.Dispose();
oclProgram = null;
}
}
}
public void Dispose()
{
program.Dispose();
context.Dispose();
kernel.Dispose();
commands.Dispose();
}
public void Dispose()
{
Context.Dispose();
_queue.Dispose();
_openCl.Dispose();
var tmpPub = _pub;
GL.DeleteBuffers(1, ref tmpPub);
GL.DeleteTexture(_texture);
}
public void Dispose()
{
FWaveformBuffer.Dispose();
commands.Dispose();
kernel.Dispose();
program.Dispose();
FContext.Dispose();
FDevice = null;
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (mQueue != null)
{
mQueue.Dispose();
mQueue = null;
}
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
clCommands.Dispose();
clKernel.Dispose();
clProgram.Dispose();
clContext.Dispose();
cbuf_Result.Dispose();
cbuf_Rng.Dispose();
}
}
static void TearDownCUDA()
{
context.Dispose();
queue.Dispose();
kernel.Dispose();
messageBuffer.Dispose();
if (gradientBuffer != null)
{
gradientBuffer.Dispose();
}
program.Dispose();
}
/// <summary>
/// Executes the specified kernel function name.
/// </summary>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <param name="functionName">Name of the function.</param>
/// <param name="args"></param>
/// <exception cref="ExecutionException">
/// </exception>
public override void Execute(string functionName, params object[] args)
{
ValidateArgs(functionName, args);
ComputeKernel kernel = _compiledKernels.FirstOrDefault(x => (x.FunctionName == functionName));
ComputeCommandQueue commands = new ComputeCommandQueue(_context, _defaultDevice, ComputeCommandQueueFlags.None);
if (kernel == null)
{
throw new ExecutionException(string.Format("Kernal function {0} not found", functionName));
}
try
{
var ndobject = (Array)args.FirstOrDefault(x => (x.GetType().IsArray));
long length = ndobject != null ? ndobject.Length : 1;
var method = KernelFunctions.FirstOrDefault(x => (x.Name == functionName));
var buffers = BuildKernelArguments(method, args, kernel, length);
commands.Execute(kernel, null, new long[] { length }, null, null);
for (int i = 0; i < args.Length; i++)
{
if (!args[i].GetType().IsArray)
{
continue;
}
var ioMode = method.Parameters.ElementAt(i).Value.IOMode;
if (ioMode == IOMode.InOut || ioMode == IOMode.Out)
{
Array r = (Array)args[i];
commands.ReadFromMemory(buffers[i], ref r, true, 0, null);
}
buffers[i].Dispose();
}
}
catch (Exception ex)
{
throw new ExecutionException(ex.Message);
}
finally
{
commands.Finish();
commands.Dispose();
}
}
public Bitmap GetScreenshot(CameraConfig camera, int screenshotHeight, int slowRender)
{
var screenshotWidth = (int)(screenshotHeight * ScreenshotAspectRatio);
var computeBuffer = new ComputeBuffer <Vector4>(_program.Context, ComputeMemoryFlags.ReadWrite, screenshotWidth * screenshotHeight);
var queue = new ComputeCommandQueue(_program.Context, _program.Context.Devices[0], ComputeCommandQueueFlags.None);
var globalSize = GlobalLaunchsizeFor(screenshotWidth, screenshotHeight);
for (var i = 0; i < slowRender; i++)
{
CoreRender(computeBuffer, queue, _kernels, new Vector4((Vector3)camera.Position), new Vector4((Vector3)camera.Lookat), new Vector4((Vector3)camera.Up), i, camera.Fov, slowRender, camera.FocalDistance, screenshotWidth, screenshotHeight, globalSize, _localSize);
}
for (var i = 0; i < camera.Frame * slowRender; i++)
{
CoreRender(computeBuffer, queue, _kernels, new Vector4((Vector3)camera.Position), new Vector4((Vector3)camera.Lookat), new Vector4((Vector3)camera.Up), i, camera.Fov, slowRender, camera.FocalDistance, screenshotWidth, screenshotHeight, globalSize, _localSize);
}
var pixels = new Vector4[screenshotWidth * screenshotHeight];
queue.ReadFromBuffer(computeBuffer, ref pixels, true, null);
queue.Finish();
computeBuffer.Dispose();
queue.Dispose();
var bmp = new Bitmap(screenshotWidth, screenshotHeight);
var destBuffer = new int[screenshotWidth * screenshotHeight];
for (var y = 0; y < screenshotHeight; y++)
{
for (var x = 0; x < screenshotWidth; x++)
{
var pixel = pixels[x + y * screenshotWidth];
if (float.IsNaN(pixel.X) || float.IsNaN(pixel.Y) || float.IsNaN(pixel.Z))
{
Console.WriteLine("Warning! Caught NAN pixel while taking screenshot!");
continue;
}
destBuffer[y * screenshotWidth + x] = (byte)(pixel.X * 255) << 16 | (byte)(pixel.Y * 255) << 8 | (byte)(pixel.Z * 255);
}
}
var bmpData = bmp.LockBits(new Rectangle(0, 0, screenshotWidth, screenshotHeight), ImageLockMode.ReadWrite, PixelFormat.Format32bppRgb);
Marshal.Copy(destBuffer, 0, bmpData.Scan0, destBuffer.Length);
bmp.UnlockBits(bmpData);
return(bmp);
}
public void Run(ComputeContext context, TextWriter log)
{
try
{
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
log.WriteLine("Original content:");
Random rand = new Random();
int count = 6;
long[] bufferContent = new long[count];
for (int i = 0; i < count; i++)
{
bufferContent[i] = (long)(rand.NextDouble() * long.MaxValue);
log.WriteLine("\t" + bufferContent[i]);
}
ComputeBuffer <long> buffer = new ComputeBuffer <long>(context, ComputeMemoryFlags.CopyHostPointer, bufferContent);
IntPtr mappedPtr = commands.Map(buffer, true, ComputeMemoryMappingFlags.Read, 0, bufferContent.Length, null);
log.WriteLine("Mapped content:");
for (int i = 0; i < bufferContent.Length; i++)
{
IntPtr ptr = new IntPtr(mappedPtr.ToInt64() + i * sizeof(long));
log.WriteLine("\t" + Marshal.ReadInt64(ptr));
}
commands.Unmap(buffer, ref mappedPtr, null);
// wait for the unmap to happen
commands.Finish();
// cleanup buffer
buffer.Dispose();
// cleanup commands
commands.Dispose();
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
}
/// <summary>
/// Executes the specified kernel function name.
/// </summary>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <param name="functionName">Name of the function.</param>
/// <param name="inputs">The inputs.</param>
/// <param name="returnInputVariable">The return result.</param>
/// <returns></returns>
/// <exception cref="ExecutionException">
/// </exception>
public override void Execute <TSource>(string functionName, params object[] args)
{
ComputeKernel kernel = _compiledKernels.FirstOrDefault(x => (x.FunctionName == functionName));
ComputeCommandQueue commands = new ComputeCommandQueue(_context, _defaultDevice, ComputeCommandQueueFlags.None);
if (kernel == null)
{
throw new ExecutionException(string.Format("Kernal function {0} not found", functionName));
}
try
{
var ndobject = (TSource[])args.FirstOrDefault(x => (x.GetType() == typeof(TSource[])));
long length = ndobject != null ? ndobject.Length : 1;
var buffers = BuildKernelArguments <TSource>(args, kernel, length);
commands.Execute(kernel, null, new long[] { length }, null, null);
foreach (var item in buffers)
{
TSource[] r = (TSource[])args[item.Key];
commands.ReadFromBuffer(item.Value, ref r, true, null);
//args[item.Key] = r;
item.Value.Dispose();
}
commands.Finish();
}
catch (Exception ex)
{
throw new ExecutionException(ex.Message);
}
finally
{
commands.Dispose();
}
}
void DestroyClBuffers()
{
if (clImage != null)
{
clImage.Dispose();
clImage = null;
}
if (result != null)
{
result.Dispose();
result = null;
}
if (cmap != null)
{
cmap.Dispose();
cmap = null;
}
if (clCommands != null)
{
clCommands.Dispose();
clCommands = null;
}
if (clKernel != null)
{
clKernel.Dispose();
clKernel = null;
}
if (clProgram != null)
{
clProgram.Dispose();
clProgram = null;
}
clDirty = true;
}
/// <summary>
/// Executes the specified kernel function name.
/// </summary>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <param name="functionName">Name of the function.</param>
/// <param name="args"></param>
/// <exception cref="ExecutionException">
/// </exception>
public override void Execute(string functionName, params object[] args)
{
ValidateArgs(functionName, args);
ComputeKernel kernel = _compiledKernels.FirstOrDefault(x => (x.FunctionName == functionName));
ComputeCommandQueue commands = new ComputeCommandQueue(_context, _defaultDevice, ComputeCommandQueueFlags.None);
if (kernel == null)
{
throw new ExecutionException(string.Format("Kernal function {0} not found", functionName));
}
try
{
Array ndobject = (Array)args.FirstOrDefault(x => (x.GetType().IsArray));
List <long> length = new List <long>();
long totalLength = 0;
if (ndobject == null)
{
var xarrayList = args.Where(x => (x.GetType().Name == "XArray" || x.GetType().BaseType.Name == "XArray")).ToList();
foreach (var item in xarrayList)
{
var xarrayobj = (XArray)item;
if (xarrayobj.Direction == Direction.Output)
{
totalLength = xarrayobj.Count;
if (!xarrayobj.IsElementWise)
{
length = xarrayobj.Sizes.ToList();
}
else
{
length.Add(totalLength);
}
}
}
if (totalLength == 0)
{
var xarrayobj = (XArray)xarrayList[0];
totalLength = xarrayobj.Count;
if (!xarrayobj.IsElementWise)
{
length = xarrayobj.Sizes.ToList();
}
else
{
length.Add(totalLength);
}
}
}
else
{
totalLength = ndobject.Length;
for (int i = 0; i < ndobject.Rank; i++)
{
length.Add(ndobject.GetLength(i));
}
}
var method = KernelFunctions.FirstOrDefault(x => (x.Name == functionName));
var buffers = BuildKernelArguments(method, args, kernel, totalLength);
commands.Execute(kernel, null, length.ToArray(), null, null);
for (int i = 0; i < args.Length; i++)
{
if (args[i].GetType().IsArray)
{
var ioMode = method.Parameters.ElementAt(i).Value.IOMode;
if (ioMode == IOMode.InOut || ioMode == IOMode.Out)
{
Array r = (Array)args[i];
commands.ReadFromMemory(buffers[i], ref r, true, 0, null);
}
buffers[i].Dispose();
}
else if (args[i].GetType().Name == "XArray" || args[i].GetType().BaseType.Name == "XArray")
{
var ioMode = method.Parameters.ElementAt(i).Value.IOMode;
if (ioMode == IOMode.InOut || ioMode == IOMode.Out)
{
XArray r = (XArray)args[i];
commands.ReadFromMemory(buffers[i], ref r, true, 0, null);
}
buffers[i].Dispose();
}
}
}
catch (Exception ex)
{
throw new ExecutionException(ex.Message);
}
finally
{
commands.Finish();
commands.Dispose();
}
}
/// <summary>
/// Renders the image based on the <see cref="latestEnvironment"/>.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="doWorkEventArgs">The <see cref="System.ComponentModel.DoWorkEventArgs"/> instance containing the event data.</param>
/// <remarks>
/// Buffers <see cref="latestEnvironment"/> into <see cref="currentEnvironment"/> before rendering, to ensure new incoming
/// data doesn't interfere, even if it comes in while still rendering.
/// </remarks>
private void RenderImage(object sender, DoWorkEventArgs doWorkEventArgs)
{
int type;
// Buffer the environment data
lock (latestEnvironmentLocker)
{
currentEnvironment = latestEnvironment;
currentBallVelocity = latestBallVelocity;
type = fieldType;
}
// Create the computation queue (this can't be saved and reused, not sure why)
var queue = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
switch (type)
{
case 0:
// Calculate the potential field
ComputeField(queue, points);
break;
case 1:
ComputeFinalApproachField(queue, points);
break;
case 2:
ComputePosessionField(queue, points);
break;
}
// Draw a picture of it
var bitmap = RenderPoints(queue, points, outCl);
// Calculate the field gradients
ComputeGradient(queue, gradientPoints);
// Draw a picture of them
var bitmap2 = RenderPoints(queue, gradientPoints, outGradient);
// Anonymous function which refreshes the images shown on the UI. Has to be called on the UI thread to allow access
// to the UI controls.
Action refresh = () =>
{
using (var stream = new MemoryStream())
{
bitmap.Save(stream, ImageFormat.Png);
stream.Seek(0, SeekOrigin.Begin);
var decoder = BitmapDecoder.Create(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad);
var writeable = new WriteableBitmap(decoder.Frames.Single());
writeable.Freeze();
FieldImage.Source = writeable;
}
using (var stream = new MemoryStream())
{
bitmap2.Save(stream, ImageFormat.Png);
stream.Seek(0, SeekOrigin.Begin);
var decoder = BitmapDecoder.Create(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad);
var writeable = new WriteableBitmap(decoder.Frames.Single());
writeable.Freeze();
GradientImage.Source = writeable;
}
};
Dispatcher.Invoke(refresh);
queue.Finish();
queue.Dispose();
}
public void DisposeQueueAndContext()
{
queue.Dispose();
context.Dispose();
}
public void Run(ComputeContext context, TextWriter log)
{
try
{
log.Write("Creating command queue... ");
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
log.WriteLine("done.");
log.Write("Generating data... ");
int linearSize = 24;
SysIntX2 rectSize = new SysIntX2(4, 6);
SysIntX3 cubicSize = new SysIntX3(2, 3, 4);
float[] linearIn = new float[linearSize];
float[] linearOut = new float[linearSize];
float[,] rectIn = new float[(int)rectSize.Y, (int)rectSize.X];
float[,] rectOut = new float[(int)rectSize.Y, (int)rectSize.X];
float[, ,] cubicIn = new float[(int)cubicSize.Z, (int)cubicSize.Y, (int)cubicSize.X];
float[, ,] cubicOut = new float[(int)cubicSize.Z, (int)cubicSize.Y, (int)cubicSize.X];
for (int i = 0; i < linearSize; i++)
{
linearIn[i] = i;
}
for (int i = 0; i < (int)rectSize.X; i++)
{
for (int j = 0; j < (int)rectSize.Y; j++)
{
rectIn[j, i] = (float)(rectSize.X.ToInt32() * j + i);
}
}
for (int i = 0; i < (int)cubicSize.X; i++)
{
for (int j = 0; j < (int)cubicSize.Y; j++)
{
for (int k = 0; k < (int)cubicSize.Z; k++)
{
cubicIn[k, j, i] = (float)(k * cubicSize.Y.ToInt32() * cubicSize.X.ToInt32() + cubicSize.X.ToInt32() * j + i);
}
}
}
log.WriteLine("done.");
log.Write("Creating buffer... ");
ComputeBuffer <float> buffer = new ComputeBuffer <float>(context, ComputeMemoryFlags.ReadWrite, linearSize);
log.WriteLine("done.");
GC.Collect();
log.Write("Writing to buffer (linear)... ");
commands.WriteToBuffer(linearIn, buffer, false, null);
log.WriteLine("done.");
log.Write("Reading from buffer (linear)... ");
commands.ReadFromBuffer(buffer, ref linearOut, false, null);
log.WriteLine("done.");
GC.Collect();
commands.Finish();
log.Write("Comparing data... ");
Compare(linearIn, linearOut);
log.WriteLine("passed.");
GC.Collect();
log.Write("Writing to buffer (rectangular)... ");
commands.WriteToBuffer(rectIn, buffer, false, new SysIntX2(), new SysIntX2(), rectSize, null);
log.WriteLine("done.");
GC.Collect();
log.Write("Reading from buffer (rectangular)... ");
commands.ReadFromBuffer(buffer, ref rectOut, false, new SysIntX2(), new SysIntX2(), rectSize, null);
log.WriteLine("done.");
GC.Collect();
commands.Finish();
log.Write("Comparing data... ");
Compare(rectIn, rectOut);
log.WriteLine("passed.");
GC.Collect();
log.Write("Writing to buffer (cubic)... ");
commands.WriteToBuffer(cubicIn, buffer, false, new SysIntX3(), new SysIntX3(), cubicSize, null);
log.WriteLine("done.");
GC.Collect();
log.Write("Reading from buffer (cubic)... ");
commands.ReadFromBuffer(buffer, ref cubicOut, false, new SysIntX3(), new SysIntX3(), cubicSize, null);
log.WriteLine("done.");
GC.Collect();
commands.Finish();
log.Write("Comparing data... ");
Compare(cubicIn, cubicOut);
log.WriteLine("passed.");
// cleanup commands
commands.Dispose();
// cleanup buffer
buffer.Dispose();
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
}
public void Run(ComputeContext context, TextWriter log)
{
try
{
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
log.WriteLine("Original content:");
Random rand = new Random();
int count = 6;
long[] bufferContent = new long[count];
for (int i = 0; i < count; i++)
{
bufferContent[i] = (long)(rand.NextDouble() * long.MaxValue);
log.WriteLine("\t" + bufferContent[i]);
}
ComputeBuffer<long> buffer = new ComputeBuffer<long>(context, ComputeMemoryFlags.CopyHostPointer, bufferContent);
IntPtr mappedPtr = commands.Map(buffer, true, ComputeMemoryMappingFlags.Read, 0, bufferContent.Length, null);
log.WriteLine("Mapped content:");
for (int i = 0; i < bufferContent.Length; i++)
{
IntPtr ptr = new IntPtr(mappedPtr.ToInt64() + i * sizeof(long));
log.WriteLine("\t" + Marshal.ReadInt64(ptr));
}
commands.Unmap(buffer, ref mappedPtr, null);
// wait for the unmap to happen
commands.Finish();
// cleanup buffer
buffer.Dispose();
// cleanup commands
commands.Dispose();
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
}
public void Run(ComputeContext context, TextWriter log)
{
try
{
// Create the arrays and fill them with random data.
int count = 10;
float[] arrA = new float[count];
float[] arrB = new float[count];
float[] arrC = new float[count];
Random rand = new Random();
for (int i = 0; i < count; i++)
{
arrA[i] = (float)(rand.NextDouble() * 100);
arrB[i] = (float)(rand.NextDouble() * 100);
}
// Create the input buffers and fill them with data from the arrays.
// Access modifiers should match those in a kernel.
// CopyHostPointer means the buffer should be filled with the data provided in the last argument.
ComputeBuffer<float> a = new ComputeBuffer<float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrA);
ComputeBuffer<float> b = new ComputeBuffer<float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrB);
// The output buffer doesn't need any data from the host. Only its size is specified (arrC.Length).
ComputeBuffer<float> c = new ComputeBuffer<float>(context, ComputeMemoryFlags.WriteOnly, arrC.Length);
// Create and build the opencl program.
program = new ComputeProgram(context, clProgramSource);
program.Build(null, null, null, IntPtr.Zero);
// Create the kernel function and set its arguments.
ComputeKernel kernel = program.CreateKernel("VectorAdd");
kernel.SetMemoryArgument(0, a);
kernel.SetMemoryArgument(1, b);
kernel.SetMemoryArgument(2, c);
// Create the event wait list. An event list is not really needed for this example but it is important to see how it works.
// Note that events (like everything else) consume OpenCL resources and creating a lot of them may slow down execution.
// For this reason their use should be avoided if possible.
ComputeEventList eventList = new ComputeEventList();
// Create the command queue. This is used to control kernel execution and manage read/write/copy operations.
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
// Execute the kernel "count" times. After this call returns, "eventList" will contain an event associated with this command.
// If eventList == null or typeof(eventList) == ReadOnlyCollection<ComputeEventBase>, a new event will not be created.
commands.Execute(kernel, null, new long[] { count }, null, eventList);
// Read back the results. If the command-queue has out-of-order execution enabled (default is off), ReadFromBuffer
// will not execute until any previous events in eventList (in our case only eventList[0]) are marked as complete
// by OpenCL. By default the command-queue will execute the commands in the same order as they are issued from the host.
// eventList will contain two events after this method returns.
commands.ReadFromBuffer(c, ref arrC, false, eventList);
// A blocking "ReadFromBuffer" (if 3rd argument is true) will wait for itself and any previous commands
// in the command queue or eventList to finish execution. Otherwise an explicit wait for all the opencl commands
// to finish has to be issued before "arrC" can be used.
// This explicit synchronization can be achieved in two ways:
// 1) Wait for the events in the list to finish,
//eventList.Wait();
// 2) Or simply use
commands.Finish();
// Print the results to a log/console.
for (int i = 0; i < count; i++)
log.WriteLine("{0} + {1} = {2}", arrA[i], arrB[i], arrC[i]);
// cleanup commands
commands.Dispose();
// cleanup events
foreach (ComputeEventBase eventBase in eventList)
{
eventBase.Dispose();
}
eventList.Clear();
// cleanup kernel
kernel.Dispose();
// cleanup program
program.Dispose();
// cleanup buffers
a.Dispose();
b.Dispose();
c.Dispose();
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
}
public void Run(ComputeContext context, TextWriter log)
{
try
{
// Create the arrays and fill them with random data.
int count = 10;
float[] arrA = new float[count];
float[] arrB = new float[count];
float[] arrC = new float[count];
Random rand = new Random();
for (int i = 0; i < count; i++)
{
arrA[i] = (float)(rand.NextDouble() * 100);
arrB[i] = (float)(rand.NextDouble() * 100);
}
// Create the input buffers and fill them with data from the arrays.
// Access modifiers should match those in a kernel.
// CopyHostPointer means the buffer should be filled with the data provided in the last argument.
ComputeBuffer <float> a = new ComputeBuffer <float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrA);
ComputeBuffer <float> b = new ComputeBuffer <float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrB);
// The output buffer doesn't need any data from the host. Only its size is specified (arrC.Length).
ComputeBuffer <float> c = new ComputeBuffer <float>(context, ComputeMemoryFlags.WriteOnly, arrC.Length);
// Create and build the opencl program.
program = new ComputeProgram(context, clProgramSource);
program.Build(null, null, null, IntPtr.Zero);
// Create the kernel function and set its arguments.
ComputeKernel kernel = program.CreateKernel("VectorAdd");
kernel.SetMemoryArgument(0, a);
kernel.SetMemoryArgument(1, b);
kernel.SetMemoryArgument(2, c);
// Create the event wait list. An event list is not really needed for this example but it is important to see how it works.
// Note that events (like everything else) consume OpenCL resources and creating a lot of them may slow down execution.
// For this reason their use should be avoided if possible.
ComputeEventList eventList = new ComputeEventList();
// Create the command queue. This is used to control kernel execution and manage read/write/copy operations.
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
// Execute the kernel "count" times. After this call returns, "eventList" will contain an event associated with this command.
// If eventList == null or typeof(eventList) == ReadOnlyCollection<ComputeEventBase>, a new event will not be created.
commands.Execute(kernel, null, new long[] { count }, null, eventList);
// Read back the results. If the command-queue has out-of-order execution enabled (default is off), ReadFromBuffer
// will not execute until any previous events in eventList (in our case only eventList[0]) are marked as complete
// by OpenCL. By default the command-queue will execute the commands in the same order as they are issued from the host.
// eventList will contain two events after this method returns.
commands.ReadFromBuffer(c, ref arrC, false, eventList);
// A blocking "ReadFromBuffer" (if 3rd argument is true) will wait for itself and any previous commands
// in the command queue or eventList to finish execution. Otherwise an explicit wait for all the opencl commands
// to finish has to be issued before "arrC" can be used.
// This explicit synchronization can be achieved in two ways:
// 1) Wait for the events in the list to finish,
//eventList.Wait();
// 2) Or simply use
commands.Finish();
// Print the results to a log/console.
for (int i = 0; i < count; i++)
{
log.WriteLine("{0} + {1} = {2}", arrA[i], arrB[i], arrC[i]);
}
// cleanup commands
commands.Dispose();
// cleanup events
foreach (ComputeEventBase eventBase in eventList)
{
eventBase.Dispose();
}
eventList.Clear();
// cleanup kernel
kernel.Dispose();
// cleanup program
program.Dispose();
// cleanup buffers
a.Dispose();
b.Dispose();
c.Dispose();
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
}
public void TakeGif(IGifableControl control, Action<string> displayInformation)
{
_kernelInUse++;
var encoder = new AnimatedGifEncoder();
encoder.Start(Ext.UniqueFilename("sequence", "gif"));
encoder.SetDelay(1000 / StaticSettings.Fetch.GifFramerate);
encoder.SetRepeat(0);
var endIgnoreControl = control.StartIgnoreControl();
var ccontext = _kernel.ComputeContext;
var queue = new ComputeCommandQueue(ccontext, ccontext.Devices[0], ComputeCommandQueueFlags.None);
var screenshotHeight = StaticSettings.Fetch.GifHeight;
var screenshotWidth = (int)(screenshotHeight * ScreenshotAspectRatio);
var computeBuffer = new ComputeBuffer<Vector4>(ccontext, ComputeMemoryFlags.ReadWrite, screenshotWidth * screenshotHeight);
var fdc = control as IFrameDependantControl;
for (var i = 0; i < StaticSettings.Fetch.GifFramecount + 1; i++)
{
if (fdc != null)
fdc.Frame = i;
var teardown = control.SetupGif((double)i / StaticSettings.Fetch.GifFramecount);
_kernel.Render(computeBuffer, queue, _parameters, new Size(screenshotWidth, screenshotHeight));
queue.Finish();
teardown();
}
for (var i = 1; i < StaticSettings.Fetch.GifFramecount + 1; i++)
{
if (fdc != null)
fdc.Frame = i;
displayInformation(string.Format("{0}% done with gif", (int)(100.0 * (i - 1) / StaticSettings.Fetch.GifFramecount)));
var teardown = control.SetupGif((double)(i - 1) / StaticSettings.Fetch.GifFramecount);
_kernel.Render(computeBuffer, queue, _parameters, new Size(screenshotWidth, screenshotHeight));
if (encoder.AddFrame(Download(queue, computeBuffer, screenshotWidth, screenshotHeight)) == false)
throw new Exception("Could not add frame to gif");
teardown();
}
endIgnoreControl();
encoder.Finish();
computeBuffer.Dispose();
queue.Dispose();
displayInformation("Done with gif");
_kernelInUse--;
}
public Bitmap GetScreenshot(CameraConfig camera, int screenshotHeight, int slowRender)
{
var screenshotWidth = (int)(screenshotHeight * ScreenshotAspectRatio);
var computeBuffer = new ComputeBuffer<Vector4>(_program.Context, ComputeMemoryFlags.ReadWrite, screenshotWidth * screenshotHeight);
var queue = new ComputeCommandQueue(_program.Context, _program.Context.Devices[0], ComputeCommandQueueFlags.None);
var globalSize = GlobalLaunchsizeFor(screenshotWidth, screenshotHeight);
for (var i = 0; i < slowRender; i++)
CoreRender(computeBuffer, queue, _kernels, new Vector4((Vector3)camera.Position), new Vector4((Vector3)camera.Lookat), new Vector4((Vector3)camera.Up), i, camera.Fov, slowRender, camera.FocalDistance, screenshotWidth, screenshotHeight, globalSize, _localSize);
for (var i = 0; i < camera.Frame * slowRender; i++)
CoreRender(computeBuffer, queue, _kernels, new Vector4((Vector3)camera.Position), new Vector4((Vector3)camera.Lookat), new Vector4((Vector3)camera.Up), i, camera.Fov, slowRender, camera.FocalDistance, screenshotWidth, screenshotHeight, globalSize, _localSize);
var pixels = new Vector4[screenshotWidth * screenshotHeight];
queue.ReadFromBuffer(computeBuffer, ref pixels, true, null);
queue.Finish();
computeBuffer.Dispose();
queue.Dispose();
var bmp = new Bitmap(screenshotWidth, screenshotHeight);
var destBuffer = new int[screenshotWidth * screenshotHeight];
for (var y = 0; y < screenshotHeight; y++)
{
for (var x = 0; x < screenshotWidth; x++)
{
var pixel = pixels[x + y * screenshotWidth];
if (float.IsNaN(pixel.X) || float.IsNaN(pixel.Y) || float.IsNaN(pixel.Z))
{
Console.WriteLine("Warning! Caught NAN pixel while taking screenshot!");
continue;
}
destBuffer[y * screenshotWidth + x] = (byte)(pixel.X * 255) << 16 | (byte)(pixel.Y * 255) << 8 | (byte)(pixel.Z * 255);
}
}
var bmpData = bmp.LockBits(new Rectangle(0, 0, screenshotWidth, screenshotHeight), ImageLockMode.ReadWrite, PixelFormat.Format32bppRgb);
Marshal.Copy(destBuffer, 0, bmpData.Scan0, destBuffer.Length);
bmp.UnlockBits(bmpData);
return bmp;
}
public static void Calculate(List<Calculation> calculations)
{
Stopwatch s = new Stopwatch();
s.Start();
int count = calculations.Count;
IntVec2[] p_p = new IntVec2[count];
IntVec2[] p_a = new IntVec2[count];
IntVec2[] p_b = new IntVec2[count];
IntVec2[] p_c = new IntVec2[count];
FloatVec3[] c = new FloatVec3[count];
int[] c_valid = new int[count];
Parallel.For(0, count, i =>
{
var calc = calculations[i];
p_p[i] = new IntVec2(calc.P);
p_a[i] = new IntVec2(calc.A);
p_b[i] = new IntVec2(calc.B);
p_c[i] = new IntVec2(calc.C);
});
mark(s, "memory init");
ComputeBuffer<IntVec2> _p_p = new ComputeBuffer<IntVec2>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, p_p);
ComputeBuffer<IntVec2> _p_a = new ComputeBuffer<IntVec2>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, p_a);
ComputeBuffer<IntVec2> _p_b = new ComputeBuffer<IntVec2>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, p_b);
ComputeBuffer<IntVec2> _p_c = new ComputeBuffer<IntVec2>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, p_c);
ComputeBuffer<FloatVec3> _c = new ComputeBuffer<FloatVec3>(context, ComputeMemoryFlags.WriteOnly, c.Length);
ComputeBuffer<int> _c_valid = new ComputeBuffer<int>(context, ComputeMemoryFlags.WriteOnly, c_valid.Length);
mark(s, "memory buffer init");
ComputeKernel kernel = program.CreateKernel("Barycentric");
kernel.SetMemoryArgument(0, _p_p);
kernel.SetMemoryArgument(1, _p_a);
kernel.SetMemoryArgument(2, _p_b);
kernel.SetMemoryArgument(3, _p_c);
kernel.SetMemoryArgument(4, _c);
kernel.SetMemoryArgument(5, _c_valid);
mark(s, "memory init 2");
ComputeEventList eventList = new ComputeEventList();
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
commands.Execute(kernel, null, new long[] { count }, null, eventList);
mark(s, "execute");
commands.ReadFromBuffer(_c, ref c, false, eventList);
commands.ReadFromBuffer(_c_valid, ref c_valid, false, eventList);
commands.Finish();
mark(s, "read 1");
Parallel.For(0, count, i =>
{
var calc = calculations[i];
calc.Coords = new BarycentricCoordinates(c[i].U,c[i].V,c[i].W);
if (c_valid[i] == 1)
{
lock (calc.Tri)
calc.Tri.Points.Add(new DrawPoint(calc.Coords, calc.P));
}
});
mark(s, "read 2");
// cleanup commands
commands.Dispose();
// cleanup events
foreach (ComputeEventBase eventBase in eventList)
{
eventBase.Dispose();
}
eventList.Clear();
// cleanup kernel
kernel.Dispose();
_p_p.Dispose();
_p_a.Dispose();
_p_b.Dispose();
_p_c.Dispose();
_c.Dispose();
_c_valid.Dispose();
mark(s, "dispose");
}
