private void RefreshDevicesList(OpenCLManager oclManager)
{
devicesAvailable.Clear();
int c = 0;
if (oclManager != null)
{
foreach (var device in oclManager.Context.Devices)
{
string deviceName = device.Vendor + ":" + device.Name;
deviceSettings.Add(new OpenCLDeviceSettings(this)
{
name = deviceName, index = c, mode = 1, UseDevice = false
});
devicesAvailable.Add(deviceName);
c++;
}
}
DevicesAvailable = devicesAvailable; //refresh list
if (devicesAvailable.Count > 0)
{
OpenCLDevice = 0;
}
else
{
this.openCLDevice = -1;
}
}
//functions
public static void initScan(OpenCLManager OCLManager, CommandQueue cqCommandQueue, int numDataShift, int chunkSize)
{
Debug.Log(" ...loading Scan.cl and creating scan program then build it\n");
Program cpProgram;
for (int i = 0; i < WORKGROUP_SIZE_AVAILABLE.Length; i++)
{
OCLManager.BuildOptions = "-D WORKGROUP_SIZE=" + WORKGROUP_SIZE_AVAILABLE[i];
OCLManager.Defines = "";
try{
TextAsset srcKernel = Resources.Load("OclKernel/Scan") as TextAsset;
cpProgram = OCLManager.CompileSource(srcKernel.text); // TODO : seperate 4 file to reuse binary
srcKernel = null;
}
catch (OpenCLBuildException e) {
string log = "CL Kernel Error: ";
for (int j = 0; j < e.BuildLogs.Count; j++)
{
log += e.BuildLogs[j];
}
Debug.LogError(log);
throw;
return;
}
ckScanExclusiveLocal1Array[i] = cpProgram.CreateKernel("scanExclusiveLocal1");
ckScanExclusiveLocal2Array[i] = cpProgram.CreateKernel("scanExclusiveLocal2");
ckUniformUpdateArray[i] = cpProgram.CreateKernel("uniformUpdate");
}
cpProgram = null;
/* TODO : check
* Debug.Log( " ...checking minimum supported workgroup size\n");
* //Check for work group size
* cl_device_id device;
* uint szScanExclusiveLocal1, szScanExclusiveLocal2, szUniformUpdate;
* ciErrNum = clGetCommandQueueInfo(cqParamCommandQue, CL_QUEUE_DEVICE, sizeof(cl_device_id), &device, NULL);
* ciErrNum |= clGetKernelWorkGroupInfo(ckScanExclusiveLocal1, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(uint), &szScanExclusiveLocal1, NULL);
* ciErrNum |= clGetKernelWorkGroupInfo(ckScanExclusiveLocal2, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(uint), &szScanExclusiveLocal2, NULL);
* ciErrNum |= clGetKernelWorkGroupInfo(ckUniformUpdate, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(uint), &szUniformUpdate, NULL);
*
* if( (szScanExclusiveLocal1 < WORKGROUP_SIZE) || (szScanExclusiveLocal2 < WORKGROUP_SIZE) || (szUniformUpdate < WORKGROUP_SIZE) ){
* Debug.Log("ERROR: Minimum work-group size %u required by this application is not supported on this device.\n", WORKGROUP_SIZE);
* return false;
* }
*/
Debug.Log(" ...allocating internal buffers\n");
// allocate offset data
OFS_DATA_SIZE = (1 << (numDataShift - 9)); // (max_voxel_num/512)
ofsDataArray = new int[OFS_DATA_SIZE + SUM_DATA_SIZE];
hofsDataArray = GCHandle.Alloc(ofsDataArray, GCHandleType.Pinned);
d_Buffer = OCLManager.Context.CreateBuffer(MemFlags.READ_WRITE, (BUFFER_LENGTH + OFS_DATA_SIZE + SUM_DATA_SIZE) * sizeof(uint));
}
private static void CreateOclManagers() // Create an OpenCLManager for each platform
{
instances = new List <OpenCLManager>();
int nPlatforms = OpenCL.NumberOfPlatforms;
Debug.Log("[OCLLOG]:Platform Count:" + nPlatforms);
if (nPlatforms <= 0)
{
Debug.LogError("[OCLLOG]:OpenCLIs[NOT]Available");
return;
}
for (int pIdx = 0; pIdx < nPlatforms; pIdx++)
{
OpenCLNet.Platform platform = OpenCLNet.OpenCL.GetPlatform(pIdx);
OpenCLNet.Device[] devices = platform.QueryDevices(OpenCLNet.DeviceType.ALL);
int nDevices = devices.Length;
if (nDevices <= 0)
{
Debug.LogError("[OCLLOG]:No OpenCL devices found that matched filter criteria on Platform_" + platform.Name);
continue;
}
// We might use the whole devices as CreateContext para, but we don't do so.
// Here create a oclMan for each device because
// the same platform will build kernel for each device in its context and can be failed
// (such as apple, failed in building kernel on HD6630M, succeeded on intel cpu)
for (int dIdx = 0; dIdx < nDevices; dIdx++)
{
try{
Debug.Log("[OCLLOG]:Creating OCL on Platform_" + platform.Name + "+Device_" + devices[dIdx].Name);
OpenCLManager oclMan = new OpenCLManager();
oclMan.SourcePath = OclSourcePath;
oclMan.BinaryPath = OclBinaryPath;
IntPtr[] properties = new IntPtr[]
{
(IntPtr)ContextProperties.PLATFORM, platform,
IntPtr.Zero
};
OpenCLNet.Device[] devicesEnum = new Device[] { devices[dIdx] };
oclMan.CreateContext(platform, properties, devicesEnum);
instances.Add(oclMan);
}
catch (Exception e) {
Debug.Log("[OCLLOG]Exception at Platform_" + platform.Name + "+Device_" + devices[dIdx].Name + ":" + e.Message);
}
}
}
}
public KeySearcherSettings(KeySearcher ks, OpenCLManager oclManager)
{
keysearcher = ks;
RefreshDevicesList(oclManager);
CoresAvailable.Clear();
for (int i = -1; i < Environment.ProcessorCount; i++)
{
CoresAvailable.Add((i + 1).ToString());
}
CoresUsed = Environment.ProcessorCount - 1;
chunkSize = 21;
KeyManager = new SimpleKeyManager("");
}
public static bool InitOclFromOpt() // true: Succeeded; false: failed and use CPU instead
{
ActiveOclMan = null;
ActiveOclCQ = null;
if (0 == string.Compare(OptCpuMask, 0, CurOclOpt, 0, OptCpuMask.Length))
{
Debug.Log("[OCLLOG]Succeed to init with " + CurOclOpt);
return(true);
}
if (instances == null)
{
CreateOclManagers();
}
try{
foreach (OpenCLManager oclMan in instances)
{
string platformName16 = oclMan.Platform.Name.Length > 16 ? oclMan.Platform.Name.Substring(0, 16) : oclMan.Platform.Name.PadRight(16, ' ');
foreach (CommandQueue cq in oclMan.CQ)
{
string opt = (OptOclMask + "|" + platformName16 + "|" + cq.Device.Name).Replace(' ', '_');
if (0 == string.Compare(opt, CurOclOpt))
{
ActiveOclMan = oclMan;
ActiveOclCQ = cq;
if (oclMarchingCube.InitMC())
{
Debug.Log("[OCLLOG]Succeed to init with " + CurOclOpt);
return(true);
}
else
{
throw new Exception("Failed to init with " + CurOclOpt);
}
}
}
}
}
catch {}
Debug.Log("[OCLLOG]Fallback to CPU because of failure to init with " + CurOclOpt);
ActiveOclMan = null;
ActiveOclCQ = null;
CurOclOpt = OptCpuMask;
return(false);
}
/// <summary>
/// Create a OpenCLManager, configure it, and then create a context using all devices in platform 0,
/// Once the context is up and running we compile our source file "OpenCLFunctions.cl"
/// The Helper automatically compiles and creates kernels.
/// We can then extract named kernels using the GetKernel method.
///
/// For more advanced scenarios, one might use the functions in the Platform class
/// to query devices, create contexts etc. Platforms can be enumerated using
/// for( int i=0; i<OpenCL.NumberofPlatforms; i++ )
/// Platform p = OpenCL.GetPlatform(i);
/// </summary>
private void InitializeOpenCL()
{
if (OpenCL.NumberOfPlatforms == 0)
{
MessageBox.Show("OpenCL not available");
Application.Exit();
}
OCLMan = new OpenCLManager();
// Attempt to save binaries after compilation, as well as load precompiled binaries
// to avoid compilation. Usually you'll want this to be true.
OCLMan.AttemptUseBinaries = true;
// Attempt to compile sources. This should probably be true for almost all projects.
// Setting it to false means that when you attempt to compile "mysource.cl", it will
// only scan the precompiled binary directory for a binary corresponding to a source
// with that name. There's a further restriction that the compiled binary also has to
// use the same Defines and BuildOptions
OCLMan.AttemptUseSource = true;
// Binary and source paths
// This is where we store our sources and where compiled binaries are placed
OCLMan.BinaryPath = @"OpenCL\bin";
OCLMan.SourcePath = @"OpenCL\src";
// If true, RequireImageSupport will filter out any devices without image support
// In this project we don't need image support though, so we set it to false
OCLMan.RequireImageSupport = false;
// The Defines string gets prepended to any and all sources that are compiled
// and serve as a convenient way to pass configuration information to the compilation process
OCLMan.Defines = "#define MyCompany_MyProject_Define 1";
// The BuildOptions string is passed directly to clBuild and can be used to do debug builds etc
OCLMan.BuildOptions = "";
OCLMan.CreateDefaultContext(0, DeviceType.ALL);
OCLProgram = OCLMan.CompileFile("OpenCLFunctions.cl");
for (int i = 0; i < OCLMan.Context.Devices.Length; i++)
{
comboBoxDeviceSelector.Items.Add(OCLMan.Context.Devices[i].Vendor + ":" + OCLMan.Context.Devices[i].Name);
}
comboBoxDeviceSelector.SelectedIndex = 0;
CrossFadeKernel = OCLProgram.CreateKernel("CrossFade");
}
private void InitializeOpenCL()
{
if (OpenCL.NumberOfPlatforms == 0)
{
MessageBox.Show("OpenCL не поддерживается вашей системой!");
Application.Exit();
}
manager = new OpenCLManager();
manager.AttemptUseBinaries = true;
manager.AttemptUseSource = true;
manager.RequireImageSupport = false;
manager.BuildOptions = "";
manager.CreateDefaultContext(0, DeviceType.ALL);
// Компиляция OpenCL кода
program = manager.CompileSource(Properties.Resources.DVR);
kernel = program.CreateKernel("DVR");
}
/// <summary>
/// Generates the OpenCL code and creates the kernel out of it.
/// </summary>
/// <param name="oclManager">The OpenCL manager to use.</param>
/// <param name="keyTranslator">The KeyTranslator to use. This is important for mapping the key movements to code.</param>
/// <returns>The Kernel</returns>
public Kernel GetBruteforceKernel(OpenCLManager oclManager, IKeyTranslator keyTranslator)
{
//caching:
if (keyTranslatorOfCode == keyTranslator)
{
return(openCLKernel);
}
try
{
var program = oclManager.CompileSource(CreateOpenCLBruteForceCode(keyTranslator));
//keySearcher.GuiLogMessage(string.Format("Using OpenCL with (virtually) {0} threads.", keyTranslator.GetOpenCLBatchSize()), NotificationLevel.Info);
openCLKernel = program.CreateKernel("bruteforceKernel");
return(openCLKernel);
}
catch (Exception ex)
{
throw new Exception(Resources.An_error_occured_when_trying_to_compile_OpenCL_code__ + ex.Message);
}
}
private void RefreshDevicesList( )
{
var oclManager = new OpenCLManager();
devicesAvailable.Clear();
for (var id = 0; id < OpenCL.GetPlatforms().Length; id++)
{
oclManager.CreateDefaultContext(id, DeviceType.ALL);
int c = 0;
if (oclManager != null)
{
foreach (var device in oclManager.Context.Devices)
{
devicesAvailable.Add(c + ": " + device.Vendor + " - " + device.Name);
c++;
}
}
}
DevicesAvailable = devicesAvailable;
}
/* Создает новый объем размера size*size*size */
public VoxelVolume(int size, OpenCLManager openClManager)
{
data = new short[size * size * size];
size_this = size;
manager_this = openClManager;
}
public unsafe void InitTasks()
{
if (!inited)
{
if (OpenCL.NumberOfPlatforms < 1)
{
throw new Exception("no opencl platforms found");
}
int groupSize = _settings.DeviceType == OpenCLDeviceType.CPU ? 1 : _settings.GroupSize;
OCLMan = new OpenCLManager();
// Attempt to save binaries after compilation, as well as load precompiled binaries
// to avoid compilation. Usually you'll want this to be true.
OCLMan.AttemptUseBinaries = true; // true;
// Attempt to compile sources. This should probably be true for almost all projects.
// Setting it to false means that when you attempt to compile "mysource.cl", it will
// only scan the precompiled binary directory for a binary corresponding to a source
// with that name. There's a further restriction that the compiled binary also has to
// use the same Defines and BuildOptions
OCLMan.AttemptUseSource = true;
// Binary and source paths
// This is where we store our sources and where compiled binaries are placed
//OCLMan.BinaryPath = @"OpenCL\bin";
//OCLMan.SourcePath = @"OpenCL\src";
// If true, RequireImageSupport will filter out any devices without image support
// In this project we don't need image support though, so we set it to false
OCLMan.RequireImageSupport = false;
// The BuildOptions string is passed directly to clBuild and can be used to do debug builds etc
OCLMan.BuildOptions = "";
OCLMan.SourcePath = System.IO.Path.GetDirectoryName(GetType().Assembly.Location);
OCLMan.BinaryPath = System.IO.Path.Combine(System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "CUE Tools"), "OpenCL");
int platformId = 0;
if (_settings.Platform != null)
{
platformId = -1;
string platforms = "";
for (int i = 0; i < OpenCL.NumberOfPlatforms; i++)
{
var platform = OpenCL.GetPlatform(i);
platforms += " \"" + platform.Name + "\"";
if (platform.Name.Equals(_settings.Platform, StringComparison.InvariantCultureIgnoreCase))
{
platformId = i;
break;
}
}
if (platformId < 0)
{
throw new Exception("unknown platform \"" + _settings.Platform + "\". Platforms available:" + platforms);
}
}
OCLMan.CreateDefaultContext(platformId, (DeviceType)_settings.DeviceType);
this.stridesPerTask = (int)OCLMan.Context.Devices[0].MaxComputeUnits * npar * 8;
// The Defines string gets prepended to any and all sources that are compiled
// and serve as a convenient way to pass configuration information to the compilation process
OCLMan.Defines =
"#define GROUP_SIZE " + groupSize.ToString() + "\n" +
"#define CLPARITY_VERSION \"" + vendor_string + "\"\n" +
#if DEBUG
"#define DEBUG\n" +
#endif
(_settings.DeviceType == OpenCLDeviceType.CPU ? "#define CLPARITY_CPU\n" : "") +
_settings.Defines + "\n";
var exts = new string[] { "cl_khr_local_int32_base_atomics", "cl_khr_local_int32_extended_atomics", "cl_khr_fp64", "cl_amd_fp64" };
foreach (string extension in exts)
{
if (OCLMan.Context.Devices[0].Extensions.Contains(extension))
{
OCLMan.Defines += "#pragma OPENCL EXTENSION " + extension + ": enable\n";
OCLMan.Defines += "#define HAVE_" + extension + "\n";
}
}
try
{
openCLProgram = OCLMan.CompileFile("parity.cl");
}
catch (OpenCLBuildException ex)
{
string buildLog = ex.BuildLogs[0];
throw ex;
}
//using (Stream kernel = GetType().Assembly.GetManifestResourceStream(GetType(), "parity.cl"))
//using (StreamReader sr = new StreamReader(kernel))
//{
// try
// {
// openCLProgram = OCLMan.CompileSource(sr.ReadToEnd()); ;
// }
// catch (OpenCLBuildException ex)
// {
// string buildLog = ex.BuildLogs[0];
// throw ex;
// }
//}
#if TTTTKJHSKJH
var openCLPlatform = OpenCL.GetPlatform(0);
openCLContext = openCLPlatform.CreateDefaultContext();
using (Stream kernel = GetType().Assembly.GetManifestResourceStream(GetType(), "parity.cl"))
using (StreamReader sr = new StreamReader(kernel))
openCLProgram = openCLContext.CreateProgramWithSource(sr.ReadToEnd());
try
{
openCLProgram.Build();
}
catch (OpenCLException)
{
string buildLog = openCLProgram.GetBuildLog(openCLProgram.Devices[0]);
throw;
}
#endif
task1 = new CLParityTask(openCLProgram, this, groupSize, this.npar, this.stride, this.stridesPerTask);
task2 = new CLParityTask(openCLProgram, this, groupSize, this.npar, this.stride, this.stridesPerTask);
inited = true;
}
}
////////////////////////////////////////////////////////////////////////////////
// initialize marching cubes
////////////////////////////////////////////////////////////////////////////////
public static bool InitMC()
{
try{
OCLManager = oclManager.ActiveOclMan;
OCLComQueue = oclManager.ActiveOclCQ;
try
{
oclScanLaucher.initScan(OCLManager, OCLComQueue, VOLUME_VOXEL_X_LEN_SHIFT + VOLUME_VOXEL_Y_LEN_SHIFT + VOLUME_VOXEL_Z_LEN_SHIFT, CHUNK_VOXEL_NUM);
}
catch (Exception e)
{
string log = "[OCLLOG]Kernel Error: ";
OpenCLBuildException eocl = e as OpenCLBuildException;
if (eocl != null)
{
for (int i = 0; i < eocl.BuildLogs.Count; i++)
{
log += eocl.BuildLogs[i];
}
}
else
{
log += e.Message;
}
Debug.LogError(log);
throw;
}
ImageFormat imageFormat = new ImageFormat(CH_ORDER, ChannelType.UNORM_INT8);
bImageFormatSupported = (!OCLComQueue.Device.Name.Contains("RV7") /*!bRV7xxGpu*/ &&
OCLComQueue.Context.SupportsImageFormat(MemFlags.READ_ONLY, MemObjectType.IMAGE3D, imageFormat.ChannelOrder, imageFormat.ChannelType));
//bImageFormatSupported = false;
OCLManager.BuildOptions = "-cl-mad-enable";
OCLManager.Defines = "";
Program cpProgram = null;
while (true)
{
try
{
string mcKernelPathName = bImageFormatSupported ? "OclKernel/marchingCubes_kernel_img" : ("OclKernel/marchingCubes_kernel_u" + VOXEL_SIZE + "b");
TextAsset srcKernel = Resources.Load(mcKernelPathName) as TextAsset;
Debug.Log("[OCLLOG]Build kernel:" + mcKernelPathName);
cpProgram = OCLManager.CompileSource(srcKernel.text);
srcKernel = null;
}
catch (Exception e)
{
string log = "[OCLLOG]Kernel Error: ";
OpenCLBuildException eocl = e as OpenCLBuildException;
if (eocl != null)
{
for (int i = 0; i < eocl.BuildLogs.Count; i++)
{
log += eocl.BuildLogs[i];
}
}
else
{
log += e.Message;
}
Debug.LogError(log);
if (bImageFormatSupported)
{
bImageFormatSupported = false;
Debug.Log("[OCLLOG]Try to build kernel without img support:");
continue;
}
throw;
}
break;
}
classifyVoxelKernel = cpProgram.CreateKernel("classifyVoxel");
compactVoxelsKernel = cpProgram.CreateKernel("compactVoxels");
generateTriangles2Kernel = cpProgram.CreateKernel("generateTriangles2_vec3");
cpProgram = null;
Debug.Log("[OCLLOG]All kernels are ready.");
if (bImageFormatSupported)
{
d_volume = OCLManager.Context.CreateImage3D(MemFlags.READ_ONLY | MemFlags.ALLOC_HOST_PTR,
imageFormat,
VOLUME_VOXEL_X_LEN_REAL, VOLUME_VOXEL_Y_LEN_REAL, VOLUME_VOXEL_Z_LEN_REAL,
0, 0, IntPtr.Zero);
}
else
{
isoValue = 128f;
d_volume = OCLManager.Context.CreateBuffer(MemFlags.READ_ONLY | MemFlags.ALLOC_HOST_PTR,
VOLUME_VOXEL_X_LEN_REAL * VOLUME_VOXEL_Y_LEN_REAL * VOLUME_VOXEL_Z_LEN_REAL * VOXEL_SIZE);
}
// create VBOs --- now use 3 float, nvidia use 4 float originally.
Vector3[] posArray = new Vector3[MAX_VERTS];
Vector2[] norm01Array = new Vector2[MAX_VERTS];
Vector2[] norm2tArray = new Vector2[MAX_VERTS];
hPosArray = GCHandle.Alloc(posArray, GCHandleType.Pinned);
hNorm01Array = GCHandle.Alloc(norm01Array, GCHandleType.Pinned);
hNorm2tArray = GCHandle.Alloc(norm2tArray, GCHandleType.Pinned);
d_pos = OCLManager.Context.CreateBuffer(MemFlags.WRITE_ONLY | MemFlags.USE_HOST_PTR, MAX_VERTS * sizeof(float) * 3, hPosArray.AddrOfPinnedObject());
d_norm01 = OCLManager.Context.CreateBuffer(MemFlags.WRITE_ONLY | MemFlags.USE_HOST_PTR, MAX_VERTS * sizeof(float) * 2, hNorm01Array.AddrOfPinnedObject());
d_norm2t = OCLManager.Context.CreateBuffer(MemFlags.WRITE_ONLY | MemFlags.USE_HOST_PTR, MAX_VERTS * sizeof(float) * 2, hNorm2tArray.AddrOfPinnedObject());
// allocate device memory
uint memSize = sizeof(uint) * MAX_VOXELS;
d_voxelVerts = OCLManager.Context.CreateBuffer(MemFlags.READ_WRITE, memSize);
d_voxelVertsScan = OCLManager.Context.CreateBuffer(MemFlags.READ_WRITE, memSize);
d_voxelOccupied = OCLManager.Context.CreateBuffer(MemFlags.READ_WRITE, memSize);
d_voxelOccupiedScan = OCLManager.Context.CreateBuffer(MemFlags.READ_WRITE, memSize);
d_compVoxelArray = OCLManager.Context.CreateBuffer(MemFlags.READ_WRITE, memSize);
oclMCStatus = 1;
}catch {
oclMCStatus = -1;
Debug.LogError("[OCLLOG]OclMarchingCubes is not available.");
return(false);
}
// Other const helper -- TODO : size should be computed according to IMG_FORMAT
volumeZeroConst = new byte[CHUNK_VOXEL_NUM_REAL * 4]; // all zero
numChunks = 0;
return(true);
}
//functions
public static void initScan(OpenCLManager OCLManager, CommandQueue cqCommandQueue, int numDataShift, int chunkSize)
{
OCLManager.BuildOptions = "";
OCLManager.Defines = "";
Program cpProgram;
try{
TextAsset srcKernel = Resources.Load("OclKernel/ScanLargeArrays_Kernels") as TextAsset;
Debug.Log("[OCLLOG]Build kernel:Scan");
cpProgram = OCLManager.CompileSource(srcKernel.text);
srcKernel = null;
}
catch (OpenCLBuildException e) {
string log = "[OCLLOG]Kernel Error: ";
for (int i = 0; i < e.BuildLogs.Count; i++)
{
log += e.BuildLogs[i];
}
Debug.LogError(log);
throw;
//return;
}
ckScanLargeKernel = cpProgram.CreateKernel("ScanLargeArrays");
ckBlockAddiKernel = cpProgram.CreateKernel("blockAddition");
ckPrefixSumKernel = cpProgram.CreateKernel("prefixSum");
zeromemKernel = cpProgram.CreateKernel("zeromem");
cpProgram = null;
MaxGroupSize = (int)cqCommandQueue.Device.MaxWorkGroupSize;
int maxWorkItemSize = cqCommandQueue.Device.MaxWorkItemSizes[0].ToInt32();
int maxWorkItemSize1 = cqCommandQueue.Device.MaxWorkItemSizes[1].ToInt32();
int maxWorkItemSize2 = cqCommandQueue.Device.MaxWorkItemSizes[2].ToInt32();
Debug.Log("[OCLLOG]SCAN MaxGroup:" + MaxGroupSize + " MaxWorkItem:" + maxWorkItemSize + "," + maxWorkItemSize1 + "," + maxWorkItemSize2);
if (cqCommandQueue.Device.Name.Contains("RV7"))
{
MaxGroupSize = maxWorkItemSize = 32;
Debug.Log("[OCLLOG]SCAN RV7xx lower MaxGroup:" + MaxGroupSize + "MaxWorkItem:" + maxWorkItemSize);
}
#if UNITY_STANDALONE_OSX
else
{
MaxGroupSize = maxWorkItemSize = maxWorkItemSize / 4;
Debug.Log("[OCLLOG]SCAN Apple lower(/4) MaxGroup:" + MaxGroupSize + "MaxWorkItem:" + maxWorkItemSize);
}
#endif
if (maxWorkItemSize > chunkSize)
{
maxWorkItemSize = chunkSize;
}
blockSize = 1; blockSizeShift = 0;
while (blockSize < maxWorkItemSize)
{
blockSize <<= 1; blockSizeShift++;
}
//blockSize >>= 1;blockSizeShift--;
blockSizeUnMask = ~(blockSize - 1);
// compute buffer length and offset
Mem buffBlockSum;
Mem buffTmpOutput;
bool bSumDataAllocated = false;
blockSumBufferList.Add(null); // Add a placeholder for inputBuffer
outBufferList.Add(null); // Add a placeholder
if (numDataShift < blockSizeShift)
{
numDataShift = blockSizeShift; // at least 1 even if blockSizeShift >= numDataShift
}
do
{
numDataShift -= blockSizeShift;
buffBlockSum = OCLManager.Context.CreateBuffer(MemFlags.READ_WRITE, (1 << numDataShift) * sizeof(uint));
blockSumBufferList.Add(buffBlockSum);
if (bSumDataAllocated == false)
{
OFS_DATA_SIZE = (1 << numDataShift);
ofsDataArray = new int[OFS_DATA_SIZE + SUM_DATA_SIZE];
hofsDataArray = GCHandle.Alloc(ofsDataArray, GCHandleType.Pinned);
buffTmpOutput = OCLManager.Context.CreateBuffer(MemFlags.READ_WRITE, (OFS_DATA_SIZE + SUM_DATA_SIZE) * sizeof(uint));
bSumDataAllocated = true;
}
else
{
buffTmpOutput = OCLManager.Context.CreateBuffer(MemFlags.READ_WRITE, (1 << numDataShift) * sizeof(uint));
}
outBufferList.Add(buffTmpOutput);
}while(numDataShift > blockSizeShift);
#if CL_DEBUG
houtArray = GCHandle.Alloc(outArray, GCHandleType.Pinned);
hsumArray = GCHandle.Alloc(sumArray, GCHandleType.Pinned);
#endif
}
