16,565 research outputs found
Relationships between Models for Concurrency
Models for concurrency can be classified with respect to three relevant parameters: behaviour/system, interleaving/noninterleaving, linear/branching time. When modelling a process, a choice concerning such parameters corresponds to choosing the level of abstraction of the resulting semantics. The classifications are formalized through the medium of category theory
Deterministic Behavioural Models for Concurrency
This paper offers three candidates for a deterministic, noninterleaving, behaviour model which generalizes Hoare traces to the noninterleaving situation. The three models are all proved equivalent in the rather strong sense of being equivalent as categories. The models are: deterministic labelled event structures, generalized trace languages in which the independence relation is context-dependent, and deterministic languages of pomsets
Persistent Contextual Values as Inter-Process Layers
Mobile applications today often fail to be context aware when they also need
to be customizable and efficient at run-time. Context-oriented programming
allows programmers to develop applications that are more context aware. Its
central construct, the so-called layer, however, is not customizable. We
propose to use novel persistent contextual values for mobile development.
Persistent contextual values automatically adapt their value to the context.
Furthermore they provide access without overhead. Key-value configuration files
contain the specification of contextual values and the persisted contextual
values themselves. By modifying the configuration files, the contextual values
can easily be customized for every context. From the specification, we generate
code to simplify development. Our implementation, called Elektra, permits
development in several languages including C++ and Java. In a benchmark we
compare layer activations between threads and between applications. In a case
study involving a web-server on a mobile embedded device the performance
overhead is minimal, even with many context switches.Comment: 8 pages Mobile! 16, October 31, 2016, Amsterdam, Netherland
Permission-Based Separation Logic for Multithreaded Java Programs
This paper motivates and presents a program logic for reasoning about multithreaded Java-like programs with concurrency primitives such as dynamic thread creation, thread joining and reentrant object monitors. The logic is based on concurrent separation logic. It is the first detailed adaptation of concurrent separation logic to a multithreaded Java-like language. The program logic associates a unique static access permission with each heap location, ensuring exclusive write accesses and ruling out data races. Concurrent reads are supported through fractional permissions. Permissions can be transferred between threads upon thread starting, thread joining, initial monitor entrancies and final monitor exits.\ud
This paper presents the basic principles to reason about thread creation and thread joining. It finishes with an outlook how this logic will evolve into a full-fledged verification technique for Java (and possibly other multithreaded languages)
Category Theory and Model-Driven Engineering: From Formal Semantics to Design Patterns and Beyond
There is a hidden intrigue in the title. CT is one of the most abstract
mathematical disciplines, sometimes nicknamed "abstract nonsense". MDE is a
recent trend in software development, industrially supported by standards,
tools, and the status of a new "silver bullet". Surprisingly, categorical
patterns turn out to be directly applicable to mathematical modeling of
structures appearing in everyday MDE practice. Model merging, transformation,
synchronization, and other important model management scenarios can be seen as
executions of categorical specifications.
Moreover, the paper aims to elucidate a claim that relationships between CT
and MDE are more complex and richer than is normally assumed for "applied
mathematics". CT provides a toolbox of design patterns and structural
principles of real practical value for MDE. We will present examples of how an
elementary categorical arrangement of a model management scenario reveals
deficiencies in the architecture of modern tools automating the scenario.Comment: In Proceedings ACCAT 2012, arXiv:1208.430
Deterministic Consistency: A Programming Model for Shared Memory Parallelism
The difficulty of developing reliable parallel software is generating
interest in deterministic environments, where a given program and input can
yield only one possible result. Languages or type systems can enforce
determinism in new code, and runtime systems can impose synthetic schedules on
legacy parallel code. To parallelize existing serial code, however, we would
like a programming model that is naturally deterministic without language
restrictions or artificial scheduling. We propose "deterministic consistency",
a parallel programming model as easy to understand as the "parallel assignment"
construct in sequential languages such as Perl and JavaScript, where concurrent
threads always read their inputs before writing shared outputs. DC supports
common data- and task-parallel synchronization abstractions such as fork/join
and barriers, as well as non-hierarchical structures such as producer/consumer
pipelines and futures. A preliminary prototype suggests that software-only
implementations of DC can run applications written for popular parallel
environments such as OpenMP with low (<10%) overhead for some applications.Comment: 7 pages, 3 figure
An Analysis of Composability and Composition Anomalies
The separation of concerns principle aims at decomposing a given design problem into concerns that are mapped to multiple independent software modules. The application of this principle eases the composition of the concerns and as such supports composability. Unfortunately, a clean separation (and composition of concerns) at the design level does not always imply the composability of the concerns at the implementation level. The composability might be reduced due to limitations of the implementation abstractions and composition mechanisms. The paper introduces the notion of composition anomaly to describe a general set of unexpected composition problems that arise when mapping design concerns to implementation concerns. To distinguish composition anomalies from other composition problems the requirements for composability at the design level is provided. The ideas are illustrated for a distributed newsgroup system
A Classification of Models for Concurrency
Models for concurrency can be classified with respect to the three relevant parameters: behaviour/system, interleaving/noninterleaving, linear/branching time. When modelling a process, a choice concerning such parameters corresponds to choosing the level of abstraction of the resulting semantics. The classifications are formalised through the medium of category theory
- …