bluuebunny/crossref_metadata_2025_split huggingface dataset:
A monitor tool for a network based on the cambridge ring
Authors: Vassiliades Synnove , Sayers Michael D. , Bacon Jean M. 
Published: November 2006

AbstractAn evolving network is subject to technological advances and increasing user demands through out its lifetime. Continuous monitoring is therefore required to understand its behaviour in the operational environment and to provide an aid to planning. A monitor tool has been developed to meet such requirements in a heavily used service network.A decentralized but integrated approach has been adopted. An active collection allows accumulated measurements to be retrieved. The measurements required are determined and the constraints imposed by existing mechanisms and the methods chosen are discussed.Flexible user facilities are available to allow selected measurements to be collected and displayed, and these are described.Daily sessions of network‐wide monitoring have been undertaken. The overhead incurred is quantified. The sessions revealed communications software errors and anomalous behaviour of a network node. Further analysis shows the symptoms of the latter, the result of a hardware fault.Enhancements which would increase the flexibility of the tool are also suggested.
Communications in meglos
Authors: Gaglianello Robert D. , Katseff Howard P. 
Published: November 2006

AbstractMeglos provides a user‐level, message‐based programming environment for a system of interconnected processors. It allows the simultaneous execution of a wide range of applications including real‐time control and large‐scale computations requiring the co‐operative work of many processors. The communications mechanisms in Meglos are designed to be easy to use and to provide high performance at the applications level. The communications primitives are based on symmetric, error‐resilient channels that are independently flow controlled. Two‐ended channels between pairs of co‐operating processes provide communications with low latency and high throughput. Multicast channels are used to send messages efficiently among a large group of processors in a single operation.
An experiment with the newcastle connection protocol
Authors: Snow C. R. , Whitfield H. 
Published: November 2006

AbstractAn experiment is described in which a set of Unix systems linked together into a Unix United system by means of the Newcastle Connection Protocol1 is also linked to a system with a dissimilar structure. It demonstrates that the Newcastle Connection technique can be used to connect together operating systems with differing structures and philosophies. The non‐Unix system, known as Nimrod, offers a set of services which can be mapped onto requests for service from standard user processes running on a remote Unix system. The services offered by Nimrod are restricted to those required for providing remote input and output to a terminal, but the results of the experiment suggest that increasing the range of services offered would be possible, despite the substantial differences in structure between Nimrod and Unix. Some of the problems associated with greater levels of inter‐system connection are also discussed.
A modular operating system for the cray‐1
Authors: Huskamp Jeffrey C. 
Published: November 2006

AbstractA new operating system for the CRAY‐1 supercomputer implements four types of objects that can be manipulated by user tasks. A directory object is used to implement a hierarchical directory structure, a file object stores random access data, a pipe object permits intertask communication and a process object is used to execute user programs. The advantages of implementing a restricted number of object types in the kernel and the lessons learned from developing a supercomputer operating system from scratch are discussed.
The ilem project: Pascal to algol in easy stages. I: Outward bound
Authors: Walker A. N. 
Published: November 2006

AbstractMost academic institutions have Pascal compilers coming out of their ears. Most academic institutions have Algol compilers only on their dinosaur mainframes. The Ilem project consists of designing a sequence of intermediate languages, IL0, IL1, IL2, …, ILN–1, ILN, where IL0 is Pascal and ILN is Algol, and where any two consecutive languages differ so little that a one‐man spare‐time project suffices to convert a compiler for one language into a compiler for the next.
Joyce—A programming language for distributed systems
Authors: Hansen Per Brinch 
Published: November 2006

AbstractThis paper describes a secure programming language called Joyce based on CSP and Pascal. Joyce permits unbounded (recursive) activation of communicating agents. The agents exchange messages through synchronous channels. A channel can transfer messages of different types between two or more agents. A compiler can check message types and ensure that agents use disjoint sets of variables only. The use of Joyce is illustrated by a variety of examples.
Parsing ambiguous addresses for electronic services
Authors: Honeyman Peter , Parseghian Patricia E. 
Published: November 2006

AbstractPathparse is a tool with a practical approach to disambiguating problematic routes for services such as electronic mail. Pathparse resolves syntactic and host name ambiguities with the aid of a database that describes host connections. The parser generates a set of path/user pairs; heuristics are used to select one among these, which may then be used by a conventional mail handler.
An integrated data dictionary to facilitate automatic report generation in a network database
Authors: Lirov Yuval , Daunov Nissim 
Published: November 2006

