Recorded history is a finely-woven magic fabric of intricate lies about events predating the sixteenth century. There is not a single piece of evidence that can be reliably and independently traced back earlier than the eleventh century. This book details events that are substantiated by hard facts and logic, and validated by new astronomical research and statistical analysis of ancient sources.
Win32 Multithread Programming explains the concepts of multithreaded programs, thus providing the developer with the knowledge necessary to skillfully construct efficient and complex applications. From basic thread synchronization using mutexes and semaphores, to advanced topics like creating reusable thread pools or implementing a deferred processing queue, the book uses real-world applications and carefully constructed examples to illustrate the principles of multithreaded programming. Some of the topics include:
Common designs for building multithreaded user interfaces</li></ul>
The CD-ROM accompanying the book features Mcl, the authors' C++ class library for multithreaded programming, which both wraps multithreaded API functions and easily supports more complex multithreaded scenarios. For programmers using MFC, an additional library, Mcl4Mfc, is included for MFC compatibility.
Win32 Multithread Programming is an essential resource for any developer interested in learning about Win32 multithreaded programming in order to create high-performance, effective applications.
Customer Reviews:
Win32 Multithreaded Programming Review.......2005-10-04
Good overview for how most operating systems work. In depth implementation overview for the different type of kernel objects that can be used via Win32 API to sync your windows threads. Good examples of syncing situations.
A lot of useful techniques.......2001-03-08
I do not deny that the style of writing can be terse at some points. However this book covers a lot of ground on how to write a good , thread safe codes. The class included has provided a lot of usable codes that can be used in complex sowftware projects.
A very good book on multithreading.......2000-11-19
I have not seen a better book on multithreading than this one...
Ok book... but wrapper class is more of a distraction.......2000-09-07
The first five chapters are above average. I considered the wrapper class a distraction from the main topic and would have preferred more examples. This book is definately not for the novice and would be better for the experienced MT programmer whose looking for a quick refresher. If you are looking for a beginner's MT book keep looking as this one is not for you.
This one is a Keeper.......2000-03-17
Here's what I liked about the book:
(1) It provides simple explanation of central concepts and issues around multithreaded programming. This knowledge is platform independent.
(2) Provides clear explanation of Win32 specific API and Kernel Objects, knowledge that is necessary to do Multithreaded Programming on most Microsoft Platforms.
(3) Builds a simple C++ based OO Wrapper class Library for Multithreaded programming that elegantly conceals Win32 APIs idiosyncrasies.
(4) Also builds additional higher Level OO Abstractions (like Monitors) that Win32 does not need to support directly but Programmers need often.
(5) Great illustrations of Multithreading problems, solutions and Patterns through the trailing part of the book.
(6) Code and Diagrams abound.
What's there not to like?
Average customer rating:
- Essential reading for programmers in its domain
- Simply the best
- Good information badly written
- Good Patterns Hidden in Excessive Verbiage
- Size does matter
|
Pattern-Oriented Software Architecture Volume 2: Patterns for Concurrent and Networked Objects
Douglas Schmidt , Michael Stal , Hans Rohnert , and Frank Buschmann
Manufacturer: Wiley
ProductGroup: Book
Binding: Hardcover
 Networking
