Tootfinder

surely this version of the joke should go,
concurrency is two of the hardest problems in computer science
https://buttondown.email/hillelwayne/archive/what-makes-concurrency-so-hard/

surely this version of the joke should go,
concurrency is two of the hardest problems in computer science
https://buttondown.email/hillelwayne/archive/what-makes-concurrency-so-hard/

🧮 Neco: Coroutine library for C
#programming #c

GitHub - tidwall/neco: Concurrency library for C (coroutines)
Concurrency library for C (coroutines). Contribute to tidwall/neco development by creating an account on GitHub.

Swift is getting more delightful features for concurrency, love it: https://github.com/rjmccall/swift-evolution/blob/isolated-any-functions/proposals/NNNN-isolated-any-functions.md

swift-evolution/proposals/NNNN-isolated-any-functions.md at isolated-any-functions · rjmccall/swift-evolution
This maintains proposals for changes and user-visible enhancements to the Swift Programming Language. - rjmccall/swift-evolution

Proceedings 15th Workshop on Programming Language Approaches to Concurrency and Communication-cEntric Software
Diana Costa (Universidade de Lisboa), Raymond Hu (Queen Mary University of London)
https://arxiv.org/abs/2404.03712

Proceedings 15th Workshop on Programming Language Approaches to Concurrency and Communication-cEntric Software
This volume contains the proceedings of PLACES 2024, the 15th edition of the Workshop on Programming Language Approaches to Concurrency and Communication-cEntric Software. The PLACES workshop series offers a forum for researchers from different fields to exchange new ideas about the challenges of modern and future programming, where concurrency and distribution are the norm rather than a marginal concern. PLACES 2024 was held on 6 April 2024 in Luxembourg City, Luxembourg. The programme inclu…

This https://arxiv.org/abs/2306.10707 has been replaced.
link: https://scholar.google.com/scholar?q=a

Partial-order Checking with Unfolding for Linear Temporal Properties
Unfolding can tackle the path-explosion problem caused by concurrency. Traditional unfolding generation faces an NP-complete problem when adding events to the unfolding structure, which also exists in the case of verifying linear temporal logic (LTL). The reason is that it is necessary to enumerate possible concurrent event combinations after adding an event. Many state-of-the-art methods optimally explore unfolding-based structure (called event structure) by a tree-like structure, which should…

This https://arxiv.org/abs/2201.00754 has been replaced.
link: https://scholar.google.com/scholar?q=a

