Professional Multicore Programming: Design and Implementation for C++ Developers presents the basics of multicore programming in a simple, easy-to-understand manner so that you can easily apply the concepts to your everyday projects. Learn the fundamentals of programming for multiprocessor and multithreaded architecture, progress to multi-core programming and eventually become comfortable with programming techniques that otherwise can be difficult to understand. Anticipate the pitfalls and traps of concurrency programming and synchronization before you encounter them yourself by finding them outlined in this indispensable guide to multicore programming.
Professional Multicore Programming
and over one million other books are available for Amazon Kindle.
Learn more
FREE Two-Day Shipping for Students. Learn more |
| ||||||||||||||||||
 Sell Back Your Copy for $10.20
Whether you buy it used on Amazon for $12.42 or somewhere else, you can sell it back through our Book Trade-In Program at the current price of $10.20.
Used Price$12.42
Trade-in Price$10.20
Price after
Trade-in$2.22 |
Book Description
Special Offers and Product Promotions
- Buy $50 in qualifying physical textbooks, get $5 in Amazon MP3 Credit. Here's how (restrictions apply)
Frequently Bought Together
Editorial Reviews
From the Back Cover
Professional Multicore Programming: Design and Implementation for C++ Developers
In order to increase overall system performance, computer manufacturers have opted to add more processors rather than increase clock frequency. In turn, if you want an application to benefit from the next new processor, that application will have to be modified to exploit multiprocessor computers. This practical book shifts the focus from sequential programming techniques to parallel and multithreaded programming techniques and introduces you to the everyday fundamentals of programming for multiprocessor and multithreaded architectures.
This duo of experienced authors takes the complicated topics of parallel processing and software concurrency and presents them in a clear, understandable manner. Their no-nonsense approach to programming multiprocessing and multithreading models, along with numerous helpful examples, demonstrates how to execute successful multicore programming and enables you to harness the power of the new multicore processors to their fullest potential.
What you will learn from this book
The various pitfalls, traps, and challenges of concurrency programming and synchronization
Methods and techniques for debugging and testing multicore programming
How to take advantage of processor-specific features using cross-platform techniques
The role of the operating system in multicore programming
Ways to take advantage of framework classes as building blocks for concurrency
How to reduce the complexity of task synchronization and communication through the use of interface classes
Who this book is for
This book is for developers of various skill levels who are making the move into multicore programming and application development.
Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job.
About the Author
Cameron Hughes is a professional software developer. He is a software engineer at CTEST Laboratories and a staff programmer/analyst at Youngstown State University. With over 15 years as a software developer, Cameron Hughes has been involved in software development efforts of all sizes, from business and industrial applications to aerospace design and development projects. Cameron is the designer of the Cognopaedia and is currently project leader on the GRIOT project that runs on the Pantheon at CTEST Laboratories. The Pantheon is a 24 node multicore cluster that is used in the development of multithreaded search engine and text extraction programs.
Tracey Hughes is a senior graphics programmer at CTEST Laboratories, where she develops knowledge and information visualization software. Tracey Hughes is the lead designer for the M.I.N.D, C.R.A.I.G, and NOFAQS projects that utilize epistemic visualization at CTEST Laboratories. She regularly contributes to Linux development software efforts. She is also a team member on the GRIOT project.
Cameron and Tracey Hughes are also the authors of six books on software development, multithreaded, and parallel programming: Parallel and Distributed Programming Using C (Addison Wesley, 2003), Linux Rapid Application Development (Hungry Minds, 2000), Mastering the Standard C++ Classes (Wiley, 1999), Object - Oriented Multithreading Using C (Wiley, 1997), Collection and Container Classes in C++ (Wiley, 1996), and Object - Oriented I/O Using C Iostreams (Wiley, 1995).
Product Details
Would you like to update product info or give feedback on images?
|
More About the Author
Discover books, learn about writers, read author blogs, and more.
Customer Reviews
|
Share your thoughts with other customers:
|
||||||||||||||||||||||
|
Most Helpful Customer Reviews
24 of 26 people found the following review helpful:
1.0 out of 5 stars
Utterly worthless!!!,
By
Amazon Verified Purchase(What's this?)
This review is from: Professional Multicore Programming: Design and Implementation for C++ Developers (Wrox Programmer to Programmer) (Paperback)
This book is a complete waste of money. When I came across this book on the Amazon website, I thought it would be similar to "The Art of Multiprocessor Programming" by Herlihy et al., for C++ programmers and with a more practical (and less theoretical) approach (because its "Programmer to Programmer"). But this book comes nowhere near that one.
The content is *extremely* light and *extremely* superficial. Authors discuss topics like threads, processes, etc. in over 100 pages, including sub-topics like "monitoring processes with the ps utility", "killing a process - exit(), abort(), kill() calls". Seriously??? Does a multicore book aimed at professional programmers need to discuss this over 100 pages? Topics like mutexes, semaphores have been discussed only at an *introductory* level. Issues like ABA problem, atomic variables, memory fences, etc are not mentioned even once!!! The worst part is that the book spends close to 300 pages discussing UML and POSIX API's. This kind of information can be readily accessed on the internet. I wish I had not bought this one. UPDATE (29AUG2011): As I learn more and more about multicore programming from other resources, my disdain for this book continues to grow. To be specific, things that are missing from this book which *must* be included in any book on this topic (apart from what I have already mentioned above): - Lock free and wait free concepts and their advantages. - Role of caches (false sharing, etc) - Some introduction to NUMA architecture. - Fine-grained locking At most, what you will learn from this book is how to wrap boost::thread in your own class for OO programming and that's it!!!
20 of 27 people found the following review helpful:
5.0 out of 5 stars
The definitive guide to parallel programming,
By
Amazon Verified Purchase(What's this?)
This review is from: Professional Multicore Programming: Design and Implementation for C++ Developers (Wrox Programmer to Programmer) (Paperback)
Professional Multicore Programming is covers lots of great stuff. The book gives you a great intro into parallel computing, then talks about using processes and threads to achieve parallelism. The examples focus on POSIX compliant systems such as Linux.
The book discusses Sun's UltraSparc T1 CPU and IBM's Cell Broadband Engine CPU and does a good job of explaining their architecture. I especially liked Appendix B where they explain 23 concurrency models. There is also a comprehensive POSIX process and threading reference section that comes in handy.
5 of 13 people found the following review helpful:
5.0 out of 5 stars
Excellent book,
By Edgar Benavides "Edgar" (Doral, FL USA) - See all my reviews
Amazon Verified Purchase(What's this?)
This review is from: Professional Multicore Programming: Design and Implementation for C++ Developers (Wrox Programmer to Programmer) (Paperback)
Excellent introduction to multi-core and parallel programming. It really seems that the autors had the hands-on experience to write what is relevant to introduce the multi-core programming.
Share your thoughts with other customers: Create your own review
|
|
Inside This Book
(learn more)
Key Phrases - Statistically Improbable Phrases (SIPs):
(learn more)
bucket status, software development life cycle, interthread communication, front side bus, cell broadband engine, work breakdown structure, standard template library, logical fault tolerance, cancelability state, filesystem persistence, automated painters, thread attribute object, multicore programming, peer threads, concurrent programming library, concurrency infrastructure, multicore development, attribute object attr, contention scope, process with multiple threads, mutex class, concurrently executing tasks, declarative architectures, outbound transitions, thread cancellation Key Phrases - Capitalized Phrases (CAPs): (learn more)
Modeling Software Systems That Require Concurrency, Application Design, Program Name, Interprocess Communication, Libraries Required, Test Environment, The Challenges of Multicore Programming, Multicore Opteron, The Operating System's Role, The New Architecture, Linux Kernel, Write Total, Single Instruction Multiple Data, Total Get, Four Effective Multicore Designs, Headers Required, Execution Instructions, Gallons of Paint Total, Cell Processor Notes, Unified Modeling Language, Exclusive Read Exclusive Write, Predicates Table, Predicate Breakdown Structure, Additional Source Files Needed, Multithreading Table Browse Sample Pages:
Front Cover | Table of Contents | First Pages | Index | Back Cover | Surprise Me!
bucket status, software development life cycle, interthread communication, front side bus, cell broadband engine, work breakdown structure, standard template library, logical fault tolerance, cancelability state, filesystem persistence, automated painters, thread attribute object, multicore programming, peer threads, concurrent programming library, concurrency infrastructure, multicore development, attribute object attr, contention scope, process with multiple threads, mutex class, concurrently executing tasks, declarative architectures, outbound transitions, thread cancellation Key Phrases - Capitalized Phrases (CAPs): (learn more)
Modeling Software Systems That Require Concurrency, Application Design, Program Name, Interprocess Communication, Libraries Required, Test Environment, The Challenges of Multicore Programming, Multicore Opteron, The Operating System's Role, The New Architecture, Linux Kernel, Write Total, Single Instruction Multiple Data, Total Get, Four Effective Multicore Designs, Headers Required, Execution Instructions, Gallons of Paint Total, Cell Processor Notes, Unified Modeling Language, Exclusive Read Exclusive Write, Predicates Table, Predicate Breakdown Structure, Additional Source Files Needed, Multithreading Table Browse Sample Pages:
Front Cover | Table of Contents | First Pages | Index | Back Cover | Surprise Me!
What Other Items Do Customers Buy After Viewing This Item?
Tags Customers Associate with This Product(What's this?)Click on a tag to find related items, discussions, and people.
|
Customer Discussions
|
This product's forum
Active discussions in related forums
Search Customer Discussions
|
Related forums
|
![[Start the discussion]](http://g-ecx.images-amazon.com/images/G/01/x-locale/communities/discussion_boards/start-new-discussion-sec._V192250339_.gif){kind=small}
Listmania!
|
|