AbstractAn integrated data dictionary (IDD) is defined to contain data definitions and their applications descriptions. An IDD which includes report descriptions may be used as an input data structure for the automatic constructor of report generators (ACORG) in any data manipulation language. ACORG may be programmed in an elegant way using recursive techniques.
Real‐time interrupt handling in Ada
Authors: Rasmussen Jørgen Born , Appelbe Bill 
Published: November 2006

AbstractThe Ada† programming language defines the semantics of interrupt handling as part of the tasking mechanism, making it possible to construct implementation‐independent interrupt handlers. However, for the Ada mechanism to be effective, an implementation must provide support not specified by the Ada standard, such as for initializing hardware interrupting devices, handling unexpected interrupts and optimizing for real‐time performance constraints. This paper analyses some of the constraints that efficient interrupt support places on an implementation. It develops a model for the interaction between interrupt hardware and Ada tasks and describes optimizations for Ada interrupt handlers. Implementation issues, including task priorities and task termination for interrupt handlers, are discussed in detail.
Microprocessor debugging techniques and their application in debugger design
Authors: Gondzio Marek 
Published: November 2006

AbstractEvery microprocessor‐based system needs powerful debugging tools. Debugging power strongly depends on a mechanism of control exchange between the debugger and an application program. Several implementation methods of such a mechanism are briefly described and compared in this paper. It is shown that conditional breakpoints facilitate a semantics‐oriented approach to program debugging. Some debugging techniques derived from elementary control‐exchange mechanisms are proposed. Most of the techniques discussed are implemented in the MD‐86 debugger designed for the Intel 8086 microprocessor. The debugger itself is also briefly described.
AIDA–A dynamic data flow anomaly detection system for pascal programs
Authors: Chan Fun Ting , Chen Tsong Yueh 
Published: November 2006

AbstractThis paper presents a description of, and experience in using, AIDA, an automated instrumentation system to perform data flow analysis for Pascal programs. AIDA is capable of detecting not only data flow anomalies, but also certain kinds of errors. It is a useful software testing and development tool for Pascal programs. The associated implementation problems and their solutions are presented.
Strongly typed user interfaces in an abstract data store
Authors: Powell M. S. 
Published: November 2006

AbstractThe UMIST Abstract Data Store is a software tool which supports abstract data types together with flexible mechanisms for specifying, for each abstract data type, alternative user interface and memory representations appropriate to different physical media. These mechanisms facilitate the definition of types, the specification of their alternative representations and the creation and manipulation of their values in a persistent fashion. The media supported may include such things as disks and visual displays and collections of these connected together via a network. This paper focuses on the mechanisms which have evolved in this environment for specifying safe user interfaces to complex data structures.
Experience acquiring and retargeting a portable Ada compiler
Authors: Ardö Anders 
Published: November 2006

AbstractA technique for implementing Ada with reasonable effort on a piece of non‐standard hardware is described. The target machine is a single processing element in an experimental multiprocessor based on NS32000. A portable Ada front‐end compiler was used for retargeting, and the process of acquiring and evaluating the front end is described. Based on this experience, comments on the validation, quality and efficiency of Ada compilers are given, along with a detailed overview of the resultant system. The Ada system was built from scratch on the bare hardware. It has three main components: a code generator, a run‐time system and an Ada kernel. The code generator is table driven and generates symbolic NS32000 assembler. This code is then assembled and linked by commercially available components. The run‐time system and the kernel are implemented in assembly language and Concurrent Euclid and handle tasking, exceptions and scheduling. The result is a complete Ada implementation.
A prolog implementation of an instruction‐level processor simulator
Authors: Pashtan Ariel 
Published: November 2006

AbstractThis paper describes the implementation of a Prolog‐based, instruction‐level simulator used in the design of a new processor. The adaptability of Prolog as a hardware description language is reported. Prolog was a good choice for purposes of rapid prototyping and as a means to derive high‐level executable specifications for the instruction set. The rapid software development strategy entailed a price to be paid in the form of a relatively slow performance. Methods to improve the speed of Prolog‐based simulators are suggested.
Mkscan—An interactive scanner generator
Authors: Horspool R. Nigel , Levy Michael R. 
Published: November 2006

AbstractMkscan is a tool for generating and editing scanners. It has been designed with ease of use in mind. The tol is interactive and uses a full screen interface. No attempt is made to provide an all‐purpose tool that can generate a recognizer for any regular language. Instead, mkscan has been tailored to suit the lexical structure of common programming languages and command languages. Using mkscan, a scanner for Pascal can be created in under ten minutes–including the time taken to type the list of keywords.
A method for interconnecting heterogeneous computer networks
Authors: Cole Robert 
Published: November 2006

