bluuebunny/crossref_metadata_2025_split huggingface dataset:
Supra‐RPC: Subprogram parameters in remote procedure calls
Authors: Stoyenko Alexander D. 
Published: November 2006

AbstractRemote‐procedure calls (RPCs) allow distributed, high‐level language programs to communicate and synchronize in the usual manner via subprogram calls. One of the great challenges in RPC research is to preserve the traditiional call semantics despite the distribution and heterogeneity of the new environment.The main contribution of SUPRA‐RPC is in addressing the passing of subprograms as RPC parameters. In doing so, SUPRA overcomes a number of technical difficulties, stemming from scoping, side‐effects and other sources. Since supporting subprogram RPC parameters is harder than supporting non‐subprogram RPC parameters, the three (of six) components of the SUPRA architecture extend in novel ways the traditional functionality found in their counterparts in other RPC systems. The SUPRA stub generator extracts information not only from remote entry interfaces, but from any scope potentially referenced by a subprogram passed as an RPC parameter. In addition to the usual call‐ and accept‐stubs and the marshaling and unmarshaling routines, the generator constructs out‐of‐scope access stubs, callback' and callback‐handling‐stubs, and modified parameter subprograms and others. The SUPRA run‐time support manages a run‐time symbol table to keep track of referencing environments and out‐of‐scope objects. When an out‐of‐scope object is unavailable for access or execution on the server, the object is reached by a synchronous, ‘under‐the‐covers’ callback. The SUPRA process management supports servers with independent threads of control, manages (possibly nested) callbacks and pools of callback handler threads, and maintains correct identification of thread‐initiated calls or callbacks.A SUPRA prototype has been implemented on Sun Unix workstations. The prototype supports C, C++ and CommonLisp programs. A prototype graphical demonstration has been implemented as well, that represents RPC concepts in terms of common life objects and situations.
Compilation of functional languages using flow graph analysis
Authors: Hartel Pieter H. , Glaser Hugh , Wild John M. 
Published: November 2006

AbstractA system based on the notion of a flow graph is used to specify formally and to implement a compiler for a lazy functional language. The compiler takes a simple functional language as input and generates C. The generated C program can then be compiled, and loaded with an extensive run‐time system to provide the facility to experiment with different analysis techniques. The compiler provides a single, unified, efficient, formal framework for all the analysis and synthesis phases, including the generation of C. Many of the standard techniques, such as strictness and boxing analyses, have been included.
Rewriting executable files to measure program behavior
Authors: Larus James R. , Ball Thomas 
Published: November 2006

AbstractInserting instrumentation code in a program is an effective technique for detecting, recording, and measuring many aspects of a program's performance. Instrumentation code can be added at any stage of the compilation process by specially‐modified system tools such as a compiler or linker or by new tools from a measurement system. For several reasons, adding instrumentation code after the compilation process—by rewriting the executable file—presents fewer complications and leads to more complete measurements.This paper describes the difficulties in adding code to executable files that arose in developing the profiling and tracing tools qp and qpt. The techniques used by these tools to instrument programs on MIPS and SPARC processors are applicable in other instrumentation systems running on many processors and operating systems. In addition, many difficulties could have been avoided with minor changes to compilers and executable file formats. These changes would simplify this approach to measuring program performance and make it more generally useful.
The design and implementation of genesis
Authors: Whitfield Deborah , Soffa Mary Lou 
Published: November 2006

AbstractAlthough code optimizations are necessary to parallelize code, few guidelines exist for determining when and where to apply optimizations to produce the most efficient code. The order of applying optimizations can also have an impact on the efficiency of the final target code. However, determining the appropriate optimizations is difficult due to the complex interactions among the optimizations, scheduler and architecture. To aid in selecting appropriate optimizations, an optimizer generator (Genesis) is presented that produces an optimizer from specifications of optimizations. This paper describes the design and implementation of Genesis and demonstrates how such a generator could be used by optimizer designers. Some experiences with the generator are also described.
Using procedural parameters and continuations in combinatorial searches
Authors: Hwang Wen‐Ping , Wang Ching‐Lin 
Published: November 2006

AbstractWe use procedural parameters as a means to cut off unwanted branches in a search tree. The technique may be used to effect non‐blind backtracking. A recursive algorithm for generating all strings of n pairs of balanced parentheses is chosen as an illustrative example, since it cannot be formulated by conventional recursive backtracking.
Simple authentication
Authors: Snow C. R. , Whitfield H. 
Published: November 2006

