6,897 research outputs found
Parameterized Concurrent Multi-Party Session Types
Session types have been proposed as a means of statically verifying
implementations of communication protocols. Although prior work has been
successful in verifying some classes of protocols, it does not cope well with
parameterized, multi-actor scenarios with inherent asynchrony. For example, the
sliding window protocol is inexpressible in previously proposed session type
systems. This paper describes System-A, a new typing language which overcomes
many of the expressiveness limitations of prior work. System-A explicitly
supports asynchrony and parallelism, as well as multiple forms of
parameterization. We define System-A and show how it can be used for the static
verification of a large class of asynchronous communication protocols.Comment: In Proceedings FOCLASA 2012, arXiv:1208.432
Enabling preemptive multiprogramming on GPUs
GPUs are being increasingly adopted as compute accelerators in many domains, spanning environments from mobile systems to cloud computing. These systems are usually running multiple applications, from one or several users. However GPUs do not provide the support for resource sharing traditionally expected in these scenarios. Thus, such systems are unable to provide key multiprogrammed workload requirements, such as responsiveness, fairness or quality of service. In this paper, we propose a set of hardware extensions that allow GPUs to efficiently support multiprogrammed GPU workloads. We argue for preemptive multitasking and design two preemption mechanisms that can be used to implement GPU scheduling policies. We extend the architecture to allow concurrent execution of GPU kernels from different user processes and implement a scheduling policy that dynamically distributes the GPU cores among concurrently running kernels, according to their priorities. We extend the NVIDIA GK110 (Kepler) like GPU architecture with our proposals and evaluate them on a set of multiprogrammed workloads with up to eight concurrent processes. Our proposals improve execution time of high-priority processes by 15.6x, the average application turnaround time between 1.5x to 2x, and system fairness up to 3.4x.We would like to thank the anonymous reviewers, Alexan-
der Veidenbaum, Carlos Villavieja, Lluis Vilanova, Lluc Al-
varez, and Marc Jorda on their comments and help improving
our work and this paper. This work is supported by Euro-
pean Commission through TERAFLUX (FP7-249013), Mont-
Blanc (FP7-288777), and RoMoL (GA-321253) projects,
NVIDIA through the CUDA Center of Excellence program,
Spanish Government through Programa Severo Ochoa (SEV-2011-0067) and Spanish Ministry of Science and Technology
through TIN2007-60625 and TIN2012-34557 projects.Peer ReviewedPostprint (author’s final draft
Communications in Choreographies, Revisited
Choreographic Programming is a paradigm for developing
correct-by-construction concurrent programs, by writing high-level descriptions
of the desired communications and then synthesising process implementations
automatically. So far, choreographic programming has been explored in the
monadic setting: interaction terms express point-to-point communications of a
single value. However, real-world systems often rely on interactions of
polyadic nature, where multiple values are communicated among two or more
parties, like multicast, scatter-gather, and atomic exchanges. We introduce a
new model for choreographic programming equipped with a primitive for grouped
interactions that subsumes all the above scenarios. Intuitively, grouped
interactions can be thought of as being carried out as one single interaction.
In practice, they are implemented by processes that carry them out in a
concurrent fashion. After formalising the intuitive semantics of grouped
interactions, we prove that choreographic programs and their implementations
are correct and deadlock-free by construction
Combining behavioural types with security analysis
Today's software systems are highly distributed and interconnected, and they
increasingly rely on communication to achieve their goals; due to their
societal importance, security and trustworthiness are crucial aspects for the
correctness of these systems. Behavioural types, which extend data types by
describing also the structured behaviour of programs, are a widely studied
approach to the enforcement of correctness properties in communicating systems.
This paper offers a unified overview of proposals based on behavioural types
which are aimed at the analysis of security properties
Mutual exclusion
Almost all computers today operate as part of a network, where they assist people in coordinating actions. Sometimes what appears to be a single computer is actually a network of cooperating computers; e.g., some supercomputers consist of many processors operating in parallel and exchanging synchronization signals. One of the most fundamental requirements in all these systems is that certain operations be indivisible: the steps of one must not be interleaved with the steps of another. Two approaches were designed to implement this requirement, one based on central locks and the other on distributed order tickets. Practicing scientists and engineers need to come to be familiar with these methods
Unlocking Blocked Communicating Processes
We study the problem of disentangling locked processes via code refactoring.
We identify and characterise a class of processes that is not lock-free; then
we formalise an algorithm that statically detects potential locks and propose
refactoring procedures that disentangle detected locks. Our development is cast
within a simple setting of a finite linear CCS variant \^a although it suffices
to illustrate the main concepts, we also discuss how our work extends to other
language extensions.Comment: In Proceedings WWV 2015, arXiv:1508.0338
- …