def add_barrier(self, last):
if self.screen_width - last.x > 100 and self.add_barriers == True:
self.barrier_types = [barrier.Barrier(self.screen_width, self.screen_height, last.last, self.openings),
closing_barrier.ClosingBarrier(self.screen_width, self.screen_height, last.last, self.openings),
moving_barrier.MovingBarrier(self.screen_width, self.screen_height, last.last, self.openings)]
if self.num_barriers % 5 == 0:
self.openings -= 10
self.barriers.append(random.choice(self.barrier_types))
self.num_barriers += 1
def level1(self):
barriers = []
barriers.append(barrier.Barrier(0, 70, 600, 10))
barriers.append(barrier.Barrier(0, 145, 420, 10))
barriers.append(barrier.Barrier(520, 145, 550, 10))
barriers.append(barrier.Barrier(0, 225, 550, 10))
barriers.append(barrier.Barrier(0, 305, 250, 10))
barriers.append(barrier.Barrier(350, 305, 250, 10))
barriers.append(barrier.Barrier(475, 315, 10, 70))
barriers.append(barrier.Barrier(100, 385, 600, 10))
return barriers
def __init__(self, height, width):
self.screen_width = width
self.screen_height = height
self.barrier_types = [barrier.Barrier(width, height),
closing_barrier.ClosingBarrier(width, height),
moving_barrier.MovingBarrier(width, height)]
self.barriers = [random.choice(self.barrier_types)]
self.num_barriers = len(self.barriers)
self.openings = 200
self.add_barriers = True
def __init__(self, host, port):
print "Starting poker server..."
self.host = host
self.port = port
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind((self.host, self.port))
self.players = []
self.currentPlayer = 0
self.betToMatch = 0
self.pot = 0
self.deck = dealer.getDeck()
self.barrier = barrier.Barrier(numPlayers)
def level4(self):
barriers = []
barriers.append(barrier.Barrier(0, 70, 155, 10))
barriers.append(barrier.Barrier(250, 0, 10, 80))
barriers.append(barrier.Barrier(260, 70, 140, 10))
barriers.append(barrier.Barrier(390, 80, 10, 110))
barriers.append(barrier.Barrier(490, 70, 210, 10))
barriers.append(barrier.Barrier(0, 145, 250, 10))
barriers.append(barrier.Barrier(85, 225, 220, 10))
barriers.append(barrier.Barrier(85, 235, 10, 150))
barriers.append(barrier.Barrier(95, 300, 300, 10))
barriers.append(barrier.Barrier(95, 375, 500, 10))
barriers.append(barrier.Barrier(485, 265, 10, 110))
barriers.append(barrier.Barrier(485, 185, 110, 10))
barriers.append(barrier.Barrier(585, 265, 10, 110))
return barriers
def level3(self):
barriers = []
barriers.append(barrier.Barrier(90, 0, 10, 233))
barriers.append(barrier.Barrier(180, 70, 10, 233))
barriers.append(barrier.Barrier(90, 303, 100, 10))
barriers.append(barrier.Barrier(90, 383, 190, 10))
barriers.append(barrier.Barrier(270, 70, 10, 90))
barriers.append(barrier.Barrier(360, 70, 210, 10))
barriers.append(barrier.Barrier(280, 150, 280, 10))
barriers.append(barrier.Barrier(560, 150, 10, 80))
barriers.append(barrier.Barrier(560, 190, 140, 10))
barriers.append(barrier.Barrier(280, 230, 290, 10))
barriers.append(barrier.Barrier(270, 230, 10, 80))
barriers.append(barrier.Barrier(360, 310, 10, 80))
barriers.append(barrier.Barrier(370, 310, 330, 10))
return barriers
def level2(self):
barriers = []
barriers.append(barrier.Barrier(105, 110, 305, 10))
barriers.append(barrier.Barrier(410, 70, 200, 10))
barriers.append(barrier.Barrier(410, 80, 10, 110))
barriers.append(barrier.Barrier(600, 80, 10, 200))
barriers.append(barrier.Barrier(105, 190, 315, 10))
barriers.append(barrier.Barrier(105, 200, 10, 200))
barriers.append(barrier.Barrier(205, 280, 10, 120))
barriers.append(barrier.Barrier(205, 270, 215, 10))
barriers.append(barrier.Barrier(410, 280, 10, 90))
barriers.append(barrier.Barrier(420, 360, 90, 10))
barriers.append(barrier.Barrier(460, 360, 10, 110))
barriers.append(barrier.Barrier(510, 200, 10, 170))
barriers.append(barrier.Barrier(520, 280, 90, 10))
barriers.append(barrier.Barrier(610, 360, 90, 10))
return barriers
class Game:
"""Main class controlling the game"""
WINDOW = pygame.display.set_mode(
(constants.GAMEMAP_WIDTH_PX, constants.GAMEMAP_HEIGHT_PX))
SPRITE_SHEET = pygame.image.load(constants.SPRITE_SHEET).convert()
MAP = gamemap.Map(constants.GAMEMAP_FILE)
barrier = barrier.Barrier(list(MAP.get_barriers()))
def __init__(self):
self.tick = 0
self.level = 0
self.score = 0
self.player = None
self.pellets = list(self.MAP.get_pellets())
self.fruit = 0
self.lives = 4
self.combo = 1
self.wait = 0
self.ghosts = {}
self.previous_ghosts_state = constants.SCATTER
def initialize_level(self, next_level):
"""Initializing level after player death or to advance to new level"""
player_x, player_y = self.MAP.get_coordinates('s')
blinky_x, blinky_y = self.MAP.get_coordinates('b')
pinky_x, pinky_y = self.MAP.get_coordinates('p')
inky_x, inky_y = self.MAP.get_coordinates('i')
clyde_x, clyde_y = self.MAP.get_coordinates('c')
self.player = characters.Player(player_x, player_y)
self.ghosts = {
"blinky": characters.Blinky(blinky_x, blinky_y),
"pinky": characters.Pinky(pinky_x, pinky_y),
"inky": characters.Inky(inky_x, inky_y),
"clyde": characters.Clyde(clyde_x, clyde_y),
}
self.combo = 1
self.fruit = 0
self.update_caption()
self.wait = 1
if next_level:
self.pellets = list(self.MAP.get_pellets())
self.draw_walls()
self.draw_pellets()
self.level += 1
self.tick = 0
else:
for ghost in self.ghosts.values():
ghost.state = self.previous_ghosts_state
self.lives -= 1
if self.lives == 0:
drawhelper.draw_text("GAME OVER!")
pygame.display.update()
while True:
events = pygame.event.get()
for event in events:
if event.type == pygame.KEYDOWN:
return
def update_caption(self):
"""Updates caption shown on Application bar"""
pygame.display.set_caption(f"Pacman level: {self.level} "
f"score: {self.score} "
f"lives: {self.lives}")
def remove_pellet(self, tile_x, tile_y):
"""Removes the pellet from given location and returns the value of it"""
try:
tile = next(t for t in self.pellets
if t.x == tile_x and t.y == tile_y)
if tile.cell in [constants.PELLET, constants.PELLET2]:
del self.pellets[self.pellets.index(tile)]
return 10
if tile.cell == constants.POWER_PELLET:
del self.pellets[self.pellets.index(tile)]
return 50
return False
except StopIteration:
return False
def step(self):
"""Step method - executed once every frame"""
start_time = time.time()
if not self.wait:
if self.player.eat(
self,
self.remove_pellet(self.player.get_tile_x(),
self.player.get_tile_y())):
self.spawn_fruit()
if self.next_level():
return (time.time() - start_time) * 1000
else:
self.player.move(self.level)
self.change_ghost_states()
if self.check_collisions():
return (time.time() - start_time) * 1000
for ghost in self.ghosts.values():
ghost.move(self.player, self.ghosts, len(self.pellets),
self.previous_ghosts_state, self.level)
self.draw_fruit()
self.draw_pellets()
self.draw_characters()
pygame.display.update() # room for improvement
self.tick += 1
self.clear_characters()
else:
self.clear_fruit()
self.draw_pellets()
self.draw_characters()
drawhelper.draw_text("R E A D Y !")
pygame.display.update()
events = pygame.event.get()
keys = [pygame.K_RIGHT, 0, pygame.K_LEFT, 0]
for event in events:
if event.type == pygame.KEYDOWN:
if event.key in keys:
self.player.direction = keys.index(event.key)
self.player.next_direction = keys.index(event.key)
self.wait = 0
self.clear_characters()
drawhelper.clear_text()
return (time.time() - start_time) * 1000
def check_collisions(self):
"""Check for collisions of player with any of the ghosts"""
for ghost in self.ghosts.values():
if not ghost.dead:
if ghost.get_tile_x() == self.player.get_tile_x():
if ghost.get_tile_y() == self.player.get_tile_y():
if ghost.state == constants.FRIGHTENED:
self.score += 200 * self.combo
self.combo *= 2
self.update_caption()
ghost.dead = True
ghost.update_target(self.player, self.ghosts)
else:
self.initialize_level(False)
return True
return False
def next_level(self):
"""Checks if no pellets are left and moves to next level"""
if not self.pellets:
self.initialize_level(True)
return True
return False
def change_ghost_states(self):
"""Operates the ghost state cycle rotation"""
if self.player.fright > 0:
self.player.fright -= 1
else:
if any(g for g in self.ghosts.values()
if g.state == constants.FRIGHTENED):
for ghost in self.ghosts.values():
ghost.change_state(self.previous_ghosts_state)
cycle_times = constants.get_level_based_constant(
self.level, constants.GHOST_MODE_CYCLE)
second = self.tick / constants.TICKRATE - \
self.player.power_pellets * \
constants.get_level_based_constant(self.level,
constants.FRIGHT_TIME)
if second in cycle_times:
cycle = cycle_times.index(second)
new_state = constants.SCATTER if cycle % 2 else constants.CHASE
self.previous_ghosts_state = new_state
for ghost in self.ghosts.values():
ghost.change_state(new_state)
def draw_walls(self):
"""Draws all the map walls depending on wall types"""
for wall_x, wall_y, wall_type in self.MAP.get_walls():
{
0: lambda x, y: drawhelper.draw_arc(x + .5, y + .5, 1 / 2, 1),
1: lambda x, y: drawhelper.draw_arc(x - .5, y + .5, 0, 1 / 2),
2: lambda x, y: drawhelper.draw_arc(x - .5, y - .5, 3 / 2, 0),
3: lambda x, y: drawhelper.draw_arc(x + .5, y - .5, 1, 3 / 2),
4: lambda x, y: drawhelper.draw_line(x + .5, y, x + .5, y + 1),
5: lambda x, y: drawhelper.draw_line(x, y + .5, x + 1, y + .5),
}[wall_type](wall_x, wall_y)
pygame.display.update()
def draw_characters(self):
"""Draws barrier, player and all the ghosts"""
self.barrier.draw()
self.player.draw(self.tick)
for ghost in self.ghosts.values():
ghost.draw(self.tick, self.player.fright)
def clear_characters(self):
"""Clears barrier, player and all the ghosts"""
self.barrier.clear()
self.player.clear()
for ghost in self.ghosts.values():
ghost.clear()
def spawn_fruit(self):
"""Spawn fruits when enough pellets are eaten"""
pellets = len(self.pellets)
if self.MAP.total_pellets - pellets in constants.FRUIT_SPAWN:
self.fruit = random.randint(9 * constants.TICKRATE,
10 * constants.TICKRATE)
def draw_fruit(self):
"""Draws fruit on game window"""
if self.fruit > 0:
fruit_x, fruit_y = self.MAP.get_coordinates('f')
fruit_image_col = constants.get_level_based_constant(
self.level, constants.FRUITS)[0]
offset = constants.TILE_SIZE / 2 - constants.SPRITE_SIZE / 2
self.WINDOW.blit(
drawhelper.get_image_at(fruit_image_col,
constants.FRUIT_IMAGE_ROW),
((fruit_x + 0.5) * constants.TILE_SIZE + offset,
fruit_y * constants.TILE_SIZE + offset))
self.fruit -= 1
if self.fruit == 0:
self.clear_fruit()
def clear_fruit(self):
"""Clears fruit"""
fruit_x, fruit_y = self.MAP.get_coordinates('f')
offset = (constants.TILE_SIZE - constants.SPRITE_SIZE) / 2
if self.fruit == 0:
drawhelper.draw_rect(fruit_x + 0.5,
fruit_y,
constants.SPRITE_SIZE,
offset=offset)
def draw_pellets(self):
"""Draws all pellets"""
tile_size = constants.TILE_SIZE
size = tile_size / 8
offset = tile_size / 2 - size / 2
for pellet in self.pellets:
pellet_x, pellet_y, pellet_type = dataclasses.astuple(pellet)
if pellet_type in [constants.PELLET, constants.PELLET2]:
drawhelper.draw_rect(pellet_x,
pellet_y,
size,
offset=offset,
color=constants.PELLET_COLOR)
elif pellet_type == constants.POWER_PELLET:
pygame.draw.circle(self.WINDOW, constants.PELLET_COLOR,
(int((pellet_x + 0.5) * tile_size),
int((pellet_y + 0.5) * tile_size)),
int(size * 2))
def level7(self):
barriers = []
barriers.append(barrier.Barrier(80, 70, 10, 250))
barriers.append(barrier.Barrier(90, 240, 100, 10))
barriers.append(barrier.Barrier(190, 70, 10, 320))
barriers.append(barrier.Barrier(80, 390, 540, 10))
barriers.append(barrier.Barrier(285, 235, 10, 70))
barriers.append(barrier.Barrier(285, 305, 420, 10))
barriers.append(barrier.Barrier(285, 70, 10, 85))
barriers.append(barrier.Barrier(285, 155, 155, 10))
barriers.append(barrier.Barrier(440, 155, 10, 70))
barriers.append(barrier.Barrier(375, 70, 195, 10))
barriers.append(barrier.Barrier(570, 70, 10, 155))
return barriers
def level6(self):
barriers = []
barriers.append(barrier.Barrier(80, 70, 195, 10))
barriers.append(barrier.Barrier(80, 80, 10, 70))
barriers.append(barrier.Barrier(80, 230, 10, 240))
barriers.append(barrier.Barrier(170, 80, 10, 310))
barriers.append(barrier.Barrier(170, 390, 155, 10))
barriers.append(barrier.Barrier(405, 0, 10, 80))
barriers.append(barrier.Barrier(300, 150, 310, 10))
barriers.append(barrier.Barrier(600, 70, 10, 80))
barriers.append(barrier.Barrier(290, 150, 10, 90))
barriers.append(barrier.Barrier(290, 240, 220, 10))
barriers.append(barrier.Barrier(290, 315, 310, 10))
barriers.append(barrier.Barrier(600, 240, 10, 230))
barriers.append(barrier.Barrier(450, 390, 150, 10))
return barriers
def init_barriers(height, width):
height = convertEv(height)
return np.array([barrier.Barrier(height, width) for i in range(0, 4)])
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 __init__(self, filename):
# Class variables
self.immobileList = pygame.sprite.RenderPlain()
self.doorList = pygame.sprite.RenderPlain()
orig = (TILE_SIZE, TILE_SIZE)
self.startList = [orig for i in range(MAX_PLAYERS + 1)]
self.monsterList = pygame.sprite.RenderPlain()
# Attempt to load the map file
try:
fullName = filename
mapFile = open(fullName)
except:
raise TypeError, "Map file %s could not be loaded." % filename
# Read the lines of the map file
mapLines = mapFile.readlines()
mapStarted = False
lineNum = 1
x = 0
y = 0
# Parse each line separately
for line in mapLines:
# Check if we have started reading the map tiles
if mapStarted:
#try:
x = 0
for tile in line.split():
if tile[0] == '*':
newWall = barrier.Barrier((x, y))
self.immobileList.add(newWall)
elif tile == '.':
pass
elif tile == 'D':
newDoor = barrier.Door((x, y))
self.doorList.add(newDoor)
self.immobileList.add(newDoor)
elif tile[0] == 'P':
#set the starting point
if tile[1] == '#':
self.startList[0] = [x, y]
for startPos in range(len(self.startList)):
if self.startList[startPos] == orig:
self.startList[startPos] = [x, y]
else:
self.startList[int(tile[1])] = [x, y]
elif tile[0] == '!':
# Powerup
newItem = item.Item([x, y], int(tile[1]))
self.immobileList.add(newItem)
elif tile[0] == 'M':
# Monster
global nextid
nextid += 1
self.monsterList.add \
(character.Character([x,y],MONSTER_CLASS + int(tile[1]),nextid))
elif tile[0] == 'G':
# Generator
global nextid
nextid += 1
genLevel = 3
newGenerator = monstergenerator.MonsterGenerator\
([x,y],GENERATOR_CLASS + int(tile[1]), \
genLevel, nextid)
self.monsterList.add(newGenerator)
elif tile[0] == 'X':
# Exit or teleporter
if tile[1] == '0':
#teleporter
pass
else:
#exit
newExit = exit.Exit([x, y], int(tile[1]))
self.immobileList.add(newExit)
pass
else:
#default to clear for now
pass
x += TILE_SIZE
y += TILE_SIZE
#except:
pass
elif line.startswith('author'):
self.author = line[7:-2]
else:
# Try to get the map size
try:
lineList = line.split()
self.width = int(lineList[0])
self.height = int(lineList[1])
mapStarted = True
except ValueError:
mapStarted = False
# Keep track of the line number for error messages
lineNum += 1
def reset(self):
self.barriers = [barrier.Barrier(self.screen_width, self.screen_height)]
self.opening = 150
def level5(self):
barriers = []
barriers.append(barrier.Barrier(0, 70, 300, 10))
barriers.append(barrier.Barrier(400, 0, 10, 120))
barriers.append(barrier.Barrier(500, 110, 110, 10))
barriers.append(barrier.Barrier(600, 120, 10, 65))
barriers.append(barrier.Barrier(90, 185, 520, 10))
barriers.append(barrier.Barrier(435, 195, 10, 80))
barriers.append(barrier.Barrier(90, 265, 250, 10))
barriers.append(barrier.Barrier(150, 275, 10, 100))
barriers.append(barrier.Barrier(90, 375, 310, 10))
barriers.append(barrier.Barrier(190, 385, 10, 80))
barriers.append(barrier.Barrier(535, 265, 65, 10))
barriers.append(barrier.Barrier(600, 265, 10, 110))
barriers.append(barrier.Barrier(500, 375, 110, 10))
return barriers
def level8(self):
barriers = []
barriers.append(barrier.Barrier(90, 160, 10, 225))
barriers.append(barrier.Barrier(100, 240, 155, 10))
barriers.append(barrier.Barrier(255, 80, 10, 80))
barriers.append(barrier.Barrier(255, 160, 100, 10))
barriers.append(barrier.Barrier(345, 90, 10, 70))
barriers.append(barrier.Barrier(345, 80, 160, 10))
barriers.append(barrier.Barrier(495, 90, 10, 70))
barriers.append(barrier.Barrier(495, 160, 90, 10))
barriers.append(barrier.Barrier(585, 160, 10, 170))
barriers.append(barrier.Barrier(345, 240, 10, 230))
barriers.append(barrier.Barrier(585, 410, 10, 60))
barriers.append(barrier.Barrier(590, 80, 110, 10))
return barriers
if get_mac() == 154505288144005:
root_dir = "/tmp/"
else:
root_dir = "/root/trading_data/"
trade_logger = setup_logger('first_logger', root_dir + "prediction_pairs_output.log")
x1 = breakout_process.Breakout() # bad
x2 = volatility_process.VolatilityProcess()# bad
x3 = delta_process.DeltaProcess()#-2.17
x4 = jump_process.JumpProcess()#okay
x5 = create_regimes.CreateRegimes() # good
x6 = gradient.Gradient()# good
x7 = gradient.Gradient()#
x8 = barrier.Barrier()# excellent
x9 = barrier.Barrier()#
x10 = grid_delta.GridDelta()# okay
x11 = markov_process.MarkovProcess()
x_sets = [x5, x2, x4, x11, x10, x6]
lags = [0, 0, 0, 0, 0, 96]
white_list = pickle.load(open(root_dir + "scalper_model_whitelist", 'rb'))
model_prediction_set = []
prediction_key_map = {}
for item in white_list:
def level9(self):
barriers = []
barriers.append(barrier.Barrier(90, 80, 10, 300))
barriers.append(barrier.Barrier(190, 120, 10, 250))
barriers.append(barrier.Barrier(190, 110, 400, 10))
barriers.append(barrier.Barrier(590, 110, 10, 260))
barriers.append(barrier.Barrier(590, 450, 10, 50))
barriers.append(barrier.Barrier(390, 370, 10, 150))
barriers.append(barrier.Barrier(290, 280, 100, 10))
barriers.append(barrier.Barrier(290, 200, 10, 80))
barriers.append(barrier.Barrier(300, 200, 200, 10))
barriers.append(barrier.Barrier(490, 210, 10, 160))
barriers.append(barrier.Barrier(300, 360, 190, 10))
return barriers
def train_and_back_test_stat_arb(trade_logger, model_key, pair,
is_use_residual, martingale_type,
global_currency_pairs, avg_spreads,
avg_prices, entry_bias, trade_dir,
is_train_model, root_dir):
print model_key, root_dir
trade_logger.info('Model Key: ' + model_key)
norm_prices = pickle.load(
open(root_dir + "stat_arb_series_" + model_key, 'rb'))
times = {model_key: [1] * len(norm_prices[model_key])}
portfolio_wts = pickle.load(
open(root_dir + "portfolio_wts_" + model_key, 'rb'))
if "_basket" in model_key:
portfolio_pairs = [pair]
actual_prices = pickle.load(
open(root_dir + "actual_price_series_" + model_key, 'rb'))
prices1, y1 = get_basket_series(norm_prices[model_key],
actual_prices[model_key])
if pair[4:7] == 'JPY':
pip_size = 0.01
else:
pip_size = 0.0001
commission = avg_spreads[pair] * pip_size
else:
portfolio_pairs = portfolio_wts[model_key]['currency_pairs']
prices1, y1 = get_portfolio_series(norm_prices[model_key])
commission = 0
for currency_pair in portfolio_wts[model_key]['wt']:
if currency_pair[4:7] == 'JPY':
pip_size = 0.01
else:
pip_size = 0.0001
commission += abs(
portfolio_wts[model_key]['wt'][currency_pair]) * (
avg_spreads[currency_pair] * pip_size)
x1 = breakout_process.Breakout() # bad
x2 = volatility_process.VolatilityProcess() # bad
x3 = delta_process.DeltaProcess() #-2.17
x4 = jump_process.JumpProcess() #okay
x5 = create_regimes.CreateRegimes() # good
x6 = gradient.Gradient() # good
x7 = gradient.Gradient() #
x8 = barrier.Barrier() # excellent
x9 = barrier.Barrier() #
x10 = grid_delta.GridDelta() # okay
x11 = markov_process.MarkovProcess()
x_sets = [x5, x2, x4, x11, x10, x6]
lags = [0, 0, 0, 0, 0, 96]
whitelist = []
for model, lag in zip(x_sets, lags):
model_key_base = model_key + "_" + str(
model.__class__.__name__) + "_" + str(lag)
if lag == 0:
predictions, test_prices = model.init(root_dir, model_key, None,
prices1, y1, None,
is_use_residual,
is_train_model)
else:
predictions, test_prices = model.init(root_dir, model_key, None,
prices1, y1, None, lag,
is_use_residual,
is_train_model)
if "_basket" in model_key:
test_prices = find_market_prices(actual_prices[model_key], y1)
if predictions == None:
print "not found", model_key_base
continue
equity_curve, returns, rating, draw_down, avg_profit, closed_profits, replay_trades, closed_times = back_test_strategy(
times[model_key], martingale_type, entry_bias, trade_dir,
predictions, test_prices, 1, commission, model_key)
if len(closed_profits) > 1:
sharpe_all = (float(np.mean(closed_profits)) /
np.std(closed_profits))
else:
sharpe_all = 0
from sklearn.linear_model import LinearRegression
reg = LinearRegression().fit([[v] for v in range(len(equity_curve))],
equity_curve)
y_pred = reg.predict([[v] for v in range(len(equity_curve))])
r2 = r2_score(equity_curve, y_pred)
trade_logger.info(
str(model_key_base) + " " + str(sharpe_all) + " " + str(r2) + " " +
str(portfolio_wts))
if sharpe_all < 0.0 and False:
equity_curve = None
else:
print model_key_base, sharpe_all, r2, np.median(
closed_profits), np.mean(closed_profits)
whitelist.append({
"is_use_residual": is_use_residual,
"closed_times": closed_times,
"closed_profits": closed_profits,
"replay_trades": replay_trades,
"prediction_key": model_key,
"model_key": model_key_base,
"wts": portfolio_wts[model_key]['wt'],
"currency_pairs": portfolio_pairs,
"num_trades": len(closed_profits),
"r2_score": r2,
"martingale_type": martingale_type,
"draw_down": draw_down,
"avg_profit": avg_profit,
"equity_curve": equity_curve,
"sharpe": sharpe_all,
"entry_bias": entry_bias,
"trade_dir": trade_dir
})
return whitelist
def level10(self):
barriers = []
barriers.append(barrier.Barrier(80, 70, 540, 10))
barriers.append(barrier.Barrier(610, 80, 10, 315))
barriers.append(barrier.Barrier(80, 150, 450, 10))
barriers.append(barrier.Barrier(80, 160, 10, 80))
barriers.append(barrier.Barrier(90, 230, 40, 10))
barriers.append(barrier.Barrier(520, 160, 10, 80))
barriers.append(barrier.Barrier(230, 230, 180, 10))
barriers.append(barrier.Barrier(410, 230, 10, 90))
barriers.append(barrier.Barrier(80, 310, 220, 10))
barriers.append(barrier.Barrier(290, 320, 10, 80))
barriers.append(barrier.Barrier(80, 400, 10, 70))
barriers.append(barrier.Barrier(80, 390, 100, 10))
barriers.append(barrier.Barrier(300, 390, 110, 10))
barriers.append(barrier.Barrier(400, 400, 10, 70))
barriers.append(barrier.Barrier(420, 310, 100, 10))
barriers.append(barrier.Barrier(520, 310, 10, 80))
return barriers
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)
