Showing papers in "Software - Practice and Experience in 1990"

The X Window System

Abstract: An overview of the X Window System is presented, focusing on the system substrate and the low-level facilities provided to build applications and to manage the desktop. The system provides high-performance, high-level, device-independent graphics. A hierarchy of resizable, overlapping windows allows a wide variety of application and user interfaces to be built easily. Network-transparent access to the display provides an important degree of functional separation, without significantly affecting performance, which is crucial to building applications for a distributed environment. To a reasonable extent, desktop management can be custom-tailored to individual environments, without modifying the base system and typically without affecting applications.

A node-positioning algorithm for general trees

Abstract: Drawing a tree consists of two stages: determining the position of each node, and actually rendering the individuals nodes and interconnecting branches. The algorithm described in this paper is concerned with the first stage: given a list of nodes, an indication of the hierarchical relationship among them, and their shape and size, where should each node be positioned for optimal aesthetic effect? This algorithm determines the positions of the nodes for any arbitrary general tree. It is the most desirable positioning with respect to certain widely-accepted heuristics. The positioning, specified in x, y co-ordinates, minimizes the width of the tree. In a general tree, there is no limit on the number of offspring per node; this contrasts with binary and ternary trees, for example, which are trees with a limit of two and three offspring per node. This algorithm operates in time O(N), where N is the number of nodes in the tree. Previously, most tree drawings have been positioned by the sure hand of a human graphic designer. Many computer-generated positionings have been either trivial or contained irregularities. Earlier work by Wetherell and Shannon1 and Tilford,2 upon which this algorithm builds, failed to position the interior nodes of some trees correctly. The algorithm presented here correctly positions a tree's node using only two passes. It also handles several practical considerations: alternative orientations of the tree, variable node sizes and out-of-bounds conditions. Radack,3 also building on Tilford's work, has solved this same problem with a different algorithm which makes four passes.

Fast allocation and deallocation of memory based on object lifetimes

Abstract: Dynamic storage-management algorithms are based either on object sizes or object lifetimes. Stack allocation, which is based on object lifetimes, is the most efficient algorithm, but severely restricts object lifetimes and creation times. Other algorithms based on object sizes, such as first fit and related algorithms, permit arbitrary lifetimes but cost more. More efficient variations capitalize on application-specific characteristics. Quick fit, for example, is more efficient when there are only a few object sizes. This paper describes a simple algorithm that is very efficient when there are few object lifetimes. In terms of instructions executed per byte allocated, the algorithm is almost half the cost of quick fit and less than twice the cost of stack allocation. Space for all objects with the same lifetime is allocated from a list of large arenas, and the entire list is deallocated at once. An implementation in ANSI C is included.

Abstract execution: a technique for efficiently tracing programs

Abstract: Many areas of computer performance analysis require detailed traces of events that occur during a program's execution. Collecting traces is expensive. The additional code required to record events greatly slows a program's execution. In addition, the resulting trace files can grow unmanageably large. This paper describes a technique called abstract execution that alleviates both problems. Abstract execution records a small set of events during the traced program's execution. These events serve as input to an abstract version of the program that generates a full trace by re-executing selected portions of the original program. This process greatly reduces both the cost of tracing the original program and the size of the trace files. The cost of regenerating a trace is insignificant in comparison to the cost of applications that use it. This paper also describes a system called AE that implements Abstract Execution. The paper contains measurements that demonstrate that AE can efficiently trace large programs.

Emerald: a general-purpose programming language

Abstract: Emerald is a general-purpose language with aspects of traditional object-oriented languages, such as Smalltalk, and abstract data type languages, such as Modula-2 and Ada. It is strongly typed with a non-traditional object model and type system that emphasize abstract types, allow separation of typing and implementation, and provide the flexibility of polymorphism and subtyping with compile-time checking. This paper describes the Emerald language and its programming methodology. We give examples that demonstrate Emerald's features, and compare and contrast the Emerald approach to programming with the approaches used in other similar languages.

Interacting with the FIELD Environment

Abstract: This paper describes the ideas behind and the use of the FIELD programming environment. FIELD is an integrated environment that is based on UNIX programming tools and that runs on top of the X11 windowing system. It provides a consistent and complete interface to its tools. In addition, FIELD provides a variety of tools for program and data visualization. The key concepts behind FIELD are an integration mechanism based on a simple, central message server, an annotation editor for integrating access to the source file with the other tools, and the use of a high-level user interface toolset.

EDGE: an extendable graph editor

Abstract: EDGE is an editor kernel for the direct and visual manipulation of graphs. The kernel can be adapted quickly to diverse applications based on graphs, such as PERT chart editing, directory browsing, call graph display, logic circuit simulation or configuration visualization. EDGE provides potential solutions to the following general problems faced by any graph editor. (1) Automatic graph layout: how can application-specific layout requirements, individual preferences, and layout stability be integrated with automatic layout algorithms? EDGE solves this problem with a novel algorithm that is based on layout constraints. (2) Graph abstraction: how can users deal with large graphs containing hundreds of nodes and edges, and thousands of edge crossings? EDGE can reduce the apparent complexity with subgraph abstractions and a novel clustering technique called edge concentration. (3) Adaptability: how should the editor kernel be structured to be adaptable to various applications? EDGE uses a special graph representation language for specifying visual appearance and the inheritance mechanism of C++ to achieve extendibility. (4) Persistence of graphs: how can the graph structures produced by the editor be kept in long-term storage, especially if the node and edge data structures have been extended for a particular application? Our approach uses a standardized, external format for graphs and handles extensions with program generator technology: the I/O routines for reading and writing extended node and edge data structures are produced automatically from the declarations of these data structures. This paper describes EDGE and presents details of the above solutions.

