Showing papers on "Application software published in 1993"

Processor reconfiguration through instruction-set metamorphosis

Abstract: The processor reconfiguration through instruction-set metamorphosis (PRISM) general-purpose architecture, which speeds up computationally intensive tasks by augmenting the core processor's functionality with new operations, is described. The PRISM approach adapts the configuration and fundamental operations of a core processing system to the computationally intensive portions of a targeted application. PRISM-1, an initial prototype system, is described, and experimental results that demonstrate the benefits of the PRISM concept are presented. >

The infeasibility of quantifying the reliability of life-critical real-time software

Abstract: This work affirms that the quantification of life-critical software reliability is infeasible using statistical methods, whether these methods are applied to standard software or fault-tolerant software. The classical methods of estimating reliability are shown to lead to exorbitant amounts of testing when applied to life-critical software. Reliability growth models are examined and also shown to be incapable of overcoming the need for excessive amounts of testing. The key assumption of software fault tolerance-separately programmed versions fail independently-is shown to be problematic. This assumption cannot be justified by experimentation in the ultrareliability region, and subjective arguments in its favor are not sufficiently strong to justify it as an axiom. Also, the implications of the recent multiversion software experiments support this affirmation. >

A model and methodology for hardware-software codesign

Abstract: A behavioral model of a class of mixed hardware-software systems is presented. A codesign methodology for such systems is defined. The methodology includes hardware-software partitioning, behavioral synthesis, software compilation, and demonstration on a testbed consisting of a commercial central processing unit (CPU), field-programmable gate arrays, and programmable interconnections. Design examples that illustrate how certain characteristics of system behavior and constraints suggest hardware or software implementation are presented. >

Secure software rental system using continuous asynchronous password verification

Abstract: A system is disclosed for providing secure access and execution of application software stored on a first computer by a second computer using a communication device while a communication link is maintained between the first and second computers. More specifically, a secure software rental system is disclosed. The system enables a user in a remote location using a personal computer and a modem to connect to a central rental facility, transfer application software from the central rental facility to the remote computer, and execute the application software on the remote computer while electronically connected to the central rental facility. When the communication link between the central rental facility and the remote computer is interrupted or terminated, the application software no longer executes on the remote computer. This is accomplished by integrating header software with the application software. The application software stored on the central rental facility is integrated with the header software to provide a security feature. The use of header software allows the user to execute the application software only while the user is electronically connected to the central rental facility continuously. This prevents the user from copying the application software to a storage device of the remote computer, and subsequently executing the application software after interrupting or terminating the communications link between the central rental facility and the remote computer.

Software Implemented Fault Tolerance: Technologies and Experience

Abstract: By software implemented fault tolerance, we mean a set of software facilities to detect ‘and recover from faults that are are not handled by the underlying hardware or operating system. We consider those faults that cause an application process to crash or hang; they include software faults as well as faults in the underlying hardware and operating system layers if they are undetected in those layers. We define 4 levels of software fault tolerance based on availability and data consistency of an application in the presence of such faults. Watchd, libft and nDFS are reusable components that provide up to the 3rd level of software fault tolerance. They perform, respectively, automatic detection and restart of failed processes, periodic checkpointing and recovery of critical volatile data, and replication and synchronization of persistent data in an application software system. These modules have been ported to a number of UNIX’ platforms and can be used by any application with minimal programming egort. Some newer telecommunications products in AT&T have already enhanced their fault-tolerance capability using these three components. Experience with those products to date indicates that these modules provide eficient and economical means to increase the level of fault tolerance in a software product. The performance overhead due to these components depends on the level and varies from 0.1% to 14% based on the amount of critical data being checkpointed and replicated.

Airline-based video game and communications system

Abstract: An airline-based video game system includes a multitasking master computer, which preferably stores video game and other application programs on its hard disk. The master computer is coupled to a set of airplane zone control computers which also perform conventional cabin management tasks. The zone control computers receive data from the master control computer and couple data to identified seat controlling processing units (SEBs). Each SEB receives data from, and couples data to, a set of unique seat display units which are associated with each seat in the airplane. The system downloads application software to the seat display units from the master computer. After receipt of a downloading request, the master computer responds by setting up an application program transmission for generating the display menu which appears on each SDU. The initial applications program downloading results in a menu display at every passenger seat which initiated a request. The applications program is then coupled to each SDU for display on its liquid crystal display screen. The display menu advantageously permits each passenger to select between various operating modes including: movies, games, shopping, survey forms, language selection, communication/data processing services. Communication or data processing services permit selection of in-flight phone services, word processing services, and facsimile services.

PRISM-II compiler and architecture

