lnu.sePublications
Change search
Link to record
Permanent link

Direct link
BETA
Österlund, Erik
Publications (7 of 7) Show all publications
Österlund, E. (2019). Going beyond on-the fly-garbage collection and improving self-adaptation with enhanced interfaces. (Doctoral dissertation). Växjö: Linnaeus univetersity press
Open this publication in new window or tab >>Going beyond on-the fly-garbage collection and improving self-adaptation with enhanced interfaces
2019 (English)Doctoral thesis, comprehensive summary (Other academic)
Place, publisher, year, edition, pages
Växjö: Linnaeus univetersity press, 2019. p. 25, 145-153
Series
Linnaeus University Dissertations ; 361
National Category
Computer Systems
Research subject
Computer and Information Sciences Computer Science, Computer Science
Identifiers
urn:nbn:se:lnu:diva-89999 (URN)9789188898890 (ISBN)9789188898906 (ISBN)
Public defence
2019-10-18, Weber, Hus K, Växjö, 13:10 (English)
Opponent
Supervisors
Available from: 2019-11-11 Created: 2019-11-11 Last updated: 2019-11-27Bibliographically approved
Österlund, E. & Löwe, W. (2016). Block-free concurrent GC: Stack scanning and copying. In: ISMM 2016: Proceedings of the 2016 ACM SIGPLAN International Symposium on Memory Management. Paper presented at 15th ACM SIGPLAN International Symposium on Memory Management, ISMM 2016, 14 June 2016 (pp. 1-12). ACM Press
Open this publication in new window or tab >>Block-free concurrent GC: Stack scanning and copying
2016 (English)In: ISMM 2016: Proceedings of the 2016 ACM SIGPLAN International Symposium on Memory Management, ACM Press, 2016, p. 1-12Conference paper, Published paper (Refereed)
Abstract [en]

On-the-fly Garbage Collectors (GCs) are the state-of-the-art concurrent GC algorithms today. Everything is done concurrently, but phases are separated by blocking handshakes. Hence, progress relies on the scheduler to let application threads (mutators) run into GC checkpoints to reply to the handshakes. For a non-blocking GC, these blocking handshakes need to be addressed. Therefore, we propose a new non-blocking handshake to replace previous blocking handshakes. It guarantees schedulingindependent operation level progress without blocking. It is scheduling independent but requires some other OS support. It allows bounded waiting for threads that are currently running on a processor, regardless of threads that are not running on a processor. We discuss this non-blocking handshake in two GC algorithms for stack scanning and copying objects. They pave way for a future completely non-blocking GC by solving hard open theory problems when OS support is permitted. The GC algorithms were integrated to the G1 GC of OpenJDK for Java. GC pause times were reduced to 12.5% compared to the original G1 on average in DaCapo. For a memory intense benchmark, latencies were reduced from 174 ms to 0.67 ms for the 99.99% percentile. The improved latency comes at a cost of 15% lower throughput.

Place, publisher, year, edition, pages
ACM Press, 2016
Keywords
Block-free, Compaction, Garbage collection, Non-blocking, Stack scanning
National Category
Computer Systems
Research subject
Computer and Information Sciences Computer Science
Identifiers
urn:nbn:se:lnu:diva-56115 (URN)10.1145/2926697.2926701 (DOI)000439639900002 ()2-s2.0-84978488416 (Scopus ID)9781450343176 (ISBN)
Conference
15th ACM SIGPLAN International Symposium on Memory Management, ISMM 2016, 14 June 2016
Available from: 2016-09-08 Created: 2016-08-31 Last updated: 2019-11-11Bibliographically approved
Österlund, E. & Löwe, W. (2015). Concurrent Compaction using a Field Pinning Protocol. In: ISMM 2015 Proceedings of the 2015 ACM SIGPLAN International Symposium on Memory Management: . Paper presented at ACM SIGPLAN International Symposium on Memory Management, ISMM, 14 Jun., 2015, Portland (pp. 56-69). ACM Press, 50(11)
Open this publication in new window or tab >>Concurrent Compaction using a Field Pinning Protocol
2015 (English)In: ISMM 2015 Proceedings of the 2015 ACM SIGPLAN International Symposium on Memory Management, ACM Press, 2015, Vol. 50(11), p. 56-69Conference paper, Published paper (Refereed)
Abstract [en]

