Blender 2.67b and OpenCL is working better

I just updated to new Blender 2.67b and found out that something in OpenCL changed to better. Last time I checked previous version of Blender there was not possible to select CPU as the compute device. Now it's possible. It's even possible to use combination of CPU and GPU. Take a look at the next picture:

I can use Intel Core i5 or/and AMD Radeon graphic card as compute device. This is nice.



You can see Intel Core i5 written twice. The reason is that I have installed two OpenCL implementations. One is from Intel and one is from AMD. Sadly I don't know which is from AMD and which is from Intel but most of users will not have that problem.

What if we try to run Cycles on OpenCL? Let's start with Intel Core i5 and theirs OpenCL implementation. In console we get next output:

Compiling OpenCL kernel ...
OpenCL kernel build output:
Compilation started
In file included from <built-in>:132:
<command line>:2:36: warning: ISO C99 requires whitespace after the macro name
Compilation done
Linking started
Linking done
Kernel <kernel_ocl_path_trace> was not vectorized
Kernel <kernel_ocl_tonemap> was successfully vectorized
Done.
Kernel compilation finished in 17.80s.  

You can see that whole Cycles code is quite massive stuff. Compilation takes 17.8s. Guys who wrote Cycles, put a lot of work into this code. Rendering time of default cube takes: 2.9s.

What about AMD's implementation of CPU backend? Console output is in this case less verbose:

Compiling OpenCL kernel ...
Kernel compilation finished in 5.13s.

Rendering time 2.2s is what is strange as AMD's implementation takes less time than Intel's implementation on Intel's CPUs! We're using AMD APP 1214.3 and Intel SDK 2013. But I'm not alone here. Phoronix found similar results: http://www.phoronix.com/scan.php?page=article&item=amd_intel_openclsdk&num=1 .

If we select not OpenCL computing but pure CPU implementation, it takes 1.8s. It seems that some work could be done to optimize whole thing. For my opinion pure CPU implementation is not needed any more. OpenCL implementation is enough. For machines which don't have OpenCL preinstalled, default OpenCL implementation could be bundled with Blender.

I noticed that Blender caches built OpenCL kernels. Good work! On the next start of Blender, first rendering is significantly faster.

What about GPU? At first we get a lot of trivial warnings which can be ignored:

Compiling OpenCL kernel ...
OpenCL kernel build output:
"/tmp/OCLawnF6S.cl", line 16307: warning: double-precision constant is
          represented as single-precision constant because double is not
          enabled
        float phi = M_2PI_F * randv;
                    ^

"/tmp/OCLawnF6S.cl", line 16323: warning: double-precision constant is
          represented as single-precision constant because double is not
          enabled
        float phi = M_2PI_F * randv;
                    ^

"/tmp/OCLawnF6S.cl", line 16337: warning: double-precision constant is
          represented as single-precision constant because double is not
          enabled
        float phi = M_2PI_F*u2;
                    ^

"/tmp/OCLawnF6S.cl", line 22875: warning: double-precision constant is
          represented as single-precision constant because double is not
          enabled
                float phi = M_2PI_F * randu;
                            ^

"/tmp/OCLawnF6S.cl", line 23165: warning: double-precision constant is
          represented as single-precision constant because double is not
          enabled
                float phiM = M_2PI_F * randv;
                             ^

"/tmp/OCLawnF6S.cl", line 23394: warning: double-precision constant is
          represented as single-precision constant because double is not
          enabled
                float phiM = M_2PI_F * randv;
                             ^                                                                                                                                                                                                    
                                                                                                                                                                                                                                  
"/tmp/OCLawnF6S.cl", line 24051: warning: double-precision constant is                                                                                                                                                            
          represented as single-precision constant because double is not                                                                                                                                                          
          enabled                                                                                                                                                                                                                 
                float phi = M_2PI_F * randu;                                                                                                                                                                                      
                            ^                                                                                                                                                                                                     
                                                                                                                                                                                                                                  
"/tmp/OCLawnF6S.cl", line 24427: warning: double-precision constant is                                                                                                                                                            
          represented as single-precision constant because double is not                                                                                                                                                          
          enabled                                                                                                                                                                                                                 
        const float tolerance = 1e-8;                                                                                                                                                                                             
                                ^                                                                                                                                                                                                 
                                                                                                                                                                                                                                  
"/tmp/OCLawnF6S.cl", line 24497: warning: double-precision constant is                                                                                                                                                            
          represented as single-precision constant because double is not                                                                                                                                                          
          enabled                                                                                                                                                                                                                 
        return ss->alpha_*(1.0f/M_4PI_F)*(Rdr + Rdv);                                                                                                                                                                             
                                ^                                                                                                                                                                                                 
                                                                                                                                                                                                                                  
"/tmp/OCLawnF6S.cl", line 26172: warning: double-precision constant is                                                                                                                                                            
          represented as single-precision constant because double is not
          enabled
                return atan2f(y, x) / M_2PI_F + 0.5f;
                                      ^

Error:E013:Insufficient Private Resources! 

OpenCL build failed: errors in console

But at then end we get:

Error:E013:Insufficient Private Resources! 

It looks like our GPU AMD Radeon 5470 is too low end. But at least it compiles all the code. It would be nice to get Cylces working on low end GPU's, but if we think further we can see that it's not worth the effort. Real Blender users will anyway use better GPU's.

The question is why it doesn't work. Is there to less local memory? Or we have to complex program? As we're talking about private resources I think that Cycles program is to complex to our GPU. It uses to much of registers or the program is to long. Maybe splitting Cycles into more smaller kernels would help. To find out the exact problem it's needed to use KernelAnalyzer from AMD APP and try to compile kernel for all GPUs.