There is an increasing noise about GPGPU<\/a> computing and how much faster than CPU (even parallel) it is. If you didn’t hear about all that, GPGPU is about using the computer’s graphics card(s) to do general purpose computations. The key to the performance lies in the parallel architecture of these devices. From what I read, an average graphics card has 64 parallel units, but they are not as versatile as the CPU of which a typical PC these days has 4 cores. That means, if the task is well suited, it can boost performance significantly, but if not, it’s nothing more than a lot of wasted work.<\/p>\n So I wanted to see for myself. To get started I read the book “OpenCL Programming Guide<\/a>“. It gave a good overview. But now it was time to give it a try.<\/p>\n The first step was to get the libraries and drivers installed. As always, the first place I looked was the ubuntu repositories, but that was kinda bummer<\/a>. So I went duckduckgoing (that’s like googling, but with DuckDuckGo<\/a> ), and I found some descriptions on how to install the drivers here<\/a> and here<\/a>. They both suggest that for all three providers (NVIDIA, ATI, Intel), you’d have to use the proprietary installer. I hate this. There is such a wonderful package system with debian and derivatives, it makes you feel like on Windows if you have to use such an installer. So I looked further, and indeed :<\/p>\n Unfortunately that is only for Nvidia. ATI is in debian experimental<\/a>, so I hope it will appear in ubuntu someday as well. Apparently there is an RPM from Intel that can be converted to a DEB with alien, but that has some caveats. For now, NVIDIA is enough to get started. When I realized that the OpenCL C++ wrapper is not in the repository, I thought about packaging it myself. But then I discovered that a guy with much more experience is on the task already<\/a>. So I just copied the few files to my project for the moment. Then I found a FindOpenCL.cmake<\/a> file just before I started to write my own one. I had to just slightly modify it to find the NVIDIA files that I installed previously.<\/p>\n The first example I tried was “vector addition in C<\/a>” then I converted it to C++ and later modified to better match the example in the book. In the process I also added errorhandling to the compiling stage just to find out that my graphics card doesn’t support double precision floating point numbers (that are the standard at my daytime job). Then I wanted to compare the performance between GPU and CPU. But in the first iteration, everything with buffers that were not too big, was barely measurable. So I had to run the stuff many times to get more accurate numbers. The code is at: https:\/\/github.com\/ulrichard\/ai-class-NLP\/tree\/master\/OpenCL\/FirstTry<\/a>\u00c2\u00a0 and here are some measurements from my computer:<\/p>\n$ apt-file search \"CL\/cl.h\"\n nvidia-current-dev: \/usr\/include\/nvidia-current\/CL\/cl.h\n nvidia-current-updates-dev: \/usr\/include\/nvidia-current-updates\/CL\/cl.h\n$ sudo apt-get install nvidia-current-dev<\/pre>\n
VectorSize<\/strong><\/td>\n| CPU AMD | \n<\/strong><\/td>\n GeForce 9800 GT<\/strong><\/td>\n | CPU Intel i7 mobile | \n<\/strong><\/td>\n Intel 4000 mobuile GPU<\/strong><\/td>\n<\/tr>\n | 10<\/td>\n | 2.48609e-06<\/td>\n | 0.000558952<\/td>\n | \u00c2\u00a02.618e-07<\/td>\n | \u00c2\u00a03.7654e-05<\/td>\n<\/tr>\n | 40<\/td>\n | 3.13896e-06<\/td>\n | 0.000570314<\/td>\n | \u00c2\u00a06.29196e-07<\/td>\n | 4.32716e-05<\/td>\n<\/tr>\n | 160<\/td>\n | 7.86075e-06<\/td>\n | 0.00058319<\/td>\n | \u00c2\u00a01.76039e-06<\/td>\n | 3.11682e-05<\/td>\n<\/tr>\n | 640<\/td>\n | 2.53343e-05<\/td>\n | 0.000502504<\/td>\n | \u00c2\u00a06.41616e-06<\/td>\n | 3.1311e-05<\/td>\n<\/tr>\n | 2560<\/td>\n | 8.38907e-05<\/td>\n | 0.000536779<\/td>\n | \u00c2\u00a02.66609e-05<\/td>\n | 4.39072e-05<\/td>\n<\/tr>\n | 10240<\/td>\n | 0.000347115<\/td>\n | 0.000918079<\/td>\n | \u00c2\u00a08.27613e-05<\/td>\n | 7.17255e-05<\/td>\n<\/tr>\n | 40960<\/td>\n | 0.00180239<\/td>\n | 0.00181058<\/td>\n | \u00c2\u00a00.000391192<\/td>\n | 9.42563e-05<\/td>\n<\/tr>\n | 163840<\/td>\n | 0.00682403<\/td>\n | 0.00560538<\/td>\n | \u00c2\u00a00.000714286<\/td>\n | 0.000424242<\/td>\n<\/tr>\n | 655360<\/td>\n | 0.0283929<\/td>\n | 0.0221429<\/td>\n | \u00c2\u00a00.00623318<\/td>\n | 0.00228972<\/td>\n<\/tr>\n | 2621440<\/td>\n | 0.114286<\/td>\n | 0.07875<\/td>\n | \u00c2\u00a00.0238596<\/td>\n | 0.00796875<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n | Sure, these numbers don’t say much, as adding two numbers is not much of a computation. But it shows already, that all the overhead of copying the buffers back and forth can be amortized with big enough tasks. And the framework I built can become useful to compare the timings of more elaborate computations.<\/p>\n Next step would be to pick an existing algorithm and see if I can make it faster on the GPU.<\/p>\n |