Minor API change to improve device picking in multi GPU setup.

diff --git a/MagickCore/accelerate-private.h b/MagickCore/accelerate-private.h
index a9a0563e863d56aae9a930afbdad9a8c3738650f..140e6d01f8380f4e67806a147b543c6167d838d9 100644 (file)
--- a/MagickCore/accelerate-private.h
+++ b/MagickCore/accelerate-private.h
@@ -2618,6 +2618,7 @@ OPENCL_ENDIF()
     event_t e = async_work_group_copy(inputImageCache, inputImage + pos, num_elements, 0);
     wait_group_events(1, &e);
 
+    unsigned int alpha_index = (number_channels == 4) || (number_channels == 2) ? number_channels - 1 : 0;
     unsigned int totalNumChunks = (actualNumPixelToCompute+pixelChunkSize-1)/pixelChunkSize;
     for (unsigned int chunk = 0; chunk < totalNumChunks; chunk++)
     {
@@ -2675,9 +2676,9 @@ OPENCL_ENDIF()
               cp.z = (float) *(p + 2);
             }
 
-            if ((number_channels == 4) || (number_channels == 2))
+            if (alpha_index != 0)
             {
-              cp.w = (float) *(p + number_channels - 1);
+              cp.w = (float) *(p + alpha_index);
 
               float alpha = weight * QuantumScale * cp.w;
 
@@ -2699,7 +2700,7 @@ OPENCL_ENDIF()
       if (itemID < actualNumPixelInThisChunk) {
         outputPixelCache[itemID] = (float4)0.0f;
         densityCache[itemID] = 0.0f;
-        if ((number_channels == 4) || (number_channels == 2))
+        if (alpha_index != 0)
           gammaCache[itemID] = 0.0f;
       }
       barrier(CLK_LOCAL_MEM_FENCE);
@@ -2710,7 +2711,7 @@ OPENCL_ENDIF()
           if (itemID%numItems == i) {
             outputPixelCache[pixelIndex]+=filteredPixel;
             densityCache[pixelIndex]+=density;
-            if ((number_channels == 4) || (number_channels == 2))
+            if (alpha_index != 0)
               gammaCache[pixelIndex]+=gamma;
           }
         }
@@ -2722,7 +2723,7 @@ OPENCL_ENDIF()
         float4 filteredPixel = outputPixelCache[itemID];
 
         float gamma = 0.0f;
-        if ((number_channels == 4) || (number_channels == 2))
+        if (alpha_index != 0)
           gamma = gammaCache[itemID];
 
         float density = densityCache[itemID];
@@ -2733,7 +2734,7 @@ OPENCL_ENDIF()
           gamma *= density;
         }
 
-        if ((number_channels == 4) || (number_channels == 2))
+        if (alpha_index != 0)
         {
           gamma = PerceptibleReciprocal(gamma);
           filteredPixel.x *= gamma;
@@ -2783,6 +2784,7 @@ OPENCL_ENDIF()
       wait_group_events(1,&e);
     }
 
+    unsigned int alpha_index = (number_channels == 4) || (number_channels == 2) ? number_channels - 1 : 0;
     unsigned int totalNumChunks = (actualNumPixelToCompute+pixelChunkSize-1)/pixelChunkSize;
     for (unsigned int chunk = 0; chunk < totalNumChunks; chunk++)
     {
@@ -2839,9 +2841,9 @@ OPENCL_ENDIF()
               cp.z = (float) *(p + (rangeLength * 2));
             }
 
-            if ((number_channels == 4) || (number_channels == 2))
+            if (alpha_index != 0)
             {
-              cp.w = (float) *(p + (rangeLength * (number_channels - 1)));
+              cp.w = (float) *(p + (rangeLength * alpha_index));
 
               float alpha = weight * QuantumScale * cp.w;
 
@@ -2863,7 +2865,7 @@ OPENCL_ENDIF()
       if (itemID < actualNumPixelInThisChunk) {
         outputPixelCache[itemID] = (float4)0.0f;
         densityCache[itemID] = 0.0f;
-        if ((number_channels == 4) || (number_channels == 2))
+        if (alpha_index != 0)
           gammaCache[itemID] = 0.0f;
       }
       barrier(CLK_LOCAL_MEM_FENCE);
@@ -2874,7 +2876,7 @@ OPENCL_ENDIF()
           if (itemID%numItems == i) {
             outputPixelCache[pixelIndex]+=filteredPixel;
             densityCache[pixelIndex]+=density;
-            if ((number_channels == 4) || (number_channels == 2))
+            if (alpha_index != 0)
               gammaCache[pixelIndex]+=gamma;
           }
         }
@@ -2886,7 +2888,7 @@ OPENCL_ENDIF()
         float4 filteredPixel = outputPixelCache[itemID];
 
         float gamma = 0.0f;
-        if ((number_channels == 4) || (number_channels == 2))
+        if (alpha_index != 0)
           gamma = gammaCache[itemID];
 
         float density = densityCache[itemID];
@@ -2897,7 +2899,7 @@ OPENCL_ENDIF()
           gamma *= density;
         }
 
