Cekirdekler/Cekirdekler/ClCommandQueue.cs

@@ -31,6 +31,9 @@ internal class ClCommandQueue
         [DllImport("KutuphaneCL", CallingConvention = CallingConvention.Cdecl)]
         private static extern IntPtr createCommandQueue(IntPtr hContext, IntPtr hDevice, int async);
 
+        [DllImport("KutuphaneCL", CallingConvention = CallingConvention.Cdecl)]
+        private static extern IntPtr createCommandQueue2(IntPtr hContext, IntPtr hDevice, int async,bool defaultQueue);
+
         [DllImport("KutuphaneCL", CallingConvention = CallingConvention.Cdecl)]
         private static extern void addMarkerToCommandQueue(IntPtr hCommandQueue);
 
@@ -51,12 +54,32 @@ internal class ClCommandQueue
         /// creates a command queue in a context
         /// </summary>
         /// <param name="context"></param>
+        /// <param name="defaultQueue">OpenCL 2.0 dynamic parallelism queue</param>
         /// <param name="async">async!=0 means out-of-order command queue</param>
-        public ClCommandQueue(ClContext context, int async=0)
+        public ClCommandQueue(ClContext context, bool defaultQueue, int async=0)
         {
             hContext = context.h();
             hDevice = context.hd();
-            hCommandQueue = createCommandQueue(hContext, hDevice,async);
+            if (defaultQueue)
+            {
+                try
+                {
+                    hCommandQueue = createCommandQueue2(hContext, hDevice, async, defaultQueue);
+                }
+                catch(EntryPointNotFoundException epnfe)
+                {
+                    Console.WriteLine("Error: KutuphaneCL.dll's OpenCL2.0 dynamic parallelism support(needs v1.4.1+) not found.");
+                    Console.WriteLine(epnfe.Message);
+                }
+                finally
+                {
+
+                }
+            }
+            else
+            {
+                hCommandQueue = createCommandQueue(hContext, hDevice, async);
+            }
             addedMarkers = 0;
         }
 

Cekirdekler/Cekirdekler/ClCruncherServerThread.cs

@@ -122,7 +122,7 @@ private void f(TcpListener listener, TcpClient client_)
                     int MAX_CPU = ((int[])arrays[6].backingArray)[0];
                     openclSystemToCrunchNumbers = new Cores(
                             deviceTypes, kernelsString,
-                            kernelNamesStringArray, localRAnge,
+                            kernelNamesStringArray,false, localRAnge,
                             numberOfGPUsToUse, GPU_STREAM,
                             MAX_CPU);
                     if(openclSystemToCrunchNumbers.errorCode()!=0)

Cekirdekler/Cekirdekler/ClNumberCruncher.cs

@@ -92,6 +92,19 @@ internal void flush()
             }
         }
 
+        /// <summary>
+        /// for a more fine-grained host control with enqueue mode, 
+        /// this can be used as a forced command issue to device
+        /// that flushes last used command queue
+        /// </summary>
+        public void flushLastUsedCommandQueue()
+        {
+            if (numberCruncher != null)
+            {
+                ClObject.Worker.flush(numberCruncher.lastUsedCommandQueueOfFirstDevice().h());
+            }
+        }
+
         /// <summary>
         /// <para>only for single gpu(or device to device pipeline stages)</para>
         /// <para>used by enqueueMode to distribute each compute job to a different queue or not</para>
@@ -187,6 +200,9 @@ public ClNumberCruncher(AcceleratorType cpuGpu, string kernelString,
                             int numberofCPUCoresToUseAsDeviceFission = -1,
                             int numberOfGPUsToUse = -1, bool stream = true, bool noPipelining=false)
         {
+            bool defaultQueue = false;
+            if (kernelString.Contains("enqueue_kernel("))
+                defaultQueue = true;
             repeatCount = 1;
             numberOfErrorsHappened = 0;
             StringBuilder cpuGpu_ = new StringBuilder("");
@@ -216,7 +232,7 @@ public ClNumberCruncher(AcceleratorType cpuGpu, string kernelString,
                 errorNotification = 1;
                 return;
             }
-            numberCruncher = new Cores(cpuGpu_.ToString(), kernelString, kernelNames_.ToArray(), 256,
+            numberCruncher = new Cores(cpuGpu_.ToString(), kernelString, kernelNames_.ToArray(), defaultQueue, 256,
                 numberOfGPUsToUse, stream, numberofCPUCoresToUseAsDeviceFission, noPipelining);
             if (numberCruncher.errorCode() != 0)
             {
@@ -296,6 +312,9 @@ public string[] deviceNames()
         /// <param name="computeQueueConcurrency">max number of command queues to send commands asynchronously, max=16, min=1</param>
         public ClNumberCruncher(ClDevices devicesForGPGPU, string kernelString,bool noPipelining=false,int computeQueueConcurrency=16)
         {
+            bool defaultQueue = false;
+            if (kernelString.Contains("enqueue_kernel"))
+                defaultQueue = true;
             repeatCount = 1;
             numberOfErrorsHappened = 0;
             List<string> kernelNames_ = new List<string>();
@@ -317,7 +336,7 @@ public ClNumberCruncher(ClDevices devicesForGPGPU, string kernelString,bool noPi
                 errorNotification = 1;
                 return;
             }
-            numberCruncher = new Cores(devicesForGPGPU, kernelString, kernelNames_.ToArray(), computeQueueConcurrency, noPipelining);
+            numberCruncher = new Cores(devicesForGPGPU, kernelString, kernelNames_.ToArray(), defaultQueue, computeQueueConcurrency, noPipelining);
             if (numberCruncher.errorCode() != 0)
             {
                 errorMessage_ = numberCruncher.errorMessage();