Connecting tools using message passing in the Field environment

An overview is given of the Field environment, which was developed to show that highly integrated, interactive environments like those on PCs can be implemented on workstations and can be used for classical-language and large-scale programming. Field connects tools with selective broadcasting, which follows the Unix philosophy of letting independent tools cooperate through simple conventions, demonstrating that this simple approach is feasible and desirable. Field achieves its goals by providing a consistent graphical front end and a simple integration framework that lets existing and new Unix tools cooperate. The front end is based on a tool set called the Brown workstation environment. The framework combines selective broadcasting with an annotation editor that provides consistent access to the source code in multiple contexts and with a set of specialized interactive analysis tools. Field's integration framework and message facility are described     

The program animation system PASTIS

The software animation system PASTIS (Program Animation System with Interactive Solutions) for program animation with emphasis on the visualization of the dynamic behaviour of algorithms and data structures is presented. Its main properties are unmodified source code of the visualized program, concurrent multiple views on algorithms and data structures, and interactive alterations of views during run time. PASTIS is distinguished by high modularity and strict separation of its components. This makes it particularly suitable for distributed computing environments. The interface between program and animation is a relational data model. Animations are directed by a single tuple, or sets of tuples, called relations, or sets of relations, called networks. Animations can be nested hierarchically. A prototype of PASTIS was implemented under Unix

1 Unix is a trademark of AT&T.

using the GNU source level debugger gdb and the X-window system.     

Combining Gprof and Event-Driven Monitoring for Analyzing Distributed Programs:A Rough View of NCSA Mosaic

There are several purposes of analyzing a program:functional or performance analysis,debugging or,more recently,mapping a program to a new paraller or distributed architecture.In this paper,we introduce an effective method leading to the Execution Graph (EG)from a program.First,the Unix profiling tool Gprof is used to get the Execution Model(EM)of a C-program.Then the event-driven monitoring tool AICOS-SIMPLE is used to get the EG which includes not only the call graph but also the execution time table of the program.This method is suitable for analyzing modern distributed programs.As the example of the analysis,the well known HTTP protocol under the NCSA Mosaic is chosen.Ae EG of NCSA Mosaic on the routing level is given.     

Scalable, secure, and highly available distributed file access

A summary of and historical perspective on work done to implement easy-to-share distributed file systems based on the Unix model are presented. Andrew and Coda are distributed Unix file systems that embody many of the recent advances in solving the problem of data sharing in large, physically dispersed workstation environments. The Andrew architecture is presented, the scalability and security of the system are discussed. The Coda system is examined, with emphasis on its high availability     

Game: Genetic algorithm for minimization of energy,an interactive program for three-dimensional intermolecular interactions

An interactive FORTRAN-77 program GAME has been developed for three-dimensional intermolecular interactions of molecular clusters or docking problems. In this note the essential features of the program are described. The source code can be compiled and run on most computer environments such as VAX/VMS, Unix and IBM and is available upon request.     

Finding minimax strategy and minimax risk in a random environment (the two-armed bandit problem)

Minimax strategy and risk in a stationary random environment are found as Bayesian ones corresponding to the worst prior distribution. For environments with normally distributed incomes with unit variance and expectations that depend only on the alternative selected, this distribution can be chosen to be symmetric and asymptotically uniform. This lets one use numerical methods. The results can be used for systems with parallel data processing, in particular, for controlling environments with distributions other than normal.     

Code generators

Code generators, which take a programmer's inputs in the form of some abstraction, design, or direct interaction with the system and write out a source program that implements the details of the application, are reviewed. After a brief overview, four separate presentations cover examples of such systems from four domains. The Tags tools uses abstraction to specify real-time control systems. In this tool, the details of synchronization code are hidden from the designer, but some functionality must still be provided in detail. Microstep is a similar kind of tool for data-processing applications. One can view both Tags and Microstep as high-level specification languages. PSG generates programming environments, i.e. one gives it a nonprocedural specification of a language's syntax and it generates an integrated programming environment for that language. While one must specify the environment in detailed form, the actual code generation is hidden. Escort is a similar system specialized for telecommunications applications. It lets one build, execute, and test specifications for telecommunication systems. Both PSG and Escort illustrate the power of domain-specific tools     

Quattor: Tools and Techniques for the Configuration,Installation and Management of Large-Scale Grid Computing Fabrics

This paper describes the quattor tool suite, a new system for the installation, configuration, and management of operating systems and application software for computing fabrics. At present Unix derivatives such as Linux and Solaris are supported. Quattor is a powerful, portable and modular open source solution that has been shown to scale to thousands of computing nodes and offers a significant reduction in management costs for large computing fabrics. The quattor tool suite includes innovations compared to existing solutions which make it very useful for computing fabrics integrated into grid environments. Evaluations of the tool suite in current large scale computing environments are presented.     

Internet网络环境的测试程序设计与实现

在ＩＣＭＰ及ＩＰ协议下,讨论了基于Ｕｎｉｘ环境的任务客户端,通过Ｉｎｔｅｒｎｅｔ网络环境是否可任何服务器端的测试程序设计,主要介绍了利用ｓｏｃｋｅｔ接口客户端测试程序的设计与实现。     

面向Java的分布式程序测试系统

