On Expressiveness and Behavioural Theory of Attribute-based Communication

Transcription

1 On Expressiveness and Behavioural Theory of Attribute-based Communication Rocco De Nicola Joint work with Y. A. Alrahman and M. Loreti Final Meeting CINA Civitanova Marche January 2016

2 Contents 1 Introduction 2 Programming Abstractions for CAS 3 AbC: A Process Calculus for CAS 4 Encoding other communication paradigms 5 A Behavioural Theory for AbC 6 Ongoing and Future work R. De Nicola 1/31

3 Collective Adaptive Systems - CAS CAS are software-intensive systems featuring massive numbers of components complex interactions among components, and other systems operating in open and non-deterministic environments dynamically adapting to new requirements, technologies and environmental conditions Challenges for software development for CAS the dimension of the systems the need to adapt to changing environments and requirements the emergent behaviour resulting from complex interactions the uncertainty during design-time and run-time Introduction R. De Nicola 2/31

4 Examples of CAS Introduction R. De Nicola 3/31

5 Programming abstractions for CAS The Service-Component Ensemble Language (SCEL) currently provides primitives and constructs for dealing with 4 programming abstractions. 1. Knowledge: to describe how data, information and (local and global) knowledge is managed 2. Behaviours: to describe how systems of components progress 3. Aggregations: to describe how different entities are brought together to form components, systems and, possibly, ensembles 4. Policies: to model and enforce the wanted evolutions of computations. Programming Abstractions for CAS R. De Nicola 4/31

6 Components and Systems Aggregations describe how different entities are brought together and controlled: Components: I Interface K Knowledge Π Policies P Processes Systems: I Interface I Interface I Interface K Knowledge Π Policies P Processes K Knowledge Π Policies P Processes... K Knowledge Π Policies P Processes Programming Abstractions for CAS R. De Nicola 5/31

7 Collective Adaptive Systems as Ensembles Ensembles Systems are structured as sets of components dynamically forming ensembles, i.e. groups of components that collaborate to achieve specific tasks; Ensembles are not rigid networks but highly flexible structures where components linkages are dynamically established; Interaction is based on a novel communication paradigm different from one-to-one message passing and from broadcast. Predicate based interaction Components expose their attributes in the interface; Interaction between components is based on predicates over attributes that permit dynamically specifying all targets of a given communication action. Programming Abstractions for CAS R. De Nicola 6/31

8 Predicate-based ensembles Ensembles are determined by the predicates validated by each component. There is no coordinator, hence no bottleneck or critical point of failure A component might be part of more than one ensemble Programming Abstractions for CAS R. De Nicola 7/31

9 Example Predicates id {n, m, p} active = yes battery level > 30% range max > (this.x x) 2 + (this.y y) 2 true trust level > medium... trousers = red shirt = green Programming Abstractions for CAS R. De Nicola 8/31

10 Distilling a calculus from SCEL Towards a Theory of CAS We aim at developing a theoretical foundation of CAS, starting from their distinctive features, summarized as follows: CAS consist of large numbers of interacting components which exhibit complex behaviours depending on their attributes, objectives and actions. CAS components may enter or leave the collective at anytime and might have different (possibly conflicting) objectives and need to dynamically adapt to new requirements and contextual conditions. AbC: A calculus with Attribute based Communication We have defined AbC, a calculus inspired by SCEL and focusing on a minimal set of primitives that rely on attribute-based communication for systems interaction. AbC: A Process Calculus for CAS R. De Nicola 9/31

11 AbC at a glance Systems are represented as sets of parallel components, each of them equipped with a set of attributes whose values can be modified by internal actions. Communication actions (send and receive) are decorated with predicates over attributes that partners have to satisfy to make the interaction possible. Communication takes place in an implicit multicast fashion, and communication partners are selected by relying on predicates over the attributes exposed in their interfaces. Components are unaware of the existence of each other and they receive messages only if they satisfy partners requirements. Components can offer different views of themselves and can interact with different partners according to different criteria. Semantics for output actions is non-blocking while input actions are blocking in that they can only take place through synchronisation with an available sent message. AbC: A Process Calculus for CAS R. De Nicola 10/31

