Plan for rest of course

Transcription

1 Plan for rest of course week 9-10 Converting CSP into JCSP architectures Include visualisation of these networks of processes to build graphical simulations. Already seen buttons but we need to know about canvases. Learn more about translation into JCSP so that we can build bigger networks week 9 Exam Structure week 11 Revision, including re-visiting CSP in order to look at safety specifications with another example COM2007 1

2 Exam Structure 3 compulsory questions question 1- demonstrate understanding of princinples and concepts of JCSP(40 marks) question 2 - CSP specification (20 marks) question 3 - modelling behaviour and defining concurrent architectures based on a scenario (40 marks) COM2007 2

3 Simple Car Park Monitoring COM2007 3

4 How to convert the abstract models channel arrive,depart maxcars = 4 CARPARKCONTROL = FILLED(0) FILLED(i) = (i < maxcars) & arrive -> FILLED(i+1) [] (i > 0) & depart -> FILLED(i-1) ARRIVALS = arrive -> ARRIVALS DEPARTURES = depart -> DEPARTURES AC = {arrive,depart} AA = {arrive} AD = {depart} CARPARK = (ARRIVALS [AA AD] DEPARTURES) [union(aa,ad) AC] CARPARKCONTROL COM2007 4

5 Key features of car park example Look to see what the key synchronisations are in the model Look to see what conditions need to hold for the synchronisations. The CarParkControl is acting like a monitor Single access procedure in the monitor ARRIVALS and DEPARTURES are acting like active entities (threads) COM2007 5

6 We model arrive using a, depart using b which are One2OneInt channels Since arrival and departure were external events we needed a way of simulating this to trigger them to happen so we put a graphics layer on top COM2007 6

7 Let s start with a frame Let s define a class which allows me to create a frame. It s just an outer shell. public class eg_frame { public static void main(string argv[]) { final ActiveClosingFrame activeclosingframe = new ActiveClosingFrame( "Lec 13 building simple frame"); final Frame frame = activeclosingframe.getactiveframe(); frame.setsize(400, 400); frame.setvisible(true); new Parallel(new CSProcess[] { activeclosingframe } ).run(); }} It s not necessary to define a parallel object at this point but I m doing it now so that you can see how to slot in the canvas in a little while (with ease). COM2007 7

8 Can we add a canvas? We can draw on an ActiveCanvas. (You can also be able to interact with it.) Declaring an active canvas object in the same file as the frame. final ActiveCanvas canvas = new ActiveCanvas (); canvas.setpaintable (displaylist); canvas.setsize (600, 400); We could separate out the canvas definition to be in its own class. For example, defining a new class where canvas will be a private variable. Then in the constructor create a new canvas. How will you know it s size. Well two ways: either give it explicitly or query the frame size. Example file Canvas_lec13.java To link it to the frame in the main java program define a canvas object and make it run in parallel with the frame. final Canvas_lec13 canvas = new Canvas_lec13(frame); COM2007 8

9 Example skeleton class Canvas_lec13 implements CSProcess{ private final ActiveCanvas activecanvas; public Canvas_lec13(final Container parent){ System.out.println ("canvas_lec13 now creating ActiveCanvas..."); activecanvas = new ActiveCanvas (); activecanvas.setsize (parent.getsize ()); } System.out.println ("canvas_lec13 adding ActiveCanvas to the parent..."); parent.add ("Center", activecanvas); } public void run () { activecanvas.run(); } Again we ll need to define a parallel object in due course in the run method. COM2007 9

10 How do we change the colour of the background on a frame? You can do this in the outer class where you defined the frame, or you can do it in the canvas class. You should call the appropriate methods for the frame object. For example, if we did it in the canvas class we d use the parameter passed to the constructor and then: parent.setlayout (new BorderLayout ()); parent.setbackground (Color.blue); COM

11 How do we get graphics onto a canvas? A DisplayList is a passive object providing graphics services on behalf of a CSProcess. It enables all methods of java.awt.graphics to be executed on the active graphics component. In JCSP when we define a DisplayList object it provides an instance of a Paintable class. Then we can pass this as an argument to the setpaintable method so that we can connect the DisplayList to the ActiveCanvas. The definition of setpaintable is defined as public void setpaintable(paintable paintable). COM