AbstractThe real problems of network interconnection lie in the management of heterogeneity. The heterogeneity is not confined to the mechanical protocols but to much wider issues such as service philosophy (connection‐orientated vs connectionless), addressing, routing, applications models, management facilities and the foresight of the network designers in allowing for interconnection with alien networking systems.This paper describes a system which interconnects two heterogeneous networking environments through a third (local) system. Application layer relaying was chosen to provide the services of computer mail and remote terminal access. The interconnection architecture uses special network front‐ends and a local area network to provide a flexible and manageable system. A transport service interface is used to provide functional separation between the front‐ends and general purpose computers, including the relays.
Hashing as a compaction technique for parser tables
Authors: Horspool R. N. , Cormack G. V. 
Published: November 2006

AbstractAuthors of papers on LR parser table compaction and authors of books on compiler construction appear to have either overlooked or discounted the possibility of using hashing. In fact, hashing is easy to implement as a compaction technique and gives reasonable performance. It produces tables that are as compact as some of the other techniques reported in the literature while permitting efficient table lookups.
The design and use of a prolog trace generator for CSP
Authors: Kourie D. G. 
Published: November 2006

AbstractThe role of traces in the context of formal description techniques is discussed, as well as issues arising in the generation of these traces by means of software. A trace generator (written in Prolog) for systems described in terms of CSP is outlined, with emphasis on the translation from CSP to Prolog, the central implementation issues in a Prolog context, and techniques for generating all traces up to termination or recursion. Some experiences with the use of the generator are mentioned, and potential extensions for generating traces of LOTOS descriptions are mentioned.
Dynamic compilation in the unix environment
Authors: Crowe M. K. 
Published: November 2006

AbstractA system for dynamic compilation under the Unix operating system is described. The basis of the system is an incremental assembler that can be used statically or during program execution to insert or replace a module in an executable image. All cross‐module references are via offets into a run‐time symbol table. All generated code is independent of its location or the location of the symbol table. The symbol table and all modules reside in memory segments compatible with the memory allocator malloc(). The symbol table origin is maintained in a processor register. Library procedures allow the assembler (or C compiler) to be called to alter the currently executing program, or to place a stub function which acts as a trap, so that when the stub is invoked it caues a file to be dynamically compiled into the executing program to replace the stub with a bona fide procedure. This facilitates the construction of advanced interactive environments using native code. Some example applications, to Prolog and to incremental compilation, are considered.
Music—A language for typesetting music scores
Authors: Foxley Eric 
Published: November 2006

AbstractThis paper describes a language which has been devised to facilitate the inclusion of printed music in the output of a typesetting system. The music program acts as a preprocessor to troff, which is the typesetting program associated with the UNIX system. The design of the music input language has concentrated on the simplicity of the process of transcribing and typing in data from a standard music score, yet still allowing some of the complex requirements of serious music scores to be handled.
Formal specification of an access control system
Authors: Stepney Susan , Lord Stephen P. 
Published: November 2006

AbstractComputing facilities networked together but controlled by different administrations pose a problem of access control. Who decides who can use what?We specify a formal model for an access control system which allows users and services from different administrations to communicate with each other, while still allowing the administrators to retain control of their own parts of the network. The model, written in the Z specification language, has been developed as the access control system for ADMIRAL, though it is not specific to ADMIRAL. It provides a framework for administrators to build access control systems to meet their differing requirements.A system based on the model would allow users to log in to a distributed computing system and to make requests for services in any part of the system, without having to provide any more information about themselves. After this initial log in all subsequent access control decisions are handled automatically, and remain invisible to the user unless access is refused.öWe also discuss the experience we have had animating this model in Prolog.
A processing algorithm for master—detail records in a relational database
Authors: Bullers William I. 
Published: November 2006

AbstractLarge numbers of data processing applications require processing of master records and their associated detail records. These relationships between master and detail files may be classified as one‐to‐many, zero‐or‐one‐to‐many and many‐to‐many. All are important to information systems, but database management system implementations differ widely in their ability to represent and process such relationships. Processing of zero‐or‐one‐to‐many relationships, in particular, is difficult in most relational databases. An obscure relational algebra operator, left outer join, that provides such a capability is described and its importance to master‐detail processing is illustrated. An implementation of left outer join is presented for dBase III, a database management system providing some relational‐like capability.
GCI—A tool for developing interactive cad user interfaces
Authors: Gudes Ehud , Bracha Gilad 
Published: November 2006

