DOCSLIB.ORG

Cetus: a Source-To-Source Compiler Infrastructure

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Cetus: a Source-To-Source Compiler Infrastructure !"#$%&'('%)$*!"+#)+%)$*!"'!),-./"*' .01*(%#*$!#$*"'1)*',$/#.!)*"%' ! ! ! "#$%#!"&'()%!*+,!"#-.&+)!/#.0&%%&1+%2! 3,$4*)&1+*5!1.!-#.%1+*5!$%#!16!)(&%!0*)#.&*5!&%!-#.0&))#,!7&)(1$)!6##8!-.19&,#,!%$4(! $%#2!:;!&%!+1)!0*,#!61.!-.16&)<!=;!&+45$,#%!)(&%!+1)&4#!*+,!*!6$55!4&)*)&1+!)1!)(#!1.&'&+*5! 71.>!1+!)(#!6&.%)!-*'#!16!)(#!41-?<!*+,!@;!,1#%!+1)!&0-5?!A333!#+,1.%#0#+)!16!*+?! )(&.,B-*.)?!-.1,$4)%!1.!%#.9&4#%C!D$)(1.%!*+,!)(#&.!410-*+&#%!*.#!-#.0&))#,!)1!-1%)! )(#&.!A333B41-?.&'()#,!0*)#.&*5!1+!)(#&.!17+!E#F!%#.9#.%!7&)(1$)!-#.0&%%&1+8! -.19&,#,!)(*)!)(#!A333!41-?.&'()!+1)&4#!*+,!*!6$55!4&)*)&1+!)1!)(#!1.&'&+*5!71.>! *--#*.!1+!)(#!6&.%)!%4.##+!16!)(#!-1%)#,!41-?C! ! /#.0&%%&1+!)1!.#-.&+)G.#-$F5&%(!)(&%!0*)#.&*5!61.!4100#.4&*58!*,9#.)&%&+'8!1.! -.101)&1+*5!-$.-1%#%!1.!61.!4.#*)&+'!+#7!4155#4)&9#!71.>%!61.!.#%*5#!1.! .#,&%).&F$)&1+!0$%)!F#!1F)*&+#,!6.10!A333!F?!7.&)&+'!)1!)(#!A333!A+)#55#4)$*5! /.1-#.)?!"&'()%!H66&4#8!IIJ!K1#%!L*+#8!/&%4*)*7*?8!MN!OPPJIBI:I:!1.!-$F%B -#.0&%%&1+%Q&###C1.'C!R1-?.&'()!S!=OOT!A333C!D55!.&'()%!.#%#.9#,C! ! DF%).*4)&+'!*+,!L&F.*.?!U%#2! DF%).*4)&+'!&%!-#.0&))#,!7&)(!4.#,&)!)1!)(#!%1$.4#C!L&F.*.&#%!*.#!-#.0&))#,!)1! -(1)141-?!61.!-.&9*)#!$%#!16!-*).1+%8!-.19&,#,!)(#!-#.B41-?!6##!&+,&4*)#,!&+!)(#! 41,#!*)!)(#!F1))10!16!)(#!6&.%)!-*'#!&%!-*&,!)(.1$'(!)(#!R1-?.&'()!R5#*.*+4#!R#+)#.8! ===!"1%#711,!V.&9#8!V*+9#.%8!WD!O:T=@C! ! ! R&)*)&1+2! R(&.*'!V*9#8!K*+%*+'!X*#8!Y#$+'BN*&!W&+8!Y#?1+'!L##8!"$,156!3&'#+0*++8!Y*0$#5! W&,>&668!ZR#)$%2!D!Y1$.4#B)1BY1$.4#!R10-&5#.!A+6.*%).$4)$.#!61.!W$5)&41.#%8Z! !"#$%&'(8!915C!I=8!+1C!:=8!--C!@[BI=8!V#4C!=OOT8!,1&2:OC::OTGWRC=OOTC@PJ! ! ! \1.!01.#!&+61.0*)&1+8!-5#*%#!9&%&)2! ())-2GG4#)$%C#4+C-$.,$#C#,$! ! ! R1+)*4)!$%!*)2! 4#)$%Q#4+C-$.,$#C#,$! ! ](#!R#)$%!]#*0! COVER FEATURE CETUS: A SOURCE- TO-SOURCE COMPILER INFRASTRUCTURE FOR MULTICORES Chirag Dave, Hansang Bae, Seung-Jai Min, Seyong Lee, Rudolf Eigenmann, and Samuel Midkiff, Purdue University The Cetus tool provides an infrastruc- This state-of-the-art snapshot of automatic paral- ture for research on multicore compiler lelization for multicores uses the Cetus tool. Cetus is an optimizations that emphasizes automatic infrastructure for research on multicore compiler optimi- parallelization. The compiler infrastruc- zations, with an emphasis on automatic parallelization. ture, which targets C programs, supports We have created a compiler infrastructure that supports source-to-source transformations, is user-oriented and source-to-source transformations, is user- easy to handle, and provides the most important par- oriented and easy to handle, and provides allelization passes as well as the underlying enabling the most important parallelization passes as techniques. The infrastructure project follows Polaris,1,2 well as the underlying enabling techniques. which was arguably the most advanced research infra- structure for optimizing compilers on parallel machines. While Polaris translated Fortran, Cetus targets C programs. ith the advent of multicore architec- Cetus arose initially from the work of several enthusiastic tures, automatic parallelization has, graduate students, who continued what they began in a for several reasons, re-emerged as an class project. Recently, we have obtained funding from the important tool technology. While classi- US National Science Foundation to evolve the project into cal parallel machines served a relatively a community resource. Wsmall user community, multicores aim to capture a mass In our work, we have measured both Cetus and Cetus- market, which demands user-oriented, high-productivity parallelized program characteristics. These results show programming tools. Further, multicores are replacing a high-quality parallelization infrastructure equally pow- complex superscalar processors, the parallelism of which erful but easier to use than other choices. Cetus can be was unquestionably exploited by the compiler and under- compared to Intel’s ICC compiler and the COINS research lying architecture. compiler. Initially we had also considered infrastructures This same model is desirable for the new generation such as SUIF (suif.stanford.edu), Open64 (www.open64. of CPUs: Automatic parallelization had its successes on net), Rose (rosecompiler.org), the Gnu C compiler, Pluto shared-address-space architectures exhibiting small num- (pluto-compiler.sourceforge.net), and the Portland Group bers of processors, which is the very structure of today’s (PGI) C Compiler. However, parallelization results for these multicores. tools were either unavailable or lacked explanation. 36 COMPUTER Published by the IEEE Computer Society 0018-9162/09/$26.00 © 2009 IEEE class Instrumenter { ... Developing a dependable public void instrumentLoops(Program p) community support system and { reaching out to Cetus users is one DepthFirstIterator iter = new DepthFirstIterator(p); of our goals. Cetus maintains a int loop_number = 0; while ( iter.hasNext() ) { community portal at cetus.ecn. Object obj = iter.next(); purdue.edu, where the compiler if ( obj instanceof ForLoop ) can be downloaded under an ar- insertTimingCalls((ForLoop)obj, loop_number++); } tistic license. The portal offers a } utility for submitting bug reports and feature requests, and a Cetus private void insertTimingCalls(ForLoop loop, int number) users’ mailing list to discuss ideas, { FunctionCall tic, toc; new functionality, research topics, tic = new FunctionCall(new Identifier(“cetus_tic”)); and user concerns. The Cetus toc = new FunctionCall(new Identifier(“cetus_toc”)); portal further provides documen- tic.addArgument(new IntegerLiteral(number)); tation for installing and running toc.addArgument(new IntegerLiteral(number)); CompoundStatement parent = (CompoundStatement)loop.getParent(); the compiler and for writing new parent.addStatementBefore(loop, new ExpressionStatement(tic)); analysis and transformation parent.addStatementAfter(loop, new ExpressionStatement(toc)); passes using the internal program representation (IR) interface. } ... Several US and worldwide } research groups already use Cetus.3-5 In our ongoing work, Figure 1. Implementation example for basic loop instrumentation. The instrumenter we apply the infrastructure for inserts timing calls around each for loop in the given input program. creating translators that convert shared-memory programs written in OpenMP to other models, such as message-passing6 and t Symbol table. Cetus’s symbol table functionality pro- CUDA (for graphics processing units).7 vides information about identifiers and data types. Its implementation makes direct use of the information CETUS ORGANIZATION AND INTERNAL stored in declaration statements in the IR. There is no REPRESENTATION separate and redundant symbol table storage. Cetus’s IR is implemented in the form of a Java class hier- t Annotations. Comments, pragmas, directives, and archy. A high-level representation provides a syntactic view other types of auxiliary information about IR ob- of the source program to the pass writer, making it easy jects can be stored in annotation objects, which to understand, access, and transform the input program. take the form of declarations. An annotation can For example, the Program class type represents the entire be associated with a statement (such as informa- program that may consist of multiple source files. Each tion about an OpenMP directive belonging to a for source file is represented as a Translation Unit. Other base statement) or could stand independently (such as IR object types are Statement, Declaration, and Expres- a comment line). sion. Specific source constructs in the IR are represented t Printing. The printing functions have been extended by classes derived from these base classes. For example, to allow for flexible rendering of the IR classes. ExpressionStatement represents a Statement that contains an Expression, and an AssignmentExpression represents an CETUS ANALYSES AND TRANSFORMATIONS Expression that assigns the value of the right-hand side to Automatically instrumenting source programs is a com- the left-hand side. There is complete data abstraction, and monly used compiler capability. Figure 1 shows a basic pass writers only manipulate the IR through access func- loop instrumenter that inserts timing calls around each tions. Important features of the IR include the following: for loop in the given input program. Here we assume that the function call cetus_tic(id) stores the current time t Traversable objects. All Cetus IR objects are derived (get time of day, for example) with the given integer tag, from a base class “Traversable.” This class provides the and cetus_toc(id) computes and stores the time differ- functionality to iterate over lists of objects generically. ence since the last call of cetus_tic(id). t Iterators. BreadthFirst, DepthFirst, and Flat iterators At the end of an application run, basic runtime statis- are built into the functionality to provide easy tra- tics on the instrumented code sections can be generated versal and search over the program IR. from this information. The Cetus code in Figure 1 assigns a DECEMBER 2009 37 COVER FEATURE int foo(void) constructs such as “adding argu- { ments” to a FunctionCall or “adding int i; double t, s, a[100]; an additional Statement” to an exist- for ( i = 0; i < 50; ++i ) ing CompoundStatement in the IR. { t = a[i]; Analysis passes a[i+50] = t + (a[i] + a[i+50])/2.0; s = s + 2*a[i]; Advanced program analysis capa- } bilities are essential to Cetus; they will return 0; grow both through our own efforts } (a) and the Cetus user community’s. Here we describe some basic analyses. int foo() Symbolic manipulation. Like its { predecessor, Polaris,1,2 Cetus provides int i; double t, s, a[100]; a key feature in its ability to analyze cetus_tic(0); the represented program in symbolic for (i = 0; i < 50; ++i) terms. The ability to manipulate sym- { bolic expressions is essential when t = a[i]; a[(i+50)] = (t + ((a[i] + a [(i+50)])/2.0)); designing analysis and transforma- s = (s + (2*a[i])); tion algorithms that deal with real } programs. For example, a data depen- cetus_toc(0); dence test can easily extract the return 0; } necessary information if array sub- (b) scripts are normalized with respect to the relevant loop indices.
Load more

