viewing

Recap Probe-Echo algorithms Syncronous communication
Concurrent Programming
Asyncronous and synchronous message passing
1 Recap
2 Probe-Echo algorithms
broadcast
calculating the topology
3 Syncronous communication
November 29
www.hh.se/staff/vero/concurrent

Recap Probe-Echo algorithms Syncronous communication
Distributed Programming
Processes execute without sharing memory, they collaborate by
communicating with each other. Processes exchange messages
with each other.
Asynchronous Message Passing
Communication channels can be used by means of
send, non blocking.
receive, blocking.

Recap Probe-Echo algorithms Syncronous communication
Distributed Programming
Processes execute without sharing memory, they collaborate by
communicating with each other. Processes exchange messages
with each other.
Asynchronous Message Passing
Communication channels can be used by means of
send, non blocking.
receive, blocking.

Recap Probe-Echo algorithms Syncronous communication
Distributed Programming
Processes execute without sharing memory, they collaborate by
communicating with each other. Processes exchange messages
with each other.
Asynchronous Message Passing
Communication channels can be used by means of
send, non blocking.
receive, blocking.

Recap Probe-Echo algorithms Syncronous communication
Distributed Programming
Processes execute without sharing memory, they collaborate by
communicating with each other. Processes exchange messages
with each other.
Asynchronous Message Passing
Communication channels can be used by means of
send, non blocking.
receive, blocking.

Recap Probe-Echo algorithms Syncronous communication
Distributed programming
Example
In MPD,
1 We distribute a program by placing resources in different
virtual machines.
2 Each resource might execute one or more processes (which
share the local variables of the resource!)
3 A resource that wants to communicate with some other
resource must export some channel for that purpose.

Recap Probe-Echo algorithms Syncronous communication
Distributed programming
Example
In MPD,
1 We distribute a program by placing resources in different
virtual machines.
2 Each resource might execute one or more processes (which
share the local variables of the resource!)
3 A resource that wants to communicate with some other
resource must export some channel for that purpose.

Recap Probe-Echo algorithms Syncronous communication
Distributed programming
Example
In MPD,
1 We distribute a program by placing resources in different
virtual machines.
2 Each resource might execute one or more processes (which
share the local variables of the resource!)
3 A resource that wants to communicate with some other
resource must export some channel for that purpose.

Recap Probe-Echo algorithms Syncronous communication
Distributed programming
Example
In MPD,
1 We distribute a program by placing resources in different
virtual machines.
2 Each resource might execute one or more processes (which
share the local variables of the resource!)
3 A resource that wants to communicate with some other
resource must export some channel for that purpose.