12 AbC through a running example A swarm of robots is spread throughout a disaster area with the goal of locating victims to rescue. Robots have rôles modelled via functional behaviours that can be changed via appropriate adaptation mechanisms. Initially all robots are explorers; a robot that finds a victim becomes a rescuer and sends info about the victim to nearby explorers; to form ensembles. An explorer that receives information about a victim changes its rôle into helper and joins the rescuers ensemble. The rescuing procedure starts when the ensemble is complete. Some of the attributes (e.g. battery level) are the projection of the robot internal state controlled via sensors and actuators. AbC: A Process Calculus for CAS R. De Nicola 11/31

13 AbC Components (Components) C ::= Γ :P C 1 C 2 νxc Single component Γ :P Γ denotes sets of attributes and P processes Parallel composition of components Name restriction νx (to delimit the scope of name x) in C 1 (νx)c 2, name x is invisible from within C 1 Running example (step 1/5) Each robot is modeled as an AbC component (Robot i ) of the following form (Γ i :P R ). Robots execute in parallel and collaborate. Robot 1... Robot n AbC: A Process Calculus for CAS R. De Nicola 12/31

14 AbC Processes P ::= 0 Act.P new(x)p Π P P 1 + P 2 P 1 P 2 K new(x)p Process name restriction Π P blocks P until the evaluation of Π under the local environment becomes true (awareness operator). Act communication and attribute update actions Running example (step 2/5) P R running on a robot has the following form: P R ( Π a 1.P 1 + a 2.P 2 ) P 3 When Π evaluates to true (e.g., victim detection), the process performs action a 1 and continues as P 1 ; Otherwise P R performs a 2 to continue as P 2 (help rescuing a victim). AbC: A Process Calculus for CAS R. De Nicola 13/31

15 Example Cont. AbC Actions Act ::= Π( x) {s} [a := E] Π( x) receive from any component satisfying Π; {s} send to components satisfying Π while exposing only the attributes in set s; [a := E]: updates the value of a with the result of evaluating E. AbC: A Process Calculus for CAS R. De Nicola 14/31

16 Example Cont. AbC Actions Act ::= Π( x) {s} [a := E] Π( x) receive from any component satisfying Π; {s} send to components satisfying Π while exposing only the attributes in set s; [a := E]: updates the value of a with the result of evaluating E. Running example (step 3/5) By specifying Π, a 1, and a 2, P R becomes: P R ( this.victimperceived = tt [this.state := stop].p 1 + (this.id, qry)@(role = rescuer role = helping) {role}.p 2 ) P 3 AbC: A Process Calculus for CAS R. De Nicola 14/31

17 Example Cont. AbC Actions Act ::= Π( x) {s} [a := E] Π( x) receive from any component satisfying Π; {s} send to components satisfying Π while exposing only the attributes in set s; [a := E]: updates the value of a with the result of evaluating E. Running example (step 3/5) By specifying Π, a 1, and a 2, P R becomes: P R ( this.victimperceived = tt [this.state := stop].p 1 + (this.id, qry)@(role = rescuer role = helping) {role}.p 2 ) P 3 We are dwelling whether to use Π( x)(σ) with σ = [a 1 E 1,..., a n E n ] as input action to atomically update the local environment of the receiver. AbC: A Process Calculus for CAS R. De Nicola 14/31

18 AbC Calculus (Components) C ::= Γ :P C 1 C 2 νxc (Processes) P ::= (Inaction) 0 (Input) Π( x).p (Output) (Ẽ)@Π {s}.p (Update) [a := E].P (New) new(x)p (Match) Π P (Choice) P 1 + P 2 (Par) P 1 P 2 (Call) K (Predicates) Π ::= tt ff E 1 E 2 Π 1 Π 2... (Data) E ::= v x a this.a... AbC: A Process Calculus for CAS R. De Nicola 15/31

19 Operational Semantics Transitions Labels we use the λ-label to range over broadcast, input, update and internal labels respectively λ {ν [a := v], τ} we use the α-label to range over all λ-labels plus the input-discarding label as follows: α λ { Γ:(ṽ)@Π} AbC: A Process Calculus for CAS R. De Nicola 16/31

