bluuebunny/crossref_metadata_2025_split huggingface dataset:
Synchronous and asynchronous handling of abnormal events in the μsystem
Authors: Buhr Peter A. , Macdonald Hamish I. , Zarnke C. Robert 
Published: November 2006

AbstractThis paper presents a general model for dealing with abnormal events during program execution and describes how this model is implemented in the μSystem. (The μSystem is a library of C definitions that provide light‐weight concurrency on uniprocessor and multiprocessor computers running the UNIX operating system.) Two different techniques can be used to deal with an abnormal event: an exception, which results in an exceptional change in control flow from the point of the abnormal event; and an intervention, which is a routine call from the point of the abnormal event that performs some corrective action. Users can define named exceptions and interventions in conjunction with ones defined by the μSystem. Exception handlers and intervention routines for dealing with abnormal events can be defined/installed at any point in a program. An exception or intervention can then be raised or called, passing data about the abnormal event and returning results for interventions. Interventions can also be activated in other tasks, like a UNIX signal. Such asynchronous interventions may interrupt a task's execution and invoke the specified intervention routine. Asynchronous interventions are found to be useful to get another task's attention when it is not listening through the synchronous communication mechanism.
Software tools for micro‐analysis of programs
Authors: Cohen Jacques , Weitzman Aline 
Published: November 2006

AbstractThe paper proposes and describes several tools enabling their user to estimate the efficiency of Pascal or C‐like programs. The approach consists of generating symbolic formulas expressing the efficiency of the programs being analyzed. The formulas are applicable to a variety of compiler‐machine configurations. The actual numeric values of the variables in the symbolic formula are determined using linear programming techniques. The proposed approach reduces considerably the amount of benchmarking needed to analyze programs. Several examples are presented showing the applicability of the tools. The effort necessary to implement them is considerably reduced by the combined usage of Prolog and a symbolic formula manipulation package (Maple).
cxterm: A Chinese terminal emulator for the X window system
Authors: Pong Man‐Chi , Zhang Yongguang 
Published: November 2006

AbstractComputing involving data in a logo‐syllabic oriental language like Chinese is more difficult than in English. Many attempts have been made to develop bilingual or multilingual processing systems.1–3 Most of them are based on microcomputers like the IBM‐PC. With the widespread use of workstations and window systems, much better multi‐lingual processing environments can be provided.This paper describes the design and implementation of the program cxterm, a Chinese terminal emulator for the X Window System. We discuss the representation of multi‐byte international characters, the problems of Chinese character input and output, the pros and cons of various approaches, and the design decisions for cxterm. A feature of cxterm is its independence of input methods. A user can incorporate new input methods into cxterm at run‐time, without changing the program code. We also compare our approach with related work in multi‐lingual input/output in X, and describe how cxterm performs better in terms of efficiency, flexibility, and user‐friendliness.
Monitoring and debugging distributed realtime programs
Authors: Dodd Paul S. , Ravishankar Chinya V. 
Published: November 2006

AbstractIn this paper we describe the design and implementation of an integrated monitoring and debugging system for a distributed real‐time computer system. The monitor provides continuous, transparent monitoring capabilities throughout a real‐time system's lifecycle with bounded, minimal, predictable interference by using software support. The monitor is flexible enough to observe both high‐level events that are operating system‐ and application‐specific, as well as low‐level events such as shared variable references. We present a novel approach to monitoring shared variable references that provides transparent monitoring with low overhead. The monitor is designed to support tasks such as debugging realtime applications, aiding real‐time task scheduling, and measuring system performance. Since debugging distributed real‐time applications is particularly difficult, we describe how the monitor can be used to debug distributed and parallel applications by deterministic execution replay.
Tm: A code generator for recursive data structures
Authors: van Reeuwijk C. 
Published: November 2006

AbstractThe transfer of data structures between programs is often carried out using binary or ad‐hoc textual formats. However, this can result in ambiguous and non‐portable file formats. The program ‘Tm’ (for ‘template manager’) prevents these problems by using a textual representation of the data structures and generating the code to read and write this representation from an abstract definition of the data structures. The same program is used to generate code for the simple data‐structure manipulations that are necessary in almost every program. At the moment, code can be generated for the programming languages C, Pascal, Lisp and Miranda. Support for other languages is easily added.
CCIGS: A data compression system for Chinese fonts and binary images using classification techniques
Authors: Chang Kuang‐Yao , Tang Gregory Y. 
Published: November 2006

