A debugger for parallel processes

A system for analysing and debugging parallel Fortran codes is in use on the Sun workstation. The system is composed of a parallel processing simulator mtsim, a window- and mouse-based debugging tool mtdbx, and a set of real-time display routines. The simulator mtsim, 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 debugger mtdbx is based on the Sun dbxtool debugging 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.     

A high-level debugger for PL/I,Fortran and Basic

Dartmouth College has implemented a single debugger for several languages sharing a common runtime environment: PL/I, Basic and Fortran. The debugger is fairly powerful; users set breakpoints and traces which occur whenever the values of given variables change, or whenever certain relational expressions become true, for example. All debugging is carried on in a syntax similar to that of a high-level language. This debugger was implemented in about a month. It should be fairly easy to implement on most timesharing systems. This paper describes the debugger's user interface and gives a rough sketch of its implementation.     

An addendum to G. S. Blair,J. A. Mariani and W. D. Shepherd: ‘A practical extension to unix for interprocess communication’

Long 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.     

Design of an interactive debugger for FORTRAN: MANTIS

MANTIS is a natural debugging facility for the FORTRAN language subsystem on the PDP-10. It was designed and implemented in an existing language subsystem in order to facilitate program preparation and debugging in the time sharing environment available on the PDP-10. Suitable debugging facilities should be included in the initial design of language subsystems. Language subsystems to run in time sharing operating systems should offer debugging facilities that exploit the interactive environment available to the user. This paper describes experience gained in designing and adding a useful interactive debugger to an existing FORTRAN subsystem. Objectives, implementation experience and system features are discussed and are related to the general problem of designing debuggers for language subsystems.     

Concurrent C语言单处理机版本的实现

Concurrent C是一种支持并发程序设计的语言,它是C语言的一个超集。本文讨论Concurrent C语言在运行XENIX或UNIX操作系统的单处理机上的实现。     

The peregrine high-performance RPC system

The Peregrine RPC system provides performance very close to the optimum allowed by the hardware limits, while still supporting the complete RPC model. Implemented on an Ethernet network of Sun-3/60 workstations, a null RPC between two user-level threads executing on separate machines requires 573μs. This time compares well with the fastest network RPC times reported in the literature, ranging from about 1100 to 2600 μs, and is only 309 μs above the measured hardware latency for transmitting the call and result packets in our environment. For large multi-packet RPC calls, the Peregrine user-level data transfer rate reaches 8.9 Mbit/s, approaching the Ethernet's 10 Mbit/s network transmission rate. Between two user-level threads on the same machine, a null RPC requires 149 μs. This paper identifies some of the key performance optimizations used in Peregrine, and quantitatively assesses their benefits.     

A debugger for concurrent programs

This paper reports on an experimental debugger for concurrent programs. Design objectives include a showing of greatest usefulness when dealing with multiprocess interactions, creation of a simplified more approachable interface for programmers, allowance for the systematic organization (and limitation) of debugging information by programmers, reflection of a natural view of concurrency, and portability. The design responds to a perceived need for debugging techniques applicable in systems of concurrent, communicating, asynchronous processes. During debugging sessions, a user is able to dynamically explore interprocess synchronization points, parallel actions and deadlock situations. The programmer interface is based on a transparent window multiplexer providing a set of windows for each concurrent process. The window manager interactively maps interesting windows to programmer-specified viewscreen locations, while relegating temporarily uninteresting windows to the background. In implementing a debugger for concurrent programs, a principal concern is the probe effect, or the possibility that the debugger itself masks synchronization errors in the program being debugged. For the examples explored, the probe effect was not observed to limit the localization of implanted synchronization errors.     

Structured flowcharts for multiprocessing

We present a flowchart language for parallel processing: in addition to the “standard” components, our flowcharts contain fork, join and synchronizing nodes. Extending the work of Mills, we suggest restrictions on controlling computation flow and show that any proper program can be algorithmically transformed to an equivalent structured program.     

A debugger for Ada tasking

The capabilities needed in an Ada debugger are discussed in light of the language's tasking constructs, and the design for a debugger is presented which operates in concert with a single-processor Ada interpreter. This debugger design demonstrates the extensions to sequential debugging techniques that are necessary to handle concurrency, and shows that significant debugging functionality can be provided even without the inclusion of automatic error diagnosis methods. The issues considered include isolation of effects and display of the full dynamic execution status, both of which are essential to diagnosis of concurrent programs     

The performance of message-passing using restricted virtual memory remapping

DASH is a distributed operating system kernel. Message-passing (MP) is used for local communication, and the MP system uses virtual memory ( VM) remapping instead of software memory copying for moving large amounts of data between virtual address spaces. Remapping eliminates a potential communication bottleneck and may increase the feasibility of moving services such as file services to the user level. Previous systems that have used VM remapping for message transfer, however, have suffered from high per-operation delay, limiting the use of the technique. The DASH design reduces this delay by restricting the generality of remapping: a fixed part of every space is reserved for remapping, and a page's virtual address does not change when it is moved between spaces. We measured the performance of the DASH kernel for Sun 3/50 workstations, on which memory can be copied at 3·9 MB/s. Using remapping, DASH can move large messages between user spaces at a rate of 39 MB/s if they are not referenced and 24·8 MB/s if each page is referenced. Furthermore, the per-operation delay is low, so VM remapping is beneficial even for messages containing only one page. To further understand the performance of the DASH MP system, we broke an MP operation into short code segments and timed them with microsecond precision. The results show the relative costs of data movement and the other components of MP operations, and allow us to evaluate several specific design decisions.     

