Programming Massively Parallel Processors: A Hands-on Approach

Bought for a programmer by trade so guessing it's good

Perfetto libro di riferimento per chi vuole approcciarsi alla programmazione parallela completo ed esaustivo. Un classico che va sempre bene (per ora)

One of the problems with many parallel programming books is that they take too general of an approach, which can leave the reader to figure out how to implement the ideas using the library of his/her choosing. There's certainly a place for such a book in the world, but not if you want to get up and running quickly.Programming Massively Parallel Processors presents parallel programming from the perspective of someone programming an NVIDIA GPU using their CUDA platform. From matrix multiplication (the "hello world" of the parallel computing world) to fine-tuned optimization, this book walks the reader through step by step not only how to do it, but how to think about it for any arbitrary problem.The introduction mentions that this book does not require a background in computer architecture or C/C++ programming experience, and while that's largely true, I think it would be extremely helpful to come into a topic like this with at least some exposure in those areas.Summary: this book is the best reference I've found for learning parallel programming "the CUDA way". Many of the concepts will carry over to other approaches (OpenMP, MPI, etc.), but this is by and large a CUDA book. Highly recommended.

Das Buch entstand aus mehreren Vorlesungen/Kursen der Autoren zur CUDA. Die Autoren verwenden nicht die übliche Copy&Paste Methode der SDK-Dokumentation. Sie geben dem Leser stattdessen den klassischen Ratschlag RTFM. Sie konzentrieren sich auf die konzeptionelle Seite. An Hand einer Matrizenmultiplikation wird schrittweise gezeigt, wie man die maximale Performance aus einer GPU herausholen kann. Die unmittelbare Transformation des Problems in die CUDA ist sehr einfach. Allerdings wird dieser naive Ansatz durch die Latenz und die Bandweite des globalen Grafikkarten Memory's ausgebremst. Ein klassisches Problem in praktisch allen massiv-parallelen Techniken mit shared memory (bei distributed memory ist dafür die Kommunikation der Flaschenhals). Die Autoren zeigen, wie man durch diverse Tricks den globalen Memory-Zugriff verringert und lokales Memory besser ausnützt. Sie gehen auch detailliert auf den dadurch erreichbaren Speedup ein. Die einzelnen Schritte sind didaktisch sehr gut aufgebaut. Man bekommt ein gutes Gefühl für die Stärken und Schwächen der GPU.Ich habe bereits eine HPC (High-Performance-Computing) Anwendung mit FPGAs gebaut. Die FPGA Community machte sich Hoffnungen, in diesen lukrativen Markt am Kuchen mitnaschen zu können. Für rein numerische (floating-point) HPC-Anwendungen sind diese Pläne m.E. mit dem Erscheinen der CUDA gestorben. Man muss auch mit der CUDA einiges Hirnschmalz aufwenden um einen Algorithmus effektiv zu implementieren. Aber im Verhältnis zum Aufwand für eine FPGA-Implementation ist das noch immer nix. Auch preislich liegen zwischen HPC-FPGA Karten und Grafikkarten Welten. Ich kenn auch keine mit diesem Buch vergleichbare Einführung in das HPC-Computing mit FPGAs.Die Sache wurde in den Kinderzimmern entschieden.Es schwebt mir vor, eine finanzmathematische Monte-Carlo Simulation auf die CUDA zu portieren. Allerdings habe ich das Problem, dass die Simulation auch am Pentium schnell genug ist. Ich muss wohl das Model komplexer machen um mich mit guten Gewissen mit der CUDA spielen zu können. Es war noch nie so leicht eine massiv-parallele Anwendung zu schreiben. Es ist aber auch nicht zu leicht.

This book is a much better introduction to programming GPUs via CUDA than CUDA manual, or some presentation floating on the web. It is a little odd in coverage and language. You can tell it is written by two people with different command of English as well as passion. One co-author seems to be trying very hard to be colorful and looking for idiot-proof analogies but is prone to repetition. The other co-author sounds like a dry marketing droid sometimes. There are some mistakes in the codes in the book, but not too many since they don't dwell too long on code listings. In terms of coverage, I wish they'd cover texture memories, profiling tools, examples beyond simple matrix multiplication, and advice on computational thinking for codes with random access patterns. Chapters 6, 8, 9, and 10 are worth reading several times as they are full of practical tricks to use to trade one performance limiter for another in the quest for higher performance.