Abstract: This paper discusses the architecture and compiler for a general-purpose metamorphic computing platform called PRISM-II. PRISM-II improves the performance of many computationally-intensive tasks by augmenting the functionality of the core processor with new instructions that match the characteristics of targeted applications. In essence, PRISM (processor reconfiguration through instruction set metamorphosis) is a general purpose hardware platform that behaves like an application-specific platform. Two methods for hardware synthesis, one using VHDL Designer and the other using X-BLOX, are presented and synthesis results are compared. >

Quantifying schema evolution

Abstract: Achieving correct changes is the dominant activity in the application software industry. Modification of database schemata is one kind of change which may have severe consequences for database applications. The paper presents a method for measuring modifications to database schemata and their consequences by using a thesaurus tool. Measurements of the evolution of a large-scale database application currently running in several hospitals in the UK are presented and interpreted. The kind of measurements provided by this in-depth study is useful input to the design of change management tools.

An architectural framework for supporting heterogeneous instruction-set architectures

Abstract: An architectural framework that allows software applications and operating system code written for a given instruction set to migrate to different, higher performance architectures is described. The framework provides a hardware mechanism that enhances application performance while keeping the same program behavior from a user perspective. The framework is designed to accommodate program exceptions, self-modifying code, tracing, and debugging. Examples are given for IBM System/390 operating-system code and AIX utilities, showing the performance potential of the scheme using a very long instruction word (VLIW) machine as the high-performance target architecture. >

Computer-aided design of a generic robot controller handling reactivity and real-time control issues

Abstract: An original system, Open Robot Controller Computer-Aided Design (ORCCAD), for the computer-aided design of robot controllers is described. Accessed by three different user levels (system, control, and application), it provides a coherent approach from a high-level specification down to its implementation, and offers several tools for design, display, and test. Following a critical study of the main architectures reported in the literature, the basic principles and underlying concepts of ORCCAD are presented. The main entity considered is the robot task, an elementary control action associated with a local behavior controlled by a set of observers and modeled by a finite-state automaton. It is made of a set of real-time communicating tasks, called module tasks. The module task which handles the behavior of the robot task, is described using the synchronous language ESTEREL. The application level is defined as a set of synchronized robot tasks, also described using ESTEREL. Two detailed examples are discussed. >

An algorithm for distributed groupware applications

Abstract: Computer supported cooperative work (CSCW) is a rapidly growing field. Real-time groupware systems are addressed that allow a group of users to edit a shared document. The architecture and concurrency control algorithm used in this system are described. The algorithm is based on the semantics of the application and can be used by the developers of other groupware systems. The authors begin by introducing the notion of a purely replicated architecture and then present GroupDesign, a shared drawing tool implemented with this architecture. They then present the main parts of the algorithm that implement the distribution. The algorithm gives the best response time for the interface and reduces the number of undo and redo operations when conflicts occur. >

A System for Operating Application Software in a Safety Critical Environment

Abstract: A system and method for operating application software in a safety critical environment comprises providing a data processor having an operating system for effecting processing operations and an intermediate shell which interacts with the operating system and application software to emulate a safety critical environment to the application software. The application software is run by interacting solely with the intermediate shell to effect a safety critical environment therefor.

The Splash 2 software environment

Abstract: Splash 2 is an attached special purpose parallel processor in which the computing elements are user programmable FPGA devices. The architecture of Splash 2 is designed to accelerate the solution of problems which exhibit at least modest amounts of temporal or data parallelism. Applications are developed by writing behavioral descriptions of algorithms in VHDL, which are then iteratively refined and debugged within the Splash 2 simulator. Once an application is determined to be functionally correct in simulation, it is compiled to a gate list and optimized by logic synthesis. The gate list is then mapped onto the FPGA architecture by automatic placement and routing tools to form a loadable FPGA object module. A C language library and a symbolic debugger comprise the execution environment. The Splash 2 system has been shown to be effective on a variety of applications, including text searching, sequence analysis, and image processing. >

Improving the N-version programming process through the evolution of a design paradigm

Abstract: The application of the N-version programming (NVP) technique in a project that reused the revised specification of a real, automatic airplane landing problem. The study involved 40 students, who formed 15 independent programming teams to design, program, test, and evaluate the application. The impact of the paradigm on the software development process, the improvement of the resulting N-version software (NVS) product, the insight, experience, and learning in conducting this project, various testing procedures applied to the program versions, several quantitative measures of the resulting NVS product, and some comparisons with previous projects are discussed. The effectiveness of the revised NVP design paradigm in improving software reliability by providing fault tolerance is demonstrated. >

A generalized algorithm for evaluating distributed-program reliability

