74 research outputs found
An Enablement Detection Algorithm for Open Multiparty Interactions
Coordination axnongst an arbitrary number of entities has
become an important issue in recent years m fields such as e--
commerce, web-based applications and so on. Traditionally,
classical client/server primitives have been used to implement
synchronisation and communication. But. when more
than two entities need to coordinate hy means of those primitives,
the coordination must be decomposed into a number
of client/server hipaxty interactions, leading the programmer
to the need of thinking in terms of the protocols needed
to achieve properties like livenes, atomicity and so on. In
this paper, we present an algorithm to perform enablement
detection to implement open multiparty interactions. This
primitive provides a high level of abstraction since the programmar
can implement multiparty coordination without
the need of thinking in terms of protocols
a framework for aspect–oriented multiparty coordination
Separation of concerns has been presented as a promising tool to tackle the
design of complex systems in which cross–cutting properties that do no fit into
the scope of a class must be satisfied. In this paper, we show that interaction
amongst a number of objects can also be described separately from functionality
by means of the CAL language, and present a framework that provides the needed
infrastructure. It is innovative because it supports open multiparty interactions
An Order-Based, Distributed Algorithm for Implementing Multiparty Interactions
Multiparty interactions have been paid much attention in
recent years because they provide the user with a useful mechanism
for coordinating a number of entities that need to cooperate in order
to achieve a common goal. In this paper, we present an algorithm for
implementing them that is based on the idea of locking resources in a
given order. It improves on previous results in that it can be used in
a context in which the set of participants in an interaction cannot be
known at compile time, and setting up communication links amongst
interaction managers is costly or completely impossible
An Algorithm for Ensuring Fairness and Liveness in Non-deterministic Systems Based on Multiparty Interactions
Strong fairness is a notion we can use to ensure that an element
that is enabled infinitely often in a non–deterministic programme,
will eventually be selected for execution so that it can progress. Unfortunately,
“eventually” is too weak to induce the intuitive idea of liveliness
and leads to anomalies that are not desirable, namely fair finiteness and
conspiracies. In this paper, we focus on non–deterministic programmes
based on multiparty interactions and we present a new criteria for selecting
interactions called strong k–fairness that improves on other proposals
in that it addresses both anomalies simultaneously, and k may be set a
priori to control its goodness. We also show our notion is feasible, and
present an algorithm for scheduling interactions in a strongly k–fair manner
using a theoretical framework to support the multiparty interaction
model. Our algorithm does not require to transform the source code to
the processes that compose the system; furthermore, it can deal with
both terminating and non–terminating processes.ComisiĂłn Interministerial de Ciencia y TecnologĂa TIC 2000–1106–C02–0
An order-based algorithm for implementing multiparty synchronization
Multiparty interactions are a powerful mechanism for coordinating several entities that need to cooperate
in order to achieve a common goal. In this paper, we present an algorithm for implementing them that
improves on previous results in that it does not require the whole set of entities or interactions to be known
at compile- or run-time, and it can deal with both terminating and non-terminating systems. We also
present a comprehensive simulation analysis that shows how sensitive to changes our algorithm is, and
compare the results with well-known proposals by other authors. This study proves that our algorithm still
performs comparably to other proposals in which the set of entities and interactions is known beforehand,
but outperforms them in some situations that are clearly identified. In addition, these results prove that
our algorithm can be combined with a technique called synchrony loosening without having an effect on
efficiency.Ministerio de Ciencia y TecnologĂa TIC 2003-02737-C02-0
Aspect-oriented interaction in multi-organisational web-based systems
Separation of concerns has been presented as a promising tool to tackle the design of complex systems in which
cross-cutting properties that do not fit into the scope of a class must be satisfied. Unfortunately, current proposals
assume that objects interact by means of object-oriented method calls, which implies that they embed interactions with
others into their functional code. This makes them dependent on this interaction model, and makes it difficult to reuse
them in a context in which another interaction model is more suited, e.g., tuple spaces, multiparty meetings, ports, and
so forth. In this paper, we show that functionality can be described separately from the interaction model used, which
helps enhance reusability of functional code and coordination patterns. Our proposal is innovative in that it is the first
that achieves a clear separation between functionality and interaction in an aspect-oriented manner. In order to show
that it is feasible, we adapted the multiparty interaction model to the context of multiorganisational web-based systems
and developed a class framework to build business objects whose performance rates comparably to handmade implementations;
the development time, however, decreases significantly.ComisiĂłn Interministerial de Ciencia y TecnologĂa TIC2000-1106-C02-0
Implantations distribuées de modèles à base de composants communicants par interactions multiparties avec priorités : application au langage BIP
Distributed software is often required for new systems, because of efficiency and physical distribution and sensors and actuators. Ensuring correctness of a distributed implementation is hard due to the interleaving of actions belonging to distinct processes. This thesis proposes a method for generating a correct and efficient distributed implementation from a high-level model of an application. The input model is described as a set of components communicating through prioritized multiparty interactions. Such primitives change the state of all components involved in an interaction during a single atomic execution step. We assume that a distributed implementation is a set of processes communicating through asynchronous message-passing. The main challenge is to produce a correct and efficient distributed implementation of prioritized multiparty interactions, relying only on message-passing. The method relies on a rigorous design flow refining the high-level model of the application into a low-level model, from which code for a given platform is generated. All intermediate models appearing in the flow are expressed using the same semantics as the input model. Complex interactions are replaced with constructs using simpler interactions at each step of the design flow. In particular, the last model obtained before code generation contains only interactions modeling asynchronous message passing. The correctness of the implementation is obtained by construction. Using multiparty interaction reduces drastically the set of reachable states, compared to an equivalent model expressed with lower level primitives. Essential properties of the system are checked at this abstraction level. Each transformation of the design flow is simple enough to be fully formalized and proved by showing observational equivalence or trace equivalence between the input and output models. The obtained implementation is correct with respect to the original model, which avoids an expensive a posteriori verification. Performance can be optimized through adequate choice of the transformation parameters, or by augmenting the knowledge of components. The latter solution requires to analyze the original model to compute the knowledge, that is reused at subsequent steps of the decentralization. The various transformations and optimizations constituting the design flow have been implemented using the BIP framework. The implementation has been used to evaluate the different possibilities, as well the influence of parameters of the design flow, on several examples. The generated code uses either Unix sockets, MPI or pthreads primitives for communication between processes.Les nouveaux systèmes ont souvent recours à une implémentation distribuée du logiciel, pour des raisons d'efficacité et à cause de l'emplacement physique de certains capteurs et actuateurs. S'assurer de la correction d'un logiciel distribué est difficile car cela impose de considérer tous les enchevêtrements possibles des actions exécutées par des processus distincts. Cette thèse propose une méthode pour générer, à partir d'un modèle d'application haut niveau, une implémentation distribuée correcte et efficace. Le modèle de l'application comporte des composants communiquant au moyen d'interactions multiparties avec priorités. L'exécution d'une interaction multipartie, qui correspond à un pas de la sémantique, change de façon atomique l'état de tous les composants participant à l'interaction. On définit une implantation distribuée comme un ensemble de processus communiquant par envoi de message asynchrone. La principale difficulté est de produire une implémentation correcte et efficace des interactions multiparties avec priorités, en utilisant uniquement l'envoi de message comme primitive. La méthode se fonde sur un flot de conception rigoureux qui raffine progressivement le modèle haut niveau en un modèle bas niveau, à partir duquel le code pour une plateforme particulière est généré. Tous les modèles intermédiaires apparaissant dans le flot sont exprimés avec la même sémantique que le modèle original. À chaque étape du flot, les interactions complexes sont remplacés par des constructions utilisant des interactions plus simples. En particulier, le dernier modèle obtenu avant la génération du code ne contient que des interactions modélisant l'envoi de message. La correction de l'implémentation est obtenue par construction. L'utilisation des interactions multiparties comme primitives dans le modèle de l'application permet de réduire très significativement l'ensemble des états atteignables, par rapport à un modèle équivalent mais utilisant des primitives de communication plus simples. Les propriétés essentielles du système sont vérifiées à ce niveau d'abstraction. Chaque transformation constituante du flot de conception est suffisamment simple pour être complètement formalisée et prouvée, en termes d'équivalence observationelle ou d'équivalence de trace entre le modèles avant et après transformation. L'implémentation ainsi obtenue est correcte par rapport au modèle original, ce qui évite une coûteuse vérification a posteriori. Concernant l'efficacité, la performance de l'implémentation peut être optimisée en choisissant les paramètres adéquats pour les transformations, ou en augmentant la connaissance des composants. Cette dernière solution requiert une analyse du modèle de départ afin de calculer la connaissance qui est réutilisée pour les étapes ultérieures du flot de conception. Les différentes transformations et optimisations constituant le flot de conception ont été implémentées dans le cadre de BIP. Cette implémentation a permis d'évaluer les différentes possibilités ainsi que l'influence des différents paramètres, sur la performance de l'implémentation obtenue avec plusieurs exemples. Le code généré utilise les primitives fournies par les sockets POSIX, MPI ou les pthreads pour envoyer des messages entre les processus
Aspect Oriented Interaction in Environments Multi Organizational
Por desgracia, las propuestas actuales de separaci´on de aspectos asumen que los objetos
interact´uan mediante invocaci´on de m´etodos, lo que implica que tienen que embeber
las interacciones dentro del c´odigo funcional. Esto los hace dependientes de este modelo de interacci´on y hace dif´ıcil reutilizarlos en un contexto en el que otro modelo de
interacci´on sea m´as adecuado. En este art´ıculo mostramos que la funcionalidad puede
ser descrita de forma independiente al modelo de interacci´on usado, lo que mejora la
facilidad de reutilizaci´on del c´odigo funcional y los patrones de coordinaci´on. Para
demostrar que es viable, hemos adaptado el modelo de interacci´on entre m´ultiples participantes al contexto de los sistemas multiorganizacionales basados en la web y hemos
desarrollado un framework de clases que permite construir objetos de negocio cuyo
rendimiento es comparable al de una implementaci´on artesanal; el tiempo de desarrollo, por el contrario, se reduce de forma muy significativa.Unfortunately, current proposals that focus on separation of concerns assume that objects interact by means of object-oriented method calls, which implies that they embed
interactions with others into their functional code. This makes them dependent on this
interaction model, and makes it difficult to reuse them in a context in which another
interaction model is more suited. In this paper, we show that functionality can be
described separately from the interaction model used, which helps enhance reusability of functional code and coordination patterns. In order to show that it is feasible,
we adapted the multiparty interaction model to the context of Multi-Organisational
Web-Based Systems and developed a class framework to build business objects whose
performance rates comparably to a handmade implementation; the development time,
however, decreases significantly
InteracciĂłn orientada a aspectos en entornos multiorganizacionales
Unfortunately, current proposals that focus on separation of concerns assume that objects interact by means of object-oriented method calls, which implies that they embed interactions with others into their functional code. This makes them dependent on this interaction model, and makes it difficult to reuse them in a context in which another interaction model is more suited.Keywords: Aspect orientation, interaction models, multiparty interactions
A Comparative Analysis of Distributed Ledger Technology Platforms
Distributed Ledger Technology (DLT) has emerged as one of the most disruptive technologies in the last decade. It promises to change the way people do their business, track their products, and manage their personal data. Though the concept of DLT was first implemented in 2009 as Bitcoin, it has gained significant attention only in the past few years. During this time, different DLT enthusiasts and commercial companies have proposed and developed several DLT platforms. These platforms are usually categorized as public vs private, general-purpose vs application-specific and so on. As a growing number of people are interested to build DLT applications, it is important to understand their underlying architecture and capabilities in order to determine which DLT platform should be leveraged for a specific DLT application. In addition, the platforms need to be evaluated and critically analyzed to assess their applicability, resiliency and sustainability in the long run. In this paper, we have surveyed several leading DLT platforms and evaluated their capabilities based on a number of quantitative and qualitative criteria. The comparative analysis presented in this paper will help the DLT developers and architects to choose the best platform as per their requirement(s)
- …