Concurrent Programming Environment Research Articles

Molecule

Molecule is a domain specific language library embedded in Scala for easing the creation of scalable and modular concurrent applications on the JVM. Concurrent applications are modeled as parallel process networks that exchange information over mobile and type-safe messaging interfaces. In this paper, we present a concurrent programming environment that combines functional and imperative programming. Using a monad, we structure the sequential or parallel coordination of user-level threads, without JVM modifications or compiler support. Our mobile channel interfaces expose reusable and parallelizable higher-order functions, as if they were streams in a lazily evaluated functional programming language. The support for graceful termination of entire process networks is simplified by integrating channel poisoning with monadic exceptions and resource control. Our runtime and system-level interfaces leverage message batching and a novel flow parallel scheduler to limit expensive context switches in multicore environments. We illustrate the expressiveness and performance benefits on a 24-core AMD Opteron machine with three classical examples: a thread ring, a genuine prime sieve and a chameneos-redux.

A robust monitor construct with runtime fault detection

AbstractThe monitor concept provides a structured and flexible high‐level programming construct to control concurrent accesses to shared resources. It has been widely used in a concurrent programming environment for implicitly ensuring mutual exclusion and explicitly achieving process synchronization. This paper proposes an extension to the monitor construct for detecting runtime errors in monitor operations. Monitors are studied and classified according to their functional characteristics. A taxonomy of concurrency control faults over a monitor is then defined. The concepts of a monitor event sequence and a monitor state sequence provide a uniform approach to history information recording and fault detection. Rules for detecting various types of faults are defined. Based on these rules, fault‐detection algorithms are developed. A prototypical implementation of the proposed monitor construct with runtime fault detection mechanisms has been developed in Java. We shall briefly report our experience with and the evaluation of the robust monitor prototype. Copyright © 2005 John Wiley & Sons, Ltd.

JDM: BUILDING DISTRIBUTED SYNCHRONIZATION SUPPORT INTO JAVA

The monitor concept has been widely used in a concurrent programming environment for implicitly ensuring mutual exclusion and explicitly achieving process synchronization. It has also been extended to support high-level distributed programming. In this paper, we present JDM, a distributed monitor construct in Java for programming large-scale distributed systems. The distributed monitor construct is based on a well-know tree-based distributed mutual exclusion algorithm proposed by K. Raymond. To increase scalability of the construct, a two-level system architecture is developed, where the node level controls the access to the system-wide shared resources using Raymond's algorithm and the process level synchronizes local processes based on the local monitor concept. An object-oriented design of the system architecture is presented. Implementation and results of performance evaluation are reported and factors that influence the performance of the construct are discussed.

Developing technologies for broad-network concurrent computing

Abstract Recent developments in networking infrastructures, computer workstation capabilities, software tools, and programming languages have motivated new approaches to broad-network concurrent computing. This paper describes extensions to concurrent computing which blend new and evolving technologies to extend users' access to resources beyond their local network. The result is a concurrent programming environment which can dynamically extend over network and file system boundaries to envelope additional resources, to enable multiple-user collaborative programming, and to achieve a more optimal process mapping. Additional aspects of the derivative environment feature extended portability and support for the accessing of legacy codes and packages. This paper describes the advantages of such a design and how they have been implemented in the environment termed “IceT”.

Recent advances in memory consistency models for hardware shared memory systems

The memory consistency model of a shared memory system determines the order in which memory operations will appear to execute to the programmer. The memory consistency model for a system typically involves a tradeoff between performance and programmability. The paper provides an overview of recent advances in hardware optimizations; compiler optimizations, and programming environments relevant to memory consistency models of hardware distributed shared memory systems. We discuss recent hardware and compiler optimizations that exploit the observation that it is sufficient to only appear as if the ordering rules of the consistency model are obeyed. These optimizations substantially improve the performance of the strictest consistency model, making it more attractive for its programmability. Recent concurrent programming languages and environments, on the other hand, support more relaxed consistency models. We discuss several such environments, including POSIX threads, Java, and OpenMP.

The inheritance of PN-COOPN

An appropriate combination of COOP and Petri nets is required in order to profit from the strength of both methods. This paper gives an overview of our ongoing research on PN-COOPN, which is a paradigm and development environment for concurrent object-oriented programming based on Petri nets. We describe the object model and programming notation and emphasis the inheritance part for PN-COOPN.

Specifying Real-Time Finite-State Systems in Linear Logic (Extended Abstract)

AbstractReal-time finite-state systems may be specified in linear logic by means of linear implications between conjunctions of fixed finite length. In this setting, where time is treated as a dense linear ordering, safety properties may be expressed as certain provability problems. These provability problems are shown to be in pspace. They are solvable, with some guidance, by finite proof search in concurrent logic programming environments based on linear logic and acting as sort of model-checkers. One advantage of our approach is that either it provides unsafe runs or it actually establishes safety.

A simple student environment for lightweight process concurrent programming under SunOs

This paper describes a simplified student environment for lightweight processes (threads) under SunOs or compatible systems. The environment is built on top of the SunOs lwp package. A range of concurrency facilities are provided including critical sections, events and signals, and monitors. A hidden scheduler enhances the effects of the nondeterminacy, even for small student programs. A sample assignment is shown using the package.

Topological properties, communication, and computation on WK‐recursive networks