A debugger for a graphical workstation

This paper describes the ups source-level debugger. Ups, which is designed to take advantage of the graphics and mouse available on a workstation, displays the debugged program's current state in the form of a hierarchically structured document in which items of interest can be expanded to show more detail. User interaction is via a system of menus and editable subfields, the intention being to create a debugger which has a lot of functionality but is easy to learn and easy to remember. The paper describes the ups user interface itself and discusses its implementaion, which may be of interest to anyone writing a program with an interface based on menus and editable fields. There is also a discussion of some of the problems that will be encountered by anyone trying to write a new debugger to run in an existing environment.     

MUPPET: A programming environment for message-based multiprocessors

MUPPET is a problem-solving environment for scientific computing with message-based multiprocessors. It consists of four part—concurrent languages, programming environments, application environments and man-machine interfaces. The programming paradigm of MUPPET is based on parallel abstract machines and transformations between them. This paradigm allows the development of programs which are portable among multiprocessors with different interconnection topologies.

In this paper we discuss the MUPPET programming paradigm. We give an introduction to the language CONCURRENT MODULA-2 and the graphic specification system GONZO. The graphic specification system tries to introduce graphics as a tool for programming. It is also the basis for programming generation and transformation.     

A message-based cocktail watermarking system

A noise-type Gaussian sequence is most commonly used as a watermark to claim ownership of media data. However, only a 1-bit information payload is carried in this type of watermark. For a logo-type watermark, the situation is better because it is visually recognizable and more information can be carried. However, since the sizes and shapes of logos for different organizations are different, the flexibility of use of a logo-type watermark will certainly be degraded. In this paper, a more flexible type of watermark, i.e., a message, is designed. Since a message is composed of a finite number of ASCII-type characters, it is by nature vulnerable to attacks. Therefore, we propose to choose a set of nonlinear Hadamard-codes that has the maximum Hamming distance between any two constituent codes to replace the original ASCII-type inputs. This design will make our system much more fault-tolerant in comparison with ASCII-code based systems under direct attack. To recover an attacked Hadamard code, we use a trained backpropagation neural network to perform inexact matching. The proposed Hadamard code-based message is embedded using the cocktail-watermarking scheme (IEEE Trans. Multimedia 2 (4) (2000) 209-224) for copyright protection. Experimental results demonstrate that our message-based cocktail watermarking system is superb in terms of robustness and flexibility.     

A dynamic debugger for asynchronous distributed algorithms

LPdbx is a distributed runtime debugger for loosely coupled parallel processors with an iconic interface. When a program suspends, users can insert additional breakpoints and examine global variables, structures, and pointer references. It has been used to debug banking and transportation applications and is available for distribution     

A component- and message-based architectural style for GUI software

While a large fraction of application code is devoted to graphical user interface (GUI) functions, support for reuse in this domain has largely been confined to the creation of GUI toolkits (“widgets”). We present a novel architectural style directed at supporting larger grain reuse and flexible system composition. Moreover, the style supports design of distributed, concurrent applications. Asynchronous notification messages and asynchronous request messages are the sole basis for intercomponent communication. A key aspect of the style is that components are not built with any dependencies on what typically would be considered lower-level components, such as user interface toolkits. Indeed, all components are oblivious to the existence of any components to which notification messages are sent. While our focus has been on applications involving graphical user interfaces, the style has the potential for broader applicability. Several trial applications using the style are described     

基于Win95的网络协议软件开发技术

网络协议软件的开发技术因为涉及到操作系统核心,所以大多没有公开的资料。以一个ＩＰ网关的实现为基础,阐述了网络协议软件在Ｗｉｎ９５中的开发方法。重点讨论了网络接口的实现,进程通信和内在管理等核心技术。     

A semantic framework for open processes

We propose a general methodology for analysing the behaviour of open systems modelled as coordinators, i.e., open terms of suitable process calculi. A coordinator is understood as a process with holes or placeholders where other coordinators and components (i.e., closed terms) can be plugged in, thus influencing its behaviour. The operational semantics of coordinators is given by means of a symbolic transition system, where states are coordinators and transitions are labeled by spatial/modal formulae expressing the potential interaction that plugged components may enable. Behavioural equivalences for coordinators, like strong and weak bisimilarities, can be straightforwardly defined over such a transition system. Different from other approaches based on universal closures, i.e., where two coordinators are considered equivalent when all their closed instances are equivalent, our semantics preserves the openness of the system during its evolution, thus allowing dynamic instantiation to be accounted for in the semantics. To further support the adequacy of the construction, we show that our symbolic equivalences provide correct approximations of their universally closed counterparts, coinciding with them over closed components. For process calculi in suitable formats, we show how tractable symbolic semantics can be defined constructively using unification.     

Dbxtool: A window-based symbolic debugger for sun workstations

Dbxtool is a window- and mouse-based debugger for C, Pascal and FORTRAN programs running on Sun workstations. Its use of the mouse as the primary input mechanism eliminates the need to type variables, line numbers, breakpoints and most commands. Its multiple windows provide several qualitatively different perspectives on the debugging problem. Compared to the Unix 4.2 BSD dbx from which it is derived, it has been extended with the abilities to debug multiple-process programs, already-running processes, and the Sun Operating System kernel.