TuSoW: Tuple Spaces for Edge Computing

TuSoW: Tuple Spaces for Edge Computing
Giovanni Ciatto1 Lorenzo Rizzato1 Andrea Omicini1
Stefano Mariani2
giovanni.ciatto@unibo.it lorenzo.rizzato@studio.unibo.it
andrea.omicini@unibo.it stefano.mariani@unimore.it
1Dipartimento di Informatica – Scienza e Ingegneria—Universit`a di Bologna
2Dipartimento di Scienze e Metodi dell’Ingegneria, Universit`a di Modena e Reggio Emilia
1st International Workshop on Edge of Things (EoT)
Valencia, Spain – August 1, 2019
Ciatto et al. (UniBo, UniMoRe) Tuple Spaces for Edge Computing EoT 2019, Aug 1 1 / 26

Outline
1 Context & Motivations
2 (Tuple-based) Coordination
3 Our proposal for TbC: the TuSoW project
4 Conclusions and Future Work

Context & Motivations
Next in Line. . .

Context & Motivations
Our perspective
In a nutshell
EoT = IoT − Cloud
Computation is delegated to edge devices, when possible
In Cloud-based applications
the Cloud acts as a central coordinator
for devices, data, and activities
The coordination problem
! How can edge devices coordinate themselves without the cloud?
! And what is coordination in the ﬁrst place?

(Tuple-based) Coordination
Next in Line. . .

What is Coordination?
Within MAS
“A framework in which the interaction of active and independent entities
called agents can be expressed” [Ciancarini, 1996]
active entities like, for instance, EoT devices and clients
interaction i.e., dependencies among computational activities
e.g. communication, cooperation, competition, etc.
expressed i.e., explicitly represented, observed & possibly governed
Takeaway
Coordination studies interaction at the fundamental level

Coordination-as-a-Service [Viroli and Omicini, 2006] as the reference
meta-model
Coordinated
Space
Interaction Space Coordination
Space
Coordinated
Entities
Requests / Responses Coordination
Media
A number of entities
e.g. edge devices
coordinate by means of a
number of media
e.g. other edge devices,
cloud providers, etc
wherewith requests and
response messages are
exchanged
e.g. HTTP, MQTT, etc

Linda [Gelernter, 1985] as the reference model I
1 In Linda coordination media are called tuple spaces
2 They are essentially shared blackboards

Linda [Gelernter, 1985] as the reference model II
3 where clients can write any sort of information—a.k.a. tuples
according to some representation format of choice
to: Bob, msg: Hello
w
rite
Alice
to: Bob, msg: Hello
4 enabling a feature called generative communication

Linda [Gelernter, 1985] as the reference model III
5 where clients can read all information matching a particular template
according to some query language of choice
to: Bob, msg: Hello
Alice
Bob
read
to: Bob, msg: *
6 enabling a feature called associative access

Linda [Gelernter, 1985] as the reference model IV
7 or take it, making it unavailable for other clients
Alice
Carl
take
to: Carl, msg: Hello
to: Carl, msg: *

Linda [Gelernter, 1985] as the reference model V
8 or take it, making it unavailable for other clients
Alice
Carl
to: Carl, msg: Hello

Linda [Gelernter, 1985] as the reference model VI
What makes Linda diﬀerent from databases?
Suspensive semantics: read and take operations are suspended if no
tuple is available
Non-determinism: if several tuples are available, read and take
operations choose one, non-deterministically
Reference uncoupling: devices do not need to know (about) each
others
! Such features enable the development of open application
where loosely-coupled clients must interact
such as in the EoT

The problem with Tuple-based Coordination (TbC)
As further discussed in [Ciatto et al., 2018]
TbC is a very well studied research topic
for which several proof of concept implementations have been
provided
coming with as many tuple & template languages
! mostly monolithic, discontinued or inadequate for real world needs
Our claim
Technological limitations are what actually hinders wide adoption of TbC

Our proposal for TbC: the TuSoW project
Next in Line. . .

The TuSoW project https://gitlab.com/pika-lab/tuples/coordination
Our proposal
TuSoW is our Linda-based technology focussing on
interoperability
lightweightness
Avoid repeating past errors
Do not commit to any particular
runtime platform (JVM, Python, JS, .NET, etc)
transport protocol (HTTP, MQTT, gRPC)
tuple/template language or matching mechanism
since EoT devices may be leverage on any of them
Design rationale
Design once, port everywhere (with minimal eﬀort)