AbstractThis paper describes a simple authentication protocol for use with terminal emulation programs running on small workstations, and communicating with a host computer over a (potentially) insecure network. The technique has the advantage that it requires no more network traffic than would be necessary using a standard user‐id/password challenge, and also requires only a small amount of additional intelligence at the workstation. Some management issues are also discussed. The system has been implemented on two host systems and two workstation types.
The programming language superpascal
Authors: Hansen Per Brinch 
Published: November 2006

AbstractThis paper defines SuperPascal—a secure programming language for publication of parallel scientific algorithms. SuperPascal extends a subset of IEEE Standard Pascal with deterministic statements for parallel processes and synchronous message communication. A parallel statement denotes parallel execution of a fixed number of statements. A forall statement denotes parallel execution of the same statement by a dynamic number of processes. Recursive procedures may be combined with parallel and forall statements to define recursive parallel processes. Parallel processes communicate by sending typed messages through channels created dynamically. SuperPascal omits ambiguous and insecure features of Pascal. Restrictions on the use of variables enable a single‐pass compiler to check that parallel processes are disjoint, even if the processes use procedures with global variables.
Multimedia e‐mail: The evolution approach based on adapters
Authors: Huang Chung‐Ming , Lo Chung‐Ming 
Published: November 2006

AbstractA lot of current e‐mail systems are ASCII text‐based, e.g. the e‐mail system in Internet. In the coming era of multimedia, e‐mails will be composed of other non‐text‐based information. This paper presents an evolution approach to enhance the capabilities of the current text‐based e‐mail systems. Using the proposed approach, an adapter is added to the top of the current system. As a result, multimedia e‐mails can be transmitted without changing the kernel part of the existing systems. We also propose an encoding scheme that has a 7/8 bandwidth utilization rate. Using this encoding scheme, all of the non‐ASCII data formats, e.g. image, voice, graphics, and so on, will be transformed to the ASCII data formats. Recently, we have developed an experimental multimedia e‐mail system using the proposed method. Our system has been developed on SUN SPARC workstations and an X‐window‐based user‐interface is provided in the system.
Optimizedk‐shortest‐paths algorithm for facility restoration
Authors: Macgregor M. H. , Grover W. D. 
Published: November 2006

AbstractThe problem of finding shortest paths arises in many contexts; testing restoration algorithms and developing design packages for large telecommunications networks are two cases where the simple task of finding sets of restoration paths can consume up to 95 per cent of the execution time of an application program. This paper presents experimental studies of several well‐known shortest‐paths algorithms adapted to the task of finding the k‐successively‐shortest link‐disjoint replacement paths for restoration in a telecommunications network with n nodes. The implementations range in complexity fromO(kn2) when based on Dijkstra's original method, through several improvements to an efficient implementation ofO(kn[v+longn]) complexity, and finally to anO(kn) implementation for the special case of edge‐sparse graphs with small integer edge weights. Here v is the maximum degree of a node in the network. Several alternatives were tested during the course of these studies, particularly with a view to minimizing the number of heap updates, These alternatives are possible because we are searching for several paths between a given pair of nodes, rather than just one path between one or more pairs of nodes. Two fairly straightforward changes yield a decrease in execution time, whereas a more complex heap management strategy consumes as much time in the added code as it releases from the main routine. Experimental results confirm the theoretical complexity of q k n log n) and demonstrate a speed‐up of nearly an order of magnitude over the simplerO(kn2) implementation in the largest networks tested. The optimized implementation is recommended for planning and operational applications of k‐shortest paths rerouting for telecommunications network restoration and restorable network design. If hop counts or small integer link weights can be used to measure distances, then the qkn) implementation is recommended, as typical telecommunications networks are edge‐sparse.
A message‐driven programming system for fine‐grain multicomputers
Authors: Maskit Daniel , Taylor Stephen 
Published: November 2006

AbstractThis paper describes an experimental message‐driven programming system for fine‐grain multicomputers. The initial target architecture is the J‐machine designed at MIT. This machine combines a unique collection of architectural features that include fine‐grain processes, on‐chip associative memory; and hardware support for process synchronization. The programming system uses these mechanisms via a simple message‐driven process model that blurs the distinction between processes and messages: messages correspond to processes that are executed elsewhere in the network. This model allows code and data to be distributed across the computers in the machine, and is supported at every stage of the program development cycle. The prototype system we have developed includes a basic set of programming tools to support the model; these include a compiler, linker, archiver, loader and microkernel. Although the concepts are language independent, our prototype system is based on GNU‐C.
A framework for execution monitoring in icon
Authors: Jeffery Clinton L. , Griswold Ralph E. 
Published: November 2006

