bluuebunny/crossref_metadata_2025_split huggingface dataset:
Modular design for simulation
Authors: Sharma Ravi , Rose Lawrence L. 
Published: November 2006

AbstractThis paper presents a modular design approach for the implementation of process‐oriented or event‐oriented discrete systems simulation software. Requirements for such a simulation facility are discussed, to include list processing capabilities, data structuring capabilities, dynamic allocation of data storage, statistics collection and number‐crunching capabilities, and subprograms. Specific focus is placed upon implementing the process view which requires constructs in the language for initiating, controlling and terminating a process. Resource management facilities are also considered, to include a means of defining a resource with its associated resource handler and a set of primitives for requesting, releasing and obtaining status information regarding a resource.HPSIM, an organized collection of modules written in Modula‐2, was designed to facilitate both event‐oriented and process‐oriented discrete systems simulation, Modula‐2 was chosen for its data abstraction facilities, its software engineering capabilities, its execution efficiency, its ability for separate compilation and its implementation of co‐routines. The modeller encapsulates the conceptual model of the system into a software module which is interfaced with the HPSIM modules. The IMPORT statement in Modula‐2 allows the modeller to access any of the routines provided by HPSIM as required. An example involving a single‐server CPU system highlights the process/resource features of HPSIM.
Derivation of local software quality metrics (software quality circles)
Authors: Poore J. H. 
Published: November 2006

AbstractSoftware is a product in serious need of quality control technology. Major effort notwithstanding, software engineering has produced few metrics for aspects of software quality that have the potential of being universally applicable. The present paper suggests that, although universal metrics are elusive, metrics that are applicable and useful in a fully defined setting are readily available. A theory is presented that a well‐defined software work group can articulate their operational concept of quality and derive useful metrics for that concept and their environment.
On a formal definition and application of dimensional design
Authors: Bertran‐Salvans Miquel 
Published: November 2006

AbstractDimensional design (DD) is a simple, practical and systematic layout technique for the display of programs, specifications, expressions, etc. for application in the general area of software. Formalizations of DD are introduced, the main one being algebraic, and the usage of DD in real software projects is outlined; one of them corresponds to a software system for the telecontrol centre of a power network.The formal definitions of DD which are presented arise during the design of a syntax‐driven editor generator for languages whose ‘phrases’ are DDs. Grammars for the definition of such languages are introduced in the paper. The varied usage of DD within the generator design is examined: grammatical, functional and algebraic notations in particular are considered. The samples of these DD representations that are given illustrate the enhancement of readability achieved, and illustrate the suitability of DD for use in the specification area in general.
A tale of two greps
Authors: Hume Andrew 
Published: November 2006

AbstractText searching programs such as the UNIX system tools grep and egrep require more than just good algorithms; they need to make efficient use of system resources such as I/O. I describe improving the I/O management in grep and egrep by using a new fast I/O library fio to replace the normal I/O library stdio. I also describe incorporating the Boyer‐Moore algorithm into egrep; egrep is now typically 8–10 (for some common patterns 30–40) times faster than grep.
The active deallocation of objects in object‐oriented systems
Authors: Atkins Martin C. , Nackman Lee R. 
Published: November 2006

AbstractIn object‐oriented systems, it is oftern useful for objects to be allowed to carry out some action before they are deallocated. This can be done by defining a destroy method in the object's class, and arranging for the memory system to send a message invoking this method immediately before deallocating the object. This allows resources associated with the object to be returned to the system, limited cross‐language garbage collection, and other, more complex, behaviour. During the execution of the destroy method it is possible for new references to objects to be created. Care must be taken that the garbage collection does not erroneously free such objects. Algorithms are presented to implement destroy methods in systems using reference counting and mark‐scan garbage collection techniques. Properties that are desirable in such systems are also discussed.
K6 — a protected mode kernel for the iAPX286
Authors: le Riche P. J. 
Published: November 2006

AbstractThis paper presents the design of an operating system kernel offering protection, and using the object model as the design methodology. Rich communication facilities are provided between domains of protection allowing stimuli, data and objects to be passed. All object types, including protection domains, may be created and deleted dynamically, and some may be ‘sealed’ and employed as user‐defined objects by a type manager which alone can penetrate them.
Program generation for Ada — a case study
Authors: Allen Pat , Burns Alan 
Published: November 2006

