6 research outputs found
Time-fluid field-based coordination
Emerging application scenarios, such as cyber-physical systems (CPSs), the Internet of Things (IoT), and edge computing, call for coordination approaches addressing openness, self-adaptation, heterogeneity, and deployment agnosticism. Field-based coordination is one such approach, promoting the idea of programming system coordination declaratively from a global perspective, in terms of functional manipulation and evolution in “space and time” of distributed data structures, called fields. More specifically, regarding time, in field-based coordination it is assumed that local activities in each device, called computational rounds, are regulated by a fixed clock, typically, a fair and unsynchronized distributed scheduler. In this work, we challenge this assumption, and propose an alternative approach where the round execution scheduling is naturally programmed along with the usual coordination specification, namely, in terms of a field of causal relations dictating what is the notion of causality (why and when a round has to be locally scheduled) and how it should change across time and space. This abstraction over the traditional view on global time allows us to express what we call “time-fluid” coordination, where causality can be finely tuned to select the event triggers to react to, up to to achieve improved balance between performance (system reactivity) and cost (usage of computational resources). We propose an implementation in the aggregate computing framework, and evaluate via simulation on a case study
Time-fluid field-based coordination
Emerging application scenarios, such as cyber-physical systems (CPSs), the Internet of Things (IoT), and edge computing, call for coordination approaches addressing openness, self-adaptation, heterogeneity, and deployment agnosticism. Field-based coordination is one such approach, promoting the idea of programming system coordination declaratively from a global perspective, in terms of functional manipulation and evolution in \u201cspace and time\u201d of distributed data structures, called fields. More specifically, regarding time, in field-based coordination it is assumed that local activities in each device, called computational rounds, are regulated by a fixed clock, typically, a fair and unsynchronized distributed scheduler. In this work, we challenge this assumption, and propose an alternative approach where the round execution scheduling is naturally programmed along with the usual coordination specification, namely, in terms of a field of causal relations dictating what is the notion of causality (why and when a round has to be locally scheduled) and how it should change across time and space. This abstraction over the traditional view on global time allows us to express what we call \u201ctime-fluid\u201d coordination, where causality can be finely tuned to select the event triggers to react to, up to to achieve improved balance between performance (system reactivity) and cost (usage of computational resources). We propose an implementation in the aggregate computing framework, and evaluate via simulation on a case study
Time-Fluid Field-Based Coordination through Programmable Distributed Schedulers
Emerging application scenarios, such as cyber-physical systems (CPSs), the
Internet of Things (IoT), and edge computing, call for coordination approaches
addressing openness, self-adaptation, heterogeneity, and deployment
agnosticism. Field-based coordination is one such approach, promoting the idea
of programming system coordination declaratively from a global perspective, in
terms of functional manipulation and evolution in "space and time" of
distributed data structures called fields. More specifically regarding time, in
field-based coordination (as in many other distributed approaches to
coordination) it is assumed that local activities in each device are regulated
by a fair and unsynchronised fixed clock working at the platform level. In this
work, we challenge this assumption, and propose an alternative approach where
scheduling is programmed in a natural way (along with usual field-based
coordination) in terms of causality fields, each enacting a programmable
distributed notion of a computation "cause" (why and when a field computation
has to be locally computed) and how it should change across time and space.
Starting from low-level platform triggers, such causality fields can be
organised into multiple layers, up to high-level, collectively-computed time
abstractions, to be used at the application level. This reinterpretation of
time in terms of articulated causality relations allows us to express what we
call "time-fluid" coordination, where scheduling can be finely tuned so as to
select the triggers to react to, generally allowing to adaptively balance
performance (system reactivity) and cost (resource usage) of computations. We
formalise the proposed scheduling framework for field-based coordination in the
context of the field calculus, discuss an implementation in the aggregate
computing framework, and finally evaluate the approach via simulation on
several case studies
Coordenação desacoplada tolerante a faltas bizantinas
Tese (doutorado) - Universidade Federal de Santa Catarina, Centro Tecnológico. Programa de Pós-graduação em Engenharia ElétricaSistemas distribuídos abertos são tipicamente compostos por um número desconhecido e variável de processos executando em um ambiente heterogêneo, onde as comunicações muitas vezes requerem desconexões temporárias e segurança contra ações maliciosas. A coordenação por espaço de tuplas é um modelo de comunicação bastante conhecido para estes ambientes pois provê comunicação desacoplada tanto no tempo (os processos não precisam estar ativos ao mesmo tempo para interagirem) quanto no espaço (os processos não necessitam saber os endereços uns dos outros). Vários trabalhos têm tentado melhorar a segurança de funcionamento dos espaços de tuplas através do uso de replicação e transações para tolerância a faltas ou controle de acesso e criptografia para segurança. Entretanto, muitas aplicações práticas na Internet requerem ambas estas dimensões. Nesta tese, o modelo de coordenação por espaços de tuplas é usado para resolver o problema da coordenação desacoplada em ambientes não confiáveis, i.e., onde os processos estão sujeitos a falhas bizantinas (podem desviar-se arbitrariamente de suas especificações). Os resultados aqui apresentados atacam dois problemas básicos: (1) como construir espaços de tuplas com segurança de funcionamento (seguros e tolerantes a faltas bizantinas), e (2) como usar estes espaços para resolução de problemas fundamentais em computação distribuída. Os resultados referentes a (1) são uma arquitetura para espaço de tuplas com segurança de funcionamento que integra mecanismos de segurança e tolerância a faltas, duas construções eficientes para espaços de tuplas tolerantes a faltas bizantinas baseadas em uma nova filosofia de replicação, e um esquema de confidencialidade para espaços de tuplas replicados. Com relação á (2), é mostrado que um espaço de tuplas aumentado protegido por políticas de granularidade fina pode ser usado para resolver eficientemente vários problemas em computação distribuída mesmo com processos sujeitos a falta
The Fading Concept in Tuple-Space Systems
Tuple-space systems based on the LINDA model have been in use in distributed systems for nearly two decades. An area that has recently received attention from the distributed systems community is Swarm Intelligence (SI) --- SI has been successfully used in fields such as robotics and optimisation. Recently its properties have started to attract research in distributed systems. In this paper we merge SI concepts into the LINDA model to provide an adaptive approach to time which is unrelated to external (real) time: the result is the introduction of an adaptive concept of time into the system, without changing the LINDA model --- we call it fading. Some potential applications of this concept are discussed, along with implications for feasible implementation