A syntax-directed integrated programming environment for developing simd supercomputer software

The increasing availability and use of supercomputers has highlighted the need for better software development techniques and tools. Supercomputers have traditionally been extensively used by engineers and scientists whose preference for Fortran is well established and recognized. However, in the parallel environment offered by the latest configurations of supercomputers, more sophisticated languages and tools are required. The present experiment is concerned with devising a syntax-directed integrated programming environment based on the language Actus, which enables a user to develop and debug programs before submitting them to an actual supercomputer. Actus is a high-level, Pascal-like language, with SIMD parallel processing features. It enables the user to ignore the idiosyncrasies of the chosen supercomputer by abstracting the parallel processing detail to a higher level. The editing, compilation and testing phases of program development are all integrated, providing a single consistent interface for all activities relating to program development.     

Portable and fault-tolerant software systems

Portable, fault-tolerant software development for networks of binary-incompatible machines continues to challenge engineers. Portable checkpoints-saved and recovered across these machines-offer a potential solution     

SUT-DAM: An integrated software environment for multi-disciplinary geotechnical engineering

As computer simulation increasingly supports engineering design, the requirement for a computer software environment providing an integration platform for computational engineering software increases. A key component of an integrated environment is the use of computational engineering to assist and support solutions for complex design. In the present paper, an integrated software environment is demonstrated for multi-disciplinary computational modeling of structural and geotechnical problems. The SUT-DAM is designed in both popularity and functionality with the development of user-friendly pre- and post-processing software. Pre-processing software is used to create the model, generate an appropriate finite element grid, apply the appropriate boundary conditions, and view the total model. Post-processing provides visualization of the computed results. In SUT-DAM, a numerical model is developed based on a Lagrangian finite element formulation for large deformation dynamic analysis of saturated and unsaturated soils. An adaptive FEM strategy is used into the large displacement finite element formulation by employing an error estimator, adaptive mesh refinement, and data transfer operator. This consists in defining new appropriate finite element mesh within the updated, deformed geometry and interpolating (mapping) the pertinent variables from one mesh to another in order to continue the analysis. The SUT-DAM supports different yield criteria, including classical and advanced constitutive models, such as the Pastor–Zienkiewicz and cap plasticity models. The paper presents details of the environment and includes several examples of the integration of application software.     

An efficient method for developing requirement specifications for plant control software using a component-based software prototype

This paper proposes an efficient method to develop requirement specifications for Plant Control Software (PCSW) using software-component-based prototypes. Prior to this proposal, domain analyses were conducted on existing PCSWs, and their functions were classified into “similar functions” and “individual functions”. Then PCSW Software Components (PSC: PCSW Software Component, PSCs: PCSW Software Components) were developed to correspond to these functions. PSCs as parameter-style components were developed in order to satisfy the clients’ (we define clients as owners, managers and operators of plants) requirements. A support environment for developing requirement specifications was developed. The environment consists of the Prototype Development Tool (PDT), the Behavior Check Simulator (BCS) and the Requirement Specification Development Tool (RSDT). The method consists of four steps. In the first step, PDT is used to define the parameters to customize PSCs and to compose a PCSW prototype by setting these parameters to PSCs. In the second step, BCS is used to execute the composed PCSW prototype and check its behavior and relevancy against the clients’ expectations. In the third step, steps 1 and 2 are repeated until the behavior of the PCSW prototype satisfies the clients’ requirements. Finally, a requirement specification is developed from the PCSW prototype which fully reflects the clients’ requirements. In order to evaluate the proposed method, it has been applied in five development cases. A Requirement Coverage of 91%, a Requirement Revision Rate of 6%, a PSC Reuse Rate of 92% and a LOC Reuse Rate of 83% have been achieved. In addition, a reduction of 55% in the amount of time required to develop requirement specifications has been achieved. These results indicate that the proposed method has sufficient capability to develop an exhaustive and an adequate PCSW requirement specification. And the developed PSCs have sufficient functions and capability to compose PCSW prototypes, and the support environment is capable of shortening the time taken to develop requirement specifications.     

Structuring fault-tolerant object systems for modularity in adistributed environment