Recap Probe-Echo algorithms Syncronous communication
MPD sensor network
resource Sensor
op deploy([*]cap Sensor nbgs)
op chan(int id, double value)
body Sensor(int identity, int interval, int netSize)
[netSize] cap Sensor neighbours
int nrOfNeighbours
procedure measure(){...}
procedure communicate(){...}
procedure work(){co measure() // communicate() oc}
proc deploy(nbgs){
nrOfNeighbours = ub(nbgs)-lb(nbgs) + 1
for[i = 1 to nrOfNeighbours]{neighbours[i]=nbgs[i]}
work()
}
end

Recap Probe-Echo algorithms Syncronous communication
MPD sensor network
resource Sensor
op deploy([*]cap Sensor nbgs)
op chan(int id, double value)
body Sensor(int identity, int interval, int netSize)
[netSize] cap Sensor neighbours
int nrOfNeighbours
procedure measure(){...}
procedure communicate(){...}
procedure work(){co measure() // communicate() oc}
proc deploy(nbgs){
nrOfNeighbours = ub(nbgs)-lb(nbgs) + 1
for[i = 1 to nrOfNeighbours]{neighbours[i]=nbgs[i]}
work()
}
end

Recap Probe-Echo algorithms Syncronous communication
MPD sensor network
resource Sensor
op deploy([*]cap Sensor nbgs)
op chan(int id, double value)
body Sensor(int identity, int interval, int netSize)
[netSize] cap Sensor neighbours
int nrOfNeighbours
procedure measure(){...}
procedure communicate(){...}
procedure work(){co measure() // communicate() oc}
proc deploy(nbgs){
nrOfNeighbours = ub(nbgs)-lb(nbgs) + 1
for[i = 1 to nrOfNeighbours]{neighbours[i]=nbgs[i]}
work()
}
end

Recap Probe-Echo algorithms Syncronous communication
MPD sensor network
resource Sensor
op deploy([*]cap Sensor nbgs)
op chan(int id, double value)
body Sensor(int identity, int interval, int netSize)
[netSize] cap Sensor neighbours
int nrOfNeighbours
procedure measure(){...}
procedure communicate(){...}
procedure work(){co measure() // communicate() oc}
proc deploy(nbgs){
nrOfNeighbours = ub(nbgs)-lb(nbgs) + 1
for[i = 1 to nrOfNeighbours]{neighbours[i]=nbgs[i]}
work()
}
end

Recap Probe-Echo algorithms Syncronous communication
MPD sensor network
resource Sensor
op deploy([*]cap Sensor nbgs)
op chan(int id, double value)
body Sensor(int identity, int interval, int netSize)
[netSize] cap Sensor neighbours
int nrOfNeighbours
procedure measure(){...}
procedure communicate(){...}
procedure work(){co measure() // communicate() oc}
proc deploy(nbgs){
nrOfNeighbours = ub(nbgs)-lb(nbgs) + 1
for[i = 1 to nrOfNeighbours]{neighbours[i]=nbgs[i]}
work()
}
end

Recap Probe-Echo algorithms Syncronous communication
MPD sensor network
resource Sensor
op deploy([*]cap Sensor nbgs)
op chan(int id, double value)
body Sensor(int identity, int interval, int netSize)
[netSize] cap Sensor neighbours
int nrOfNeighbours
procedure measure(){...}
procedure communicate(){...}
procedure work(){co measure() // communicate() oc}
proc deploy(nbgs){
nrOfNeighbours = ub(nbgs)-lb(nbgs) + 1
for[i = 1 to nrOfNeighbours]{neighbours[i]=nbgs[i]}
work()
}
end

Recap Probe-Echo algorithms Syncronous communication
MPD sensor network
Example
1 A program will create some sensors by letting each sensor run
in its own virtual machine:
cap Sensor s = create Sensor(id, interval, size)
on machine
2 and deploy the network by providing each sensor with its
neighbours
s.deploy(ns)
(where ns is an array of sensors.)
3 We then have a distributed program, where the sensors do
some local work while they can also collaborate with each
other to do some work together.

Recap Probe-Echo algorithms Syncronous communication
MPD sensor network
Example
1 A program will create some sensors by letting each sensor run
in its own virtual machine:
cap Sensor s = create Sensor(id, interval, size)
on machine
2 and deploy the network by providing each sensor with its
neighbours
s.deploy(ns)
(where ns is an array of sensors.)
3 We then have a distributed program, where the sensors do
some local work while they can also collaborate with each
other to do some work together.

Recap Probe-Echo algorithms Syncronous communication
MPD sensor network
Example
1 A program will create some sensors by letting each sensor run
in its own virtual machine:
cap Sensor s = create Sensor(id, interval, size)
on machine
2 and deploy the network by providing each sensor with its
neighbours
s.deploy(ns)
(where ns is an array of sensors.)
3 We then have a distributed program, where the sensors do
some local work while they can also collaborate with each
other to do some work together.

Recap Probe-Echo algorithms Syncronous communication
MPD sensor network
Example
1 A program will create some sensors by letting each sensor run
in its own virtual machine:
cap Sensor s = create Sensor(id, interval, size)
on machine
2 and deploy the network by providing each sensor with its
neighbours
s.deploy(ns)
(where ns is an array of sensors.)
3 We then have a distributed program, where the sensors do
some local work while they can also collaborate with each
other to do some work together.

Recap Probe-Echo algorithms Syncronous communication
Plan
Today
Process interaction in distributed programs:
Probe-Echo algorithms using asynchronous message passing
(MPD)
Synchronous communication, reactive objects (MPD)
Next lectures
More constructions for communication: Remote Procedure
Call (remote method invocation in Java).
One new paradigm of interaction: client-server.

Recap Probe-Echo algorithms Syncronous communication
Plan
Today
Process interaction in distributed programs:
Probe-Echo algorithms using asynchronous message passing
(MPD)
Synchronous communication, reactive objects (MPD)
Next lectures
More constructions for communication: Remote Procedure
Call (remote method invocation in Java).
One new paradigm of interaction: client-server.

Recap Probe-Echo algorithms Syncronous communication
Probe-Echo algorithms
We assume processes are executing in distributed nodes (mpd
resources).
That some nodes can communicate with some other nodes can be
modelled using graphs.
Nodes are resources that can
communicate with their
neighbours in the graph.
Nodes send probes to their
neighbours and receive echos
from them.

Recap Probe-Echo algorithms Syncronous communication
Probe-Echo algorithms
We assume processes are executing in distributed nodes (mpd
resources).
That some nodes can communicate with some other nodes can be
modelled using graphs.
Nodes are resources that can
communicate with their
neighbours in the graph.
Nodes send probes to their
neighbours and receive echos
from them.

Recap Probe-Echo algorithms Syncronous communication
Probe-Echo algorithms
We assume processes are executing in distributed nodes (mpd
resources).
That some nodes can communicate with some other nodes can be
modelled using graphs.
Nodes are resources that can
communicate with their
neighbours in the graph.
Nodes send probes to their
neighbours and receive echos
from them.

Recap Probe-Echo algorithms Syncronous communication
Probe-Echo algorithms
We assume processes are executing in distributed nodes (mpd
resources).
That some nodes can communicate with some other nodes can be
modelled using graphs.
Nodes are resources that can
communicate with their
neighbours in the graph.
Nodes send probes to their
neighbours and receive echos
from them.

Recap Probe-Echo algorithms Syncronous communication
Probe-Echo algorithms
We assume processes are executing in distributed nodes (mpd
resources).
That some nodes can communicate with some other nodes can be
modelled using graphs.
Nodes are resources that can
communicate with their
neighbours in the graph.
Nodes send probes to their
neighbours and receive echos
from them.

Recap Probe-Echo algorithms Syncronous communication
Broadcast in a network
Probes can be used for a process to broadcast a message to all
other nodes in a network.
1 Each resource will have a channel to do
broadcast
2 Each resource will have a process engaged in
broadcast
3 This process will
1 wait to receive the message
2 send it to all its neighbours
4 Some other process in one resource starts
the broadcast.

Recap Probe-Echo algorithms Syncronous communication
Broadcast in a network
Probes can be used for a process to broadcast a message to all
other nodes in a network.
1 Each resource will have a channel to do
broadcast
2 Each resource will have a process engaged in
broadcast
3 This process will
1 wait to receive the message
2 send it to all its neighbours
4 Some other process in one resource starts
the broadcast.

Recap Probe-Echo algorithms Syncronous communication
Broadcast in a network
Probes can be used for a process to broadcast a message to all
other nodes in a network.
1 Each resource will have a channel to do
broadcast
2 Each resource will have a process engaged in
broadcast
3 This process will
1 wait to receive the message
2 send it to all its neighbours
4 Some other process in one resource starts
the broadcast.

Recap Probe-Echo algorithms Syncronous communication
Broadcast in a network
Probes can be used for a process to broadcast a message to all
other nodes in a network.
1 Each resource will have a channel to do
broadcast
2 Each resource will have a process engaged in
broadcast
3 This process will
1 wait to receive the message
2 send it to all its neighbours
4 Some other process in one resource starts
the broadcast.

Recap Probe-Echo algorithms Syncronous communication
Broadcast in a network
Probes can be used for a process to broadcast a message to all
other nodes in a network.
1 Each resource will have a channel to do
broadcast
2 Each resource will have a process engaged in
broadcast
3 This process will
1 wait to receive the message
2 send it to all its neighbours
4 Some other process in one resource starts
the broadcast.

Recap Probe-Echo algorithms Syncronous communication
Broadcast in a network
Probes can be used for a process to broadcast a message to all
other nodes in a network.
1 Each resource will have a channel to do
broadcast
2 Each resource will have a process engaged in
broadcast
3 This process will
1 wait to receive the message
2 send it to all its neighbours
4 Some other process in one resource starts
the broadcast.

Recap Probe-Echo algorithms Syncronous communication
Broadcast in a network
Probes can be used for a process to broadcast a message to all
other nodes in a network.
1 Each resource will have a channel to do
broadcast
2 Each resource will have a process engaged in
broadcast
3 This process will
1 wait to receive the message
2 send it to all its neighbours
4 Some other process in one resource starts
the broadcast.

Recap Probe-Echo algorithms Syncronous communication
Doesn’t work!
What will happen in the next broadcast?
Because a node might be a
neighbour to more than one node,
there might be many messages
sent to its broadcast channel!
They will be read in the next
receive, instead for the new
message being broadcast!
Empty the channel by receiving from all other neighbours (and
throwing the messages away!)

Recap Probe-Echo algorithms Syncronous communication
Doesn’t work!
What will happen in the next broadcast?
Because a node might be a
neighbour to more than one node,
there might be many messages
sent to its broadcast channel!
They will be read in the next
receive, instead for the new
message being broadcast!
Empty the channel by receiving from all other neighbours (and
throwing the messages away!)

Recap Probe-Echo algorithms Syncronous communication
Doesn’t work!
What will happen in the next broadcast?
Because a node might be a
neighbour to more than one node,
there might be many messages
sent to its broadcast channel!
They will be read in the next
receive, instead for the new
message being broadcast!
Empty the channel by receiving from all other neighbours (and
throwing the messages away!)

Recap Probe-Echo algorithms Syncronous communication
Doesn’t work!
What will happen in the next broadcast?
Because a node might be a
neighbour to more than one node,
there might be many messages
sent to its broadcast channel!
They will be read in the next
receive, instead for the new
message being broadcast!
Empty the channel by receiving from all other neighbours (and
throwing the messages away!)

Recap Probe-Echo algorithms Syncronous communication
Works!
The algorithm
In each resource the process engaged in broadcast will
1 Receive the message in a dedicated channel
2 Send the message to all its neighbours
3 Receive in the dedicated channel as many times as number of
neighbours -1.
How does everything start?
In some resource, an initiator process will send the original message
to the broadcast process in that resource!
What happens with the boadcast process in the resource of the
initiator? What can be done about it?

Recap Probe-Echo algorithms Syncronous communication
Works!
The algorithm
In each resource the process engaged in broadcast will
1 Receive the message in a dedicated channel
2 Send the message to all its neighbours
3 Receive in the dedicated channel as many times as number of
neighbours -1.
How does everything start?
In some resource, an initiator process will send the original message
to the broadcast process in that resource!
What happens with the boadcast process in the resource of the
initiator? What can be done about it?

Recap Probe-Echo algorithms Syncronous communication
Works!
The algorithm
In each resource the process engaged in broadcast will
1 Receive the message in a dedicated channel
2 Send the message to all its neighbours
3 Receive in the dedicated channel as many times as number of
neighbours -1.
How does everything start?
In some resource, an initiator process will send the original message
to the broadcast process in that resource!
What happens with the boadcast process in the resource of the
initiator? What can be done about it?

Recap Probe-Echo algorithms Syncronous communication
Works!
The algorithm
In each resource the process engaged in broadcast will
1 Receive the message in a dedicated channel
2 Send the message to all its neighbours
3 Receive in the dedicated channel as many times as number of
neighbours -1.
How does everything start?
In some resource, an initiator process will send the original message
to the broadcast process in that resource!
What happens with the boadcast process in the resource of the
initiator? What can be done about it?

Recap Probe-Echo algorithms Syncronous communication
Works!
The algorithm
In each resource the process engaged in broadcast will
1 Receive the message in a dedicated channel
2 Send the message to all its neighbours
3 Receive in the dedicated channel as many times as number of
neighbours -1.
How does everything start?
In some resource, an initiator process will send the original message
to the broadcast process in that resource!
What happens with the boadcast process in the resource of the
initiator? What can be done about it?

Recap Probe-Echo algorithms Syncronous communication
Works!
The algorithm
In each resource the process engaged in broadcast will
1 Receive the message in a dedicated channel
2 Send the message to all its neighbours
3 Receive in the dedicated channel as many times as number of
neighbours -1.
How does everything start?
In some resource, an initiator process will send the original message
to the broadcast process in that resource!
What happens with the boadcast process in the resource of the
initiator? What can be done about it?

Recap Probe-Echo algorithms Syncronous communication
A better broadcast
In the previous algorithm there were many messages that were sent
and then just discarded! Could a process guide the message?
. . . it can construct a spanning
tree . . .
If the initiator node S knows all of
the graph . . .
. . . where each node can find its
relevant neighbours for the
broadcast!
The spanning tree has to be sent
as part of the message!

Recap Probe-Echo algorithms Syncronous communication
A better broadcast
In the previous algorithm there were many messages that were sent
and then just discarded! Could a process guide the message?
If the initiator node S knows all of
the graph . . .
. . . it can construct a spanning
tree . . .
. . . where each node can find its
relevant neighbours for the
broadcast!
The spanning tree has to be sent
as part of the message!

Recap Probe-Echo algorithms Syncronous communication
A better broadcast
In the previous algorithm there were many messages that were sent
and then just discarded! Could a process guide the message?
If the initiator node S knows all of
the graph . . .
. . . it can construct a spanning
tree . . .
. . . where each node can find its
relevant neighbours for the
broadcast!
The spanning tree has to be sent
as part of the message!

Recap Probe-Echo algorithms Syncronous communication
A better broadcast
In the previous algorithm there were many messages that were sent
and then just discarded! Could a process guide the message?
If the initiator node S knows all of
the graph . . .
. . . it can construct a spanning
tree . . .
. . . where each node can find its
relevant neighbours for the
broadcast!
The spanning tree has to be sent
as part of the message!

Recap Probe-Echo algorithms Syncronous communication
A better broadcast
In the previous algorithm there were many messages that were sent
and then just discarded! Could a process guide the message?
If the initiator node S knows all of
the graph . . .
. . . it can construct a spanning
tree . . .
. . . where each node can find its
relevant neighbours for the
broadcast!
The spanning tree has to be sent
as part of the message!

Recap Probe-Echo algorithms Syncronous communication
Gathering the topology
Two steps
1 Send a probe to all neighbours.
2 Send back an echo with the partial topology to the process
that sent the first probe.
What is a graph?
In this context we will model graphs using an adjacency matrix
The spanning tree is also a graph!
1 2 3 4 5 6 7
1 f t f f f f t
2 t f t f f t f
3 f t f t t t f
4 f f t f t f f
5 f f t t f f t
6 f t t f f f t
7 t f f f t t f

Recap Probe-Echo algorithms Syncronous communication
Gathering the topology
Two steps
1 Send a probe to all neighbours.
2 Send back an echo with the partial topology to the process
that sent the first probe.
What is a graph?
In this context we will model graphs using an adjacency matrix
The spanning tree is also a graph!
1 2 3 4 5 6 7
1 f t f f f f t
2 t f t f f t f
3 f t f t t t f
4 f f t f t f f
5 f f t t f f t
6 f t t f f f t
7 t f f f t t f

Recap Probe-Echo algorithms Syncronous communication
Gathering the topology
Two steps
1 Send a probe to all neighbours.
2 Send back an echo with the partial topology to the process
that sent the first probe.
What is a graph?
In this context we will model graphs using an adjacency matrix
The spanning tree is also a graph!
1 2 3 4 5 6 7
1 f t f f f f t
2 t f t f f t f
3 f t f t t t f
4 f f t f t f f
5 f f t t f f t
6 f t t f f f t
7 t f f f t t f

Recap Probe-Echo algorithms Syncronous communication
Gathering the topology
Two steps
1 Send a probe to all neighbours.
2 Send back an echo with the partial topology to the process
that sent the first probe.
What is a graph?
In this context we will model graphs using an adjacency matrix
The spanning tree is also a graph!
1 2 3 4 5 6 7
1 f t f f f f t
2 t f t f f t f
3 f t f t t t f
4 f f t f t f f
5 f f t t f f t
6 f t t f f f t
7 t f f f t t f

Recap Probe-Echo algorithms Syncronous communication
Gathering the topology
Two steps
1 Send a probe to all neighbours.
2 Send back an echo with the partial topology to the process
that sent the first probe.
What is a graph?
In this context we will model graphs using an adjacency matrix
The spanning tree is also a graph!
1 2 3 4 5 6 7
1 f t f f f f t
2 t f t f f t f
3 f t f t t t f
4 f f t f t f f
5 f f t t f f t
6 f t t f f f t
7 t f f f t t f

Recap Probe-Echo algorithms Syncronous communication
Gathering the topology
Two steps
1 Send a probe to all neighbours.
2 Send back an echo with the partial topology to the process
that sent the first probe.
What is a graph?
In this context we will model graphs using an adjacency matrix
The spanning tree is also a graph!
1 2 3 4 5 6 7
1 f t f f f f t
2 t f t f f t f
3 f t f t t t f
4 f f t f t f f
5 f f t t f f t
6 f t t f f f t
7 t f f f t t f

Recap Probe-Echo algorithms Syncronous communication
Gathering the topology
Two steps
1 Send a probe to all neighbours.
2 Send back an echo with the partial topology to the process
that sent the first probe.
What is a graph?
In this context we will model graphs using an adjacency matrix
The spanning tree is also a graph!
1 2 3 4 5 6 7
1 f t f f f f t
2 t f t f f t f
3 f t f t t t f
4 f f t f t f f
5 f f t t f f t
6 f t t f f f t
7 t f f f t t f

Recap Probe-Echo algorithms Syncronous communication
Calculating the topology
The algorithm
All resources involved in calculating the topology will use the
following types:
type graph = bool [n,n]
type kind = enum (PROBE, ECHO)
The resources export a channel
op probe_echo(kind k, int sender, graph topology)
The resource collecting the topology uses one extra channel
op finalecho(graph topology)

Recap Probe-Echo algorithms Syncronous communication
Calculating the topology
The algorithm
The resource s that will collect the topology starts everyting doing
graph topology
send probe_echo(PROBE,s,allFalse)
receive finalecho(topology)
All resources in the network will have a process involved in
collecting the topology. For this it will use
graph newtop, localtop # all false!
Recall that each resource knows what resources are its neighbours
bool links[n]

Recap Probe-Echo algorithms Syncronous communication
Calculating the topology
The algorithm
1 Initialize localtop with links .
2 Receive the probe from one neighbour (the first one!)
3 Send the probe to all other neighbours!
4 Receive redundant probes and echoes:
If it is an echo, build the local topology by adding the received
topology (Just a logical or between the matrices!)
If it is a probe, send the empty topology as echo back to the
sender.
5 Send an echo back to the first sender (or to the finalecho if
the process is executing in the resource s)

Recap Probe-Echo algorithms Syncronous communication
Calculating the topology
The algorithm
1 Initialize localtop with links .
2 Receive the probe from one neighbour (the first one!)
3 Send the probe to all other neighbours!
4 Receive redundant probes and echoes:
If it is an echo, build the local topology by adding the received
topology (Just a logical or between the matrices!)
If it is a probe, send the empty topology as echo back to the
sender.
5 Send an echo back to the first sender (or to the finalecho if
the process is executing in the resource s)

Recap Probe-Echo algorithms Syncronous communication
Calculating the topology
The algorithm
1 Initialize localtop with links .
2 Receive the probe from one neighbour (the first one!)
3 Send the probe to all other neighbours!
4 Receive redundant probes and echoes:
If it is an echo, build the local topology by adding the received
topology (Just a logical or between the matrices!)
If it is a probe, send the empty topology as echo back to the
sender.
5 Send an echo back to the first sender (or to the finalecho if
the process is executing in the resource s)

Recap Probe-Echo algorithms Syncronous communication
Calculating the topology
The algorithm
1 Initialize localtop with links .
2 Receive the probe from one neighbour (the first one!)
3 Send the probe to all other neighbours!
4 Receive redundant probes and echoes:
If it is an echo, build the local topology by adding the received
topology (Just a logical or between the matrices!)
If it is a probe, send the empty topology as echo back to the
sender.
5 Send an echo back to the first sender (or to the finalecho if
the process is executing in the resource s)

Recap Probe-Echo algorithms Syncronous communication
Calculating the topology
The algorithm
1 Initialize localtop with links .
2 Receive the probe from one neighbour (the first one!)
3 Send the probe to all other neighbours!
4 Receive redundant probes and echoes:
If it is an echo, build the local topology by adding the received
topology (Just a logical or between the matrices!)
If it is a probe, send the empty topology as echo back to the
sender.
5 Send an echo back to the first sender (or to the finalecho if
the process is executing in the resource s)

Recap Probe-Echo algorithms Syncronous communication
Calculating the topology
The algorithm
1 Initialize localtop with links .
2 Receive the probe from one neighbour (the first one!)
3 Send the probe to all other neighbours!
4 Receive redundant probes and echoes:
If it is an echo, build the local topology by adding the received
topology (Just a logical or between the matrices!)
If it is a probe, send the empty topology as echo back to the
sender.
5 Send an echo back to the first sender (or to the finalecho if
the process is executing in the resource s)

Recap Probe-Echo algorithms Syncronous communication
Calculating the topology
The algorithm
1 Initialize localtop with links .
2 Receive the probe from one neighbour (the first one!)
3 Send the probe to all other neighbours!
4 Receive redundant probes and echoes:
If it is an echo, build the local topology by adding the received
topology (Just a logical or between the matrices!)
If it is a probe, send the empty topology as echo back to the
sender.
5 Send an echo back to the first sender (or to the finalecho if
the process is executing in the resource s)

Recap Probe-Echo algorithms Syncronous communication
Calculating the topology
The algorithm
1 Initialize localtop with links .
2 Receive the probe from one neighbour (the first one!)
3 Send the probe to all other neighbours!
4 Receive redundant probes and echoes:
If it is an echo, build the local topology by adding the received
topology (Just a logical or between the matrices!)
If it is a probe, send the empty topology as echo back to the
sender.
5 Send an echo back to the first sender (or to the finalecho if
the process is executing in the resource s)

Recap Probe-Echo algorithms Syncronous communication
Broadcasting revisited
So, now we know that one resource (a node in the graph) can
calculate the topology of the network by collaborating with other
resources using a probe/echo pattern of communication.
It is easy for that node to calculate a spanning tree
Spanning tree
A sub-graph with only one path from the root to any other node
using some of the edges in the original graph.

Recap Probe-Echo algorithms Syncronous communication
Broadcasting revisited
So, now we know that one resource (a node in the graph) can
calculate the topology of the network by collaborating with other
resources using a probe/echo pattern of communication.
It is easy for that node to calculate a spanning tree
Spanning tree
A sub-graph with only one path from the root to any other node
using some of the edges in the original graph.

Recap Probe-Echo algorithms Syncronous communication
Broadcasting revisited
So, now we know that one resource (a node in the graph) can
calculate the topology of the network by collaborating with other
resources using a probe/echo pattern of communication.
It is easy for that node to calculate a spanning tree
Spanning tree
A sub-graph with only one path from the root to any other node
using some of the edges in the original graph.

Recap Probe-Echo algorithms Syncronous communication
Broadcasting revisited
So, now we know that one resource (a node in the graph) can
calculate the topology of the network by collaborating with other
resources using a probe/echo pattern of communication.
It is easy for that node to calculate a spanning tree
Spanning tree
A sub-graph with only one path from the root to any other node
using some of the edges in the original graph.

Recap Probe-Echo algorithms Syncronous communication
Broadcasting revisited
So, now we know that one resource (a node in the graph) can
calculate the topology of the network by collaborating with other
resources using a probe/echo pattern of communication.
It is easy for that node to calculate a spanning tree
Spanning tree
A sub-graph with only one path from the root to any other node
using some of the edges in the original graph.

Recap Probe-Echo algorithms Syncronous communication
calculating a spanning tree

Recap Probe-Echo algorithms Syncronous communication
Broadcasting revisited
The algorithm
Let the channel that all resources export deal with both messages
and a spanning tree:
op probe(double value, graph sptree)
Then the process in each resource involved in the broadcast will
just
1 Receive the message and the spanning tree (from only one
process!)
2 Send the message and the spanning tree only to the
neighbours in the spanning tree!

Recap Probe-Echo algorithms Syncronous communication
Broadcasting revisited
The algorithm
Let the channel that all resources export deal with both messages
and a spanning tree:
op probe(double value, graph sptree)
Then the process in each resource involved in the broadcast will
just
1 Receive the message and the spanning tree (from only one
process!)
2 Send the message and the spanning tree only to the
neighbours in the spanning tree!

Recap Probe-Echo algorithms Syncronous communication
Broadcasting revisited
The algorithm
Let the channel that all resources export deal with both messages
and a spanning tree:
op probe(double value, graph sptree)
Then the process in each resource involved in the broadcast will
just
1 Receive the message and the spanning tree (from only one
process!)
2 Send the message and the spanning tree only to the
neighbours in the spanning tree!

Recap Probe-Echo algorithms Syncronous communication
Broadcasting revisited
The algorithm
Let the channel that all resources export deal with both messages
and a spanning tree:
op probe(double value, graph sptree)
Then the process in each resource involved in the broadcast will
just
1 Receive the message and the spanning tree (from only one
process!)
2 Send the message and the spanning tree only to the
neighbours in the spanning tree!

Recap Probe-Echo algorithms Syncronous communication
Rendezvouz
It is very difficult to synchronize processes using asyncronous
message passing! We would like to attack problems like waiting on
conditions in the setting of distributed programming.
Think of the primitive of sending a message to another process
leaving the sender process suspended until the message is received
and processed! At that point the processes can handshake or
rendezvous.
The receiving operation will have a queue of waiting processes,
instead of a queue of messages!
Implementations of these primitives in programming languages can
include
Returning a value to the calling process!
Add conditions to the receive primitive for blocking senders!

Recap Probe-Echo algorithms Syncronous communication
Rendezvouz
It is very difficult to synchronize processes using asyncronous
message passing! We would like to attack problems like waiting on
conditions in the setting of distributed programming.
Think of the primitive of sending a message to another process
leaving the sender process suspended until the message is received
and processed! At that point the processes can handshake or
rendezvous.
The receiving operation will have a queue of waiting processes,
instead of a queue of messages!
Implementations of these primitives in programming languages can
include
Returning a value to the calling process!
Add conditions to the receive primitive for blocking senders!

Recap Probe-Echo algorithms Syncronous communication
Rendezvouz
It is very difficult to synchronize processes using asyncronous
message passing! We would like to attack problems like waiting on
conditions in the setting of distributed programming.
Think of the primitive of sending a message to another process
leaving the sender process suspended until the message is received
and processed! At that point the processes can handshake or
rendezvous.
The receiving operation will have a queue of waiting processes,
instead of a queue of messages!
Implementations of these primitives in programming languages can
include
Returning a value to the calling process!
Add conditions to the receive primitive for blocking senders!

Recap Probe-Echo algorithms Syncronous communication
Rendezvouz
It is very difficult to synchronize processes using asyncronous
message passing! We would like to attack problems like waiting on
conditions in the setting of distributed programming.
Think of the primitive of sending a message to another process
leaving the sender process suspended until the message is received
and processed! At that point the processes can handshake or
rendezvous.
The receiving operation will have a queue of waiting processes,
instead of a queue of messages!
Implementations of these primitives in programming languages can
include
Returning a value to the calling process!
Add conditions to the receive primitive for blocking senders!

Recap Probe-Echo algorithms Syncronous communication
Rendezvouz
It is very difficult to synchronize processes using asyncronous
message passing! We would like to attack problems like waiting on
conditions in the setting of distributed programming.
Think of the primitive of sending a message to another process
leaving the sender process suspended until the message is received
and processed! At that point the processes can handshake or
rendezvous.
The receiving operation will have a queue of waiting processes,
instead of a queue of messages!
Implementations of these primitives in programming languages can
include
Returning a value to the calling process!
Add conditions to the receive primitive for blocking senders!

Recap Probe-Echo algorithms Syncronous communication
Rendezvouz
It is very difficult to synchronize processes using asyncronous
message passing! We would like to attack problems like waiting on
conditions in the setting of distributed programming.
Think of the primitive of sending a message to another process
leaving the sender process suspended until the message is received
and processed! At that point the processes can handshake or
rendezvous.
The receiving operation will have a queue of waiting processes,
instead of a queue of messages!
Implementations of these primitives in programming languages can
include
Returning a value to the calling process!
Add conditions to the receive primitive for blocking senders!

Recap Probe-Echo algorithms Syncronous communication
Rendezvous in MPD
The channel is declared as an op with fields for the message and
possibly a return type:
resource TimeServer
op getTime() returns int
op delay(int)

Recap Probe-Echo algorithms Syncronous communication
Rendezvous in MPD
The operation is serviced by an in statement:
in getTime() returns time -> time = tod ni
in a process that is executing concurrently with the sender!
Between in and ->: the
guard
Between in and ni: a
guarded operation
The process executing the in
is delayed until there is at
least one pending call on the
channel getTime
Then it selects the oldest
pending call and executes the
operation time = tod
At this point both processes
can proceed!

Recap Probe-Echo algorithms Syncronous communication
Rendezvous in MPD
The operation is serviced by an in statement:
in getTime() returns time -> time = tod ni
in a process that is executing concurrently with the sender!
Between in and ->: the
guard
Between in and ni: a
guarded operation
The process executing the in
is delayed until there is at
least one pending call on the
channel getTime
Then it selects the oldest
pending call and executes the
operation time = tod
At this point both processes
can proceed!

Recap Probe-Echo algorithms Syncronous communication
Rendezvous in MPD
The operation is serviced by an in statement:
in getTime() returns time -> time = tod ni
in a process that is executing concurrently with the sender!
Between in and ->: the
guard
Between in and ni: a
guarded operation
The process executing the in
is delayed until there is at
least one pending call on the
channel getTime
Then it selects the oldest
pending call and executes the
operation time = tod
At this point both processes
can proceed!

Recap Probe-Echo algorithms Syncronous communication
Rendezvous in MPD
The operation is serviced by an in statement:
in getTime() returns time -> time = tod ni
in a process that is executing concurrently with the sender!
Between in and ->: the
guard
Between in and ni: a
guarded operation
The process executing the in
is delayed until there is at
least one pending call on the
channel getTime
Then it selects the oldest
pending call and executes the
operation time = tod
At this point both processes
can proceed!

Recap Probe-Echo algorithms Syncronous communication
Rendezvous in MPD
The operation is serviced by an in statement:
in getTime() returns time -> time = tod ni
in a process that is executing concurrently with the sender!
Between in and ->: the
guard
Between in and ni: a
guarded operation
The process executing the in
is delayed until there is at
least one pending call on the
channel getTime
Then it selects the oldest
pending call and executes the
operation time = tod
At this point both processes
can proceed!

Recap Probe-Echo algorithms Syncronous communication
Rendezvous in MPD
The operation is serviced by an in statement:
in getTime() returns time -> time = tod ni
in a process that is executing concurrently with the sender!
Between in and ->: the
guard
Between in and ni: a
guarded operation
The process executing the in
is delayed until there is at
least one pending call on the
channel getTime
Then it selects the oldest
pending call and executes the
operation time = tod
At this point both processes
can proceed!

Recap Probe-Echo algorithms Syncronous communication
Rendezvous in MPD
The operation is serviced by an in statement:
in getTime() returns time -> time = tod ni
in a process that is executing concurrently with the sender!
Between in and ->: the
guard
Between in and ni: a
guarded operation
The process executing the in
is delayed until there is at
least one pending call on the
channel getTime
Then it selects the oldest
pending call and executes the
operation time = tod
At this point both processes
can proceed!

Recap Probe-Echo algorithms Syncronous communication
Rendezvous in MPD
The general form of in
A process servicing an in can serve several alternatives:
in getTime() returns time
-> time = tod
[] delay(waketime) and waketime skip
ni
and a guard can include a boolean expression!
The process executing the in will
Delay until some guard succeeds (there is a call to the channel
and the boolean expression is true).
The oldest invocation is served by executing its action.
After, both the caller and the service can continue.

Recap Probe-Echo algorithms Syncronous communication
Rendezvous in MPD
The general form of in
A process servicing an in can serve several alternatives:
in getTime() returns time
-> time = tod
[] delay(waketime) and waketime skip
ni
and a guard can include a boolean expression!
The process executing the in will
Delay until some guard succeeds (there is a call to the channel
and the boolean expression is true).
The oldest invocation is served by executing its action.
After, both the caller and the service can continue.

Recap Probe-Echo algorithms Syncronous communication
Rendezvous in MPD
The general form of in
A process servicing an in can serve several alternatives:
in getTime() returns time
-> time = tod
[] delay(waketime) and waketime skip
ni
and a guard can include a boolean expression!
The process executing the in will
Delay until some guard succeeds (there is a call to the channel
and the boolean expression is true).
The oldest invocation is served by executing its action.
After, both the caller and the service can continue.

Recap Probe-Echo algorithms Syncronous communication
Rendezvous in MPD
The general form of in
A process servicing an in can serve several alternatives:
in getTime() returns time
-> time = tod
[] delay(waketime) and waketime skip
ni
and a guard can include a boolean expression!
The process executing the in will
Delay until some guard succeeds (there is a call to the channel
and the boolean expression is true).
The oldest invocation is served by executing its action.
After, both the caller and the service can continue.

Recap Probe-Echo algorithms Syncronous communication
Rendezvous in MPD
The general form of in
A process servicing an in can serve several alternatives:
in getTime() returns time
-> time = tod
[] delay(waketime) and waketime skip
ni
and a guard can include a boolean expression!
The process executing the in will
Delay until some guard succeeds (there is a call to the channel
and the boolean expression is true).
The oldest invocation is served by executing its action.
After, both the caller and the service can continue.

Recap Probe-Echo algorithms Syncronous communication
A time server
A process that can be used by
other processes to be delayed until
some deadline. Processes can use
the time server to set up alarms!

Recap Probe-Echo algorithms Syncronous communication
The time server
resource TimeServer
op getTime() returns int
op delay(int)
body TimeServer()
process timer{
int tod = 0 # time of day
while(true){
in getTime() returns time -> time = tod
[] delay(waketime) and waketime skip
ni
}
}
end

Recap Probe-Echo algorithms Syncronous communication
Using the time server
Example
resource Test
import TimeServer
body Test()
cap TimeServer ts = create TimeServer()
process A{
int i = 0;
while(true){
call ts.delay(20*i++);
write(ts.getTime()/20);
}
}
Notice the use of call! When we use the results we can omit the
call (as inside the write).

Recap Probe-Echo algorithms Syncronous communication
Using the time server
Example
resource Test
import TimeServer
body Test()
cap TimeServer ts = create TimeServer()
process A{
int i = 0;
while(true){
call ts.delay(20*i++);
write(ts.getTime()/20);
}
}
Notice the use of call! When we use the results we can omit the
call (as inside the write).

Recap Probe-Echo algorithms Syncronous communication
Asynchronous message passing revisited
Example
How did the TimeServer keep track of the time? (increment tod)
There will be a hardware
process associated to the
computer clock that
asynchronously and
periodically sends messages
to the TimeServer!
On receiving such messages
tod will be incremented.
In MPD a receive is just an
abbreviation for an operation
serviced by an in and invoked
with a send!
Serviced by in invoked by
call: Rendezvous!
Serviced by in invoked by
send: Asynchronous
message passing!

Recap Probe-Echo algorithms Syncronous communication
Asynchronous message passing revisited
Example
How did the TimeServer keep track of the time? (increment tod)
There will be a hardware
process associated to the
computer clock that
asynchronously and
periodically sends messages
to the TimeServer!
On receiving such messages
tod will be incremented.
In MPD a receive is just an
abbreviation for an operation
serviced by an in and invoked
with a send!
Serviced by in invoked by
call: Rendezvous!
Serviced by in invoked by
send: Asynchronous
message passing!

Recap Probe-Echo algorithms Syncronous communication
Asynchronous message passing revisited
Example
How did the TimeServer keep track of the time? (increment tod)
There will be a hardware
process associated to the
computer clock that
asynchronously and
periodically sends messages
to the TimeServer!
On receiving such messages
tod will be incremented.
In MPD a receive is just an
abbreviation for an operation
serviced by an in and invoked
with a send!
Serviced by in invoked by
call: Rendezvous!
Serviced by in invoked by
send: Asynchronous
message passing!

Recap Probe-Echo algorithms Syncronous communication
Asynchronous message passing revisited
Example
How did the TimeServer keep track of the time? (increment tod)
There will be a hardware
process associated to the
computer clock that
asynchronously and
periodically sends messages
to the TimeServer!
On receiving such messages
tod will be incremented.
In MPD a receive is just an
abbreviation for an operation
serviced by an in and invoked
with a send!
Serviced by in invoked by
call: Rendezvous!
Serviced by in invoked by
send: Asynchronous
message passing!

Recap Probe-Echo algorithms Syncronous communication
Asynchronous message passing revisited
Example
How did the TimeServer keep track of the time? (increment tod)
There will be a hardware
process associated to the
computer clock that
asynchronously and
periodically sends messages
to the TimeServer!
On receiving such messages
tod will be incremented.
In MPD a receive is just an
abbreviation for an operation
serviced by an in and invoked
with a send!
Serviced by in invoked by
call: Rendezvous!
Serviced by in invoked by
send: Asynchronous
message passing!

Recap Probe-Echo algorithms Syncronous communication
Asynchronous message passing revisited
Example
How did the TimeServer keep track of the time? (increment tod)
There will be a hardware
process associated to the
computer clock that
asynchronously and
periodically sends messages
to the TimeServer!
On receiving such messages
tod will be incremented.
In MPD a receive is just an
abbreviation for an operation
serviced by an in and invoked
with a send!
Serviced by in invoked by
call: Rendezvous!
Serviced by in invoked by
send: Asynchronous
message passing!

Recap Probe-Echo algorithms Syncronous communication
The time server revisited
resource TimeServer
op getTime() returns int
op delay(int)
op tick()
body TimeServer()
process timer{
int tod = 0 # time of day
while(true){
in getTime() returns time -> time = tod
[] delay(waketime) and waketime skip
[] tick() -> tod++
ni
}
}
end