AbstractExecution monitors are widely used during software development for tasks that require an understanding of program behavior, such as debugging and profiling. The Icon programming language has been enhanced with a framework that supports execution monitoring. Under the enhanced translator and interpreter, neither source modification nor any special compiler command‐line option is required in order to monitor an Icon program. Execution monitors are written in the source language, instead of the implementation language. Performance, portability, and detailed access to the monitored program's state are achieved using a coroutine model and dynamic loading rather than the separate‐process model employed by many conventional monitoring systems.
DeViouS: A distributed environment for computer vision
Authors: Romig Phillip R. , Samal Ashok 
Published: November 2006

AbstractComputer vision, owing to the size and complexity of its tasks and its importance to industrial and economic growth, was selected as one of the grand challenge problems by the U.S. Federal High Performance Computing Program. Integration of vision operations is identified as a key element of the challenge. A system to integrate computer vision in a distributed environment is presented here. This system, called DeViouS, is based on the client/server model and runs in a heterogeneous environment of Unix workstations. Modern computing environments include large numbers of high‐powered workstations connected by a very fast network. Many of these computers are idle most of the time. DeViouS takes advantage of this feature of computing environments to distribute the execution of vision tasks.Two primary goals of DeViouS are to provide a practical distributed system and a research environment for vision computing. DeViouS is based on a modular design that allows experimentation in various aspects of algorithm design, scheduling and network programming. It can make use of any existing computer vision packages with very minor changes to DeViouS. DeViouS has been tested in an environment of SUN and Digital workstations and has shown substantial improvements in speed over sequential computing with negligible overhead.
Extending a functional programming system for embedded applications
Authors: Wallace Malcolm , Runciman Colin 
Published: November 2006

AbstractFunctional languages do not usually mesh well with embedded applications because of the need for special I/O device‐handling. By introducing a process model to a language, however, it becomes possible to express register‐level device operations and interrupts in a modular manner. This paper describes such a model, its implementation by extension to the Gofer programming system, and examples of its use. Performance results indicate that even this prototype interpretive system is adequate for small applications. The major gain of using a functional language is the ease with which abstraction can be layered over low‐level detail, improving both the readability of code and its tractability.
Declarative specification of the architecture of a software development environment
Authors: Ambriola V. , Ciancarini P. , Corradini A. 
Published: November 2006

AbstractThere is an increasing interest in the study of software architectures; however, it still unclear which kind of formalisms and techniques should be used in their design. We study the suitability of a rule‐based, parallel logic language in the specification of the architecture of a complex software system, i.e. a software development environment. We have used as a case study SMILE, an environment for programming‐in‐the‐large. Because of the declarative, concurrent and object‐oriented features of parallel logic programming, we have been able to design a software architecture that emphasizes the dynamics of co‐ordination inside the software development environment. The result of this experience shows the usefulness and some weaknesses of logic languages for specifying and prototyping the software architecture of a distributed interactive system.
A flexible graphical user interface for performance modeling
Authors: Lin Yi‐Bing , Daly Dan 
Published: November 2006

AbstractWe identify three goals for the graphical user interface (GUI) of a network simulation environment: user friendliness, model re‐usability, and application extensibility. We address the user‐friendliness issue by proposing a simple yet efficient approach to setup parameters for the simulation models. We address the application extensibility issue with a two‐layer GUI architecture. The two layers are loosely coupled, and the first layer can be easily replaced without affecting the other components of the simulation environment. The concept of subnetwork is used to address the model reusability issue. Unlike most existing simulation packages, where a subnetwork is simply a method to group the nodes, the subnetwork construct in our approach is a first‐class citizen in the simulation environment (i.e., all operations for a basic node also apply to a subnetwork). The port concept is used to define the I/O relationship between a subnetwork and the outside world. Parameter dialog boxes are used to set up the parameters for a subnetwork conveniently. Finally, a simple stack mechanism is used to measure subnetwork‐wide output statistics.
Operational machine specification in a functional programming language
Authors: Koopman P. W. M. , Eekelen M. C. J. D. Van , Plasmeijer M. J. 
Published: November 2006