20 Operational Semantics Processes and Systems Semantics AbC is equipped with a two levels labelled semantics. 1. the behaviour of processes is modelled by the transition relation Proc PLAB Proc 2. the behaviour of component is modelled by the transition relation: Comp CLAB Comp where Proc stands for Processes and Comp stands for a Components, PLAB stands stands for {ν xγ:(ṽ)@π, Γ:(ṽ)@Π, [a := v], τ, Γ:(ṽ)@Π} CLAB stands for {ν xγ:(ṽ)@π, Γ:(ṽ)@Π, τ} AbC: A Process Calculus for CAS R. De Nicola 17/31

21 Semantics of Processes (excerpt) (Brd) Ẽ Γ = ṽ Π 1 Γ = Π (Ẽ)@Π 1 s.p Γ s:(ṽ)@π Γ P Γ s = { Γ(a) if a s otherwise Running example (step 4/5) (Rcv) Π 1[ṽ/ x] Γ =Π 1 (Γ =Π 1 ) Π 1 ( x).p Γ :(ṽ)@π 2 Γ P[ṽ/ x] P R resides within a robot with Γ(id) = 1 Some possible evolutions where Γ = Γ 1 {role} are: P R P R [this.state:=stop] Γ1 P 1 P 3 Γ :(1, qry)@(role=rescuer role=helping) Γ1 P 2 P 3 AbC: A Process Calculus for CAS R. De Nicola 18/31

22 Semantics of Processes (excerpt) Discarding Label (FBrd) 1 s.p Γ 2 Γ 1 s.p (FSum) P Γ :(ṽ)@π 1 Γ P 1 P Γ :(ṽ)@π 2 Γ P 2 P 1 + P Γ :(ṽ)@π 2 Γ P 1 + P 2 Rules like (FBrd) models the non-blocking nature of the broadcast; Rules like (FSum)), are instead used to control internal non-determinism as side-effect and avoid unwanted evolutions. Running example (step 4/6) P R resides within a robot with explorer role. P R can discard unwanted broadcasts. P R Γ 2 :(info)@(role=explorer) Γ1 P R AbC: A Process Calculus for CAS R. De Nicola 19/31

23 From Processes to Components (excerpt) Γ (C-Brd) P Γ P (Com) C 1 Γ : P Γ :(ṽ)@π Γ:P ν xγ:(ṽ)@π C 1 Γ:(ṽ)@Π C 2 C 2 C 1 C 2 ν xγ:(ṽ)@π C 1 C 2 Γ :(ṽ)@π (C-Rcv) P Γ P Γ : P Π ff Γ :(ṽ)@π (Γ =Π) Γ:P x fn(c 2 ) = Running example (step 5/5): Further specifying P 2 in P R Query (this.id, qry)@(role = rescuer role = helper) {role}. ( ((role = rescuer role = helper) x = ack) (victim pos, x).p 2 + Query ) AbC: A Process Calculus for CAS R. De Nicola 20/31

24 From Processes to Components (excerpt) Running example (step 5/5): Cont. Assume Robot 2 is rescuer, Robot 3 is helper, and all others are explorers. Robot 3 received victim information from Robot 2 and now is in charge. Robot 1 sent a msg containing its identity this.id and qry request and Robot 3 caught it. Now by using rule (C-Brd), Robot 3 sends the victim position < 3, 4 > and ack back to Robot 1 as follows: Γ 3 :P R3 Γ:(<3,4>, ack)@(id=1) Γ 3 :P R 3 where Γ = Γ 3 {role}. Robot 1 applies rule (C-Rcv) to receive victim information and generates this transition. Γ 1 :P R1 Γ:(<3,4>, ack)@(id=1) Γ 1 :P 2 [< 3, 4 >/victim pos, ack/x] AbC: A Process Calculus for CAS R. De Nicola 21/31

25 From Processes to Components (excerpt) Running example (step 5/5): Cont. Robots can perform the above transitions since Γ 1 = (id = 1) and Γ = ((role = rescuer role = helper) x = ack). Other robots discard the broadcast. Now the overall system evolves by applying rule (Com) as follows: S Γ:(<3,4>, ack)@(id=1) Γ 1 :P 2 [< 3, 4 >/victim pos, ack/x] Γ 2 :P R2 Γ 3 :P R 3... Γ n :P Rn AbC: A Process Calculus for CAS R. De Nicola 22/31

