1) Discuss the mutual exclusion mechanism that you choose as implemented in the chosen language and the associated basic syntax

Transcription

1 Lab report Project 3 Mihai Ene I have implemented the solution in Java. I have leveraged its threading mechanisms and concurrent API (i.e. concurrent package) in order to achieve the required functionality and in order to implement a slightly more modular approach (by leveraging Java s OOP capabilities). 1) Discuss the mutual exclusion mechanism that you choose as implemented in the chosen language and the associated basic syntax Java provides quite a number of mechanisms for implementing a concurrent programming paradigm. Unlike C, we cannot create multiple processes; however, Java provides both low level and high level APIs for working with Threads. I have used the equivalent of semaphores and implemented the process-like mechanism by using threads (i.e. Thread instances). The main focus lies on the Thread synchronization aspect and on acquiring and releasing permissions (via said semaphore). 2) Specify where the critical section(s) is (are) located in your code I have modeled the critical section as a method in the Tunnel.java class. In order for a car to pass through the tunnel (i.e. call the gothroughtunnel() method on the Tunnel instance), a semaphore is acquired (and subsequently, released), in order to emulate cars going through. public void gothroughtunnel(car car){ arrive(car); try { semaphore.acquire(); System.out.println("[TUNNEL] CAR GOING THROUGH TUNNEL HEADING " +car.getdirection() + " FOR BUFFER SIZE: " + buffersize); log.logmessage("[tunnel] CAR GOING THROUGH TUNNEL HEADING " +car.getdirection() + " FOR BUFFER SIZE: " + buffersize); int speed = car.getspeed(); int duration = getlength() / speed; try { Thread.sleep(duration*1000); catch (InterruptedException e) { e.printstacktrace(); semaphore.release(); depart(car); catch (InterruptedException e1) { e1.printstacktrace();

2 3) How such a critical section is guarded with the mutual exclusion of your choice, so that only one car is in the tunnel in one direction. You should also include in this report The gothroughtunnel(car car) method receives a Car.java instance which is actually a thread. The semaphore s acquire() and release() methods and also arrive() and depart() are called. The latter ones represent Tunnel.java s methods. The method sleeps for a specified duration. After resuming, the semaphore s lock is released. 4) A discussion about how you generate the data. I have created a number of constants in order to simply alter and extend the behavior of the application. In order to simulate the process, I have segmented the code into methods and classes. For instance, in order to generate the information pertaining to cars, I have created a Java class (Car.java) which represents such entities. In order to completely leverage Java s OOP features, I have created a method ( generatecars(..) ) which populates a Collections instance (i.e. a List in this case) with cars with different traits (i.e. values for fields, encapsulated via getter, setter methods). I have generated the information as per specification, with appropriate values which are obtained from a Random instance. private static final int NUMBER_OF_CARS = 100; private static final int MAX_NUMBER_OF_CARS_IN_TUNNEL = 147; private static final int CAR_SPEED = 38; // feet per second private static final int TIME_TO_STOP = 7; private static final int NUMBER_OF_MINUTES_IN_DAY = 1440; public static List<Car> generatecars(tunnel tunnel) { List<Car> cars = new ArrayList<>(); Random rand = new Random(); for (int i = 0; i < NUMBER_OF_CARS; i++) { boolean isnorth = rand.nextboolean(); // generate random direction // for the car (either NORTH // or SOUTH) Direction direction = null; if (isnorth) { direction = Direction.NORTH; else { direction = Direction.SOUTH; // create new car, associated with a tunnel "critical resource", // random direction and car speed Car car = new Car(tunnel, direction, CAR_SPEED); // sort cars by arrival time, I have used the Comparator interface // in order to sort the collection (i.e. List of cars) // car.setarrivaltime(rand.nextint(number_of_minutes_in_day)); TODO: // reset car.setarrivaltime(rand.nextint(number_of_minutes_in_day) * System.currentTimeMillis()); cars.add(car); // sort cars by arrival time, I have used the // Comparator interface in order to sort the // collection (i.e. List of cars) Collections.sort(cars, new CarComparator()); return cars;

3 5) A conclusion as which policy is optimal and why. In order to best assess the best policy for each case, I ran several simulations. Also, I have developed a Logger class which logs the relevant information (not only final data, but also waiting times presented below in milliseconds for each car i.e. Car.java instance). For each scenario, I logged the required information (total and average waiting time). Each simulation is ran separately: public static void main(string[] args) { Integer buffers[] = { 2, 6, 8, 10, 12 ; // scenario(2); for (Integer bfr : buffers) { scenario(bfr); According to the measurements when sending through 100 cars: INFO: AVERAGE WAITING TIME FOR SCENARIO 2 is : seconds Apr 06, :20:19 AM app.filelogger logmessage INFO: AVERAGE WAITING TIME FOR SCENARIO 6 is : seconds Apr 06, :25:55 AM app.filelogger logmessage INFO: AVERAGE WAITING TIME FOR SCENARIO 8 is : seconds Apr 06, :32:27 AM app.filelogger logmessage INFO: AVERAGE WAITING TIME FOR SCENARIO 10 is : seconds Apr 06, :40:57 AM app.filelogger logmessage Apr 06, :49:21 AM app.filelogger logmessage INFO: AVERAGE WAITING TIME FOR SCENARIO 12 is : seconds When sending through a sample of 300 cars we can observe that : INFO: TOTAL WAITING TIME FOR SCENARIO 2 is : seconds INFO: AVERAGE WAITING TIME FOR SCENARIO 2 is : seconds TOTAL NUMBER OF CARS THROUGH TUNNEL : 278

4 INFO: TOTAL WAITING TIME FOR SCENARIO 6 is : seconds INFO: AVERAGE WAITING TIME FOR SCENARIO 6 is : seconds TOTAL NUMBER OF CARS THROUGH TUNNEL : 191 INFO: TOTAL WAITING TIME FOR SCENARIO 8 is : seconds INFO: AVERAGE WAITING TIME FOR SCENARIO 8 is : seconds TOTAL NUMBER OF CARS THROUGH TUNNEL : 170 INFO: TOTAL WAITING TIME FOR SCENARIO 10 is : seconds INFO: AVERAGE WAITING TIME FOR SCENARIO 10 is : seconds TOTAL NUMBER OF CARS THROUGH TUNNEL : 131 INFO: TOTAL WAITING TIME FOR SCENARIO 12 is : seconds INFO: AVERAGE WAITING TIME FOR SCENARIO 12 is : seconds TOTAL NUMBER OF CARS THROUGH TUNNEL : 120 The general pattern from comparing these 2 cases is that when having a larger buffer size the average waiting time decreases for each case and also the total waiting time for each case is also decreased. The best case scenario is achieved in the first test when the buffer is 12 resulting in the smallest average waiting time. In the second case the optimal scenario is scenario 10 where average waiting time is the smallest. The downside of a larger waiting time between directions semaphore switch is that smaller numbers of cars get to pass through the tunnel. In the last case the smallest waiting time yielded the largest numbers of cars that were able to pass through the tunnel therefore there is a balance between the average waiting time and the total of number of cars that are able to go through the tunnel in a given period of time. For 1000 cars: INFO: TOTAL WAITING TIME FOR SCENARIO 2 is : seconds INFO: AVERAGE WAITING TIME FOR SCENARIO 2 is : seconds TOTAL NUMBER OF CARS THROUGH TUNNEL : 652 INFO: TOTAL WAITING TIME FOR SCENARIO 6 is : seconds INFO: AVERAGE WAITING TIME FOR SCENARIO 6 is : seconds TOTAL NUMBER OF CARS THROUGH TUNNEL : 263

5 INFO: TOTAL WAITING TIME FOR SCENARIO 8 is : seconds INFO: AVERAGE WAITING TIME FOR SCENARIO 8 is : seconds TOTAL NUMBER OF CARS THROUGH TUNNEL : 184 INFO: TOTAL WAITING TIME FOR SCENARIO 10 is : seconds INFO: AVERAGE WAITING TIME FOR SCENARIO 10 is : seconds TOTAL NUMBER OF CARS THROUGH TUNNEL : 151 Because the code simulates a real life scenario actually testing for large number of cars can take numerous hours even days. In order to run the test for 100 cars it tool roughly half an hour and for 300 it took about 1 hour and 30 minutes. In the case of 1000 cars my home desktop is still running the simulation since this afternoon; currently calculating scenario 12.