AbstractThis paper advocates the use functional programming languages for the formal specification of (abstract) machines. The presented description method describes machines by a two‐level model. At the bottom layer machine components and the micro instructions to handle them are described by using an abstract data type. The top layer describes the machine instructions in terms of these micro instructions.Using a functional language as specification language has several advantages. The abstraction mechanisms offered by a functional programming language are that good that one can abstract from irrelevant details as is required for a specification language. Functional languages have a well‐defined semantics such that the meaning of the specification is clear as well. Moreover, they offer the advantages of a programming language: the compiler can check the specification for partial correctness, eliminating for example type errors and unbound identifiers (errors which occur in many published descriptions). Furthermore, the specification can be executed such that one obtains a prototype implementation almost for free. Such an executable formal specification can, for instance, be used to investigate the dynamic behaviour of the described machine.For a simple machine, the proposed description method is compared with several other description methods: a traditional style, a denotational semantics and a formal specification in the language Z. To show that the proposed method is indeed useful to describe large and complicated machines, the method is applied for the specification of an abstract imperative graph rewrite machine (the ABC‐machine) which has been used in the construction of the compiler for the functional language Concurrent Clean.
Using multicast communications to distribute code and data in wide area networks
Authors: Knight Jon , Guest Steve 
Published: November 2006

AbstractThis paper describes the implementation and use of a prototype multicast late‐binding RPC (LbRPC) system. The system provides a mechanism for exporting arbitrary code and data across a wide area internetwork to multiple hosts for evaluation. This mechanism provides a means to ensure that the total execution time for the application is as small as possible without requiring continual monitoring and estimation of the state of the hosts and the intervening network. The impact of sending the same code and data to a group of remote hosts is minimized by using multicast Internet protocol (IP) communications for the outward leg of the transaction. This prototype implementation demonstrates the feasibility of using multicasting for process placement and some performance measurements are included to show how it stands up to usage on the Internet. The paper concludes with a discussion of outstanding issues raised by this research.
Automatic verification of properties in transition systems
Authors: Arnold A. , Brlek S. 
Published: November 2006

AbstractThe aim of this paper is to show the use of MEC, an automated tool for analysing transition systems, for discovering deadlocks, livelocks and other properties of a given transition system. The features of MEC are shown with two instructive examples: first, the analysis of an electronic mail system, first analysed by G. Brebner using the concurrency work bench (another automated analysis tool); second, the analysis of a simple call‐processing system originating from Bell‐Northern‐Research.
Runtime and language support for compiling adaptive irregular programs on distributed‐memory machines
Authors: Hwang Yuan‐Shin , Moon Bongki , Sharma Shamik D. , Ponnusamy Ravi , Das Raja , Saltz Joel H. 
Published: November 2006

AbstractIn many scientific applications, arrays containing data are indirectly indexed through indirection arrays. Such scientific applications are called irregular programs and are a distinct class of applications that require special techniques for parallelization.This paper presents a library called CHAOS, which helps users implement irregular programs on distributed‐memory message‐passing machines, such as the Paragon, Delta, CM‐5 and SP‐1. The CHAOS library provides efficient runtime primitives for distributing data and computation over processors; it supports efficient index translation mechanisms and provides users high‐level mechanisms for optimizing communication. CHAOS subsumes the previous PARTI library and supports a larger class of applications. In particular, it provides efficient support for parallelization of adaptive irregular programs where indirection arrays are modified during the course of computation. To demonstrate the efficacy of CHAOS, two challenging real‐life adaptive applications were parallelized using CHAOS primitives: a molecular dynamics code, CHARMM, and a particle‐in‐cell code, DSMC.Besides providing runtime support to users, CHAOS can also be used by compilers to automatically parallelize irregular applications. This paper demonstrates how CHAOS can be effectively used in such a framework. By embedding CHAOS primitives in the Syracuse Fortran 90D/HPF compiler, kernels taken from the CHARMM and DSMC codes have been automatically parallelized.
Parallel 1D‐FFT computation on constant‐valence multicomputers
Authors: Mazzeo Antonino , Villano Umberto 
Published: November 2006

AbstractThis paper addresses the problem of monodimensional (1D) FFT parallel computation on constant‐valence multicomputers, i.e. on parallel systems made up of processing elements (PEs) which do not share memory and are connected to a bounded number of neighbours. After a qualitative analysis of several possible partitionings of the DIT FFT algorithm, a decomposition is introduced that has good scalability properties and makes it possible to use sections of sequential code based on the most common 1D‐FFT algorithms. If a computing architecture with indirect binary n‐cube interconnection network is used, the proposed decomposition guarantees strictly local communications and therefore requires no through‐routing support. These characteristics have a positive impact on software development and also on overall performance. Furthermore, thanks to a pipelined organization of the PEs, the resulting architecture has high potentialities for real‐time signal processing. As these useful features are obtained at the ‘expense’ of an uneven workload distribution, computing efficiency is relatively low but does not significantly change in a wide range of the number of processors. An implementation on a Transputer‐based system is presented along with the performance results obtained. Finally a simple analytical model of the architecture is shown, that allows the values of the main performance parameters to be obtained as a function of the number of processors used and of the elementary response times of the first stage of PEs.