1,709 research outputs found
Multi-Threaded Actors
In this paper we introduce a new programming model of multi-threaded actors
which feature the parallel processing of their messages. In this model an actor
consists of a group of active objects which share a message queue. We provide a
formal operational semantics, and a description of a Java-based implementation
for the basic programming abstractions describing multi-threaded actors.
Finally, we evaluate our proposal by means of an example application.Comment: In Proceedings ICE 2016, arXiv:1608.0313
Concurrent object-oriented programming: The MP-Eiffel approach
This article evaluates several possible approaches for integrating concurrency into
object-oriented programming languages, presenting afterwards, a new language named
MP-Eiffel. MP-Eiffel was designed attempting to include all the essential properties
of both concurrent and object-oriented programming with simplicity and safety.
A special care was taken to achieve the orthogonality of all the language mechanisms,
allowing their joint use without unsafe side-effects (such as inheritance anomalies)
A synchronous cooperative architecture for the PROSOFT software engineering environment
This paper shows the evolution of a software engineering environment (SEE) called PROSOFT to support the formal development of groupware applications. This environment, which is centered in the data-driven approach for software development, evolved to support cooperation in the software development process. Its transition is founded in a client/server
communication model called Distributed PROSOFT that provides software mechanisms to permit concurrent use of the environment resources. Thus, this paper presents a formal model that provides an object middleware with synchronous handling and version support for the objects created with the software tools integrated to the environment. Cooperative PROSOFT is presented as an architecture for the formal development of groupware applications that permits the formal validation of cooperative applications specified under its paradigm. A consequence of this work is the integration of the advantages found in formal specification techniques to the groupware development that provides the development of higher quality groupware applications than those obtained with the use of traditional techniques.Ingeniería de SoftwareRed de Universidades con Carreras en Informática (RedUNCI
Benchmarking Memory Management Capabilities within ROOT-Sim
In parallel discrete event simulation techniques, the simulation model is partitioned into objects, concurrently executing events on different CPUs and/or multiple CPUCores. In such a context, run-time supports for logical time synchronization across the different simulation objects play a central role in determining the effectiveness of the specific parallel simulation environment. In this paper we present an experimental evaluation of the memory management capabilities offered by the ROme OpTimistic Simulator (ROOT-Sim). This is an open source parallel simulation environment transparently supporting optimistic synchronization via recoverability (based on incremental log/restore techniques) of any type of memory operation affecting the state of simulation objects, i.e., memory allocation, deallocation and update operations. The experimental study is based on a synthetic benchmark which mimics different read/write patterns inside the dynamic memory map associated with the state of simulation objects. This allows sensibility analysis of time and space effects due to the memory management subsystem while varying the type and the locality of the accesses associated with event processin
A Type System for First-Class Layers with Inheritance, Subtyping, and Swapping
Context-Oriented Programming (COP) is a programming paradigm to encourage
modularization of context-dependent software. Key features of COP are
layers---modules to describe context-dependent behavioral variations of a
software system---and their dynamic activation, which can modify the behavior
of multiple objects that have already been instantiated. Typechecking programs
written in a COP language is difficult because the activation of a layer can
even change objects' interfaces. Inoue et al. have informally discussed how to
make JCop, an extension of Java for COP by Appeltauer et al., type-safe.
In this article, we formalize a small COP language called ContextFJ
with its operational semantics and type system and show its type soundness. The
language models main features of the type-safe version of JCop, including
dynamically activated first-class layers, inheritance of layer definitions,
layer subtyping, and layer swapping
- …