Question

1 Problems (PY 1. Write a program to simulate a very busy TA in office hours, according to the following specifications. The TA: (a) The TA has a predetermined rate of how fast she can work. (b) The TA has a predetermined amount of time she can hold office hours for. (c) Once the TA starts helping a student, the TA will help the student until their question is answered. (d) The TA can only help one student at a time. The Table: (c) There are only spots for 3 students at a time at the TA's tablc. (f) When a new student comes in and the TA is not busy, the student takes a seat at the table and the TA helps the new student. (g) If a student sitting at the table finishes, the student leaves the resource center entirely. (h) If there are students at the table when the TA's time is done, the TA will help only until the students still sitting at the table are helped (no new students may sit at the table).

Answer 1

'''

Ensure correct tab spacing before you run the program

'''

import time

from threading import Thread, Lock

class Clock:

    #currentTime = 0;

    def run(self):

                    self.currentTime = 0;

                    while(True):

                                    time.sleep(1)

                                    self.currentTime += 1

    def now(self):

                    return self.currentTime

clock = Clock()

class Assistant:

    def __init__(self, pStart, pEnd):

                    self.StartTime = pStart

                    self.EndTime = pEnd

                    self.Speed = 5

                    self.Table = [ None, None, None ]

                    self.Arrivals = []

                    self.CurrentlyHelping = None

                    self.myIdleTime = 0

                   

                    self.mutex = Lock()

    def run(self):

                    self.helpStudent()

                    

    def helpStudent(self):   

                    while(clock.now() < self.EndTime):

                                    if (len(self.Arrivals) ==0 ):

                                                    time.sleep(1)

                                                    self.myIdleTime += 1

                                    else:

                                                    earliest = self.Arrivals.pop(0)

                                                    self.CurrentlyHelping = self.Table[earliest]

                                                    while(self.CurrentlyHelping.getTimeRequired() > 0):

                                                                    time.sleep(1)

                                                   

                                                    self.CurrentlyHelping = None

                                   

                                    

    def getTable(self):

                    return self.Table

                   

    def getEmptySlot(self):

                    try:

                                    slot = self.Table.index(None)

                    except (ValueError):

                                    slot = None

                    return slot

    def getCurrentlyHelping(self):

                    return self.CurrentlyHelping

                   

    def fillSlot(self, pSlot, pStudent):

                    self.mutex.acquire()

                    if (self.Table[pSlot] is None):

                                    self.Table[pSlot] = pStudent

                                    self.Arrivals.append(pSlot)

                                    self.mutex.release()

                                    return True

                    else:

                                    self.mutex.release()

                                    return False

    def getIdleTime(self):

                    return myIdleTime

    def getArrivals(self):

                    return self.Arrivals

                               

#End of TA

resourceCentre = []

waitingResources = 0

totalWaitTime = 0

tableWaitTime = 0

waitingAtTable = 0

class Student:

    def __init__(self, pID, pTimeRequired, pSeekHelpAt,pTA):

                    self.ID = pID

                    self.TimeReq = pTimeRequired

                    self.ApproachTA = pSeekHelpAt

                    self.TA = pTA

                    self.myArrivalTime = None

                    self.mySlot = None

                    self.myWaitTime = 0

                    self.waiting = False

                    

    def run(self):

                    while(clock.now() < self.ApproachTA):

                                    time.sleep(1)

                    self.seekHelp()

    def waitInResourceQueue(self):

                    global waitingResources

                    self.waiting = True;

                    waitingResources += 1

                    while(resourceCentre.index(self) > 0):

                                    time.sleep(1)

                                    self.myWaitTime += 1                

    def seekHelp(self):

                    if (self.TA.getEmptySlot() is None):

                                    resourceCentre.append(self)

                                    self.waitInResourceQueue()

                                   

                    self.mySlot = self.TA.getEmptySlot()

                    while(self.mySlot is None or not self.occupySlot()):

                                    time.sleep(1)

                                    self.mySlot = self.TA.getEmptySlot()

                    

                    if(self.TA.getCurrentlyHelping() != self):

                                    self.solveOnYourOwn()

                   

                    while(self.TimeReq > 0):

                                    time.sleep(1)

                                   self.TimeReq -= 1

                    self.leaveSlot()

  

                    

    def solveOnYourOwn(self):

                    global waitingAtTable

                    global tableWaitTime

                    val = 1

                    waitingAtTable += 1

                    while (self != self.TA.getCurrentlyHelping()):

                                    time.sleep(1)

                                    tableWaitTime += 1

                                    if (val == 0):

                                                    self.TimeReq -= 1

                                                    if (self.TimeReq == 0):

                                                                    return

                                    val = (val + 1)%3

    def occupySlot(self):

                    global totalWaitTime

                    if (not self.TA.fillSlot(self.mySlot, self)):

                                    self.mySlot = None

                                    return False

                    else:

                                    if (self.waiting):

                                                    resourceCentre.pop(0)

                                                    totalWaitTime += self.myWaitTime

                                    self.myArrivalTime = clock.now()

                                    return True

    def getArrivalTime(self):

                    return self.myArrivalTime

                   

    def getTimeRequired(self):

                    return self.TimeReq

                   

    def leaveSlot(self):

                    tbl = self.TA.getTable()

                    tbl[self.mySlot] = None

                   

    def getWaitTime(self):

                    return self.myWaitTime

                               

#End of Student

def main():

    tClock = Thread(name="clock", target=clock.run)

    tClock.start()

    print("Please wait 10 seconds for the output")

    TA = Assistant(0, 10)

    tTA = Thread(name="ta", target=TA.run)

    tTA.start()

    myClass = []

    for i in range(0,25):

                    #pID, pTimeRequired, pSeekHelpAt,pTA

                    obj = Student(i, 4+i%5, 3+i+i, TA)

                    student = Thread(target = obj.run)

                    student.start();

                    myClass.append(student);

    tTA.join()

    #for(student in myClass):

    #             student.join()

    global totalWaitTime, waitingResources, resourceCentre, waitingAtTable, tableWaitTime, resourceCentre

    print("Average wait of resource line: ", totalWaitTime/waitingResources)

    print("Total students remaining in resource Line: ", len(resourceCentre))

    print("Average wait of tables: ", tableWaitTime/waitingAtTable)

    print("Number of students TA was not able to help: ", len(resourceCentre) + len(TA.getArrivals()))

main()