Loci: Simple Thread-Locality for Java

Wrigstad, Tobias; Pizlo, Filip; Meawad, Fadi; Zhao, Lei; Vítek, Jan

doi:10.1007/978-3-642-03013-0_21

Cited by 27 publications

(18 citation statements)

References 26 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Heap Partitioning and Regions Loci [Wrigstad et al 2009] split the heap into per-thread subheaps plus a shared space. This division is only conceptually, and does not aim to affect representation in memory.…”

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

Self Cite

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

Self Cite

View full text Add to dashboard Cite

show abstract

“…Our system takes important inspiration from Loci [66], a type system for enforcing thread locality which requires very few source annotations. However, LACASA supports ownership transfer, which is outside the domain of Loci.…”

Section: Other Related Workmentioning

confidence: 99%

LaCasa: lightweight affinity and object capabilities in Scala

HallerPhilipp¹,

LoikoAlex²

2016

SIGPLAN Not.

View full text Add to dashboard Cite

Aliasing is a known source of challenges in the context of imperative object-oriented languages, which have led to important advances in type systems for aliasing control. However, their large-scale adoption has turned out to be a surprisingly difficult challenge. While new language designs show promise, they do not address the need of aliasing control in existing languages.This paper presents a new approach to isolation and uniqueness in an existing, widely-used language, Scala. The approach is unique in the way it addresses some of the most important obstacles to the adoption of type system extensions for aliasing control. First, adaptation of existing code requires only a minimal set of annotations. Only a single bit of information is required per class. Surprisingly, the paper shows that this information can be provided by the object-capability discipline, widely-used in program security. We formalize our approach as a type system and prove key soundness theorems. The type system is implemented for the full Scala language, providing, for the first time, a sound integration with Scala's local type inference. Finally, we empirically evaluate the conformity of existing Scala open-source code on a corpus of over 75,000 LOC.

show abstract

“…This is particularly relevant for private fields, as a non-compositional private field may be counter-intuitive to programmers [22,24,35].…”

Section: Implementation and Evaluationmentioning

confidence: 99%

“…This application of Cypress is a concrete example of a well-established direction: reasoning about thread locality with ownership (e.g. [35]). …”

Section: Jato Supportmentioning

confidence: 99%

Heap Decomposition Inference with Linear Programming

Zhu

Liu

2013

ECOOP 2013 – Object-Oriented Programming

View full text Add to dashboard Cite

Abstract. Hierarchical decomposition is a fundamental principle that encourages the organization of program elements into nested scopes of access, instead of treating all as "global." This paper offers a foundational study of heap decomposition inference, the problem of statically extracting the decomposition hierarchy latent in the runtimes of object-oriented programs, henceforth revealing the compositional nature of the heap. The centerpiece of the paper is Cypress, a sound, precise, and scalable constraint-based ownership type inference coupled with a novel application of linear programming over integers. All constraints in Cypress are linear, and the precision of decomposition -placing objects to scopes as non-global as possible -can be reduced to a linear programming problem. Cypress has been implemented as an open-source tool that can decompose realworld Java applications of more than 100K LOC and up to 6000 statically distinct instantiations.

show abstract

Loci: Simple Thread-Locality for Java

Cited by 27 publications

References 26 publications

You can have it all: abstraction and good cache performance

You can have it all: abstraction and good cache performance

LaCasa: lightweight affinity and object capabilities in Scala

Heap Decomposition Inference with Linear Programming

Contact Info

Product

Resources

About