Experience with safe manual memory-management in cyclone

Hicks, Michael; Morrisett, Greg; Grossman, Dan; Jim, Trevor

doi:10.1145/1029873.1029883

Cited by 65 publications

(52 citation statements)

References 31 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…They use region types, which divide memory in regions, in an ML language, where allocation and deallocation are inferred from type and effect analysis. This idea was used in the Cyclone language [Hicks et al 2004], which is concerned with safety of C-like languages. Deterministic Parallel Java also provides means to split data in the heap: Java code is annotated with regions information used to calculate the effects of reading and writing to data [Bocchino et al 2009].…”

Section: Related Workmentioning

confidence: 99%

You can have it all: abstraction and good cache performance

Franco

Hagelin

Wrigstad

et al. 2017

Proceedings of the 2017 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Sof

View full text Add to dashboard Cite

On current architectures, the optimisation of an application's performance often involves data being stored according to access affinity -what is accessed together should be stored together, rather than logical affinity -what belongs together logically stays together. Such low level techniques lead to faster, but more error prone code, and end up tangling the program's logic with low-level data layout details.Our vision, which we call SHAPES-Safe, High-level, Abstractions for oPtimisation of mEmory cacheS -is that the layout of a data structure should be defined only once, upon instantiation, and the remainder of the code should be layout agnostic. This enables performance improvements while also guaranteeing memory safety, and supports the separation of program logic from low level concerns. In this paper we investigate how this vision can be supported by extending a programming language.We describe the core language features supporting this vision: classes can be customized to support different layouts, and layout information is carried around in types; the remaining source code is layout-unaware and the compiler emits layout-aware code. We then discuss our SHAPES implementation through a prototype library, which we also used for preliminary evaluations. Finally, we discuss how the core could be expanded so as to deliver SHAPES's full potential: the incorporation of compacting garbage collection, * Work done while at Uppsala University.

show abstract

Section: Related Workmentioning

confidence: 99%

You can have it all: abstraction and good cache performance

Franco

Hagelin

Wrigstad

et al. 2017

Proceedings of the 2017 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Sof

View full text Add to dashboard Cite

show abstract

“…Region-based memory management Region-based memory management was first used in the implementations of functional languages [7,39] such as Standard ML [25], and then was extended to Prolog [28], C [21,22,24,26], and real-time Java [13,17,27]. More recently, some mark-region hybrid methods such as Immix [15] combine tracing GC with regions to improve GC performance for Java.…”

Section: Related Workmentioning

confidence: 99%

A bloat-aware design for big data applications

Borkar

et al. 2013

SIGPLAN Not.

View full text Add to dashboard Cite

Over the past decade, the increasing demands on data-driven business intelligence have led to the proliferation of large-scale, dataintensive applications that often have huge amounts of data (often at terabyte or petabyte scale) to process. An object-oriented programming language such as Java is often the developer's choice for implementing such applications, primarily due to its quick development cycle and rich community resource. While the use of such languages makes programming easier, significant performance problems can often be seen -the combination of the inefficiencies inherent in a managed run-time system and the impact of the huge amount of data to be processed in the limited memory space often leads to memory bloat and performance degradation at a surprisingly early stage.This paper proposes a bloat-aware design paradigm towards the development of efficient and scalable Big Data applications in object-oriented GC enabled languages. To motivate this work, we first perform a study on the impact of several typical memory bloat patterns. These patterns are summarized from the user complaints on the mailing lists of two widely-used open-source Big Data applications. Next, we discuss our design paradigm to eliminate bloat. Using examples and real-world experience, we demonstrate that programming under this paradigm does not incur significant programming burden. We have implemented a few common data processing tasks both using this design and using the conventional object-oriented design. Our experimental results show that this new design paradigm is extremely effective in improving performance -even for the moderate-size data sets processed, we have observed 2.5×+ performance gains, and the improvement grows substantially with the size of the data set.

show abstract

“…In [11], they briefly outline this technique along with two other memory management ideas that are of independent interest. Their dynamic regions can be roughly interpreted in our small region language by assuming that region handles are always existentially packed.…”

Section: Related Workmentioning

confidence: 99%

“…Recently, there have been a number of proposals [4,18,9,2,11] based on the concept of regions [14,15], that allow safe, explicitly controlled memory management. All these systems (with the exception of portions of [11] which was developed independently from our work around the same time) guarantee safety at compile time.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Memory Management with Use-Counted Regions

Terauchi¹,

Aiken²

2004

View full text Add to dashboard Cite

We introduce a new region-based memory management technique that allows flexible memory usage patterns and is provably safe. Our technique is explicit and manual like C's malloc and free, and it allows programmers to exert a similar degree of control over the program behavior. Our method is quite simple in spite of this expressiveness and safety.We apply the technique to a small functional language to formally describe the core concepts, prove its safety, and argue its usability and efficiency analytically. In particular, we show that the system can efficiently encode more rigid, traditional regions whose lifetime is bounded by that of a stack frame. We also show that the technique works nicely with multi-threaded and imperative programs.

show abstract

Experience with safe manual memory-management in cyclone

Cited by 65 publications

References 31 publications

You can have it all: abstraction and good cache performance

You can have it all: abstraction and good cache performance

A bloat-aware design for big data applications

Memory Management with Use-Counted Regions

Contact Info

Product

Resources

About