Tobias Wrigstad

Tobias Wrigstad

Auto-generated profile, based on publicly available information

Tobias Wrigstad

Uppsala University, Uppsala, Sweden

Research Focus & Metrics

Academic Career Length

18Years (2009-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
16 October 2023 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
EAEllen Arvidsson
Ellen Arvidsson
ECElias Castegren
Elias Castegren
SCSylvan Clebsch
Sylvan Clebsch
SDSophia Drossopoulou
Sophia Drossopoulou
JNJames Noble
James Noble
TWTobias Wrigstad
Tobias Wrigstad
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.

21 September 2022 in ACM Transactions on Programming Languages and Systems
Verified
Journal Article
Open access
AYAlbert Mingkun Yang
Albert Mingkun Yang
TWTobias Wrigstad
Tobias Wrigstad
ZGC is a modern, non-generational, region-based, mostly concurrent, parallel, mark-evacuate collector recently added to OpenJDK. It aims at having GC pauses that do not grow as the heap size increases, offering low latency even with large heap sizes. The ZGC C++ source code is readily accessible in the OpenJDK repository, but reading it (25 KLOC) can be very intimidating, and one might easily get lost in low-level implementation details, obscuring the key concepts. To make the ZGC algorithm more approachable, this work provides a thorough description on a high-level, focusing on the overall design with moderate implementation details. To explain the concurrency aspects, we provide a SPIN model that allows studying races between mutators and GC threads, and how they are resolved in ZGC. Such a model is not only useful for learning the current design (offering a deterministic and interactive experience) but also beneficial for prototyping new ideas and extensions. Our hope is that our detailed description and the SPIN model will enable the use of ZGC as a building block for future GC research, and research ideas implemented on top of it could even be adopted in the industry more readily, bridging the gap between academia and industry in the context of GC research.

26 February 2021 in The Art, Science, and Engineering of Programming
Verified
Journal Article
Closed access
MKMalin Källén
Malin Källén
TWTobias Wrigstad
Tobias Wrigstad
Programming paper: Jupyter notebooks has emerged as a standard tool for data science programming. Programs in Jupyter notebooks are different from typical p...

16 October 2023 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
LCLuke Cheeseman
Luke Cheeseman
MPMatthew J. Parkinson
Matthew J. Parkinson
SCSylvan Clebsch
Sylvan Clebsch
MKMarios Kogias
Marios Kogias
SDSophia Drossopoulou
Sophia Drossopoulou
PLPaul Liétar
Paul Liétar
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 July 2009
Verified
Conference Paper
Open access
TWTobias Wrigstad
Tobias Wrigstad
PEPatrick Eugster
Patrick Eugster
JFJohn Field
John Field
NNNate Nystrom
Nate Nystrom
JVJan Vitek
Jan Vitek

17 October 2021
Verified
Conference Paper
Open access
KFKiko Fernandez-Reyes
Kiko Fernandez-Reyes
IGIsaac Oscar Gariano
Isaac Oscar Gariano
JNJames Noble
James Noble
EGErin Greenwood-Thessman
Erin Greenwood-Thessman
MHMichael Homer
Michael Homer
TWTobias Wrigstad
Tobias Wrigstad
Dynamic languages like Erlang, Clojure, JavaScript, and E adopted data-race freedom by design. To enforce data-race freedom, these languages either deep copy objects during actor (thread) communication or proxy back to their owning thread. We present Dala, a simple programming model that ensures data-race freedom while supporting efficient inter-thread communication. Dala is a dynamic, concurrent, capability-based language that relies on three core capabilities: immutable values can be shared freely; isolated mutable objects can be transferred between threads but not aliased; local objects can be aliased within their owning thread but not dereferenced by other threads. Objects with capabilities can co-exist with unsafe objects, that are unchecked and may suffer data races, without compromising the safety of safe objects. We present a formal model of Dala, prove data race-freedom and state and prove a dynamic gradual guarantee. These theorems guarantee data race-freedom when using safe capabilities and show that the addition of capabilities is semantics preserving modulo permission and cast errors.