Three parallel algorithms for classical molecular dynamics are presented. The first assigns each processor a fixed subset of atoms; the second assigns each a fixed subset of inter-atomic forces to compute; the third assigns each a fixed spatial region. The algorithms are suitable for molecular dynamics models which can be difficult to parallelize efficiently—those with short-range forces where the neighbors of each atom change rapidly. They can be implemented on any distributed-memory parallel machine which allows for message-passing of data between independently executing processors. The algorithms are tested on a standard Lennard-Jones benchmark problem for system sizes ranging from 500 to 100,000,000 atoms on several parallel supercomputers--the nCUBE 2, Intel iPSC/860 and Paragon, and Cray T3D. Comparing the results to the fastest reported vectorized Cray Y-MP and C90 algorithm shows that the current generation of parallel machines is competitive with conventional vector supercomputers even for small problems. For large problems, the spatial algorithm achieves parallel efficiencies of 90% and a 1840-node Intel Paragon performs up to 165 faster than a single Cray C9O processor. Trade-offs between the three algorithms and guidelines for adapting them to more complex molecular dynamics simulations are also discussed.

Fast parallel algorithms for short-range molecular dynamics

物件導向軟體之架構(Object-Oriented Software Construction)探討

Dynamic binary instrumentation (DBI) frameworks make it easy to build dynamic binary analysis (DBA) tools such as checkers and profilers. Much of the focus on DBI frameworks has been on performance; little attention has been paid to their capabilities. As a result, we believe the potential of DBI has not been fully exploited.In this paper we describe Valgrind, a DBI framework designed for building heavyweight DBA tools. We focus on its unique support for shadow values-a powerful but previously little-studied and difficult-to-implement DBA technique, which requires a tool to shadow every register and memory value with another value that describes it. This support accounts for several crucial design features that distinguish Valgrind from other DBI frameworks. Because of these features, lightweight tools built with Valgrind run comparatively slowly, but Valgrind can be used to build more interesting, heavyweight tools that are difficult or impossible to build with other DBI frameworks such as Pin and DynamoRIO.

/pdf/valgrind-a-framework-for-heavyweight-dynamic-binary-83md0bpji5.pdf

Valgrind: a framework for heavyweight dynamic binary instrumentation

This ebook is the first authorized digital version of Kernighan and Ritchie's 1988 classic, The C Programming Language (2nd Ed.). One of the best-selling programming books published in the last fifty years, "K&R" has been called everything from the "bible" to "a landmark in computer science" and it has influenced generations of programmers. Available now for all leading ebook platforms, this concise and beautifully written text is a "must-have" reference for every serious programmers digital library.

As modestly described by the authors in the Preface to the First Edition, this "is not an introductory programming manual; it assumes some familiarity with basic programming concepts like variables, assignment statements, loops, and functions. Nonetheless, a novice programmer should be able to read along and pick up the language, although access to a more knowledgeable colleague will help."

The C programming language

Program analysis utilizes static techniques for computing reliable information about the dynamic behavior of programs. Applications include compilers (for code improvement), software validation (for detecting errors) and transformations between data representation (for solving problems such as Y2K). This book is unique in providing an overview of the four major approaches to program analysis: data flow analysis, constraint-based analysis, abstract interpretation, and type and effect systems. The presentation illustrates the extensive similarities between the approaches, helping readers to choose the best one to utilize.

Principles of program analysis

Clear description of algorithms and clean design of compiler components. Crafting a Compiler presents a practical approach to compiler construction with thorough coverage of the material and examples that clearly illustrate the concepts in the book. Unlike other texts on the market, Fischer/Cytron/LeBlanc uses object-oriented design patterns and incorporates an algorithmic exposition with modern software practices. An ideal reference and tutorial. MARKET: Software engineers, systems analysts, software architects

Crafting a Compiler

Illegal pointer and array accesses are a major cause of failure for C programs. We present a technique called ‘guarding’ to catch illegal array and pointer accesses. Our implementation of guarding for C programs works as a source-to-source translator. Auxiliary objects called guards are added to a user program to monitor pointer and array accesses at run time. Guards maintain attributes to catch out of bounds array accesses and accesses to deallocated memory. Our system has found a number of previously unreported errors in widely-used Unix utilities and SPEC92 benchmarks. Many commonly used programs have bugs which may not always manifest themselves as a program crash, but may instead produce a subtly wrong answer. These programs are not routinely checked for run-time errors because the increase in execution time due to run-time checking can be very high. We present two techniques to handle the high cost of run-time checking of pointer and array accesses in C programs: ‘customization’ and ‘shadow processing’. Customization works by decoupling run-time checking from original computation. A user program is customized for guarding by throwing away computation not relevant for guarding. We have explored using program slicing for customization. Customization can cut the overhead of guarding by up to half. Shadow processing uses idle processors in multiprocessor workstations to perform run-time checking in the background. A user program is instrumented to obtain a ‘main process’ and a ‘shadow process’. The main process performs computations from the orignal program, occasionally communicating a few key values to the shadow process. The shadow process follows the main process, checking pointer and array accesses. The overhead to the main process which the user sees is very low – almost always less than 10%. © 1997 by John Wiley & Sons, Ltd.

Low-cost, concurrent checking of pointer and array accesses in C programs