A system for adaptive disk rearrangement

Abstract: The speed of mass storage devices has a significant impact on the performance of computer systems. The speed that is realized on a particular mass storage device, however, depends heavily on how that device is used. Operating systems, such as the UNIX1 time-sharing system, use layout policies and head-scheduling disciplines that are designed to work well on average. Numerous studies have shown that disk access patterns exhibit a high degree of locality. Further, studies have shown that these access patterns do not necessarily correspond to the usage patterns anticipated by the system's designers, and that head scheduling is used infrequently enough that it has limited effect. This paper describes the design, implementation, and use of a disk subsystem that adaptively corrects the disparity between expected access patterns and actual access patterns by reorganizing disk data. A representative experiment that demonstrates the resulting performance improvement is presented.

Structured dataflow analysis for arrays and its use in an optimizing complier

Abstract: We extend the well-known interval analysis method so that it can be used to gather global flow information for individual array elements. Data dependences between all array accesses in different basic blocks, different iterations of the same loop, and across different loops are computed and represented as labelled arcs in a program flow graph. This approach results in a uniform treatment of scalars and arrays in the compiler and builds a systematic basis from which the compiler can perform numerous global optimizations. This global dataflow analysis is performed as a separate phase in the compiler. This phase only gathers the global relationships between different accesses to a variable, yet the use of this information is left to the code generator. This organization substantially simplifies the engineering of an optimizing compiler and separates the back end of the compiler (e.g. code generator and register allocator) from the flow analysis part. The global dataflow analysis algorithm described in this paper has been implemented and used in an optimizing compiler for a processor with deep pipelines. This paper describes the algorithm and its compact implementation and evaluates it, both with respect to the accuracy of the information and to the compile-time cost of obtaining and using it.

A Dual Gas Tracer Technique for Determining Trapped Gas Saturation During Steady Foam Flow in Porous Media

Abstract: Foam is a possible mobility control agent for effective oil displacement from reservoirs. Micromodel studies and prior gas-phase tracer experiments show that a significant fraction of the gas in a foam exists as trapped bubbles which, therefore, have a major impact on the flow resistance. To obtain quantitative measurements of trapped gas saturations, we have developed a unique experimental apparatus employing dual gas tracers. During steady foam flow in a porous medium, dilute sulfur hexafluoride (SF{sub 6}) and methane (CH{sub 4}) tracers in a nitrogen carrier are injected, and the effluent concentration is monitored by gas chromatography. The measured tracer histories are fit to a simple mass transfer model which describes any partitioning between the mobil and trapped foam phases. Tracer effluent concentrations predicted by the model are strongly influenced by the solubility of each tracer in the liquid phase. Hence, multiple gas tracers provide a discriminating assessment of trapped gas saturation during foam flow through porous media. New trapped gas saturations are reported for an aqueous C{sub 14-16} {alpha}-olefin sulfonate foamer solution and nitrogen flowing through a 2.3-{mu}m{sup 2} fired Berea sandstone at 10{sup 5} Pa (1 atm) back pressure and at room temperature. 26 refs., 7 figs., 1more » tab.« less

The μsystem: Providing light-weight concurrency on shared-memory multiprocessor computers running UNIX

Abstract: This paper presents a description of the μSystem, which is a library of C routines that provide light-weight concurrency on uniprocessor and multiprocessor computers running the UNIX operating system. A discussion of the run-time structure of a μSystem program is given, which includes the following concepts: coroutines, tasks, virtual processors and clusters. Next the routines that implement these concepts are discussed in detail. Finally, some performance figures from the μSystem are given and discussed, followed by a comparison of the μSystem with other similar systems.

Univers: an attribute-based name server

Abstract: Univers is a generic attribute-based name server upon which a variety of high-level naming services can be built. This paper defines Univers' underlying attribute-based naming model. It also describes several aspects of its implementation and demonstrates how various naming services ― including a global white-pages service, a local yellow-pages service and a conventional name-to-address mapper ― can be built on top of Univers

VIFOR: a tool for software maintenance

Abstract: VIFOR is a software tool oriented towards maintenance of medium-to-large Fortran77 programs. With VIFOR, programs can be displayed and edited in two forms: as the code and as the graph. VIFOR also contains transformations in both directions, i.e. from code to graph and from graph to skeletons of code. Hence, it is suitable for re-engineering and maintenance of existing code. Specially designed browsers implement the graphical interface. VIFOR contains a database that is based on a simple but effective data model of Fortran programs. The model contains only four entity classes and three relations, which makes the tool small, and easy to implement and use. A simple query language allows browsing through the database.