Protelis: Practical Aggregate Programming - Symposium on Applied Computing (SAC), 2015

Protelis: Practical Aggregate Programming

Danilo Pianini, Mirko Viroli{danilo.pianini,mirko.viroli}@unibo.it

Jacob [email protected]

Universita di BolognaItaly

Raytheon BBN TechnologiesUnited States of America

Symposium on Applied Computing 2015Salamanca

Pianini, Viroli, Beal (UniBo / BBN) Protelis — Aggregate programming 2015-04-16 SAC/CM 1 / 37

Outline You’ll soon have your God, and you’ll make it with your hands.

1 Aggregate ProgrammingLocal to GlobalFrom Proto to Field Calculus

2 ProtelisLanguage featuresSimulator and RuntimeExamples

3 Conclusion and Future work


Aggregate Programming

Outline





Aggregate Programming Local to Global

Our stage

Large number of devices or services

Possibly situated

Capable of sensing, computing, communicating

Behaviour must be coordinated to achieve a global goal

Pervasive Continuum or (pick the one you prefer):

Pervasive computingSmart citiesInternet of things



Classic approach

Local to global

Complex global behaviour

Simple local behaviour

The whole is more than the sum of the parts

Interaction is key

Nature inspiration

Several systems use nature as inspiration:

physical particles [MZ09]

chemical reactions [ZCF+11]

ants, termites and other social insects [TM03]

Very brief list! There are many more.



Nice properties and hard challenges

The beauty

High resilience and fault tolerance

Self adaptation

Openness

Self healing

The beast

Local to global is hard to engineer

The desired functionality happens at the aggregate level

It is very difficult to design the local behaviour in such a way that theinteraction of many of them produces the desired global behaviour

Many attempts, but no good engineering processes to safely designsuch systems

Often, development becomes a try-and-simulate loopPianini, Viroli, Beal (UniBo / BBN) Protelis — Aggregate programming 2015-04-16 SAC/CM 6 / 37


Collective to local

Device&

Neighborhood&

Manifold&

Device&

Neighborhood&

Network&

Possible solution

Create a language that allows to express collective properties

Create a runtime that can run such programs

Possibly, also create a tool to test programs prior to deployment


Aggregate Programming From Proto to Field Calculus

Existing languages

MIT Proto [BB06] is the most known and successful

Developed at MIT and maintained at BBN Technologies

Functional language, LISP-like syntax (I know you hate it too)

All devices run the same program

Computation happens in rounds:

Every device sleeps for some timeProcesses the messages received from the neighboursExecutes its programSends all the neighbours its result

Complex operational semantics

Difficult to maintain and extend


Aggregate Programming From Proto to Field Calculus

Field Calculus

A “distillate” of Proto

Provides a lightweight operational semantics [VDB13]

((((LISP-like syntax))))

Still a functional language

Simple enough to formally prove properties, powerful enough to beuniversal (proved!)

Theoretical object, no runtime nor simulation tool provided


Protelis

Outline





Protelis Language features

Ordinary language features

Functional language

Same operational semantics of the field calculus

C-family syntax with infix operators

Java interoperability: static methods imports and calls, methodinvocation with dynamic binding

Higher order functions (functions as arguments, lambdas)

Dynamic code



Field calculus operators

rep

defines a locally visible variable

Retains its value at each computation round

Enables stateful computation

nbr

Builds a field

Map device →valueIncludes self

*hood built-in functions summarize the field back to ordinaryexpressions



Branching

mux / else

Functional inclusive “multiplexing” branching

Evaluates both branches, then returns the correct one

nbrs in branches can “align”

if / else

Exclusive branching: nbrs in different branches do not “align”

Network gets partitioned into two regions



Code example

def count() {rep(x<-0) { x + 1 }

}

def maxh(field) { maxHood(nbr{field}) }

def distanceTo(source) {rep (d <- Infinity) {

mux (source) { 0 } else { minHood(nbr{d} + nbrRange) }}

}

def distanceToWithObstacle(source, obstacle) {if (obstacle) { Infinity } else { distanceTo(source) }

}


Protelis Simulator and Runtime

Architecture

Implementation, distribution

Based on Xtext

Eclipse plugin

Integrated with Alchemist [PMV13]

Stand-alone framework for real devices

Write once, run everywhere — evolved :)

Now distributed through Maven Central a

aartifact: it.unibo.alchemist:alchemist.protelis



Abstract architecture

Protelis)Parser)

Protelis)Device)

Environment)Variables)

Protelis)Interpreter)

Protelis)Program)

Other&Devices&



Simulation runtime architecture

Simulated*Device*

Protelis*Parser*

Protelis*Device*

Environment*Variables*

Protelis*Interpreter*

Protelis)Program)

Simulated*Environment*

Simula8on*Builder*

Simula/on)Script)

Alchemist*Simulator*

Simulated*Network*



Standalone runtime architecture

Daemon'Device'

Protelis'Parser'

Protelis'Device'

Environment'Variables'

Protelis'Interpreter'

Protelis)Program)

Service'Manager'Daemon'

Networked'Service'

Start/Stop'Signals'

