bluuebunny/crossref_metadata_2025_split huggingface dataset:
The performance of message‐passing using restricted virtual memory remapping
Authors: Tzou Shin‐Yuan , Anderson David P. 
Published: November 2006

AbstractDASH is a distributed operating system kernel. Message‐passing (MP) is used for local communication, and the MP system uses virtual memory ( VM) remapping instead of software memory copying for moving large amounts of data between virtual address spaces. Remapping eliminates a potential communication bottleneck and may increase the feasibility of moving services such as file services to the user level. Previous systems that have used VM remapping for message transfer, however, have suffered from high per‐operation delay, limiting the use of the technique. The DASH design reduces this delay by restricting the generality of remapping: a fixed part of every space is reserved for remapping, and a page's virtual address does not change when it is moved between spaces.We measured the performance of the DASH kernel for Sun 3/50 workstations, on which memory can be copied at 3·9 MB/s. Using remapping, DASH can move large messages between user spaces at a rate of 39 MB/s if they are not referenced and 24·8 MB/s if each page is referenced. Furthermore, the per‐operation delay is low, so VM remapping is beneficial even for messages containing only one page. To further understand the performance of the DASH MP system, we broke an MP operation into short code segments and timed them with microsecond precision. The results show the relative costs of data movement and the other components of MP operations, and allow us to evaluate several specific design decisions.
TPDL: Extended temporal profile description language
Authors: Cabodi G. , Camurati P. , Prinetto P. , Reorda M. Sonza 
Published: November 2006

AbstractThis paper presents TPDL (extended temporal profile description language), a general‐purpose language to observe and condition dynamic systems by means of temporal and logical expressions. It describes how time is modelled in TPDL, gives an overview of the language through its basic types, primitives and conditional constructs, and its use in computer‐aided design of digital systems. The paper discusses TPDL's facilities to support the description of hardware behaviour, to define the environment in which devices operate, and to observe and control both circuits and environments. The characteristics of the language are demonstrated through some representative examples.
NovAtel's novel approach to CPU usage measurement
Authors: Crowe David R. 
Published: November 2006

AbstractThis paper describes a set of CPU usage analysis tools, named CPU Probes, with the benefits of both hardware and software tools, and few of their disadvantages. CPU probes use a serial line unit or programmable interval timer as a clock to sample the CPU usage of a system, resulting in fast and accurate CPU usage estimates. CPU usage can be monitored for all processes simultaneously or as little as a single machine instruction. CPU probes are well suited for monitoring real‐time system performance. These tools have been implemented on PDP‐11/RSX and UNIX System V/386 systems.
Profiling software through the use of metrics
Authors: Robillard Pierre N. , Coupal Daniel , Coallier François 
Published: November 2006

AbstractThis paper presents an approach to software assessment using a new software tool that integrates most of the known static metrics. A six‐step method shows how to use metrics to obtain a picture of the software project. The method is visual and each step provides graphical representations of the data. Successive integration of data results in normality profiles. Examples illustrate each step. The method is adaptable to various environments and specific applications.
Design and implementation of a distributed file system
Authors: Cheng Hsiao‐Chung , Sheu Jang‐Ping 
Published: November 2006

AbstractWe introduce a new model for replication in distributed systems. The primary motivation for replication lies in fault tolerance. Although there are different kinds of replication approaches, our model combines the advantages ofmodular redundancyandprimary‐stand‐byapproaches to give more flexibility with respect to system configuration.To implement such a model, we select the IBM PC‐net with MS‐DOS environment as our base.Transparencyas well asfault‐tolerance file accessare the highlights of our system design. To fulfil these requirements, we incorporate the idea ofdirectory‐oriented replicationandextended prefix tablesin the system design. The implementation consists of a command shell, a DOS manager, and a recovery manager. Through this design, we can simulate a UNIX‐like distributed file system whose function is compatible with MS‐DOS.
Literate programming on a team project
Authors: Ramsey Norman , Marceau Carla 
Published: November 2006

AbstractWe used literate programming on a team project to write a 33,000 line program for the Synthesizer Generator. The program, Penelope, was written using WEB, a tool designed for writing literate programs. Unlike other WEB programs, many of which have been written by WEB's developer or by individuals, Penelope was not intended to be published. We used WEB in the hope that both our team and its final product would benefit from the advantages often attributed to literate programming. The WEB source served as good internal documentation throughout development and maintenance, and it continues to document Penelope's design and implementation. Our experience also uncovered a number of problems with WEB.
An inheritance model for supporting flexible displays of data structures
Authors: Dewan Prasun 
Published: November 2006

