At uni we are studying concurrency using a very simple program which controls several robots within an area. They simulate processes/ threads. The whole thing comes bundled in a sort of mockup IDE which has a graphical console, all of this is programmed in Java, but we program in a sort of pseudocode.
(please excuse lack of knowledge about concurrency, we literally have three weeks to learn concepts and are graded in the fourth week).
We are asked to program robot types for different tasks. We may have several instances of the same type of robot running at once in order to have them doing the same thing in different places.
The robots must perform their tasks without bumping into other robots. They achieve this by:
- sending and receiving messages. The message sending is asynchronous and the receiving is synchronous (this blocks the robot which is receiving until the message arrives).
- blocking the part of the area which they need (the area is a 100 x 100 matrix with x,y coordinates). We can block a particular "corner" if we need to do something there, but must then unblock it after leaving so as to not lower concurrency.
- sectoring off parts of the whole area into smaller private ones (for one robot) or semi private areas (for a few robots). Areas can be private, partly shared or completely shared, with the idea of simulating the memory in concurrency.
The tasks the robots perform are to drop or pick up objects from a corner. They can also move in a straight line and turn the corner.
We were asked to make a program to resolve the following issue.
Three collector robots positioned in their own respective corners(3,3),(4,4),(5,5) need to collect from the same corner, let's say (10,10).
One boss robot, in (1,1), uses a random function to pick which of the three robots will go to the shared corner to collect the goods.
The program needs to consider that: - the robots must all know when there may be nothing to collect from the start or when there is no longer anything to collect. It is inevitable that a lot of message sending will need to happen, but we do need to consider that the less messages we send the better because they lower concurrency. Similarily with corner blocking.
Once all of the goods have been collected the boss will inform which of the three collector robots has collected the most.
First of all the collector robots are all of the same type. So they have the same programming. One of them may go to the corner first, find nothing, communicate to the boss robot that there is nothing and that then the rest of the collector robots must stop when the boss informs them that there is nothing to collect.
Then, the same applies for once they are collecting. At some point, they will all collect, one of them will collect the last thing, and needs to communicate that to the rest, probably communicating it to the boss who will communicate that to the rest. They must all stop.
Finally, the boss must inform which one of the robots got the most elements. A maximum function.
This has so far worked allright if not efficiently and I am not sure if completely correctly.
I am including the pseudocode, In order to get some feedback. I know it can be done better, but qhenever I change anything to try and refactor the code, it just breaks and something stops working.
I really can't see the forest for the trees right now and the exams are coming up next week. Any insight is welcomed.
program threeCollectors
functions
function max (ES max: integer; ES maxrobot: integer;
E aux: integer; E id: integer)
begin
if (max < aux)
max:= aux
maxrobot:=id
end
function sendID
begin
SendMsg(1, robot1)
SendMsg(2, robot2)
SendMsg(3, robot3)
end
function collect (E myPosX: integer; E myPosY: integer;
ES boxes: integer; ES plants:integer; ES goOn: integer; ES ok: boolean)
begin
BlockCorner(10,10)
Pos(10,10)
if ~(ThereIsBox) & ~(ThereIsPlant)
ok:= F
goOn:=0
Pos(myPosY,myPosX)
FreeCorner(10,10)
SendMsg(goOn, robot0)
Print('dontGoOn',goOn)
else
ok:= V
goOn:=1
if(ThereIsBox) & (ThereIsPlant)
getBox
boxes:=boxes+1
getPlant
plants:=plants+1
else
if (ThereIsBox)
getBox
boxes:=boxes+1
else
if (ThereIsPlant)
getPlant
plants:=plants+1
SendMsg(goOn, robot0)
Pos(myPosY,myPosX)
FreeCorner(10,10)
ReceiveMsg(goOn, robot0)
end
areas
areaJ : AreaP(1,1,1,1)
area: AreaPC(3,3,10,10)
robots
robot boss
variables
t:integer
id: integer
max:integer
maxrobot: integer
goOn: integer
total: integer
begin
max:= -1
total:= 0
goOn:= 1
sendID
while (goOn = 1)
Random(id, 1, 3)
Print('envio',id)
if(id = 3)
SendMsg(goOn, robot3)
ReceiveMsg(goOn, robot3)
else
if (id = 1)
SendMsg(goOn, robot1)
ReceiveMsg(goOn, robot1)
else
if(id = 2)
SendMsg(goOn, robot2)
ReceiveMsg(goOn, robot2)
if (goOn =0)
SendMsg(goOn, robot1)
SendMsg(goOn, robot2)
SendMsg(goOn, robot3)
for 3
ReceiveMsg(id, *)
if (id = 1)
ReceiveMsg(t, robot1)
else
if (id = 2)
ReceiveMsg(t, robot2)
else
if (id = 3)
ReceiveMsg (t, robot3)
max(max, maxrobot, t, id)
Print('gano',maxrobot)
Print('collected',t)
end
robot collector
variables
boxes: integer
plants: integer
myPosY:integer
myPosX:integer
whoami: integer
goOn: integer
total: integer
ok: boolean
begin
total:=0
boxes:= 0
plants:= 0
ok:=V
myPosY:=PosY
myPosX:=PosX
ReceiveMsg(whoami, robot0)
ReceiveMsg(goOn, robot0)
while (goOn = 1) & (ok = V)
collect (myPosX,myPosY, boxes,plants,goOn,ok)
total:= plants + boxes
SendMsg(whoami, robot0)
SendMsg(total, robot0)
end
variables
robot0: boss
robot1,robot2,robot3: collector
begin
AsignArea(robot0, areaJ)
AsignArea(robot1,area)
AsignArea(robot2,area)
AsignArea(robot3,area)
Init(robot0, 1,1)
Init(robot1, 3, 3)
Init(robot2, 4, 4)
Init(robot3, 5, 5)