def main(processes, messages, runscript, broadcastType, logsDir, testConfig):
# Set tc for loopback
#tc = TC(testConfig['TC'])
#print(tc)
sleepSends = [25, 50]
sleepDelivers = [150, 200, 250, 300, 350]
timeoutAcks = [10, 15]
tries = [2]
numOutstandings = [1400, 1500, 1600]
sleepOutStandings = [50, 100, 150]
best_finish = float('inf')
best_del = 0
best_finish_dict = defaultdict(int)
best_del_dict = defaultdict(int)
for sleepSend in sleepSends:
for sleepDeliver in sleepDelivers:
for timeoutAck in timeoutAcks:
for tri in tries:
for numOutstanding in numOutstandings:
for sleepOutStanding in sleepOutStandings:
print("sleepSend:", sleepSend, flush=True)
print("sleepDeliver:", sleepDeliver, flush=True)
print("timeoutAck:", timeoutAck, flush=True)
print("tries:", tri, flush=True)
print("numOutstanding:", numOutstanding, flush=True)
print("sleepOutStanding:", sleepOutStanding, flush=True)
tot_finishes = []
tot_dels = []
for _ in range(3):
# Start the barrier
initBarrier = barrier.Barrier(BARRIER_IP, BARRIER_PORT, processes)
initBarrier.listen()
startTimesFuture = initBarrier.startTimesFuture()
initBarrierThread = threading.Thread(target=initBarrier.wait)
initBarrierThread.start()
# Start the finish signal
finishSignal = finishedSignal.FinishedSignal(SIGNAL_IP, SIGNAL_PORT, processes)
finishSignal.listen()
finishSignalThread = threading.Thread(target=finishSignal.wait)
finishSignalThread.start()
if broadcastType == "fifo":
validation = FifoBroadcastValidation(processes, messages, logsDir)
else:
validation = LCausalBroadcastValidation(processes, messages, logsDir, None)
hostsFile, configFile = validation.generateConfig()
try:
# Start the processes and get their PIDs
procs = startProcesses(processes, runscript, hostsFile.name, configFile.name, logsDir,
sleepSend, sleepDeliver, timeoutAck, tri, numOutstanding, sleepOutStanding)
# Create the stress test
st = StressTest(procs,
testConfig['ST']['concurrency'],
testConfig['ST']['attempts'],
testConfig['ST']['attemptsDistribution'])
for (logicalPID, procHandle) in procs:
print("Process with logicalPID {} has PID {}".format(logicalPID, procHandle.pid), flush=True)
initBarrierThread.join()
print("All processes have been initialized.", flush=True)
# st.run()
# print("StressTest is complete.")
# print("Resuming stopped processes.")
# st.continueStoppedProcesses()
print("Waiting until all running processes have finished broadcasting.", flush=True)
finishSignalThread.join(1)
if(not finishSignalThread.is_alive()):
finishes = []
for pid, startTs in OrderedDict(sorted(startTimesFuture.items())).items():
print("Process {} finished broadcasting {} messages in {} ms".format(pid, messages, finishSignal.endTimestamps()[pid] - startTs), flush=True)
finishes.append(finishSignal.endTimestamps()[pid] - startTs)
avg_time = np.mean(np.array(finishes))
print("Average time to finished broadcast: {} ms".format(avg_time), flush=True)
tot_finishes.append(avg_time)
else:
tot_finishes.append(1000)
print("Average time to finished broadcast: > 1 seconds", flush=True)
numberDel = []
time.sleep(10)
st.terminateAllProcesses()
time.sleep(3)
for pid in range(1, processes+1):
filePath = os.path.join(logsDir, 'proc{:02d}.stdout'.format(pid))
with open(filePath) as f:
for line in f:
if "Total message delivered: " in line:
tot_del = line.split("Total message delivered: ")[-1].rstrip("\n").rstrip()
print("Process {} delivered {} messages".format(pid, tot_del), flush=True)
numberDel.append(int(tot_del))
break
avg_del = np.mean(np.array(numberDel))
print("Average number of delivered messages: {} ".format(avg_del), flush=True)
tot_dels.append(avg_del)
mutex = threading.Lock()
def waitForProcess(logicalPID, procHandle, mutex):
procHandle.wait()
with mutex:
print("Process {} exited with {}".format(logicalPID, procHandle.returncode), flush=True)
# Monitor which processes have exited
monitors = [threading.Thread(target=waitForProcess, args=(logicalPID, procHandle, mutex)) for (logicalPID, procHandle) in procs]
[p.start() for p in monitors]
[p.join() for p in monitors]
if procs is not None:
for _, p in procs:
p.kill()
# input('Hit `Enter` to validate the output')
# print("Result of validation: {}".format(validation.checkAll()))
finally:
if procs is not None:
for _, p in procs:
p.kill()
full_avg_del = np.mean(np.array(tot_dels))
if (full_avg_del > best_del):
best_del_dict["sleepSend"] = sleepSend
best_del_dict["sleepDeliver"] = sleepDeliver
best_del_dict["timeoutAck"] = timeoutAck
best_del_dict["tries"] = tri
best_del_dict["numOutstanding"] = numOutstanding
best_del_dict["sleepOutStanding"] = sleepOutStanding
print("Best del dict:", best_del_dict, flush=True)
print("Best del:", full_avg_del, flush=True)
best_del = full_avg_del
full_avg_finishes = np.mean(np.array(tot_finishes))
if (full_avg_finishes < best_finish):
best_finish_dict["sleepSend"] = sleepSend
best_finish_dict["sleepDeliver"] = sleepDeliver
best_finish_dict["timeoutAck"] = timeoutAck
best_finish_dict["tries"] = tri
best_finish_dict["numOutstanding"] = numOutstanding
best_finish_dict["sleepOutStanding"] = sleepOutStanding
best_finish = full_avg_finishes
print("Best finish dict:", best_finish_dict, flush=True)
print("Best finish:", full_avg_finishes, flush=True)
print("Best del num: ", best_del, flush=True)
print("Best del dict:", best_del_dict, flush=True)
print("Best finish time: ", best_finish, flush=True)
print("Best finish dict:", best_finish_dict, flush=True)
def main(processes, messages, runscript, broadcastType, logsDir, testConfig):
# Set tc for loopback
tc = TC(testConfig['TC'])
print(tc)
# Start the barrier
initBarrier = barrier.Barrier(BARRIER_IP, BARRIER_PORT, processes)
initBarrier.listen()
startTimesFuture = initBarrier.startTimesFuture()
initBarrierThread = threading.Thread(target=initBarrier.wait)
initBarrierThread.start()
# Start the finish signal
finishSignal = finishedSignal.FinishedSignal(
SIGNAL_IP, SIGNAL_PORT, processes)
finishSignal.listen()
finishSignalThread = threading.Thread(target=finishSignal.wait)
finishSignalThread.start()
if broadcastType == "fifo":
validation = FifoBroadcastValidation(processes, messages, logsDir)
else:
validation = LCausalBroadcastValidation(
processes, messages, logsDir, None)
hostsFile, configFile = validation.generateConfig()
try:
# Start the processes and get their PIDs
procs = startProcesses(processes, runscript,
hostsFile.name, configFile.name, logsDir)
# Create the stress test
st = StressTest(procs,
testConfig['ST']['concurrency'],
testConfig['ST']['attempts'],
testConfig['ST']['attemptsDistribution'])
for (logicalPID, procHandle) in procs:
print("Process with logicalPID {} has PID {}".format(
logicalPID, procHandle.pid))
initBarrierThread.join()
print("All processes have been initialized.")
st.run()
print("StressTest is complete.")
print("Resuming stopped processes.")
st.continueStoppedProcesses()
print("Waiting until all running processes have finished broadcasting.")
finishSignalThread.join()
for pid, startTs in OrderedDict(sorted(startTimesFuture.items())).items():
print("Process {} finished broadcasting {} messages in {} ms".format(
pid, messages, finishSignal.endTimestamps()[pid] - startTs))
unterminated = st.remainingUnterminatedProcesses()
if unterminated is not None:
input('Hit `Enter` to terminate the remaining processes with logicalPIDs {}.'.format(
unterminated))
st.terminateAllProcesses()
mutex = threading.Lock()
def waitForProcess(logicalPID, procHandle, mutex):
procHandle.wait()
with mutex:
print("Process {} exited with {}".format(
logicalPID, procHandle.returncode))
# Monitor which processes have exited
monitors = [threading.Thread(target=waitForProcess, args=(
logicalPID, procHandle, mutex)) for (logicalPID, procHandle) in procs]
[p.start() for p in monitors]
[p.join() for p in monitors]
input('Hit `Enter` to validate the output')
print("Result of validation: {}".format(validation.checkAll()))
finally:
if procs is not None:
for _, p in procs:
p.kill()
def main(processes, messages_avoided, runscript, broadcastType, logsDir, testConfig):
# Set tc for loopback
# tc = TC(testConfig['TC'])
# print(tc)
# windowSize = [100, 500, 1000, 2500, 5000, 10000, 20000]
# initThresh = [100, 500, 1000, 5000, 10000, 50000]
messages_list = [100, 500, 1000, 3000, 5000, 10000, 15000, 30000, 100000, 1000000]
waiting_time = [60, 60, 300, 600, 600, 600, 1200, 1200, 300, 600]
for i, messages in enumerate(messages_list):
tot_finishes = []
tot_dels = []
print("tentative:", i)
print("Messages:", messages)
print("Will wait:", waiting_time[i])
# Start the barrier
initBarrier = barrier.Barrier(BARRIER_IP, BARRIER_PORT, processes)
initBarrier.listen()
startTimesFuture = initBarrier.startTimesFuture()
initBarrierThread = threading.Thread(target=initBarrier.wait)
initBarrierThread.start()
# Start the finish signal
finishSignal = finishedSignal.FinishedSignal(SIGNAL_IP, SIGNAL_PORT, processes)
finishSignal.listen()
finishSignalThread = threading.Thread(target=finishSignal.wait)
finishSignalThread.start()
if broadcastType == "fifo":
validation = FifoBroadcastValidation(processes, messages, logsDir)
else:
validation = LCausalBroadcastValidation(processes, messages, logsDir, None)
hostsFile, configFile = validation.generateConfig()
try:
# Start the processes and get their PIDs
procs = startProcesses(processes, runscript, hostsFile.name, configFile.name, logsDir, i)
# Create the stress test
st = StressTest(procs,
testConfig['ST']['concurrency'],
testConfig['ST']['attempts'],
testConfig['ST']['attemptsDistribution'])
for (logicalPID, procHandle) in procs:
print("Process with logicalPID {} has PID {}".format(logicalPID, procHandle.pid), flush=True)
initBarrierThread.join()
print("All processes have been initialized.", flush=True)
#st.run()
print("StressTest is complete.")
print("Resuming stopped processes.")
st.continueStoppedProcesses()
print("Waiting until all running processes have finished broadcasting.", flush=True)
finishSignalThread.join(1)
if(not finishSignalThread.is_alive()):
finishes = []
for pid, startTs in OrderedDict(sorted(startTimesFuture.items())).items():
print("Process {} finished broadcasting {} messages in {} ms".format(pid, messages, finishSignal.endTimestamps()[pid] - startTs), flush=True)
finishes.append(finishSignal.endTimestamps()[pid] - startTs)
avg_time = np.mean(np.array(finishes))
print("Average time to finished broadcast: {} ms".format(avg_time), flush=True)
tot_finishes.append(avg_time)
else:
tot_finishes.append(1000)
print("Average time to finished broadcast: > 1 seconds", flush=True)
numberDel = []
time.sleep(waiting_time[i])
st.terminateAllProcesses()
time.sleep(3)
for pid in range(1, processes+1):
filePath = os.path.join(logsDir, str(i), 'proc{:02d}.stdout'.format(pid))
with open(filePath) as f:
for line in f:
if "Total message delivered: " in line:
tot_del = line.split("Total message delivered: ")[-1].rstrip("\n").rstrip()
print("Process {} delivered {} messages".format(pid, tot_del), flush=True)
numberDel.append(int(tot_del))
break
avg_del = np.mean(np.array(numberDel))
print("Average number of delivered messages: {} ".format(avg_del), flush=True)
tot_dels.append(avg_del)
mutex = threading.Lock()
def waitForProcess(logicalPID, procHandle, mutex):
procHandle.wait()
with mutex:
print("Process {} exited with {}".format(logicalPID, procHandle.returncode), flush=True)
# Monitor which processes have exited
monitors = [threading.Thread(target=waitForProcess, args=(logicalPID, procHandle, mutex)) for (logicalPID, procHandle) in procs]
[p.start() for p in monitors]
[p.join() for p in monitors]
if procs is not None:
for _, p in procs:
p.kill()
# input('Hit `Enter` to validate the output')
# print("Result of validation: {}".format(validation.checkAll()))
finally:
if procs is not None:
for _, p in procs:
p.kill()
full_avg_del = np.mean(np.array(tot_dels))
print(full_avg_del, flush=True)
full_avg_finishes = np.mean(np.array(tot_finishes))
print(full_avg_finishes, flush=True)