The object-oriented approach to system structuring has found widespread acceptance among designers and developers of robust computing systems. The authors propose a system structure for distributed programming systems that support persistent objects and describe how properties such as persistence and recoverability can be implemented. The proposed structure is modular, permitting easy exploitation of any distributed computing facilities provided by the underlying system. An existing system constructed according to the principles espoused here is examined to illustrate the practical utility of the proposed approach to system structuring     

A portable fault-tolerant parallel software MPEG-1 encoder

MPEG video compression is quite difficult to achieve in real time, and hardware solutions for this problem are expensive. We present a portable, fault-tolerant, parallel, MPEG-1 encoder implemented in software. We detail the implementation strategy for the encoder and give performance results on a network of workstations and a massively parallel processor. We also show that our encoder can efficiently adapt to fluctuating processing power typical in workstation networks.     

An adaptive fault-tolerant routing algorithm for hypercubemulticomputers

This paper presents a partially adaptive fault-tolerant routing algorithm for hypercube multicomputers. The algorithm is tolerant to n-1 link and/or node faults for an n-cube. It makes routing decisions adaptively based on local failure information only. It is simple to implement and needs a very small message overhead. A comparison between the algorithm and a popular previous work is given     

Standards-a standard environment for software production

The author reviews what has been accomplished in recent years to develop a standard environment. He examines the current state of affairs to determine why problems in meeting cost, schedule, and technical performance goals persist. He makes some suggestions for dealing with these problems and concludes that a standard for maintainable code and more skilled personnel are needed to deal with them effectively     

An operating system for a fault-tolerant multiprocessor controller

The development of an operating system that is a central component of a fault-tolerant multiprocessor is described. The operating system, while relatively simple and small, supports multitasking and multiprocessing, as well as both self-diagnostics and cross-diagnostics for fault detection. In the event of a fault, the system permits rapid reconfiguration in a manner that retains processing for the highest-priority tasks. Since the hardware needed to provide fault tolerance is available when there are no faults, the operating system can utilize this excess capacity to accomplish lower-priority tasks during normal operation. This approach yields graceful degradation in response to faults in the system components     

A distributed development environment for embedded software

The HAGAR project is building a high-performance disk controller. It is an embedded system for which many hundreds of thousands of lines of embedded software will have to be developed concurrently with the development of the hardware. We found existing methods for embedded software development, such as simulation and remote cross development, to be inadequate for us. To meet our special needs, we developed a distributed development environment that combines and extends the capabilities of existing methods while fixing their drawbacks. Our environment is based on a processor-pool architecture, in which multiple hardware sets are pooled and managed systematically. It supports embedded software development for many programmers at different sites. It allows for the emulation of non-existing hardware adaptor cards and for the integration of embedded software testing with hardware simulation. The environment provides a single system image, hiding many hardware and configuration details from its users. From the perspective of the programmers, our environment makes developing embedded software for special hardware systems as easy as developing application programs for a UNIX workstation.     

A software environment for parallel computer vision

A software environment tailored to computer vision and image processing (CVIP) that focuses on how information about the CVIP problem domain can make the high-performance algorithms and the sophisticated algorithm techniques being designed by algorithm experts more readily available to CVIP researchers is presented. The environment consists of three principle components: DISC, Cloner, and Graph Matcher. DISC (dynamic intelligent scheduling and control) supports experimentation at the CVIP task level by creating a dynamic schedule from a user's specification of the algorithms that constitute a complex task. Cloner is aimed at the algorithm development process and is an interactive system that helps a user design new parallel algorithms by building on and modifying existing library algorithms. Graph Matcher performs the critical step of mapping new algorithms onto the target parallel architecture. Initial implementations of DISC and Graph Matcher have been completed, and work on Cloner is in progress     

A software environment for studying computational neural systems

UCLA-SFINX is a neural network simulation environment that enables users to simulate a wide variety of neural network models at various levels of abstraction. A network specification language enables users to construct arbitrary network structures. Small, structurally irregular networks can be modeled by explicitly defining each neuron and can be modeled by explicitly defining each neuron and corresponding connections. Very large networks with regular connectivity patterns can be implicitly specified using array constructs. Graphics support, based on X Windows System, is provided to visualize simulation results. Details of the simulation environment are described, and simulation examples are presented to demonstrate SFINX's capabilities     

