Showing papers on "Software portability published in 1987"

Experience with a data base of programs

Abstract: The Adele system was initially designed as a specialized data base of programs for an experimental Pascal environment, with a focus on configuration management. Later, it was redesigned as a general data base for large scale programs written in any language. The focus here was on side effect control and real problems of large industrial software products [Estublier84]. Then in a third stage Adele evolved into the kernel for programming environments and was developed as an industrial product, with emphasis on portability, flexibility, distribution, control of rights and on the structure of the software products [Belkhatir86]. This paper describes the experience gained in the use of the Adele data base of programs.1

A portable environment for developing parallel FORTRAN programs

Abstract: The emergence of commercially produced parallel computers has greatly increased the problem of producing transportable mathematical software. Exploiting these new parallel capabilities has led to extensions of existing languages such as FORTRAN and to proposals for the development of entirely new parallel languages. We present an attempt at a short term solution to the transportability problem. The motivation for developing the package has been to extend capabilities beyond loop based parallelism and to provide a convenient machine independent user interface. A package called SCHEDULE is described which provides a standard user interface to several shared memory parallel machines. A user writes standard FORTRAN code and calls SCHEDULE routines which express and enforce the large grain data dependencies of his parallel algorithm. Machine dependencies are internal to SCHEDULE and change from one machine to another but the users code remains essentially the same across all such machines. The semantics and usage of SCHEDULE are described and several examples of parallel algorithms which have been implemented using SCHEDULE are presented.

Configuration of the CTRON* Kernel

Abstract: TRON's specification for a communication network operating system produced this kernel model. It promises software portability and a high level of performance functions common to diverse network nodes.

Evaluating expert system tools: a framework and methodology

Abstract: : This report summarizes the results of study undertaken to develop criteria for evaluating and selecting tools used to build expert systems The authors used an evaluation framework composed of five elements: (1) application characteristics, which describe the problem and the project to be undertaken; (2) tool capabilities, the capabilities that the tools support; (3) metrics, the quantitative and qualitative measures of merit for expert system tools; (4) assessment techniques, specific ways of applying metrics to tools; and (5) contexts, which describe the ways in which the evaluation criteria depend on the development phases targeted by a project Many of the study's conclusions relate to software engineering aspects of the expert system endeavor Robustness, reliability, portability, integrability, database access, concurrent access, performance, and user interface all appear to be increasingly important requirements for tools, as well as eventual requirements for the expert systems that will be produced with those tools In addition, the expert system paradigm seems to have had a significant and beneficial effect on software engineering itself

Advanced Directives to Limit Treatment: The Need for Portability

Abstract: A patient's right to refuse burdensome medical care is exercised in a highly regulated health care environment. A variety of policy instruments including living wills, durable powers of attorney, and do-not-resuscitate (DNR) orders have been created to enable patients to exercise this right. It is widely agreed that health facility policies should encourage \"durable\" decision-making in \"advance\" of the need for emergency treatment. Durability means that a patient's wishes remain valid despite incompetence during a later emergency. Advanced decision-making allows for a deliberative process impossible in medical emergencies. Hospital and nursing home policies usually assume that the decision to limit treatment will be made and implemented within a single facility where the physician has recorded an advanced directive in the medical record.'r2 Such policies do not provide for communication of advanced directives between health care facilities: directives are not \"portable\" as the patient moves between health care providers. Portable advanced directives could be implemented by subsequent health care providers who are called upon to perform a treatment that a patient has previously declined. The issue of portability is raised whenever a patient with an advanced directive to limit treatment is transferred from one health provider to another. The problem of portability arises because patients are often transferred between providers without provisions for transmitting advanced directives, precisely as urgent treatment issues are raised.

Recovery management in QuickSilver

