bluuebunny/crossref_metadata_2025_split huggingface dataset:
VIS: A virtual image system for image‐understanding research
Authors: Vernon David , Sandini Giulio 
Published: November 2006

AbstractImage understanding is concerned with the elucidation of a computational base inherent in perceiving a three‐dimensional world using vision. This paper describes a low‐level (or early) vision software system, developed in the context of current collaborative research activities in image understanding, which goes some way toward fulfilling the goals of portability, ease of use, and general‐purpose extensibility. Since visual perception uses several types of disparate, but interrelated, information in some explicit cognitive organization, a central objective of the work is to represent this information in a coherent integrated manner which allows one interactively to investigate the properties of the interdependency between information types.
Experience with an object‐oriented virtual machine
Authors: Sandberg David W. 
Published: November 2006

AbstractThe implementation of a virtual machine for X2, an object‐based programming language, is presented. The X2 virtual machine, is similar to the Smalltalk‐80 virtual machine, but X2 does not perform message look‐up. The implementation differs from most Smalitalk‐80 systems in that objects are paged and in the ability to save changes to an image instead of the whole image. These differences allow larger images to be handled.
An exception handling method for constructive algebraic specifications
Authors: van Horebeek Ivo , Lewi Johan , Bevers Eddy , Duponcheel Luc , van Puymbroeck Willy 
Published: November 2006

AbstractThis paper describes an exception detection and exception handling method for constructive algebraic specifications. A notation that supports exception handling is introduced. First, a safety function is provided for every sort. This function characterizes each object as being safe or unsafe. Secondly, axioms may contain markers that indicate when they are applicable.The proposed notation is a trade‐off between readability and capability to handle a large class of exceptional situations. The description of exception handling promotes a two‐step design method for constructive algebraic specifications. In a first step the specification is given with exception detection only; in a second step exception handling is superimposed.
A micro‐kernel for concurrency in C
Authors: Cormack Gordon V. 
Published: November 2006

AbstractA micro‐kernel that supports concurrent execution of C procedures within a single user process is described. A micro‐kernel provides only four primitives, which have been used to build a number of higher‐level abstractions, including support for distributed processing. The micro‐kernel differs from other efforts in that it is small and efficient, it is written entirely as a non‐privileged user program, and it provides fine‐grained unpredictable interleaving of execution.
Garbage collection of strings and linked data structures in real time
Authors: Nilsen K. 
Published: November 2006

AbstractModern high‐level languages frequently need to collect garbage not only from regions of linked structures similar to LISP's dotted pairs, but also from string regions where data is organized as an array of characters. Some characteristics of string regions that make garbage collection particularly difficult are as follows: multiple pointers to the same characters within the array are allowed and encouraged; all possible character values are legitimate as data, so it is not possible to ‘mark’ a string by overwriting with a reserved character; and a character is generally much smaller than a pointer, so it is not possible to overwrite a single character value with a forwarding pointer to a new location for a particular string. This paper describes the addition of certain information to a string descriptor and enhancements to existing copying garbage collection algorithms that permit linked data structures and strings to be allocated and garbage collected from a shared region of memory in real time. This algorithm is real‐time in the sense that the time required for allocation of each basic unit of memory is bounded by a constant. An analysis of performance is reported, and comparisons are made with traditional garbage collection.
A simple system for constructing distributed, mixed‐language programs
Authors: Hayes Roger , Manweiler Steve W. , Schlichting Richard D. 
Published: November 2006

AbstractThe Mixed‐Language Programming (MLP) System is a simple system that facilitates construction of sequential programs in which procedures can be written in different programming languages to exploit heterogeneity in language functionality. In addition, MLP provides a simple remote procedure call (RPC) facility that allows heterogeneity in machine functionality to be exploited. To minimize implementation cost, the system does not solve all of the problems related to mixed‐language programming; rather, MLP is designed to handle common situations well. Among the unique aspects of MLP are its advanced facilities, which allow complex situations to be handled with user intervention; for example, these facilities allow arguments of a type not defined by a language to be used by procedures written in that language. This paper overviews the use of MLP and describes its implementation. In addition, two programs that have been written using the MLP system—a small database system and a collection of plot routines—are discussed. The system executes on a collection of Vaxes and Suns running Berkeley UNIX. Currently supported languages are C, Pascal and Icon.
A retrospective on DOSE: An interpretive approach to structure editor generation
Authors: Kaiser Gail E. , Feiler Peter H. , Jalili Fahimeh , Schlichter Johann H. 
Published: November 2006