AbstractProgram generation software is increasingly being used, not only to assist non‐computer professionals to produce their own applications, but also to provide tools for programmers and designers. As part of the toolkit for an Ada dialogue development system, a program generator has been written in Ada to generate the package which codes the dialogue manager for a specified user interface. The input specifications and the method of generation are described. The advantages and disadvantages of Ada as the implementation, target and specification language are discussed.
Elastic memory: Buddy systems interface
Authors: Challab D. J. 
Published: November 2006

AbstractTo implement single‐ended flexible arrays (‘elastic memory’) a class of underlying dynamic storage allocation methods called buddy systems may be used to allocate fixed blocks of memory of restricted choices of size. Arrays are implemented in one approach as contiguous blocks of memory and in another as two‐level structures. Each approach is combined with three buddy methods for allocating blocks of memory, making six methods in all. This paper illustrates the general ideas of implementing elastic memory mechanisms in terms of the buddy system interface.
Concurrent C++: Concurrent programming with class(es)
Authors: Gehani N. H. , Roome W. D. 
Published: November 2006

AbstractC++ and Concurrent C are both upward‐compatible supersets of C that provide data abstraction and parallel programming facilities, respectively. Although data abstraction facilities are important for writing concurrent programs, we did not provide data abstraction facilities in Concurrent C because we did not want to duplicate the C++ research effort. Instead, we decided that we would eventually integrate C++ and Concurrent C facilities to produce a language with both data abstraction and parallel programming facilities, namely, Concurrent C++. Data abstraction and parallel programming facilities are orthogonal. Despite this, the merger of Concurrent C and C++ raised several integration issues.In this paper, we will give introductions to C++ and Concurrent C, give two examples illustrating the advantages of using data abstraction facilities in concurrent programs, and discuss issues in integrating C++ and Concurrent C to produce Concurrent C++.
A debugger for parallel processes
Authors: Griffin James H. , Wasserman Harvey J. , McGavran Lauren P. 
Published: November 2006

AbstractA system for analysing and debugging parallel Fortran codes is in use on the Sun workstation. The system is composed of a parallel processing simulatormtsim, a window‐ and mouse‐based debugging toolmtdbx, and a set of real‐time display routines. The simulatormtsim, which is called from Fortran by a set of routines having the same syntax as the CRAY X‐MP multitasking library, causes several concurrently active user tasks to be executed. The debuggermtdbxis based on the Sundbxtooldebugging facility. It has an enhanced command interface with functional control of parallel processes in multiple windows. The display routines offer two real‐time views of multitasking synchronization primitives as they are used during execution. These three components of the debugging system afford the opportunity to analyse the behaviour of parallel processes by dynamic interaction at run‐time.
An addendum to G. S. Blair, J. A. Mariani and W. D. Shepherd: ‘A practical extension to unix for interprocess communication’
Authors: Saunders D. 
Published: November 2006

AbstractLong expressions derived from stochastic situations such as communication networks can usually be simplified. Although this simplification can often be done algebraically, the resulting answer sometimes points to a simpler view of the process, and thence to an easy way of simplifying the expression. This communication does this in the setting of the above‐mentioned paper.
The ECLIPSE user interface
Authors: Sommerville Ian , Welland Ray , Potter Stuart , Smart John 
Published: November 2006

AbstractThis paper describes the user interface facilities of the ECLIPSE integrated project support environment. This interface is based on a consistent metaphor called the ‘control panel’ metaphor and includes standard help and message‐handling systems. The paper describes these as well as some of the interface standards which have been developed. The interface has been implemented on top of the ‘applications interface’, which provides a portable, hardware‐independent interface for software tools.
A heuristic for software evaluation and selection
Authors: Anderson Evan E. 
Published: November 2006

AbstractThe proliferation of software packages has created a difficult, complex problem of evaluation and selection for many users. Traditional approaches to the quantification of package performance have relied on compensatory models, such as the linear weighted attribute model, which sums the weighted ratings of software attributes. These approaches define the dimensions of quality too narrowly and, therefore, omit substantial amounts of information from consideration. This paper presents an alternative methodology, previously used in capital rationing and tournament ranking, that expands the opportunity for objective insight into software quality. In particular, it considers three measures of quality, the frequency with which the attribute ratings of one package exceed those of another, the presence of outliers, where very poor performance may exist on a single attribute and be glossed over by compensatory methods, and the cumulative magnitude of attribute ratings on one package that exceed those on others. The proposed methodology is applied to the evaluation of the following software types: word processing, database management systems, spreadsheet/financial planning, integrated software, graphics, data communications and project management.
Software function allocation methodology
Authors: Ralpho'neal Michael , Lively William , Sheppard Sallie 
Published: November 2006