Abstract: One price of extensibility and distribution, as implemented in QuickSilver, is a more complicated set of failure modes, and the consequent necessity of dealing with them. In traditional operating systems, services (e.g., file, display) are intrinsic pieces of the kernel. Process state is maintained in kernel tables, and the kernel contains explicit cleanup code (e.g., to close files, reclaim memory, and get rid of process images after hardware or software failures). QuickSilver, however, is structured according to the client-server model, and as in many systems of its type, system services are implemented by user-level processes that maintain a substantial amount of client process state. Examples of this state are the open files, screen windows, address space, etc., belonging to a process. Failure resilience in such an environment requires that clients and servers be aware of problems involving each other. Examples of the way one would like the system to behave include having files closed and windows removed from the screen when a client terminates, and having clients see bad return codes (rather than hanging) when a file server crashes. This motivates a number of design goals:Properly written programs (especially servers) should be resilient to external process and machine failures, and should be able to recover all resources associated with failed entities.Server processes should contain their own recovery code. The kernel should not make any distinction between system service processes and normal application processes.To avoid the proliferation of ad-hoc recovery mechanisms, there should be a uniform system-wide architecture for recovery management.A client may invoke several independent servers to perform a set of logically related activitites (a unit of work) that must execute atomically in the presence of failures, that is, either all the related activities should occur or none of them should. The recovery mechanism should support this.In QuickSilver, recovery is based on the database notion of atomic transactions, which are made available as a system service to be used by other, higher-level servers. This allows meeting all the above design goals. Software portability is important in the QuickSilver environment, dictating that transaction-based recovery be accessible to conventional programming languages rather than a special-purpose one such as Argus [Liskov84]. To accommodate servers with diverse recovery demands, the low-level primitives of commit coordination and log recovery are exposed directly rather than building recovery on top of a stable-storage mechanism such as in CPR [Attanasio87] or recoverable objects such as those in Camelot [Spector87] or Clouds [Allchin&McKendry83].

CLIPS: An expert system tool for delivery and training

Abstract: The C Language Integrated Production System (CLIPS) is a forward chaining rule-based language. The requirements necessary for an expert system tool which is used for development, delivery, and training are examined. Because of its high portability, low cost, and ease of integration with external systems, CLIPS has great potential as an expert system tool for delivery and training. In addition, its representation flexibility, debugging aids, and performance, along with its other strengths, make it a viable alternative for expert system development.

Design principles and configuration of CTRON

Abstract: Information communication networks are being developed which provide a variety of services integrating information processing and communications. A high realtime processing capability and high reliability are required in switching and other nodes making up such networks. Multi-user processing and large-scale data processing functions are also required, especially in information processing nodes. In addition, as the network develops, in order to realize a diversity of services reliably and efficiently it should be possible to incorporate similar functions in a number of nodes, and to change the distribution of functions among nodes. Software portability across nodes is thus an important factor. This paper will outline the design principles and configuration of CTRON, which is a set of operating system interfaces designed to meet these requirements in information communication networks.

A Portable Natural Language Interface.

Abstract: : Project 5470, A Portable Natural Language Interface, was an outgrowth of the experience gained with the linguistic interface to the Knowledge-Based System (KNOBS) and the KNOBS Replanning System (KRS). The KNOBS/KRS interface provided multiple media including English and graphics, enabling users to easily communicate with the underlying mission planning system. Notable and very limiting deficiencies were however present in the interface. The most significant of these deficiencies were the lack of extensibility and portability. Application of KNOBS/KRS system to new domains and even simple enhancements to the vocabulary were inhibited by the complexity of the task. Integration of the interface to any other system was out of the question. The purpose of project 5470 was to create a natural language interface for expert systems that would be portable across different applications and would be capable of reasoning about user goals. This interface would integrate the use of graphics, menus and natural language within a new model and architecture that combined syntactic, semantic and discourse analysis in such a way as to promote generality and application independence. This report discusses the design and implementation of this portable interface and the degree of success attained in accomplishing the original goals.

Design of CTRON

Abstract: Information communication networks are being developed which provide a variety of services integrating information processing and communications. A high realtime processing capability and high reliability are required in switching and other nodes making up such networks. Multi-user processing and large-scale data processing functions are also required, especially in information processing nodes. In addition, as the network develops, in order to realize a diversity of services reliably and efficiently it should be possible to incorporate similar functions in a number of nodes, and to change the distribution of functions among nodes. Software portability across nodes is thus an important factor. This paper will outline the design principles and configuration of CTRON, which is a set of operating system interfaces designed to meet these requirements in information communication networks.

