|
||||||||||||||||||||
|
||||||||||||||||||||
|
||||||||||||||||||||
The Art of Concurrency
und über 1 Million weitere Bücher verfügbar für Amazon Kindle .
Erfahren Sie mehr
| |||||||||||||||
 Gutschein erhalten
Tauschen Sie jetzt The Art of Concurrency: A Thread Monkey's Guide to Writing Parallel Applications gegen einen Amazon-Gutschein in Höhe von EUR 8,60 ein - einlösbar für Tausende von Artikeln bei Amazon.de. Entdecken Sie mehr eintauschbare Bücher im Bücher Trade-In Shop. Bitte beachten Sie die Teilnahmebedingungen.
 Jetzt für Amazon Student anmelden und um 20% erhöhten Eintauschwert sichern. |
Wird oft zusammen gekauft
Produktinformation
Möchten Sie die Produktinformationen aktualisieren oder Feedback zu den Produktabbildungen geben?
Ist der Verkauf dieses Produkts für Sie nicht akzeptabel? |
Mehr über den Autor
Entdecken Sie Bücher, lesen Sie über Autoren und mehr
› Besuchen Sie die Seite von Clay Breshears auf Amazon
› Besuchen Sie die Seite von Clay Breshears auf Amazon
Produktbeschreibungen
Pressestimmen
"Fazit: Das er ein "Freund der Sortierung" ist, lässt sich bereits an der Seitenzahl der Kapitel ablesen. Aber das tut dem runden Eindruck, den das Buch hinterlässt, keinen Abbruch. Die zuvor annvisierte Leserschaft wird mit dem Buch von Clay Breshears bestens zurechtkommen und interessierten Neulingen bietet er eine kompetente Einführung in die Thematik. Dieses Buch hat mich zu einigen neuen Ideen inspiriert - weshalb ich es nicht zuletzt deshalb empfehlen kann." - StuSieLug, November 2009 Lesen Sie die ausführliche Rezension unter: http://linux.studentensiedlung.de/books/concurr.php
Kurzbeschreibung
If you're looking to take full advantage of multi-core processors with concurrent programming, this practical book provides the knowledge and hands-on experience you need. The Art of Concurrency is one of the few resources to focus on implementing algorithms in the shared-memory model of multi-core processors, rather than just theoretical models or distributed-memory architectures. The book provides detailed explanations and usable samples to help you transform algorithms from serial to parallel code, along with advice and analysis for avoiding mistakes that programmers typically make when first attempting these computations. Written by an Intel engineer with over two decades of parallel and concurrent programming experience, this book will help you: * Understand parallelism and concurrency * Explore differences between programming for shared-memory and distributed-memory * Learn guidelines for designing multithreaded applications, including testing and tuning * Discover how to make best use of different threading libraries, including Windows threads, POSIX threads, OpenMP, and Intel Threading Building Blocks * Explore how to implement concurrent algorithms that involve sorting, searching, graphs, and other practical computations The Art of Concurrency shows you how to keep algorithms scalable to take advantage of new processors with even more cores. For developing parallel code algorithms for concurrent programming, this book is a must.
Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?
In diesem Buch
(Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Tags, die Kunden mit diesem Produkt verbinden(Was ist das?)Klicken Sie zum Suchen verwandter Artikel, Diskussionen oder Personen auf ein Tag.
|
Kundenrezensionen
Die hilfreichsten Kundenrezensionen
16 von 17 Kunden fanden die folgende Rezension hilfreich
Von der Kunst der Gleichzeitigkeit - Clay Breshears Einführung in thread-basierte Programmierung
31. Oktober 2009
Format:Taschenbuch
Einleitung
Es ist noch gar noch so lange her, da wurde man als Programmierer von seinen Freunden und Kollegen ein wenig schief angeschaut, wenn man in vertrauter Runde auf die Frage, an was man denn gerade arbeite, geantwortet hat, das man eine Thread-basierte Software entwickle. Viele der Entwickler rümpften zumindest innerlich mit der Nase - lautete doch der neuste Hype in Sachen paralleler Programmierung und Ereignisverarbeitung "event-based" und nicht (mehr) "thread-based" [1].
Nicht so bei dem Autor Clay Breshears: er hat ein Buch über die Kunst der parallelen Programmierung (genauer: über die "Kunst der Gleichzeitigkeit") geschrieben, in dem er Threads pragmatisch und vollkommen undogmatisch verwendet. Das mag auch damit zusammenhängen, das die modernen Prozessoren durch die Multikern-Technologie zu echter Parallelität fähig sind (soweit dies von dem Betriebssystem und/oder der Programmiersprache unterstützt wird).
Beschreibung
Das Buch beginnt klassisch und wie bei O'Reilly gewohnt: mit einem Kapitel, indem sich der Autor über die anvisierte Zielgruppe Gedanken macht. In diesem Fall richtet sich Clay Breshears an Studenten, professionelle Softwareentwickler und ambitionierte Programmierer, die vor numerischen Algorithmen und theoretischen Überlegungen nicht zurückschrecken. Er führt einige Grundbegriffe der parallelen Programmierung ein, die im weiteren Verlauf des Buches immer wieder auftauchen werden. Er stellt dabei zunächst ganz grundsätzliche Fragen in den Raum und nähert sich so dem "Paradigma" der parallelen Programmierung.
(Keywords: shared-memory, distributed-memory, dividing work, communication, design, locks
Seiten: 18)
Im zweiten Kapitel steht die Frage nach "Was ist denn parallel und was nicht?" im Vordergrund. Er untersucht unterschiedliche Szenarien und versucht diese in parallele Handlungsstränge zu dekomponieren. Wo dies nicht gelingt, erbringt er einen Hinweis auf die Nicht-Parallelisierung des Problems.
(Keywords: task decomposition, granularity, boss-worker, scheduling, data decomposition
Seiten: 21)
Das dritte Kapitel steht ganz im Zeichen von Performanz und Verifikation. Er verdeutlicht die Problematik anhand von Algorithmen, die sich nicht korrekt verhalten und leitet daraus Richtlinien ab, mit denen man einige der kritischen Bereiche umgehen kann.
Neben der korrekten Funktionsweise der Programme untersucht er die Performanz der Algorithmen und interessiert sich dabei besonders für die Verbesserung der Laufzeit (Speedup).
(Keywords: critical section, speedup, conditions
Seiten: 22)
Im vierten Kapitel fasst er die vorherigen Erkenntnisse und Gedanken zusammen und präsentiert acht Grundregeln für ein gutes Design von multithreaded Applikationen.
(Seiten: 7)
Kapitel fünf ist vier Thread-Bibliotheken oder -umgebungen gewidmet, mit denen er in den folgenden Kapiteln die Algorithmen (in verkürzter Form) beschreiben wird. Er unterscheidet zwischen implizitem Threading mit den Vertretern "OpenMP" und "Intel TBB (Thread Building Blocks)" sowie explizitem Threading mit POSIX Threads und Windows Threads by Microsoft.
(Keywords: implicit threading, explicit threading, libraries
Seiten: 11)
Mit dem sechsten Kapitel beginnt der algorithmische und numerische Teil des Buches: die ersten fünf Kapitel dienten der Einführung in die Welt der parallelen Programmierung, nun stellt er konkrete Algorithmen und Probleme vor, wählt dazu eine der Thread-Libraries aus und entwickelt Lösungen für das Problem. Jeder wichtige Algorithmus wird anschließend nach vier Kriterien beurteilt. Die Kriterien lauten:
1. Effizienz
2. Einfachheit ('simplicity')
3. Portabilität und
4- Skalierbarkeit
Er beginnt mit parallelen Summen und Präfix-Suchen.
(Keywords: parallel sum, PRAM algorithm, median
Seiten: 28)
Das siebte Kapitel gilt "MapReduce" - einem Framework ganz ählich wie "divide-and-conquer" o.ä. Zunächst untersucht er das "Mapping" der Daten (und deren Dekomposition) um sich danach auf das "Reduzieren" zu konzentrieren. Im Verlauf des Kapitels wird ein weiterer Mechanismus zur Synchronisierung von parallelen Prozessen vorgeschlagen: das "Barrier Object".
(Keywords: map, reduce, google, barrier object, key-value,
Seiten: 17)
Kapitel acht ist ausschließlich der Sortierung gewidmet. Er stellt mindestens fünf Sortierverfahren vor, samt naiver Implementierung, Verbesserungen und Beurteilung nach dem vier-Kritierien Schema (siehe Kapitel sechs).
(Keywords: bubblesort, odd-even transposition, shellsort, quicksort, radix-sort,
Seiten: 37)
Das Thema des neunten Kapitels ist "Suchen". Er unterscheidet zwischen unsortierten und bereits geordneten Daten und untersucht darauf jeweils eine Such-Strategie.
(Keywords: binary search, sorted, unsorted,
Seiten: 9)
Im zehnten und vorletzten Kapitel werden "Graphen" und für diesen Bereich typische Fragestellungen ("minimal spanning tree" etc.) behandelt.
(Keywords: depth-first, shortest path, rubik's cube, breadth-first, floyd, kruskal, prim
Seiten: 24)
Das letzte Kapitel ist eine Vorstellung von Tools, die bei der Entwicklung und Programmierung von parallelen Applikationen helfen sollen.
(Keywords: gdb, dbx, debugger, hot-spots,
Seiten: 6)
Meinung
Der Autor hat einen angenehm zu lesenden, professionellen und präzisen Schreibstil. Er vermittelt seine langjährige Erfahrung glaubhaft, ohne jedoch überheblich oder abgehoben zu wirken. Das Buch im Ganzen und jedes Kapitel im Einzelnen ist klar gegliedert und wirkt in seiner Struktur aufgeräumt und übersichtlich. Die Probleme sind gut beschrieben, und dort wo nötig, illustriert. Grafiken sind sparsam aber effektiv eingesetzt.
Clay Breshears führt kompetent in die Thematik ein und wird ihrer Komplexität in dem Rahmen, den er sich für das Buch gesetzt hat, gerecht. Leider sind viele Beispiele zu "akademisch", d.h. er arbeitet mit Datenstrukturen, die recht klein dimensioniert (aber damit auch anschaulicher) sind. So ist es nicht so nicht ganz einfach, davon auf reale Probleme zu schließen, um ein Gefühl
für die Verbesserungen durch parallele Algorithmen zu bekommen. Auch fehlen dem Buch ein paar Benchmarks, die er in einem kleine Testszenario ermittelt hat und deren Ergebnisse er kommentiert.
Obwohl er bei Intel arbeitet, gibt es leider auch keine Informationen zur Architektur von Multikern-Prozessoren, die das Verständnis u.U. noch weiter gefördert hätten.
Fazit
Das er ein "Freund der Sortierung" ist, lässt sich bereits an der Seitenzahl der Kapitel ablesen. Aber das tut dem runden Eindruck, den das Buch hinterlässt, keinen Abbruch. Die zuvor annvisierte Leserschaft wird mit dem Buch von Clay Breshears bestens zurechtkommen und interessierten Neulingen bietet er eine kompetente Einführung in die Thematik. Dieses Buch hat mich zu einigen neuen Ideen inspiriert - weshalb ich es nicht zuletzt deshalb empfehlen kann.
--
[1]:
Dieser Eindruck wird durch die imposante Anzahl von gefundenen Seiten und Dokumenten bestätigt, wenn man an Google eine Suchanfrage mit "thread-based vs event-based" schickt. Meine letzte Anfrage ergab ca. 59 Millionen Seiten!
(30.10.2009, 19:00 Uhr).
Es ist noch gar noch so lange her, da wurde man als Programmierer von seinen Freunden und Kollegen ein wenig schief angeschaut, wenn man in vertrauter Runde auf die Frage, an was man denn gerade arbeite, geantwortet hat, das man eine Thread-basierte Software entwickle. Viele der Entwickler rümpften zumindest innerlich mit der Nase - lautete doch der neuste Hype in Sachen paralleler Programmierung und Ereignisverarbeitung "event-based" und nicht (mehr) "thread-based" [1].
Nicht so bei dem Autor Clay Breshears: er hat ein Buch über die Kunst der parallelen Programmierung (genauer: über die "Kunst der Gleichzeitigkeit") geschrieben, in dem er Threads pragmatisch und vollkommen undogmatisch verwendet. Das mag auch damit zusammenhängen, das die modernen Prozessoren durch die Multikern-Technologie zu echter Parallelität fähig sind (soweit dies von dem Betriebssystem und/oder der Programmiersprache unterstützt wird).
Beschreibung
Das Buch beginnt klassisch und wie bei O'Reilly gewohnt: mit einem Kapitel, indem sich der Autor über die anvisierte Zielgruppe Gedanken macht. In diesem Fall richtet sich Clay Breshears an Studenten, professionelle Softwareentwickler und ambitionierte Programmierer, die vor numerischen Algorithmen und theoretischen Überlegungen nicht zurückschrecken. Er führt einige Grundbegriffe der parallelen Programmierung ein, die im weiteren Verlauf des Buches immer wieder auftauchen werden. Er stellt dabei zunächst ganz grundsätzliche Fragen in den Raum und nähert sich so dem "Paradigma" der parallelen Programmierung.
(Keywords: shared-memory, distributed-memory, dividing work, communication, design, locks
Seiten: 18)
Im zweiten Kapitel steht die Frage nach "Was ist denn parallel und was nicht?" im Vordergrund. Er untersucht unterschiedliche Szenarien und versucht diese in parallele Handlungsstränge zu dekomponieren. Wo dies nicht gelingt, erbringt er einen Hinweis auf die Nicht-Parallelisierung des Problems.
(Keywords: task decomposition, granularity, boss-worker, scheduling, data decomposition
Seiten: 21)
Das dritte Kapitel steht ganz im Zeichen von Performanz und Verifikation. Er verdeutlicht die Problematik anhand von Algorithmen, die sich nicht korrekt verhalten und leitet daraus Richtlinien ab, mit denen man einige der kritischen Bereiche umgehen kann.
Neben der korrekten Funktionsweise der Programme untersucht er die Performanz der Algorithmen und interessiert sich dabei besonders für die Verbesserung der Laufzeit (Speedup).
(Keywords: critical section, speedup, conditions
Seiten: 22)
Im vierten Kapitel fasst er die vorherigen Erkenntnisse und Gedanken zusammen und präsentiert acht Grundregeln für ein gutes Design von multithreaded Applikationen.
(Seiten: 7)
Kapitel fünf ist vier Thread-Bibliotheken oder -umgebungen gewidmet, mit denen er in den folgenden Kapiteln die Algorithmen (in verkürzter Form) beschreiben wird. Er unterscheidet zwischen implizitem Threading mit den Vertretern "OpenMP" und "Intel TBB (Thread Building Blocks)" sowie explizitem Threading mit POSIX Threads und Windows Threads by Microsoft.
(Keywords: implicit threading, explicit threading, libraries
Seiten: 11)
Mit dem sechsten Kapitel beginnt der algorithmische und numerische Teil des Buches: die ersten fünf Kapitel dienten der Einführung in die Welt der parallelen Programmierung, nun stellt er konkrete Algorithmen und Probleme vor, wählt dazu eine der Thread-Libraries aus und entwickelt Lösungen für das Problem. Jeder wichtige Algorithmus wird anschließend nach vier Kriterien beurteilt. Die Kriterien lauten:
1. Effizienz
2. Einfachheit ('simplicity')
3. Portabilität und
4- Skalierbarkeit
Er beginnt mit parallelen Summen und Präfix-Suchen.
(Keywords: parallel sum, PRAM algorithm, median
Seiten: 28)
Das siebte Kapitel gilt "MapReduce" - einem Framework ganz ählich wie "divide-and-conquer" o.ä. Zunächst untersucht er das "Mapping" der Daten (und deren Dekomposition) um sich danach auf das "Reduzieren" zu konzentrieren. Im Verlauf des Kapitels wird ein weiterer Mechanismus zur Synchronisierung von parallelen Prozessen vorgeschlagen: das "Barrier Object".
(Keywords: map, reduce, google, barrier object, key-value,
Seiten: 17)
Kapitel acht ist ausschließlich der Sortierung gewidmet. Er stellt mindestens fünf Sortierverfahren vor, samt naiver Implementierung, Verbesserungen und Beurteilung nach dem vier-Kritierien Schema (siehe Kapitel sechs).
(Keywords: bubblesort, odd-even transposition, shellsort, quicksort, radix-sort,
Seiten: 37)
Das Thema des neunten Kapitels ist "Suchen". Er unterscheidet zwischen unsortierten und bereits geordneten Daten und untersucht darauf jeweils eine Such-Strategie.
(Keywords: binary search, sorted, unsorted,
Seiten: 9)
Im zehnten und vorletzten Kapitel werden "Graphen" und für diesen Bereich typische Fragestellungen ("minimal spanning tree" etc.) behandelt.
(Keywords: depth-first, shortest path, rubik's cube, breadth-first, floyd, kruskal, prim
Seiten: 24)
Das letzte Kapitel ist eine Vorstellung von Tools, die bei der Entwicklung und Programmierung von parallelen Applikationen helfen sollen.
(Keywords: gdb, dbx, debugger, hot-spots,
Seiten: 6)
Meinung
Der Autor hat einen angenehm zu lesenden, professionellen und präzisen Schreibstil. Er vermittelt seine langjährige Erfahrung glaubhaft, ohne jedoch überheblich oder abgehoben zu wirken. Das Buch im Ganzen und jedes Kapitel im Einzelnen ist klar gegliedert und wirkt in seiner Struktur aufgeräumt und übersichtlich. Die Probleme sind gut beschrieben, und dort wo nötig, illustriert. Grafiken sind sparsam aber effektiv eingesetzt.
Clay Breshears führt kompetent in die Thematik ein und wird ihrer Komplexität in dem Rahmen, den er sich für das Buch gesetzt hat, gerecht. Leider sind viele Beispiele zu "akademisch", d.h. er arbeitet mit Datenstrukturen, die recht klein dimensioniert (aber damit auch anschaulicher) sind. So ist es nicht so nicht ganz einfach, davon auf reale Probleme zu schließen, um ein Gefühl
für die Verbesserungen durch parallele Algorithmen zu bekommen. Auch fehlen dem Buch ein paar Benchmarks, die er in einem kleine Testszenario ermittelt hat und deren Ergebnisse er kommentiert.
Obwohl er bei Intel arbeitet, gibt es leider auch keine Informationen zur Architektur von Multikern-Prozessoren, die das Verständnis u.U. noch weiter gefördert hätten.
Fazit
Das er ein "Freund der Sortierung" ist, lässt sich bereits an der Seitenzahl der Kapitel ablesen. Aber das tut dem runden Eindruck, den das Buch hinterlässt, keinen Abbruch. Die zuvor annvisierte Leserschaft wird mit dem Buch von Clay Breshears bestens zurechtkommen und interessierten Neulingen bietet er eine kompetente Einführung in die Thematik. Dieses Buch hat mich zu einigen neuen Ideen inspiriert - weshalb ich es nicht zuletzt deshalb empfehlen kann.
--
[1]:
Dieser Eindruck wird durch die imposante Anzahl von gefundenen Seiten und Dokumenten bestätigt, wenn man an Google eine Suchanfrage mit "thread-based vs event-based" schickt. Meine letzte Anfrage ergab ca. 59 Millionen Seiten!
(30.10.2009, 19:00 Uhr).
1 von 1 Kunden fanden die folgende Rezension hilfreich
Format:Taschenbuch
Mit dem Titel "The Art of Concurrency" wird ein hoher Anspruch geweckt, der nicht erfüllt wird. Der Untertitel "A Thread Monkey's Guide to Writing Parallel Applications" wird dem Inhalt schon eher gerecht, aber auch hier gibt es noch einige Kritikpunkte.
In diesem Buch wird die threadbasierte Programmierung von Shared-Memory-Rechnern mit POSIX Threads (pthreads), Windows Threads, OpenMP und mit Intel Thread-Building-Blocks in einer C-ähnlichen-Sprache erläutert. Für Java-Programmierer ist es daher nur bedingt geeignet.
Die theoretischen Grundlagen von Parallelität und Nebenläufigkeit werden nur ganz kurz anhand der PRAM erläutert. Andere Modelle, z. B. das Aktor-Modell, Petri-Netze oder Prozess-Kalküle fehlen völlig. Ebenfalls nichts über "Futures" und "Promises".
Was der Autor hingegen schön macht ist, wie er erklärt, wie man aus einem Algorithmus für die PRAM threadbasierten Code für Shared-Memory-Architekturen herleitet. Wie man etwas am besten parallelisiert und da aus seiner reichhaltigen Erfahrung schöpft.
Leser mit genügend Interesse an dieser Programmierung finden hier viele Beispiele. Gegner, die behaupten das Code mit Threads und Shared-Memory leicht kompliziert wird und zu nicht wartbarem Code-Chaos führt allerdings auch.
Insgesamt werden 13 Algorithmen (davon 6 Sortierverfahren) parallelisiert. Mir persönlich ist nicht klar, warum die Möglichkeiten der Parallelisierung nicht an 2-3 Beispielalgorithmen gezeigt werden. Was will mir dieses Buch beibringen? Die grundlegenden Algorithmen? Diese werden in anderen Büchern (Cormen, Leiserson, Rivest, etc.) besser und ausführlicher erklärt. Auch ist die verwendete C-ähnliche Programmiersprache didaktisch ungeeignet.
Leider gibt es auch keine Übungsaufgaben im Buch, so dass der Leser leider nicht selber aktiv werden und das Gelernte überprüfen kann.
Als ich dann bei Wikipedia unter "Minimal Spanning Tree" folgendes las "Typically, parallel algorithms are based on Bor'vka algorithm'Prim's and especially Kruskal's algorithm do not scale as well to additional processors." , habe ich mich schon gefragt, warum gerade die letzten beiden im Buch implementiert werden.
Fazit: Der Untertitel beschreibt das Buch recht gut, ein Buch über die Kunst des Programmierens, wie z. B. bei Donald Knuths "The Art of Computer Programming" ist es allerdings bei weitem nicht.
In diesem Buch wird die threadbasierte Programmierung von Shared-Memory-Rechnern mit POSIX Threads (pthreads), Windows Threads, OpenMP und mit Intel Thread-Building-Blocks in einer C-ähnlichen-Sprache erläutert. Für Java-Programmierer ist es daher nur bedingt geeignet.
Die theoretischen Grundlagen von Parallelität und Nebenläufigkeit werden nur ganz kurz anhand der PRAM erläutert. Andere Modelle, z. B. das Aktor-Modell, Petri-Netze oder Prozess-Kalküle fehlen völlig. Ebenfalls nichts über "Futures" und "Promises".
Was der Autor hingegen schön macht ist, wie er erklärt, wie man aus einem Algorithmus für die PRAM threadbasierten Code für Shared-Memory-Architekturen herleitet. Wie man etwas am besten parallelisiert und da aus seiner reichhaltigen Erfahrung schöpft.
Leser mit genügend Interesse an dieser Programmierung finden hier viele Beispiele. Gegner, die behaupten das Code mit Threads und Shared-Memory leicht kompliziert wird und zu nicht wartbarem Code-Chaos führt allerdings auch.
Insgesamt werden 13 Algorithmen (davon 6 Sortierverfahren) parallelisiert. Mir persönlich ist nicht klar, warum die Möglichkeiten der Parallelisierung nicht an 2-3 Beispielalgorithmen gezeigt werden. Was will mir dieses Buch beibringen? Die grundlegenden Algorithmen? Diese werden in anderen Büchern (Cormen, Leiserson, Rivest, etc.) besser und ausführlicher erklärt. Auch ist die verwendete C-ähnliche Programmiersprache didaktisch ungeeignet.
Leider gibt es auch keine Übungsaufgaben im Buch, so dass der Leser leider nicht selber aktiv werden und das Gelernte überprüfen kann.
Als ich dann bei Wikipedia unter "Minimal Spanning Tree" folgendes las "Typically, parallel algorithms are based on Bor'vka algorithm'Prim's and especially Kruskal's algorithm do not scale as well to additional processors." , habe ich mich schon gefragt, warum gerade die letzten beiden im Buch implementiert werden.
Fazit: Der Untertitel beschreibt das Buch recht gut, ein Buch über die Kunst des Programmierens, wie z. B. bei Donald Knuths "The Art of Computer Programming" ist es allerdings bei weitem nicht.
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com:
10 Rezensionen
33 von 36 Kunden fanden die folgende Rezension hilfreich
Not a bad book if you can get over the style and sloppy code
27. August 2009
Format:Taschenbuch
This book is kind of a dull read for (in my opinion) interesting material. The writing style is informal, but self-importantly so (lots of "I did this" and "I've said this before"). Even discounting that, the writer cannot make the subject very interesting. Partly because he eschews figures or flowcharts or itemized steps for walls of text, partly because the writing itself is disjointed and not very good. Remember, informal != good.
Plus, the code is sloppy. Almost everywhere a main routine has a loop pthread_create'ing new threads, "new" is used to allocate and free is used to deallocate a pointer. This is the most egregious one; one can take issue with a lot of others (for example, why is the code C++ if 99% of it is C? Why is the pointer allocated in the main thread but freed in the worker thread?).
The thing I liked about the book is that it covers a lot of relevant topics, including modern ones such as MapReduce. It should reward someone with the patience to overlook its flaws.
Plus, the code is sloppy. Almost everywhere a main routine has a loop pthread_create'ing new threads, "new" is used to allocate and free is used to deallocate a pointer. This is the most egregious one; one can take issue with a lot of others (for example, why is the code C++ if 99% of it is C? Why is the pointer allocated in the main thread but freed in the worker thread?).
The thing I liked about the book is that it covers a lot of relevant topics, including modern ones such as MapReduce. It should reward someone with the patience to overlook its flaws.
21 von 22 Kunden fanden die folgende Rezension hilfreich
casually-written "taster" approach to teaching concurrency
17. Dezember 2009
Format:Taschenbuch
If you are a relative beginner, and not dealing with inherited code, then this book provides a happily patronising and sloppily-coded "taster" introduction to writing algorithms in OpenMP or Intel Thread Building Blocks, with a little coverage of pThreads, and a very small amount of Windows Threading. Java, Erlang, and CUDA/OpenCL are completely absent. Compiler support was sparse and the C++0x standard not ratified at time of writing, so no examples are given of the way lambda functions make it easier to write and use TBB algorithms.
Thread-local storage is mentioned, but no example code is given, so there is insufficient information to actually use it -- the same is true for many other indexed items. (TLS has four entries in the index, but the useful paragraph on p43 is not in the index at all).
If you already know enough to use the libraries it covers, then the only useful thing from this book is going to be the hints, tips and experiences. Unlike a previous good reviewer, these are what I think should be the golden core of the book (there are plenty of better books on parallel algorithms). But like the previous reviewer, I was left extremely disappointed by an opportunity lost. With hints and tips associated with arbitrary algorithms and scorecards throughout the book, most of their potential benefit is lost.
Debugging tools are summarily dealt with on pages 258 and 259, and profiling tools take up the following three pages. Verification and correctness do not make it to the index, although there is a single entry for "testing for correctness", which refers to Design Step 3 on page 10, which says that you should do this, but simply refers you to the six pages of the tools chapter above. Step 3 finally exits reality saying: "With a good solid design, you should be able to keep the number of threading or logic errors to a minimum, so not much verbiage is spent on finding or correcting errors in [concurrent] code". Chapter Three "Proving Correctness and Measuring Performance" does spend a few pages on correctness, but mainly refers to the Ben-Ari book. On actually measuring performance it says: "For serial applications, you can measure an application's speed using a stopwatch. Simply time the run from start to finish." The author then explains how you can measure performance improvement by comparing the time taken for the first version with that of subsequent versions. "It is the same with concurrent programs."
Sample sentences that give you a flavour for the author's style: "While I've never written one or seen an implementation of one, creating a barrier that could work with a different number of threads each time it was used sounds like such a complex and daunting task", "I recommend reading the chapters from Ben-Ari's text (See if you can get it out of the library..", I've not had the chance to work with the task constructs in OpenMP, so there may be other details...", "I won't create a threaded version of this code, but you're welcome to give it a try on your own..", "und so veiter [sic] (or 'and so on' for my English readers)". "
The author is a course architect for Intel specializing in multithreaded progamming and training.
Thread-local storage is mentioned, but no example code is given, so there is insufficient information to actually use it -- the same is true for many other indexed items. (TLS has four entries in the index, but the useful paragraph on p43 is not in the index at all).
If you already know enough to use the libraries it covers, then the only useful thing from this book is going to be the hints, tips and experiences. Unlike a previous good reviewer, these are what I think should be the golden core of the book (there are plenty of better books on parallel algorithms). But like the previous reviewer, I was left extremely disappointed by an opportunity lost. With hints and tips associated with arbitrary algorithms and scorecards throughout the book, most of their potential benefit is lost.
Debugging tools are summarily dealt with on pages 258 and 259, and profiling tools take up the following three pages. Verification and correctness do not make it to the index, although there is a single entry for "testing for correctness", which refers to Design Step 3 on page 10, which says that you should do this, but simply refers you to the six pages of the tools chapter above. Step 3 finally exits reality saying: "With a good solid design, you should be able to keep the number of threading or logic errors to a minimum, so not much verbiage is spent on finding or correcting errors in [concurrent] code". Chapter Three "Proving Correctness and Measuring Performance" does spend a few pages on correctness, but mainly refers to the Ben-Ari book. On actually measuring performance it says: "For serial applications, you can measure an application's speed using a stopwatch. Simply time the run from start to finish." The author then explains how you can measure performance improvement by comparing the time taken for the first version with that of subsequent versions. "It is the same with concurrent programs."
Sample sentences that give you a flavour for the author's style: "While I've never written one or seen an implementation of one, creating a barrier that could work with a different number of threads each time it was used sounds like such a complex and daunting task", "I recommend reading the chapters from Ben-Ari's text (See if you can get it out of the library..", I've not had the chance to work with the task constructs in OpenMP, so there may be other details...", "I won't create a threaded version of this code, but you're welcome to give it a try on your own..", "und so veiter [sic] (or 'and so on' for my English readers)". "
The author is a course architect for Intel specializing in multithreaded progamming and training.
19 von 24 Kunden fanden die folgende Rezension hilfreich
Solid book on concurrent programming
25. Mai 2009
Format:Taschenbuch
This is a new book on concurrent programming that splits the difference between academic tomes on the subject and cookbook code dump type texts.
The author assumes that readers have some basic knowledge of data structures and algorithms and asymptotic efficiency of algorithms (Big-Oh notation) that is typically taught in an undergraduate computer science curriculum. Readers familiar with Introduction to Algorithms should do the trick. He also assumes that the reader is an experienced C programmer (he uses C throughout the book) and knows something about OpenMP, Intel Threading Building Blocks, POSIX threads, or Windows Threads libraries and has a good idea of which of these tools will be used in their own situations. The author does not focus on using one programming paradigm here, since, for the most part, the functionality of these overlap. Instead he presents a variety of threading implementations across a wide spectrum of algorithms that are featured in the latter portion of the book.
The current product description does not show the table of contents, so I do that next:
Chapter 1, "Want to go faster" anticipates and answers some of the questions you might have about concurrent programming. This chapter explains the differences between parallel and concurrent, and describes the four-step threading methodology. The chapter ends with some background on concurrent programming and some of the differences and similarities between distributed-memory and shared-memory programming and execution models.
Chapter 2, "Concurrent or Not Concurrent" collects a lot of the author's wisdom on initial approaches that apply to a large percentage of code you're likely to encounter. Also, the author lets you know that not every bit of computation can be made concurrent, no matter how hard you try. There are examples of the kinds of algorithms and computations that are not friendly to concurrency in Section 2.2. When any of those examples can be modified to allow for concurrent execution, hints and tips are included about how to do that.
Chapter 3, "Proving Correctness and Measuring Performance" takes a look at topics related to the final two steps of the threading methodology. The first is knowing when your concurrent algorithms will run correctly or at least having a good idea that you've done a good job of designing an error-free concurrent algorithm. The second topic covers some of the ways you can measure how well your concurrent code is executing in parallel.
Chapter 4, "Eight Simple Rules" should give you more success in writing the best and most efficient threaded implementation of your applications. In upcoming chapters, when discussing the design and implementation of specific algorithms, the author drops in a reference to one or more of these eight rules.
Chapter 5, Threading Libraries, reviews some of the details of the threading libraries used in subsequent chapters to implement the algorithms. The author assumes that you are already familiar with at least one of these threading methods. Proficiency is not expected, but you should have at least tried your hand at some threaded coding examples before.
If you are unfamiliar with any of the threading libraries, this chapter should provide you with enough details to understand the algorithms implemented with such a library and any library-specific features that are used. Otherwise, this should be a review. You can skip over this chapter and come back when you might have a question about syntax or threading without fear of loss of continuity.
Chapter 6, is entitled "Parallel Sum and Prefix Scan". Summing the elements of an array or finding all partial sums of the elements in an array are basic algorithmic problems. The solution to these problems is easy to describe in a single sentence or two. The concurrent versions of these algorithms, known as parallel sum and prefix scan respectively, are simple and easy to understand. Since they are so simple, these problems have been extensively analyzed and are used as bellwether algorithms within the parallel programming community. Description, design, analysis, and implementation of these two algorithms is intended to prepare you for the rest of the algorithms contained in the text.
Chapter 7, "Map Reduce", is about an algorithmic framework of the same name, like divide-and-conquer or backtracking, rather than a specific algorithm. The pair of operations, map and reduce, is found in LISP and other functional languages. MapReduce has been getting a lot of interest lately as an algorithmic framework that can be executed concurrently.
Chapter 8, "Sorting" examines concurrent sorting. First considered are compare-exchange sorts such as bubble sort. These are sorting algorithms that use the results from comparing two keys to determine the relative order of the elements with those keys. Movement of data items will be based on those results and will be the exchange of the positions of the two items under consideration. The final algorithm considered is radix sort, which compares bits within keys to determine movement of data.
Chapter 9, "Searching", discusses two algorithms you can use to search through a collection of data and shows how to make them concurrent to decrease the time needed to locate items of interest. For simplicity, it is assumed that all keys within a data set to be searched are unique. Strategies for dealing with multiple duplicate keys are only mentioned briefly.
Chapter 10, "Graph Algorithms", talks briefly about what a graph is and how it is represented and then how it is traversed using both depth-first and breadth-first search algorithms. It is very well illustrated.
Chapter 11,"Threading Tools", mentions some debugging and performance tools that you can use on threaded applications. The set of tools covered in this chapter is not exhaustive and is meant to show you ways to track down problems in a much quicker manner than if you performed the hunt yourself.
All in all, this is a very useful yet not over-academic book. I would say that you should probably have read something along the lines of Using OpenMP: Portable Shared Memory Parallel Programming (Scientific and Engineering Computation), or at least read that book in parallel with this one. If you're not interested in OpenMP, you would of course read a book on a different technique for concurrent programming.
The author assumes that readers have some basic knowledge of data structures and algorithms and asymptotic efficiency of algorithms (Big-Oh notation) that is typically taught in an undergraduate computer science curriculum. Readers familiar with Introduction to Algorithms should do the trick. He also assumes that the reader is an experienced C programmer (he uses C throughout the book) and knows something about OpenMP, Intel Threading Building Blocks, POSIX threads, or Windows Threads libraries and has a good idea of which of these tools will be used in their own situations. The author does not focus on using one programming paradigm here, since, for the most part, the functionality of these overlap. Instead he presents a variety of threading implementations across a wide spectrum of algorithms that are featured in the latter portion of the book.
The current product description does not show the table of contents, so I do that next:
Chapter 1, "Want to go faster" anticipates and answers some of the questions you might have about concurrent programming. This chapter explains the differences between parallel and concurrent, and describes the four-step threading methodology. The chapter ends with some background on concurrent programming and some of the differences and similarities between distributed-memory and shared-memory programming and execution models.
Chapter 2, "Concurrent or Not Concurrent" collects a lot of the author's wisdom on initial approaches that apply to a large percentage of code you're likely to encounter. Also, the author lets you know that not every bit of computation can be made concurrent, no matter how hard you try. There are examples of the kinds of algorithms and computations that are not friendly to concurrency in Section 2.2. When any of those examples can be modified to allow for concurrent execution, hints and tips are included about how to do that.
Chapter 3, "Proving Correctness and Measuring Performance" takes a look at topics related to the final two steps of the threading methodology. The first is knowing when your concurrent algorithms will run correctly or at least having a good idea that you've done a good job of designing an error-free concurrent algorithm. The second topic covers some of the ways you can measure how well your concurrent code is executing in parallel.
Chapter 4, "Eight Simple Rules" should give you more success in writing the best and most efficient threaded implementation of your applications. In upcoming chapters, when discussing the design and implementation of specific algorithms, the author drops in a reference to one or more of these eight rules.
Chapter 5, Threading Libraries, reviews some of the details of the threading libraries used in subsequent chapters to implement the algorithms. The author assumes that you are already familiar with at least one of these threading methods. Proficiency is not expected, but you should have at least tried your hand at some threaded coding examples before.
If you are unfamiliar with any of the threading libraries, this chapter should provide you with enough details to understand the algorithms implemented with such a library and any library-specific features that are used. Otherwise, this should be a review. You can skip over this chapter and come back when you might have a question about syntax or threading without fear of loss of continuity.
Chapter 6, is entitled "Parallel Sum and Prefix Scan". Summing the elements of an array or finding all partial sums of the elements in an array are basic algorithmic problems. The solution to these problems is easy to describe in a single sentence or two. The concurrent versions of these algorithms, known as parallel sum and prefix scan respectively, are simple and easy to understand. Since they are so simple, these problems have been extensively analyzed and are used as bellwether algorithms within the parallel programming community. Description, design, analysis, and implementation of these two algorithms is intended to prepare you for the rest of the algorithms contained in the text.
Chapter 7, "Map Reduce", is about an algorithmic framework of the same name, like divide-and-conquer or backtracking, rather than a specific algorithm. The pair of operations, map and reduce, is found in LISP and other functional languages. MapReduce has been getting a lot of interest lately as an algorithmic framework that can be executed concurrently.
Chapter 8, "Sorting" examines concurrent sorting. First considered are compare-exchange sorts such as bubble sort. These are sorting algorithms that use the results from comparing two keys to determine the relative order of the elements with those keys. Movement of data items will be based on those results and will be the exchange of the positions of the two items under consideration. The final algorithm considered is radix sort, which compares bits within keys to determine movement of data.
Chapter 9, "Searching", discusses two algorithms you can use to search through a collection of data and shows how to make them concurrent to decrease the time needed to locate items of interest. For simplicity, it is assumed that all keys within a data set to be searched are unique. Strategies for dealing with multiple duplicate keys are only mentioned briefly.
Chapter 10, "Graph Algorithms", talks briefly about what a graph is and how it is represented and then how it is traversed using both depth-first and breadth-first search algorithms. It is very well illustrated.
Chapter 11,"Threading Tools", mentions some debugging and performance tools that you can use on threaded applications. The set of tools covered in this chapter is not exhaustive and is meant to show you ways to track down problems in a much quicker manner than if you performed the hunt yourself.
All in all, this is a very useful yet not over-academic book. I would say that you should probably have read something along the lines of Using OpenMP: Portable Shared Memory Parallel Programming (Scientific and Engineering Computation), or at least read that book in parallel with this one. If you're not interested in OpenMP, you would of course read a book on a different technique for concurrent programming.
Waren diese Rezensionen hilfreich?
Wir wollen von Ihnen hören.
Kunden diskutieren
|
Das Forum zu diesem Produkt
Fragen stellen, Meinungen austauschen, Einblicke gewinnen Aktive Diskussionen in ähnlichen Foren
Kundendiskussionen durchsuchen
|
Ähnliche Foren
|
||||||||||||||||||||||||||||||||||
Lieblingslisten
|
|
Ähnliche Artikel finden
Anhand des Sachgebietes nach ähnlichen Produkten suchen:
Ihr Kommentar
Möchten Sie die Produktinformationen aktualisieren oder Feedback zu den Produktabbildungen geben?
|
