lnu.sePublikationer
Ändra sökning
Avgränsa sökresultatet
1 - 10 av 10
RefereraExporteraLänk till träfflistan
Permanent länk
Referera
Referensformat
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Annat format
Fler format
Språk
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Annat språk
Fler språk
Utmatningsformat
  • html
  • text
  • asciidoc
  • rtf
Träffar per sida
  • 5
  • 10
  • 20
  • 50
  • 100
  • 250
Sortering
  • Standard (Relevans)
  • Författare A-Ö
  • Författare Ö-A
  • Titel A-Ö
  • Titel Ö-A
  • Publikationstyp A-Ö
  • Publikationstyp Ö-A
  • Äldst först
  • Nyast först
  • Skapad (Äldst först)
  • Skapad (Nyast först)
  • Senast uppdaterad (Äldst först)
  • Senast uppdaterad (Nyast först)
  • Disputationsdatum (tidigaste först)
  • Disputationsdatum (senaste först)
  • Standard (Relevans)
  • Författare A-Ö
  • Författare Ö-A
  • Titel A-Ö
  • Titel Ö-A
  • Publikationstyp A-Ö
  • Publikationstyp Ö-A
  • Äldst först
  • Nyast först
  • Skapad (Äldst först)
  • Skapad (Nyast först)
  • Senast uppdaterad (Äldst först)
  • Senast uppdaterad (Nyast först)
  • Disputationsdatum (tidigaste först)
  • Disputationsdatum (senaste först)