Design of the CTRON File Management

Abstract: The CTRON file management is a functional block of the extended operating system layer in CTRON. It prescribes interfaces used in common in various application fields and assures the portability of the upper-layer software. It provides two kinds of files: an ordinary file and a device file. It provides two kinds of file organization: a basic organization and an indexed sequential organization. It controls file location by means of a tree-structured directory. This paper describes these features of the CTRON file management.

An optimizing Prolog compiler

Abstract: In this paper we report on our experiment on Prolog compiler technology. Targeted properties of the compiler are efficiency and portability. The generated code attained so far is efficient enough to gain more than 1 MEGA LIPS on IBM 3090. One of the specialities of the compiler is in the intermediate Virtual Prolog Machine Code, which enhanced efficiency and portability. Another advantage of the compiler is to generate PL.8 code which can be used on multiple machines including the IBM 370 and IBM RT-PC. We also introduce some declarative extensions , which are compatible with Prolog and powerful enough to produce efficient code.

Design of CTRON Input-Output Control Interface

Abstract: The function of the CTRON input-output control is to enable to port the operating system components, such as file management, using the access interfaces which conceal hardware architecture differences However, performance and specification expandability should not be sacrificed to ensure this portability

An Implementation of the New IEEE Standard Routines for FASTBUS

Abstract: The minimum of implementation level details in the standard document is helpful from the point of view of the implementor (and the subsequent user also). The standard for the most part is defined at a fairly abstract and functional level. This gives the implementor more freedom then would otherwise be available, and results in quite portable routines. The explicit provision in the standard for implementation dependent extensions in operational parameters, error returns, and some routine calls, makes it quite easy to adapt the standard to particular hardware or to a particular application environment. Some mandatory features can seem unecessary. The default environment, and the mandatory requirement that primitive routines and interrupt related routines supported by the hardware must be implemented, are examples. But a goal of the standard routines is to increase uniformity of implementations, and therefore portability, and these mandatory features help in achieving that goal. The error reporting defined in the standard document can be difficult to understand, because of its potential complexity. But in our low level implementation of error reporting there were no problems. In the case of the GPM, some performance improvement could be obtained by supporting delayed execution mode. This is especially true in its use as a host interface. We have not looked at these aspects in detail however. Because of our particular application and the resultant simplicity of the implementation we have chosen not to implement delayed execution mode. It may be useful to do so at some time in the future.

CTRON: An Overview

Abstract: CTRON is a specification of OS for servers in a network of TRON-based computers. It is meant to support file servers, database servers, network gateways, and other specialized servers. Portability and other design issues are addressed in the design of CTRON specification.

Portable C and UNIX system programming

Abstract: This practical guide contains a detailed set of C standards and UNIX system comparisons for the construction of highly portable software. Professionals will learn the underlying causes of portability problems as well as the techniques for creating portable UNIX system software. It shortens the software development and test cycle and enables the user to reduce the cost of long-term support.

Design and implementation of a C-based language for distributed real-time systems

Abstract: This paper describes the design and implementation of a concurrent programming language suitable for use with real-time distributed systems. The language, MC, is an extension of the language C with some of the concrrency features of ADA. The implementation provides portability and simplicity by assuming a basic C compiler for its compilation and a minimal semaphore-based run-time support kernel.

Multiprogramming and the performance of parallel programs

Abstract: Parallel processing has proven to be the way to break the speed limit of computing imposed by hardware technologies. Currently, there is a wide range of multiprocessors that are no longer only dedicated number crunching machines but, rather, general purpose computers that run multiprogrammed operating systems. This thesis addresses the problem of running parallel programs on these multiprogrammed multiprocessors. On these machines, the number of running processes may exceed the total number of CPU's, which will severly affect the performance of parallel programs and slow down their execution. In this thesis, parallel algorithms, sources of performance degradations and the theory of parallel programming are investigated. Based on these investigations, a new parallel programming methodology is presented that can be used to write parallel programs that tolerate the suspension of processes. These programs will utilize available running processes to make computational progress without waiting for suspended processes. This tolerance is a result of coordinating parallel programming activities with the operating system's state of processes. The new methodology is implemented as an extension to the Force parallel programming language, which enhances the portability of parallel programs to a wide range of multiprogrammed multiprocessors.

