Message Analysis for Concurrent Languages

Carlsson, Richard; Sagonas, Konstantinos; Wilhelmsson, Jesper

doi:10.1007/3-540-44898-5_5

Cited by 4 publications

(9 citation statements)

References 21 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…For our purposes, the main difference is that several processes may share the same heap data. Can our proposed atom garbage collector 4 Recall that in the proposed algorithm, there can be at most two tables 5 Our measurements for R9C2 indicate that 1327 modules would need roughly 512 KB, one word per referenced atom, so the actual space needed is likely to be less than this number. 6 Systems with less than 65,000 modules can make do with a 2-byte reference count.…”

Section: Related Workmentioning

confidence: 99%

“…First, during an atom collection, there may be several atom tables in the system, one per epoch 4 . They may store duplicate information, e.g., the same atom may occur in several places.…”

Section: Additional Space Overheadsmentioning

confidence: 99%

“…Various alternative heap architectures have been proposed for Erlang/OTP, based on sharing data between processes [7,5,4,6]. For our purposes, the main difference is that several processes may share the same heap data.…”

Section: Related Workmentioning

confidence: 99%

See 2 more Smart Citations

Atom garbage collection

Lindgren¹

2005

Proceedings of the 2005 ACM SIGPLAN Workshop on Erlang

View full text Add to dashboard Cite

Atoms are a central data type in Erlang, yet there is currently no method for memory management of atoms in the most popular implementations. For long-lived systems, this leads to obscure bugs or defensive programming.In this paper, we discuss the relevant issues for atom garbage collection and propose some principles. We then devise an incremental copying collector with some optimizations.While a full implementation of the collector still remains to be done, an examination of pause times and space overheads, based on existing systems and realistic data, indicates that the algorithm is practical.

show abstract

Section: Related Workmentioning

confidence: 99%

“…First, during an atom collection, there may be several atom tables in the system, one per epoch 4 . They may store duplicate information, e.g., the same atom may occur in several places.…”

Section: Additional Space Overheadsmentioning

confidence: 99%

See 1 more Smart Citation

Atom garbage collection

Lindgren¹

2005

Proceedings of the 2005 ACM SIGPLAN Workshop on Erlang

View full text Add to dashboard Cite

show abstract

“…This can be achieved by user annotations on the source code, by dynamically monitoring the creation of data as proposed in [13], or by the static message analysis that we have described in [6] and integrated in the hybrid runtime system configuration of Erlang/OTP.…”

Section: Allocation In the Hybrid Architecturementioning

confidence: 99%

“…For the purposes of this paper, the details of the message analysis are unimportant and the interested reader is referred to [6]. Instead, it suffices to understand how the analysis guides allocation of data in the compiler.…”

Section: Allocation In the Hybrid Architecturementioning

confidence: 99%

Message analysis-guided allocation and low-pause incremental garbage collection in a concurrent language

Sagonas

Wilhelmsson

2004

Proceedings of the 4th International Symposium on Memory Management

Self Cite

View full text Add to dashboard Cite

We present a memory management scheme for a concurrent programming language where communication occurs using messagepassing with copying semantics. The runtime system is built around process-local heaps, which frees the memory manager from redundant synchronization in a multithreaded implementation and allows the memory reclamation of process-local heaps to be a private business and to often take place without garbage collection. The allocator is guided by a static analysis which speculatively allocates data possibly used as messages in a shared memory area. To respect the (soft) real-time requirements of the language, we develop a generational, incremental garbage collection scheme tailored to the characteristics of this runtime system. The collector imposes no overhead on the mutator, requires no costly barrier mechanisms, and has a relatively small space overhead. We have implemented these schemes in the context of an industrial-strength implementation of a concurrent functional language used to develop largescale, highly concurrent, embedded applications. Our measurements across a range of applications indicate that the incremental collector substantially reduces pause times, imposes only very small overhead on the total runtime, and achieves a high degree of mutator utilization.

show abstract

Specialization of CML message-passing primitives

Reppy

Xiao

2007

Proceedings of the 34th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

View full text Add to dashboard Cite

Concurrent ML (CML) is a statically-typed higher-order concurrent language that is embedded in Standard ML. Its most notable feature is its support for first-class synchronous operations. This mechanism allows programmers to encapsulate complicated communication and synchronization protocols as first-class abstractions, which encourages a modular style of programming where the underlying channels used to communicate with a given thread are hidden behind data and type abstraction.While CML has been in active use for well over a decade, little attention has been paid to optimizing CML programs. In this paper, we present a new program analysis for statically-typed higher-order concurrent languages that enables the compile-time specialization of communication operations. This specialization is particularly important in a multiprocessor or multicore setting, where the synchronization overhead for general-purpose operations are high. Preliminary results from a prototype that we have built demonstrate that specialized channel operations are much faster than the general-purpose operations.Our analysis technique is modular (i.e., it analyzes and optimizes a single unit of abstraction at a time), which plays to the modular style of many CML programs. The analysis consists of three steps: the first is a type-sensitive control-flow analysis that uses the program's type-abstractions to compute more precise results. The second is the construction of an extended control-flow graph using the results of the CFA. The last step is an iterative analysis over the graph that approximates the usage patterns of known channels. Our analysis is designed to detect special patterns of use, such as one-shot channels, fan-in channels, and fan-out channels. We have proven the safety of our analysis and state those results.

show abstract

Message Analysis for Concurrent Languages

Cited by 4 publications

References 21 publications

Atom garbage collection

Atom garbage collection

Message analysis-guided allocation and low-pause incremental garbage collection in a concurrent language

Specialization of CML message-passing primitives

Contact Info

Product

Resources

About