AbstractDOSE is unique among structure editor generatiors in its interpretive approach. This approach leads to very fast turn‐around time for changes and provides multi‐language facilities for no aditional effort or cost. This article compares the interpretive approach to the compilation approach of other structure editor generators. It describes some of the design and implementation decisions made and remade durign this project and the lessons learned. It emphasizes the advantages and disadvantages of DOSE with respect to other structure editing systems.
Animation of requirements specifications
Authors: Kramer Jeff , Ng Keng 
Published: November 2006

AbstractRequirements analysis has been recognized as one of the most critical and difficult tasks in software engineering. The need for tool support is essential. This paper reports some work done to provide such support for interpretation and validation of requirements specifications by animation.The Animator provides facilities for the selection and execution of a transaction to reflect the specified behaviour of a particular scenario specified in the requirements specification. Actions are described in terms of input‐output mappings and or functions with pattern matching. Simple rules can be specified to control the triggering of actions. In addition, facilities are provided to replay and interact with transactions. User interaction during animation includes the ability to change data values or role play selected actions as desired. A full graphical interface is supported.The approach has been tested by the provision of an Animator for the requirements analysis method CORE and an associated ‘Analyst Workstation’. Animation has been tested on a number of small examples and a major case study. This paper describes the Animator, justifies the approach taken and discusses experience and future work.
A study of a C function inliner
Authors: Davidson Jack W. , Holler Anne M. 
Published: November 2006

AbstractAlthough the inline expansion of subprograms has often been cited as a method for improving a program's execution time, few available compilers perform the operation, and fewer still perform it without requiring explicit direction from the programmer. The authors have written a tool called INLINER, which is a source‐to‐source filter that automatically performs inline expansion of C functions in a module. With this tool, the effect of inlining was investigated using a set of programs on several machines. The authors' findings are presented, including an instance (unrelated to the size of the inlined executable) in which inlining can diminish a program's performance, and evidence that the size of the inlined executable does not, in practice, prove to cause problems.
GPROC—an integrated system for the processing of numerical scientific data
Authors: O'Neill M. A. 
Published: November 2006

AbstractWork done on an interactive graphical processing system is described. An overview is given of the uses to which a system could be put, with especial reference to aspects of solid state physics. Algorithms which may be usefully included in such a system, when used in a technical scientific environment, are described. The problems of implementing such a system on small microcomputer systems are outlined, and some possible areas of future development are discussed.
The distributed operating system of the SMD project
Authors: Marques J. Alves , Cunha J. P. , Guedes P. , Guimarães N. , Cunha A. 
Published: November 2006

AbstractThis article analyses the structure of the distributed operating system of the SMD project— DIOS.The description of the basic structure is followed by a global view of the services and the supporting kernel of the system. Each service is analysed according to its functionality and implementation.DIOS was implemented on bare machines and on top of commercial operating systems. The port of the system to hetereogeneous environments is discussed and some implementation details are described.In parallel with the research on DIOS a multiprocessor station has been developed. These two projects had clear influences on each other; to illustrate some of the major interdependencies, the performance of DIOS in their particular architecture is analysed.The paper ends with information on the current status of the project and on some planned directions of work.
Compiler performance analysis tools
Authors: Heines T. S. , Jalics P. J. 
Published: November 2006

AbstractMost of the performance bench‐marks for compilers do not give detailed performance characteristics that might be useful to a programmer. The goal of most bench‐marks seems to be to produce a single number. A set of bench‐mark tools that measure individual language features of C and generate a large number of measurements has been designed to create a detailed performance profile of any C compiler. There is an emphasis on the detailed statement‐level measurements of both CPU and I/O aspects of C, but there is also a range of routine and program‐level bench‐marks that seek to measure the interaction of CPU and I/O in actual application programs. The programs are portable, parametrized, and openended so that additional measurements can be added with little effort. With some additional effort, the tools could be adapted to other languages.
The design of an object‐oriented command interpreter
Authors: Budd Timothy A. 
Published: November 2006