GRADE: A software environment for machine translation

GRADE, a software environment for machine translation is described. It has been developed for the Mu machine translation project, which was supported by the Science & Technology Agency of the Japanese Government. GRADE consists of 3 components: (1) a grammar writing language based on flexible tree-to-tree transformation rules with a control mechanism and an interpreter; (2) software tools for constructing and maintaining grammar rules; and (3) software tools for developing dictionary databases which are based on the concept ofneutral dictionary. In this paper, these software packages are discussed from the viewpoint of the development of a large scale machine translation system.The authors thank their colleagues in the Mu project, who helped in the development of the system and already returned to their private companies to develop their own machine translation systems. We also wish to thank the researchers at the Japan Information Center of Science and Technology, and the Electrotechnical Laboratory of Kyoto University for their cooperation.     

Clustering algorithm for parallelizing software systems inmultiprocessors environment

A variety of techniques and tools exist to parallelize software systems on different parallel architectures (SIMD, MIMD). With the advances in high-speed networks, there has been a dramatic increase in the number of client/server applications. A variety of client/server applications are deployed today, ranging from simple telnet sessions to complex electronic commerce transactions. Industry standard protocols, like Secure Socket Layer (SSL), Secure Electronic Transaction (SET), etc., are in use for ensuring privacy and integrity of data, as well as for authenticating the sender and the receiver during message passing. Consequently, a majority of applications using parallel processing techniques are becoming synchronization-centric, i.e., for every message transfer, the sender and receiver must synchronize. However, more effective techniques and tools are needed to automate the clustering of such synchronization-centric applications to extract parallelism. The authors present a new clustering algorithm to facilitate the parallelization of software systems in a multiprocessor environment. The new clustering algorithm achieves traditional clustering objectives (reduction in parallel execution time, communication cost, etc.). Additionally, our approach: 1) reduces the performance degradation caused by synchronizations, and 2) avoids deadlocks during clustering. The effectiveness of our approach is depicted with the help of simulation results     

An optimal fault-tolerant routing algorithm for weighted bidirectional double-loop networks

Double-loop networks are widely used in computer networks. In this paper, we present an optimal message routing algorithm and an optimal fault-tolerant message routing algorithm for weighted bidirectional double-loop networks. The algorithms presented are novel, and they do not use routing tables. After a precalculation of O(log N) steps to determine network parameters, the algorithms can route messages using constant time at each node along the route. The algorithm presented can route messages in the presence of up to three faulty nodes or links. The fault-tolerant routing algorithm guarantees an optimal route in the presence of one node failure.     

A frame-based knowledge software tool for developing interactive robots

A knowledge-based software tool for developing interactive robot applications, called SPAK, has been developed. The “world” of interest is represented in a SPAK knowledge base by using a frame knowledge technique. This technique is chosen because it can represent the world meaningfully and naturally. Relationships among frames, which represent things in the world, and actions to be taken when certain things occur can be specified. In action, SPAK perceives changes in the environment, updates the knowledge base if needed, and generates output actions according to the knowledge contents. To support robotic applications, extensions to the conventional frame model are proposed. Various robotic applications can run cooperatively on top of SPAK. Each can easily make use of the knowledge available, and share its knowledge with others. A SPAK knowledge editor allows simple and intuitive development and modification of robot applications. To demonstrate these benefits, a prototype system and a sample robot application are developed. A multiagent technique is employed to combine various robotic components, both hardware and software, together. A sample dialogue manager for managing interactions with humans runs as an application on SPAK.     

A complete software engineering environment

A complete software engineering environment is comprised of all the engineering tasks for developing, reengineering, and maintaining software systems. These tasks can be supported by automated tools, manual procedures, or both. The organizational challenge is to automate the right tasks in the correct order so that they have the greatest impact on software quality and engineer productivity. Our experience indicates that tools for managing system requirements, configurations and changes, acceptance testing, and verification and validation result in significant, measurable benefits