WorldCat Identities

Hilfinger, Paul N.

Works: 18 works in 44 publications in 1 language and 399 library holdings
Genres: Handbooks and manuals 
Roles: Author
Classifications: QA76.6, 001.6424
Publication Timeline
Most widely held works by Paul N Hilfinger
Abstraction mechanisms and language design by Paul N Hilfinger( Book )

14 editions published between 1981 and 1986 in English and Undetermined and held by 310 WorldCat member libraries worldwide

Fundamental structures of computer science by William Allan Wulf( Book )

1 edition published in 1981 in English and held by 17 WorldCat member libraries worldwide

Code reorganization for instruction caches by A. Dain Samples( Book )

3 editions published in 1988 in English and held by 11 WorldCat member libraries worldwide

Program performance can be improved on machines with virtual memory by reorganizing the program's address space. We address the question whether reorganization could benefit programs on machines with instruction caches. We have performed experiments to determine the efficacy of restructuring using simple reordering algorithms and profile data, concluding that performance improvement can be obtained relatively cheaply. Experiments show improvements in rise rates on the order 30% to 50%, and sometimes as high as 50% to 80%, by performing a simple algorithm that relocates only 3% to 5% of the basic blocks of a program
Direct function calls in LISP by Benjamin Zorn( Book )

2 editions published in 1988 in English and held by 9 WorldCat member libraries worldwide

This paper compares the implementation of direct function calls in SPUR Lisp. Spice Lisp, Zecalisp, etc. We examine the performance of direct and indirect function calls on the VAX MC68020, and SPUR architectures. For the SPUR architecture, sin gle indirection slows applications by 3-4%, and double indirection slows applications by 6-8%. The performance benefits of direct function calls are smaller for the VAX and MC68020 architectures. Implementing direct function calls requires maintaining bac kpointers from each function to all the functions that call it. The additional memory allocated for backpointers ranges from 10-50% of the memory allocated for functions. Maintaining backpointers increases the time to load functions by 10-15%. Redefining a function in a direct call implementation adds up to 50% to the time needed in an implementation with indirect function calls
Implementation of multiprocessing SPUR Lisp by Berkeley University of California( Book )

4 editions published in 1988 in English and held by 9 WorldCat member libraries worldwide

This paper describes an implementation of the multiprocessing features of SPUR Lisp. The implementation consists of a set of C runtime routines that is being integrated into the Lisp system. It was developed on Sun workstation under the Sprite operating system, and will ported to the SPUR multiprocessor workstations when the hardware becomes available. In this report, we describe the internal structure of the system, design tradeoffs, and present preliminary performance figures. We hope this paper will be useful to other implementors of these multiprocessing features
Implementing Ada fixed-point types having arbitrary scales by Paul N Hilfinger( Book )

2 editions published in 1990 in English and held by 7 WorldCat member libraries worldwide

If x and y are the integer values representing the operands, these operations reduce to finding integer approximations of any [alpha]xy or [beta]x/y with an absolute error less than 1 for a fixed-point result type, an absolute error less than or equal to 1/2 for an integer result type, or a relative error of less than one safe interval for a floating- point result type. The static constants [alpha] and [beta] may be arbitrary positive rational numbers, depending on the scales of the two operand types and on the result type. I present reasonably fast ways to compute appropriate fixed-point results for all values of [alpha] or [beta]
A memory allocation profiler for C and LISP by Benjamin Zorn( Book )

3 editions published in 1988 in English and held by 7 WorldCat member libraries worldwide

This paper describes inprof, a tool used to study the memory allocation behavior of programs. mprof records the amount of memory each function allocates, breaks down allocation information by type and size, and displays a program's dynamic cal graph so that functions indirectly responsible for memory allocation are easy to identify. mprof is a two-phase tool. The monitor phase is linked into executing programs and records information each time memory is allocated. The display phase reduces the data generated by the monitor and displays the information to the user in several tables. mprof has been implemented for C and Kyoto Common Lisp. Measurements of these implementations are presented
FIDIL reference manual by Paul N Hilfinger( Book )

3 editions published in 1993 in English and Undetermined and held by 6 WorldCat member libraries worldwide

FIDIL (for FInite DIfference Language) is a language supporting finite difference and particle method computations. It extends the semantic domain of FORTRAN-like algebraic languages with facilities for construction, composition, refinement, and other manipulation of grids (called domains) and for performing computations on functions defined over these domains. FIDIL is an attempt to automate much of the routine bookkeeping that forms a large part of many programs involving PDEs, and to bring the semantic level of these programs closer to that at which the algorithms are conceived and published. This report gives the current definition of the FIDIL language. We expect the definition to evolve with experience
Tartan, language design for the Ironman requirement : reference manual by Mary Shaw( Book )

2 editions published in 1978 in English and held by 5 WorldCat member libraries worldwide

Tartan is an experiment in language design. The goal was to determine whether a 'simple' language could meet substantially all of the ironman requirements for a common high-order programming language. This experiment was undertaken because it was believed that all the designs done in the first phase of the DOD effort were too large and too complex. That complexity was viewed as a serious failure of the designs; excess complexity in a programming language can interfere with its use, even to the extent that any beneficial properties are of little consequence. The researchers wanted to find out whether the requirements inherently lead to such complexity or whether a substantially simpler language would suffice. Three ground rules drove the experiment. First, no more than two months -- April 1 to May 31 -- would be devoted to the project. Second, the language would meet all the Ironman requirements except for a few points at which it would anticipate Steelman requirements. Further, the language would contain no extra features unless they resulted in a simpler language. Third, simplicity would be the overriding objective. It must be emphasized again that this effort is an experiment, not an attempt to compete with DOD contractors. Tartan is, however, an open challenge to the Phase II contractors: The language can be at least this simple. Can anyone do better
(Preliminary) : an informal definition of Alphard( Book )