-        if ((number_channels == 4) || (number_channels == 2))
+        if (alpha_index != 0)
         {
           gamma = PerceptibleReciprocal(gamma);
           filteredPixel.x *= gamma;

diff --git a/MagickCore/accelerate.c b/MagickCore/accelerate.c
index 17e9faf0b9b674ff6c1a849fc7000b9a8e77f398..517521f778c1c478e8aaece3c4b797a2b37885ba 100644 (file)
--- a/MagickCore/accelerate.c
+++ b/MagickCore/accelerate.c
@@ -560,7 +560,7 @@ static Image *ComputeAddNoiseImage(const Image *image,MagickCLEnv clEnv,
   filteredImageBuffer = NULL;
   addNoiseKernel = NULL;
 
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
   queue = AcquireOpenCLCommandQueue(device);
 
   image_view=AcquireAuthenticCacheView(image,exception);
@@ -683,10 +683,16 @@ cleanup:
   if (filteredImage_view != NULL)
     filteredImage_view=DestroyCacheView(filteredImage_view);
 
-  if (queue!=NULL)                  RelinquishOpenCLCommandQueue(device, queue);
-  if (addNoiseKernel!=NULL)         RelinquishOpenCLKernel(addNoiseKernel);
-  if (imageBuffer!=NULL)                   clEnv->library->clReleaseMemObject(imageBuffer);
-  if (filteredImageBuffer!=NULL)         clEnv->library->clReleaseMemObject(filteredImageBuffer);
+  if (queue!=NULL)
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
+  if (addNoiseKernel!=NULL)
+    RelinquishOpenCLKernel(addNoiseKernel);
+  if (imageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageBuffer);
+  if (filteredImageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(filteredImageBuffer);
   if (outputReady == MagickFalse && filteredImage != NULL) 
     filteredImage=DestroyImage(filteredImage);
 
@@ -791,7 +797,7 @@ static Image *ComputeBlurImage(const Image* image,MagickCLEnv clEnv,
 
   outputReady = MagickFalse;
 
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
   queue = AcquireOpenCLCommandQueue(device);
 
   image_view=AcquireAuthenticCacheView(image,exception);
@@ -950,15 +956,25 @@ cleanup:
   if (filteredImage_view != NULL)
     filteredImage_view=DestroyCacheView(filteredImage_view);
 
-  if (imageBuffer!=NULL)     clEnv->library->clReleaseMemObject(imageBuffer);
-  if (tempImageBuffer!=NULL)      clEnv->library->clReleaseMemObject(tempImageBuffer);
-  if (filteredImageBuffer!=NULL)  clEnv->library->clReleaseMemObject(filteredImageBuffer);
-  if (imageKernelBuffer!=NULL)    clEnv->library->clReleaseMemObject(imageKernelBuffer);
-  if (blurRowKernel!=NULL)        RelinquishOpenCLKernel(blurRowKernel);
-  if (blurColumnKernel!=NULL)     RelinquishOpenCLKernel(blurColumnKernel);
-  if (queue != NULL)              RelinquishOpenCLCommandQueue(device, queue);
+  if (imageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageBuffer);
+  if (tempImageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(tempImageBuffer);
+  if (filteredImageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(filteredImageBuffer);
+  if (imageKernelBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageKernelBuffer);
+  if (blurRowKernel!=NULL)
+    RelinquishOpenCLKernel(blurRowKernel);
+  if (blurColumnKernel!=NULL)
+    RelinquishOpenCLKernel(blurColumnKernel);
+  if (queue != NULL)
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
   if (outputReady == MagickFalse && filteredImage != NULL)
     filteredImage=DestroyImage(filteredImage);
+
   return(filteredImage);
 }
 
@@ -1101,7 +1117,7 @@ static MagickBooleanType ComputeCompositeImage(Image *image,MagickCLEnv clEnv,
   imageBuffer = NULL;
   compositeImageBuffer = NULL;
 
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
   queue = AcquireOpenCLCommandQueue(device);
 
   /* Create and initialize OpenCL buffers. */
@@ -1198,9 +1214,14 @@ static MagickBooleanType ComputeCompositeImage(Image *image,MagickCLEnv clEnv,
 cleanup:
 
   image_view=DestroyCacheView(image_view);
-  if (imageBuffer!=NULL)      clEnv->library->clReleaseMemObject(imageBuffer);
-  if (compositeImageBuffer!=NULL)  clEnv->library->clReleaseMemObject(compositeImageBuffer);
-  if (queue != NULL)               RelinquishOpenCLCommandQueue(device,queue);
+  if (imageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageBuffer);
+  if (compositeImageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(compositeImageBuffer);
+  if (queue != NULL)
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
 
   return(outputReady);
 }
@@ -1307,7 +1328,7 @@ static MagickBooleanType ComputeContrastImage(Image *image,MagickCLEnv clEnv,
   filterKernel = NULL;
   queue = NULL;
 
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
 
   /* Create and initialize OpenCL buffers. */
   image_view=AcquireAuthenticCacheView(image,exception);
@@ -1389,9 +1410,15 @@ cleanup:
 
   image_view=DestroyCacheView(image_view);
 
-  if (imageBuffer!=NULL)                     clEnv->library->clReleaseMemObject(imageBuffer);
-  if (filterKernel!=NULL)                     RelinquishOpenCLKernel(filterKernel);
-  if (queue != NULL)                          RelinquishOpenCLCommandQueue(device,queue);
+  if (imageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageBuffer);
+  if (filterKernel!=NULL)
+    RelinquishOpenCLKernel(filterKernel);
+  if (queue != NULL)
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
+
   return(outputReady);
 }
 
@@ -1516,7 +1543,7 @@ static MagickBooleanType ComputeContrastStretchImage(Image *image,
   /*
    * initialize opencl env
    */
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
   queue = AcquireOpenCLCommandQueue(device);
 
   /*
@@ -1979,21 +2006,18 @@ cleanup:
     clEnv->library->clReleaseMemObject(stretchMapBuffer);
   if (stretch_map!=NULL)
     stretch_map=(PixelPacket *) RelinquishMagickMemory(stretch_map);
-
-
   if (histogramBuffer!=NULL)
     clEnv->library->clReleaseMemObject(histogramBuffer);
   if (histogram!=NULL)
     histogram=(cl_uint4 *) RelinquishMagickMemory(histogram);
-
-
-  if (histogramKernel!=NULL)                     
+  if (histogramKernel!=NULL)
     RelinquishOpenCLKernel(histogramKernel);
-  if (stretchKernel!=NULL)                     
+  if (stretchKernel!=NULL)
     RelinquishOpenCLKernel(stretchKernel);
-
-  if (queue != NULL)                          
-    RelinquishOpenCLCommandQueue(device, queue);
+  if (queue != NULL)
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
 
   return(outputReady);
 }
@@ -2112,7 +2136,7 @@ static Image *ComputeConvolveImage(const Image* image,MagickCLEnv clEnv,
   filteredImage_view = NULL;
   outputReady = MagickFalse;
 
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
 
   image_view=AcquireAuthenticCacheView(image,exception);
   inputPixels=GetCacheViewAuthenticPixels(image_view,0,0,image->columns,image->rows,exception);
@@ -2336,22 +2360,18 @@ cleanup:
   image_view=DestroyCacheView(image_view);
   if (filteredImage_view != NULL)
     filteredImage_view=DestroyCacheView(filteredImage_view);
-
   if (imageBuffer != NULL)
     clEnv->library->clReleaseMemObject(imageBuffer);
-
   if (filteredImageBuffer != NULL)
     clEnv->library->clReleaseMemObject(filteredImageBuffer);
-
   if (convolutionKernel != NULL)
     clEnv->library->clReleaseMemObject(convolutionKernel);
-
   if (clkernel != NULL)
     RelinquishOpenCLKernel(clkernel);
-
   if (queue != NULL)
-    RelinquishOpenCLCommandQueue(device, queue);
-
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
   if (outputReady == MagickFalse)
   {
     if (filteredImage != NULL)
@@ -2474,7 +2494,7 @@ static Image *ComputeDespeckleImage(const Image *image,MagickCLEnv clEnv,
   queue = NULL;
   tempImageBuffer[0] = tempImageBuffer[1] = NULL;
 
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
   queue = AcquireOpenCLCommandQueue(device);
  
   image_view=AcquireAuthenticCacheView(image,exception);
@@ -2741,17 +2761,26 @@ cleanup:
   if (filteredImage_view != NULL)
     filteredImage_view=DestroyCacheView(filteredImage_view);
 
-  if (queue != NULL)                          RelinquishOpenCLCommandQueue(device, queue);
-  if (imageBuffer!=NULL)                     clEnv->library->clReleaseMemObject(imageBuffer);
+  if (queue != NULL)
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
+  if (imageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageBuffer);
   for (k = 0; k < 2; k++)
   {
-    if (tempImageBuffer[k]!=NULL)            clEnv->library->clReleaseMemObject(tempImageBuffer[k]);
+    if (tempImageBuffer[k]!=NULL)
+      clEnv->library->clReleaseMemObject(tempImageBuffer[k]);
   }
-  if (filteredImageBuffer!=NULL)             clEnv->library->clReleaseMemObject(filteredImageBuffer);
-  if (hullPass1!=NULL)                       RelinquishOpenCLKernel(hullPass1);
-  if (hullPass2!=NULL)                       RelinquishOpenCLKernel(hullPass2);
+  if (filteredImageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(filteredImageBuffer);
+  if (hullPass1!=NULL)
+    RelinquishOpenCLKernel(hullPass1);
+  if (hullPass2!=NULL)
+    RelinquishOpenCLKernel(hullPass2);
   if (outputReady == MagickFalse && filteredImage != NULL)
     filteredImage=DestroyImage(filteredImage);
+
   return(filteredImage);
 }
 
@@ -2871,7 +2900,7 @@ static MagickBooleanType ComputeEqualizeImage(Image *image,MagickCLEnv clEnv,
   /*
    * initialize opencl env
    */
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
   queue = AcquireOpenCLCommandQueue(device);
 
   /*
@@ -3192,29 +3221,26 @@ cleanup:
 
   image_view=DestroyCacheView(image_view);
 
-  if (imageBuffer!=NULL)                     
+  if (imageBuffer!=NULL)
     clEnv->library->clReleaseMemObject(imageBuffer);
-
   if (map!=NULL)
     map=(FloatPixelPacket *) RelinquishMagickMemory(map);
-
   if (equalizeMapBuffer!=NULL)
     clEnv->library->clReleaseMemObject(equalizeMapBuffer);
   if (equalize_map!=NULL)
     equalize_map=(PixelPacket *) RelinquishMagickMemory(equalize_map);
-
-  if (histogramBuffer!=NULL)                 
+  if (histogramBuffer!=NULL)
     clEnv->library->clReleaseMemObject(histogramBuffer);
   if (histogram!=NULL)
     histogram=(cl_uint4 *) RelinquishMagickMemory(histogram);
-
-  if (histogramKernel!=NULL)                     
+  if (histogramKernel!=NULL)
     RelinquishOpenCLKernel(histogramKernel);
-  if (equalizeKernel!=NULL)                     
+  if (equalizeKernel!=NULL)
     RelinquishOpenCLKernel(equalizeKernel);
-
-  if (queue != NULL)                          
+  if (queue != NULL)
     RelinquishOpenCLCommandQueue(device, queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
 
   return(outputReady);
 }
@@ -3307,7 +3333,7 @@ static MagickBooleanType ComputeFunctionImage(Image *image,MagickCLEnv clEnv,
   parametersBuffer = NULL;
   pixels = NULL;
 
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
 
   image_view=AcquireAuthenticCacheView(image,exception);
   imageBuffer=createReadWriteBuffer(image,image_view,clEnv,device,pixels,
@@ -3385,10 +3411,16 @@ cleanup:
 
   image_view=DestroyCacheView(image_view);
   
-  if (clkernel != NULL) RelinquishOpenCLKernel(clkernel);
-  if (queue != NULL) RelinquishOpenCLCommandQueue(device, queue);
-  if (imageBuffer != NULL) clEnv->library->clReleaseMemObject(imageBuffer);
-  if (parametersBuffer != NULL) clEnv->library->clReleaseMemObject(parametersBuffer);
+  if (clkernel != NULL)
+    RelinquishOpenCLKernel(clkernel);
+  if (queue != NULL)
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
+  if (imageBuffer != NULL)
+    clEnv->library->clReleaseMemObject(imageBuffer);
+  if (parametersBuffer != NULL)
+    clEnv->library->clReleaseMemObject(parametersBuffer);
 
   return(status);
 }
@@ -3480,7 +3512,7 @@ static MagickBooleanType ComputeGrayscaleImage(Image *image,MagickCLEnv clEnv,
   /*
    * initialize opencl env
    */
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
   queue = AcquireOpenCLCommandQueue(device);
 
   /* Create and initialize OpenCL buffers.
@@ -3543,7 +3575,9 @@ cleanup:
   if (grayscaleKernel!=NULL)
     RelinquishOpenCLKernel(grayscaleKernel);
   if (queue != NULL)
-    RelinquishOpenCLCommandQueue(device, queue);
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
 
   return( outputReady);
 }
@@ -3658,7 +3692,7 @@ static Image *ComputeLocalContrastImage(const Image *image,MagickCLEnv clEnv,
   queue = NULL;
   outputReady = MagickFalse;
 
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
   queue = AcquireOpenCLCommandQueue(device);
 
   /* Create and initialize OpenCL buffers. */
@@ -3877,13 +3911,22 @@ cleanup:
   if (filteredImage_view != NULL)
     filteredImage_view=DestroyCacheView(filteredImage_view);
 
-  if (imageBuffer!=NULL)                      clEnv->library->clReleaseMemObject(imageBuffer);
-  if (filteredImageBuffer!=NULL)              clEnv->library->clReleaseMemObject(filteredImageBuffer);
-  if (tempImageBuffer!=NULL)                  clEnv->library->clReleaseMemObject(tempImageBuffer);
-  if (imageKernelBuffer!=NULL)                clEnv->library->clReleaseMemObject(imageKernelBuffer);
-  if (blurRowKernel!=NULL)                    RelinquishOpenCLKernel(blurRowKernel);
-  if (blurColumnKernel!=NULL)                 RelinquishOpenCLKernel(blurColumnKernel);
-  if (queue != NULL)                          RelinquishOpenCLCommandQueue(device, queue);
+  if (imageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageBuffer);
+  if (filteredImageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(filteredImageBuffer);
+  if (tempImageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(tempImageBuffer);
+  if (imageKernelBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageKernelBuffer);
+  if (blurRowKernel!=NULL)
+    RelinquishOpenCLKernel(blurRowKernel);
+  if (blurColumnKernel!=NULL)
+    RelinquishOpenCLKernel(blurColumnKernel);
+  if (queue != NULL)
+    RelinquishOpenCLCommandQueue(device, queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
   if (outputReady == MagickFalse)
   {
     if (filteredImage != NULL)
@@ -3892,6 +3935,7 @@ cleanup:
       filteredImage = NULL;
     }
   }
+
   return(filteredImage);
 }
 
@@ -3990,7 +4034,7 @@ static MagickBooleanType ComputeModulateImage(Image *image,MagickCLEnv clEnv,
   /*
    * initialize opencl env
    */
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
   queue = AcquireOpenCLCommandQueue(device);
 
   outputReady = MagickFalse;
@@ -4088,12 +4132,14 @@ cleanup:
 
   image_view=DestroyCacheView(image_view);
 
-  if (imageBuffer!=NULL)                     
+  if (imageBuffer!=NULL)
     clEnv->library->clReleaseMemObject(imageBuffer);
-  if (modulateKernel!=NULL)                     
+  if (modulateKernel!=NULL)
     RelinquishOpenCLKernel(modulateKernel);
-  if (queue != NULL)                          
+  if (queue != NULL)
     RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
 
   return outputReady;
 
@@ -4219,7 +4265,7 @@ static Image* ComputeMotionBlurImage(const Image *image,MagickCLEnv clEnv,
   motionBlurKernel = NULL;
   queue = NULL;
 
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
 
   /* Create and initialize OpenCL buffers. */
 
@@ -4450,11 +4496,18 @@ cleanup:
   if (filteredImage_view != NULL)
     filteredImage_view=DestroyCacheView(filteredImage_view);
 
-  if (filteredImageBuffer!=NULL)  clEnv->library->clReleaseMemObject(filteredImageBuffer);
-  if (imageBuffer!=NULL)     clEnv->library->clReleaseMemObject(imageBuffer);
-  if (imageKernelBuffer!=NULL)    clEnv->library->clReleaseMemObject(imageKernelBuffer);
-  if (motionBlurKernel!=NULL)  RelinquishOpenCLKernel(motionBlurKernel);
-  if (queue != NULL)           RelinquishOpenCLCommandQueue(device,queue);
+  if (filteredImageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(filteredImageBuffer);
+  if (imageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageBuffer);
+  if (imageKernelBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageKernelBuffer);
+  if (motionBlurKernel!=NULL)
+    RelinquishOpenCLKernel(motionBlurKernel);
+  if (queue != NULL)
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
   if (outputReady == MagickFalse && filteredImage != NULL)
     filteredImage=DestroyImage(filteredImage);
 
@@ -4952,7 +5005,7 @@ static Image *ComputeResizeImage(const Image* image,MagickCLEnv clEnv,
   cubicCoefficientsBuffer = NULL;
   queue = NULL;
 
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
 
   image_view = AcquireAuthenticCacheView(image, exception);
   imageBuffer=createReadBuffer(image,image_view,clEnv,device,exception);
@@ -5062,13 +5115,21 @@ cleanup:
   if (filteredImage_view != NULL)
     filteredImage_view=DestroyCacheView(filteredImage_view);
 
-  if (imageBuffer!=NULL)                 clEnv->library->clReleaseMemObject(imageBuffer);
-  if (tempImageBuffer!=NULL)             clEnv->library->clReleaseMemObject(tempImageBuffer);
-  if (filteredImageBuffer!=NULL)         clEnv->library->clReleaseMemObject(filteredImageBuffer);
-  if (cubicCoefficientsBuffer!=NULL)      clEnv->library->clReleaseMemObject(cubicCoefficientsBuffer);
-  if (queue != NULL)                     RelinquishOpenCLCommandQueue(device, queue);
+  if (imageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageBuffer);
+  if (tempImageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(tempImageBuffer);
+  if (filteredImageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(filteredImageBuffer);
+  if (cubicCoefficientsBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(cubicCoefficientsBuffer);
+  if (queue != NULL)
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
   if (outputReady == MagickFalse && filteredImage != NULL)
     filteredImage=DestroyImage(filteredImage);
+
   return(filteredImage);
 }
 
@@ -5205,7 +5266,7 @@ static Image* ComputeRotationalBlurImage(const Image *image,MagickCLEnv clEnv,
   queue = NULL;
   rotationalBlurKernel = NULL;
 
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
 
   image_view=AcquireAuthenticCacheView(image, exception);
   imageBuffer=createReadBuffer(image,image_view,clEnv,device,exception);
@@ -5335,12 +5396,20 @@ cleanup:
   if (filteredImage_view != NULL)
     filteredImage_view=DestroyCacheView(filteredImage_view);
 
-  if (filteredImageBuffer!=NULL)  clEnv->library->clReleaseMemObject(filteredImageBuffer);
-  if (imageBuffer!=NULL)     clEnv->library->clReleaseMemObject(imageBuffer);
-  if (sinThetaBuffer!=NULL)       clEnv->library->clReleaseMemObject(sinThetaBuffer);
-  if (cosThetaBuffer!=NULL)       clEnv->library->clReleaseMemObject(cosThetaBuffer);
-  if (rotationalBlurKernel!=NULL) RelinquishOpenCLKernel(rotationalBlurKernel);
-  if (queue != NULL)              RelinquishOpenCLCommandQueue(device,queue);
+  if (filteredImageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(filteredImageBuffer);
+  if (imageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageBuffer);
+  if (sinThetaBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(sinThetaBuffer);
+  if (cosThetaBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(cosThetaBuffer);
+  if (rotationalBlurKernel!=NULL)
+    RelinquishOpenCLKernel(rotationalBlurKernel);
+  if (queue != NULL)
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
   if (outputReady == MagickFalse)
   {
     if (filteredImage != NULL)
@@ -5349,6 +5418,7 @@ cleanup:
       filteredImage = NULL;
     }
   }
+
   return filteredImage;
 }
 
@@ -5457,7 +5527,7 @@ static Image *ComputeUnsharpMaskImage(const Image *image,MagickCLEnv clEnv,
   queue = NULL;
   outputReady = MagickFalse;
 
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
   queue = AcquireOpenCLCommandQueue(device);
 
   image_view = AcquireAuthenticCacheView(image, exception);
@@ -5619,13 +5689,22 @@ cleanup:
   if (filteredImage_view != NULL)
     filteredImage_view=DestroyCacheView(filteredImage_view);
 
-  if (imageBuffer!=NULL)                     clEnv->library->clReleaseMemObject(imageBuffer);
-  if (filteredImageBuffer!=NULL)              clEnv->library->clReleaseMemObject(filteredImageBuffer);
-  if (tempImageBuffer!=NULL)                  clEnv->library->clReleaseMemObject(tempImageBuffer);
-  if (imageKernelBuffer!=NULL)                clEnv->library->clReleaseMemObject(imageKernelBuffer);
-  if (blurRowKernel!=NULL)                    RelinquishOpenCLKernel(blurRowKernel);
-  if (unsharpMaskBlurColumnKernel!=NULL)      RelinquishOpenCLKernel(unsharpMaskBlurColumnKernel);
-  if (queue != NULL)                          RelinquishOpenCLCommandQueue(device,queue);
+  if (imageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageBuffer);
+  if (filteredImageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(filteredImageBuffer);
+  if (tempImageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(tempImageBuffer);
+  if (imageKernelBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageKernelBuffer);
+  if (blurRowKernel!=NULL)
+    RelinquishOpenCLKernel(blurRowKernel);
+  if (unsharpMaskBlurColumnKernel!=NULL)
+    RelinquishOpenCLKernel(unsharpMaskBlurColumnKernel);
+  if (queue != NULL)
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
   if (outputReady == MagickFalse)
   {
     if (filteredImage != NULL)
@@ -5634,6 +5713,7 @@ cleanup:
       filteredImage = NULL;
     }
   }
+
   return(filteredImage);
 }
 
@@ -5695,7 +5775,7 @@ static Image *ComputeUnsharpMaskImageSingle(const Image *image,
   queue = NULL;
   outputReady = MagickFalse;
 
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
   queue = AcquireOpenCLCommandQueue(device);
 
   image_view=AcquireAuthenticCacheView(image,exception);
@@ -5785,11 +5865,18 @@ cleanup:
   if (filteredImage_view != NULL)
     filteredImage_view=DestroyCacheView(filteredImage_view);
 
-  if (imageBuffer!=NULL)                     clEnv->library->clReleaseMemObject(imageBuffer);
-  if (filteredImageBuffer!=NULL)              clEnv->library->clReleaseMemObject(filteredImageBuffer);
-  if (imageKernelBuffer!=NULL)                clEnv->library->clReleaseMemObject(imageKernelBuffer);
-  if (unsharpMaskKernel!=NULL)                RelinquishOpenCLKernel(unsharpMaskKernel);
-  if (queue != NULL)                          RelinquishOpenCLCommandQueue(device,queue);
+  if (imageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageBuffer);
+  if (filteredImageBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(filteredImageBuffer);
+  if (imageKernelBuffer!=NULL)
+    clEnv->library->clReleaseMemObject(imageKernelBuffer);
+  if (unsharpMaskKernel!=NULL)
+    RelinquishOpenCLKernel(unsharpMaskKernel);
+  if (queue != NULL)
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
   if (outputReady == MagickFalse)
   {
     if (filteredImage != NULL)
@@ -5798,6 +5885,7 @@ cleanup:
       filteredImage = NULL;
     }
   }
+
   return(filteredImage);
 }
 
@@ -5875,7 +5963,7 @@ static Image *ComputeWaveletDenoiseImage(const Image *image,MagickCLEnv clEnv,
   denoiseKernel = NULL;
   outputReady = MagickFalse;
 
-  device = GetOpenCLDevice(clEnv);
+  device = RequestOpenCLDevice(clEnv);
   queue = AcquireOpenCLCommandQueue(device);
 
   /* Create and initialize OpenCL buffers. */
@@ -5971,10 +6059,16 @@ cleanup:
   if (filteredImage_view != NULL)
     filteredImage_view = DestroyCacheView(filteredImage_view);
 
-  if (imageBuffer != NULL)                     clEnv->library->clReleaseMemObject(imageBuffer);
-  if (filteredImageBuffer != NULL)     clEnv->library->clReleaseMemObject(filteredImageBuffer);
-  if (denoiseKernel != NULL)           RelinquishOpenCLKernel(denoiseKernel);
-  if (queue != NULL)                           RelinquishOpenCLCommandQueue(device,queue);
+  if (imageBuffer != NULL)
+    clEnv->library->clReleaseMemObject(imageBuffer);
+  if (filteredImageBuffer != NULL)
+    clEnv->library->clReleaseMemObject(filteredImageBuffer);
+  if (denoiseKernel != NULL)
+    RelinquishOpenCLKernel(denoiseKernel);
+  if (queue != NULL)
+    RelinquishOpenCLCommandQueue(device,queue);
+  if (device != NULL)
+    ReleaseOpenCLDevice(clEnv,device);
   if (outputReady == MagickFalse)
   {
     if (filteredImage != NULL)
@@ -5983,6 +6077,7 @@ cleanup:
       filteredImage = NULL;
     }
   }
+
   return(filteredImage);
 }
 

diff --git a/MagickCore/opencl-private.h b/MagickCore/opencl-private.h
index 06b153d3be56677b861846a069cd2c250de3e58e..e0e209af46ad08901b52c3ff0dac9151156d2b8a 100644 (file)
--- a/MagickCore/opencl-private.h
+++ b/MagickCore/opencl-private.h
@@ -291,9 +291,11 @@ struct _MagickCLDevice
   SemaphoreInfo
     *lock;
 
+  size_t
+    requested;
+
   ssize_t
-    command_queues_index,
-    created_queues;
+    command_queues_index;
 };
 
 struct _MagickCLEnv
@@ -378,7 +380,7 @@ extern MagickPrivate MagickBooleanType
     const char *,...);
 
 extern MagickPrivate MagickCLDevice
-  GetOpenCLDevice(MagickCLEnv);
+  RequestOpenCLDevice(MagickCLEnv);
 
 extern MagickPrivate MagickCLEnv
   GetCurrentOpenCLEnv(void);
@@ -390,14 +392,10 @@ extern MagickPrivate void
   DumpOpenCLProfileData(),
   OpenCLTerminus(),
   RecordProfileData(MagickCLDevice,cl_kernel,cl_event),
+  ReleaseOpenCLDevice(MagickCLEnv,MagickCLDevice),
   RelinquishOpenCLCommandQueue(MagickCLDevice,cl_command_queue),
   RelinquishOpenCLKernel(cl_kernel);
 
-extern MagickPrivate cl_mem
-  GetAndLockRandSeedBuffer(MagickCLEnv,MagickCLDevice);
-extern MagickPrivate void
-  UnlockRandSeedBuffer(MagickCLEnv);
-
 #if defined(__cplusplus) || defined(c_plusplus)
 }
 #endif

diff --git a/MagickCore/opencl.c b/MagickCore/opencl.c
index 48281461b01a6bbe8c8d3fbe2ab1b7c8ea2c2d95..a6c0fe00bc300e2aa5c315b7c68f55ce51cdc0a5 100644 (file)
--- a/MagickCore/opencl.c
+++ b/MagickCore/opencl.c
@@ -567,7 +567,6 @@ MagickPrivate cl_command_queue AcquireOpenCLCommandQueue(MagickCLDevice device)
 
   assert(device != (MagickCLDevice) NULL);
   LockSemaphoreInfo(device->lock);
-  device->created_queues++;
   if ((device->profile_kernels == MagickFalse) &&
       (device->command_queues_index >= 0))
   {
@@ -1437,71 +1436,6 @@ MagickPrivate MagickCLEnv GetCurrentOpenCLEnv(void)
   return(default_CLEnv);
 }
 
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%   G e t O p e n C L D e v i c e                                             %
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-%  GetOpenCLDevice() returns one of the enabled OpenCL devices.
-%
-%  The format of the GetOpenCLDevice method is:
-%
-%      MagickCLDevice GetOpenCLDevice(MagickCLEnv clEnv)
-%
-%  A description of each parameter follows:
-%
-%    o clEnv: the OpenCL environment.
-*/
-
-MagickPrivate MagickCLDevice GetOpenCLDevice(MagickCLEnv clEnv)
-{
-  MagickCLDevice
-    device;
-
-  double
-    score,
-    best_score;
-
-  size_t
-    i;
-
-  if (clEnv == (MagickCLEnv) NULL)
-    return((MagickCLDevice) NULL);
-
-  if (clEnv->number_devices == 1)
-  {
-    if (clEnv->devices[0]->enabled)
-      return(clEnv->devices[0]);
-    else
-      return((MagickCLDevice) NULL);
-  }
-
-  device=(MagickCLDevice) NULL;
-  best_score=0.0;
-  for (i = 0; i < clEnv->number_devices; i++)
-  {
-    if (clEnv->devices[i]->enabled == MagickFalse)
-      continue;
-
-    LockSemaphoreInfo(clEnv->devices[i]->lock);
-    score=clEnv->devices[i]->score+(clEnv->devices[i]->score*
-      clEnv->devices[i]->created_queues);
-    UnlockSemaphoreInfo(clEnv->devices[i]->lock);
-    if ((device == (MagickCLDevice) NULL) || (score < best_score))
-    {
-      device=clEnv->devices[i];
-      best_score=score;
-    }
-  }
-  return(device);
-}
-
 /*
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %                                                                             %
@@ -1830,13 +1764,17 @@ static MagickBooleanType HasOpenCLDevices(MagickCLEnv clEnv,
     return(MagickFalse);
 
   /* Check if we need to compile a kernel for one of the devices */
+  status=MagickTrue;
   for (i = 0; i < clEnv->number_devices; i++)
   {
     if ((clEnv->devices[i]->enabled != MagickFalse) &&
         (clEnv->devices[i]->program == (cl_program) NULL))
+    {
+      status=MagickFalse;
       break;
+    }
   }
-  if (i == clEnv->number_devices)
+  if (status != MagickFalse)
     return(MagickTrue);
 
   /* Get additional options */
@@ -2403,6 +2341,38 @@ MagickPrivate void RecordProfileData(MagickCLDevice device,
   name=DestroyString(name);
 }
 
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   R e l e a s e  M a g i c k C L D e v i c e                                %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  ReleaseOpenCLDevice() returns the OpenCL device to the environment
+%
+%  The format of the ReleaseOpenCLDevice method is:
+%
+%      void ReleaseOpenCLDevice(MagickCLEnv clEnv,MagickCLDevice device)
+%
+%  A description of each parameter follows:
+%
+%    o clEnv: the OpenCL environment.
+%
+%    o device: the OpenCL device to be released.
+%
+*/
+
+MagickPrivate void ReleaseOpenCLDevice(MagickCLEnv clEnv,MagickCLDevice device)
+{
+  LockSemaphoreInfo(clEnv->lock);
+  device->requested--;
+  UnlockSemaphoreInfo(clEnv->lock);
+}
+
 /*
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %                                                                             %
@@ -2512,13 +2482,17 @@ MagickPrivate void RelinquishOpenCLCommandQueue(MagickCLDevice device,
 
   assert(device != (MagickCLDevice) NULL);
   LockSemaphoreInfo(device->lock);
-  device->created_queues--;
   if ((device->profile_kernels != MagickFalse) ||
-      (device->command_queues_index >= MAGICKCORE_OPENCL_COMMAND_QUEUES-1))
-    (void) openCL_library->clReleaseCommandQueue(queue);
+      (device->command_queues_index >= MAGICKCORE_OPENCL_COMMAND_QUEUES - 1))
+  {
+    UnlockSemaphoreInfo(device->lock);
+    (void)openCL_library->clReleaseCommandQueue(queue);
+  }
   else
-    device->command_queues[++device->command_queues_index]=queue;
-  UnlockSemaphoreInfo(device->lock);
+  {
+    device->command_queues[++device->command_queues_index] = queue;
+    UnlockSemaphoreInfo(device->lock);
+  }
 }
 
 /*
@@ -2551,6 +2525,74 @@ MagickPrivate void RelinquishOpenCLKernel(cl_kernel kernel)
     (void) openCL_library->clReleaseKernel(kernel);
 }
 
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   R e q u e s t O p e n C L D e v i c e                                     %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  RequestOpenCLDevice() returns one of the enabled OpenCL devices.
+%
+%  The format of the RequestOpenCLDevice method is:
+%
+%      MagickCLDevice RequestOpenCLDevice(MagickCLEnv clEnv)
+%
+%  A description of each parameter follows:
+%
+%    o clEnv: the OpenCL environment.
+*/
+
+MagickPrivate MagickCLDevice RequestOpenCLDevice(MagickCLEnv clEnv)
+{
+  MagickCLDevice
+    device;
+
+  double
+    score,
+    best_score;
+
+  size_t
+    i;
+
+  if (clEnv == (MagickCLEnv) NULL)
+    return((MagickCLDevice) NULL);
+
+  if (clEnv->number_devices == 1)
+  {
+    if (clEnv->devices[0]->enabled)
+      return(clEnv->devices[0]);
+    else
+      return((MagickCLDevice) NULL);
+  }
+
+  device=(MagickCLDevice) NULL;
+  best_score=0.0;
+  LockSemaphoreInfo(clEnv->lock);
+  for (i = 0; i < clEnv->number_devices; i++)
+  {
+    if (clEnv->devices[i]->enabled == MagickFalse)
+      continue;
+
+    score=clEnv->devices[i]->score+(clEnv->devices[i]->score*
+      clEnv->devices[i]->requested);
+    if ((device == (MagickCLDevice) NULL) || (score < best_score))
+    {
+      device=clEnv->devices[i];
+      best_score=score;
+    }
+  }
+  if (device != (MagickCLDevice)NULL)
+    device->requested++;
+  UnlockSemaphoreInfo(clEnv->lock);
+
+  return(device);
+}
+
 /*
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %                                                                             %