由于程序的分布运行,测试分布式程序必须同时考虑并发特性和运行环境.介绍了一个面向Java语言的分布式程序测试系统JDPT(Java-oriented distributed program testing system).JDPT基于运行环境定义事件,通过事件序列记录分布式程序的运行过程,并定义事件约束检测可行事件序列集的有效性.通过该技术,JDPT可以有效地判断程序在运行环境中并发执行的正确性,适用于跨平台的Java程序测试.     

Virtual network computing: cross-platform remote display and collaboration software

VNC (Virtual Network Computing) is a computer program written to address the problem of cross-platform remote desktop/application display. VNC uses a client/server model in which an image of the desktop of the server is transmitted to the client and displayed. The client collects mouse and keyboard input from the user and transmits them back to the server. The VNC client and server can run on Windows 95/98/NT, MacOS, and Unix (including Linux) operating systems. VNC is multi-user on Unix machines (any number of servers can be run are unrelated to the primary display of the computer), while it is effectively single-user on Macintosh and Windows machines (only one server can be run, displaying the contents of the primary display of the server). The VNC servers can be configured to allow more than one client to connect at one time, effectively allowing collaboration through the shared desktop. I describe the function of VNC, provide details of installation, describe how it achieves its goal, and evaluate the use of VNC for molecular modelling. VNC is an extremely useful tool for collaboration, instruction, software development, and debugging of graphical programs with remote users.     

Dynamic compilation in the unix environment

A system for dynamic compilation under the Unix operating system is described. The basis of the system is an incremental assembler that can be used statically or during program execution to insert or replace a module in an executable image. All cross-module references are via offets into a run-time symbol table. All generated code is independent of its location or the location of the symbol table. The symbol table and all modules reside in memory segments compatible with the memory allocator malloc() . The symbol table origin is maintained in a processor register. Library procedures allow the assembler (or C compiler) to be called to alter the currently executing program, or to place a stub function which acts as a trap, so that when the stub is invoked it caues a file to be dynamically compiled into the executing program to replace the stub with a bona fide procedure. This facilitates the construction of advanced interactive environments using native code. Some example applications, to Prolog and to incremental compilation, are considered.     

基于CORBA的多层分布式系统研究

CORBA规范实现了分布式系统和面向对象技术的完美结合，实现中使用了代理器，将分布式请求映射到能处理这些请求的实现上，实现不同语言环境（C^ ,Java,Delphi,C等）之间的互调用，并运行在不同的操作系统（如：Windows,Linux,Solaris,Unix等）上，使其灵活运用于多层分布式系统的互操作中。     

Static slicing in Unix process environment

We present a method for computing static slices of concurrent programs in a Unix process environment. As a part of our methodology, we introduce the notion of a Concurrent Program Dependence Graph (CPDG). A CPDG represents various aspects of concurrent programs in a hierarchical fashion. This hierarchical representation lets us compute static slices of programs at different levels of abstraction. Based on our methodology, we have implemented a static slicing tool supporting an option to view slices of programs at different levels of details. Experience with our implementation shows that this approach helps the user get a better understanding of the behavior of concurrent programs. Copyright © 2000 John Wiley & Sons, Ltd.     

采用信任管理的分布式文件系统TrustFs

在传统的分布式文件系统中用户无法判断文件的可信任性,针对此问题提出采用信任管理的分布式文件系统TrustFs,使用数字签名对文件的发布者进行认证,通过信任管理技术评估发布者的可信任度,从而达到帮助用户识别不安全文件的目的。TrustFs使用可堆叠文件系统的技术实现,可以移植到所有的Unix系统,并具有良好的扩展性。     

SPLICE, a computer program for automated extraction of information from GenBank sequence entries

SPLICE, a software tool for the extraction of sequences from files in GenBank tape format, has been developed. The program can analyze the features table in this format and use any of the information provided to write the corresponding sequences into a standard sequence file format suitable for use with sequence analysis programs. Sequences that are present as several subsequent fragments in a single GenBank file, such as those encoding a peptide, can be spliced together by the program. Further, sequences that are present in more than one Genbank file, such as an exon which spans several different files, can also be spliced into one sequence. SPLICE runs under the MS/DOS and Unix operating systems, can be called as a sub-process by other programs and can process batches of files.     

A family of code coverage-based heuristics for effective fault localization

Locating faults in a program can be very time-consuming and arduous, and therefore, there is an increased demand for automated techniques that can assist in the fault localization process. In this paper a code coverage-based method with a family of heuristics is proposed in order to prioritize suspicious code according to its likelihood of containing program bugs. Highly suspicious code (i.e., code that is more likely to contain a bug) should be examined before code that is relatively less suspicious; and in this manner programmers can identify and repair faulty code more efficiently and effectively. We also address two important issues: first, how can each additional failed test case aid in locating program faults; and second, how can each additional successful test case help in locating program faults. We propose that with respect to a piece of code, the contribution of the first failed test case that executes it in computing its likelihood of containing a bug is larger than or equal to that of the second failed test case that executes it, which in turn is larger than or equal to that of the third failed test case that executes it, and so on. This principle is also applied to the contribution provided by successful test cases that execute the piece of code. A tool, χDebug, was implemented to automate the computation of the suspiciousness of the code and the subsequent prioritization of suspicious code for locating program faults. To validate our method case studies were performed on six sets of programs: Siemens suite, Unix suite, space, grep, gzip, and make. Data collected from the studies are supportive of the above claim and also suggest Heuristics III(a), (b) and (c) of our method can effectively reduce the effort spent on fault localization.