AbstractWe have designed an inheritance model that reduces the effort required to define presentations of data structures of programs written in conventional languages. It assumes that the presentation of a data structure is determined by one or more attributes of the data structure; classifies data structures into several groups based on their types, contexts, siblings, ancestors and other properties; and allows an attribute to be defined once for all members of a group. These groups are arranged in multiple intersecting hierarchies, and a subgroup is allowed to inherit attributes from its supergroups(s). This paper motivates, describes, and illustrates our method of grouping values and arranging the value groups in inheritance hierarchies.
Extending regular expressions with context operators and parse extraction
Authors: Kearns Steven M. 
Published: November 2006

AbstractRegular expressions are used in many applications to specify patterns because any regular expression can be compiled into a very efficient one‐pass pattern matcher called a finite automaton. Finding matches is useful, but even more useful is parse extraction, which describes in detail how a pattern matches some input. After matching an address, for example, parse extraction makes it easy to find out the Zip code part of the address. We present an elegant, efficient algorithm for extracting a parse after matching with a finite automaton. In addition, we extend the regular expression language to include new operators for matching arbitrary left context and single character right context. The extended language can be matched as efficiently as the usual regular expression language, but is more expressive. Finally, we suggest how to apply the matching algorithms to match regular expressions containing arbitrary right context and single character left context. In effect, this allows one to specify patterns that seem to require an unlimited amount of look‐ahead to match.
Compiled instruction set simulation
Authors: Mills Christopher , Ahalt Stanley C. , Fowler Jim 
Published: November 2006

AbstractAn efficient method for simulating instruction sets is described. The method allows for compiled instruction set simulation using the macro expansion capabilities found in many languages. Additionally, we show how the semantics of the C case statement allows instruction branching to be incorporated in an efficient manner. The method is compared with conventional interpreted techniques and is shown to offer considerable performance benefits.
A multi‐protocol campus time server
Authors: Snow C. R. 
Published: November 2006

AbstractA time server system has been constructed at the University of Newcastle upon Tyne which may be accessed by users of the campus Ethernet. It uses a commercially available radio clock to receive an accurate time signal from the MSF transmitter at Rugby, and can respond to requests from users of the network using a number of different protocols. This paper describes the server system, both hardware and software, and discusses some network management issues raised as a result of the associated experimentation and testing of the system.
A design rationale for a language‐based editor
Authors: Welsh Jim , Broom Brad , Kiong Derek 
Published: November 2006

AbstractThis paper reviews the design issues that arise in the construction of effective language‐based editors for the preparation of syntactically and static semantically correct language sentences, typically computer programs. The need for such editors to support a pluralistic view of program structure is identified, together with the need to observe the constraints on performance and storage consumption if such editors are to be accepted by professional programmers. From these basic needs, more specific requirements for the display, parsing and semantic checking components of such an editor are derived.
Simple register spilling in a retargetable compiler
Authors: Fraser Christopher W. , Hanson David R. 
Published: November 2006

AbstractThis paper describes the management of register spills in a retargetable C compiler. Spills are rare, which means that testing is a bigger problem than performance. The trade‐offs have been arranged so that the common case (no spills) generates respectable code quickly and the uncommon case (spills) is less efficient but as simple as possible. The technique has proven practical and is in production use on VAX, Motorola 68020, SPARC and MIPS machines.
Incremental semantic evaluation in language‐based editors
Authors: Kiong Derek , Welsh Jim 
Published: November 2006

AbstractWe present an incremental semantic analysis strategy for use in language‐based editors. Its advantage is the low storage cost involved in achieving incremental semantic operation with a relatively small loss in response. The scheme, which involves limiting identifier attribute flow, is first described for a simple block‐structured language like Pascal, and then extended to more modern modular languages.
Efficient prolog programming
Authors: Knuutila Timo 
Published: November 2006

AbstractThis paper presents some basic programming strategies for Prolog programmers. The strategies are based on knowledge about the operational behaviour of the Warren Abstract Machine (WAM). The aim is to provide simple principles for making programs both faster and less space‐consuming. The programming hints given are mostly local, i.e. only a single clause or procedure need be considered at a time.
A parallel database‐driven protocol verification system prototype
Authors: Frieder O. 
Published: November 2006

AbstractProtocol verification systems test the specification of communication protocols. A prototype of a protocol verification system based on parallel database primitives for a hypercube multicomputer is described. Using the described prototype, two conventional protocols are verified. To evaluate the performance of verification systems, a synthetic protocol that is to be used as a benchmark is proposed. Extensions to and properties of the synthetic protocol are described. Using this protocol, the performance of the developed verification system is evaluated.
Implementing concurrent C
Authors: Gehani N. H. , Roome W. D. 
Published: November 2006