AbstractRecently, with the support of the CAPRI (Concurrent Architecture and PRogramming environment for highly Integrated system) project, Vecchia and Sanges proposed a new general class of recursively scalable networks, termed WK‐recursive networks, and developed routing and broadcasting algorithms on them. They have also implemented the WK‐recursive networks using VLSI technology. This paper studies WK‐recursive networks by first investigating their topological properties such as diameter, connectivity, and Hamiltonicity. We then develop new and more efficient routing and broadcasting algorithms. Our routing algorithm can guarantee the shortest paths. Our broadcasting algorithm is much simpler and requires fewer extra bits to be transmitted. The broadcasting tree of our broadcasting algorithm is of minimal height (equal to the diameter), and each node receives the message exactly once. Moreover, we show the execution of descend/ ascend algorithms on the WK‐recursive networks using the bitonic sort as an illustrative example. © 1994 by John Wiley & Sons, Inc.

Data structure and process data traversal in a manufacturing cell controller

For manufacturing cells used in flexible manufacturing systems (FMS), a cell control system functions autonomously in coordinating the operations of all equipment and a material handling robot in the cell. Since the sequential approach to cell control cannot handle multiple and simultaneous tasks, a cell controller is developed in a concurrent programming environment. The data structures required by the cell control operation are defined, including that for the product, the AGV, the robot, the processes and the system I/O. All data structures are stored in a public memory area that is accessible to all processes. Control tasks are achieved by traversing these data structures and dynamically constructing a control command with the necessary process data in run-time. It is shown that an autonomous control system using multi-tasking and software interrupt techniques is useful for the real-time control of cell production, and software modularity provides a good flexibility to adapting system changes. The relation of the cell control data structure and the overall manufacturing system's database is also briefly discussed.

Experience with the language SR in an undergraduate operating systems course

In undergraduate operating systems classes, students learn about concurrent process synchronization, including such things as shared data, race conditions, critical sections, mutual exclusion, semaphores, monitors, and the test-and-set hardware instruction. They also study interprocess communication, message passing, rendezvous, and remote procedure calls. Solutions to classical problems, such as the dining philosophers, producers and consumers, bounded buffers, and readers and writers, are presented using the above concepts. However, students need to write programs in a language that provides facilities for concurrent programming in order to appreciate fully the above concepts. This paper describes the SR language and discusses its successful use as an environment for concurrent programming in an undergraduate operating systems class.

I-Pigs: an Interactive Graphical Environment for Concurrent Programming

I-Pigs: an Interactive Graphical Environment for Concurrent Programming

Developing concurrent processing applications to power system planning and operations

The implementation of existing power system applications in a concurrent programming environment is discussed. The tools comprise a multiprocessor computing system with concurrent processing software facilities and a concurrent processing simulator for helping on problem partition and debugging. Shorter execution times taking into account the solution structure are obtained. Three case studies are used to illustrate the application of the above tools and the development methodology: multiarea reliability, system analysis model, and security-constrained dispatch with postcontingency corrective rescheduling. Results show a very high efficiency in the use of the concurrent processors.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Secondary storage in a concurrent logic programming environment

This paper presents a declarative approach to secondary storage in a logic programming environment. We begin with a simple, but powerful, storage model which unifies the ideas of nonvolatile storage and a file system. Using a parallel logic programming language, a succinct specification of the model is given. The specification, with minor modification, forms an implementation. The implementation is described and critiqued. An improved second model is presented which advocates secondary storage through a declarative nonvolatile storage medium and a separate file system. An implementation is again easily realized. Features of the implementation are discussed. This work develops a model and implementation of term-based, declarative I/O. Side effects and destructive assignment are avoided. Concepts developed include device processors, unique compact representations, and lazy-term expansion. Information transfer is unification based, so file abstractions do not require explicit read and write operations. The parallel logic program language used is Concurrent Prolog.

An environment for concurrent programming in Pascal

This paper presents the specification and implementation of a kernel supporting an environment oriented towards the development and execution of concurrent programs written in an extension of PASCAL. The environment is based on the TURBO PASCAL which was extended with constructs providing mechanisms to express and synchronize the concurrent execution of processes. In addition to the specification and implementation details of the kernel, the paper also outlines the use of the environment in the development of parallel programs, and describes the current stage of the work which should lead to the migration of the environment to a parallel host machine.

HCRC-Parallel computer: A massively parallel combined architecture supercomputer

This paper describes the HCRC-parallel computer prototype, a massively parallel supercomputer able to effectively support various programming style (imperative, logic, functional and object-oriented) and to exploit several types of concurrency and granularity. After a short description of the project objectives and main guidelines, the chosen high level concurrent system language is shown along with its concurrent programming environment. Further, the system overall organization is described on the basis of interconnection network topology and processing node architecture.

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.

Network programming with MUPPET

MUPPET is a network programming environment for scientific computing with message-based multiprocessors. It consists of four parts—concurrent languages, programming environments, application environments, and man-machine interfaces. The programming paradigm of MUPPET is based on parallel abstract machines. In this paper we discuss the MUPPET programming paradigm. We give an introduction to the the graphical specification system GONZO and the transformation system TROLLO. The graphical specification system uses graphics as a tool for programming. From the graphical specification a parallel program frame is generated. It is also used for mapping the process graph to the processor topology.

Introductory concurrent programming with Modula-2

Modula-2 can be a useful language for teaching the principles of concurrent programming. Although the language does not provide any particular process synchronisation primitives, its facilities for defining user modules and for low-level machine access enable it to be extended to support a variety of concurrency mechanisms. A description is given of how Module-2 may be used to provide a concurrent programming environment to give practical support to an undergraduate course in operating systems.

Interactive debugging of concurrent programs

This paper summarizes techniques for designing and implementing source-level interactive debuggers for concurrent programs. Facilities common to source-level interactive debuggers have been adapted to meet the needs of a concurrent programming environment. Of special interest are those debugging facilities which allow the programmer to monitor and influence the execution of concurrent processes.