from iodev import *
from simprocess import *
running = 1; finished = 0
fcfsdisktime = 0.0
sstfdisktime = 0.0

class FCFS(Thread):
  def __init__(self,dev):
    self.device = dev; self.queue = []
    self.mutex = Lock()
    Thread.__init__(self,group=None, target=None, name=None, args=None)
    self.setDaemon(1)
  def run(self):
    global running, fcfsdisktime
    dev = self.device
    while running:
      if (len(self.queue) > 0):
        self.mutex.acquire()
        dist = 2*dev.size; closest = 0; cur = dev.current_block
        (block,complete) = self.queue[closest]
        print "%d is next in" % (block), self.str_q(self.queue)
        del self.queue[closest]
        
        self.mutex.release()
        t = self.device.seek(block)
        fcfsdisktime = fcfsdisktime + t
        print "completed request for block %d in time %f" % (block,t)
        complete.set()
      else:
        pass
      time.sleep(0)
  
  def start(self):
    Thread.start(self)
  def accept_req(self,n,b,lk):
    self.mutex.acquire()
    self.queue.append((b,lk))
    self.mutex.release()
    print "accepted request from %s for block %d, queue=" % (n,b),\
          self.str_q(self.queue)
    return
  def str_q(self,q):
    r = []
    for x in q:
      (b,e) = x
      r.append(b)
    return r

class SSTF(Thread):
  def __init__(self,dev):
    self.device = dev; self.queue = []
    self.mutex = Lock()
    Thread.__init__(self,group=None, target=None, name=None, args=None)
    self.setDaemon(1)
  def run(self):
    global running, sstfdisktime
    dev = self.device
    while running:
      if (len(self.queue) > 0):
        self.mutex.acquire()
        dist = 2*dev.size; closest = 0; cur = dev.current_block
        for i in range(len(self.queue)):
          (b,l) = self.queue[i]
          if (abs(b-cur) < dist):
            closest = i; dist = abs(b-cur)
        (block,complete) = self.queue[closest]
        print "%d is closest to %d in" % (block,cur), self.str_q(self.queue)
        del self.queue[closest]
        
        self.mutex.release()
        t = self.device.seek(block)
        sstfdisktime = sstfdisktime + t
        print "completed request for block %d in time %f" % (block,t)
        complete.set()
      else:
        pass
      time.sleep(0)
  
  def start(self):
    Thread.start(self)
  def accept_req(self,n,b,lk):
    self.mutex.acquire()
    self.queue.append((b,lk))
    self.mutex.release()
    print "accepted request from %s for block %d, queue=" % (n,b),\
          self.str_q(self.queue)
    return
  def str_q(self,q):
    r = []
    for x in q:
      (b,e) = x
      r.append(b)
    return r
  
df = Disk(); sched_fcfs = FCFS(df); sched_fcfs.start()
ds = Disk(); sched_sstf = SSTF(ds); sched_sstf.start()

def fcfs_disk_req(n,b):
  global sched_fcfs
  complete = Event(); complete.clear()
  sched_fcfs.accept_req(n,b,complete)
  complete.wait()
  return
  
def sstf_disk_req(n,b):
  global sched_sstf
  complete = Event(); complete.clear()
  sched_sstf.accept_req(n,b,complete)
  complete.wait()
  return
  
b = []; NumB = 10
for i in range(NumB):
  name = "chop+fcfs%d" % i
  newbf = BisectionSeeker(name,fcfs_disk_req,20,0,1000)
  name = "chop+sstf%d" % i
  newbs = BisectionSeeker(name,sstf_disk_req,20,0,1000)
  b.append(newbf)
  b.append(newbs)
  newbf.start(); newbs.start()

for i in range(2*NumB):
  b[i].join();
running = 0
sched_fcfs.join(); sched_sstf.join()

print "\nTotal FCFS Disk Seek Time = ",fcfsdisktime
print "\nTotal SSTF Disk Seek Time = ",sstfdisktime