Recommended publications
  • About ILE C/C++ Compiler Reference
    IBM i 7.3 Programming IBM Rational Development Studio for i ILE C/C++ Compiler Reference IBM SC09-4816-07 Note Before using this information and the product it supports, read the information in “Notices” on page 121. This edition applies to IBM® Rational® Development Studio for i (product number 5770-WDS) and to all subsequent releases and modifications until otherwise indicated in new editions. This version does not run on all reduced instruction set computer (RISC) models nor does it run on CISC models. This document may contain references to Licensed Internal Code. Licensed Internal Code is Machine Code and is licensed to you under the terms of the IBM License Agreement for Machine Code. © Copyright International Business Machines Corporation 1993, 2015. US Government Users Restricted Rights – Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp. Contents ILE C/C++ Compiler Reference............................................................................... 1 What is new for IBM i 7.3.............................................................................................................................3 PDF file for ILE C/C++ Compiler Reference.................................................................................................5 About ILE C/C++ Compiler Reference......................................................................................................... 7 Prerequisite and Related Information..................................................................................................
    [Show full text]
  • Compiler Error Messages Considered Unhelpful: the Landscape of Text-Based Programming Error Message Research
    Working Group Report ITiCSE-WGR ’19, July 15–17, 2019, Aberdeen, Scotland Uk Compiler Error Messages Considered Unhelpful: The Landscape of Text-Based Programming Error Message Research Brett A. Becker∗ Paul Denny∗ Raymond Pettit∗ University College Dublin University of Auckland University of Virginia Dublin, Ireland Auckland, New Zealand Charlottesville, Virginia, USA [email protected] [email protected] [email protected] Durell Bouchard Dennis J. Bouvier Brian Harrington Roanoke College Southern Illinois University Edwardsville University of Toronto Scarborough Roanoke, Virgina, USA Edwardsville, Illinois, USA Scarborough, Ontario, Canada [email protected] [email protected] [email protected] Amir Kamil Amey Karkare Chris McDonald University of Michigan Indian Institute of Technology Kanpur University of Western Australia Ann Arbor, Michigan, USA Kanpur, India Perth, Australia [email protected] [email protected] [email protected] Peter-Michael Osera Janice L. Pearce James Prather Grinnell College Berea College Abilene Christian University Grinnell, Iowa, USA Berea, Kentucky, USA Abilene, Texas, USA [email protected] [email protected] [email protected] ABSTRACT of evidence supporting each one (historical, anecdotal, and empiri- Diagnostic messages generated by compilers and interpreters such cal). This work can serve as a starting point for those who wish to as syntax error messages have been researched for over half of a conduct research on compiler error messages, runtime errors, and century. Unfortunately, these messages which include error, warn- warnings. We also make the bibtex file of our 300+ reference corpus ing, and run-time messages, present substantial difficulty and could publicly available.
    [Show full text]
  • ROSE Tutorial: a Tool for Building Source-To-Source Translators Draft Tutorial (Version 0.9.11.115)
    ROSE Tutorial: A Tool for Building Source-to-Source Translators Draft Tutorial (version 0.9.11.115) Daniel Quinlan, Markus Schordan, Richard Vuduc, Qing Yi Thomas Panas, Chunhua Liao, and Jeremiah J. Willcock Lawrence Livermore National Laboratory Livermore, CA 94550 925-423-2668 (office) 925-422-6278 (fax) fdquinlan,panas2,[email protected] [email protected] [email protected] [email protected] [email protected] Project Web Page: www.rosecompiler.org UCRL Number for ROSE User Manual: UCRL-SM-210137-DRAFT UCRL Number for ROSE Tutorial: UCRL-SM-210032-DRAFT UCRL Number for ROSE Source Code: UCRL-CODE-155962 ROSE User Manual (pdf) ROSE Tutorial (pdf) ROSE HTML Reference (html only) September 12, 2019 ii September 12, 2019 Contents 1 Introduction 1 1.1 What is ROSE.....................................1 1.2 Why you should be interested in ROSE.......................2 1.3 Problems that ROSE can address...........................2 1.4 Examples in this ROSE Tutorial...........................3 1.5 ROSE Documentation and Where To Find It.................... 10 1.6 Using the Tutorial................................... 11 1.7 Required Makefile for Tutorial Examples....................... 11 I Working with the ROSE AST 13 2 Identity Translator 15 3 Simple AST Graph Generator 19 4 AST Whole Graph Generator 23 5 Advanced AST Graph Generation 29 6 AST PDF Generator 31 7 Introduction to AST Traversals 35 7.1 Input For Example Traversals............................. 35 7.2 Traversals of the AST Structure............................ 36 7.2.1 Classic Object-Oriented Visitor Pattern for the AST............ 37 7.2.2 Simple Traversal (no attributes)....................... 37 7.2.3 Simple Pre- and Postorder Traversal....................
    [Show full text]
  • Basic Compiler Algorithms for Parallel Programs *
    Basic Compiler Algorithms for Parallel Programs * Jaejin Lee and David A. Padua Samuel P. Midkiff Department of Computer Science IBM T. J. Watson Research Center University of Illinois P.O.Box 218 Urbana, IL 61801 Yorktown Heights, NY 10598 {j-lee44,padua}@cs.uiuc.edu [email protected] Abstract 1 Introduction Traditional compiler techniques developed for sequential Under the shared memory parallel programming model, all programs do not guarantee the correctness (sequential con- threads in a job can accessa global address space. Communi- sistency) of compiler transformations when applied to par- cation between threads is via reads and writes of shared vari- allel programs. This is because traditional compilers for ables rather than explicit communication operations. Pro- sequential programs do not account for the updates to a cessors may access a shared variable concurrently without shared variable by different threads. We present a con- any fixed ordering of accesses,which leads to data races [5,9] current static single assignment (CSSA) form for parallel and non-deterministic behavior. programs containing cobegin/coend and parallel do con- Data races and synchronization make it impossible to apply structs and post/wait synchronization primitives. Based classical compiler optimization and analysis techniques di- on the CSSA form, we present copy propagation and dead rectly to parallel programs because the classical methods do code elimination techniques. Also, a global value number- not account.for updates to shared variables in threads other ing technique that detects equivalent variables in parallel than the one being analyzed. Classical optimizations may programs is presented. By using global value numbering change the meaning of programs when they are applied to and the CSSA form, we extend classical common subex- shared memory parallel programs [23].
    [Show full text]
  • A Compiler-Compiler for DSL Embedding
    A Compiler-Compiler for DSL Embedding Amir Shaikhha Vojin Jovanovic Christoph Koch EPFL, Switzerland Oracle Labs EPFL, Switzerland {amir.shaikhha}@epfl.ch {vojin.jovanovic}@oracle.com {christoph.koch}@epfl.ch Abstract (EDSLs) [14] in the Scala programming language. DSL devel- In this paper, we present a framework to generate compil- opers define a DSL as a normal library in Scala. This plain ers for embedded domain-specific languages (EDSLs). This Scala implementation can be used for debugging purposes framework provides facilities to automatically generate the without worrying about the performance aspects (handled boilerplate code required for building DSL compilers on top separately by the DSL compiler). of extensible optimizing compilers. We evaluate the practi- Alchemy provides a customizable set of annotations for cality of our framework by demonstrating several use-cases encoding the domain knowledge in the optimizing compila- successfully built with it. tion frameworks. A DSL developer annotates the DSL library, from which Alchemy generates a DSL compiler that is built CCS Concepts • Software and its engineering → Soft- on top of an extensible optimizing compiler. As opposed to ware performance; Compilers; the existing compiler-compilers and language workbenches, Alchemy does not need a new meta-language for defining Keywords Domain-Specific Languages, Compiler-Compiler, a DSL; instead, Alchemy uses the reflection capabilities of Language Embedding Scala to treat the plain Scala code of the DSL library as the language specification. 1 Introduction A compiler expert can customize the behavior of the pre- Everything that happens once can never happen defined set of annotations based on the features provided by again.
    [Show full text]
  • Wind River Diab Compiler
    WIND RIVER DIAB COMPILER Boost application performance, reduce memory footprint, and produce high-quality, standards-compliant object code for embedded systems with Wind River® Diab Compiler. Wind River has a long history of providing software and tools for safety-critical applications requiring certification in the automotive, medical, avionics, and industrial markets. And it’s backed by an award-winning global support organization that draws on more than 25 years of compiler experience and hundreds of millions of successfully deployed devices. TOOLCHAIN COMPONENTS Diab Compiler includes the following programs and utilities: • Driver: Intelligent wrapper program invoking the compiler, assembler, and linker, using a single application • Assembler: Macro assembler invoked automatically by the driver program or as a complete standalone assembler generating object modules – Conditional macro assembler with more than 30 directives – Unlimited number of symbols – Debug information for source-level debugging of assembly programs • Compiler: ANSI/ISO C/C++ compatible cross-compiler – EDG front end – Support for ANSI C89, C99, and C++ 2003 – Hundreds of customizable optimizations for performance and size – Processor architecture–specific optimizations – Whole-program optimization capability • Low-level virtual machine (LLVM)–based technology: Member of the LLVM commu- nity, accelerating inclusion of new innovative compiler features and leveraging the LLVM framework to allow easy inclusion of compiler add-ons to benefit customers • Linker: Precise
    [Show full text]
  • Cosmic Evolution Through Uv Surveys (Cetus) Final Report
    COSMIC EVOLUTION THROUGH UV SURVEYS (CETUS) FINAL REPORT Thematic Activity: Project (probe mission concept) Program: Electromagnetic observations from space Authors of Final Report: Jonathan Arenberg, Northrop Grumman Corporation Sally Heap, Univ. of Maryland, [email protected] Tony Hull, Univ. of New Mexico Steve Kendrick, Kendrick Aerospace Consulting LLC Bob Woodruff, Woodruff Consulting Scientific Contributors: Maarten Baes, Rachel Bezanson, Luciana Bianchi, David Bowen, Brad Cenko, Yi-Kuan Chiang, Rachel Cochrane, Mike Corcoran, Paul Crowther, Simon Driver, Bill Danchi, Eli Dwek, Brian Fleming, Kevin France, Pradip Gatkine, Suvi Gezari, Lea Hagen, Chris Hayward, Matthew Hayes, Tim Heckman, Edmund Hodges-Kluck, Alexander Kutyrev, Thierry Lanz, John MacKenty, Steve McCandliss, Harvey Moseley, Coralie Neiner, Goren Östlin, Camilla Pacifici, Marc Rafelski, Bernie Rauscher, Jane Rigby, Ian Roederer, David Spergel, Dan Stark, Alexander Szalay, Bryan Terrazas, Jonathan Trump, Arjun van der Wel, Sylvain Veilleux, Kate Whitaker, Isak Wold, Rosemary Wyse Technical Contributors: Jim Burge, Kelly Dodson, Chip Eckles, Brian Fleming, Jamie Kennea, Gerry Lemson, John MacKenty, Steve McCandliss, Greg Mehle, Shouleh Nikzad, Trent Newswander, Lloyd Purves, Manuel Quijada, Ossy Siegmund, Dave Sheikh, Phil Stahl, Ani Thakar, John Vallerga, Marty Valente, the Goddard IDC/MDL. September 2019 Cosmic Evolution Through UV Surveys (CETUS) TABLE OF CONTENTS INTRODUCTION TO CETUS ................................................................................................................
    [Show full text]
  • Compilers History Wikipedia History Main Article: History of Compiler
    Compilers History Wikipedia History Main article: History of compiler construction Software for early computers was primarily written in assembly language for many years. Higher level programming languages were not invented until the benefits of being able to reuse software on different kinds of CPUs started to become significantly greater than the cost of writing a compiler. The very limited memory capacity of early computers also created many technical problems when implementing a compiler. Towards the end of the 1950s, machine-independent programming languages were first proposed. Subsequently, several experimental compilers were developed. The first compiler was written by Grace Hopper, in 1952, for the A-0 programming language. The FORTRAN team led by John Backus at IBM is generally credited as having introduced the first complete compiler in 1957. COBOL was an early language to be compiled on multiple architectures, in 1960. In many application domains the idea of using a higher level language quickly caught on. Because of the expanding functionality supported by newer programming languages and the increasing complexity of computer architectures, compilers have become more and more complex. Early compilers were written in assembly language. The first self-hosting compiler — capable of compiling its own source code in a high-level language — was created for Lisp by Tim Hart and Mike Levin at MIT in 1962. Since the 1970s it has become common practice to implement a compiler in the language it compiles, although both Pascal and C have been popular choices for implementation language. Building a self-hosting compiler is a bootstrapping problem—the first such compiler for a language must be compiled either by hand or by a compiler written in a different language, or (as in Hart and Levin's Lisp compiler) compiled by running the compiler in an interpreter.
    [Show full text]
  • Compilers and Compiler Generators
    Compilers and Compiler Generators an introduction with C++ © P.D. Terry, Rhodes University, 1996 [email protected] This is a set of Postcript® files of the text of my book "Compilers and Compiler Generators - an introduction with C++", published in 1997 by International Thomson Computer Press. The original edition is now out of print, and the copyright has reverted to me. The book is also available in other formats. The latest versions of the distribution and details of how to download up-to-date compressed versions of the text and its supporting software and courseware can be found at http://www.scifac.ru.ac.za/compilers/ The text of the book is Copyright © PD Terry. Although you are free to make use of the material for academic purposes, the material may not be redistributed without my knowledge or permission. File List The 18 chapters of the book are filed as chap01.ps through chap18.ps The 4 appendices to the book are filed as appa.ps through appd.ps The original appendix A of the book is filed as appa0.ps The contents of the book is filed as contents.ps The preface of the book is filed as preface.ps An index for the book is filed as index.ps. Currently (January 2000) the page numbers refer to an A4 version in PCL® format available at http://www.scifac.ru.ac.za/compilers/longpcl.zip. However, software tools like GhostView may be used to search the files for specific text. The bibliography for the book is filed as biblio.ps Change List 18-October-1999 - Pre-release 12-November-1999 - First official on-line release 16-January-2000 - First release of Postscript version (incorporates minor corrections to chapter 12) Compilers and Compiler Generators © P.D.
    [Show full text]
  • Perl
    -I<directory> directories specified by –I are Perl prepended to @INC -I<oct_name> enable automatic line-end processing Ming- Hwa Wang, Ph.D. -(m|M)[- executes use <module> before COEN 388 Principles of Computer- Aided Engineering Design ]<module>[=arg{,arg}] executing your script Department of Computer Engineering -n causes Perl to assume a loop around Santa Clara University -p your script -P causes your script through the C Scripting Languages preprocessor before compilation interpreter vs. compiler -s enable switch parsing efficiency concerns -S makes Perl use the PATH environment strong typed vs. type-less variable to search for the script Perl: Practical Extraction and Report Language -T forces taint checks to be turned on so pattern matching capability you can test them -u causes Perl to dump core after Resources compiling your script Unix Perl manpages -U allow Perl to do unsafe operations Usenet newsgroups: comp.lang.perl -v print version Perl homepage: http://www.perl/com/perl/, http://www.perl.org -V print Perl configuration and @INC Download: http://www.perl.com/CPAN/ values -V:<name> print the value of the named To Run Perl Script configuration value run as command: perl –e ‘print “Hello, world!\n”;’ -w print warning for unused variable, run as scripts (with chmod +x): perl <script> using variable without setting the #!/usr/local/bin/perl –w value, undefined functions, references use strict; to undefined filehandle, write to print “Hello, world!\n”; filehandle which is read-only, using a exit 0; non-number as it were a number, or switches subroutine recurse too deep, etc.
    [Show full text]
  • 407 a Abell Galaxy Cluster S 373 (AGC S 373) , 351–353 Achromat
    Index A Barnard 72 , 210–211 Abell Galaxy Cluster S 373 (AGC S 373) , Barnard, E.E. , 5, 389 351–353 Barnard’s loop , 5–8 Achromat , 365 Barred-ring spiral galaxy , 235 Adaptive optics (AO) , 377, 378 Barred spiral galaxy , 146, 263, 295, 345, 354 AGC S 373. See Abell Galaxy Cluster Bean Nebulae , 303–305 S 373 (AGC S 373) Bernes 145 , 132, 138, 139 Alnitak , 11 Bernes 157 , 224–226 Alpha Centauri , 129, 151 Beta Centauri , 134, 156 Angular diameter , 364 Beta Chamaeleontis , 269, 275 Antares , 129, 169, 195, 230 Beta Crucis , 137 Anteater Nebula , 184, 222–226 Beta Orionis , 18 Antennae galaxies , 114–115 Bias frames , 393, 398 Antlia , 104, 108, 116 Binning , 391, 392, 398, 404 Apochromat , 365 Black Arrow Cluster , 73, 93, 94 Apus , 240, 248 Blue Straggler Cluster , 169, 170 Aquarius , 339, 342 Bok, B. , 151 Ara , 163, 169, 181, 230 Bok Globules , 98, 216, 269 Arcminutes (arcmins) , 288, 383, 384 Box Nebula , 132, 147, 149 Arcseconds (arcsecs) , 364, 370, 371, 397 Bug Nebula , 184, 190, 192 Arditti, D. , 382 Butterfl y Cluster , 184, 204–205 Arp 245 , 105–106 Bypass (VSNR) , 34, 38, 42–44 AstroArt , 396, 406 Autoguider , 370, 371, 376, 377, 388, 389, 396 Autoguiding , 370, 376–378, 380, 388, 389 C Caldwell Catalogue , 241 Calibration frames , 392–394, 396, B 398–399 B 257 , 198 Camera cool down , 386–387 Barnard 33 , 11–14 Campbell, C.T. , 151 Barnard 47 , 195–197 Canes Venatici , 357 Barnard 51 , 195–197 Canis Major , 4, 17, 21 S. Chadwick and I. Cooper, Imaging the Southern Sky: An Amateur Astronomer’s Guide, 407 Patrick Moore’s Practical
    [Show full text]
  • The Argonne Leadership Computing Facility Scott Parker Argonne and the Blue Gene
    The Argonne Leadership Computing Facility Scott Parker Argonne and the Blue Gene . 2005: – Argonne accepts 1 rack (1024 nodes) of Blue Gene/L (5.6 TF) . 2006: – Argonne Leadership Computing Facility (ALCF) created . 2008: – ALCF accepts 40 racks (160k nodes) of Blue Gene/P (557 TF) . 2009: – ALCF approved for 10 petaflop system to be delivered in 2012 . 2012 – 10 PF Mira Blue Gene/Q hardware delivered to ALCF . 2013: – Mira in production 2 ALCF Systems . Mira – BG/Q system – 49,152 nodes / 786,432 cores – 768 TB of memory – Peak flop rate: 10 PF – Linpack flop rate: 8.6 PF (#5 Top 500) . Cetus & Vesta (T&D) - BG/Q systems – 4K & 2k nodes / 64k & 32k cores – 64 TB & 32 TB of memory – 820 TF & 410 TF peak flop rate . Tukey – Nvidia system – 100 nodes / 1600 x86 cores/ 200 M2070 GPUs – 6.4 TB x86 memory / 1.2 TB GPU memory – Peak flop rate: 220 TF . Storage – 30 PB capacity, 240 GB/s bw (GPFS) – Storage upgrade planned in 2015 3 ALCF Systems (16) DDN 12Ke couplets – Scratch – 28 PB (raw), 240 GB/s Mira Infiniband 48 racks/768K cores 10 PF I/O Switch Switch (3) DDN 12Ke couplets – Home – 1.8 PB (raw), 45 GB/s Cetus (Dev) 4 rack/64K cores Complex I/O 820 TF Tape Library – 16 PB (raw) Tukey (Viz) 100 nodes/1600 cores 200 NVIDIA GPUs 220 TF Networks – 100Gb (via ESnet, internet2 UltraScienceNet, ) IB Switch (1) DDN 12Ke – 600 TB (raw), 15 GB/s Vesta (Dev) 2 racks/32K cores I/O 410 TF 4 Blue Gene DNA .
    [Show full text]