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.

Abstract. A hot spot of a program is a program region, whose execution time crucially impacts the overall execution time of the program. A hot spot can often be optimized without fully analyzing the whole program. This is supported by approaches for demand-driven data-flow analysis. Particularly successful in practice turned out to be an approach based on reverse data-flow analysis. In this paper, we reconsider this approach. By recalling the Reverse Safety and Coincidence Theorem and the Link Theorem we highlight the duality of classical and reverse data-flow analysis and their relationship to each other. This addresses a common gap in previous presentations of this approach and sheds light on the formal foundation underlying the construction of correct and precise demand-driven data-flow analyses based on reverse data-flow analysis. We illustrate the usability of this approach for hot-spot program optimization. It is useful, however, for other applications, too, such as just-in-time compilation and debugging. 1

Abstract. The increasing demands for highly performant, proven correct, easily maintainable, extensible programs together with the continuous growth of real-world programs strengthen the pressure for powerful and scalable program analyses for program development and code generation. Multi-core computing systems offer new chances for enhancing the scalability of program analyses, if the additional computing power offered by these systems can be used effectively. This, however, poses new challenges on the analysis side. In principle, it requires program analyses which can be easily parallelized and mapped to multi-core architectures. In this paper we remind to reverse data-flow analysis, which has been introduced and investigated in the context of demand-driven data-flow analysis, as one such class of program analyses which is particularly suitable for this. Keywords. Multi-core computing systems, scalable program analysis, reverse data-flow analysis, demand-driven data-flow analysis 1