AbstractConcurrent C (C++) is a parallel superset of C (C++). Versions of Concurrent C have now been implemented for a variety of uniprocessors and multiprocessors. We first implemented a uniprocessor version of Concurrent C correctly anticipating that it would be relatively easy to extend the uniprocessor implementation to run on multiprocessors. Concurrent C is translated to C. The generated C code contains calls to the C library implementing the Concurrent C run‐time system.This paper describes the ‘hard core’ details of the Concurrent C implementation: the specifics of process states, the data structures used, the library functions, and the C code generated for various Concurrent C constructs. We also give an overview of the Concurrent C facilities and of the uniprocessor, distributed and shared‐memory multiprocessor implementations.
Object‐oriented implementation issues in an experimental CAD system
Authors: Wolf Wayne 
Published: November 2006

AbstractThis case study of object‐oriented program design illustrates two limitations of object‐oriented programming languages. Existing object‐oriented languages do not have good facilities to support two key program design problems: the definition of composite objects, or data structures that include sets of related subobjects; and the specification and run‐time management of temporary data structures required to implement efficient algorithms. Both composite objects and temporary data structures are important to the construction of a wide variety of programs. We use the design and implementation of an interactive computer‐aided design system to describe how the limitations of present object‐oriented languages complicate the design of composite objects and temporary data structures.
ARTK‐M2: A kernel for Ada tasking requirements: An implementation and an automatic generator
Authors: Díaz‐Herrera Jorge L. , Graft Ronald D. , Rupp Douglas B. 
Published: November 2006

AbstractA run‐time kernel, ARTK‐M2, supporting Ada tasking semantics is discussed; full support for task creation, synchronization, communication, scheduling, and termination is provided, together with all options of the Ada rendezvous. An implementation in Modula‐2 is presented and a method for automatically translating Ada programs into semantically equivalent Modula‐2 programs with corresponding kernel calls is introduced. A parser generator and an attribute grammar were used for the automatic translation. A subset of the Ada Compiler Validation Capability was processed to test the implementation and to illustrate the translation mechanism. The kernel is applicable to the study of real‐time control systems; it can also serve as a baseline for studying implementation alternatives of Ada concepts, such as new scheduling algorithms, and for analysing new language constructs. Work is under way to implement some of the changes to the Ada tasking model being proposed as a result of the language revision (Ada9X). Finally, through proper extensions, ARTK‐M2 can form an integral part of programming tools such as an Ada compilation system and a distributed kernel for multi‐processing environments.
A vector C and Fortran compiler for the FPS T‐series: Experiences with compiling to occam I
Authors: Stevenson D. E. , Ammons L. K. , Crosmun W. G. , Jackson A. , Raj G. L. 
Published: November 2006

AbstractWe describe our implementation of C and Fortran preprocessors for the FPS T‐series hypercube. The target of these preprocessors is the occam I language.We provide a brief overview of the INMOS transputer and the Weitek vector processing unit (VPU). These two units comprise one node of the T‐series. Some depth of understanding of the VPU is required to fully appreciate the problems encountered in generating vector code. These complexities were not fully appreciated at the outset.The occam I language is briefly described. We focus on only those aspects of occam I which differ radically from C. The transformations used to preprocess C into occam I are discussed in detail. The special problems with the VPU both in terms of its (non)interface with occam I and in dealing with numerical programs is discussed separately.A lengthy discussion on the special techniques required for compilation is provided. C and Fortran are simply incompatible with the occam I model. We provide a catalogue of problems encountered. We emphasize that these problems are not so much with occam I but with preprocessing to occam I. We feel the CSP and occam I models are quite good for distributed processing.The ultimate message from this work should be seen in a larger context.Several languages—such as Ada and Modula‐2—are being touted as the standards for the 1990s. These languages severely restrict parallel programming style; this may make saving dusty decks by preprocessing an impossibility.
A new parsing method for non‐LR(1) grammars
Authors: Harford A. Gayler , Heurinc Vincent P. , Main Michael G. 
Published: November 2006

AbstractOne of the difficult problems that faces a compiler writer is to devise a grammar that is suitable for both efficient parsing and semantic attribution. This paper describes a system that resolves conflicts in LR(1) parsing by taking advantage of information in the parse tree. The system, which functions as part of a compiler generator, rewrites the user's grammar to remove parsing conflicts. It then places code into the generated compiler that rewrites the parse tree during parsing so as to produce the tree of the original grammar. The compiler writer can then write the semantic attribution to fit his or her original grammar without any knowledge of the changes made. The method is expected to be efficient in most cases, even in parsing systems that do not explicitly build the entire parse tree. The method complements previous work in its capabilities and advantages. The system has been implemented and integrated into a compiler generator system.
Selecting the median and two quartiles in a set of numbers
Authors: Cunto Walter , Munro J. Ian , Rey Manuel 
Published: November 2006