Markera
Maxantalet träffar du kan exportera från sökgränssnittet är 250. Vid större uttag använd dig av utsökningar.
  • 1.
    Österlund, Erik
    Linnéuniversitetet, Fakulteten för teknik (FTK), Institutionen för datavetenskap och medieteknik (DM).
    Going beyond on-the fly-garbage collection and improving self-adaptation with enhanced interfaces2019Doktorsavhandling, sammanläggning (Övrigt vetenskapligt)
  • 2.
    Österlund, Erik
    et al.
    Oracle.
    Löwe, Welf
    Linnéuniversitetet, Fakulteten för teknik (FTK), Institutionen för datavetenskap och medieteknik (DM), Institutionen för datavetenskap (DV).
    Self-adaptive concurrent components2018Ingår i: Automated Software Engineering: An International Journal, ISSN 0928-8910, E-ISSN 1573-7535, Vol. 25, nr 1, s. 47-99Artikel i tidskrift (Refereegranskat)
    Abstract [en]

    Selecting the optimum component implementation variant is sometimes difficult since it depends on the component's usage context at runtime, e.g., on the concurrency level of the application using the component, call sequences to the component, actual parameters, the hardware available etc. A conservative selection of implementation variants leads to suboptimal performance, e.g., if a component is conservatively implemented as thread-safe while during the actual execution it is only accessed from a single thread. In general, an optimal component implementation variant cannot be determined before runtime and a single optimal variant might not even exist since the usage contexts can change significantly over the runtime. We introduce self-adaptive concurrent components that automatically and dynamically change not only their internal representation and operation implementation variants but also their synchronization mechanism based on a possibly changing usage context. The most suitable variant is selected at runtime rather than at compile time. The decision is revised if the usage context changes, e.g., if a single-threaded context changes to a highly contended concurrent context. As a consequence, programmers can focus on the semantics of their systems and, e.g., conservatively use thread-safe components to ensure consistency of their data, while deferring implementation and optimization decisions to context-aware runtime optimizations. We demonstrate the effect on performance with self-adaptive concurrent queues, sets, and ordered sets. In all three cases, experimental evaluation shows close to optimal performance regardless of actual contention.

  • 3.
    Österlund, Erik
    et al.
    Linnéuniversitetet, Fakulteten för teknik (FTK), Institutionen för datavetenskap och medieteknik (DM), Institutionen för datavetenskap (DV).
    Löwe, Welf
    Linnéuniversitetet, Fakulteten för teknik (FTK), Institutionen för datavetenskap och medieteknik (DM), Institutionen för datavetenskap (DV).
    Block-free concurrent GC: Stack scanning and copying2016Ingår i: ISMM 2016: Proceedings of the 2016 ACM SIGPLAN International Symposium on Memory Management, ACM Press, 2016, s. 1-12Konferensbidrag (Refereegranskat)
    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.

  • 4.
    Österlund, Erik
    et al.
    Linnéuniversitetet, Fakulteten för teknik (FTK), Institutionen för datavetenskap (DV).
    Löwe, Welf
    Linnéuniversitetet, Fakulteten för teknik (FTK), Institutionen för datavetenskap (DV).
    Concurrent Compaction using a Field Pinning Protocol2015Ingår i: ISMM 2015 Proceedings of the 2015 ACM SIGPLAN International Symposium on Memory Management, ACM Press, 2015, Vol. 50(11), s. 56-69Konferensbidrag (Refereegranskat)
    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. 

  • 5.
    Österlund, Erik
    et al.
    Linnéuniversitetet, Fakulteten för teknik (FTK), Institutionen för datavetenskap (DV).
    Löwe, Welf
    Linnéuniversitetet, Fakulteten för teknik (FTK), Institutionen för datavetenskap (DV).
    Concurrent transformation components using contention context sensors2014Ingår i: Proceedings of the 29th ACM/IEEE international conference on Automated software engineering, ACM Press, 2014, s. 223-234Konferensbidrag (Refereegranskat)
    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.

  • 6.
    Österlund, Erik
    et al.
    Linnéuniversitetet, Fakulteten för teknik (FTK), Institutionen för datavetenskap (DV).
    Löwe, Welf
    Linnéuniversitetet, Fakulteten för teknik (FTK), Institutionen för datavetenskap (DV).
    Field Pinning GC2014Konferensbidrag (Refereegranskat)
    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. 

  • 7.
    Österlund, Erik
    et al.
    Linnéuniversitetet, Fakulteten för teknik (FTK), Institutionen för datavetenskap (DV).
    Löwe, Welf
    Linnéuniversitetet, Fakulteten för teknik (FTK), Institutionen för datavetenskap (DV).
    Dynamically transforming data structures2013Ingår i: 2013 IEEE/ACM 28th International Conference on Automated Software Engineering (ASE): Proceedings / [ed] Ewewn Denney, Tevfik Bultan, Andreas Zeller, IEEE, 2013, s. 410-420Konferensbidrag (Refereegranskat)
    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.

  • 8.
    Österlund, Erik
    et al.
    Linnéuniversitetet, Fakultetsnämnden för naturvetenskap och teknik, Institutionen för datavetenskap, fysik och matematik, DFM.
    Löwe, Welf
    Linnéuniversitetet, Fakultetsnämnden för naturvetenskap och teknik, Institutionen för datavetenskap, fysik och matematik, DFM.
    Analysis of pure methods using garbage collection2012Ingår i: Proceedings of the 2012 ACM SIGPLAN Workshop on Memory Systems Performance and Correctness, ACM Press, 2012, s. 48-57Konferensbidrag (Refereegranskat)
    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.

  • 9.
    Österlund, Erik
    Linnéuniversitetet, Fakultetsnämnden för naturvetenskap och teknik, Institutionen för datavetenskap, fysik och matematik, DFM.
    Garbage Collection supporting automatic JIT parallelization in JVM2012Självständigt arbete på avancerad nivå (magisterexamen), 10 poäng / 15 hpStudentuppsats (Examensarbete)
    Abstract [en]

    With increasing clock-rates in CPUs coming to an end, a need for parallelization has emerged. This thesis proposes a dynamic purity analysis of objects, detecting independent execution paths that may be run in parallel. The analysis relies in speculative guesses and may be rolled back when proven wrong. It piggybags on an efficient replicating garbage collector integrated to JVM.

    The efficiency of the algorithms are shown in benchmark, and are comparable to the speed of state of the art garbage collectors in hotspot’s JVM.

    With this dynamic purity analysis now accessible in Java programs, the potential for automatic JIT-parallelization of pure methods is possible.

  • 10.
    Österlund, Erik
    Linnéuniversitetet, Fakultetsnämnden för naturvetenskap och teknik, Institutionen för datavetenskap, fysik och matematik, DFM.
    Automatic memory management system for automatic parallelization2011Självständigt arbete på grundnivå (kandidatexamen), 10 poäng / 15 hpStudentuppsats (Examensarbete)
    Abstract [en]

    With Moore’s law coming to an end and the era of multiprocessor chips emerging, the need for ways of dealing with the essential problems with concurrency is becoming imminent. Automatic parallelization for imperative languages and pure functions in functional programming languages all try to prove independence statically. This thesis argues that independence is dynamic in nature. Static analysis for automatic parallelization has failed to do anything but trivial optimizations.

    This thesis shows a new approach where dynamic analysis about the system is provided for very low costs using a garbage collector that has to go through all live cells anyway. Immutable sub-graphs of objects that cannot change state are found. Their methods become pure functions that can be parallelized. The garbage collector implemented is a kind of replicating collector. It is about three times faster than Boehm’s collector in garbage collection, fully concurrent and provides the dynamic analysis almost for free.

1 - 10 av 10
RefereraExporteraLänk till träfflistan
Permanent länk
Referera
Referensformat
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Annat format
Fler format
Språk
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Annat språk
Fler språk
Utmatningsformat
  • html
  • text
  • asciidoc
  • rtf