This paper investigates a generalized Kropina metric featuring a specific $π$-form. Start with a Finsler manifold $(M,F)$ admits a concurrent $π$-vector field $\overline{\varphi}$, then, examine the $φ$-concurrent generalized Kropina change defined by $\widehat{F}=\frac{F^{m+1}}{Φ^{m}},\,\, Φ^{m}>0$, where $Φ$ represents the corresponding $1$-form. We investigate the fundamental geometric objects associated with $\widehat{F}$ in an intrinsic manner after adopting this modification and present an example of a Finsler metric that admits a concurrent vector field along with $\widehat{F}$. Also, we prove that the geodesic sprays of $F$ and $\widehat{F}$ can never be projectively related. Moreover, we show $\overline{\varphi}$ is not concurrent with respect to $\widehat{F}$. Eventhough, we give a sufficient condition for $\overline{\varphi}$ to be concurrent with respect to $\widehat{F}$. Finally, we prove that the $φ$-concurrent generalized Kropina change ($F \longrightarrow \widehat{F}$) preserves the almost rational property of the initial Finsler metric ${F}$.
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 concurrency control (CC) and is a good fit for implementing concurrent data structures. However, DBMSs are over-generalized for this use case, which fails to match the performance of specialized implementations. This paper makes the case for the Declarative Concurrent Data Structures (DCDS) framework for automatically generating concurrent data structures from a serial specification. In DCDS, users declare the attributes and methods needed for their desired data structure through an embedded DSL at design time. DCDS automatically injects CC at build-time, generating a concurrent intermediate representation (IR) compiled into machine code. A declarative interface for designing data structure enables
A concurrent system is defined as a monoid action of a trace monoid on a finite set of states. Concurrent systems represent state models where the state is distributed and where state changes are local. Starting from a spectral property on the combinatorics of concurrent systems, we prove the existence and uniqueness of a Markov measure on the space of infinite trajectories relatively to any weight distributions. In turn, we obtain a combinatorial result by proving that the kernel of the associated Möbius matrix has dimension 1; the Möbius matrix extends in this context the Möbius polynomial of a trace monoid. We study ergodic properties of irreducible concurrent systems and we prove a Strong law of large numbers. It allows us to introduce the speedup as a measurement of the average amount of concurrency within infinite trajectories. Examples are studied.
Synchronization is the major obstacle to scalability in distributed computing. Concurrent operations on the shared data engage in synchronization when they encounter a \emph{conflict}, i.e., their effects depend on the order in which they are applied. Ideally, one would like to detect conflicts in a \emph{dynamic} manner, i.e., adjusting to the current system state. Indeed, it is very common that two concurrent operations conflict only in some rarely occurring states. In this paper, we define the notion of \emph{dynamic concurrency}: an operation employs strong synchronization primitives only if it \emph{has} to arbitrate with concurrent operations, given the current system state. We then present a dynamically concurrent universal construction.
A process is able to execute a set of actions with a predefined manner, while a truly concurrent process executes this set of actions with a manner with the flavour of true concurrency. The so-called truly concurrent process algebras bridge the true concurrency (such as Petri nets, event structures, etc), and the interleaving concurrency (such as CCS, CSP, ACP, etc). In this paper, we give truly concurrent processes testing semantics followed by Hennessy's great work, which inherits the trinity of operational semantics, axiomatic semantics and denotational semantics.
Concurrent data structures serve as fundamental building blocks for concurrent computing. Many concurrent counterparts have been designed for basic sequential mechanisms; however, one notable omission is a concurrent tree that supports aggregate queries. Aggregate queries essentially compile succinct information about a range of data items, for example, calculating the average salary of employees in their 30s. Such queries play an essential role in various applications and are commonly taught in undergraduate data structures courses. In this paper, we formalize a type of aggregate queries that can be efficiently supported by concurrent trees and present a design for implementing these queries on concurrent trees. We bring two algorithms implementing this design, where one optimizes for tree update time, while the other optimizes for aggregate query time. We analyze their correctness and complexity, demonstrating the trade-offs between query time and update time.
Trace properties, which are sets of execution traces, are often used to analyze systems, but their expressiveness is limited. Clarkson and Schneider defined hyperproperties as a generalization of trace properties to sets of sets of traces. Typical applications of hyperproperties are found in information flow security. We introduce an analogous definition of concurrent hyperproperties, by generalizing traces to concurrent traces, which we define as partially ordered multisets. We take Petri nets as the basic semantic model. Concurrent traces are formalized via causal nets. To check concurrent hyperproperties, we define may and must testing of sets of concurrent traces in the style of DeNicola and Hennessy, using the parallel composition of Petri nets. In our approach, we thus distinguish nondeterministic and concurrent behavior. We discuss examples where concurrent hyperproperties are needed.
Previous papers give accounts of quests for satisfactory formalizations of the classical informal notion of an algorithm and the contemporary informal notion of an interactive algoritm. In this paper, an attempt is made to generalize the results of the former quest to the contemporary informal notion of a concurrent algorithm. The notion of a concurrent proto-algorithm is introduced. The thought is that concurrent algorithms are equivalence classes of concurrent proto-algorithms under an appropriate equivalence relation. Three equivalence relations are defined. Two of them are deemed to be bounds for an appropriate equivalence relation and the third is likely an appropriate one. The connection between concurrency and non-determinism in the presented setting is also addressed.
The queue is conceptually one of the simplest data structures-a basic FIFO container. However, ensuring correctness in the presence of concurrency makes existing lock-free implementations significantly more complex than their original form. Coordination mechanisms introduced to prevent hazards such as ABA, use-after-free, and unsafe reclamation often dominate the design, overshadowing the queue itself. Many schemes compromise strict FIFO ordering, unbounded capacity, or lock-free progress to mask coordination overheads. Yet the true source of complexity lies in the pursuit of infinite protection against reclamation hazards--theoretically sound but impractical and costly. This pursuit not only drives unnecessary complexity but also creates a protection paradox where excessive protection reduces system resilience rather than improving it. While such costs may be tolerable in conventional workloads, the AI era has shifted the paradigm: training and inference pipelines involve hundreds to thousands of concurrent threads per node, and at this scale, protection and coordination overheads dominate, often far heavier than the basic queue operations themselves. This paper introduces Cyclic
The development of concurrent applications is challenging because of the complexity of concurrent designs and the hazards of concurrent programming. Architectural modeling using the Unified Modeling Language (UML) can support the development process, but the problem of mapping the model to a concurrent implementation remains. This paper addresses this problem by defining a scheme to map concurrent UML designs to a concurrent object-oriented program. Using the COMET method for the architectural design of concurrent object-oriented systems, each component and connector is annotated with a stereotype indicating its behavioral design pattern. For each of these patterns, a reference implementation is provided using SCOOP, a concurrent object-oriented programming model. We evaluate this development process using a case study of an ATM system, obtaining a fully functional implementation based on the systematic mapping of the individual patterns. Given the strong execution guarantees of the SCOOP model, which is free of data races by construction, this development method eliminates a source of intricate concurrent programming errors.
We study the concurrent composition properties of interactive differentially private mechanisms, whereby an adversary can arbitrarily interleave its queries to the different mechanisms. We prove that all composition theorems for non-interactive differentially private mechanisms extend to the concurrent composition of interactive differentially private mechanisms, whenever differential privacy is measured using the hypothesis testing framework of $f$-DP, which captures standard $(\eps,δ)$-DP as a special case. We prove the concurrent composition theorem by showing that every interactive $f$-DP mechanism can be simulated by interactive post-processing of a non-interactive $f$-DP mechanism. In concurrent and independent work, Lyu~\cite{lyu2022composition} proves a similar result to ours for $(\eps,δ)$-DP, as well as a concurrent composition theorem for Rényi DP. We also provide a simple proof of Lyu's concurrent composition theorem for Rényi DP. Lyu leaves the general case of $f$-DP as an open problem, which we solve in this paper.
In this submission, we explore the use of equality saturation to optimize concurrent computations. A concurrent environment gives rise to new optimization opportunities, like extracting a common concurrent subcomputation. To our knowledge, no existing equality saturation framework allows such an optimization. The challenge with concurrent environments is that they require non-local reasoning since parallel computations are inherently unrelated and disjoint. This submission presents a new approach to optimizing equivalent concurrent computations: extending e-graphs to capture equal concurrent computations in order to replace them with a single computation.
The recent advancements in multicore machines highlight the need to simplify concurrent programming in order to leverage their computational power. One way to achieve this is by designing efficient concurrent data structures (e.g. stacks, queues, hash-tables, etc.) and synchronization techniques (e.g. locks, combining techniques, etc.) that perform well in machines with large amounts of cores. In contrast to ordinary, sequential data-structures, the concurrent data-structures allow multiple threads to simultaneously access and/or modify them. Synch is an open-source framework that not only provides some common high-performant concurrent data-structures, but it also provides researchers with the tools for designing and benchmarking high performant concurrent data-structures. The Synch framework contains a substantial set of concurrent data-structures such as queues, stacks, combining-objects, hash-tables, locks, etc. and it provides a user-friendly runtime for developing and benchmarking concurrent data-structures. Among other features, the provided runtime provides functionality for creating threads easily (both POSIX and user-level threads), tools for measuring performance, etc. M
We design a reversible version of truly concurrent process algebra CTC which is called RCTC. It has good properties modulo several kinds of strongly forward-reverse truly concurrent bisimulations and weakly forward-reverse truly concurrent bisimulations. These properties include monoid laws, static laws, new expansion law for strongly forward-reverse truly concurrent bisimulations, τlaws for weakly forward-reverse truly concurrent bisimulations, and congruences for strongly and weakly forward-reverse truly concurrent bisimulations.
The size of a data structure (i.e., the number of elements in it) is a widely used property of a data set. However, for concurrent programs, obtaining a correct size efficiently is non-trivial. In fact, the literature does not offer a mechanism to obtain a correct (linearizable) size of a concurrent data set without resorting to inefficient solutions, such as taking a full snapshot of the data structure to count the elements, or acquiring one global lock in all update and size operations. This paper presents a methodology for adding a concurrent linearizable size operation to sets and dictionaries with a relatively low performance overhead. Theoretically, the proposed size operation is wait-free with asymptotic complexity linear in the number of threads (independently of data-structure size). Practically, we evaluated the performance overhead by adding size to various concurrent data structures in Java$-$a skip list, a hash table and a tree. The proposed linearizable size operation executes faster by orders of magnitude compared to the existing option of taking a snapshot, while incurring a throughput loss of $1\%-20\%$ on the original data structure's operations.
There are many different models of concurrent processes. The goal of this work is to introduce a common formalized framework for current research in this area and to eliminate shortcomings of existing models of concurrency. Following up the previous research of the authors and other researchers on concurrency, here we build a high-level metamodel EAP (event-action-process) for concurrent processes. This metamodel comprises a variety of other models of concurrent processes. We shape mathematical models for, and study events, actions, and processes in relation to important practical problems, such as communication in networks, concurrent programming, and distributed computations. In the third section of the work, a three-level algebra of events, actions and processes is constructed and studied as a new stage of algebra for concurrent processes. Relations between EAP process algebra and other models of concurrency are considered in the fourth section of this work.
We propose a novel concurrent ranging technique for distance estimation with ultra-wideband (UWB) radios. Conventional schemes assume that the necessary packet exchanges occur in isolation, to avoid collisions. Concurrent ranging relies on the overlapping of replies from nearby responders to the same ranging request issued by an initiator node. As UWB transmissions rely on short pulses, the individual times of arrival can be discriminated by examining the channel impulse response (CIR) of the initiator transceiver. By ranging against N responders with a single, concurrent exchange, our technique drastically abates network overhead, enabling higher ranging frequency with lower latency and energy consumption w.r.t. conventional schemes. Concurrent ranging can be implemented with a strawman approach requiring minimal changes to standard schemes. Nevertheless, we empirically show that this limits the attainable accuracy, reliability, and therefore applicability. We identify the main challenges in realizing concurrent ranging without dedicated hardware and tackle them by contributing several techniques, used in synergy in our prototype based on the popular DW1000 transceiver. Our evalua
Concurrent Kleene Algebra (CKA) is a recently proposed algebraic structure by Hoare and collaborators that unifies the laws of concurrent programming. The unifying power of CKA rests largely on the so-called exchange law that describes how concurrent and sequential composition operators can be interchanged. Based on extensive theoretical work on true concurrency in the past, this paper extends Gischer's pomset model with least fixed point operators and formalizes the program refinement relation by Ésik's monotonic bijective morphisms to construct a partial order model of CKA. The existence of such a model is relevant when we want to prove and disprove properties about concurrent programs with loops. In particular, it gives a foundation for the analysis of programs that concurrently access relaxed memory as shown in subsequent work.
We derive an abstract computational model from a sequential computational model that is generally used for function execution. This abstract computational model allows for the concurrent execution of functions. We discuss concurrent models for function execution as implementations from the abstract computational model. We give an example of a particular concurrent function construct that can be implemented on a concurrent machine model using multi-threading. The result is a framework of computational models at different levels of abstraction that can be used in further development of concurrent computational models that deal with the problems inherent with concurrency.
The first part of the paper is an introduction to the theory of probabilistic concurrent systems under a partial order semantics. Key definitions and results are given and illustrated on examples. The second part includes contributions. We introduce deterministic concurrent systems as a subclass of concurrent systems. Deterministic concurrent system are "locally commutative'" concurrent systems. We prove that irreducible and deterministic concurrent systems have a unique probabilistic dynamics, and we characterize these systems by means of their combinatorial properties.