458 research outputs found
A Study of Concurrency Bugs and Advanced Development Support for Actor-based Programs
The actor model is an attractive foundation for developing concurrent
applications because actors are isolated concurrent entities that communicate
through asynchronous messages and do not share state. Thereby, they avoid
concurrency bugs such as data races, but are not immune to concurrency bugs in
general. This study taxonomizes concurrency bugs in actor-based programs
reported in literature. Furthermore, it analyzes the bugs to identify the
patterns causing them as well as their observable behavior. Based on this
taxonomy, we further analyze the literature and find that current approaches to
static analysis and testing focus on communication deadlocks and message
protocol violations. However, they do not provide solutions to identify
livelocks and behavioral deadlocks. The insights obtained in this study can be
used to improve debugging support for actor-based programs with new debugging
techniques to identify the root cause of complex concurrency bugs.Comment: - Submitted for review - Removed section 6 "Research Roadmap for
Debuggers", its content was summarized in the Future Work section - Added
references for section 1, section 3, section 4.3 and section 5.1 - Updated
citation
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
Prototyping a scalable Aggregate Computing cluster with open-source solutions
L'Internet of Things è un concetto che è stato ora adottato in modo pervasivo per descrivere un vasto insieme di dispositivi connessi attraverso Internet. Comunemente, i sistemi IoT vengono creati con un approccio bottom-up e si concentrano principalmente sul singolo dispositivo, il quale è visto come la basilare unità programmabile. Da questo metodo può emergere un comportamento comune trovato in molti sistemi esistenti che deriva dall'interazione di singoli dispositivi. Tuttavia, questo crea un'applicazione distribuita spesso dove i componenti sono strettamente legati tra di loro. Quando tali applicazioni crescono in complessità , tendono a soffrire di problemi di progettazione, mancanza di modularità e riusabilità , difficoltà di implementazione e problemi di test e manutenzione.
L'Aggregate Programming fornisce un approccio top-down a questi sistemi, in cui l'unità di calcolo di base è un'aggregazione anziché un singolo dispositivo.
Questa tesi consiste nella progettazione e nella distribuzione di una piattaforma, basata su tecnologie open-source, per supportare l'Aggregate Computing nel cloud, in cui i dispositivi saranno in grado di scegliere dinamicamente se il calcolo si trova su se stessi o nel cloud. Anche se Aggregate Computing è intrinsecamente progettato per un calcolo distribuito, il Cloud Computing introduce un'alternativa scalabile, affidabile e altamente disponibile come strategia di esecuzione. Quest'opera descrive come sfruttare una Reactive Platform per creare un'applicazione scalabile nel cloud.
Dopo che la struttura, l'interazione e il comportamento dell'applicazione sono stati progettati, viene descritto come la distribuzione dei suoi componenti viene effettuata attraverso un approccio di containerizzazione con Kubernetes come orchestratore per gestire lo stato desiderato del sistema con una strategia di Continuous Delivery
Using an Actor Framework for Scientific Computing: Opportunities and Challenges
We examine the challenges and advantages of using an actor framework for programming and execution of scientific workflows. The following specific topics are studied: implementing workflow semantics and typical workflow patterns in the actor model, parallel and distributed execution of workflow activities using actors, leveraging event sourcing as a novel approach for workflow state persistence and recovery, and applying supervision as a fault tolerance model for workflows. In order to practically validate our research, we have created Scaflow, an Akka-based programming library and workflow execution engine. We study an example workflow implemented in Scaflow, and present experimental measurements of workflow persistence overhead
A Semantic Consistency Model to Reduce Coordination in Replicated Systems
Large-scale distributed applications need to be available and responsive to satisfy millions
of users, which can be achieved by having data geo-replicated in multiple replicas.
However, a partitioned system cannot sustain availability and consistency at fully.
The usage of weak consistency models might lead to data integrity violations, triggered
by problematic concurrent updates, such as selling twice the last ticket on a flight company
service. To overcome possible conflicts, programmers might opt to apply strong
consistency, which guarantees a total order between operations, while preserving data
integrity. Nevertheless, the illusion of being a non-replicated system affects its availability.
In contrast, weaker notions might be used, such as eventual consistency, that boosts
responsiveness, as operations are executed directly at the source replica and their effects
are propagated to remote replicas in the background. However, this approach might put
data integrity at risk. Current protocols that preserve invariants rely on, at least, causal
consistency, a consistency model that maintains causal dependencies between operations.
In this dissertation, we propose a protocol that includes a semantic consistency model.
This consistency model stands between eventual consistency and causal consistency. We
guarantee better performance comparing with causal consistency, and ensure data integrity.
Through semantic analysis, relying on the static analysis tool CISE3, we manage
to limit the maximum number of dependencies that each operation will have. To support
the protocol, we developed a communication algorithm in a cluster. Additionally,
we present an architecture that uses Akka, an actor-based middleware in which actors
communicate by exchanging messages. This architecture adopts the publish/subscribe
pattern and includes data persistence. We also consider the stability of operations, as well
as a dynamic cluster environment, ensuring the convergence of the replicated state. Finally,
we perform an experimental evaluation regarding the performance of the algorithm
using standard case studies. The evaluation confirms that by relying on semantic analysis,
the system requires less coordination between the replicas than causal consistency,
ensuring data integrity.Aplicações distribuÃdas em larga escala necessitam de estar disponÃveis e de serem responsivas
para satisfazer milhões de utilizadores, o que pode ser alcançado através da
geo-replicação dos dados em múltiplas réplicas.
No entanto, um sistema particionado não consegue garantir disponibilidade e consistência
na sua totalidade. O uso de modelos de consistência fraca pode levar a violações da
integridade dos dados, originadas por escritas concorrentes problemáticas. Para superar
possÃveis conflitos, os programadores podem optar por aplicar modelos de consistência
forte, originando uma ordem total das operações, assegurando a integridade dos dados.
Em contrapartida, podem ser utilizadas noções mais fracas, como a consistência eventual,
que aumenta a capacidade de resposta, uma vez que as operações são executadas diretamente
na réplica de origem e os seus efeitos são propagados para réplicas remotas. No
entanto, esta abordagem pode colocar em risco a integridade dos dados. Os protocolos
existentes que preservam as invariantes dependem, pelo menos, da consistência causal,
um modelo de consistência que mantém as dependências causais entre operações.
Nesta dissertação propomos um protocolo que inclui um modelo de consistência semântica.
Este modelo situa-se entre a consistência eventual e a consistência causal. Garantimos
um melhor desempenho em comparação com a consistência causal, e asseguramos
a integridade dos dados. Através de uma análise semântica, obtida através da ferramenta
de análise estática CISE3, conseguimos limitar o número de dependências de cada operação.
Para suportar o protocolo, desenvolvemos um algoritmo de comunicação entre
um aglomerado de réplicas. Adicionalmente, apresentamos uma arquitetura que utiliza
Akka, um middleware baseado em atores que trocam mensagens entre si. Esta arquitetura
utiliza o padrão publish/subscribe e inclui a persistência dos dados. Consideramos também
a estabilidade das operações, bem como um ambiente dinâmico de réplicas, assegurando
a convergência do estado. Por último, apresentamos a avaliação do desempenho do algoritmo
desenvolvido, que confirma que a análise semântica das operações requer menos
coordenação entre as réplicas que a consistência causal
- …