bluuebunny/crossref_metadata_2025_split huggingface dataset:
Mirage+: A kernel implementation of distributed shared memory on a network of personal computers
Authors: Fleisch Brett D. , Hyde Randall L. , Juul Niels Christian 
Published: November 2006

AbstractWe describe the evolution of a distributed shared memory (DSM) system, Mirage, and the difficulties encountered when moving the system from a Unix‐based* kernel on the VAX to a Unix‐based kernel on personal computers. Mirage provides a network transparent form of shared memory for a loosely coupled environment. The system hides network boundaries for processes that are accessing shared memory and is upward compatible with the Unix System V Interface Definition.This paper addresses the architectural dependencies in the design of the system and evaluates performance of the implementation. The new version, MIRAGE+, performs well compared to Mirage even though eight times the amount of data is sent on each page fault because of the larger page size used in the implementation. We show that performance of systems with a large page size to network packet size can be dramatically improved on conventional hardware by applying three well‐known techniques: packet blasting, compression, and running at interrupt level.The measured time for a page fault in MIRAGE+ has been reduced 37 per cent by sending a page using packet blasting instead of using a handshake for each portion of the page. When compression was added to MIRAGE+, the time to fault a page across the network was further improved by 47 per cent when the page was compressed into one network packet. Our measured performance compares favorably with the amount of time it takes to fault a page from disk. Lastly, running at interrupt level may improve performance 16 per cent when faulting pages without compression.
A database of groups of prime‐power order
Authors: Butler G. , Iyer S. S. , O'brien E. A. 
Published: November 2006

AbstractThe design, implementation and performance of TwoGroups, a deductive database for the 58,761 groups of order 2n, (n ≤ 8), is described. The system is implemented in NU‐Prolog, a Prolog system with built‐in functions for creating and using deductive databases. TwoGroups has a set‐theoretic query language, which provides users with a familiar notation to access the data. The paper describes the data and its representation, the set‐theoretic query language, its translator and optimiser, and the experiments on the performance of the database.
Techniques for file system simulation
Authors: Thekkath Chandramohan A. , Wilkes John , Lazowska Edward D. 
Published: November 2006

AbstractCareful simulation‐based evaluation plays an important role in the design of file and disk systems. We describe here a particular approach to such evaluations that combines techniques in workload synthesis, file system modeling, and detailed disk behavior modeling. Together, these make feasible the detailed simulation of I/O hardware and file system software. In particular, using the techniques described here is likely to make comparative file system studies more accurate.In addition to these specific contributions, the paper makes two broader points. First, it argues that detailed models are appropriate and necessary in many cases. Second, it demonstrates that detailed models need not be difficult or time consuming to construct or execute.
Efficient binary transfer of pointer structures
Authors: Toyn Ian , Dix Alan J. 
Published: November 2006

AbstractThis paper presents a pair of algorithms for output and input of pointer structures in binary format. Both algorithms operate in linear space and time. They have been inspired by copying garbage collection algorithms, and make similar assumptions about the representations of pointer structures.In real programs, the transfer of entire pointer structures is often inappropriate. The algorithms are extended to transfer partitions of a pointer structure lazily: the receiver requests partitions when it needs them.A remote procedure call mechanism is presented that uses the binary transfer algorithms for communicating arguments and results. A use of this as an enabling mechanism in the implementation of a software engineering environment is discussed.
Design and implementation of national engineering education delivery system (NEEDS)
Authors: Schmitz Daniel C. , Wong Johnny S. , Nelson Ron M. 
Published: November 2006

AbstractEducational course material is constantly being developed by professors. More and more of this course material is now on computers. It is often desirable for this material to be available through computer networks to the widest possible audience. Given a general audience, this access should be quick and simple. The National Engineering Delivery System (NEEDS) is a new courseware development and distributed system which allows faculty, students, industry and other users to easily access a large number of diverse courseware modules in an effective and efficient manner. This paper documents the design and implementation of a system that may make this idea a reality. The work includes the development of databases used to store course material information, the design of an efficient communication networking protocol for delivering courseware modules, and the development of user front‐ends for general access to the course material stored in the databases.
A comparison of object‐oriented programming in four modern languages
Authors: Henderson Robert , Zorn Benjamin 
Published: November 2006