We describe Dead Value Information (DVI) and introduce three new optimizations which exploit it. DVI provides assertions that certain register values are dead, meaning they will not be read before being overwritten. The processor can use DVI to track dead registers and dynamically eliminate unnecessary save and restore instructions from the execution stream at procedure calls and context switches. Our results indicate that dynamic saves and restore instances can be reduced by 46% for procedure calls and by 51% for context switches. In addition, save/restore elimination for procedure calls can improve overall performance by up to 5%. DVI also allows the processor manage physical registers to efficiently, reducing the size requirements of the physical register file. When the system clock rate is proportional to the register file cycle time, this optimization can improve performance. All of these optimizations can be supported with only a few new instructions and minimal additional hardware structures.

/pdf/exploiting-dead-value-information-2cll7dn1vd.pdf

Exploiting dead value information

(Each chapter contains "Exercises".) Introduction. Overview and History. What Do Compilers Do? The Structure of a Compiler. The Syntax and Semantics of Programming Languages. Compiler Design and Programming Language Design. Compiler Classifications. Influences On Computer Design. Exercises. A Simple Compiler. The Structure of a Micro Compiler. A Micro Scanner. The Syntax of Micro. Recursive Descent Parsing. Translating Micro. Exercises. Scanning--Theory and Practice. Overview. Regular Expressions. Finite Automata and Scanners. Using a Scanner Generator. Practical Considerations. Translating Regular Expressions Into Finite Automata. Exercises. Grammars and Parsing. Context-Free Grammars: Concepts and Notation. Errors in Context-Free Grammars. Transforming Extended Bnf Grammars. Parsers and Recognizers. Grammar Analysis Algorithms. Exercises. Ll(1) Grammars and Parsers. The Ll(1) Predict Function. The Ll(1) Parse Table. Building Recursive Descent Parsers From Ll(1) Tables. An Ll(1) Parser Driver. Ll(1) Action Symbols. Making Grammars Ll(1) / The If-Then-Else Problem in Ll(1) Parsing. The Llgen Parser Generator. Properties of Ll(1) Parsers. Ll(K) Parsing. Exercises. Lr Parsing. Shift-Reduce Parsers. Lr Parsers. Lr(1) Parsing. Slr(1) Parsing. Lalr(1). Calling Semantic Routines in Shift-Reduce Parsers. Using a Parser Generator. Optimizing Parse Tables. Practical Lr(1) Parsers. Properties of Lr Parsers. Ll(1) Or Lalr(1), That Is The Question. Other Shift-Reduce Techniques. Exercises. Semantic Processing. Syntax-Directed Translation. Semantic Processing Techniques. Intermediate Representations and Code Generation. Exercises. Symbol Tables. A Symbol Table Interface. Basic Implementation Techniques. Block-Structured Symbol Tables. Extensions to Block-Structured Symbol Tables. Implicit Declarations. Overloading. Forward References. Summary. Exercises. Run-Time Storage Organization. Static Allocation. Stack Allocation. Heap Allocation. Program Layout in Memory. Static and Dynamic Chains. Formal Procedures. Exercises. Processing Declarations. Declaration Processing Fundamentals. Action Routines for Simple Declarations. Action Routines for Advanced Features. Exercises. Processing Expressions and Data Structure References. Introduction. Action Routines for Simple Names, Expressions, and Data Structures. Action Routines for Advanced Features. Exercises. Translating Control Structures. If Statements. Loops. Compiling Exits. The Case Statement. Compiling Goto Statements. Exception Handling. Short-Circuit Boolean Expressions. Exercises. Translating Procedures and Functions. Simple Subprograms. Passing Parameters to Subprograms. Processing Subprogram Calls and Parameter Lists. Subprogram Invocation. Label Parameters. Name Parameters. Exercises. Attribute Grammars and Multipass Translation. Attribute Grammars. Tree-Structured Intermediate Representations. Exercises. Code Generation and Local Code Optimization. An Overview. Register and Temporary Management. A Simple Code Generator. Interpretive Code Generation. Peephole Optimization. Generating Code From Trees. Generating Code From Dags. Code Generator Generators. Exercises. Global Optimization. An Overview: Goals and Limits. Optimizing Subprogram Calls. Loop Optimization. Global Data Flow Analysis. Putting it All Together. Exercises. Parsing in The Real World. Compacting Tables. Syntactic Error Recovery and Repair. Exercises. Appendices. A. Definition of Ada/Cs. B. Scangen. C. Llgen User Manual. D. Lalrgen User Manual. E. Error-Repair Features of Llgen and Lalrgen. F. Compiler Development Utilities. Bibliography. Index. 0805321667T04062001

Crafting a Compiler with C

A classlficaUon of automated retargetable code generation techniques and a survey of the work on these techmques is presented Retargetable code generation research.is classified into three categories: interpretive code generation, pattern-matched code generation, and table-driven code generatlon. Interpretive code generation approaches generate code for a virtual machine and then expand into real target code Pattern-matched code generation approaches separate the machine description from the code generation algorithm. Tabledriven code generation approaches employ a formal machine description and use a code-' generator generator to produce code generators automatically. An analysis Qf these techniques and a critique of automatic code generation algorithms are presented,

Charles N. Fischer

Papers

Crafting a Compiler

Low-cost, concurrent checking of pointer and array accesses in C programs

Exploiting dead value information

Crafting a Compiler with C

Retargetable Compiler Code Generation