Compaction of memory in long running systems has always been important. The latency of compaction increases in today’s systems with high memory demands and large heaps. To deal with this problem, we present a lock-free protocol allowing for copying concurrent with the application running, which reduces the latencies of compaction radically. It pro- vides theoretical progress guarantees for copying and appli- cation threads without making it practically infeasible, with performance overheads of 20% on average. The algorithm paves way for a future lock-free Garbage Collector. 

Place, publisher, year, edition, pages
ACM Press, 2015
Series
SIGPLAN notices, ISSN 0362-1340 ; 50(11)
National Category
Computer Sciences
Research subject
Computer and Information Sciences Computer Science, Computer Science
Identifiers
urn:nbn:se:lnu:diva-42434 (URN)10.1145/2754169.2754177 (DOI)000370548500006 ()2-s2.0-84959917293 (Scopus ID)978-1-4503-3589-8 (ISBN)
Conference
ACM SIGPLAN International Symposium on Memory Management, ISMM, 14 Jun., 2015, Portland
Funder
Swedish Research Council, 2011-6185
Available from: 2015-04-15 Created: 2015-04-15 Last updated: 2019-11-11Bibliographically approved
Österlund, E. & Löwe, W. (2014). Concurrent transformation components using contention context sensors. In: Proceedings of the 29th ACM/IEEE international conference on Automated software engineering: . Paper presented at ASE 2014, September 15-19, 2014, Västerås, Sweden (pp. 223-234). ACM Press
Open this publication in new window or tab >>Concurrent transformation components using contention context sensors
2014 (English)In: Proceedings of the 29th ACM/IEEE international conference on Automated software engineering, ACM Press, 2014, p. 223-234Conference paper, Published paper (Refereed)
Abstract [en]

Sometimes components are conservatively implemented as thread-safe, while during the actual execution they are only accessed from one thread. In these scenarios, overly conservative assumptions lead to suboptimal performance.

The contribution of this paper is a component architecture that combines the benefits of different synchronization mechanisms to implement thread-safe concurrent components. Based on the thread contention monitored at runtime, context-aware composition and optimization select the appropriate mechanism. On changing contention, it revises this decision automatically and transforms the components accordingly. We implemented this architecture for concurrent queues, sets, and ordered sets. In all three cases, experimental evaluation shows close to optimal performance regardless of the actual contention.

As a consequence, programmers can focus on the semantics of their systems and, e.g., conservatively use thread-safe components to assure consistency of their data, while deferring implementation and optimization decisions to contention-context-aware composition at runtime.

Place, publisher, year, edition, pages
ACM Press, 2014
National Category
Computer Sciences
Research subject
Computer and Information Sciences Computer Science, Computer Science
Identifiers
urn:nbn:se:lnu:diva-42432 (URN)10.1145/2642937.2642995 (DOI)2-s2.0-84908610246 (Scopus ID)978-1-4503-3013-8 (ISBN)
Conference
ASE 2014, September 15-19, 2014, Västerås, Sweden
Funder
Swedish Research Council, 2011-6185
Available from: 2015-04-15 Created: 2015-04-15 Last updated: 2018-01-11Bibliographically approved
Österlund, E. & Löwe, W. (2014). Field Pinning GC. In: : . Paper presented at ACM SIGPLAN Workshop on Memory Systems Performance and Correctness, June 13, 2014, Edinburgh, Scotland.
Open this publication in new window or tab >>Field Pinning GC
2014 (English)Conference paper, Poster (with or without abstract) (Refereed)
Abstract [en]

The contribution of this study is a Field Pinning garbage collector (GC) without handshakes in the compaction phase. It is one step towards guaranteeing wait-free GC. It compacts memory concurrently and guarantees that fragmentation is bounded. Mutator heap accesses and computations are wait-free. The compaction algorithm does not need handshakes, but may use them for increased performance. The solution is evaluated experimentally in a prototype VM for Java. The GC progress is not wait-free, but impeded only by stack scanning and marking which was outside the scope of this study. The compaction algorithm does not impair global GC progress. 