AbstractTo achieve a high compression ratio when storing a large amount of Chinese characters is a problem in applications using Chinese characters. In this paper, we present a data compression software system which can reduce the storage requirement of Chinese characters and binary images. This system is composed of a Chinese font compressing subsystem and a binary image compressing subsystem. In the Chinese font compressing subsystem we have improved the traditional methods of feature extraction and classification techniques so as to achieve a high compression ratio in the compression of Chinese characters. Based on the technique of this subsystem, we have combined the block segmentation technique to compress a binary image. In addition to achieving a good data compression ratio the encoding‐decoding process is computationally very efficient in our system. We also show that with our system the quality and accuracy of the reconstructed pattern and image are very close to those of the original pattern and image.
Reusability through fine‐grain inheritance
Authors: Johnson Paul , Rees Ceri 
Published: November 2006

AbstractObject‐oriented languages are often promoted as encouraging the production of flexible, reusable software. Unfortunately, experience suggests that although individual classes may be reusable, large class libraries seem to lack flexibility in the face of circumstances unforeseen by the designer.This paper explores the problems associated with flexibility and reuse in large libraries, and shows how fine‐grain inheritance can alleviate some of these problems. A methodology for designing fine‐grain inheritance graphs is proposed and a detailed case study is presented.
An exercise in formalizing the description of a concurrent system
Authors: Bustard D. W. , Norris M. T. , Orr R. A. , Winstanley A. C. 
Published: November 2006

AbstractLOTOS is one of the most recent formal description languages to appear and one of very few with a standard definition. It has both a process algebra and an abstract data‐type component, and these facilities are used in combination to describe the behaviour of concurrent systems. The purpose of this paper is to examine, in a tutorial style, what is involved in constructing and taking benefit from such descriptions. The presentation is illustrated through the development of two formal descriptions for the children's game of pass‐the‐parcel. These descriptions and a concise summary of the main features of LOTOS are given as appendices. Many of the points made in the paper apply equally well to other process‐oriented languages such as CCS and CSP.
Rapid prototyping of protocols from LOTOS specifications
Authors: Valenzano A. , Sisto R. , Ciminiera L. 
Published: November 2006

AbstractA new tool for generating implementation prototypes of communication protocols and concurrent systems specified using the ISO LOTOS language is presented in this paper. A brief introduction to LOTOS and a discussion of the main problems related to the efficient execution of specifications written in LOTOS are presented first. The design and implementation of the tool are then considered: LOTOS specifications are analysed and translated into C functions which are executed by co‐operating processes in the Unix environment. The set of LOTOS process definitions is first translated into a suitable number of extended finite‐state machines (EFSMs). The method proposed allows the problem of deriving unbounded EFSMs to be circumvented and a sort of control on the process number/size trade‐off to be obtained at the same time.The problem of implementing the LOTOS multi‐way rendezvous mechanism for process synchronization is solved by using an algorithm based on message‐passing techniques. An example of prototype derivation is also described, showing the form of C code generated by translating a simple specification. Finally, some performance figures are presented.
PDB: A pictorial database oriented to data analysis
Authors: Maccarone Maria Concetta , Tripiciano Mario , Gesù Vito Di , Tegolo Domenico 
Published: November 2006

AbstractThe paper describes a new pictorial database oriented to image analysis, implemented inside the MIDAS data analysis system. Pictorial databases need expressive data structures in order to represent a wide class of information from the numerical to the visual. The model of the database is relational; however, a full normalization is not achievable, owing to the complexity of the visual information. The paper reports the general design and notes on the software implementation. Preliminary experiments show the performance of the pictorial database.
A first exploration of PrologIII's capabilities
Authors: Rueher Michel 
Published: November 2006

AbstractThis paper explores PrologIII's capabilities through the study of two short but non‐trivial applications that are chosen to show the advantages of constraint logic programming languages over conventional Prologs, especially for tackling combinatorial problems.The first application (manipulation of causal graphs) highlights the expressive power of the constraints on booleans and shows that constraint logic programming techniques provide great flexibility for the exploration of the domain of an application, and therefore significantly improve Prolog's prototyping capabilities.The second application (map colouring) demonstrates that a combined use of numerical constraints and constraints on trees of PrologIII enables one to improve solutions based on standard backtracking, through the use of simple heuristics. Such heuristics allow drastic reduction of the search space and yield good performance even for quite complex problems. The adaptability of the approach to other combinatorial problems is shown on several examples.
The peregrine high‐performance RPC system
Authors: Johnson David B. , Zwaenepoel Willy 
Published: November 2006