AbstractObject‐oriented programming has become a widely used, important programming paradigm that is supported in many different languages. C++ has become the most widely used object‐oriented language and many C++ programmers are unfamiliar with the different approaches taken by other languages in the paradigm. This paper is intended as an introduction to a broad range of ideas in object‐oriented programming. Specifically, we introduce four modern programming languages that support object‐oriented programming (Oberon‐2, Modula‐3, Sather and Self), and show how a simple application is coded in these languages. While each of these programming languages provide support for inheritance, dynamic dispatch, code reuse, and information hiding, they do so in very different ways and with varying levels of efficiency and simplicity. The use of a simple example, based on a common programming problem, facilitates our comparison. We have coded the application in all of these languages, including C++, and we compare the compile times, object code sizes, and run times of the available implementations. Implementations of all the languages compared and all of the programs we measure are available on the Internet. Ultimately, our goal is to encourage and facilitate programmers in understanding and exploring a variety of object‐oriented programming languages.
Kitrace: Precise interactive measurement of operating systems kernels
Authors: Kuenning Geoffrey H. 
Published: November 2006

AbstractKitrace is a software tool that allows dynamic interactive measurement of UNIX kernel performance to much greater precision than that available from kernel profiling. Developers can measure, to microsecond resolution, the time required by a complex kernel activity, including time spent waiting for I/O activity or user processes. Kitrace has also proven useful for debugging, especially in situations where traditional breakpointing would be undesirable or would change the behavior of the kernel.
A requirements capture method and its use in an air traffic control application
Authors: McCluskey T. L. , Porteous J. M. , Naik Y. , Taylor C. N. , Jones S. 
Published: November 2006

AbstractThis paper describes our experience in capturing, using a formal specification language, a model of the knowledge‐intensive domain of oceanic air traffic control. This model is intended to form part of the requirements specification for a decision support system for air traffic controllers. We give an overview of the methods we used in analysing the scope of the domain, choosing an appropriate formalism, developing a domain model, and validating the model in various ways. Central to the method was the development of a formal requirements engineering environment which provided automated tools for model validation and maintenance.
Statistical testing of software based on a usage model
Authors: Walton Gwendolyn H. , Poore J. H. , Trammell Carmen J. 
Published: November 2006

AbstractIn statistical testing, a model is developed to characterize the population of uses of the software, and the model is used to generate a statistically correct sample of all uses of the software. A software ‘usage model’ characterizes the population of intended uses of the software in the intended environment. Statistical testing based on a software usage model ensures that the failures that will occur most frequently in operational use will be found early in the testing cycle. The usage model is based on the software specification. The model can be developed in parallel with the software, thus shortening the elapsed time required to develop the deliver software.Usage modeling has been demonstrated to be an activity that improves the specification, gives an analytical description of the specification, quantifies the testing costs and, with statistical testing, provides a basis from which inferences of software reliability may be made. This paper describes the justification for statistical testing of software using a usage model, describes procedures for developing and using a usage model and discusses several usage modeling issues and recent advances in usage model applications.
Design and implementation aspects of an experimental C++ programming environment
Authors: Sametinger J. , Schiffer S. 
Published: November 2006

AbstractA good programming language alone is not sufficient for economic software production. The programming environment has a significant influence on the productivity of software engineers. Providing a programmer with information about an object‐oriented software system requires extracting information from the source code, e.g. class, method and variable names. We use separate structure files for holding this information and take advantage of proven tools such as make and the C preprocessor for keeping the structure files up to date and for processing software systems that heavily use macros.In this paper we describe the concepts used for comfortable processing of C++ software systems, and discuss interesting design and implementation aspects, including structure files, the applied make mechanism and the exploitation of the C preprocessor.
Efficient implementation of suffix trees
Authors: Andersson Arne , Nilsson Stefan 
Published: November 2006

AbstractWe study the problem of string searching using the traditional approach of storing all unique substrings of the text in a suffix tree. The methods of path compression, level compression and data compression are combined to build a simple, compact and efficient implementation of a suffix tree. Based on a comparative discussion and extensive experiments, we argue that our new data structure is superior to previous methods in many practical situations.
Improving the output of the FORTRAN to C translator, f2c
Authors: Levy G. F. 
Published: November 2006

AbstractThe popularity of C as a computer language has meant that many Fortran 77 programs have been translated into C. Although automatic translation from Fortran 77 to C can be accomplished using the tool f2c, the generated C code is not easy to read and maintain. This article describes a set of tools developed at NAG Ltd for the automatic polishing of f2c generated C code.
An implementation of storage management in capability environments
Authors: Corsini Paolo , Lopriore Lanfranco 
Published: November 2006