TuSoW – Layered Perspective
TuSoW Core API
TuSoW Local
Implementation
Transport Layer
TuSoW Core API
TuSoW Remote
Implementation
iOS
Docker
JVM
Library
Linking
(De)Serialization
HTTP
MQTT
gRPC
YAML
XML
JSON
JS
Python
JVM
.NET
iOS
Native
{
{
LocalRemote
Figure: Dashed lines as choice points
Remote impl., supporting
mainstream platforms
General, abstract, shared core API
Presentation layer supporting
various data representation
formats
Transport layer supporting various
protocols
and diﬀerent applications
Local impl., supporting mobile
devices and containerisation

About transport protocols
HTTP targets web-based & general purpose applications
focus on compatibility
gRPC targets mobile devices and smartphones
focus on portability
MQTT targets resource constrained devices (e.g. Raspberries)
focus on lightweightness

TuSoW – Spaces, Tuples, and Templates
core
Tuple Template
TupleSpace Match
domstringslogic
TuSoW
HTTP gRPC
MQTT
implementimplementimplement
wrapwrapwrap
Client
Client_API
implements
uses
Spaces Tuples Templates
textual strings regex
logic logic terms non-ground terms
objects YAML/JSON JsonPath
DOM XML XPath

About Tuple Spaces and Tuple/Template languages
Textual spaces target coordination of heterogeneous devices handling
poorly structured data
Logic spaces target coordination intelligent agents prone to symbolic
knowledge processing
Object or DOM spaces target coordination in the Web of Things

TuSoW – Multi-platform concurrency
Diﬀerent platforms come with diﬀerent concurrency model
e.g. co-routines on Python & .NET
e.g. Futures or Promises on Java or JavaScript
e.g. callbacks on Node
→ Remote libraries must support the most natural style for each platform

Conclusions and Future Work
Next in Line. . .

Conclusions and Future Work
Conclusion & Future Works
Summing up, in this work we
argue Coordination-as-a-Service has a role to play in EoT
present TuSoW as an interoperable technology implementing it
and overcoming current technological limitations
In the future we plan to
extend TuSoW with access control
extend TuSoW with replications, for fault tolerance
provide more high-level API, e.g. for FIPA IP [O’Brien and Nicol, 1998]

TuSoW: Tuple Spaces for Edge Computing
Giovanni Ciatto1 Lorenzo Rizzato1 Andrea Omicini1
Stefano Mariani2
giovanni.ciatto@unibo.it lorenzo.rizzato@studio.unibo.it
andrea.omicini@unibo.it stefano.mariani@unimore.it
1Dipartimento di Informatica – Scienza e Ingegneria—Universit`a di Bologna
2Dipartimento di Scienze e Metodi dell’Ingegneria, Universit`a di Modena e Reggio Emilia
1st International Workshop on Edge of Things (EoT)
Valencia, Spain – August 1, 2019

References
References I
Ciancarini, P. (1996).
Coordination models and languages as software integrators.
ACM Computing Surveys, 28(2):300–302.
Ciatto, G., Mariani, S., Omicini, A., Zambonelli, F., and Louvel, M.
(2018).
Twenty years of coordination technologies: State-of-the-art and
perspectives.
In Di Marzo Serugendo, G. and Loreti, M., editors, Coordination
Models and Languages, volume 10852 of Lecture Notes in Computer
Science, pages 51–80. Springer.
20th IFIP WG 6.1 International Conference, COORDINATION 2018,
Held as Part of the 13th International Federated Conference on
Distributed Computing Techniques, DisCoTec 2018, Madrid, Spain,
June 18-21, 2018. Proceedings.

References
References II
Gelernter, D. (1985).
Generative communication in Linda.
ACM Transactions on Programming Languages and Systems,
7(1):80–112.
O’Brien, P. D. and Nicol, R. C. (1998).
Fipa — towards a standard for software agents.
BT Technology Journal, 16(3):51–59.
Viroli, M. and Omicini, A. (2006).
Coordination as a service.
Fundamenta Informaticae, 73(4):507–534.

TuSoW: Tuple Spaces for Edge Computing

More Related Content

Similar to TuSoW: Tuple Spaces for Edge Computing (20)

More from Giovanni Ciatto (12)

Recently uploaded (20)

TuSoW: Tuple Spaces for Edge Computing