Bugs in distributed systems are often hard to find. Many bugs reflect discrepancies between a system’s behavior and the programmer’s assumptions about that behavior. We present Pip 1, an infrastructure for comparing actual behavior and expected behavior to expose structural errors and performance problems in distributed systems. Pip allows programmers to express, in a declarative language, expectations about the system’s communications structure, timing, and resource consumption. Pip includes system instrumentation and annotation tools to log actual system behavior, and visualization and query tools for exploring expected and unexpected behavior 2. Pip allows a developer to quickly understand and debug both familiar and unfamiliar systems. We applied Pip to several applications, including FAB, SplitStream, Bullet, and RanSub. We generated most of the instrumentation for all four applications automatically. We found the needed expectations easy to write, starting in each case with automatically generated expectations. Pip found unexpected behavior in each application, and helped to isolate the causes of poor performance and incorrect behavior. 1

The concurrent functional programming language Erlang has been designed to ease the development of large-scale distributed soft real-time control applications. So far, it has been used quite successfully in industry, both within Ericsson Telecom, where it was designed and developed, and by other companies. This "declarative language success-story" has taken place despite the fact that Erlang implementations are slow compared with implementations of other functional languages. Wanting to improve the performance aspects of publicly available Erlang implementations, which are based on emulators, we embarked on a project called HiPE (High-Performance Erlang) whose aim has been to develop an efficient just-in-time native code compiler for Erlang (called the HiPE system). Since its start in 1996, the system has gone through various (re-)design phases, partly due to implementation choices that did not turn out to be as promising as they appeared on paper, but mainly due to changes in Ericsson's Erlang system upon which the HiPE system is built. In this article, we describe how the HiPE system was developed, what it currently looks like, and its current performance. We critically examine design decisions that we took, and the main lessons learnt from implementing them. Finally, we also report on our experiences from trying to keep up with the concurrent development of Ericsson's base Erlang system. As such, this article both documents the HiPE system and can serve as possible guidance to anyone wishing to attempt a sinhi- lar feat.

language Erlang. The system is based on two concepts; a (forward) data flow analysis that determines upper approximations of the possible values of expressions and other constructs, and a specification language that allows the programmer to specify the interface of a module. We examine the programming language Erlang and point to various aspects of the language that make it hard to type. We present experimental result of applying the soft-typing system to some previously written programs.

We propose an extension to Fredlund’s formal semantics for Erlang that models the concept of nodes. The motivation is that there exist sequences of events that can occur in practice, but are impossible to describe using a single-node semantics, such as Fredlund’s. The consequence is that some errors in distributed systems might not be detected by model checkers based on Fredlund’s original semantics, or by other single-node verification techniques such as testing. Our extension is modest; it re-uses most of Fredlund’s work but adds an extra layer at the top-level.

Abstract. We describe an analysis-driven storage allocation scheme for concurrent languages that use message passing with copying semantics. The basic principle is that in such a language, data which is not part of any message does not need to be allocated in a shared data area. This allows for deallocation of threadspecific data without requiring global synchronization and often without even triggering garbage collection. On the other hand, data that is part of a message should preferably be allocated on a shared area, which allows for fast (O(1)) interprocess communication that does not require actual copying. In the context of a dynamically typed, higher-order, concurrent functional language, we present a static message analysis which guides the allocation. As shown by our performance evaluation, conducted using an industrial-strength language implementation, the analysis is effective enough to discover most data which is to be used as a message, and to allow the allocation scheme to combine the best performance characteristics of both a process-centric and a shared-heap memory architecture. 1

We describe an analysis-driven storage allocation scheme for concurrent systems that use message passing with copying semantics. The basic principle is that in such a system, data which is not part of any message does not need to be allocated in a shared data area. This allows for deallocation of thread-specific data without requiring global synchronization and often without even triggering garbage collection. On the other hand, data that is part of a message should preferably be allocated on a shared area, which allows for fast (O(1)) interprocess communication that does not require actual copying. In the context of a dynamically typed, higher-order, concurrent functional language, we present a static message analysis which guides the allocation. As shown by our performance evaluation, conducted using an industrial-strength language implementation, the analysis is effective enough to discover most data which is to be used as a message, and to allow the allocation scheme to combine the best performance characteristics of both a process-centric and a communal memory architecture.

In order to formally reason about distributed Erlang systems, it is necessary to have a formal semantics. In a previous paper we have proposed such a semantics for distributed Erlang. However, recent work with a model checker for Erlang revealed that the previous attempt was not good enough. In this paper we present a more accurate semantics for distributed Erlang. The more accurate semantics includes several modifications and additions to the semantics for distributed Erlang proposed by Claessen and Svensson in 2005, which in turn is an extension to Fredlund’s formal single-node semantics for Erlang. The most distinct addition to the previous semantics is the possibility to correctly model disconnected nodes.

Abstract. This paper presents a type analysis for the programming language Erlang. The analysis computes interprocedural control-flow and data-flow information, and should be applicable to any higher-order functional programming language with call-by-value semantics. The analysis uses a novel method for polyvariance, static limiting, where an approximation of the call graph is analyzed to determine whether a function should be treated as polyvariant or monovariant. A general framework for polyvariant analysis is presented. This framework is used for experimental investigations to evaluate the cost and potential benefits of polyvariant analysis and to compare different approaches to polyvariant analysis. The experimental results show that static limiting gives the same or better precision as the other polyvariant analyses, while having more predictable analysis times. However, the experiments show only small improvements in precision for the various polyvariant analyses. 1

Erlang is a concurrent functional language, especially tailored for distributed and fault-tolerant software. Its strength has been demonstrated by several successful commercial applications. An important part of Erlang is its support for fault tolerance by implementing failure-recovery, through organising the processes of an Erlang system into trees of processes, in which parent nodes monitor the failure status of their children and are responsible for their restart. In this paper we present ongoing work on a tool that captures the static part of the global process structure of an application Erlang. The tool extracts the process structure from the applications source code, and presents it as a process creation graph. The extracted process structure provides a starting point for understanding and analysis of aspects such as fault handling in Erlang applications.

With the rise of the internet has come a rise in the importance of distributed systems. Distributed systems—groups of networked computers cooperating to run a single application or service—power modern web sites and communication services, infrastructure services like content-distribution networks and overlay networks, and parallel computations. With the complexity of distributed systems comes bugs: errors that affect a system’s correctness, performance, or both. Traditional debugging tools and methods do not apply well to distributed systems. Thus, new tools are needed that will enable programmers to find and fix bugs in distributed systems. These improvements will in turn improve the performance and reliability that end users experience. Many bugs reflect discrepancies between a system’s behavior and the programmer’s assumptions about that behavior. In this thesis, we show that expressing distributed system behavior as a set of causal paths and helping programmers separate