26 Encoding other communication paradigms A number of alternative communication paradigms such as: Explicit Message Passing Group based Communications Publish-Subscribe can be easily modelled by relying on AbC primitives Communication Paradigms R. De Nicola 23/31

27 Encoding the bπ-calculus A bπ-calculus process P is rendered as an AbC component Γ:P where Γ =. Possible problem Impossibility of specifying the channel along which the exchange has to happen instantaneously. Way out Send the communication channel as a part of the transmitted values and the receiver checks its compatibility. āx.p (a, x)@(a = a) {}. P a(x).p Π(y, x). P with Π = (y = a) and y n( P ) Communication Paradigms R. De Nicola 24/31

28 Group-based interaction Group based communication A group name is encoded as an attribute in AbC. The constructs for joining or leaving a given group can be encoded as attribute updates.... Γ 1 : (msg)@(group = b) {group} Γ 2 : (group = a)(x). Γ 7 : (group = a)(x) [this.group := b] Let Γ 1 (group) = a, Γ 2 (group) = b, Γ 7 (group) = c Communication Paradigms R. De Nicola 25/31

29 Publish-Subscribe Publish-Subscribe interaction is a simple special case of attribute-based communication: A Publisher sends tagged messages for all subscribers by exposing from his environment only the current topic. Subscribers check compatibility of messages according to their subscriptions. Γ 1 : (msg)@(tt) {topic} Γ 2 : (topic = this.subscription)(x). Γ n : (topic = this.subscription)(x) Observation Dynamic updates of attributes and the possibility of controlling their visibility give AbC great flexibility and expressive power. Communication Paradigms R. De Nicola 26/31

30 Behavioural Theory for AbC Some Notations = denotes τ γ = denotes = γ = if (γ τ) ˆγ = denotes = if (γ = τ) and γ = otherwise. denotes { γ γ is an output or γ = τ} denotes( ) AbC Contexts A context C[ ] is a component term with a hole, denoted by [ ] and AbC contexts are generated by the following grammar: C[ ] ::= [ ] [ ] C C [ ] νx[ ] A Behavioural Theory for AbC R. De Nicola 27/31

31 Barbed Congruence Observable Barbs Let C Π mean that component C can broadcast a message with a predicate Π (i.e., C ν xγ:(ṽ)@π where Π ff). We write C Π if C C Π. Weak Reduction Barbed Congruence Relations A Weak Reduction Barbed Relation is a symmetric relation R over the set of AbC-components which is barb-preserving, reduction-closed, and context-closed. Barbed Bisimilarity Two components are weakly reduction barbed congruent, written C 1 = C2, if (C 1, C 2 ) R for some weak reduction barbed congruent relation R. The strong reduction congruence is obtained in a similar way by replacing with and with. A Behavioural Theory for AbC R. De Nicola 28/31

32 Bisimulation for AbC Components Weak Labelled Bisimulation A symmetric binary relation R over the set of AbC-components is a weak bisimulation if for every action γ, whenever (C 1, C 2 ) R and γ is of the form τ, Γ:(ṽ)@Π, or (ν xγ:(ṽ)@π with Π ff), it holds that C 1 γ C 1 implies C 2 ˆγ = C 2 and (C 1, C 2 ) R Bisimilarity Two components C 1 and C 2 are weak bisimilar, written C 1 C 2 if there exists a weak bisimulation R relating them. Strong bisimilarity,, is defined in a similar way by replacing = with. Bisimilarity and Barbed Congruence do coincide C 1 = C2 if and only if C 1 C 2. A Behavioural Theory for AbC R. De Nicola 29/31

33 Ongoing & Future Work We are currently continuing our investigations by: Looking for simpler operators and semantics, aiming at minimality; Evaluating the relative expressiveness of the calculus Developing quantitative variants to support components in taking decisions (e.g. via probabilistic model checking). Considering alternative semantics and behavioural equivalences for AbC Studying the impact of bisimulation (algebraic laws, proof techniques,... ) Implementing the calculus and devising a full fledged language based on it, as alternative to SCEL. Ongoing and Future work R. De Nicola 30/31

34 Many thanks for your time. Questions? Ongoing and Future work R. De Nicola 31/31