National Category
Computer Sciences
Research subject
Computer and Information Sciences Computer Science, Computer Science
Identifiers
urn:nbn:se:lnu:diva-42433 (URN)
Conference
ACM SIGPLAN Workshop on Memory Systems Performance and Correctness, June 13, 2014, Edinburgh, Scotland
Funder
Swedish Research Council, 2011-6185
Available from: 2015-04-15 Created: 2015-04-15 Last updated: 2018-01-11Bibliographically approved
Österlund, E. & Löwe, W. (2013). Dynamically transforming data structures. In: Ewewn Denney, Tevfik Bultan, Andreas Zeller (Ed.), 2013 IEEE/ACM 28th International Conference on Automated Software Engineering (ASE): Proceedings. Paper presented at 28th IEEE/ACM International Conference on Automated Software Engineering (ASE 2013), Palo Alto, CA, NOV 11-15, 2013 (pp. 410-420). IEEE
Open this publication in new window or tab >>Dynamically transforming data structures
2013 (English)In: 2013 IEEE/ACM 28th International Conference on Automated Software Engineering (ASE): Proceedings / [ed] Ewewn Denney, Tevfik Bultan, Andreas Zeller, IEEE, 2013, p. 410-420Conference paper, Published paper (Refereed)
Abstract [en]

Fine-tuning which data structure implementation to use for a given problem is sometimes tedious work since the optimum solution depends on the context, i.e., on the operation sequences, actual parameters as well as on the hardware available at run time. Sometimes a data structure with higher asymptotic time complexity performs better in certain contexts because of lower constants. The optimal solution may not even be possible to determine at compile time.We introduce transformation data structures that dynamically change their internal representation variant based on a possibly changing context. The most suitable variant is selected at run time rather than at compile time.We demonstrate the effect on performance with a transformation ArrayList data structure using an array variant and a linked hash bag variant as alternative internal representations. Using our transformation ArrayList, the standard DaCapo benchmark suite shows a performance gain of 5.19% in average.

Place, publisher, year, edition, pages
IEEE, 2013
Series
IEEE ACM International Conference on Automated Software Engineering, ISSN 1527-1366
Keywords
possibly changing context, transformation ArrayList data structure, hash bag variant, DaCapo benchmark suite, internal representation variant
National Category
Computer Sciences
Research subject
Computer and Information Sciences Computer Science, Computer Science
Identifiers
urn:nbn:se:lnu:diva-28100 (URN)10.1109/ASE.2013.6693099 (DOI)000331090200041 ()2-s2.0-84893634611 (Scopus ID)978-1-4799-0215-6 (ISBN)
Conference
28th IEEE/ACM International Conference on Automated Software Engineering (ASE 2013), Palo Alto, CA, NOV 11-15, 2013
Available from: 2013-08-13 Created: 2013-08-13 Last updated: 2019-11-11Bibliographically approved
Österlund, E. & Löwe, W. (2012). Analysis of pure methods using garbage collection. In: Proceedings of the 2012 ACM SIGPLAN Workshop on Memory Systems Performance and Correctness: . Paper presented at ACM SIGPLAN Workshop on Memory Systems Performance and Correctness (pp. 48-57). ACM Press
Open this publication in new window or tab >>Analysis of pure methods using garbage collection
2012 (English)In: Proceedings of the 2012 ACM SIGPLAN Workshop on Memory Systems Performance and Correctness, ACM Press, 2012, p. 48-57Conference paper, Published paper (Refereed)
Abstract [en]

Parallelization and other optimizations often depend on static dependence analysis. This approach requires methods to be independent regardless of the input data, which is not always the case.

Our contribution is a dynamic analysis "guessing" if methods are pure, i. e., if they do not change state. The analysis is piggybacking on a garbage collector, more specifically, a concurrent, replicating garbage collector. It guesses whether objects are immutable by looking at actual mutations observed by the garbage collector. The analysis is essentially for free. In fact, our concurrent garbage collector including analysis outperforms Boehm's stop-the-world collector (without any analysis), as we show in experiments. Moreover, false guesses can be rolled back efficiently.

The results can be used for just-in-time parallelization allowing an automatic parallelization of methods that are pure over certain periods of time. Hence, compared to parallelization based on static dependence analysis, more programs potentially benefit from parallelization.

Place, publisher, year, edition, pages
ACM Press, 2012
Keywords
garbage collection, automatic parallelization, dynamic analysis, pure functions
National Category
Computer Sciences
Research subject
Computer Science, Software Technology
Identifiers
urn:nbn:se:lnu:diva-25976 (URN)10.1145/2247684.2247694 (DOI)2-s2.0-84863436374 (Scopus ID)978-1-4503-1219-6 (ISBN)
Conference
ACM SIGPLAN Workshop on Memory Systems Performance and Correctness
Funder
Swedish Research Council, 2011-6185
Available from: 2013-05-31 Created: 2013-05-31 Last updated: 2019-11-11Bibliographically approved
Organisations

Search in DiVA

Show all publications