fixed merge

ramalho · ramalho · commit 4ef4b82e827a · 2015-04-15T04:51:38.000-03:00
diff --git a/.gitignore b/.gitignore
@@ -1,5 +1,6 @@
 concurrency/flags/img/*.gif
 concurrency/charfinder/charfinder_index.pickle
+18-asyncio/charfinder/charfinder_index.pickle
 metaprog/oscon-schedule/data/schedule?_db
 concurrency/wikipedia/fixture/docroot/
 
diff --git a/16-coroutine/taxi_sim.py b/16-coroutine/taxi_sim.py
diff --git a/control/taxi_sim3.py b/control/taxi_sim3.py
@@ -1,4 +1,3 @@
-
 """
 Taxi simulator
 
@@ -27,91 +26,114 @@
 
 """
 
-import sys
 import random
 import collections
 import queue
 import argparse
+import time
 
 DEFAULT_NUMBER_OF_TAXIS = 3
-DEFAULT_END_TIME = 80
-SEARCH_DURATION = 4
-TRIP_DURATION = 10
+DEFAULT_END_TIME = 180
+SEARCH_DURATION = 5
+TRIP_DURATION = 20
 DEPARTURE_INTERVAL = 5
 
 Event = collections.namedtuple('Event', 'time proc action')
 
-
-def compute_delay(interval):
-    """Compute action delay using exponential distribution"""
+Actitivy = collections.namedtuple('Actitivy', 'name distr_param')
+
+START = Actitivy('start shift', TRIP_DURATION)
+SEARCH_PAX = Actitivy('searching for passenger', SEARCH_DURATION)
+DRIVE_PAX = Actitivy('driving passenger', TRIP_DURATION)
+
+TRANSITIONS = {
+    START : SEARCH_PAX;
+    SEARCH_PAX : DRIVE_PAX;
+}
+
+def compute_duration(previous_action):
+    """Compute action duration using exponential distribution"""
+    if previous_action in ['leave garage', 'drop off passenger']:
+        # state is prowling
+        interval = SEARCH_DURATION
+    elif previous_action == 'pick up passenger':
+        # state is trip
+        interval = TRIP_DURATION
+    elif previous_action == 'going home':
+        interval = 1
+    else:
+        assert False
     return int(random.expovariate(1/interval)) + 1
 
+
 # BEGIN TAXI_PROCESS
 def taxi_process(ident, trips, start_time=0):  # <1>
     """Yield to simulator issuing event at each state change"""
     time = yield Event(start_time, ident, 'leave garage')  # <2>
     for i in range(trips):  # <3>
-        prowling_ends = time + compute_delay(SEARCH_DURATION)  # <4>
-        time = yield Event(prowling_ends, ident, 'pick up passenger')  # <5>
+        time = yield Event(time, ident, 'pick up passenger')  # <4>
+        time = yield Event(time, ident, 'drop off passenger')  # <5>
 
-        trip_ends = time + compute_delay(TRIP_DURATION)  # <6>
-        time = yield Event(trip_ends, ident, 'drop off passenger')  # <7>
-
-    yield Event(time + 1, ident, 'going home')  # <8>
-    # end of taxi process # <9>
+    yield Event(time, ident, 'going home')  # <6>
+    # end of taxi process # <7>
 # END TAXI_PROCESS
 
+
 # BEGIN TAXI_SIMULATOR
 class Simulator:
 
     def __init__(self, procs_map):
         self.events = queue.PriorityQueue()
         self.procs = dict(procs_map)
 
-
-    def run(self, end_time):  # <1>
+    def run(self, end_time, delay=False):  # <1>
         """Schedule and display events until time is up"""
         # schedule the first event for each cab
         for _, proc in sorted(self.procs.items()):  # <2>
             first_event = next(proc)  # <3>
             self.events.put(first_event)  # <4>
 
         # main loop of the simulation
-        time = 0
-        while time < end_time:  # <5>
-            if self.events.empty():  # <6>
+        sim_time = 0  # <5>
+        while sim_time < end_time:  # <6>
+            if self.events.empty():  # <7>
                 print('*** end of events ***')
                 break
 
             # get and display current event
-            current_event = self.events.get()  # <7>
-            print('taxi:', current_event.proc,  # <8>
-                  current_event.proc * '   ', current_event)
-
+            current_event = self.events.get()  # <8>
+            if delay:
+                time.sleep((current_event.time - sim_time) / 2)
+            # update the simulation time
+            sim_time, proc_id, previous_action = current_event
+            print('taxi:', proc_id, proc_id * '   ', current_event)
+            active_proc = self.procs[proc_id]
             # schedule next action for current proc
-            time = current_event.time  # <9>
-            proc = self.procs[current_event.proc]  # <10>
+            next_time = sim_time + compute_duration(previous_action)
             try:
-                next_event = proc.send(time)  # <11>
+                next_event = active_proc.send(next_time)  # <12>
             except StopIteration:
-                del self.procs[current_event.proc]  # <12>
+                del self.procs[proc_id]  # <13>
             else:
-                self.events.put(next_event)  # <13>
-        else:  # <14>
+                self.events.put(next_event)  # <14>
+        else:  # <15>
             msg = '*** end of simulation time: {} events pending ***'
             print(msg.format(self.events.qsize()))
 # END TAXI_SIMULATOR
 
+
+
+
 def main(end_time=DEFAULT_END_TIME, num_taxis=DEFAULT_NUMBER_OF_TAXIS,
-         seed=None):
+         seed=None, delay=False):
     """Initialize random generator, build procs and run simulation"""
     if seed is not None:
         random.seed(seed)  # get reproducible results
 
     taxis = {i: taxi_process(i, (i+1)*2, i*DEPARTURE_INTERVAL)
              for i in range(num_taxis)}
     sim = Simulator(taxis)
-    sim.run(end_time)
+    sim.run(end_time, delay)
 
 
 if __name__ == '__main__':
@@ -128,9 +150,11 @@ def main(end_time=DEFAULT_END_TIME, num_taxis=DEFAULT_NUMBER_OF_TAXIS,
                         % DEFAULT_NUMBER_OF_TAXIS)
     parser.add_argument('-s', '--seed', type=int, default=None,
                         help='random generator seed (for testing)')
+    parser.add_argument('-d', '--delay', action='store_true',
+                        help='introduce delay proportional to simulation time')
 
     args = parser.parse_args()
-    main(args.end_time, args.taxis, args.seed)
+    main(args.end_time, args.taxis, args.seed, args.delay)
 
 
 """