Status,'Sockets'

Other&Services&

Other&Managers&

Enterprise&Server&


Protelis Examples

Rendezvous at a Mass Event

Problem

Large public event

People want to rendezvous with a companion

Cloud-based services may be unreachable

Possible solution with Protelis

Simple P2P geometric calculation across network

Testbed

Simulated in Alchemist


Protelis Examples



Protelis Examples


// Follow the gradient of a potential field down from a sourcedef descend(source, potential) {

rep(path <- source) {let nextStep = minHood(nbr([potential, self.getId()]));

if (nextStep.size() > 1) {let candidates = nbr([nextStep.get(1), path]);

source || anyHood([self.getId(), true] == candidates)

} else {source

}}

}def rendezvous(person1, person2) {

descend (person1 == owner, distanceTo(person2 == owner))

}// Example of using rendezvousrendezvous("Alice", "Bob");


Protelis Examples



Protelis Examples

Network Service Management

Problem

Legacy or poorly coded services do not respond gracefully to thefailure of their dependencies

Risk of inconsistent state and of being unable to resume correctlywhen the failed dependency is back online

Possible solution with Protelis

Attach a Protelis daemon to each service, which watches its statusand communicates with other daemons to coordinate shutdown andrestart

Testbed

Implemented on a network of EmuLab servers

Services are emulated by query-response networking Java programs

they “hang” when triggered or when their queries consistently fail


Protelis Examples


External)Portals)

Supplies)Database)

Financial)Database)

Logis7cs)Server)

Backup)Server)

B2B)Catalog)Server)

Interac(on*Dependency*


Protelis Examples


import it.unibo.alchemist.language.protelis.datatype.Tuple.*

import com.bbn.a3.distributedrestart.DaemonNode.*

// Compare required and available serviceslet nbr_set = unionHood(nbr([serviceID]));

let nbr_missing = dependencies.subtract(nbr_set);

let nbr_required = #contains(dependencies, nbr(serviceID));

let nbr_down = nbr(managedServiceStatus=="hung" || managedServiceStatus=="stop");

// Is service currently safe to run?let problem = anyHood(nbr_down && nbr_required) || !nbr_missing.isEmpty();

// Take managed service up and down accordinglyif (managedServiceStatus == "run" && problem) {

#stopProcess(managedService);

} else {if (managedServiceStatus=="stop" && !problem) {

#startProcess(managedService);

} else {managedServiceStatus

}}


Protelis Examples



Conclusion and Future work

Outline





Conclusion and Future work

Conclusion and Future Work

Conclusion

Universality and coherence by building atop the field calculus

Accessibility, portability and ease of integration by Javainteroperability

Important component of the toolchain necessary for using aggregateprogramming in practice

Future work

Development is very active

Next step: use Protelis to build a library of reusable, high-levelbuilding blocks for distributed applications.


References

References I

Jacob Beal and Jonathan Bachrach.Infrastructure for engineered emergence on sensor/actuator networks.IEEE Intelligent Systems, 21(2):10–19, 2006.

Marco Mamei and Franco Zambonelli.Programming pervasive and mobile computing applications: The tota approach.ACM Trans. Softw. Eng. Methodol., 18(4):1–56, 2009.

Danilo Pianini, Sara Montagna, and Mirko Viroli.Chemical-oriented simulation of computational systems with Alchemist.Journal of Simulation, 2013.

Robert Tolksdorf and Ronaldo Menezes.Using swarm intelligence in linda systems.In Andrea Omicini, Paolo Petta, and Jeremy Pitt, editors, ESAW, volume 3071 of LectureNotes in Computer Science, pages 49–65. Springer, 2003.

Mirko Viroli, Ferruccio Damiani, and Jacob Beal.A calculus of computational fields.In Carlos Canal and Massimo Villari, editors, Advances in Service-Oriented and CloudComputing, volume 393 of Communications in Computer and Information Science, pages114–128. Springer Berlin Heidelberg, 2013.


References

References II

Franco Zambonelli, Gabriella Castelli, Laura Ferrari, Marco Mamei, Alberto Rosi, GiovannaDi Marzo, Matteo Risoldi, Akla-Esso Tchao, Simon Dobson, Graeme Stevenson, Yuan Ye,Elena Nardini, Andrea Omicini, Sara Montagna, Mirko Viroli, Alois Ferscha, SaschaMaschek, and Bernhard Wally.Self-aware pervasive service ecosystems.Procedia Computer Science, 7:197–199, December 2011.Proceedings of the 2nd European Future Technologies Conference and Exhibition 2011(FET 11).


References

Protelis: Practical Aggregate Programming

Danilo Pianini, Mirko Viroli{danilo.pianini,mirko.viroli}@unibo.it

Jacob [email protected]

Universita di BolognaItaly

Raytheon BBN TechnologiesUnited States of America

Symposium on Applied Computing 2015Salamanca


References

Simpler semantics

Proto Field calculus


Protelis: Practical Aggregate Programming - Symposium on Applied Computing (SAC), 2015

Technology

Transcript of Protelis: Practical Aggregate Programming - Symposium on Applied Computing (SAC), 2015