def putItem(self, item):
self.cv.acquire()
blocked = False
self.bt = time.time()
while (self.buffer1.size() == 2 and self.buffer2.size() == 2
and self.buffer3.size() == 2):
Shared.log("Inspector 1: blocked")
blocked = True
# calculate time blocked here (can do in inspector1)
self.cv.notifyAll()
self.cv.wait()
if (blocked):
self.blockedTime += time.time() - self.bt
if self.buffer3.size() == 0:
self.buffer3.putItem(item)
elif self.buffer2.size() == 0:
self.buffer2.putItem(item)
elif self.buffer2.size() == 1:
self.buffer2.putItem(item)
elif self.buffer3.size() == 1:
self.buffer3.putItem(item)
else:
self.buffer1.putItem(item)
self.cv.notifyAll()
self.cv.release()
def inspectItem(self, delay):
Shared.log("Inspector 1: Inspecting Item - Time Delay: %s seconds" %
delay)
self.blackbox.inspector1[0].append(time.time())
self.blackbox.system[0].append(time.time())
time.sleep(delay)
self.blackbox.inspector1[1].append(time.time())
self.sendItem()
def run(self):
with open(self.datadir, "r") as data:
for dataline in data:
self.inspectItem(Shared.timeFromString(dataline))
if self.indicator:
break
if not self.indicator:
Shared.log("Inspector 1 is complete.")
self.indicator = True
else:
Shared.log("Inspector 1 has been terminated.")
def inspectItem(self, delay, component):
Shared.log(
"Inspector 2: Inspecting Item {} with Time Delay: {} seconds".
format(component, delay))
self.blackbox.inspector2[0].append(time.time())
self.blackbox.system[0].append(time.time())
time.sleep(delay)
self.blackbox.inspector2[1].append(time.time())
Shared.log("Inspector 2: Finished {}".format(component))
if component == Component.C2:
self.buffer2.putItem(component)
elif component == Component.C3:
self.buffer3.putItem(component)
def processItem(self, t):
item2 = self.buffer2.getItem()
Shared.log("Workstation 3: Got C3")
item1 = self.bufferbox.getItem3()
Shared.log("Workstation 3: Got C1")
Shared.log("Workstation 3 is processing P3 with %f delay" % t)
self.blackbox.workstation3[0].append(time.time())
time.sleep(t)
self.blackbox.workstation3[1].append(time.time())
self.blackbox.system[1].append(time.time())
Shared.log("Workstation 3 made P3")
self.counter += 1
Shared.log("Workstation 3: Made {} so far".format(self.counter))
def putItem(self, item):
self.cv.acquire() # acquire lock
blocked = False
self.bt = time.time()
while self.q.qsize() >= 2:
Shared.log("Inspector 2: blocked")
blocked = True
# calculate time blocked here for inspector2
# calculate inspector2 block time here maybe?
self.cv.wait() # release lock and wait
if (blocked):
self.blockedTime += time.time() - self.bt
self.q.put(item)
if self.name == 2:
self.blackbox.component2[0].append(time.time())
elif self.name == 3:
self.blackbox.component3[0].append(time.time())
self.cv.notifyAll() # notify waiting threads
self.cv.release() # release lock
def run(self):
lst22 = []
lst23 = []
count22 = 0
count23 = 0
with open(self.datadir1, "rt") as data:
for dataline in data:
lst22.append(dataline.strip())
with open(self.datadir2, "rt") as data:
for dataline in data:
lst23.append(dataline.strip())
while count22 < len(lst22) and count23 < len(
lst23) and not self.indicator:
# pick a random number to decide between c2,c3 to inspect
number = random.randint(0, 1)
currentcomponent = self.component[number]
if currentcomponent == Component.C2:
count22 += 1
self.inspectItem(Shared.timeFromString(lst22[count22]),
currentcomponent)
elif currentcomponent == Component.C3:
count23 += 1
self.inspectItem(Shared.timeFromString(lst23[count23]),
currentcomponent)
if not self.indicator:
Shared.log("Inspector 2 is complete.")
self.indicator = True
else:
Shared.log("Inspector 2 has been terminated.")
def run(self):
if self.replications:
print()
print("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print("\t\t\tReplication Data")
print("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print()
for x in range(22):
for thread in range(2, 5):
self.threads[thread].counter = 0
self.threads[0].bufferbox.blockedTime = 0
self.threads[1].buffer2.blockedTime = 0
self.threads[1].buffer3.blockedTime = 0
self.threads[0].bufferbox.bt = time.time()
self.threads[1].buffer2.bt = time.time()
self.threads[1].buffer3.bt = time.time()
t1 = time.time();
tf = Shared.timeFactor
time.sleep(tf/20)
t2 = time.time()
tim = t2 - t1
th2 = tim * tf
th = self.threads[2].counter / th2
th1 = self.threads[3].counter / th2
th3 = self.threads[4].counter / th2
print("%f %f %f %f %f" % (th*60, th1*60, th3*60, (self.threads[0].bufferbox.blockedTime)/th2 * tf, (self.threads[1].buffer2.blockedTime*tf + self.threads[1].buffer3.blockedTime*tf)/th2))
else:
while True:
# checks inspector 1 and 2 if they're done
for thread in range(0, 1):
if self.threads[thread].indicator:
self.isdone = True
break
# if done, get out of the loop
if self.isdone:
break
#array [w1,w2,w3,idle1,idle2]
# print out results
time.sleep(1)
Shared.log("Manufacturer finished.")
Shared.disable()
for thread in range(2, 5):
Shared.log("Workstation {} made {} P{} Product(s)".format(thread - 1, self.threads[thread].counter, thread - 1))
self.blackbox.endTime = time.time()
self.blackbox.roundCheck()
def main():
generatedDataChosen = False
# Prompt user for type of data, generated/given
print("Enter 1 for Given data, 2 to Generate data")
genOrGiven = int(input())
if (genOrGiven == 2):
# print("Deleting previous generated data...")
# shutil.rmtree("data_generated")
# print("Making directory...")
# os.mkdir("data_generated")
print(
"Please enter the preferred size of your data, or 0 to use previously generated data"
)
size = input()
size = int(size)
if size == 0:
pass
else:
# Generated data is created with parameters calculated from the data. The report should contain these values.
writeTo('data_generated/ws1.dat',
'exponential',
size,
mean=4.604417)
writeTo('data_generated/ws2.dat',
'exponential',
size,
mean=11.09261)
writeTo('data_generated/ws3.dat', 'weibull', size, alpha=9, beta=1)
writeTo('data_generated/servinsp1.dat',
'weibull',
size,
alpha=11,
beta=1.2)
writeTo('data_generated/servinsp22.dat',
'exponential',
size,
mean=15.5369)
writeTo('data_generated/servinsp23.dat',
'exponential',
size,
mean=20.63276)
generatedDataChosen = True
print("Enter 1 for Simulation Outputs, 2 for Replication data")
user_input = int(input())
rep = False
if user_input == 2:
print("Enter number of replications:")
replications = int(input())
rep = True
Shared.disable()
else:
replications = 1
replicationsData = []
for x in range(replications):
#Initiate Blackbox
blackbox = Blackbox()
# create buffers for the components. b1,b2,b3 hold C1, b4 holds C2, b5 holds C3
b1 = Buffer(1, blackbox)
b2 = Buffer(2, blackbox)
b3 = Buffer(3, blackbox)
b4 = Buffer23(2, blackbox) # c2 buffer
b5 = Buffer23(3, blackbox) # c3 buffer
# create threads given the buffers
bb = BufferBox(b1, b2, b3)
i1 = Inspector1([Component.C1], bb, blackbox)
i2 = Inspector2([Component.C2, Component.C3], b4, b5, blackbox)
w1 = Workstation1(bb, blackbox)
w2 = Workstation2(bb, b4, blackbox)
w3 = Workstation3(bb, b5, blackbox)
# making the threads daemon, so if one of the threads stop then the program stops
# similar to a manufacturing facility, if they don't have the components then no
# products can be made
i1.daemon = True
i2.daemon = True
w1.daemon = True
w2.daemon = True
w3.daemon = True
# indicator to see when a inspector or workstation has completed their commands
ind = Indicator([i1, i2, w1, w2, w3], blackbox, rep)
if generatedDataChosen:
# set data directory for workstations and inspectors based on generated data
i1.datadir = 'data_generated/servinsp1.dat'
i2.datadir1 = 'data_generated/servinsp22.dat'
i2.datadir2 = 'data_generated/servinsp23.dat'
w1.datadir = 'data_generated/ws1.dat'
w2.datadir = 'data_generated/ws2.dat'
w3.datadir = 'data_generated/ws3.dat'
t1 = time.time()
# # start threads
i1.start()
i2.start()
w1.start()
w2.start()
w3.start()
ind.start()
ind.join()
def run(self):
f = open(self.datadir, "r")
lines = f.readlines()
for line in lines:
self.processItem(Shared.timeFromString(line))
def sendItem(self):
self.bufferbox.putItem(self.component)
Shared.log("Inspect 1: inspected %s" % self.component)
return