Abstract: A one-step algorithm, GEAR (generalized evaluation algorithm for reliability), is introduced that computes the reliability of a distributed computing system (DCS), which usually consists of processing element, memory unit, input/output devices, data-files, and programs as its shared resources. The probability that a task or an application can be computed successfully by sharing the required resources on the DCS is termed the system reliability. Some of the important reliabilities defined using the above concept are discussed, including terminal-pair, computer-network, distributed-program, and distributed-system. GEAR is general enough to compute all four of these parameters, and does not require any prior knowledge about multiterminal connections for computing reliability expression. Many examples are included to illustrate the usefulness of GEAR for computing reliability measures of a DCS. >

An algorithm for partitioning of application specific systems

Abstract: A simulated-annealing based algorithm to partition an application specific system into a set of modules is presented. The role of partitioning is to discover the structure implicit in the functional specification of the system so as to guide high level synthesis decisions in a design environment for digital systems consisting of hardware parts and possibly software components. The partitioning algorithm can also be used to partition the final or intermediate results of a high-level synthesis process into several physical blocks. Experimental results show that the approach produces better register-transfer designs with less global communications. >

Simulation of Software Behavior Under Hardware Faults

Abstract: A simulation-based software-model that permits application specific dependability analysis in the early design stages is introduced. The model represents an application program by decomposing it into a graph model consisting of a set of nodes, a set of edges that probabilistically determine the flow from node to node, and a mapping of the nodes to memory. The software model simulates the execution of the program while errors are injected into the program's memory space. The model provides application-dependent parameters such as detection and propagation times and permits evaluation of function on system level error detection and recovery schemes. A case study illustrates the interaction between an application program and two detection schemes. Specifically, Gaussian elimination programs running on a Tandem Integrity S2 system with memory scrubbing are studied. Results from the simulation-based software model are validated with data measured from an actual Tandem Integrity S2 system. Application dependent coverage values obtained with the model are compared with those obtained via traditional schemes that assume uniform or ramp memory access patterns. For the authors' program, some coverage values obtained with the traditional approaches were found to be 100% larger than those obtained with the software model.

Developing and distributing user-friendly application software

Abstract: The adoption of new techniques in predictive microbiology by the food industry will ultimately be dependent on the development of user-friendly application software that makes it easy for non-research personnel to employ the mathematical models. Such applications should be an integral part of projects in predictive microbiology. Recommendations related to the architecture, speed, protection, testing, and distribution of application software are presented based on our experience in developing and distributing the ‘Microbial Food Safety Pathogen Modeling Program’.

Method for the acquisition of software and data-processing system to implement the method

Abstract: Disclosed are a method and a data-processing system for the acquisition of software programs by a microcomputer. The system comprises, for this purpose, a data base service center in which application software programs are stored and a removable electronic memory carrier containing rights of access, to be introduced into a drive of the microcomputer to enable the remote-loading, into the microcomputer, of software programs for which the carrier contains the corresponding rights of access, this same carrier being capable of containing the rights to run the remote-loaded software. The disclosed device can be applied to portable microcomputers.

Dynamic, object-oriented parallel processing

Abstract: Mentat, a dynamic, object-oriented parallel-processing system that provides tools for constructing portable, medium-grain parallel software by combining an object-oriented approach with an underlying layered virtual-machine model is described. Mentat's three primary design objectives-high performance through parallel execution, easy parallelism, and software portability across a wide range of platforms-are reviewed. The performance of four applications of Mentat on two platforms-a 32-node Intel iPSC/2 hypercube and a network of 16 Sun IPC Sparcstations-are examined. The applications are DNA and protein sequence comparison, image convolution, Gaussian elimination and partial pivoting, and sparse matrix-vector multiplication. The performance of Mentat in these applications is compared to that of object-oriented parallel-processing systems, compiler-based distributed-memory systems, portable parallel-processing systems, and hand-coded implementations of the same applications. >

Software for simulation

Abstract: This tutorial describes computer languages and other software packages that support discrete-event simulation.

Assisted navigation for a powered wheelchair

Abstract: The VAHM project aims to improve the control of powered wheelchairs by adding possibilities of autonomous mobility. The disabled person may indicate the goal to be reached, may alter the already undertaken trajectory or stop the mobile in case of emergency. A hybrid software architecture to achieve this is proposed. The possibilities offered by such a system are described from an example of application. >

Observations on industrial practice using formal methods

Abstract: Formal methods refer to the use of mathematically based techniques in software and system engineering. The authors summarize observations on their use in a dozen applications in industrial settings. Application goals ranged from reengineering to system certification. The purpose is to extract some of the key observations about practice in software engineering terms with minimal reference to formal methods terminology and glossing over distinctions among methods. The methodology of the study is described. Applications include oscilloscopes, nuclear reactors, trains, planes, ships, satellites, smartcards, transaction processing, arithmetic units, networks, medical instruments, and language processors. The observations follow from a systematic survey of these applications using a structured interview process and analysis of results using a set of features covering various aspects of practice: process, methods, tools, and technology transfer. >