12 Display List (continued) In JCSP we can think of DisplayList as a special form of channel. The user process sees the display interface to the DisplayList so that a user process writes to it by setting up and/or editing an ordered list of GraphicsCommands. The ActiveCanvas process sees the Paintable interface to the DisplayList (reads). Therefore, a DisplayList gives you two views and a secure interface between an active user process and an active graphics component. From JCSP docs: DisplayList user process >>> ActiveCanvas Display Paintable COM

13 What would the code look like to define a DisplayList object? So if we were doing it in one large file we do: final DisplayList displaylist = new DisplayList (); final ActiveCanvas canvas = new ActiveCanvas (); canvas.setpaintable (displaylist); whereas in a class structured program you would define a private variable private final DisplayList displaylist; and then have: displaylist = new DisplayList (); activecanvas.setpaintable(displaylist); COM

14 Graphics Command User processes send an array of GraphicsCommands by invoking set, change methods to the DisplayList object. It is a class jcsp.awt.graphicscommand. E.g. GraphicsCommand.DrawImage corresponds to java.awt.graphics.drawimage. The following draws a background colour, a rectangle with a message in black in the center. final GraphicsCommand[] myfilledrect = {new GraphicsCommand.SetColor (Color.cyan), new GraphicsCommand.FillRect (0, 0, 600, 400), new GraphicsCommand.SetColor (Color.black), new GraphicsCommand.DrawString ("hello", 145, 200)}; displaylist.set(myfilledrect); COM

15 Experimenting in one large file (yuck...) new Parallel(new CSProcess[] { activeclosingframe, canvas, new CSProcess() { public void run() { final GraphicsCommand[] myfilledrect = { new GraphicsCommand.SetColor(Color.cyan), new GraphicsCommand.FillRect(0, 0, 600, 400), new GraphicsCommand.SetColor(Color.black), new GraphicsCommand.DrawString("hello", 145, 200) }; displaylist.set(myfilledrect); } } }).run(); Example eg_framecanvascolour.java draws a filled rectangle on a canvas in a frame and eg_framecanvaschangingcolour.java draws a filled rectangle on a canvas in a frame which changes colour after a delay. COM