AbstractThe Peregrine RPC system provides performance very close to the optimum allowed by the hardware limits, while still supporting the complete RPC model. Implemented on an Ethernet network of Sun‐3/60 workstations, a null RPC between two user‐level threads executing on separate machines requires 573μs. This time compares well with the fastest network RPC times reported in the literature, ranging from about 1100 to 2600 μs, and is only 309 μs above the measured hardware latency for transmitting the call and result packets in our environment. For large multi‐packet RPC calls, the Peregrine user‐level data transfer rate reaches 8.9 Mbit/s, approaching the Ethernet's 10 Mbit/s network transmission rate. Between two user‐level threads on the same machine, a null RPC requires 149 μs. This paper identifies some of the key performance optimizations used in Peregrine, and quantitatively assesses their benefits.
Application integration: Constructing composite applications from interactive components
Authors: Cowan D. D. , Stepien T. M. , Ierusalimschy R. , Lucena C. J. P. 
Published: November 2006

AbstractCreating new applications by integrating user interface and application components is a relatively new idea which is currently of wide interest. A significant part of this problem is clearly defining the separation between user interface and application components. This paper proposes a new design methodology based on the concept of an abstract data view (ADV), a structuring method which cleanly defines this separation. A number of examples of composite interactive documents, ones which could contain several different user interfaces with entities such as text, calculations, drawings and possibly even multi‐media presentations, illustrate the ADV concept. These examples lead naturally to the introduction of the concept ofhole, a user interface area in a composite interactive document which is managed by an external program, and uses ADVs. Prototypes of a number of systems supporting ADVs and holes are currently running in our laboratory.
CIRL/PIWI: A GUI toolkit supporting retargetability
Authors: Cowan D. D. , Durance C. M. , Giguère E. , Pianosi G. M. 
Published: November 2006

AbstractWriting applications that are easily moved to various computer platforms with different graphical user interfaces (GUIs) is a complex task. Yet this concept is important for the creator of commercial software, as it is not likely to be clear for many years whether one or two GUIs will survive and become industry ‘standards’ or whether the growth in GUIs will continue because of new developments in human‐computer interfaces. Providing a user interface abstraction that maps into all toolkits seems to be an appropriate way to proceed, but is fraught with difficulty. For example, different GUIs present a different look‐and‐feel that often causes system‐specific information to be embedded in an application. This paper surveys the problems inherent in designing a user interface abstraction, and describes the experiences gained from a specific implementation called CIRL/PIWI.CIRL and PIWI are acronyms for Co‐ordinate‐Independent Resource Language and Presentation‐Independent Windowed Interface.
The user interface abstraction contains a knowledge base that allows many components of the user interface to be defined independent of look‐and‐feel thereby increasing the portability of an application.
Multi‐way versus one‐way constraints in user interfaces: Experience with the deltablue algorithm
Authors: Sannella Michael , Maloney John , Freeman‐Benson Bjorn , Borning Alan 
Published: November 2006

AbstractThe efficient satisfaction of constraints is essential to the performance of constraint‐based user interfaces. In the past, most constraint‐based user interfaces have used one‐way rather than multi‐way constraints because of a widespread belief that one‐way constraints were more efficient. In this paper we argue that many user interface construction problems are handled more naturally and elegantly by multi‐way constraints than by one‐way constraints. We present pseudocode for an incremental multi‐way constraint satisfaction algorithm, DeltaBlue, and describe experience in using the algorithm in two user interface toolkits. Finally, we provide performance figures demonstrating that multi‐way constraint solvers can be entirely competitive in performance with one‐way constraint solvers.
Extensions to the C programming language for enhanced fault detection
Authors: Plater David W. , Yesha Yelena , Park E. K. 
Published: November 2006

AbstractThe acceptance of the C programming language by academia and industry is partially responsible for the ‘software crisis’. The simple, trusting semantics of C mask many common faults, such as range violations, which would be detected and reported at run‐time by programs coded in a robust language such as Ada.Ada is a registered trademark of the U.S. Government (Ada Joint Program Office)
This needlessly complicates the debugging of C programs. Although the assert macro lets programmers add run‐time consistency checks to their programs, the number of instantiations of this macro needed to make a C program robust makes it highly unlikely that any programmer could correctly perform the task. We make some unobtrusive extensions to the C language which support the efficient detection of faults at run‐time without reducing the readability of the source code. Examples of the extensions are automatic checking of error codes returned by library routines, constrained subtypes and detection of references to uninitialized and/or non‐existent array elements.
Executable specifications with data‐flow diagrams
Authors: Fuggetta Alfonso , Ghezzi Carlo , Mandrioli Dino , Morzenti Angelo 
Published: November 2006

AbstractSpecifications of information systems applications are often based on the use of entity‐relationship (ER) and data‐flow diagrams (DFD), which cover, respectively, the conceptual modelling of data and funtions. This paper introduces VLP: an executable visual language for formal specifications and prototyping which integrates ER and DFD diagrams in a semantically rigorous and clear way. Unlike existing commercial products (so‐called CASE tools), which can support good‐quality documentation, simple forms of consistency checking and bookkeeping, VLP also supports executable specifications, which provide a prototype of the desired application. After reviewing the principles of VLP, the paper outlines the structure of the ECASET environment in which VLP is embedded. In particular, it shows how the environment supports the stepwise derivation of specifications, from informal to formal, and how it supports specification‐in‐the‐large.
Standardized protocol interfaces
Authors: Holzmann Gerard J. 
Published: November 2006

