556 lines
22 KiB
C#
556 lines
22 KiB
C#
|
/*
|
|||
|
|
* Copyright (c) 2009 Olav Kalgraf(olav.kalgraf@gmail.com)
|
|||
|
|
*
|
|||
|
|
* Permission is hereby granted, free of charge, to any person
|
|||
|
|
* obtaining a copy of this software and associated documentation
|
|||
|
|
* files (the "Software"), to deal in the Software without
|
|||
|
|
* restriction, including without limitation the rights to use,
|
|||
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
|
|
* copies of the Software, and to permit persons to whom the
|
|||
|
|
* Software is furnished to do so, subject to the following
|
|||
|
|
* conditions:
|
|||
|
|
*
|
|||
|
|
* The above copyright notice and this permission notice shall be
|
|||
|
|
* included in all copies or substantial portions of the Software.
|
|||
|
|
*
|
|||
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
using System;
|
|||
|
|
using System.Collections.Generic;
|
|||
|
|
using System.ComponentModel;
|
|||
|
|
using System.Data;
|
|||
|
|
using System.Drawing;
|
|||
|
|
using System.Linq;
|
|||
|
|
using System.Text;
|
|||
|
|
using System.Text.RegularExpressions;
|
|||
|
|
using System.Windows.Forms;
|
|||
|
|
using System.IO;
|
|||
|
|
using System.Runtime.InteropServices;
|
|||
|
|
using System.Threading;
|
|||
|
|
using OpenCLNet;
|
|||
|
|
|
|||
|
|
namespace UnitTests
|
|||
|
|
{
|
|||
|
|
public partial class Form1 : Form
|
|||
|
|
{
|
|||
|
|
Platform[] Platforms;
|
|||
|
|
Regex ParseOpenCLVersion = new Regex(@"OpenCL (?<MajorVersion>\d+)\.(?<MinorVersion>\d+).*");
|
|||
|
|
|
|||
|
|
public Form1()
|
|||
|
|
{
|
|||
|
|
InitializeComponent();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void startToolStripMenuItem_Click(object sender, EventArgs e)
|
|||
|
|
{
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
listBoxErrors.Items.Clear();
|
|||
|
|
listBoxWarnings.Items.Clear();
|
|||
|
|
listBoxOutput.Items.Clear();
|
|||
|
|
RunTests();
|
|||
|
|
}
|
|||
|
|
catch (Exception ex)
|
|||
|
|
{
|
|||
|
|
MessageBox.Show(ex.ToString(), "Test terminated with a fatal exception.");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void RunTests()
|
|||
|
|
{
|
|||
|
|
TestOpenCLClass();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void TestOpenCLClass()
|
|||
|
|
{
|
|||
|
|
if (OpenCL.NumberOfPlatforms <= 0)
|
|||
|
|
{
|
|||
|
|
listBoxOutput.Items.Add("OpenCL.NumberOfPlatforms=" + OpenCL.NumberOfPlatforms);
|
|||
|
|
throw new Exception("TestOpenCLClass: NumberOfPlatforms<0. Is the API available at all?");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Platforms = OpenCL.GetPlatforms();
|
|||
|
|
if (Platforms.Length != OpenCL.NumberOfPlatforms)
|
|||
|
|
Error("OpenCL.NumberOfPlatforms!=Length of openCL.GetPlatforms()" + OpenCL.NumberOfPlatforms);
|
|||
|
|
|
|||
|
|
for (int platformIndex = 0; platformIndex < Platforms.Length; platformIndex++)
|
|||
|
|
{
|
|||
|
|
if (OpenCL.GetPlatform(platformIndex) != Platforms[platformIndex])
|
|||
|
|
Error("openCL.GetPlatform(platformIndex)!=Platforms[platformIndex]");
|
|||
|
|
|
|||
|
|
Output("Testing Platform " + platformIndex);
|
|||
|
|
TestPlatform(Platforms[platformIndex]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void TestPlatform(Platform p)
|
|||
|
|
{
|
|||
|
|
Device[] allDevices;
|
|||
|
|
Device[] cpuDevices;
|
|||
|
|
Device[] gpuDevices;
|
|||
|
|
Device[] acceleratorDevices;
|
|||
|
|
|
|||
|
|
Output("Name: " + p.Name);
|
|||
|
|
Output("Vendor:" + p.Vendor);
|
|||
|
|
Output("Version:" + p.Version);
|
|||
|
|
|
|||
|
|
// Check format of version string
|
|||
|
|
Match m = ParseOpenCLVersion.Match(p.Version);
|
|||
|
|
if (!m.Success)
|
|||
|
|
Warning("Platform " + p.Name + " has an invalid version string");
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
if (m.Groups["MajorVersion"].Value != "1" && m.Groups["MinorVersion"].Value != "0")
|
|||
|
|
Warning("Platform " + p.Name + " has a version number!=1.0(Not really a problem, but this test is written for 1.0)");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Check format of profile
|
|||
|
|
Output("Profile:" + p.Profile);
|
|||
|
|
if (p.Profile == "FULL_PROFILE" || p.Profile == "EMBEDDED_PROFILE")
|
|||
|
|
Output("Profile:" + p.Profile);
|
|||
|
|
else
|
|||
|
|
Warning("Platform " + p.Name + " has unknown profile "+p.Profile);
|
|||
|
|
|
|||
|
|
Output("Extensions: " + p.Extensions);
|
|||
|
|
|
|||
|
|
// Test whether number of devices is consistent
|
|||
|
|
allDevices = p.QueryDevices(DeviceType.ALL);
|
|||
|
|
if( allDevices.Length<=0 )
|
|||
|
|
Warning( "Platform "+p.Name+" has no devices" );
|
|||
|
|
|
|||
|
|
cpuDevices = p.QueryDevices(DeviceType.CPU);
|
|||
|
|
gpuDevices = p.QueryDevices(DeviceType.GPU);
|
|||
|
|
acceleratorDevices = p.QueryDevices(DeviceType.ACCELERATOR);
|
|||
|
|
if( allDevices.Length!=cpuDevices.Length+gpuDevices.Length+acceleratorDevices.Length )
|
|||
|
|
Warning( "QueryDevices( DeviceType.ALL ) return length inconsistent with sum of special purpose queries" );
|
|||
|
|
|
|||
|
|
// Create a few contexts and test them
|
|||
|
|
Output( "Testing Platform.CreateDefaultContext()" );
|
|||
|
|
using (Context c = p.CreateDefaultContext())
|
|||
|
|
{
|
|||
|
|
Output("Testing context"+c);
|
|||
|
|
TestContext(c);
|
|||
|
|
}
|
|||
|
|
Output("");
|
|||
|
|
Output("");
|
|||
|
|
|
|||
|
|
if (cpuDevices.Length > 0)
|
|||
|
|
{
|
|||
|
|
Output("Testing Platform.CreateContext()");
|
|||
|
|
using (Context c = p.CreateContext(null, cpuDevices, new ContextNotify(ContextNotifyFunc), (IntPtr)0x01234567))
|
|||
|
|
{
|
|||
|
|
Output("Testing context" + c);
|
|||
|
|
TestContext(c);
|
|||
|
|
}
|
|||
|
|
Output("");
|
|||
|
|
Output("");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (gpuDevices.Length > 0)
|
|||
|
|
{
|
|||
|
|
Output("Testing Platform.CreateContext()");
|
|||
|
|
using (Context c = p.CreateContext(null, gpuDevices, new ContextNotify(ContextNotifyFunc), (IntPtr)0x01234567))
|
|||
|
|
{
|
|||
|
|
Output("Testing context" + c);
|
|||
|
|
TestContext(c);
|
|||
|
|
}
|
|||
|
|
Output("");
|
|||
|
|
Output("");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (cpuDevices.Length > 0)
|
|||
|
|
{
|
|||
|
|
Output("Testing Platform.CreateContextFromType()");
|
|||
|
|
IntPtr[] contextProperties = new IntPtr[]
|
|||
|
|
{
|
|||
|
|
(IntPtr)ContextProperties.PLATFORM, p.PlatformID,
|
|||
|
|
IntPtr.Zero
|
|||
|
|
};
|
|||
|
|
using (Context c = p.CreateContextFromType(contextProperties, DeviceType.CPU, new ContextNotify(ContextNotifyFunc), (IntPtr)0x01234567))
|
|||
|
|
{
|
|||
|
|
Output("Testing context" + c);
|
|||
|
|
TestContext(c);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (gpuDevices.Length > 0)
|
|||
|
|
{
|
|||
|
|
Output("Testing Platform.CreateContextFromType()");
|
|||
|
|
IntPtr[] contextProperties = new IntPtr[]
|
|||
|
|
{
|
|||
|
|
(IntPtr)ContextProperties.PLATFORM, p.PlatformID,
|
|||
|
|
IntPtr.Zero
|
|||
|
|
};
|
|||
|
|
using (Context c = p.CreateContextFromType(contextProperties, DeviceType.GPU, new ContextNotify(ContextNotifyFunc), (IntPtr)0x01234567))
|
|||
|
|
{
|
|||
|
|
Output("Testing context" + c);
|
|||
|
|
TestContext(c);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void ContextNotifyFunc( string errInfo, byte[] privateInfo, IntPtr cb, IntPtr userData )
|
|||
|
|
{
|
|||
|
|
Error(errInfo);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int NativeKernelCalled = 0;
|
|||
|
|
NativeKernel NativeKernelCallRef;
|
|||
|
|
|
|||
|
|
private void TestContext(Context c)
|
|||
|
|
{
|
|||
|
|
Device[] devices = c.Devices;
|
|||
|
|
OpenCLNet.Program p = c.CreateProgramFromFile("MemoryTests.cl");
|
|||
|
|
Dictionary<string, Kernel> kernelDictionary;
|
|||
|
|
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
p.Build();
|
|||
|
|
}
|
|||
|
|
catch (OpenCLException ocle)
|
|||
|
|
{
|
|||
|
|
throw ocle;
|
|||
|
|
}
|
|||
|
|
kernelDictionary = p.CreateKernelDictionary();
|
|||
|
|
NativeKernelCallRef = new NativeKernel(NativeKernelTest);
|
|||
|
|
for (int deviceIndex = 0; deviceIndex < devices.Length; deviceIndex++)
|
|||
|
|
{
|
|||
|
|
Device d;
|
|||
|
|
|
|||
|
|
d = devices[deviceIndex];
|
|||
|
|
using (CommandQueue cq = c.CreateCommandQueue(d))
|
|||
|
|
{
|
|||
|
|
if ( (d.ExecutionCapabilities & (ulong)DeviceExecCapabilities.NATIVE_KERNEL)!=0 )
|
|||
|
|
{
|
|||
|
|
Output("Testing native kernel execution");
|
|||
|
|
cq.EnqueueNativeKernel(NativeKernelCallRef);
|
|||
|
|
cq.EnqueueBarrier();
|
|||
|
|
if (NativeKernelCalled != 1)
|
|||
|
|
Error("EnqueueNativeKernel failed");
|
|||
|
|
Interlocked.Decrement(ref NativeKernelCalled);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
Output("Testing native kernel execution: Not supported");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
TestMem(c, cq, kernelDictionary);
|
|||
|
|
TestDevice(d);
|
|||
|
|
TestCommandQueue(c, cq);
|
|||
|
|
TestKernel(c, cq, kernelDictionary["ArgIO"]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public unsafe void NativeKernelTest(IntPtr args)
|
|||
|
|
{
|
|||
|
|
Interlocked.Increment(ref NativeKernelCalled);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[StructLayout(LayoutKind.Sequential, Pack=1)]
|
|||
|
|
internal struct IOKernelArgs
|
|||
|
|
{
|
|||
|
|
internal long outLong;
|
|||
|
|
internal int outInt;
|
|||
|
|
internal float outSingle;
|
|||
|
|
internal IntPtr outIntPtr;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private unsafe void TestKernel(Context c, CommandQueue cq, Kernel argIOKernel)
|
|||
|
|
{
|
|||
|
|
Mem outArgBuffer = c.CreateBuffer(MemFlags.WRITE_ONLY, sizeof(IOKernelArgs), IntPtr.Zero);
|
|||
|
|
|
|||
|
|
Output("Testing kernel - Argument return");
|
|||
|
|
|
|||
|
|
argIOKernel.SetIntArg(0, 1);
|
|||
|
|
argIOKernel.SetLongArg(1, 65);
|
|||
|
|
argIOKernel.SetSingleArg(2, 38.4f);
|
|||
|
|
argIOKernel.SetIntPtrArg(3, new IntPtr(0x01234567));
|
|||
|
|
argIOKernel.SetIntPtrArg(4, outArgBuffer.MemID);
|
|||
|
|
|
|||
|
|
cq.EnqueueTask(argIOKernel);
|
|||
|
|
|
|||
|
|
IntPtr outArgPtr = cq.EnqueueMapBuffer( outArgBuffer, true, MapFlags.READ, IntPtr.Zero, (IntPtr)sizeof(IOKernelArgs) );
|
|||
|
|
IOKernelArgs args = (IOKernelArgs)Marshal.PtrToStructure(outArgPtr, typeof(IOKernelArgs));
|
|||
|
|
cq.EnqueueUnmapMemObject(outArgBuffer, outArgPtr);
|
|||
|
|
|
|||
|
|
if (args.outInt != 1)
|
|||
|
|
Error("argIOKernel failed to return correct arguments");
|
|||
|
|
if (args.outLong != 65)
|
|||
|
|
Error("argIOKernel failed to return correct arguments");
|
|||
|
|
if (args.outSingle != 38.4f)
|
|||
|
|
Error("argIOKernel failed to return correct arguments");
|
|||
|
|
if (args.outIntPtr != new IntPtr(0x01234567))
|
|||
|
|
Error("argIOKernel failed to return correct arguments");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void TestMem(Context c, CommandQueue cq, Dictionary<string, Kernel> kernelDictionary )
|
|||
|
|
{
|
|||
|
|
long size = 8192;
|
|||
|
|
|
|||
|
|
Output( "Testing Mem class" );
|
|||
|
|
Output( "Allocating "+size+" bytes of READ_WRITE memory" );
|
|||
|
|
using (Mem buffer = c.CreateBuffer(MemFlags.READ_WRITE, size, IntPtr.Zero))
|
|||
|
|
{
|
|||
|
|
Output("Mem.MemSize=" + size);
|
|||
|
|
if (buffer.MemSize.ToInt64() != size)
|
|||
|
|
Error("Mem.Size!=input size");
|
|||
|
|
Output("Mem.MemType=" + buffer.MemType);
|
|||
|
|
if (buffer.MemType != MemObjectType.BUFFER)
|
|||
|
|
Error("Mem.MemType!=MemObjectType.BUFFER");
|
|||
|
|
|
|||
|
|
Output("Mem.MapCount=" + buffer.MapCount);
|
|||
|
|
if (buffer.MapCount != 0)
|
|||
|
|
Error("Mem.MapCount!=0");
|
|||
|
|
|
|||
|
|
Kernel k = kernelDictionary["TestReadWriteMemory"];
|
|||
|
|
k.SetArg(0, buffer);
|
|||
|
|
k.SetArg(1, (IntPtr)size);
|
|||
|
|
cq.EnqueueTask(k);
|
|||
|
|
cq.EnqueueBarrier();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Output("Allocating " + size + " bytes of READ memory");
|
|||
|
|
using (Mem buffer = c.CreateBuffer(MemFlags.READ_ONLY, size, IntPtr.Zero))
|
|||
|
|
{
|
|||
|
|
Output("Mem.MemSize=" + size);
|
|||
|
|
if (buffer.MemSize.ToInt64() != size)
|
|||
|
|
Error("Mem.Size!=input size");
|
|||
|
|
Output("Mem.MemType=" + buffer.MemType);
|
|||
|
|
if (buffer.MemType != MemObjectType.BUFFER)
|
|||
|
|
Error("Mem.MemType!=MemObjectType.BUFFER");
|
|||
|
|
|
|||
|
|
Output("Mem.MapCount=" + buffer.MapCount);
|
|||
|
|
if (buffer.MapCount != 0)
|
|||
|
|
Error("Mem.MapCount!=0");
|
|||
|
|
|
|||
|
|
Kernel k = kernelDictionary["TestReadMemory"];
|
|||
|
|
k.SetArg(0, buffer);
|
|||
|
|
k.SetArg(1, (IntPtr)size);
|
|||
|
|
cq.EnqueueTask(k);
|
|||
|
|
cq.EnqueueBarrier();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Output("Allocating " + size + " bytes of WRITE memory");
|
|||
|
|
using (Mem buffer = c.CreateBuffer(MemFlags.WRITE_ONLY, size, IntPtr.Zero))
|
|||
|
|
{
|
|||
|
|
Output("Mem.MemSize=" + size);
|
|||
|
|
if (buffer.MemSize.ToInt64() != size)
|
|||
|
|
Error("Mem.Size!=input size");
|
|||
|
|
Output("Mem.MemType=" + buffer.MemType);
|
|||
|
|
if (buffer.MemType != MemObjectType.BUFFER)
|
|||
|
|
Error("Mem.MemType!=MemObjectType.BUFFER");
|
|||
|
|
|
|||
|
|
Output("Mem.MapCount=" + buffer.MapCount);
|
|||
|
|
if (buffer.MapCount != 0)
|
|||
|
|
Error("Mem.MapCount!=0");
|
|||
|
|
|
|||
|
|
Kernel k = kernelDictionary["TestWriteMemory"];
|
|||
|
|
k.SetArg(0, buffer);
|
|||
|
|
k.SetArg(1, (IntPtr)size);
|
|||
|
|
cq.EnqueueTask(k);
|
|||
|
|
cq.EnqueueBarrier();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void TestDevice( Device d )
|
|||
|
|
{
|
|||
|
|
Output("Testing device: " + d.Name);
|
|||
|
|
// d.ToString() is overloaded to output all properties as a string, so every property will be used that way
|
|||
|
|
Output(d.ToString());
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void TestCommandQueue(Context c, CommandQueue cq )
|
|||
|
|
{
|
|||
|
|
string programName = @"MemoryTests.cl";
|
|||
|
|
|
|||
|
|
Output("Testing compilation of: " + programName);
|
|||
|
|
OpenCLNet.Program p0 = c.CreateProgramWithSource(File.ReadAllLines(programName));
|
|||
|
|
OpenCLNet.Program p = c.CreateProgramWithSource(File.ReadAllText(programName));
|
|||
|
|
p0.Build();
|
|||
|
|
p.Build();
|
|||
|
|
Kernel k = p.CreateKernel(@"LoopAndDoNothing");
|
|||
|
|
|
|||
|
|
TestCommandQueueMemCopy(c, cq);
|
|||
|
|
TestCommandQueueAsync(c, cq, k );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#region TestCommandQueue helper functions
|
|||
|
|
|
|||
|
|
private void TestCommandQueueAsync(Context c, CommandQueue cq, Kernel kernel )
|
|||
|
|
{
|
|||
|
|
List<Event> events = new List<Event>();
|
|||
|
|
Event clEvent;
|
|||
|
|
|
|||
|
|
Output("Testing asynchronous task issuing (clEnqueueTask) and waiting for events");
|
|||
|
|
|
|||
|
|
// Issue a bunch of slow operations
|
|||
|
|
kernel.SetArg(0, 5000000);
|
|||
|
|
for (int i = 0; i < 10; i++)
|
|||
|
|
{
|
|||
|
|
cq.EnqueueTask(kernel, 0, null, out clEvent);
|
|||
|
|
events.Add(clEvent);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Issue a bunch of fast operations
|
|||
|
|
kernel.SetArg(0, 500);
|
|||
|
|
for (int i = 0; i < 1000; i++)
|
|||
|
|
{
|
|||
|
|
cq.EnqueueTask(kernel, 0, null, out clEvent);
|
|||
|
|
events.Add(clEvent);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Event[] eventList = events.ToArray();
|
|||
|
|
cq.EnqueueWaitForEvents(eventList.Length, eventList);
|
|||
|
|
while (events.Count > 0)
|
|||
|
|
{
|
|||
|
|
events[0].Dispose();
|
|||
|
|
events.RemoveAt(0);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void TestCommandQueueMemCopy(Context c, CommandQueue cq)
|
|||
|
|
{
|
|||
|
|
AlignedArrayFloat aafSrc = new AlignedArrayFloat(1024 * 1024, 64);
|
|||
|
|
AlignedArrayFloat aafDst = new AlignedArrayFloat(1024 * 1024, 64);
|
|||
|
|
|
|||
|
|
SetAAF(aafSrc, 0.0f);
|
|||
|
|
SetAAF(aafDst, 1.0f);
|
|||
|
|
|
|||
|
|
/// Test HOST_PTR -> HOST_PTR copy
|
|||
|
|
/// The call to EnqueueMapBuffer synchronizes caches before testing the result
|
|||
|
|
Output("Testing synchronous host memory->memory copy(clEnqueueCopyBuffer)");
|
|||
|
|
using (Mem memSrc = c.CreateBuffer(MemFlags.USE_HOST_PTR, aafSrc.ByteLength, aafSrc))
|
|||
|
|
{
|
|||
|
|
using (Mem memDst = c.CreateBuffer(MemFlags.USE_HOST_PTR, aafDst.ByteLength, aafDst))
|
|||
|
|
{
|
|||
|
|
cq.EnqueueCopyBuffer(memSrc, memDst, IntPtr.Zero, IntPtr.Zero, (IntPtr)aafSrc.ByteLength);
|
|||
|
|
cq.EnqueueBarrier();
|
|||
|
|
IntPtr mappedPtr = cq.EnqueueMapBuffer(memDst, true, MapFlags.READ, (IntPtr)0, (IntPtr)aafDst.ByteLength);
|
|||
|
|
if (!TestAAF(aafDst, 0.0f))
|
|||
|
|
Error("EnqueueCopyBuffer failed, destination is invalid");
|
|||
|
|
cq.EnqueueUnmapMemObject(memDst, mappedPtr);
|
|||
|
|
cq.EnqueueBarrier();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// Test COPY_HOST_PTR -> COPY_HOST_PTR copy
|
|||
|
|
/// Verify that original source buffers are intact and that the copy was successful
|
|||
|
|
Output("Testing synchronous host memory->memory copy(clEnqueueCopyBuffer)");
|
|||
|
|
SetAAF(aafSrc, 0.0f);
|
|||
|
|
SetAAF(aafDst, 1.0f);
|
|||
|
|
using (Mem memSrc = c.CreateBuffer(MemFlags.COPY_HOST_PTR, aafSrc.ByteLength, aafSrc))
|
|||
|
|
{
|
|||
|
|
using (Mem memDst = c.CreateBuffer(MemFlags.COPY_HOST_PTR, aafSrc.ByteLength, aafDst))
|
|||
|
|
{
|
|||
|
|
SetAAF(aafSrc, 2.0f);
|
|||
|
|
SetAAF(aafDst, 3.0f);
|
|||
|
|
|
|||
|
|
cq.EnqueueCopyBuffer(memSrc, memDst, IntPtr.Zero, IntPtr.Zero, (IntPtr)aafSrc.ByteLength);
|
|||
|
|
cq.Finish();
|
|||
|
|
|
|||
|
|
if (!TestAAF(aafSrc, 2.0f))
|
|||
|
|
Error("Memory copy destroyed src buffer");
|
|||
|
|
if (!TestAAF(aafDst, 3.0f))
|
|||
|
|
Error("Memory copy destroyed dst buffer");
|
|||
|
|
|
|||
|
|
cq.EnqueueReadBuffer(memDst, true, IntPtr.Zero, (IntPtr)aafDst.ByteLength, aafDst);
|
|||
|
|
cq.Finish();
|
|||
|
|
if (!TestAAF(aafDst, 0.0f))
|
|||
|
|
Error("Memory copy failed");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// Test ALLOC_HOST_PTR -> ALLOC_HOST_PTR copy
|
|||
|
|
Output("Testing synchronous host memory->memory copy(clEnqueueCopyBuffer)");
|
|||
|
|
SetAAF(aafSrc, 0.0f);
|
|||
|
|
SetAAF(aafDst, 1.0f);
|
|||
|
|
using (Mem memSrc = c.CreateBuffer((MemFlags)((ulong)MemFlags.ALLOC_HOST_PTR + (ulong)MemFlags.READ_WRITE), aafSrc.ByteLength, IntPtr.Zero))
|
|||
|
|
{
|
|||
|
|
using (Mem memDst = c.CreateBuffer((MemFlags)((ulong)MemFlags.ALLOC_HOST_PTR + (ulong)MemFlags.WRITE_ONLY), aafSrc.ByteLength, IntPtr.Zero))
|
|||
|
|
{
|
|||
|
|
cq.EnqueueWriteBuffer(memSrc, false, (IntPtr)0, (IntPtr)aafSrc.ByteLength, aafSrc);
|
|||
|
|
cq.EnqueueWriteBuffer(memDst, false, (IntPtr)0, (IntPtr)aafSrc.ByteLength, aafSrc);
|
|||
|
|
cq.EnqueueBarrier();
|
|||
|
|
|
|||
|
|
cq.EnqueueCopyBuffer(memSrc, memDst, IntPtr.Zero, IntPtr.Zero, (IntPtr)aafSrc.ByteLength);
|
|||
|
|
cq.EnqueueBarrier();
|
|||
|
|
|
|||
|
|
cq.EnqueueReadBuffer(memDst, true, IntPtr.Zero, (IntPtr)aafDst.ByteLength, aafDst);
|
|||
|
|
if (!TestAAF(aafDst, 0.0f))
|
|||
|
|
Error("Memory copy failed");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// Test DEFAULT -> DEFAULT copy
|
|||
|
|
Output("Testing synchronous host memory->memory copy(clEnqueueCopyBuffer)");
|
|||
|
|
SetAAF(aafSrc, 0.0f);
|
|||
|
|
SetAAF(aafDst, 1.0f);
|
|||
|
|
using (Mem memSrc = c.CreateBuffer((MemFlags)((ulong)MemFlags.ALLOC_HOST_PTR + (ulong)MemFlags.READ_ONLY), aafSrc.ByteLength, IntPtr.Zero))
|
|||
|
|
{
|
|||
|
|
using (Mem memDst = c.CreateBuffer((MemFlags)((ulong)MemFlags.ALLOC_HOST_PTR + (ulong)MemFlags.WRITE_ONLY), aafSrc.ByteLength, IntPtr.Zero))
|
|||
|
|
{
|
|||
|
|
cq.EnqueueWriteBuffer(memSrc, false, (IntPtr)0, (IntPtr)aafSrc.ByteLength, aafSrc);
|
|||
|
|
cq.EnqueueWriteBuffer(memDst, false, (IntPtr)0, (IntPtr)aafSrc.ByteLength, aafSrc);
|
|||
|
|
cq.EnqueueBarrier();
|
|||
|
|
|
|||
|
|
cq.EnqueueCopyBuffer(memSrc, memDst, IntPtr.Zero, IntPtr.Zero, (IntPtr)aafSrc.ByteLength);
|
|||
|
|
cq.EnqueueBarrier();
|
|||
|
|
|
|||
|
|
cq.EnqueueReadBuffer(memDst, true, IntPtr.Zero, (IntPtr)aafDst.ByteLength, aafDst);
|
|||
|
|
if (!TestAAF(aafDst, 0.0f))
|
|||
|
|
Error("Memory copy failed");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private bool TestAAF(AlignedArrayFloat aaf, float c)
|
|||
|
|
{
|
|||
|
|
for (int i = 0; i < aaf.Length; i++)
|
|||
|
|
if (aaf[i] != c)
|
|||
|
|
return false;
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void SetAAF(AlignedArrayFloat aaf, float c)
|
|||
|
|
{
|
|||
|
|
for (int i = 0; i < aaf.Length; i++)
|
|||
|
|
aaf[i] = c;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void SetAAFLinear(AlignedArrayFloat aaf)
|
|||
|
|
{
|
|||
|
|
for (int i = 0; i < aaf.Length; i++)
|
|||
|
|
aaf[i] = (float)i;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
private void Output(string s)
|
|||
|
|
{
|
|||
|
|
listBoxOutput.Items.Add(s);
|
|||
|
|
Application.DoEvents();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void Warning(string s)
|
|||
|
|
{
|
|||
|
|
listBoxWarnings.Items.Add(s);
|
|||
|
|
Application.DoEvents();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void Error(string s)
|
|||
|
|
{
|
|||
|
|
listBoxErrors.Items.Add(s);
|
|||
|
|
Application.DoEvents();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|