AbstractOne of the challenges of distributed computer systems is the effective allocation of software system functions among the hardware components of the distributed system. Software function allocation methodology (SFAM) provides computer software system designers with a thorough and flexible method to allocate software system functions among the hardware components of a distributed computer system. Software designers select and rank relevant design parameters, analyse how well different distributed computer system components meet the chosen parameters, and allocate the software function accordingly.The paper defines the problem, covers necessary terminology, and discusses the current state of research. The preconditions necessary for an analysis using SFAM are covered along with the environment in which SFAM should be used. Details of SFAM components are discussed. A complete outline of the SFAM methodology is provided, along with discussion of key points and frequent examples.
Record manipulation in prolog
Authors: Vaucher Jean G. 
Published: November 2006

AbstractProlog is a relatively new programming language that has proved excellent for symbolic computation. However, Prolog was not specifically designed for industrial scale work and it lacks some standard features that are useful for reading, maintaining and debugging large programs. In particular, Prolog has no record mechanism, and programs often require major changes when data structures are modified.The record is a standard data abstraction concept that improves the robustness of programs. The main advantage in using records is that data structures can be modified and extended with minimal repercussion to program code. Furthermore, the use of significant names to access data fields means that the intent of code is generally clearer.We present a set of primitive operators that support a readable and robust programming style for the manipulation of record data structures in standard Prolog. The proposal covers both simple and imbricated record types and handles selective modification of records cleanly. We also treat property lists and records in a uniform way. These benefits are achieved with minimal overhead while retaining the traditional Prolog non‐deterministic style.
A measurement‐based study of hardware support for object invocation
Authors: Ramachandran Umakishore , Yousef Khalidi M. Amin 
Published: November 2006

AbstractThe object invocation paradigm is attractive for structuring distributed systems. Distributed object‐based operating systems view the resources of the system as a collection of objects. Object invocation is the primary mechanism in such systems, and is often used as a yardstick for measuring the system performance. However, existing systems of this flavour exhibit poor performance due to the mismatch between the requirements of the object invocation mechanism and the machine architecture. Through measurements of an existing object‐based kernel, we present a breakdown of the costs involved in implementing the object invocation mechanism. The measurements suggest architectural solutions to improve the performance of such systems. We present our preliminary studies towards providing hardware support for the object invocation mechanism.
Rapid location of mount points
Authors: Smith Jonathan M. 
Published: November 2006

Abstract‘Mount points’ allow more storage to be grafted into tree‐structured hierarchical file systems. Administrative tasks use their locations, which are tabulated in a file. In our System V Unix environment, this file was occasionally removed. Getmnt was written to recover the information. Getmnt has had three significant versions. The original version (getmnt1) was a highly optimized naive tree traversal. Getmnt3 improved the real time performance by a mean factor of 7 by pruning unnecessary branches from the traversal. Getmnt3 doubled getmnt2's speed, with a change from depth‐first to breadth‐first search. On our development system, getmnt1 required 647.6 s to run, whereas getmnt3 required 42.53 s.
The oberon system
Authors: Wirth N. , Gutknecht J. 
Published: November 2006

AbstractIn this paper we describe an operating system for a workstation designed and implemented by the authors within two and a half years. It includes memory management and module loader, a file system, a viewer system, editors for text and graphics, a compiler, a server interface and various tools. The primary motivation was to demonstrate the feasibility of a small, yet highly flexible and powerful, system, a system that is a (decimal) order of magnitude smaller than commonly used operating systems. This is possible due to regularity of concepts and concentration on the essential. The benefits are not only fewer resources needed, but elegance and generality of concepts resulting in transparency and convenience of use and increased reliability. A corner‐stone of this approach is genuine extensibility, which is achieved by a new language, in particular by a facility called type extension. It allows for the integration of variables (objects) of a new, extended type in structures of elements of an existing base type.
Tools for implementing network protocols
Authors: Hutchinson Norman C. , Mishra Shivakant , Peterson Larry L. , Thomas Vicraj T. 
Published: November 2006

