43,879 research outputs found
Integration of concurrency control in a language with subtyping and subclassing
This paper describes the integration of concurrency control in BALLOON, an object-oriented language that separates the concepts of type and class as well of subtyping and subclassing. Types are interface specifications enriched with concurrency control annotations. Classes are used to implement the operational functionality of types as well as concurrency control mechanisms. Types, classes and concurrency control annotations are independently reusable and derivable. The language takes advantage of this separation to solve the typical problems of the inheritance anomaly
Trends in Concurrency, Polygyny, and Multiple Sex Partnerships During a Decade of Declining HIV Prevalence in Eastern Zimbabwe.
Background. Observed declines in the prevalence of human immunodeficiency virus (HIV) infection in Zimbabwe have been attributed to population-level reductions in sexual partnership numbers. However, it remains unknown whether certain types of sex partnerships were more important to this decline. Particular debate surrounds the epidemiologic importance of polygyny (the practice of having multiple wives). Methods. We analyze changes in reported multiple partnerships, nonmarital concurrency, and polygyny in eastern Zimbabwe during a period of declining HIV prevalence, from 1998 to 2011. Trends are reported for adult men (age, 17–54 years) and women (age, 15–49 years) from 5 survey rounds of the Manicaland HIV/STD Prevention Project, a general-population open cohort study. Results. At baseline, 34.2% of men reported multiple partnerships, 11.9% reported nonmarital concurrency, and 4.6% reported polygyny. Among women, 4.6% and 1.8% reported multiple partnerships and concurrency, respectively. All 3 partnership indicators declined by similar relative amounts (around 60%–70%) over the period. Polygyny accounted for around 25% of male concurrency. Compared with monogamously married men, polygynous men reported higher levels of subsequent divorce/separation (adjusted relative risk [RR], 2.92; 95% confidence interval [CI], 1.87–4.55) and casual sex partnerships (adjusted RR, 1.63; 95% CI, 1.41–1.88). Conclusions. No indicator clearly dominated declines in partnerships. Polygyny was surprisingly unstable and, in this population, should not be considered a safe form of concurrency
Typing actors using behavioural types
The actor model of computation assists and disciplines
the development of concurrent programs by forcing
the software engineer to reason about high-level concurrency
abstractions. While this leads to a better handling
of concurrency-related issues, the model itself does not exclude
erratic program behaviours. In this paper we consider
the actor model and investigate a type-based static analysis
to identify actor systems which may behave erraticly during
runtime. We consider the notion of behavioural types
and consider issues related to the nature of the actor model
including non-determinism, multi-party communication, dynamic
actor spawning, non-finite computation and a possibly
changing communication topology, which we contrast with
existing works.peer-reviewe
An optimized conflict-free replicated set
Eventual consistency of replicated data supports concurrent updates, reduces
latency and improves fault tolerance, but forgoes strong consistency.
Accordingly, several cloud computing platforms implement eventually-consistent
data types. The set is a widespread and useful abstraction, and many replicated
set designs have been proposed. We present a reasoning abstraction, permutation
equivalence, that systematizes the characterization of the expected concurrency
semantics of concurrent types. Under this framework we present one of the
existing conflict-free replicated data types, Observed-Remove Set. Furthermore,
in order to decrease the size of meta-data, we propose a new optimization to
avoid tombstones. This approach that can be transposed to other data types,
such as maps, graphs or sequences.Comment: No. RR-8083 (2012
Affine Sessions
Session types describe the structure of communications implemented by
channels. In particular, they prescribe the sequence of communications, whether
they are input or output actions, and the type of value exchanged. Crucial to
any language with session types is the notion of linearity, which is essential
to ensure that channels exhibit the behaviour prescribed by their type without
interference in the presence of concurrency. In this work we relax the
condition of linearity to that of affinity, by which channels exhibit at most
the behaviour prescribed by their types. This more liberal setting allows us to
incorporate an elegant error handling mechanism which simplifies and improves
related works on exceptions. Moreover, our treatment does not affect the
progress properties of the language: sessions never get stuck
Static Race Detection and Mutex Safety and Liveness for Go Programs
Go is a popular concurrent programming language thanks to its ability to efficiently combine concurrency and systems programming. In Go programs, a number of concurrency bugs can be caused by a mixture of data races and communication problems. In this paper, we develop a theory based on behavioural types to statically detect data races and deadlocks in Go programs. We first specify lock safety/liveness and data race properties over a Go program model, using the happens-before relation defined in the Go memory model. We represent these properties of programs in a μ-calculus model of types, and validate them using type-level model-checking. We then extend the framework to account for Go’s channels, and implement a static verification tool which can detect concurrency errors. This is, to the best of our knowledge, the first static verification framework of this kind for the Go language, uniformly analysing concurrency errors caused by a mix of shared memory accesses and asynchronous message-passing communications
On the relative expressiveness of higher-order session processes
By integrating constructs from the λ-calculus and the π-calculus, in higher-order process calculi exchanged values may contain processes. This paper studies the relative expressiveness of HOπ, the higher-order π-calculus in which communications are governed by session types. Our main discovery is that HO, a subcalculus of HOπ which lacks name-passing and recursion, can serve as a new core calculus for session-typed higher-order concurrency. By exploring a new bisimulation for HO, we show that HO can encode HOπ fully abstractly (up to typed contextual equivalence) more precisely and efficiently than the first-order session π-calculus (π). Overall, under session types, HOπ, HO, and π are equally expressive; however, HOπ and HO are more tightly related than HOπ and π
A Concurrency-Agnostic Protocol for Multi-Paradigm Concurrent Debugging Tools
Today's complex software systems combine high-level concurrency models. Each
model is used to solve a specific set of problems. Unfortunately, debuggers
support only the low-level notions of threads and shared memory, forcing
developers to reason about these notions instead of the high-level concurrency
models they chose.
This paper proposes a concurrency-agnostic debugger protocol that decouples
the debugger from the concurrency models employed by the target application. As
a result, the underlying language runtime can define custom breakpoints,
stepping operations, and execution events for each concurrency model it
supports, and a debugger can expose them without having to be specifically
adapted.
We evaluated the generality of the protocol by applying it to SOMns, a
Newspeak implementation, which supports a diversity of concurrency models
including communicating sequential processes, communicating event loops,
threads and locks, fork/join parallelism, and software transactional memory. We
implemented 21 breakpoints and 20 stepping operations for these concurrency
models. For none of these, the debugger needed to be changed. Furthermore, we
visualize all concurrent interactions independently of a specific concurrency
model. To show that tooling for a specific concurrency model is possible, we
visualize actor turns and message sends separately.Comment: International Symposium on Dynamic Language
- …