The netsim graphics system

Abstract: Described in this paper is the development of an interactive computer graphics (ICG) system, named GTRAF, that provides users with a new and highly efficient methodology for analyzing results generated by the NETSIM microscopic traffic simulation program. This tool may be executed on microcomputers (PCs) with graphics capabilities or on any larger computer that supports Fortran and graphics. Portability of the software is assured through the adherence to ANSI Fortran and the Graphics Kernel System (GKS) standard. Following a discussion outlining the need for and use of ICG systems for the traffic engineering profession, an outline is provided of the concepts and objectives guiding the design of GTRAF, as well as a description of its logical structure. The reader is then walked-through an ICG session with GTRAF. Photographs of the displays are provided to illustrate the process.

The evolution of a graduated symbol software package in a changing graphics environment

Abstract: The paper describes the developmental history of a software package for computer-assisted drafting of graduated symbol maps. Given the machinery prevalent 10 years ago, the first version was implemented on a mini-computer with vector-oriented devices, such as mechanical plotters and storage tube terminals. The programs provide functions for plotting graduated symbols of various forms, legends and Line drawing. To improve map legibility the hidden areas in cases of overlapping symbols are removed. The visual separation of the symbols is enhanced by a halo effect, a small gap between the symbols, or the symbols and map background. New hardware required the reprogramming of the package to exploit the extended capabilities of new computers and graphic devices, including colour and hardware area fill. To increase flexibility, portability and maintainability, the graphic standard GKS (Graphical Kernel System) has been used as a device-independent software interface for the third generation of the package.

Observations on the portability of Ada I/O

Abstract: I have been involved recently in developing reusable Ada components which are portable (in theory) across multiple systems using multiple compilers. One of the biggest problem areas in Ada portability aside from Chapter 13 issues is Chapter 14, Ada I/O. This paper represents an informal collection of my working notes on the portability problems of Chapter 14. These notes are based on my experience with a wide variety of compilers on an even larger set of hardware. I have purposefully not mentioned any compilers by name as I only wish to show the differences between implementations and do not wish to imply that any compiler is better than any other. While I/O is inherently non-portable, packages of common I/O functions such as those described in Chapter 14 can be specified in a manner which ensures maximum portability. There are too many loopholes and areas for implementor interpretation in current Ada 1.0; I hope to see more stringent I/0 specifications in 1988.

C programming language: an applied perspective

Abstract: Introducing C Programming. Basic Data Types and Operators. Pointers, Arrays, and Strings. Statements. Functions. Program Structure and Storage Classes. The Preprocessor. Arrays and Pointers Revisited. Constructed Data Types. Linked Data Structures. C and the Outside World. Portability and Efficiency.

Full-span structural compilation of DSP hardware

Abstract: Most current silicon compilers rely on an underlying hardware function-library, thereby restricting the user to producing structural assemblies of library components. Although this gives the systems designer the power to implement function directly in silicon, it precludes the use of arbitrary cell functions that might be more suited to his application than the existing set. Moreover, should a new process become available, the cell-library must be redesigned and laid-out according to new rules, by a circuit and layout expert. An advance in structural silicon compilation, SECOND, is reported, which promises to impart flexibility and portability to cell-libraries. Through the automatic generation of layout from logical descriptions, cell-libraries may be maintained in process-independent form, and incorporate not only new components, but also new processes with ease. Implementations of user-specified chips may be in custom or semi-custom form - only physical assembly procedures differ.

Extensions to the Ash Algorithm for Finding Root Loci

Abstract: This paper describes extensions to the Ash root-locus-finding algorithm that increase its efficiency and robustness. Also described are improvements to the implementation that increase the program's portability and the amount of information available to the user. An example of the use of the improved program is given.