AbstractObject‐oriented programming languages are noted for their ability to allow users quickly to construct large software systems. They achieve this ability by allowing the programmer to concentrate on what it is they want to do, ignoring details of how that functionality is achieved. Such characteristics should make the object‐oriented style of programming attractive to casual or novice computer users, indeed one of the best known object‐oriented programming languages, Smalltalk, was initially designed with just such novice users in mind.The Unix operating system is widely regarded as a good environment for doing software development. Nevertheless, its large number of often terse and cryptic commands make it difficult for novice or casual users to use. In this paper we argue that one solution is to create an object‐oriented command interpreter, or shell, between the user and the underlying system. This paper reports on the construction of one such prototype shell, and the lessons we have learned from the use of this system.
Quick compilers using peephole optimization
Authors: Davidson Jack W. , Whalley David B. 
Published: November 2006

AbstractAbstract machine modelling is a popular technique for developing portable compilers. A compiler can be quickly realized by translating the abstract machine operations to target machine operations. The problem with these compilers is that they trade execution efficiency for portability. Typically, the code emitted by these compilers runs two to three times slower than the code generated by compilers that employ sophisticated code generators. This paper describes a C compiler that uses abstract machine modelling to achieve portability. The emitted target machine code is improved by a simple, classical rule‐directed peephole optimizer. Our experiments with this compiler on four machines show that a small number of very general handwritten patterns (under 40) yields code that is comparable to the code from compilers that use more sophisticated code generators. As an added bonus, compilation time on some machines is reduced by 10 to 20 per cent.
Practical interface specification
Authors: Hoffman Daniel 
Published: November 2006

AbstractAlthough software development based on modules is now widely practiced and taught, specification of module interfaces has received far less acceptance. Languages such as Ada and Modula‐2 require an interface specification, but it is syntactic, merely listing the exported procedures and functions and their signatures. No semantic information is given, leaving the effect of each call on the return value of other calls unspecified. Module users must either guess the interface semantics or infer them from the module implementation, seriously compromising the value of the modular approach. Formal methods, such as the algebraic and trace approaches, do specify interface semantics, but have proved difficult to teach and to apply in practice.In this paper we present the software cost reduction (SCR) method for specifying the syntax and semantics of the module interface. We describe the basic approach and illustrate it on simple, but complete examples. We describe and demonstrate the additional features and techniques we have introduced to handle more complex problems. We also show the precise relationship between the SCR and trace techniques by presenting a method for converting any SCR specification to an equivalent trace specification.
Interprocedural optimization: Experimental results
Authors: Richardson Stephen , Ganapathi Mahadevan 
Published: November 2006

AbstractThe problem of tracking data flow across procedure boundaries has a long history of theoretical study by people who believed that such information would be useful for code optimization. Building upon previous work, an algorithm for interprocedural data flow analysis has been implemented. The algorithm produces three flow‐insensitive summary sets: MOD, USE and ALIASES. The utility of the resulting information was investigated using an optimizing Pascal compiler. Over a sampling of 27 bench‐marks, new optimizations performed as a result of interprocedural summary information contributed almost nothing to program execution speed. Finally, related optimization techniques of possibly greater potential are discussed.
Simple generational garbage collection and fast allocation
Authors: Appel Andrew W. 
Published: November 2006

AbstractGenerational garbage collection algorithms achieve efficiency because newer records point to older records; the only way an older record can point to a newer record is by a store operation to a previously created record, and such operations are rare in many languages. A garbage collector that concentrates just on recently allocated records can take advantage of this fact. Such a garbage collector can be so efficient that the allocation of records costs more than their disposal. A scheme for quick record allocation attacks this bottleneck. Many garbage‐collected environments do not know when to ask the operating system for more memory. A robust heuristic solves this problem.This paper presents a simple, efficient, low‐overhead version of generational garbage collection with fast allocation, suitable for implementation in a Unix environment.
Word‐based text compression
Authors: Moffat Alistair 
Published: November 2006

AbstractThe development of efficient algorithms to support arithmetic coding has meant that powerful models of text can now be used for data compression. Here the implementation of models based on recognizing and recording words is considered. Move‐to‐the‐front and several variable‐order Markov models have been tested with a number of different data structures, and first the decisions that went into the implementations are discussed and then experimental results are given that show English text being represented in under 2‐2 bits per character. Moreover the programs run at speeds comparable to other compression techniques, and are suited for practical use.
An implementation of the object‐oriented concurrent programming language SINA
Authors: Tripathi Anand , Berge Eric , Aksit Mehmet 
Published: November 2006