Scheduling and communication in MetaH

Abstract: This paper describes certain aspects of an architecture description language (MetaH) and associated toolset used to specify, analyze, and automatically assemble software for real-time, fault-tolerant, secure, multi-processor systems. One goal in the design of this language and toolset was to provide design-time analysis that accurately characterizes the behavior of the actual implementation. Currently, our toolset consists of tools to automatically assemble the application software and to perform a real-time schedulability analysis for that application. >

Providing network video service to mobile clients

Abstract: Mobile computing and multimedia are two emerging trends in computer systems. One foreseeable application suggested by these two trends is the playback of stored video on both mobile devices and conventional workstations. A system supporting such an application must provide performance-guaranteed delivery of video data to different types of clients, some of which may be mobile. In this paper, we address some of the issues involved in supporting such an application, namely the efficient layout of multiple representations of video data on a file server and network support for host mobility. >

A software architecture-based human-machine interface for reconfigurable sensor-based control systems

Abstract: The authors report on Onika, an iconically programmed human-machine interface, to interact with a reconfigurable software framework to create a reusable code. Onika presents appropriate work environments for both application engineers and end-users. For engineers, icons representing real-time software modules can be combined to form real-time jobs. For the end-user, icons representing these jobs are assembled by the user into applications. Onika verifies that all jobs and applications are syntactically correct, non-ambiguous, and complete. They can then be executed from within Onika, or can be saved as a stand-alone program which can be executed independently on the underlying real-time operating system. Onika has been fully integrated with the Chimera real-time operating system in order to control several different robotic systems in the Advanced Manipulators Laboratory at Carnegie Mellon University. >

Real-time operating system and virtual digital signal processor for the control of a computer

Abstract: A data processor, such as a digital signal processor, that has augmented memory, I/O and math units for real-time performance of complex functions, is placed under the control of a group of abstract object-oriented modules arranged with an underlying operational nucleus that includes a real-time kernel. The modules are hierarchically configured, with the lowest being an array object type that references memory allocations. A stream object type, based on the arrays, defines channels between application software and data devices. A vector object type, also based on the arrays, establishes structure within allocated blocks and also enables vector math functions to be undertaken by the vector module. Matrix and filter object types utilize the arrays and vectors in sequences controlled by the corresponding matrix and vector modules. The system provides a model of DSP functionality that is hardware independent, and an interface between high level language calls and highly efficient routines executed in assembly language. With this arrangement a large library of math functions is held available for use in real-time operations of complex nature.

A functional reconfigurable architecture and compiler for adaptive computing

Abstract: Many computationally intensive tasks spend nearly all of their execution time within a small fraction of the executable code. Substantial gains can be achieved by allowing the configuration and fundamental operations of a processor to adapt to these frequently accessed portions. A method is presented which improves the performance of many computationally intensive tasks by utilizing information extracted at compile-time to synthesize new operations which augment the functionality of a core processor. The newly synthesized operations are targeted for RAM-based field-programmable gate array (FPGA) devices which provide a mechanism for fast processor reconfiguration. A proof-of-concept system called PRISM, consisting of a specialized C configuration compiler and a reconfigurable hardware platform, is presented. Compilation and performance results are provided which confirm the concept viability, and demonstrate significant speed-up over conventional general-purpose architectures. >

Extending Pearl for industrial real-time applications

Abstract: High-Integrity Pearl, (HI-Pearl) an extension to the Process and Experiment Automation Real-Time language (Pearl) which incorporates several principles from the real-time Euclid language, is described. The requirements of real-time software and components of a real-time language are reviewed. HI-Pearl's mechanisms for concurrency control, synchronization, allocation, time-bounded loops, surveillance of events, parallelism, timing constraints, overload detection and handling, storage management, run tracing, and error detection and handling are discussed. HI-Pearl's schedulability analyzer, an automated tool to predict whether real-time software will adhere to its critical timing constraints, is also discussed. >

Recent developments and future trends in PLC programming languages and programming tools for real-time control

Abstract: The programmable logic controller (PLC) is changing to reflect the demands of sequencing and continuous processing applications. The PLC can be thought of as a hardened computer with high speed I/O and communications ports with bus interfacing for multiprocessor or coprocessor enhancements, and a BIOS that supports those features. PLC manufacturers now retain control over both aspects of the PLC which interoperate in a proprietary manner. Via the delineation of the two may come a standard real time operating system or real time kernel which would give rise to true applications portability. Specific topics addressed include relay ladder logic, a structured approach to error dynamic diagnostic information (EDDI), state control language, and process control function blocks. >