1 edition published in 1978 in English and held by 4 WorldCat member libraries worldwide

Tartan, language design for the Ironman requirement : notes and examples by Mary Shaw( Book )

2 editions published in 1978 in English and held by 4 WorldCat member libraries worldwide

The Tartan language was designed as an experiment to see whether the Ironman requirement for a common high-order programming language could be satisfied by an extremely simple language. The result, Tartan substantially meets the Ironman requirement. We believe it is substantially simpler than the four designs that were done in the first phase of the DOD-1 effort. The language definition appears in a companion report; this report provides a more expository discussion of some of the language's features, some examples of its use, and a discussion of some facilities that could enhance the basic design at relatively little cost. (Author)
Titanium language reference manual( Book )

1 edition published in 2001 in English and held by 2 WorldCat member libraries worldwide

An Ada package for dimensional analysis by Paul N Hilfinger( Book )

1 edition published in 1986 in English and held by 1 WorldCat member library worldwide

Discusses the use of Ada's abstraction facilities to define away to attribute units of measure to variables and values
An Ada (Trade Name) Package for Dimensional Analysis( Book )

1 edition published in 1984 in English and held by 1 WorldCat member library worldwide

This paper illustrates the use of Ada's abstraction facilities-notably operator overloading and type parameterization-to define an oft-requested feature: a way to attribute units of measure to variable and values. The definition given allows the programmer to specify units of measure for variables, constants, and parameters; checks uses of these entities for dimensional consistency; allows arithmetic between them, where legal; and provides scale conversions between commensurate units. It is not constrained to a particular system of measurement (such as the metric or English systems.) While the definition is in standard Ada and requires nothing special of the compiler, certain reasonable design choices in the compiler, discussed here at some length, can make its implementation particularly efficient. Dimensional analysis is a consistency check common in scientific and engineering computations. It consists of verifying that uses of numerical quantities conform to their declared units of measure-for example, that measures of length are not added to measures of time and that quotients of distance and time are treated as velocities. In many ways, dimensional analysis resembles strong typing, as found in Ada and other modern programming languages
Improved RISC Support for the Smalltalk-80 Language( Book )

1 edition published in 1987 in English and held by 1 WorldCat member library worldwide

The Smalltalk-80 language is polymorphic and dynamically typed. That is, subprograms (methods in Smalltalk jargon) legally may operate on arguments of different types; the method invoked as a result of a given textual call (send) depends on the type (class) of the first operand; and the classes of local variables, parameters, and fields (instance variables) in general cannot be deduced at compilation time. Because all sends can involve polymorphism, a straightforward implementation requires run-time dispatching on the class of the first operand for every send. Typical Samlltalk-80 coding style results in many small methods, implying that sends figure prominently in dynamic instruction counts, and that their fast execution is important. There are two basic ways that have been used to reduce the time required for a polymorphic send. First, one can use some form of method caching. Second, one can use type inference and in-line substitution. Polymorphism is relatively rare; about 5% of sends reach the same target on consecutive executions. As a result, it makes sense to save the result of each method look up operation so that it can be quickly retrieved upon subsequent re-execution of the same text. Ungar describes the in-line caching scheme used in the SOAR project at Berkeley, in which the result of each look up is saved by replacing the look up code with a direct call on the method found
Compiling Smalltalk-80 to a RISC( Book )

1 edition published in 1987 in English and held by 1 WorldCat member library worldwide

The Smalltalk On A RISC project at U.C. Berkeley proved that good performance executing a high-level language on a modified RISC architecture was attainable. The system removed a layer of interpretation, translating bytecodes to a register-based instruction set. This paper describes the bytecode translator and how it was affected by SOAR architectural features. The translator generates code of reasonable density and speed. Because of bytecode semantics, relatively few optimizations are possible, but hardware and software mechanisms at runtime offset these limitations. Register allocation with register windows is the major task of the compiler. Several hardware features could be easily performed by the compiler
FIDIL: a language for scientific programming by Paul N Hilfinger( )

1 edition published in 1989 in English and held by 1 WorldCat member library worldwide

Reference manual for the Ada programming language by J. D Ichbiah( Book )

1 edition published in 1983 in English and held by 1 WorldCat member library worldwide

Ada is the result of a collective effort to design a common language for programming large scale and real-time systems. This report is the proposed standard document for Ada. Since the early 70's, DoD has been committed to the use of High Order Languages and has developed an extensive set of requirements for a single language which could be adopted for use throughout DoD. In April 1978, the language designed by Jean Ichbiah and his team at Honeywell/Cii-Honeywell Bull, Paris, France, was chosen to be the new DoD language. For the ensuing fourteen months, Ada was subjected to an intense period of test and evaluation by the international computer science community and the design was modified in response to language issues raised during the test and evaluation. It will be added to the list of approved languages for use in DoD systems and promises to have a significant impact on DoD software development. Ada will be reviewed under American National Standards Institute (ANSI) canvass procedures for designation as an American National Standard and is on the agenda for the International Standards Organization (ISO). The DoD is concentrating on the development of compilers and an integrated programming support environment for Ada software. Although developed for use in DoD systems, Ada has generated considerable interest in the international computing community, particularly NATO, as well as in the U.S. commercial computing community. (Author)
moreShow More Titles
fewerShow Fewer Titles
Audience Level
Audience Level
  Kids General Special  
Audience level: 0.62 (from 0.47 for Fundamenta ... to 0.99 for Compiling ...)

English (41)