AbstractA traditional protocol implementation typically consists of at least two distinct parts, a sender and a receiver. Each part runs on a distinct machine, with the implementation provided by a local expert. At best, the two machines are of the same type and the protocol implementations are provided by the same person. More likely, however, the machines are not of the same type and the implementations of the two halves of the protocol are provided by two different people, working from an often loosely defined protocol specification. It seems almost unavoidable that the two implementations are not quite compatible.In this paper we consider an alternative technique. With this method, one of the two implementors can design, formally validate, and implement all the relevant protocol parts, including those parts that are to be executed remotely. Each communication channel is now terminated on the receiving side, by a single standard protocol interface, which can be called a universal asynchronous protocol interface, or UAPI.Though it is likely that the UAPI is most efficiently implemented in hardware, it can also trivially run as a software module, e.g. under a standard UNIX® operating system (in our case under 10th Edition Research Unix). This paper introduces the concept of a UAPI and explains how the sample software controller was constructed.
The measured cost of conservative garbage collection
Authors: Zorn Benjamin 
Published: November 2006

AbstractBecause dynamic memory management is an important part of a large class of computer programs, high‐performance algorithms for dynamic memory management have been, and will continue to be, of considerable interest. Experience indicates that for many programs, dynamic storage allocation is so important that programmers feel compelled to write and use their own domain‐specific allocators to avoid the overhead of system libraries. As an alternative to explicit storage management techniques, conservative garbage collection has been suggested as an important algorithm for dynamic storage management in C programs. In this paper, I evaluate the costs of different dynamic storage management algorithms, including domain‐specific allocators, widely‐used general‐purpose allocators, and a publicly available conservative garbage collection algorithm. Surprisingly, I find that programmer enhancements often have little effect on program performance. I also find that the true cost of conservative garbage collection is not the CPU overhead, but the memory system overhead of the algorithm. I conclude that conservative garbage collection is a promising alternative to explicit storage management and that the performance of conservative collection is likely to improve in the future. C programmers should now seriously consider using conservative garbage collection instead of explicitly calling free in programs they write.
Vartalaap: A distributed multicast communication system
Authors: Lashkari Yezdezard , Ramachandran Viswanath , Malpani Sanjay , Mehndiratta S. L. 
Published: November 2006

AbstractWith the increasing proliferation of computer networks and distributed systems, there is a growing number of applications using multicast communication. This paper presents the Vartalaap system developed at IIT, Bombay. Vartalaap is an hierarchical distributed system for multicast communication over a network, implemented in a hardware‐independent fashion. The multicast is achieved without resorting to unnecessary broadcasting of messages over the network. Issues covered in this paper include the primitives for multicast, the multicast model and the system architecture. We discuss the implementation of Vartalaap and compare it with some other systems. We conclude with a discussion on the limitations of the current implementation and directions for future work.
Parsing Non‐LR(k) grammars with yacc
Authors: Merrill Gary H. 
Published: November 2006

AbstractOf the parser generating tools currently in use, yacc (or one of its several variants) is perhaps the most frequently employed. However, because of inherent ambiguities there are some languages (such as C++) that a yacc‐generated parser cannot successfully compile. This paper describes a set of minor modifications to yacc‐like tools that allows them to be used in a straightforward way to parse ambiguities and, more generally, grammars that require an indefinite amount of lookahead. Required changes to the lexical analyzer are also discussed, and the application of these techniques is illustrated within the context of specific examples.
Customalloc: Efficient synthesized memory allocators
Authors: Grunwald Dirk , Zorn Benjamin 
Published: November 2006

AbstractThe allocation and disposal of memory is a ubiquitous operation in most programs. Rarely do programmers concern themselves with details of memory allocators; most assume that memory allocators provided by the system perform well. Yet, in some applications, programmers use domain‐specific knowledge in an attempt to improve the speed or memory utilization of memory allocators.In this paper, we describe a program (CustoMalloc) that synthesizes a memory allocator customized for a specific application. Our experiments show that the synthesized allocators are uniformly faster and more space efficient than the Berkeley UNIX allocator. Constructing a custom allocator requires little programmer effort, usually taking only a few minutes. Experience has shown that the synthesized allocators are not overly sensitive to properties of input sets and the resulting allocators are superior even to domain‐specific allocators designed by programmers. Measurements show that synthesized allocators are from two to ten times faster than widely‐used allocators.