Effects of concurrency on epidemic spreading in Markovian temporal networks
The concurrency of edges, quantified by the number of edges that share a common node at a given time point, may be an important determinant of epidemic processes in temporal networks. We propose theoretically tractable Markovian temporal network models in which each edge flips between the active and inactive states in continuous time. The different models have different amounts of concurrency while we can tune the models to share the same statistics of edge activation and deactivation (and henc…

Good morning fellow Strict Concurrency lovers.
Rethought my model and we are at 38 warnings down from 30,000.

Heterogeneous Data Access Model for Concurrency Control and Methods to Deal with High Data Contention
Alexander Thomasian
https://arxiv.org/abs/2404.02276 …

Heterogeneous Data Access Model for Concurrency Control and Methods to Deal with High Data Contention
OLTP has stringent performance requirements defined by Service Level Agreements. Transaction response time is used to determine the maximum throughout in benchmarks. Capacity planning tools for OLTP performance are based on queueing network models for hardware resources and database lock contention has a secondary effect on performance. With ever increasing levels of e-commerce and surges in OLTP traffic we discuss the need for studies of database workloads to develop more realistic lock/latch …

Efficient Distributed Data Structures for Future Many-core Architectures
Panagiota Fatourou, Nikolaos D. Kallimanis, Eleni Kanellou, Odysseas Makridakis, Christi Symeonidou
https://arxiv.org/abs/2404.05515

Efficient Distributed Data Structures for Future Many-core Architectures
We study general techniques for implementing distributed data structures on top of future many-core architectures with non cache-coherent or partially cache-coherent memory. With the goal of contributing towards what might become, in the future, the concurrency utilities package in Java collections for such architectures, we end up with a comprehensive collection of data structures by considering different variants of these techniques. To achieve scalability, we study a generic scheme which mak…

On Propositional Dynamic Logic and Concurrency
Matteo Acclavio, Fabrizio Montesi, Marco Peressotti
https://arxiv.org/abs/2403.18508 https://

On Propositional Dynamic Logic and Concurrency
Dynamic logic in the setting of concurrency has proved problematic because of the challenge of capturing interleaving. This challenge stems from the fact that the operational semantics for programs considered in these logics is tailored on trace reasoning for sequential programs. In this work, we generalise propositional dynamic logic (PDL) to a logic framework we call operational propositional dynamic logic (OPDL) in which we are able to reason on sets of programs provided with arbitrary opera…

Update on SwiftGodot and strict concurrency.
The easy stuff is gone, but the remaining stuff is hard. I could brute force my way to the end, but goal is not to just have it build, I want to make sure that my users can rely on the guarantees and be able to benefit from this additional level of safety.
So the next step will take some time to complete, as many of these will require some research into some Godot features.

This https://arxiv.org/abs/2401.16097 has been replaced.
link: https://scholar.google.com/scholar?q=a

Pushing the Limits: Concurrency Detection in Acyclic Sound Free-Choice Workflow Nets in $O(P^2 + T^2)$
Concurrency is an important aspect of Petri nets to describe and simulate the behavior of complex systems. Knowing which places and transitions could be executed in parallel helps to understand nets and enables analysis techniques and the computation of other properties, such as causality, exclusivity, etc.. All techniques based on concurrency detection depend on the efficiency of this detection methodology. Kovalyov and Esparza have developed algorithms that compute all concurrent places in $O…

Concurrency Model of BDI Programming Frameworks: Why Should We Control It?
Martina Baiardi, Samuele Burattini, Giovanni Ciatto, Danilo Pianini, Andrea Omicini, Alessandro Ricci
https://arxiv.org/abs/2404.10421

Concurrency Model of BDI Programming Frameworks: Why Should We Control It?
We provide a taxonomy of concurrency models for BDI frameworks, elicited by analysing state-of-the-art technologies, and aimed at helping both BDI designers and developers in making informed decisions. Comparison among BDI technologies w.r.t. concurrency models reveals heterogeneous support, and low customisability.

On Propositional Dynamic Logic and Concurrency
Matteo Acclavio, Fabrizio Montesi, Marco Peressotti
https://arxiv.org/abs/2403.18508 https://

On Propositional Dynamic Logic and Concurrency
Dynamic logic in the setting of concurrency has proved problematic because of the challenge of capturing interleaving. This challenge stems from the fact that the operational semantics for programs considered in these logics is tailored on trace reasoning for sequential programs. In this work, we generalise propositional dynamic logic (PDL) to a logic framework we call operational propositional dynamic logic (OPDL) in which we are able to reason on sets of programs provided with arbitrary opera…

How do you leverage Rust’s concurrency features in your projects? Any particular strategies or libraries that have been invaluable?

Me: Ok, I am going to embrace Swift Concurrency and show the world.
5 minutes later:

Me: Ok, I am going to embrace Swift Concurrency and show the world.
5 minutes later:

When View- and Conflict-Robustness Coincide for Multiversion Concurrency Control
Brecht Vandevoort, Bas Ketsman, Frank Neven
https://arxiv.org/abs/2403.17665

When View- and Conflict-Robustness Coincide for Multiversion Concurrency Control
A DBMS allows trading consistency for efficiency through the allocation of isolation levels that are strictly weaker than serializability. The robustness problem asks whether, for a given set of transactions and a given allocation of isolation levels, every possible interleaved execution of those transactions that is allowed under the provided allocation, is always safe. In the literature, safe is interpreted as conflict-serializable (to which we refer here as conflict-robustness). In this pape…

Presenting Interval Pomsets with Interfaces
Amazigh Amrane, Hugo Bazille, Emily Clement, Uli Fahrenberg, Krzysztof Ziemianski
https://arxiv.org/abs/2403.16626

Presenting Interval Pomsets with Interfaces
Interval-order partially ordered multisets with interfaces (ipomsets) have shown to be a versatile model for executions of concurrent systems in which both precedence and concurrency need to be taken into account. In this paper, we develop a presentation of ipomsets as generated by a graph of certain discrete ipomsets (starters and terminators) under the relation which composes subsequent starters and subsequent terminators. Using this presentation, we show that also subsumptions are generated …

This https://arxiv.org/abs/2401.16097 has been replaced.
link: https://scholar.google.com/scholar?q=a

Pushing the Limits: Concurrency Detection in Acyclic Sound Free-Choice Workflow Nets in $O(P^2 + T^2)$
Concurrency is an important aspect of Petri nets to describe and simulate the behavior of complex systems. Knowing which places and transitions could be executed in parallel helps to understand nets and enables analysis techniques and the computation of other properties, such as causality, exclusivity, etc.. All techniques based on concurrency detection depend on the efficiency of this detection methodology. Kovalyov and Esparza have developed algorithms that compute all concurrent places in $O…

Good post by @… on what he learned and the tradeoffs he did when designing an API for strict swift concurrency support.
The best part are the regrets he has, good guidance for those of us starting on our strict journey:

Designing a Swift library with data-race safety
I cut an initial release (0.1.0-alpha) of the library automerge-repo-swift. A supplemental library to Automerge swift, it adds background networking for sync and storage capabilities. The library e…

HMTRace: Hardware-Assisted Memory-Tagging based Dynamic Data Race Detection
Jaidev Shastri, Xiaoguang Wang, Basavesh Ammanaghatta Shivakumar, Freek Verbeek, Binoy Ravindran
https://arxiv.org/abs/2404.19139

HMTRace: Hardware-Assisted Memory-Tagging based Dynamic Data Race Detection
Data race, a category of insidious software concurrency bugs, is often challenging and resource-intensive to detect and debug. Existing dynamic race detection tools incur significant execution time and memory overhead while exhibiting high false positives. This paper proposes HMTRace, a novel Armv8.5-A memory tag extension (MTE) based dynamic data race detection framework, emphasizing low compute and memory requirements while maintaining high accuracy and precision. HMTRace supports race detect…

🧮 Hermit is a hermetic and reproducible sandbox for running programs
#software

GitHub - facebookexperimental/hermit: Hermit launches linux x86_64 programs in a special, hermetically isolated sandbox to control their execution. Hermit translates normal, nondeterministic behavior, into deterministic, repeatable behavior. This can be used for various applications, including replay-debugging, reproducible artifacts, chaos mode concurrency testing and bug analysis.
Hermit launches linux x86_64 programs in a special, hermetically isolated sandbox to control their execution. Hermit translates normal, nondeterministic behavior, into deterministic, repeatable beh...

GTX: A Write-Optimized Latch-free Graph Data System with Transactional Support
Libin Zhou, Yeasir Rayhan, Lu Xing, Walid. G. Aref
https://arxiv.org/abs/2405.01418

GTX: A Write-Optimized Latch-free Graph Data System with Transactional Support
This paper introduces GTX a standalone main-memory write-optimized graph system that specializes in structural and graph property updates while maintaining concurrent reads and graph analytics with snapshot isolation-level transactional concurrency. Recent graph libraries target efficient concurrent read and write support while guaranteeing transactional consistency. However, their performance suffers for updates with strong temporal locality over the same vertexes and edges due to vertex-centr…

Presenting Interval Pomsets with Interfaces
Amazigh Amrane, Hugo Bazille, Emily Clement, Uli Fahrenberg, Krzysztof Ziemianski
https://arxiv.org/abs/2403.16626

Presenting Interval Pomsets with Interfaces
Interval-order partially ordered multisets with interfaces (ipomsets) have shown to be a versatile model for executions of concurrent systems in which both precedence and concurrency need to be taken into account. In this paper, we develop a presentation of ipomsets as generated by a graph of certain discrete ipomsets (starters and terminators) under the relation which composes subsequent starters and subsequent terminators. Using this presentation, we show that also subsumptions are generated …

GTX: A Transactional Graph Data System For HTAP Workloads
Libin Zhou, Walid Aref
https://arxiv.org/abs/2405.01448 https://arxiv.org/p…

GTX: A Transactional Graph Data System For HTAP Workloads
Processing, managing, and analyzing dynamic graphs are the cornerstone in multiple application domains including fraud detection, recommendation system, graph neural network training, etc. This demo presents GTX, a latch-free write-optimized transactional graph data system that supports high throughput read-write transactions while maintaining competitive graph analytics. GTX has a unique latch-free graph storage and a transaction and concurrency control protocol for dynamic power-law graphs. G…

Undo and Redo Support for Replicated Registers
Leo Stewen, Martin Kleppmann
https://arxiv.org/abs/2404.11308 https://arxiv.org/pdf/24…

Undo and Redo Support for Replicated Registers
Undo and redo functionality is ubiquitous in collaboration software. In single user settings, undo and redo are well understood. However, when multiple users edit a document, concurrency may arise, leading to a non-linear operation history. This renders undo and redo more complex both in terms of their semantics and implementation. We survey the undo and redo semantics of current mainstream collaboration software and derive principles for undo and redo behavior in a collaborative setting. We th…

On the external concurrency of current BDI frameworks for MAS
Martina Baiardi, Samuele Burattini, Giovanni Ciatto, Danilo Pianini, Alessandro Ricci, Andrea Omicini
https://arxiv.org/abs/2404.10397

Declarative Concurrent Data Structures
Aun Raza, Hamish Nicholson, Ioanna Tsakalidou, Anna Herlihy, Prathamesh Tagore, Anastasia Ailamaki
https://arxiv.org/abs/2404.13359

Declarative Concurrent Data Structures
Implementing concurrent data structures is challenging and requires a deep understanding of concurrency concepts and careful design to ensure correctness, performance, and scalability. Further, composing operations on two or more concurrent data structures often requires a synchronization wrapper to ensure the operations are applied together atomically, resulting in serialization and, thereby, giving up the performance benefit of the individual data structures. DBMS provides generalized concurr…