OpenCL Programming by Example: A comprehensive guide on OpenCL programming with examples with this book and ebook

Due to the war between the GPUs reaching a terminal phase this may be the last comprehensive book published for OpenCL. Nvidia's dominance in the field of GPU programming and the prevalence of CUDA code examples are overshadowing OpenCL.However, there are many systems out there still using AMD's products and the mobile market is still OpenCL accessible. The ARM chariman says so and Sony's Experia can use it. Also, Nexus 10 and 4 devices have drivers for it. So, tablet designers attention! If you want to manage eye-popping animations or twisty-curley 3D simulations or detector displays, then pay attention to this manual.You will have to search the internet and fire up your Android NDK in some cases to maximize your mobile device to manage a display of 10,000 airplane tracks on a map of the US or merge six voice channels into one conference call.For the rest of us, it's a piece of cake, drivers for all the Nvidia and ATI cards are available. Every computing device with a supported GPU can run this code. I even ran the OpenCL starfield simulation on my MSI portable at 112 times the speed of the CPU and it was running on an Nvidia GTX 570GTM internal chip!This book will show you how to take all those simulation ideas and run any computer with a decent graphics card 100 times faster than any current CPU can manage. The book covers all the aspects of using OpenCL from buffer loading, kernel creating and executing, to synchronization and performance evaluation.OK, at 277 pages, its a bit thin for the price. But, what is the cost of fame and fortune? So, buck up and get your head wrapped around this information. The sky is the limit to your imagination here.

Couvre les besoins pour bien comprendre OpenCL et même plus ...Facile à assimiler que l'on soit développeurs avancés ou débutants

Looks like it will be useful once I get started with a compatible C++ compiler.

OpenCL Programming by Example, published by Packt Publishing, is geared toward the OpenCL beginner, so if you already have experience with OpenCL the book doesn’t offer much, though I did learn some nice tips and the OpenCL 1.2 information is useful.The book starts off with some nicely detailed background information on GPU architectures – no surprise as the authors work for AMD. Information is provided on getting the necessary OpenCL libraries and runtimes installed and read for use, so there shouldn’t be any confusion about how to get started. Then comes the nicely detail sample code, which is abundant and well documented.The book covers both basic and more complex GPU algorithms, including basic image processing with OpenCL images, computing histograms with reductions, implementing JPEG compression, and even goes into advanced case studies of speeding up curve-fitting and bitonic sort. The explanations and examples are very complete.I had a few minor issues with the book though. The early chapters are nicely edited but later on there are many grammatical errors and editing mistakes. A lot of boilerplate code is repeated in the examples; it would have been nice if the authors had developed a little wrapper or framework to hide some of the more mundane stuff. And as someone who uses OpenCL for image processing, I would like to have seen more examples in that area. The image processing examples were fairly mundane and well covered elsewhere.Gripes aside, I would definitely recommend this book to a programmer who wants to learn OpenCL. This is probably the most complete book I’ve read yet on the subject. Finally, I’d encourage everyone to check out Packt’s steadily growing library of technical books. The breadth of topics there will surprise you.

