High Performance Computing

High Performance Computing

by Kevin Dowd


$19.72 $25.95 Save 24% Current price is $19.72, Original price is $25.95. You Save 24%.

Product Details

ISBN-13: 9781565920323
Publisher: O'Reilly Media, Incorporated
Publication date: 06/28/1993
Series: RISC Architectures, Optimization & Benchmarks Series
Pages: 398
Product dimensions: 6.00(w) x 9.00(h) x 0.88(d)

About the Author

Charles Severance is the associate director for advanced technology at the University of Michigan Media Union, where he also teaches computer science courses including Introduction to C++. His current research is in the area of Internet delivery of educational material. He has been active in IEEE standards for many years, and he edits a monthly column in the magazine IEEE Computer on computer standards. Charles is the co-host of the television show North Coast Digital and was previously the co-host of the television show Nothin but Net.

Kevin Dowd is a consultant to the aerospace and commercial industries, specializing in performance computing and information infrastructures. He is a veteran of two computer companies (which no longer make computers), and the nuclear power plant business (not many more of those have been made either). Kevin is a principal in the Atlantic Computing Technology Corporation, located in Wethersfield, Connecticut.

Table of Contents

Part 1. Modern Computer Architectures

Chapter 1. What Is High Performance Computing?
Why Worry About Performance?
Scope of High Performance Computing
Studying High Performance Computing
Measuring Performance
The Next Step

Chapter 2. High Performance Microprocessors
Fundamentals of RISC
Second-Generation RISC Processors
RISC Means Fast
Out-of-Order Execution: The Post-RISC Architecture
Future Trends: Intel IA-64 and EPIC
Closing Notes

Chapter 3. Memory
Memory Technology
Cache Organization
Virtual Memory
Improving Memory Performance
Closing Notes

Chapter 4. Floating-Point Numbers
Effects of Floating-Point Representation
Improving Accuracy Using Guard Digits
History of IEEE Floating-Point Format
IEEE Floating-Point Standard
IEEE Storage Format
IEEE Operations
Special Values
Exceptions and Traps
Compiler Issues
Closing Notes

Part 2. Programming and Tuning Software

Chapter 5. What a Compiler Does
History of Compilers
Which Language to Optimize?
Optimizing Compiler Tour
Optimization Levels
Classical Optimizations
Closing Notes

Chapter 6. Timing and Profiling
Subroutine Profiling
Basic Block Profilers
Virtual Memory
Closing Notes

Chapter 7. Eliminating Clutter
Subroutine Calls
Branches Within Loops
Other Clutter
Closing Notes

Chapter 8. Loop Optimizations
Operation Counting
Basic Loop Unrolling
Qualifying Candidates for Loop Unrolling
Nested Loops
Loop Interchange
Memory Access Patterns
When Interchange Won't Work
Blocking to Ease Memory Access Patterns
Programs That Require More Memory Than You Have
Closing Notes

Part 3. Shared-Memory Parallel Processors

Chapter 9. Understanding Parallelism
Loop-Carried Dependencies
Ambiguous References
Closing Notes

Chapter 10. Shared-Memory Multiprocessors
Symmetric Multiprocessing Hardware
Multiprocessor Software Concepts
Techniques for Multithreaded Programs
A Real Example
Closing Notes

Chapter 11. Programming Shared-Memory Multiprocessors
Automatic Parallelization
Assisting the Compiler
Closing Notes

Part 4. Scalable Parallel Processing

Chapter 12. Large-Scale Parallel Computing
Amdahl's Law
Interconnect Technology
A Taxonomy of Parallel Architectures
A Survey of Parallel Architectures
The Top 500 Report
Shared Uniform Memory MIMD
Shared Non-Uniform Memory MIMD Systems
Distributed-Memory MIMD Architecture
Single Instruction, Multiple Data
Closing Notes

Chapter 13. Language Support for Performance
Data-Parallel Problem: Heat Flow
Explicitly Parallel Languages
Problem Decomposition
High Performance FORTRAN (HPF)
Closing Notes

Chapter 14. Message-Passing Environments
Parallel Virtual Machine (PVM)
Message-Passing Interface (MPI)
Closing Notes

Part 5. Benchmarking

Chapter 15. Using Published Benchmarks
User Benchmarks
Industry Benchmarks
Closing Notes

Chapter 16. Running Your Own Benchmarks
Choosing What to Benchmark
Types of Benchmarks
Preparing the Code
Closing Notes

Part 6. Appendixes
Appendix A. Processor Architectures
Appendix B. Looking at Assembly Language
Appendix C. Future Trends: Intel IA-64
Appendix D. How FORTRAN Manages Threads at Runtime
Appendix E. Memory Performance


Customer Reviews

Most Helpful Customer Reviews

See All Customer Reviews