AbstractGCI is a Unix‐based tool for developing interactive CAD programs. By separating command/ menu definitions from the progam, GCI makes it easier to change and extend the user interface. The language provided by GCI is used to define the syntax of commands, menus, messages, and help text. Generally, GCI supports a static hierarchical structure of commands and menus. However, through a program interface, an application program has the freedom to change environments, commands and menus. This flexibility of run‐time control of the user interface is essential for developing highly responsive interfaces in a CAD environment.This paper presents the main concepts and definition language of GCI. It then discusses architectural and implementation issues, and finally presents a typical application's view of using the tool.
Automatic inference and fast interpretation of peephole optimization rules†
Authors: Davidson Jack W. , Fraser Christopher W. 
Published: November 2006

AbstractPeephole optimizers that are driven by machine descriptions are generally more thorough but less efficient than their classical rule‐directed counterparts. This paper describes a system that addresses this shortcoming. It automatically infers rules by tracking the behaviour of a description‐directed optimizer on a testbed, and it adapts a classical optimizer to interpret these rules efficiently. Experiments show that an easily constructed testbed can generate rules similar to those in a large hand‐written rulebase. This software forms part of a compiler that simplifies retargeting by substituting peephole optimization for case analysis.
The text editor sam
Authors: Pike Rob 
Published: November 2006

AbstractSam is an interactive multi‐file text editor intended for bitmap displays. A textual command language supplements the mouse‐driven, cut‐and‐paste interface to make complex or repetitive editing tasks easy to specify. The language is characterized by the composition of regular expressions to describe the structure of the text being modified. The treatment of files as a database, with changes logged as atomic transactions, guides the implementation and makes a general ‘undo’ mechanism straightforward.Sam is implemented as two processes connected by a low‐bandwidth stream, one process handling the display and the other the editing algorithms. Therefore it can run with the display process in a bitmap terminal and the editor on a local host, with both processes on a bitmap‐equipped host, or with the display process in the terminal and the editor in a remote host. By suppressing the display process, it can even run without a bitmap terminal.
A real‐time messaging system for token ring networks
Authors: Weaver Alfred C. , Colvin M. Alex 
Published: November 2006

AbstractThe Computer Networks Laboratory at the University of Virginia has developed a real‐time messaging service that runs on IBM PCs and PC/ATs when interconnected with a Proteon ProNET‐10 token ring local area network. The system is a prototype for a real‐time communications network to be used aboard ships. The system conforms to the IEEE 802.2 logical link control standard for type I (connectionless, or datagram) service, with an option for acknowledged datagrams.The application environment required substantial network throughput and bounded message delay. Thus, the development philosophy was to emphasize performance initially and to offer only primitive user services. After providing and measuring the performance of a basic datagram service, the intent is to add additional user services one at a time and to retain only those which the user can ‘afford’ in terms of their impact on throughput, delay, and CPU utilization.The current system is programmed in C. The user interface is a set of C procedure calls that initialize tables, reserve buffer space, send and receive messages, and report network status. The system is now operational, and initial performance measurements are complete. Using this system, an individual PC can transmit or receive approximately 200 short (about 100 bytes) messages per second, and the PC/AT operates at nearly 500 short messages per second.
An object‐oriented class library for C++ programs
Authors: Gorlen Keith E. 
Published: November 2006

AbstractThe Object‐Oriented Program Support (OOPS) class library is a portable collection of classes similar to those of Smalltalk‐80 that has been developed using the C++ programming language under the UNIX operating system. The OOPS library includes generally useful data types, such as String, Date and Time, and most of the Smalltalk‐80 collection classes such as OrderedCtn (indexed arrays), LinkedList (singly linked lists), Set (hash tables), and Dictionary (associative arrays). Arbitrarily complex data structures comprised of OOPS and user‐defined objects can be stored on disk files or moved between UNIX processes by means of an object I/O facility. The classes Process, Scheduler, Semaphore and SharedQueue provide multiprogramming with coroutines. This paper gives a brief introduction to object‐oriented programming and how it is supported by the C+ + programming language. An overview of the OOPS library is also presented, followed by a programming example. The implementation details of two of the class library's more interesting features, object I/O and processes, are described. The paper concludes with a discussion of the differences between the OOPS library and Smalltalk‐80 and some observations based on our programming experience with C++ and OOPS.
A file replication facility for berkeley unix
Authors: Purdin Titus D. M. , Schlichting Richard D. , Andrews Gregory R. 
Published: November 2006

AbstractThis paper describes two mechanisms – reproduction sets and metafiles – that provide low‐cost, semi‐automatic file replication and location transparency facilities for an interconnected collection of machines running Berkeley Unix. A reproduction set is a collection of files that the system attempts to keep identical; this is done on a ‘best effort’ basis, with the system relying on the user to handle unusual situations. A metafile is a special file that contains symbolic pathnames of other files, each of which may be on any machine in the network; opening a metafile results in opening an available constituent file. Examples are given to illustrate the use of these mechanisms. Their implementation and performance are also described.