First and foremost, a proper disclosure: I was originally signed by Packt Publishing to write this book. Having failed to meet their schedule, Packt re-signed the book with the current authors and asked me to review the book during writing. I have reviewed the first couple of chapters and returned my comments, none of which were integrated in the book, nor have I received any additional chapters for review. My Amazon customer review may therefore seem biased, but I do hope the advised reader will take note and deduce, on her own accord, whether or not that is the case.And now my Amazon customer review:In the preface of the book, the section dubbed "Errata" starts with the following sentence: "Although we have taken every care to ensure the accuracy of our content, mistakes do happen". This is a rather standard statement in many technical books, and should be taken into account whenever a reader finds a mistake in the content. I find it hard to treat the book seriously though, having gone through the process of reviewing the first two chapters prior to the books publication, and ending up reading almost the exact same text in the published material, as what I have received for review and commented on.An example of such mistake that appears in the published book appears at the middle of chapter 1. In the section dubbed "Implement the SAXPY routine in OpenCL", the authors provide a code listing for an ANSI-C implementation of saxpy:void saxpy(int n, float a, float *b, float *c){ for (int i = 0; i < n; ++i) y[i] = a*x[i] + y[i];}I'm not trying to nitpick here, but this code will not compile under any C compiler, unless x and y are globally defined elsewhere, in which case the function will probably not accomplish the intended purpose. Of course it is clear that this is an editorial error, where x and y should have been b and c (or vise verse), but the fact that I commented on this while reviewing the chapter, and the error prevailed to the published version, sheds the promise of "we have taken every care to ensure the accuracy of our content" in a bad light.I would have been OK with the book if this was the only type of errors I found in it, but unfortunately they're not. The book contains a lot of information that newcomers to OpenCL, and to parallel programming in general will find interesting. It is too bad however that this information is flawed, and in some cases gives the impression that the authors, although undoubtedly used and are using OpenCL, fail to fully grasp some of the concepts or delicacies presented by the standard. Add to that the rather poor English grammar conveyed in the book (Packt's English editors were especially sloppy here), and you got yourself a recipe for producing misguided beginner programmers.Some examples are required to emphasis this claim. I'll give some from the 1st chapter, because if this early such mistakes are made, the following is of lesser importance.The 2nd paragraph in chapter 1 draws from Wikipedia's definition of parallel computing. It concludes with the following phrasing: "... large problems can often be divided into smaller ones, which are then solved concurrently (in parallel)". It is important to distinguish between the terms "parallel" and "concurrent". Although one would strive that her different "smaller" tasks run concurrently, that isn't always feasible, even as these are parallel tasks. Parallel is a logical term, describing the state of two (or more) task, having the theoretical ability of being executed at the same time. Concurrency is a physical term describing the target hardware's ability to execute parallel tasks. Parallel computing therefore, by no means, suggests that these parallel tasks will be executed concurrently.I will skip a few paragraphs, namely the rather odd list of parallel programming models in which the authors makes several errors regarding the "pros" and "cons" he chooses to list for each, and his decisions to put these models in comparison when they inherently target different levels of parallelism (local, heterogeneous systems, and distributed systems), and when these models are usually used in conjunction to one another, and complement one another, rather than compete.In the section dubbed "Introduction to OpenCL" the authors claim "OpenCL gives developers a common set of easy-to-use tools...". This is false. OpenCL provides two things, and two things only: an API (divided into two layers) which allows a host processor to manage and coordinate computations across different target devices within the system, and a programming language named OpenCL C, which the developer uses in order to write the code that will be executed on these devices. No tools. More than that, the authors are clearly confused as in a later section dubbed "OpenCL program flow" he falsely writes " An OpenCL C host code does the following...". As mentioned above, OpenCL C is used for programming the devices, whereas the host utilized the OpenCL API.I can actually list more problems found in chapter 1, but I hope that at this point you got the point. This actually gets worse in the following chapters where the authors describe the 4 models presented by the OpenCL standard. Just a small example for a mistake in the text: the authors claim "For high performance every OpenCL device has an associated local memory. This is the memory closest to the OpenCL processing element". This is false, as OpenCL does not define how local memory is to be implemented, and therefore some vendors choose to implement it over the same physical banks of their global memory (which means it operates at the same latency as global memory - providing no performance gains). Local memory with regards to OpenCL, has no performance considerations. These are the domain of device-specific targeting. As you may by now suspect, the list of false claims is much longer, but I will not indulge in it at this time.On a positive note, the set of examples provided in the book (and some are actually pretty good) allows the authors to demonstrate the usage of key concepts in OpenCL programming, which leads me to believe the authors are indeed experienced users of OpenCL, although lack a deep understanding of the different aspects of the standard (they should be, as the lead author is an AMD employee, working on OpenCL code optimizations).The bottom line is simple: if you are serious about learning OpenCL programming - keep away from this book. Not because it doesn't give good examples, but because it is filled with misguided, and at times simply wrong information, both in background topics, but also, and perhaps more concerning, the actual matter of the OpenCL standard. Do yourself a favor and pick a copy of "OpenCL in Action" (published by: Manning Publications), or "Heterogeneous Computing with OpenCL" (published by: Morgan Kaufmann), or even "The OpenCL Programming Guide" (published by: Addison-Wesley Professional), which closely resembles the standard (written by some of the standard editors...), before you pick this book.