AbstractSINA is an object‐oriented language for distributed and concurrent programming. The primary focus of this paper is on the object‐oriented concurrent programming mechanisms of SINA and their implementation. This paper presents the SINA constructs for concurrent programming and inter‐object communication, some illustrative examples and a message‐based implementation model for SINA that we have used in our current implementation.
SAHAYOG: A test bed for evaluating dynamic load‐sharing policies
Authors: Dikshit Piyush , Tripathi Satish K. , Jalote Pankaj 
Published: November 2006

AbstractThis paper describes the implementation of a test bed called SAHAYOG, for evaluating dynamic load‐sharing policies in which job‐transfer decisions are based on the state of the system. The test bed is implemented on a network of AT&T 3B2 minicomputers. It provides an interactive user interface for conducting load‐sharing experiments. Based on user‐specified parameters it creates independent job streams at different nodes in the network. Jobs are transferred among the nodes by the load‐sharing algorithm being evaluated. Each node collects data about the jobs, which are used to generate statistics about the experiment. Five load‐sharing algorithms are implemented and evaluated using the test bed under different load conditions and for various parameter values. These experiments confirm some earlier results about load sharing and also provide some new insights. SAHAYOG also contains an optional fault‐tolerance feature to handle single‐node failures, and evaluates the effect of fault tolerance on the performance of different policies.
A user interface specification for a program debugging and measuring environment
Authors: Lopriore Lanfranco 
Published: November 2006

AbstractA high level of complexity is involved in program dynamics. A number of tools have been developed to assist the programmer in mastering this complexity in the various phases of software development. However, these tools are specifically oriented towards the monitoring of particular aspects of program behaviour. This paper presents the results of a systematic attempt at defining the user interface to an environment for program debugging, program performance evaluation and program structure analysis. This environment can be used to implement many common debugging techniques, and to evaluate important program performance indexes and program structure statistics. It supports both sequential and concurrent block‐oriented high‐level languages.
A performance study of deadlock prevention algorithms in a distributed file system
Authors: Ha&Ca Anna , Jin Xiaowei , Soo Jo‐Han 
Published: November 2006

AbstractThis paper describes an implementation and performance evaluation of different deadlock prevention algorithms. A deadlock prevention algorithm ensures that deadlock will never happen. The algorithms for deadlock prevention are proposed and implemented in a locally distributed system. A number of experiments were executed in a distributed system for various lengths of file operation and different numbers of files. The performance of the system and of each algorithm is evaluated and discussed. Some general results are derived for a single‐host and a distributed system.
A visual shell interface to a database
Authors: Rowe Lawrence A. , Danzig Peter , Choi Wilson 
Published: November 2006

AbstractThis paper describes a visual command language for a workstation with a bit‐mapped display and a mouse that can be used to create different user interfaces. Primitive interface components can be combined into more complex user interfaces. The user specifies interconnections between these components over which data and commands can be sent by pointing with a mouse.Primitive interface components are described for creating several different database user interfaces. The design and implementation of the software architecture is described, including the primitives for database interfaces and the communication protocols used by the system.
Set notation as a language to specify data transformation programs
Authors: Abbott Russell J. 
Published: November 2006

AbstractTo allow tools in a computer‐based working environment to share data, it is sometimes necessary to transform the data from the form used by one tool to the form expected by another. An application generator has been developed that generates data transformation programs from high‐level descriptions of the required transformations. The transformation specifications are expressed in traditional set notation, which combines features of functional and logic programming. The system thus offers a powerful declarative language for expressing data transformations.
The errors of tex
Authors: Knuth Donald E. 
Published: November 2006

AbstractThis paper is a case study of program evolution. The author kept track of all changes made to TEX during a period of ten years, including the changes made when the original program was first debugged in 1978. The log book of these errors, numbering more than 850 items, appears as an appendix to this paper. The errors have been classified into fifteen categories for purposes of analysis, and some of the noteworthy bugs are discussed in detail. The history of the TEX project can teach valuable lessons about the preparation of highly portable software and the maintenance of programs that aspire to high standards of reliability.