AbstractThe exploitation of the salient features of capability‐based addressing environments leads to a high number of small objects existing in memory at the same time. It is thus necessary to enhance the efficiency of the mechanisms for object relocation, and to avoid congestion of input/output devices due to swapping. In this paper, we present an approach to the management of a large virtual memory space aimed at solving these problems. We insert partial information concerning the physical allocation of each object into the virtual identifier of this object. Objects are grouped into large swapping units, called pages. The page size is independent of the average object size. This results in enhanced efficiency in managing the relocation information both with regard to memory requirements and access times. The allocation of objects into pages, and the movement of pages through the memory hierarchy, are controlled by user processes. This means that programs which have knowledge of their own use of virtual memory can increase their locality of reference, diminish the number of swap operations and reduce fragmentation.
Myriad: Design and implementation of a federated database prototype
Authors: Lim Ee‐Peng , Hwang San‐Yih , Srivastava Jaideep , Clements Dave , Ganesh M. 
Published: November 2006

AbstractA key problem in providing ‘enterprise‐wide’ information is the integration of databases that have been independently developed. An important requirement is to accommodate heterogeneity and maintain the autonomy of component databases. Myriad is a federated database prototype developed at the University of Minnesota, to provide a testbed for investigating alternatives in architecture and algorithms for database integration, query processing and optimization, and concurrency control and recovery. The system incorporates our group's research results in these areas. This paper describes our experiences in the design and implementation of Myriad, and in the project management. Special emphasis is given to discussing design alternatives and their impact on Myriad. This paper also presents the software engineering principles and the project management techniques we used in developing Myriad and the lessons we learned. We believe these lessons would be useful for practitioners who wish to develop a similar system.Handling heterogeneity and autonomy were prime objectives throughout the prototyping effort. We are convinced that a prototype federated database is an important infrastructural requirement for the overall goal of ‘enterprise‐integration’, and believe Myriad to be a significant contribution towards this.
Parc++: A parallel C++
Authors: Tödter Kai , Hammer Carsten , Struckmann Werner 
Published: November 2006

AbstractPARC++ is a system that supports object‐oriented parallel programming in C++. PARC++ provides the user with a set of predefined C++ classes that can easily be used for the construction of parallel C++ programs. With the help of PARC++ objects, the programmer is able to create and start new processes (threads), to synchronize their activities (Blocklock, Monitor) and to manage communication via message passing (Mailbox). PARC++ is written in C++ and currently runs on top of the EMEX operating system on a FORCE machine with 11 processing elements and an EDS (European Declarative System) with 28 processing elements. The paper also contains information about the run‐time system model, the implementation and some performance measurements.
Comparison of syntactic error handling in LR parsers
Authors: Degano Pierpaolo , Priami Corrado 
Published: November 2006

AbstractError recovery techniques for LR parsers presented in the literature are described and classified. The techniques considered range from the non‐correcting ones to interactive and incremental ones. Also, some of the techniques presented are compared and evaluated. An example showing the advantages and the disadvantages of each class of strategies is given and is used as a guideline for classifying syntax errors according to the recovery strategies which are more adequate to correct them.
Experiences of parallelising finite‐element problems in a functional style
Authors: Grant P. W. , Sharp J. A. , Webster M. F. , Zhang X. 
Published: November 2006

AbstractExperiences are described of parallelizing a functional finite‐element program (written in Haskell) for the solution of computational fluid‐dynamics problems. A transformation prototyping approach using a system developed at the University of York, which simulates idealised parallel machines on a conventional sequential workstation, is presented. In this paper we demonstrate: (a) the relative simplicity of the functional approach for parallelizing a complex program compared with the conventional procedural approach; (b) the suitability of functional languages for prototyping parallel algorithms to improve an implementation; and (c) the considerable assistance provided by the simulator.
Type inference of SELF: Analysis of objects with dynamic and multiple inheritance
Authors: Agesen Ole , Palsberg Jens , Schwartzbach Michael I. 
Published: November 2006

AbstractWe have designed and implemented a type inference algorithm for the SELF language. The algorithm can guarantee the safety and disambiguity of message sends, and provide useful information for browsers and optimizing compilers.SELF features objects with dynamic inheritance. This construct has until now been considered incompatible with type inference because it allows the inheritance graph to change dynamically. Our algorithm handles this by deriving and solving type constraints that simultaneously define supersets of both the possible values of expressions and of the possible inheritance graphs. The apparent circularity is resolved by computing a global fixed‐point, in polynomial time.The algorithm has been implemented and can successfully handle the SELF benchmark programs, which exist in the ‘standard SELF world’ of more than 40,000 lines of code.
Using conditional execution to exploit instruction level concurrency
Authors: Adams Rod , Gray Sue 
Published: November 2006