AbstractThis paper describes two software tools—a message manager and a map manager—used to implement network protocols. The tools are provided as part of the x‐kernel, an operating system kernel designed to support the construction and composition of protocols. For each tool, we briefly motivate the network task that needs to be done, give a high‐level specification of the tool, outline the algorithms and data structures used to implement the tool and give concrete examples of how the tool is used to implement real protocols. We also demonstrate how the tools, even though they are designed for general use, perform efficiently.
Automated software management based on structural models
Authors: Waters Richard C. 
Published: November 2006

AbstractA number of software management tasks (consistent system construction, system installation, etc.) can be performed by automatic tools. Given a particular software system, such a tool requires a task model that describes how the task is to be applied to the system. For example, a system construction tool needs to know which operations (compilation, linking, etc.) must be applied to which modules.Unfortunately, although task models are convenient for an automatic software management tool, they are inconvenient for users for two reasons. First, users have to create and maintain multiple, partially redundant models. Secondly, task models are often quite awkward to deal with‐a primary source of difficulty being the need to specify low‐level, task‐specific details.In recognition of these problems, recent software management tools have been moving away from task models towards structural models (e.g. who calls who) as a user interface. Structural models are easy to deal with, because they contain high‐level, task‐independent relationships, rather than task‐dependent details.A prototype tool has been implemented that makes this change complete. The tool automatically performs a variety of software management tasks using a single structural model for a system. The tasks themselves are described separately using system‐independent task descriptions.
Microcomputer vs. mainframe simulations: A case study
Authors: Bengtson Neal M. 
Published: November 2006

AbstractA comparison was made between using a simulation language to run models on a mainframe computer and on a microcomputer with a hard disk. The study was performed at NASA Langley using both the SLAM II mainframe and PC versions. The procedure for executing SLAM II on a PC is given. A batch job was created to simplify this procedure and allows PCs with a hard disk to execute simulations with one command. NASA's space transportation system operations model and the examples in the SLAM II text were used as a basis for the comparison. The PC simulations completed in predictable times. These were almost always faster than the more unpredictable mainframe times.
TGMS: An object‐oriented system for programming geometry
Authors: Dietrich Walter C. , Nackman Lee R. , Sundaresan Christine J. , Gracer Franklin 
Published: November 2006

AbstractTGMS (tiered geometric modelling system) is an experimental system intended to reduce the difficulty and cost of developing new solid modelling applications while preserving investment in an existing, time‐tested, solid modeller. The application developer writes programs in the TGMS language, which consists of a base language augmented by data types (classes) for geometry. The base programming language is AML/X, an object‐oriented language intended for use in design and manufacturing applications. Solid modelling is done using an interface to GDP (geometric design processor), an existing, production‐quality solid modelling system. TGMS shows how a system written in a non‐object‐oriented language can be used as a base for an object‐oriented application programming environment.This paper presents the design of TGMS and discusses important aspects of its implementation. The TGMS language defines classes and methods that provide an interface to functions and data represented in a non‐object‐oriented language. To implement TGMS, issues related to communication, storage management and consistency were addressed. These, and other, implementation issues are discussed. The paper includes sample programs and a summary of feedback from TGMS users. It concludes that the use of object‐oriented programming for geometry has many benefits, and that an object‐oriented system can be built on top of a non‐object‐oriented system at less cost than building the equivalent object‐oriented system from scratch.
A case study comparison of four declarative programming languages
Authors: Fleck A. C. 
Published: November 2006

AbstractA case study comparison is made of four declarative programming languages: Miranda,Miranda is a trademark of Research Software Ltd.
Fp, Equations and Prolog. The case study is used as a vehicle to assess both expressiveness and performance aspects of these languages. In expressive power, Miranda is judged to be superior, Equations and Prolog are rated about even in second place, and Fp is judged least expressive. Performance was quite poor for all the available implementations. Reasons for this are explored and the implications are discussed.
VIFOR: A tool for software maintenance
Authors: Rajlich Vaclav , Damaskinos Nicholas , Linos Panagiotis , Khorshid Wafa 
Published: November 2006

AbstractVIFOR is a software tool oriented towards maintenance of medium‐to‐large Fortran77 programs. With VIFOR, programs can be displayed and edited in two forms: as the code and as the graph. VIFOR also contains transformations in both directions, i.e. from code to graph and from graph to skeletons of code. Hence, it is suitable for re‐engineering and maintenance of existing code. Specially designed browsers implement the graphical interface. VIFOR contains a database that is based on a simple but effective data model of Fortran programs. The model contains only four entity classes and three relations, which makes the tool small, and easy to implement and use. A simple query language allows browsing through the database.