16 How would we make use of graphics commands using a class structured program? We d have three classes - one for the frame, one for the canvas and display list and one for what s going on inside the canvas i.e. what we want to see. Let s first look at Canvasv2_lec13.java. We d need to have a circle variable. private final Circle circle; /* in the privately scoped area of class */ circle = new Circle(displayList); /* goes in constructor */ public void run () { /* then we need to run it in parallel with the canvas */ new Parallel ( new CSProcess[] { activecanvas, circle } ).run (); Ah, this means that the circle object will be a process. COM

17 Let s make a simple user process Consider a Circle class. The following sets up a circle display object in the java program where the parallel processes are defined. We ve just seen: Circle circle = new Circle(displayList); The above means that the Circle object can write along the DisplayList channel to the canvas. Therefore, the constructor in the Circle class definition is given in the following: public class Circle implements CSProcess { DisplayList displaylist; // for graphics public Circle(DisplayList displaylist){ this.displaylist = displaylist; }... Then we can use the displaylist.set(...) calls in the run method. Typically, we define private functions which are called in the run method to capture the setting up of the graphics so that the code is well structured (see Circle.java). COM

18 Examples so far The eg_frame.java is a simple example of just getting a frame constructed The eg_framecanvas.java is a simple example of just a frame and a canvas The eg_framecanvascolour.java is one large program which displays a colour on a canvas. The eg_framecanvaschangingcolour.java is one large program which displays a colour on a canvas that changes with a delay. The eg_displaylist.java and Canvas_v2.java and Circle.java is a good overall structure for developing a graphics application The MyCircleTest2.java adds a buttons so that the execution of the circle can be paused/unpaused. You can run this example yourselves. It makes use of gridbaglayout to organise the layout. COM

19 Returning to Car Park Example-Arrival Class Need a way of simulating arrival at regular intervals so that output communication that car arrived can be sent to the CarPark Set up output channel for arrival of car (will be a one2one communication channel a with CarPark) Set up timer to control display (is internal communication, bit more complex than the skip we ve seen in the lab in week 9) Set up events to control button, normally two: event and change (similar to the freeze control events we ve seen in week 8 and are one2one communications with the button) COM

20 final Guard[] altchannels = { event, tim }; final Alternative alt = new Alternative(altChannels); Arrival Class code structure while (true) { int i = 0; while (i < 360) // for 1 complete circle { switch (alt.priselect()) { case EVENT: if (event.read() == " Pause ") { change.write("unpause"); // change button label and wait for event.read(); change.write(" Pause "); // unpausing button event } break; case TIM: // wait for 1 interval then update timeout = tim.read() + interval; tim.after(timeout); tick(l); //update graphics l = (l + 1) % 360; i++; break; } } // after 1 complete circle output to car park out.write(1); i = 0; } COM

21 Returning to Car Park Example-CarPark Class Set up an attribute to represent the i variable in the FILLED process which records the number of cars in the car park Set up an alternative to be the choice between the arrival and departure of a car, we will monitor this as inputs from the a and b channels. Iteratively do the following: Need to check whether can accept the communication or not, can do this with a simple if or a pre-condition in the alting statement In each case read the communication. BUT the value being communicated is not important so can throw it away or send dummy information. This is the way to map atomic events into JCSP Also update the i attribute and update the graphics COM

22 CarPark Class Code Structure final Guard[] altchannels = {in, request}; final Alternative alt = new Alternative(altChannels); // alt over arrivals and request for a departure while(true) { switch (alt.fairselect()) { case IN: // arrival if(n<4) // can accept an arrival { in.read(); // read in arrival n++; spaces(n); // update car park graphics } break; } } case REQUEST: // requests a departure if(n>0) // at least 1 car in car park { request.read(); // read request out.write(1); // output car n--; spaces(n); // update car park } break; COM

23 Returning to Car Park Example-Departure Class Has a mirrored structure to the Arrival class However, we have added a simple protocol for an acknowledge of the request to leave the car park. This is not included in the CSP but is one way to refine the model so that you can include more communication if necessary. This acknowledge protocol could mean that the CarPark class first has to lift the barrier, this could be reflected in the graphic. COM

24 Departure class Code Structure final Guard[] altchannels = {event, tim}; final Alternative alt = new Alternative(altChannels); while (true) { int i = 0; while(i<360) // for 1 complete circle { switch (alt.priselect()) { case EVENT: //deal with pausing the button case TIM: //wait for time interval and update the graphic } //after 1 complete circle request from car park and read in request.write(1); in.read(); i=0; //reset the circle variable } COM

25 Putting it all together All channels need to be defined in a Main class which is not part of the diagram structure. All the channels in this case study are simple One2One channels Alting structures have been introduced in CarPark to reflect the ones in the CSP class Alting structures have been introduced in the Arrival and Departure class in order to time the output/input communication. new Parallel(new CSProcess[] { activeclosingframe, activecanvas, button, button2, arrival, departure, carpark }).run(); COM

26 Recap of Lab 4 cars on a bridge COM

27 Architecture COM

28

29

30 Assumptions and Simplications Combine the MAINLIGHT, ISLANDLIGHT and BRIDGE together into one class. Then the combined new Bridge class can control the ordering of the offmainland, offisland, mturngreen, mturnred, iturnred and iturngreen. So in effect it is combining the state machines of these three processes. This is a non-trivial task. (Hint: one way to start is to re-write the CSP processses as one process, stepping through what transitions are possible at each step.) Resolved the non-determinism in TCONTROL so that I give the traffic lights a prescribed sequence pattern. Since CSP is a modelling language the simulations can be refinements of the abstract models and provide a definite behaviour. Make the simulation easier by only looking at the flow of traffic from the mainland to the island. COM