| 1. |
- Shimchenko, Marina, 1994-
(författare)
-
Optimizing Energy Efficiency of Concurrent Garbage Collection
- 2024
-
Doktorsavhandling (övrigt vetenskapligt/konstnärligt)abstract
- The increasing energy consumption of the Information and Communication Technology sector amid climate change concerns underscores the urgency for energy efficiency improvements in computing. This thesis focuses on optimizing the energy efficiency of Java, a widely used programming language, and its implementation in OpenJDK. Specifically, our focus is on enhancing the energy efficiency of concurrent garbage collection.As a starting point for our work, we assessed the energy consumption of various garbage collection algorithms within OpenJDK, establishing concurrent garbage collectors as the least energy-efficient. This prompted further investigation into methods to enhance their energy consumption. We investigated methods like dynamically adjusting the memory size required by an application based on how much of the computer's processors one wants to use for garbage collection. We also looked into scheduling garbage collection tasks to run on specific types of computer cores that use less energy and running these tasks when the computer is not being actively used. We implemented all the abovementioned strategies in one of Java’s concurrent garbage collectors, ZGC. Through our experiments, we showed that these techniques can significantly reduce the amount of energy used by garbage collection without slowing down the performance of the programs running on the computer. Overall, our research contributes to making computing more environmentally friendly by finding ways to use less energy while still getting the same results.
|
|
| 2. |
- Arvidsson, Ellen, et al.
(författare)
-
Reference Capabilities for Flexible Memory Management
- 2023
-
Ingår i: Proceedings of the ACM on Programming Languages. - : Association for Computing Machinery (ACM). - 2475-1421. ; 7:OOPSLA2, s. 1363-1393
-
Tidskriftsartikel (refereegranskat)abstract
- Verona is a concurrent object-oriented programming language that organises all the objects in a program into a forest of isolated regions. Memory is managed locally for each region, so programmers can control a program's memory use by adjusting objects' partition into regions, and by setting each region's memory management strategy. A thread can only mutate (allocate, deallocate) objects within one active region---its "window of mutability". Memory management costs are localised to the active region, ensuring overheads can be predicted and controlled. Moving the mutability window between regions is explicit, so code can be executed wherever it is required, yet programs remain in control of memory use. An ownership type system based on reference capabilities enforces region isolation, controlling aliasing within and between regions, yet supporting objects moving between regions and threads. Data accesses never need expensive atomic operations, and are always thread-safe.
|
|
| 3. |
- Castegren, Elias, Doktor, 1987-, et al.
(författare)
-
Encore : Coda
- 2023
-
Ingår i: Active Object Languages. - : Springer Nature.
-
Bokkapitel (refereegranskat)abstract
- Encore is a programming language that was developed between 2014 and 2019. Encore was designed following the principle of inversion of defaults: computations are concurrent (rather than sequential) by default; data is isolated (rather than freely sharable) by default. The language worked as a seedbed for a large number of research ideas aimed at making programming with active objects safe, expressive and efficient.Encore allows active objects to share data but statically ensures the absence of data races and allows fully concurrent garbage collection. Active objects can synchronize using first-class futures, which are also used to delegate and coalesce computations across active objects. The type system also supports orchestration of intra-object parallelism, expressed using composable units of computation. Active objects which see a lot of traffic can turn themselves into passive objects protected by lock-free synchronization mechanisms to avoid performance bottle-necks, while still facilitating safe sharing and concurrent garbage collection.This paper gives an overview of these features of Encore, reflecting on lessons learned from trying to fit all of these research ideas into a single language.
|
|
| 4. |
- Castegren, Elias, et al.
(författare)
-
OOlong : A Concurrent Object Calculus for Extensibility and Reuse
- 2019
-
Ingår i: ACM SIGAPP Applied Computing Review. - : ACM Press. - 1559-6915 .- 1931-0161. ; 18:4, s. 47-60
-
Tidskriftsartikel (refereegranskat)abstract
- We present OOlong, an object calculus with interface inheritance, structured concurrency and locks. The goal of the calculus is extensibility and reuse. The semantics are therefore available in a version for LATEX typesetting (written in Ott), a mechanised version for doing rigorous proofs in Coq, and a prototype interpreter (written in OCaml) for typechecking an running OOlong programs.
|
|
| 5. |
- Cheeseman, Luke, et al.
(författare)
-
When Concurrency Matters : Behaviour-Oriented Concurrency
- 2023
-
Ingår i: Proceedings of the ACM on Programming Languages. - : Association for Computing Machinery (ACM). - 2475-1421. ; 7:OOPSLA2, s. 1531-1560
-
Tidskriftsartikel (refereegranskat)abstract
- Expressing parallelism and coordination is central for modern concurrent programming. Many mechanisms exist for expressing both parallelism and coordination. However, the design decisions for these two mechanisms are tightly intertwined. We believe that the interdependence of these two mechanisms should be recognised and achieved through a single, powerful primitive. We are not the first to realise this: the prime example is actor model programming, where parallelism arises through fine-grained decomposition of a program’s state into actors that are able to execute independently in parallel. However, actor model programming has a serious pain point: updating multiple actors as a single atomic operation is a challenging task. We address this pain point by introducing a new concurrency paradigm: Behaviour-Oriented Concurrency (BoC). In BoC, we are revisiting the fundamental concept of a behaviour to provide a more transactional concurrency model. BoC enables asynchronously creating atomic and ordered units of work with exclusive access to a collection of independent resources. In this paper, we describe BoC informally in terms of examples, which demonstrate the advantages of exclusive access to several independent resources, as well as the need for ordering. We define it through a formal model. We demonstrate its practicality by implementing a C++ runtime. We argue its applicability through the Savina benchmark suite: benchmarks in this suite can be more compactly represented using BoC in place of Actors, and we observe comparable, if not better, performance.
|
|
| 6. |
- Fernández Reyes, Francisco Ramón, 1985-
(författare)
-
Abstractions to Control the Future
- 2021
-
Doktorsavhandling (övrigt vetenskapligt/konstnärligt)abstract
- Multicore and manycore computers are the norm nowadays, and users have expectations that their programs can do multiple things concurrently. To support that, developers use concur- rency abstractions such as threads, promises, futures, and/or channels to exchange information. All these abstractions introduce trade-offs between the concurrency model and the language guarantees, and developers accept these trade-offs for the benefits of concurrent programming.Many concurrent languages are multi-paradigm, e.g., mix the functional and object-oriented paradigms. This is beneficial to developers because they can choose the most suitable approach when solving a problem. From the point of view of concurrency, purely functional programming languages are data-race free since they only support immutable data. Object-oriented languages do not get a free lunch, and neither do multi-paradigm languages that have imperative features.The main problem is uncontrolled concurrent access to shared mutable state, which may inadvertently introduce data-races. A data-race happens when two concurrent memory operations target the same location, at least one of them is a write, and there is no synchronisation operation involved. Data-races make programs to exhibit (unwanted) non-deterministic behaviour.The contribution of this thesis is two-fold. First, this thesis introduces new concurrent abstractions in a purely functional, statically typed programming language (Paper I – Paper III); these abstractions allow developers to write concurrent control- and delegation-based patterns. Second, this thesis introduces a capability-based dynamic programming model, named Dala, that extends the applicability of the concurrent abstractions to an imperative setting while maintaining data-race freedom (Paper IV). Developers can also use the Dala model to migrate unsafe programs, i.e., programs that may suffer data-races, to data-race free programs.
|
|
| 7. |
- Källén, Malin, 1986-
(författare)
-
Towards Higher Code Quality in Scientific Computing
- 2021
-
Doktorsavhandling (övrigt vetenskapligt/konstnärligt)abstract
- In scientific computing and data science, computer programs employing mathematical and statistical models are used for obtaining knowledge in different application domains. The results of these programs form the basis of among other things scientific papers and important desicions that may e.g. affect people's health. Consequently, correctness of the programs is of great importance. To reduce the risk of defects in the source code, and to not waste human resources, it is important that the code is maintainable, i.e. not unnecessarily hard to analyze, test, modify or reuse. For these reasons, this thesis strives towards increased maintainability and correctness in code bases for scientific computing and data science.Object-oriented programming is a programming paradigm that facilitates writing maintainable code, by providing mechanisms for reuse and for division of code into smaller components with restricted access to each others data. Further, it makes extending a code base without changing the existing code possible, increasing flexibility and decreasing the risk of breaking existing functionality. However, in many cases, object-orientation trades its benefits for performance. For some scientific computing programs, performance is essential, e.g. because the results are unusable if they are produced too late. In the first part of this thesis, it is shown that object-oriented programming can be used to improve the quality of an important group of scientific computing programs, with only a small impact on performance.The aim of the second part of the thesis is to contribute to understanding of, and improve quality in, source code for data science. A large corpus of Jupyter notebooks, a tool frequently used by data scientists for writing code, is studied. Results presented suggest that cloned code, i.e. identical or close to identical code that recurs in different places, is common in Jupyter notebooks. Code cloning is important from a perspective of maintenance as well as for research. Additionally, the most frequently called library functions from Python, the language used in the vast majority of the notebooks, are studied. A large number of combinations of parameters for which it is possible to pass values that may lead to unexpected behavior or decreased maintainability are identified. The existence and consequences of occurrences of such combinations of values in the corpus are evaluated. To reduce the risk of future defects in source code calling these functions, improvements are suggested to the developers of the functions.
|
|
| 8. |
- Norlinder, Jonas, et al.
(författare)
-
Compressed Forwarding Tables Reconsidered
- 2022
-
Ingår i: MPLR '22. - New York : Association for Computing Machinery (ACM). - 9781450396967 ; , s. 45-63
-
Konferensbidrag (refereegranskat)abstract
- How concurrent compacting collectors store and manage forwarding information is crucial for their performance.In this paper, we propose CFW, a representation technique for forwarding information that guarantees that forwarding information for an entire heap can be stored in at most 3.14% of its size. By providing such a guarantee, we simplify the task of deploying programs with respect to memory needs. This is important given how memory is typically the dominating factor in the cost model for cloud-based deployments.We explore the design space of our technique through a prototype implementation on-top of ZGC. A rigorous performance evaluation shows promising results.
|
|
| 9. |
- Parkinson, Matthew J., et al.
(författare)
-
Reference Counting Deeply Immutable Data Structures with Cycles : An Intellectual Abstract
- 2024
-
Ingår i: Proceedings of the 2024 ACM Sigplan International Symposium on Memory Management, ISMM 2024. - : Association for Computing Machinery (ACM). - 9798400706158 ; , s. 131-141
-
Konferensbidrag (refereegranskat)abstract
- Immutable data structures are a powerful tool for building concurrent programs. They allow the sharing of data without the need for locks or other synchronisation mechanisms. This makes it much easier to reason about the correctness of the program. In this paper, we focus on what we call deep immutability from freeze, that is, objects are initially mutable, and then can be frozen, and from that point on the object and everything it refers to (transitively) can no longer be mutated. A key challenge with this form of immutability is "how to manage the memory of cyclic data structures?" The standard approach is to use a garbage collector (GC), or a back-up cycle detector. These approaches sacrifice the promptness of memory reclamation, and the determinism of memory usage. In this paper, we argue that memory underlying an immutable data structure can be efficiently managed using reference counting even in the presence of cycles, based on the observation that the cycles are themselves immutable. Our approach takes a classic algorithm for calculating strongly connected components (SCCs) and managing equivalence classes with union-find (UF), and combines them so that the liveness of each SCC can be tracked efficiently using only a single reference counter. The key observation is that since the graph is unchanging, we can calculate the SCCs once, in time that is almost linear in the size of the graph, and then use the result to reference count at the level of the SCCs. This gives precise reachability information, and does not require any backup mechanism to detect or handle cycles.
|
|
| 10. |
- Shimchenko, Marina, et al.
(författare)
-
Analysing and Predicting Energy Consumption of Garbage Collectors in OpenJDK
- 2022
-
Ingår i: MPLR '22. - New York : Association for Computing Machinery (ACM). - 9781450396967 ; , s. 3-15
-
Konferensbidrag (refereegranskat)abstract
- Sustainable computing needs energy-efficient software. This paper explores the potential of leveraging the nature of software written in managed languages: increasing energy efficiency by changing a program’s memory management strategy without altering a single line of code. To this end, we perform comprehensive energy profiling of 35 Java applications across four benchmarks. In many cases, we find that it is possible to save energy by replacing the default G1 collector with another without sacrificing performance. Furthermore, potential energy savings can be even higher if performance regressions are permitted. Inspired by these results, we study what the most energy-efficient GCs are to help developers prune the search space for energy profiling at a low cost. Finally, we show that machine learning can be successfully applied to the problem of finding an energy-efficient GC configuration for an application, reducing the cost even further.
|
|