AbstractThe median, the 0.25‐percentile and the 0.75‐percentile are three of the most relevant ranks in data analysis. MED2Q is a new in situ algorithm to solve this problem. It asymptotically performs an average of 2 5/8 n + o(n) comparisons when n numbers are given as input thus becoming the asymptotically fastest algorithm for this problem reported to date. The performance of MED2Q is compared with those of FIND1 and ALGORITHM 4892, two well‐known selection algorithms adapted to this specific problem. From this performance comparison, MED2Q is best when input sets consist of more than 50,000 numbers.
Ingest—A simple program for performing distributed relational database operations
Authors: Silberberg David 
Published: November 2006

AbstractThe Hubble Space Telescope (HST) and ground system produce approximately 600 gigabytes of data per year in the form of many types of datasets. Because of the formidable size of the total data stream, the datasets are impractical to manage with a conventional database system. Therefore, they are archived onto an optical disk juke‐box system. A smaller HST Catalog exists to describe the archived data and manage access to the HST archived data. When the Catalog keywords are queried, the resulting records point to file names stored in the archive. This allows users to request datasets by their descriptive keywords instead of file names.The Catalog is populated by data from several external databases via the Ingest program. Ingest normalizes and/or joins rows of multiple external database tables and writes the new rows to the HST Catalog. Secondarily, Ingest parses data values, translates data values, and creates row identifiers for each row to be written to the HST Catalog. The Ingest process is driven by translation tables residing in the object database which can be altered on‐the‐fly. This paper describes the design of the HST Catalog Data Ingest program in more detail.Ingest has proven to be a powerful tool in the HST environment where functional requirements are many, database structures are enormous and both evolve rapidly.
Problems with determining package cohesion and coupling
Authors: Rising Linda , Calliss Frank W. 
Published: November 2006

AbstractThe cohesion and coupling guidelines described by Yourdon, Constantine and Myers have proved useful aids for the design of modular programs. They have also provided direction for the evaluation of existing modules, pointing to those candidates for restructuring during perfective maintenance. For languages like Ada, where support for a higher‐level of abstraction is provided in the form of a package, subprogram heuristics are inadequate. This paper examines existing guidelines and taxonomies for the Ada package and proposes extensions to these schemes. These package‐level schemes are applied in a case study of an existing Ada program.
An optimizing compiler for the icon programming language
Authors: Walker Kenneth , Griswold Ralph E. 
Published: November 2006

AbstractCompiling code for the Icon programming language presents several challenges, particularly in dealing with types and goal‐directed expression evaluation. In order to produce optimized code, it is necessary for the compiler to know much more about operations than is necessary for the compilation of most programming languages. This paper describes the organization of the Icon compiler and the way it acquires and maintains information about operations. The Icon compiler generates C code, which makes it portable to a wide variety of platforms and also allows the use of existing C compilers for performing routine optimizations on the final code. A specially designed implementation language, which is a superset of C, is used for writing Icon's run‐time system. This language allows the inclusion of information about the abstract semantics of Icon operations and their type‐checking and conversion requirements. A translator converts code written in the run‐time language to C code to provide an object library for linking with the code produced by the Icon compiler. The translation process also automatically produces a database that contains the information the Icon compiler needs to generate and optimize code. This approach allows easy extension of Icon's computational repertoire, alternate computational extensions, and cross compilation.
Multilevel security in the UNIX tradition
Authors: McIlroy M. D. , Reeds J. A. 
Published: November 2006

AbstractThe original UNIX system was designed to be small and intelligible, achieving power by generality rather than by a profusion of features. In this spirit we have designed and implemented IX, a multilevel‐secure variant of the Bell Labs research system. IX aims at sound, practical security, suitable for private‐and public‐sector uses other than critical national‐security applications. The major security features are: private paths for safe cooperation among privileged processes, structured management of privilege, and security labels to classify information for purposes of privacy and integrity. The labels of flies and processes are checked at every system call that involves data flow and are adjusted dynamically to assure that labels on outputs reflect labels on inputs.
Assignment of independent tasks to minimize completion time
Authors: Blake Ben A. 
Published: November 2006

AbstractThe task of scheduling dynamic applications that consist of single process tasks on a non‐shared memory multicomputer is examined in this paper. Each task of the application is assumed to (1) require execution on a single processor, (2) have an estimate of its maximum execution time, and (3) not wait on communications with other tasks. The objective of the studied schedulers is to map an application's tasks onto the underlying hardware in such a way that the application's completion time is minimized. Experimental evaluation of the schedulers indicate that in many situations, a more sophisticated scheduler fails to outperform simpler schedulers.