AbstractMultiple‐instruction‐issue processors seek to improve performance over scalar RISC processors by providing multiple pipelined functional units in order to fetch, decode and execute several instructions per cycle. The process of identifying instructions which can be executed in parallel and distributing them between the available functional units is referred to as instruction scheduling. This paper describes a simple compile‐time scheduling technique, called conditional compaction, which uses the concept of conditional execution to move instructions across basic block boundaries. It then presents the results of an investigation into the performance of the scheduling technique using C benchmark programs scheduled for machines with different functional unit configurations. This paper represents the culmination of our investigation into how much performance improvement can be obtained using conditional execution as the sole scheduling technique.
Interactive hypermedia applications: A model and its implementation
Authors: Wang H. K. , Wu Jean‐Lien C. 
Published: November 2006

AbstractBy referring to the object‐oriented efforts of the Multimedia and Hypermedia information coding Expert Group (MHEG), and the augmented Petri net model, we present a formal definition of the multimedia hypermedia Petri net (MHPN) model. Through this proposed model, issues of authoring, rendering and synchronization of multimedia information (i.e. structure authoring, spatial temporal relationships, user interaction, etc.) can all be laid to rest. We have implemented a testbed system, the Petri net object information system (POIS), which offers considerable potential for the development of distributed hypermedia applications. The testbed has been implemented on an IBM‐PC486 under Windows 3.1. We are now in the process of porting the testbed model to Windows NT.
Object‐oriented specification of user interfaces
Authors: Jaaksi Ari 
Published: November 2006

AbstractThis paper presents an object‐oriented approach for the specification of graphical user interfaces. Specification starts with the analysis of the end user's operations. The user interface is then designed on the basis of this analysis. Operation analysis is followed by structure and component specification which presents the dialogue structure of the application and the contents of each dialogue. Visualization produces the final screen layouts, and task specification documents the usage of the user interface for the purpose of creating user's guides.The method presented in this paper makes it easier for a designer to take the end user's needs into account. Still, it does not automatically guarantee good quality user interfaces. The top‐down nature of the method allows the designer to concentrate on the most important aspects of the user interface and split the design procedure into manageable pieces. Also, the visibility of the process allows the designer to communicate with other people while specifying the user interface.This paper connects the method with the object‐oriented specification of entire applications. It briefly explains the connections with object‐oriented analysis and design, and demonstrates how to implement the specified user interface in an object oriented fashion. The approach presented in this paper is being applied in the development of a large network management system with about two million lines of C++ code running in the XII environment. Still, the method does not require the specification being implemented with any specific windowing system. The only requirement is that the user interface is based on graphical elements, such as dialogues, push‐buttons and text fields.
Design and implementation of heterogeneous distributed multimedia system using mosaic GSQL
Authors: Magavi Sunil , Wong Johnny , Bodla Prakash 
Published: November 2006

AbstractWith more and more computer users having access to the Internet, it is important for them to access the vast amount of information in an efficient and easy manner. This project explores one of the possibilities for providing an integrated system to the user to access the different types of media like text, image, audio and video stored in different databases on remote machines without the user having to know about the underlying mechanism involved in accessing the database. Such a system must hide the location of the remote data, retrieve the information, process the results and present it to the user. We have used the National Center for Supercomputer Applications (NCSA) Mosaic's Gateway Structured Query Language (GSQL), which enables a system developer to build input forms, query to the remote database in a relatively easy manner and present the results to the user. With the help of this prototype, the development time to build such an application is considerably reduced as compared with developing the same application using the existing Graphical User Interface (GUI) tools like the X‐Window system.
Experience with logical code analysis in software maintenance
Authors: Hart Johnson M. 
Published: November 2006

AbstractFormal program specification and logical analysis are often used for program derivation and proofs of correctness. The basic tools include the logic of predicate calculus and Dijkstra's weakest precondition calculations. Recent work has shown that these tools are also very useful in the maintenance phase of the software life‐cycle. This paper reports experience working with software maintenance teams to apply formal methods. Formal logical analysis is invaluable for isolating defects, determining code corrections, eliminating side‐effects, and code re‐engineering. Logical analysis works well in software maintenance because many defects can be isolated to small segments of code. These small segments can then be analyzed manually or with code analysis tools. The result is lowered software maintenance costs due to the benefits of defect prevention, reduction of code complexity metrics, productivity improvements, and better specifications and documentation. It would be beneficial to use logical code analysis in the earlier phases of the software life‐cycle, such as quality assurance and inspection.