| Subjects
| Certification Central
| Computers & Internet
| Subjects
| Books
General
| Certification Central
| Computers & Internet
| Subjects
| Books
Computer Design
| Microprocessors & System Design
| Hardware
| Computers & Internet
| Subjects
| Books
Parallel Computing
| System Architecture
| Hardware
| Computers & Internet
| Subjects
| Books
General
| System Architecture
| Hardware
| Computers & Internet
| Subjects
| Books
Object-Oriented Design
| Software Design
| Programming
| Computers & Internet
| Subjects
| Books
Software Design
| Software Design
| Programming
| Computers & Internet
| Subjects
| Books
Software Development
| Software Design
| Programming
| Computers & Internet
| Subjects
| Books
Information Systems
| Software Engineering
| Computer Science
| Computers & Internet
| Subjects
| Books
General
| Computers & Internet
| Subjects
| Books
General
| Medicine
| Subjects
| Books
Software
| Information Systems
| Computer Science & Information Systems
| New & Used Textbooks
| Stores
| Books
Qualifying Textbooks - Spring 2007
| Stores
| Books
Look Inside Computer Books
| Trip
| Specialty Stores
| Books
Look Inside Science Books
| Trip
| Specialty Stores
| Books
Object-Oriented Design
| Design & Development
| Software Books
| Custom Stores
| Stores
| Software
Software Design
| Design & Development
| Software Books
| Custom Stores
| Stores
| Software
Software Development
| Design & Development
| Software Books
| Custom Stores
| Stores
| Software
Similar Items:
- Pattern-Oriented Software Architecture Volume 1: A System of Patterns
- Pattern-Oriented Software Architecture Volume 3: Patterns for Resource Management
- Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series)
- Patterns of Enterprise Application Architecture
- The ACE Programmer's Guide: Practical Design Patterns for Network and Systems Programming
ASIN: 0471606952 |
Book Description
Designing application and middleware software to run in concurrent and networked environments is a significant challenge to software developers. The patterns catalogued in this second volume of Pattern-Oriented Software Architectures (POSA) form the basis of a pattern language that addresses issues associated with concurrency and networking.
The book presents 17 interrelated patterns ranging from idioms through architectural designs. They cover core elements of building concurrent and network systems: service access and configuration, event handling, synchronization,
and concurrency. All patterns present extensive examples and known uses in multiple programming languages, including C++, C, and Java.
The book can be used to tackle specific software development problems or read from cover to cover to provide a fundamental understanding of the best practices for constructing concurrent and networked applications and middleware.
About the Authors
This book has been written by the award winning team responsible for the first POSA volume "A System of Patterns", joined in this volume by Douglas C. Schmidt from University of California, Irvine (UCI), USA.
Visit our Web Page
Customer Reviews:
Essential reading for programmers in its domain.......2006-08-11
I recently finished reading Pattern Oriented Software Architecture Vol 2: Patterns for Networked and Concurrent Objects. Believe it or not, it took me just one night to read this book cover to cover. The main reasons behind this are that a) the techniques described in this book are already well known to people working in a company that deals with some of the largest network applications in the world, and b) the book itself is very well written.
The really nice thing about this book is the way in which the patterns are presented. I was thoroughly impressed with how, for each pattern, the authors start with describing the problems and constraints. The solution is then presented with a static, object view. This is follwed by a dynamic view with a UML sequence diagram that shows how the pattern works at run-time. This is followed by detailed textual description of the steps required to implement the pattern, along with code snippets. Lastly, there's a list of real-world software implementations that have used the respective patterns, and one example from real life. The real life example is on occasion so instrumental in understanding the purpose and/or workings of the pattern that it could make you exclaim, "a-ha!".
Many of the patterns, like Wrapper Facade, Scoped Locking Idiom, Thread-safe Interface, Half-Sync/Half-Async, Leader/Followers, etc. are easy to follow and likely already known to people dealing with networked applications. The most insane patterns that I found were Proactor (for asynchronous demultiplexing and handling of events) and Interceptor (for event based access to the internals of a framework in a safe manner). They have the potential of making you start hating frameworks! About half of the patterns were new for me.
Simply the best.......2006-03-10
If you really want to understand concurrent networked systems, this is the book. It codifies things that have only been known as "black magic" in the past. I have used these concepts in code that I have written, and the results are amazing. It is quite focused on ACE, so you will get the most benefit out of it if you use ACE, but the concepts are presented generally so that using ACE is not required.
Good information badly written.......2005-04-08
This book summarizes some important distributed systems patterns researchers have identified in recent years. In that sense it is a necessary contribution to the software engineering literature.
However, the examples are at times unclear and the author does not always motivate them convincingly. From a technical writing perspective, the passive voice plagues this book from start to end, forcing readers to stop and reread sections to make sense of convoluted prose.
Good Patterns Hidden in Excessive Verbiage.......2004-11-22
First, the patterns in this book are very good. It was nice to see some coverage of low level networking patterns. As an experienced programmer, I was vaguely familiar with many of the patterns already, but it is really helpful to see the lines drawn in the sand, to hear why the authors chose to break things up as they did, and to understand the ramifications of the patterns in greater detail (eg, their clarification of the difference between Observer and Interceptor was quite helpful). I even got to learn some new patterns! (The Leader / Followers pattern was new to me.)
That said, the writing style about drove me BANANAS! I have never lost my place in a sentence when reading a book so many times. I must have read every line twice. Look, I'm a computer geek - I LOVE dense technical books, but this is something else. It's like reading Shakespear, or Charles Dickens. The authors must have been paid by the word. The specific implies the general! Have mercy! I don't need the difference between an interface and its concrete implementation belabored every time it comes up (and in a patterns book, believe me it's often!)
Size does matter.......2004-10-27
Big problems really are different from small problems. Solutions to small problems rarely scale well - the big solution often has to be different in kind from the small one. This book is about solutions to big problems, the kind that may involve hundreds of servers and thousands of clients, or more.
This gives a clear, thorough description of about 15 design patterns that work well large, performance-sensitive applications. Some (like "Scoped Locking") depend on the specific semantics of C++, but may work in Java or C# if used carefully. Others are highly specialized implementations of more general patterns. The "Leader/Followers" pattern, for example, is a one implementation of the "Object Pool" pattern (see Grand, 'Patterns in Java', 1998) used for a particular purpose. On the whole, the authors did a fair job of relating these patterns to others in the literature. I was only occasionally frustrated that I did not have that literature at hand when reading this.
The authors go into extreme detail in describing implementations based on each pattern, something sure to help some readers. There is often a C++ implementation as well, at least in skeletal form. The descriptions go on at great length, averaging almost thirty pages of discussion for each pattern. More isn't necessarily better, though, and some descriptions would have benefitted from a slimming program. I would also have been grateful for more differential discussion - comparing patterns, in terms of the specific decision critieria that argue for one pattern vs. another.
The back matter in this book takes about 100 pages - glossary, bibliography, and indices by pattern, topic, and author names. Very helpful stuff. If it's going to be that long, however, a sentence or two about the more important references would have added little bulk but lots of value to the bibliography.
The book is a good one, giving lots of practical information about the patterns it discusses. It's aimed at an experiecned reader, someone already conversant with OO programming, patterns, and at least a taste of problems bigger than classroom exercises or solo projects. A bit less mass chosen a bit more carefully would have improved this book, but it's still a worthwhile addition to my technical library.
//wiredweird
Average customer rating:
- Great for MPI beginners
- Your MPI on-ramp
- Just what I needed
- Well written, easy for someone who is not an MPI guru... yet
- Very insightful!
|
Parallel Programming With MPI
Peter Pacheco
Manufacturer: Morgan Kaufmann
ProductGroup: Book
Binding: Paperback
Parallel Computing
| System Architecture
| Hardware
| Computers & Internet
| Subjects
| Books
General
| System Architecture
| Hardware
| Computers & Internet
| Subjects
| Books
General
| Programming
| Computers & Internet
| Subjects
| Books
General
| Software
| Computers & Internet
| Subjects
| Books
Mathematics
| Professional Science
| Professional & Technical
| Subjects
| Books
| Applied
| Chaos & Systems
| Geometry & Topology
| Mathematical Analysis
| Mathematical Physics
| Number Systems
| Pure Mathematics
| Transformations
| Trigonometry
Look Inside Computer Books
| Trip
| Specialty Stores
| Books
All Amazon Upgrade
| Amazon Upgrade
| Stores
| Books
Computers & Internet
| Amazon Upgrade
| Stores
| Books
Professional & Technical
| Amazon Upgrade
| Stores
| Books
Qualifying Textbooks - Spring 2007
| Stores
| Books
General
| Software Books
| Custom Stores
| Stores
| Software
Similar Items:
- Using MPI - 2nd Edition: Portable Parallel Programming with the Message Passing Interface (Scientific and Engineering Computation)
- MPI: The Complete Reference (2-volume set)
- Parallel Programming in OpenMP
- Parallel Scientific Computing in C++ and MPI: A Seamless Approach to Parallel Algorithms and their Implementation
- Parallel Programming in C with MPI and OpenMP
ASIN: 1558603395 |
Book Description
A hands-on introduction to parallel programming based on the Message-Passing Interface (MPI) standard, the de-facto industry standard adopted by major vendors of commercial parallel systems. This textbook/tutorial, based on the C language, contains many fully-developed examples and exercises. The complete source code for the examples is available in both C and Fortran 77. Students and professionals will find that the portability of MPI, combined with a thorough grounding in parallel programming principles, will allow them to program any parallel system, from a network of workstations to a parallel supercomputer.
* Proceeds from basic blocking sends and receives to the most esoteric aspects of MPI.
* Includes extensive coverage of performance and debugging.
* Discusses a variety of approaches to the problem of basic I/O on parallel machines.
* Provides exercises and programming assignments.
Customer Reviews:
Great for MPI beginners.......2006-11-09
Pacheco's book is a strong, gently paced introduction to a very complex API. MPI, the message passing interface, is the most common coordination tool for parallel scientific computing. When a Blue Gene programmer has 1,000 or 100,000 processors all working on different parts of one calculation, there's a big problem in getting partial results from where they're computed to where they're needed. That's what MPI is for.
When the problem is so complicated, the solution is also complicated. Pacheco does a good job of breaking MPI down into digestible pieces, starting with the basic send and receive primitives that you'll use most often. He presents each new part of the API in terms of some problem to be solved, keeping a concrete and practical tone to this book. He gradually adds more pieces in terms of more practical exercises: broadcasts and reductions, scatter and gather, data structuring, communicators, and asynchronous IO.
Along the way, Pacheco introduces algorithms that even experienced uniprocessor programmers may not be familiar with, including bitonic sorting and Fox's algorithm for matrix multiplication. This isn't gratuitous intellectual showmanship. It's a pointed demonstration that, when communication barriers change the computation landscape, old paths to solutions may not be the best routes any more. After finishing with the MPI API itself, Pacheco presents debugging techniques and common kinds of support libraries, as well as basic techniques for analyzing the potential and actual acceleration possible for a given problem.
If you're serious about MPI, you'll need the official standard for understanding the fussy details of these complex APIs. That's a pretty brutal way for a beginner to get going, though. This introduces not only the basic concepts of MPI, but also the basics of how to think about highly parallel programming. And, as multi-threaded multi-core multi-processor systems become common, that's an increasing percentage of all programming.
//wiredweird
Your MPI on-ramp.......2006-09-23
I read this book over the past week, covering chapters 1 through 6, skimming 7-10, and reading 11 through the final chapter 16. Its basically applied MPI programming, done up very well and clearly, starting with architectural history & motivations and leading into a simple numerical integrator example program in chapter 4 (chapter 3 was the MPI `hello, world'). The coding used is C, and I wrote my own integrator after finishing chapter 4 to also explore floating point numbers in calculations, loop control, and to integrate arbitrary functions on arbitrary intervals with adjustable resolution. The integrator is developed more fully throughout the book wherein MPI performance issues of the original design are pointed out and polished off as additional MPI functions and techniques are introduced. Some of these techniques included tree-structured initialization & broadcasts, data communication optimizations (such as derived types, packing / unpacking, etc), and guidance as to when certain techniques would be more useful than others offered by MPI. Communications are further advanced later in the book where the important non-blocking forms and more advanced concepts are brought to light & illustrated. Empirical analysis of algorithmic performance occupies two full chapters and is very interesting, including a detailed look into Amdahl's law. Its an excellent example of why we should keeps our eyes open in research. Program design & troubleshooting are also covered, but I only skimmed those chapters. Several parallel algorithms and some parallel libraries are also treated well in the text. At only 362 pages, (minus appendices) this book is a quick read and a superb lab manual. If you are a software developer just now getting into MPI, this book will certainly accelerate you onto MPI with the confidence that you can do anything with it. Just give it a week of your time. Its the perfect self-study manual.
5-stars
Just what I needed.......2006-08-16
I was looking for a good introduction into MPI to parallelize some software I had written. Somehow, no online resources seemed to cover the topic well, so $30 seemed like a worthwhile investment, compared to my time. I got this book and the more recent one by Quinn (PP in C with MPI and OpenMP). This one's the hands-down winner. I basically scanned it in bed for three nights, and two weeks later my code is running like a charm. Just the right mix of reference and tutorial, very little distraction, and a pleasant read throughout.
Highly recommended.
Well written, easy for someone who is not an MPI guru... yet.......2005-05-22
The book is written very well and goes through how the MPI functions work and all their parameters in pretty fine detail. He even talks about the simpler things many books overlook. The only thing I wish was in this book, and this has nothing to do with the quality of the book, is some C++ reference or talk of the C++ MPI calls. This book is written with examples in C only (I think FORTRAN one may be available online), but the theory he teaches and the design of the programs will work for any language, of course. It would be nice to have a good reference chapter that lists the FORTRAN MPI functions and the C++ ones too though.
Very insightful!.......2003-04-22
This book is a great introduction not only to MPI but to parallel programming itself. Initially, one learns essential concepts of parallel programming, including hardware and network topologies. An MPI version of ``Hello World!'' gently introduces the reader to the mechanics of running MPI programs (if you haven't set up your parallel computing environment yet, this may well be the most time consuming chapter of the book!) In what follows, the author lays out the basics of each topic in parallel programming, followed by MPI-specific details (i.e. which MPI function is used in that situation). Particularly worthy of praise is the example-driven approach, whereby in each chapter a problem is presented (like numerical integration or matrix multiplication), and the author shows how to solve them with techniques taught in that chapter. Some problems are rehashed in other sections/chapters, in order to show different PP techniques to solve them. The book doesn't suffer from the black-box syndrome of hiding implementation details: the reader is usually shown the inner workings of, say, each communication technique, while being advised to use MPI's built-in functions instead of rolling out his own versions.
Topics covered include collective communication methods, I/O, debugging, design, performance, parallel algorithms and libraries, and advanced topics in communication. A handy appendix on MPI functions wraps up the book.
As an aside, I will be forever grateful to this book due to its clear exposition of the butterfly broadcast method, which helped me understand the Cooley-Tukey iterative version of the FFT (which uses the same butterfly idea), something I had been struggling with for a couple of years. I would have gladly bought the book for this explanation alone.
Average customer rating:
- 5 for knowledge; 0 for the writing -> 2.5 -> 2
- If you want to program concurency in Java you need this book
- Great Threaded Programming Information for More than Java
- Will make you a better programmer, but not for beginners.
- "This is Phylosophy of concurrency".
|
Concurrent Programming in Java(TM): Design Principles and Pattern (2nd Edition)
Doug Lea
Manufacturer: Prentice Hall PTR
ProductGroup: Book
Binding: Paperback
General
| Java
| Programming
| Computers & Internet
| Subjects
| Books
General
| Programming
| Computers & Internet
| Subjects
| Books
General
| Languages & Tools
| Programming
| Computers & Internet
| Subjects
| Books
General
| Software
| Computers & Internet
| Subjects
| Books
Mathematics
| Professional Science
| Professional & Technical
| Subjects
| Books
| Applied
| Chaos & Systems
| Geometry & Topology
| Mathematical Analysis
| Mathematical Physics
| Number Systems
| Pure Mathematics
| Transformations
| Trigonometry
Look Inside Computer Books
| Trip
| Specialty Stores
| Books
Qualifying Textbooks - Spring 2007
| Stores
| Books
General
| Software Books
| Custom Stores
| Stores
| Software
Similar Items:
- Java Concurrency in Practice
- Effective Java Programming Language Guide
- Java Threads (Java Series (O'Reilly & Associates))
- Java Thread Programming
- Java(TM) Puzzlers: Traps, Pitfalls, and Corner Cases
ASIN: 0201310090 |
Amazon.com
Concurrent Programming in Java, 2nd Edition surveys a wide field of research in parallelism and concurrency and shows how to do more with multithreading in Java with dozens of patterns and design tips. Written for the advanced Java developer, this book offers a comprehensive tour of leading-edge thinking about parallel coding processes.
Within the dozens of techniques and tips offered here, this book accomplishes at least two goals. First, it shows how concurrency is implemented by default within Java, with material on how built-in features (like the synchronized keyword and its memory model) can be expected to perform when dealing with multiple threads. Naturally, Java threads themselves are also covered, including priorities, scheduling, and the like.
Much of this book looks at ways to improve performance of concurrent code beyond the simple default strategies. After defining criteria for measuring concurrent code (such as safety and "liveness," a measure of running live threads effectively), the book presents dozens of techniques for letting threads work together safely. For the working Java programmer, coverage of patterns that have been implemented in the downloadable java.concurrency package will be the most immediately useful. (Within this nearly encyclopedic survey, short code snippets are used for every pattern and concept.)
Though theoretical at times, this book offers plenty of ideas and sample code to get you started thinking of ways to improve multithreaded code.
Impressively comprehensive, Concurrent Programming in Java offers a veritable bible of techniques for doing two things at once with threads in Java. It's a worthwhile guide to the state-of-the-art strategies for improving the performance of your Java threads. --Richard Dragan
<B>Topics covered</B>: Threads and concurrency in Java, design considerations (safety, liveness, and performance), Before/After Patterns, layering, adapters, immutability and synchronization, deadlock, resource ordering, the Java Memory Model and concurrency, using the java.concurrency package, confinement, refactoring for concurrency, mutexes, read-write locks, recovering from failure, notifications, semaphores, latches, exchanges, transactions, one-way messages, worker threads, polling and event-driven I/O, parallelism techniques (fork/join, computation trees, and barriers), Communicating Sequential Processes (CSP).
Book Description
In this second edition, you will find thoroughly updated coverage of the Java(tm) 2 platform and new or expanded coverage of:
* Memory model * Cancellation * Portable parallel programming * Utility classes for concurrency control
The Java platform provides a broad and powerful set of APIs, tools, and technologies. One of its most powerful capabilities is the built-in support for threads. This makes concurrent programming an attractive yet challenging option for programmers using the Java programming language.
This book shows readers how to use the Java platform's threading model more precisely by helping them to understand the patterns and tradeoffs associated with concurrent programming.
You will learn how to initiate, control, and coordinate concurrent activities using the class java.lang.Thread, the keywords synchronized and volatile, and the methods wait, notify, and notifyAll. In addition, you will find detailed coverage of all aspects of concurrent programming, including such topics as confinement and synchronization, deadlocks and conflicts, state-dependent action control, asynchronous message passing and control flow, coordinated interaction, and structuring web-based and computational services.
The book targets intermediate to advanced programmers interested in mastering the complexities of concurrent programming. Taking a design pattern approach, the book offers standard design techniques for creating and implementing components that solve common concurrent programming challenges. The numerous code examples throughout help clarify the subtleties of the concurrent programming concepts discussed.
Customer Reviews:
5 for knowledge; 0 for the writing -> 2.5 -> 2.......2006-04-19
Sure he knows his stuff but doesn't have a clue on how to write. This is appallingly poorly written. It is one of the most ridiculously disorganized collections of academic 'verbage' (verbiage subsumes garbage) I have ever read. It's almost useless as a reference: its very non-linear (say non-deterministic almost) in concept elucidation (perhaps he's taken the notion of multithreading too much to heart and tried multi-threaded writing???). It's useless as a book to learn from- since learning by example is not just a way to learn, but the only way to learn (Einstein) and this book largely disavows examples.
What it needs is another edition with a ghost writer. Seriously it's not good. Try Paul Hyde for a good intro to threads.
While those at guru-ish level may love this book, those of us for whom threads represent a means to an end, not an end in and of themselves, would probably want to throw this book in frustration of the author's inability to structure a coherent sentence with a clear point. This meanders on like great uncle herb's war stories and is equally will sapping.
Avoid if you can or check it out when you reach guru-ness. It's a good cure for insomnia though.
If you want to program concurency in Java you need this book.......2006-01-16
This is a kind of book you'll need to start developing concurrent systems in Java. It shows details of what should be done to safely handle patterns for concurrent programs.
I beleive this book is a must for every developer who want to start learning concurrency design priciples for Java.
Great Threaded Programming Information for More than Java.......2006-01-09
This is the best book I have ever read on threading, and certainly applies well to other languages naturally (especially languages with a modern and mature thread library like Mono/.NET). Unlike other reviewers here, I encourage so-called "beginners" to read this book. He has plenty of examples so you will not get lost, and this *is* the right way to do things, so start with this one.
Will make you a better programmer, but not for beginners........2004-10-30
This book is great but don't read it as your first introduction to Java threads.
This book is not about Java threads per se, but more about design patterns and good object oriented programming practices as applied to concurrent programming (hence the title). Doug Lea is a university professor and this book has a very academic style, including a ton of references to an impressive array of concurrency and object oriented research. While this makes the material somewhat dense, it is very thorough and thankfully supplemented by actual code snippets (Doug Lea also makes significant contributions to the Java SDK and writes great code).
Especially notable are the sections on semaphores and locking in general. Users of util.concurrent (which directly supplements this book), and even the new Java 5.0 concurrency utilities (which were written by Lea and company), will get tremendous value out of these chapters as the locking strategies form the backbone of the higher level classes found in those packages.
For beginners, read "Java Thread Programming" by Paul Hyde, and then try this book.
"This is Phylosophy of concurrency"........2004-07-05
This is not "concurrent programming".This is only "philosophy of concurrency".I think so too.
Average customer rating:
- Great introduction
- has many Fortran 77 but not Fortran 95 examples
- Clear and concise
|
Parallel Programming in OpenMP
Rohit Chandra , Ramesh Menon , Leo Dagum , David Kohr , Dror Maydan , and Jeff McDonald
Manufacturer: Morgan Kaufmann
ProductGroup: Book
Binding: Paperback
Parallel Computing
| System Architecture
| Hardware
| Computers & Internet
| Subjects
| Books
General
| System Architecture
| Hardware
| Computers & Internet
| Subjects
| Books
General
| Programming
| Computers & Internet
| Subjects
| Books
General
| Languages & Tools
| Programming
| Computers & Internet
| Subjects
| Books
General
| Software
| Computers & Internet
| Subjects
| Books
Look Inside Computer Books
| Trip
| Specialty Stores
| Books
All Amazon Upgrade
| Amazon Upgrade
| Stores
| Books
Computers & Internet
| Amazon Upgrade
| Stores
| Books
Qualifying Textbooks - Spring 2007
| Stores
| Books
General
| Software Books
| Custom Stores
| Stores
| Software
Similar Items:
- Parallel Programming in C with MPI and OpenMP
- Parallel Programming With MPI
- Patterns for Parallel Programming (Software Patterns Series)
- Using MPI - 2nd Edition: Portable Parallel Programming with the Message Passing Interface (Scientific and Engineering Computation)
- Parallel Scientific Computing in C++ and MPI: A Seamless Approach to Parallel Algorithms and their Implementation
ASIN: 1558606718 |
Amazon.com
The OpenMP standard allows programmers to take advantage of new shared-memory multiprocessor systems from vendors like Compaq, Sun, HP, and SGI. Aimed at the working researcher or scientific C/C++ or Fortran programmer, Parallel Programming in OpenMP both explains what this standard is and how to use it to create software that takes full advantage of parallel computing.
At its heart, OpenMP is remarkably simple. By adding a handful of compiler directives (or pragmas) in Fortran or C/C++, plus a few optional library calls, programmers can "parallelize" existing software without completely rewriting it. This book starts with simple examples of how to parallelize "loops"--iterative code that in scientific software might work with very large arrays. Sample code relies primarily on Fortran (undoubtedly the language of choice for high-end numerical software) with descriptions of the equivalent calls and strategies in C/C++. Each sample is thoroughly explained, and though the style in this book is occasionally dense, it does manage to give plenty of practical advice on how to make code run in parallel efficiently. The techniques explored include how to tweak the default parallelized directives for specific situations, how to use parallel regions (beyond simple loops), and the dos and don'ts of effective synchronization (with critical sections and barriers). The book finishes up with some excellent advice for how to cooperate with the cache mechanisms of today's OpenMP-compliant systems.
Overall, Parallel Programming in OpenMP introduces the competent research programmer to a new vocabulary of idioms and techniques for parallelizing software using OpenMP. Of course, this standard will continue to be used primarily for academic or research computing, but now that OpenMP machines by major commercial vendors are available, even business users can benefit from this technology--for high-end forecasting and modeling, for instance. This book fills a useful niche by describing this powerful new development in parallel computing. --Richard Dragan
<B>Topics covered:</B> <ul>
OpenMP quick reference</ul>
Book Description
The rapid and widespread acceptance of shared-memory multiprocessor architectures has created a pressing demand for an efficient way to program these systems. At the same time, developers of technical and scientific applications in industry and in government laboratories find they need to parallelize huge volumes of code in a portable fashion. OpenMP, developed jointly by several parallel computing vendors to address these issues, is an industry-wide standard for programming shared-memory and distributed shared-memory multiprocessors. It consists of a set of compiler directives and library routines that extend FORTRAN, C, and C++ codes to express shared-memory parallelism.
Parallel Programming in OpenMP is the first book to teach both the novice and expert parallel programmers how to program using this new standard. The authors, who helped design and implement OpenMP while at SGI, bring a depth and breadth to the book as compiler writers, application developers, and performance engineers.
* Designed so that expert parallel programmers can skip the opening chapters, which introduce parallel programming to novices, and jump right into the essentials of OpenMP.
* Presents all the basic OpenMP constructs in FORTRAN, C, and C++.
* Emphasizes practical concepts to address the concerns of real application developers.
* Includes high quality example programs that illustrate concepts of parallel programming as well as all the constructs of OpenMP.
* Serves as both an effective teaching text and a compact reference.
* Includes end-of-chapter programming exercises.
Customer Reviews:
Great introduction.......2006-11-09
Chandra et al. have put together a readable, helpful introduction to parallel programming with OpenMP. Unlike its major competitor, MPI, OpenMP assumes a shared memory model, in which every processor has the same view of the same address space as every other. At least as a start, this cuts the intellectual load way down. The programmer adds just one concept to the problem, parallelism, without adding buffering, communication networks, and lots of other stuff as well.
After two introductory chapters, the authors introduce OpenMP in three stages: loop parallelism, general parallelism, and synchronization, roughly in order of increasing complexity. The authors present the necessary OpenMP pragmas and APIs at each step, showing how they address the immediate problems. An appendix summarizes the pragmas and APIs, in both their C/C++ and Fortran forms. OO C++ programmers may be dismayed by the amount of attention paid to an un-cool language like Fortran, but need to realize that it's still the lingua franca of performance programming. And, in fairness, the authors spend equal time on C++ idiosyncrasies, such as constructor invocations for variables that are silently replicated in each of the parallel threads.
If you've ever done performance programming, you're groaningly aware that getting the parallelism right is actually the easy part. The tricky parts come in breaking dependencies, in scheduling, in ensuring spatial and temporal locality, and in dealing with cache coherency issues of multiprocessors. The authors give great introductions to all of the basics. This includes a patient description of how caches actually work, since there's a new crop of beginners every day. The authors describe performance analysis tools, but only briefly. The tools differ so much between vendors and between one rev and the next, that any detailed description would be useless to most readers immediately and obsolete for all readers very soon.
This won't turn a beginner into the guru of performance computing. It will, however, establish a working competence in one popular parallelization tool, OpenMP, and in the computing technologies that affect parallel performance.
//wiredweird
has many Fortran 77 but not Fortran 95 examples.......2004-12-31
This book has many examples of how to parallelize Fortran 77 programs with loops using OpenMP directives, but coverage of how to parallelize Fortran 95 code using array operations is sparse. For this, one should read the tutorial "Parallel Programming in Fortran 95 using OpenMP", by Miguel Hermanns, available at the OpenMP web site.
Clear and concise.......2002-05-13
this is probably the first book about OMP. The author has decribed the uses of many functions and directives of OMP. The examples (in Fortran and C) given are also useful. Generally this is a good book to get you started off with OMP.
Average customer rating:
- Barring a miracle....
- An Excellent Interlinear To Own
- Use with Liddel and Scott for best results.
- Really Nice.
- Very handy in Greek Class.
|
The New Greek-English Interlinear New Testament (Personal Size)
Robert K. Brown
Manufacturer: Tyndale House Publishers
ProductGroup: Book
Binding: Hardcover
Parallel Editions
| Formats
| Bibles
| Christianity
| Religion & Spirituality
| Subjects
| Books
New Testament
| Bibles
| Christianity
| Religion & Spirituality
| Subjects
| Books
New International Reader's Version
| Translations
| Bibles
| Christianity
| Religion & Spirituality
| Subjects
| Books
General
| Reference
| Christianity
| Religion & Spirituality
| Subjects
| Books
Language Studies
| Reference
| Christianity
| Religion & Spirituality
| Subjects
| Books
General
| Bible & Other Sacred Texts
| Religion & Spirituality
| Subjects
| Books
Look Inside Religion & Spirituality Books
| Trip
| Specialty Stores
| Books
Similar Items:
- Word Study Greek-English New Testament
- Basics of Biblical Greek Workbook
- Basics of Biblical Greek Grammar
- The Greek New Testament: Bonded Leather
- Biblical Greek (Zondervan Get an A! Study Guides)
ASIN: 0842345647 |
Book Description
The New Greek-English Interlinear New Testament contains a literal word-for-word English rendering of the Greek text in interlinear form. A parallel column of the New Revised Standard Version (NRSV) accompanies the interlinear text. Numerous textual notes are also included. The New Greek-English Interlinear New Testament is the newest interlinear translation that uses the UBS4/NA27 text.
Customer Reviews:
Barring a miracle...........2007-05-18
Barring a miracle like the Dead Sea Scrolls are for Old Testament studies, this text is essentially as close as we will ever come to the original text of the New Testament. There will be scholarly tweaking and dispute over particulat words and phrases, of course.
You do not have to be able to read Greek in order to use this book for study, although that would obviously enrich your study. The other reviews here match my experience and I recommend reading them.
What particular words mean will often depend upon the dictionary and concordance you use since historically these have frequently been written by people with a particular theological agenda. You need to be an advanced student a'la Raymond Brown to puzzle out biases and errors. This book, both the interlinear and the NRSV, pretty much steer you past those problems.
To understand the general background of scholarly issues which led to this particular text you need to read Metzger's book The Text of the New Testament: Its Transmission, Corruption, and Restoration (4th Edition). To find out about specific textual issus which are still oustanding, you also need Metzger: A Textual Commentary on the Greek New Testament.
With this book and the two by Metzger you can be as confident as the current state of the art permits that you are studying the "real" New Testament.
An Excellent Interlinear To Own.......2007-05-06
Much of the time I have found interlinears to be too bulky to really enjoy. I must admit that I own several but would rather just pull out my Greek New Testament than to try to work through reading from an interlinear New Testament. However, I recently puchased this personal size interlinear from my local Christian bookstore and have truly enjoyed it. The book, as others have noted, is well crafted with a strong, sturdy cover, easy to read print, and while I have not been a big fan of the NRSV, I have found the text to be much more accurate than say the NIV.
However, I must warn my readers that you need to know NT Greek before you purchase this book. A working knowledge of the Greek text is a must to really enjoy any interlinear New Testament. A few Greek language books along with this interlinear can provide the disciple with a life long search of the New Testament that will add to your faith. Overall this is a great book to own and one of the best (if not the best) interlinears that you can purchase.
Use with Liddel and Scott for best results. .......2007-04-29
The New Testament is indoubtably an extremely important collection of books, just in terms of the influence it has had over human thought over the course of the past 2,000 years. This edition offers you a chance to look at it in its original language. Well, OK. You'll still need a basic Greek book and a lexicon if you want to actually read the Greek for yourself, but an interlinear edition such as this really makes everything a lot easier to parse and look at and helps you memorize grammatical forms by looking at them in context.
Even if you're not particularly interested in the New Testament, this is still of great use to the beginning Greek student. Koine Greek is fairly straightforward in its grammar and sentence construction; the people who wrote this were not overly interested in proving their rhetorical prowess and wanted to get their message across in the simplest way possible. This simplicity makes for a good text to look at in depth before moving on to something a bit more complex. The price for this edition is substantially lower than that of Loeb Classical Library volumes, and you get more for it.
Really Nice........2007-04-05
Well made, sturdy, lays flat.
Printing is big and clear.
I wish it wasn't NRSV, but it's not that big of a deal.
I really wish that it had some sort of basic concordance of Greek words, but, again, for $16 it's already a great deal.
I wish that the makers of this volume would make a Hebrew Old Testament as well. (With the Greek deuterocanonicals, Catholic here!!)
Very handy in Greek Class........2007-03-15
If your university has the same book store supplier as mine, then you will have that little maroonish reddish Greek New Testament for class. The best part about this book, is it is the same size as that New Testament, and when you take the cover off, it is a pretty close match. So when everyone else is sitting in Greek class not going on because they can't read the language and their Bibles don't have English in them, you will be one step up.
Best 16 dollars I ever spent.
Average customer rating:
- wonderful storytelling and a fun study aide
- Excellent book to build kanji and vocab recognition
- Excellent japanese reader
- simply brilliant
- I absolutely adore this book
|
Breaking into Japanese Literature: Seven Modern Classics in Parallel Text
Giles Murray
Manufacturer: Kodansha International
ProductGroup: Book
Binding: Paperback
General
| Literature & Fiction
| Subjects
| Books
| Classics
| Comic
| Contemporary
| Literary
Anthologies
| Short Stories
| Literature & Fiction
| Subjects
| Books
Japanese
| Instruction
| Foreign Languages
| Reference
| Subjects
| Books
Reading Skills
| Words & Language
| Reference
| Subjects
| Books
General
| Reference
| Subjects
| Books
Look Inside Fiction Books
| Trip
| Specialty Stores
| Books
Look Inside Nonfiction Books
| Trip
| Specialty Stores
| Books
Look Inside Reference Books
| Trip
| Specialty Stores
| Books
Poetry & Short Stories
| Large Print
| Formats
| Books
Similar Items:
- Read Real Japanese: All You Need to Enjoy Eight Contemporary Writers
- Basic Connections: Making Your Japanese Flow (Power Japanese Series) (Kodansha's Children's Classics)
- Making Sense of Japanese: What the Textbooks Don't Tell You (Power Japanese Series) (Kodansha's Children's Classics)
- All About Particles: A Handbook of Japanese Function Words (Power Japanese Series) (Kodansha's Children's Classics)
- Kodansha's Furigana Japanese Dictionary: Japanese-English English-Japanese
ASIN: 4770028997 |
Book Description
Reading great books in the original should be the culmination of language study, but reading Japanese literature unassisted is a daunting task that can defeat even the most able of students. Breaking into Japanese Literature is specially designed to help you bypass all the frustration and actually enjoy classics of Japanese literature.
Breaking into Japanese Literature features seven graded stories covering a variety of genres: whether it's the spellbinding surrealism of Natsume Soseki's Ten Nights of Dreams, the humor of Akutagawa Ryunosuke's fable of temple life ("The Nose"), or the excitement of his historic thrillers ("In a Grove" and "Rashomon"), you are sure to find a story that appeals to you in this collection.
The unique layout -- with the original Japanese story in large print, an easy-to-follow English translation and a custom dictionary -- was created for maximum clarity and ease of use. There's no need to spend time consulting reference books when everything you need to know is right there in front of your nose.
To make Japanese literature fun, Breaking into Japanese Literature also has some unique extra features: mini-biographies to tell you about the authors' lives and works, individual story prefaces to alert you to related works of literature or film, and original illustrations to fire your imagination. Best of all, MP3 sound files of all the stories have been made available for FREE on the Internet.
Breaking into Japanese Literature provides all the backup you need to break through to a new and undiscovered world -- the world of great Japanese fiction. All the hard work has been taken care of so you can enjoy the pleasures of the mind. Why not take advantage?
Learn <BR>* 50% of all common-use kanji covered <BR>* Kanji entry numbers given for follow-up study <BR>* Japanese + English translation + custom dictionary on the same page <BR>* Every single kanji word explained
Listen <BR>* Free download of sound files from the Net
Look <BR>* 7 original atmospheric illustrations
Link <BR>* Original stories for Kurosawa's Rashomon and Dreams
All the stories in this book are available on the Internet as MP3 sound files read by professional Japanese actors.
For students who want to consolidate their understanding of kanji, the entry numbers for any of the 2,230 characters in The Kodansha Kanji Learner's Dictionary have been provided when those characters feature in Breaking into Japanese Literature. This makes cross-referencing a matter of seconds.
Customer Reviews:
wonderful storytelling and a fun study aide.......2007-02-24
Ive studied Nihongo for 2 months and only know 175 kanji but bought this anyway to motivate myself. As expected, it's beyond my reading level, but I was able to recognize some kanji and get a feel for how "real" Japanese differs from the exercises in my Genki text. I'll read the easiest story again in 6 months and again in 1 year to check my progress.
The MP3 file for Soseki's "First Night" is a treat for the ears and while I only understand the 1st sentence ("I had a dream") I have a better grasp of proper Japanese pronunciation and pace --- unlike Pimsleur CDS which are artificially slow by necessity. In short, even if you're a rank beginner like me, I highly recommend buying this.
Excellent book to build kanji and vocab recognition.......2006-12-27
I have only had a year and a half of Japanese, so I got this book to put myself to the test. It is excellent - every word is defined at the bottom of the pages so that a dictionary is not necessary, saving valuable time. The English on the right hand side reinforces an understanding of how Japanese sentence structures work. What's great is even if a word is defined on page 1, if it appears on the next page it is redefined at the bottom in case you forget it.
It took me a while to be able to fluently read and understand the first three sentences but after that I could read new sentences much faster. I think this book may still be a bit above me as there are some basic words I have not learned yet, but thanks to the English on the right side I can figure it out with relative ease.
The stories themselves are relatively interesting, and offer a variety of difficulty levels - the first third of the book is best suited for beginners, the second section is more intermediate, and the last section is more advanced.
Aside from the Genki textbooks, this is my favorite Japanese book I own.
Excellent japanese reader.......2006-03-13
The vocabulary list and the english translation make these japanese stories easy to read and also makes it possible to verify your understanding of the japanese texts. The soundfiles that can be downloaded from the internet make this a great listening exercise.
simply brilliant.......2005-10-17
I love this book. Where else can you expand your vocabulary, learn and retain new kanji, and develop your reading skills, all while reading a truly kick-ass story? And believe me, the stories are great. You've got "Dreams", a sometimes macabre, sometimes funny exercise in surrealism. There's "In a Grove", a page-turner of a murder mystery. My favorite is "Rashomon", which surprised me with its black humor.
I also love the fact that the book is so compact. You can read it on the train (as I do) without announcing to the world that that you're another gaijin trying to learn Japanese. This is a tool whose value far outweighs its price.
I absolutely adore this book.......2005-08-06
This book went beyond my expectations. First of all, let me say that you will never get frustrated while reading this. All the information you need is right there, including definitions of the words, furigana, and the english translation. It is also nice that they place the english on the right side of the book while the japanese is on the left, which makes it easier not to cheat while reading but still keeps the english conveniently close. The words' definitions are on the bottom of the page, which makes them easy to find so you don't have to go looking up words in a dictionary or in the back.
Another extremely useful aspect is the kanji listing number. This is in conjunction with The Kodansha Kanji Learner's Dictionary. Beside the kanji listed underneath the text is a number in brackets which indicates the number in the Kanji Learner's Dictionary so you can easily look up the kanji. It is really quite convenient.
The overall stories are also fascinating and not at all childish as one might imagine. They are twisted and mysterious, and hold your interest easily. Yet they are short enough to reduce any feelings of boredom or fatigue you might feel from the effort of reading the text. As mentioned, the stories begin short and easy and progress into longer, more complicated text. Beautiful, laudable choices for study.
Finally, the ability to download the mp3s of the spoken text draws a blissful sigh of contentment from me. Not only can you practice reading it, but listening as well. So your pronunciation does not suffer and you can improve your speaking skills.
There is nothing they could add to this book to make it any better than it already is. Buy this book and prepare to feel satisfied beyond what you expected.
Programming Book:
- Pascal
- Perl
- PostScript
- PowerBuilder
- Prograph
- Prolog
- Python
- Rexx
- RPG
- Ruby
Programming Book
Programming Book
