Distributed Control Flow Research Articles

Translating active objects into colored Petri nets for communication analysis

Actor-based languages attract attention for their ability to scale to highly parallel architectures. Active objects combine the asynchronous communication of actors with object-oriented programming by means of asynchronous method calls and synchronization on futures. However, the combination of asynchronous calls and synchronization may introduce communication cycles which lead to a form of communication deadlock and livelock. This paper addresses such communication deadlocks and livelocks for ABS, a formally defined active object language which additionally supports cooperative scheduling to express complex distributed control flow, using first-class futures and explicit process release points. Our approach is based on a translation of the semantics of ABS into colored Petri nets, such that a program and its state correspond to a marking of this net. We prove the soundness of this translation and demonstrate by example how the implementation of this net can be used to analyze ABS programs with respect to communication deadlocks and livelocks.

Improving communication latency with the write-only architecture

This paper introduces a novel execution paradigm called the Write-Only Architecture (WOA) that reduces communication latency overheads by up to a factor of five over previous methods. The WOA writes data through distributed control flow logic rather than using a read–write paradigm or a centralised message hub which allows tasks to be partitioned at a fine-grained level without suffering from excessive communication overheads on distributed systems. In this paper we provide formal assignment results for software benchmarks partitioned using the WOA and previous execution paradigms for distributed heterogeneous architectures along with bounds and complexity information to demonstrate the robust performance improvements possible with the WOA.

Serialization of Distributed Threads in Java

In this paper we present a mechanism for serializing the execution-state of a distributed Java application that is implemented on a conventional Object Request Broker (ORB) architecture such as Java Remote Method Invocation (RMI). To support serialization of distributed execution-state, we developed a byte code transformer and associated management subsystem that adds this functionality to a Java application by extracting execution-state from the application code. An important benefit of our mechanism is its portability. It can transparently be integrated into any legacy Java application. Furthermore, it does require no modifications to the Java Virtual Machine (JVM) or to the underlying ORB. Our serialization mechanism can serve many purposes such as migrating execution-state over the network or storing it on disk. In particular, we describe the implementation of a prototype for repartitioning distributed Java applications at run-time. Proper partitioning of distributed objects over the different machines is critical to the global performance of the distributed application. Methods for partitioning exist, and employ a graph-based model of the application being partitioned. Our mechanism enables then applying these methods at any point in an ongoing distributed computation. In the implementation of the management subsystem, we experienced the problem of losing logical thread identity when the distributed control flow crosses address space boundaries. We solved this well known problem by introducing the generic notion of distributed thread identity in Java programming. Propagation of a globally unique, distributed thread identity provides a uniform mechanism by which all the program's constituent objects involved in a distributed control flow can uniquely refer to that distributed thread as one and the same computational entity

Distributed call-tracking for security

In this paper, we introduce a functional language which facilitates the mobility of code between the sites of a distributed system. We observe that code mobility renders systems with limited resources vulnerable to denial-of-service attacks. Languages which are designed with the objective of preventing these attacks would benefit from static analysis which can expose the resource consumption of programs. In functional computation there is a close connection between the consumption of resources and the flow of control within the system. We show that it is possible to exploit type systems to perform distributed control flow analysis and discuss the potential applications of such analyses in promoting security of resource-sensitive systems.