def get_results(width, height, color, material, num_of_masters):
if material == 'parquet':
floor = ParquetFloor(width, height, color)
master = Master(num_of_masters)
return floor.price() + master.price_of_masters
elif material == 'wooden':
floor = WoodenFloor(width, height, color)
master = Master(num_of_masters)
return floor.price() + master.price_of_masters
def run(name, ip, port, logging_level):
logger = init_logger(name, logging_level)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
# add write service to replica to handle database updates from master
write_service = WriteService(name, logger=logger)
search_pb2_grpc.add_DatabaseWriteServicer_to_server(write_service, server)
write_service = WriteService(name, logger=logger)
search_pb2_grpc.add_DatabaseWriteServicer_to_server(write_service, server)
# the dynamic replica need to query the backup hence doesn't need to know who the backup is
master = Master(name, ip, None, logging_level)
search_pb2_grpc.add_SearchServicer_to_server(master, server)
search_pb2_grpc.add_HealthCheckServicer_to_server(master, server)
search_pb2_grpc.add_ReplicaUpdateServicer_to_server(master, server)
search_pb2_grpc.add_ReplicaCreationServicer_to_server(master, server)
print("Starting replica " + name)
server.add_insecure_port('[::]:' + port)
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
master.logger.info("Shutting down server")
logging.shutdown()
server.stop(0)
def run(master_server_ip, own_ip, crawler, logging_level, backup_port):
retries = 0
logger = init_logger('backup', logging_level)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
# add write service to backup server to handle database updates from crawler
write_service = WriteService('backup', logger=logger)
search_pb2_grpc.add_DatabaseWriteServicer_to_server(write_service, server)
master = Master("backup", own_ip, None, logging_level)
search_pb2_grpc.add_ReplicaUpdateServicer_to_server(master, server)
server.add_insecure_port('[::]:' + backup_port)
server.start()
try:
thread.start_new_thread(sendHeartBeatMessage, (
master_server_ip,
server,
master,
logger,
crawler,
logging_level,
))
except Exception as e:
print str(e)
logger.error("Cannot start new thread due to " + str(e))
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
logger.info("Shutting down server")
logging.shutdown()
server.stop(0)
def refresh_pos():
# global明示しないとlocalになる
global master, order
master = Master()
order = Order(master.item_master)
# print(order.df)
return master, order
def master_serve(server, own_ip, db_name, logging_level):
# NOTE: backup doesn't have a backup
# TODO: Sync with crawler and master metadata
master = Master(db_name, own_ip, None, logging_level)
search_pb2_grpc.add_SearchServicer_to_server(master, server)
search_pb2_grpc.add_HealthCheckServicer_to_server(master, server)
print("Starting master")
try:
thread.start_new_thread(updateReplicaAndBackup, (master, ))
except Exception as e:
print str(e)
master.logger.error("Cannot start new thread due to " + str(e))
try:
thread.start_new_thread(sendHeartbeatsToReplicas, (
db_name,
master,
))
except Exception as e:
print str(e)
master.logger.error("Cannot start new thread due to " + str(e))
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
master.logger.info("Shutting down server")
logging.shutdown()
server.stop(0)
def main():
parser = argparse.ArgumentParser(description="Python Phone")
parser.add_argument("--srv",
dest="srv",
action="store_true",
help="Start the server")
parser.add_argument("--call", dest="hostname", help="Call a hostname")
parser.add_argument("--dev",
dest="devices",
action="store_true",
help="List devices")
args = parser.parse_args()
master = Master()
if args.devices:
p = pyaudio.PyAudio()
i = 0
while True:
try:
print "{0}: {1}".format(i,
p.get_device_info_by_index(i)['name'])
i += 1
except:
break
if args.srv:
master.serve()
elif args.hostname:
master.call(args.hostname, Config.port)
else:
print "Please specify either --srv or --call."
def test_Distribute():
#initilalize master node
CNN = [{
"l_type": "conv",
"kernel": "W1",
"hparams": {
"stride": 1,
"pad": 0
}
}, {
"l_type": "max",
"hparams": {
"stride": 1,
"f": 2
}
}]
nodes = [{"ip": "localhost", "port": 9998}]
edge = {"ip": "localhost", "port": 9000}
image = np.array([1, 2])
master_node = Master(CNN, nodes, edge, image)
np.random.seed(1)
X1 = np.random.randn(1, 3, 3, 1)
out = vecConv(X1[0, :, :, :], kernels["W1"], {"stride": 1, "pad": 0})
out2 = master_node.thread_Compute(X1, CNN[0])
np.testing.assert_array_equal(out2, out)
def __init__(self, amount):
self.masters = list()
for _ in range(0, amount):
mas = Master(int(random.random() * (self.MAX_SALARY -
self.MIN_SALARY + 1) + self.MIN_SALARY))
self.masters.append(mas)
self.queue = deque()
self.wentAway = 0
self.completedRequests = 0
def RELOCATE_HEADER(self, filename, directory):
if not type(filename) is str:
raise Error(
'RELOCATE_HEADER(): filename parameter must be a string')
if not type(directory) in (list, tuple):
raise Error(
'RELOCATE_HEADER(): directory parameter must be list or tuple')
self.__dirbuilder.add_builder(Master(filename, directory))
pass
def creat_master(m_setting, screen, ship, masters):
ship = Ship(screen)
master = Master(m_setting, screen)
ship_height = ship.rect.height
master_width = master.rect.width
master_height = master.rect.height
avaliable_x = m_setting.screen_width - 2 * master_width
avaliable_y = m_setting.screen_length - 3 * master_height - ship_height
number_x = avaliable_x / (2 * master_width)
number_y = int(avaliable_y / (2 * master_height))
for master_y in range(number_y):
for master_nmber in range(int(number_x)):
master = Master(m_setting, screen)
master.x = master_width + 2 * master_width * master_nmber
master.y = master_height + 2 * master.rect.height * master_y
master.rect.x = master.x
master.rect.y = master.y
masters.add(master)
def main():
master = Master(800, 800, img_size)
setup_road_network(master)
try:
master.run_simulation()
except KeyboardInterrupt:
pass
def test(seed):
random.seed(seed)
master = Master()
numbers = set()
for i in range(90):
number = master.next_number()
assert type(number) is int
assert 0 < number < 91
assert number not in numbers
numbers.add(number)
def getSolution(problem, processCount):
# single-process program
if processCount == 1:
solver = Serial(problem)
# multi-process program
else:
workerCount = processCount - 1
solver = Master(problem, workerCount)
# get solution using correct solver
return solver.solve()
def main():
pool = Pool(size=100)
greenlets = []
master = Master(MASTER_SERVER)
for appid in APPIDS:
for addr in master.get_servers(appid=appid):
greenlets.append(pool.spawn(fetch_server, addr))
greenlets = [greenlet.get() for greenlet in greenlets]
servers = sorted(filter(None, greenlets),
key=lambda x: (x['gamedir'], x['hostname'].lower()))
with codecs.open('servers.json', 'w', 'utf8') as f:
f.write(json.dumps(servers))
def __init__(self, k):
# Pointers to root, and solution nodes; initially None
self.root = None
self.solution = None
self.M = Master(k)
# List of values already visited and discovered
self.visited = []
self.bfs_disc_val = []
# Queue of nodes to visit in BFS
self.bfs_queue = []
def init_master():
itr = RoundRobinIter()
cservers = [
ChunkServer(env=MemEnv()),
ChunkServer(env=MemEnv()),
ChunkServer(env=MemEnv())
]
m = Master(
chunk_server_iter=itr,
chunk_servers=cservers
)
return m
def main():
my_state = InternalState()
init()
logging.info('start service ...')
try:
while (my_state.state is not STATE_MASTER):
client = Client()
my_state = client.run(4, my_state)
master = Master()
master.run(my_state)
except KeyboardInterrupt:
sys.exit()
def setUp(self):
"""
var setups
"""
self.master_config = '../../docs/config/my_master.json'
self.slave_config = '../../docs/config/my_slave.json'
self.base = None
self.conn = None
self.mast = None
self.base = BaseDB()
self.base.load_config(self.master_config)
self.conn, db, t = self.base.connect_server()
self.mast = Master(self.conn)
def __init__(self):
self.parse_options()
if self.mode == 'client':
client = Client()
client.standby()
elif self.mode == 'master':
master = Master()
master.start()
elif self.mode == 'server':
server = Server()
server.standby()
else:
BenchResultsParser()
def setUp(self):
'''
Mock redis constructors, AsyncPubSub constructor, schema methods, and config file
'''
self.redis_cli_mock = Mock()
self.redis_mock = Mock(return_value=self.redis_cli_mock)
self.pubsub_cli_mock = Mock()
self.pubsub_mock = Mock(return_value=self.pubsub_cli_mock)
with patch('master.config', CONFIG, create=True):
with patch('redis.StrictRedis', self.redis_mock, create=True):
with patch('master.AsyncPubSub', self.pubsub_mock,
create=True):
with patch('schema.Monaco', create=True):
with patch('schema.MonacoJobQueue', create=True):
self.lp_mock = Mock()
self.master = Master(self.lp_mock)
def run():
args = argparser()
path = utils.create_log_dir(sys.argv)
utils.start(args.http_port)
env = Env(args)
agents = [Agent(args) for _ in range(args.n_agent)]
master = Master(args)
for agent in agents:
master.add_agent(agent)
master.add_env(env)
success_list = []
time_list = []
for idx in range(args.n_episode):
print('=' * 80)
print("Episode {}".format(idx + 1))
# 서버의 stack, timer 초기화
print("서버를 초기화하는중...")
master.reset(path)
# 에피소드 시작
master.start()
# 에이전트 학습
master.train()
print('=' * 80)
success_list.append(master.infos["is_success"])
time_list.append(master.infos["end_time"] - master.infos["start_time"])
if (idx + 1) % args.print_interval == 0:
print("=" * 80)
print("EPISODE {}: Avg. Success Rate / Time: {:.2} / {:.2}".format(
idx + 1, np.mean(success_list), np.mean(time_list)))
success_list.clear()
time_list.clear()
print("=" * 80)
if (idx + 1) % args.checkpoint_interval == 0:
utils.save_checkpoints(path, agents, idx + 1)
if args.visual:
visualize(path, args)
print("끝")
utils.close()
def __init__(self):
master = Master(20)
for i in range(1, 101):
t = Task()
t.setId(i)
t.setName("任务" + str(i))
t.setPrice(random()*1000)
master.submit(t)
master.execute()
start = time.time()
res = master.get_results()
while True:
if master.is_complete():
end = time.time() - start
print(master.get_results())
break
def evo_main():
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
logging.basicConfig(level=logging.DEBUG, format=f'[%(asctime)s][rank {rank}] %(message)s')
pa = ProgramArguments(rank)
gpu_fix(pa.args.gpu_ram)
if rank == 0:
max_rank: int = comm.Get_size()
cute: Cute = Cute(pa)
master = Master(cute, comm, max_rank)
master.run()
else:
worker = Worker(rank, comm)
worker.run()
def main(arguments):
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('-i', '--infile', help="Input file", type=str)
parser.add_argument('-o', '--outfile', help="Output file", type=str)
parser.add_argument('-g', '--gateway', help="Gateway", type=str)
parser.add_argument('-f',
'--force-gateway',
help="Force gateway",
action="store_true")
args = parser.parse_args(arguments)
infile = INFILE if args.infile is None else args.infile
outfile = OUTFILE if args.outfile is None else args.outfile
master = Master()
master.from_file(infile)
master.to_file(outfile, args.gateway, args.force_gateway)
def main():
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
create_str = "Kreiran procesor " + str(rank) + " ukupno: " + str(size)
print(create_str, flush=True)
comm.barrier()
if rank == 0:
processor = Master(rank, size, comm)
game = processor.create_game()
Master.start_working(game)
elif rank is not 0:
processor = Worker(rank, size, comm)
processor.do_the_work()
def main():
parser = ArgumentParser()
parser.add_argument('--cfg',
type=str,
required=True,
help="big daddy config file")
args = parser.parse_args()
with open(args.cfg) as f:
cfg = yaml.safe_load(f)
# print(rank, socket.gethostname())
rank = MPI.COMM_WORLD.Get_rank()
if rank == 0:
m = Master(cfg)
m.main()
else:
w = Worker(cfg)
w.main()
def launch(max_size=None, verbose=0):
"""
Launch all machines
Params:
:max_size -- int: max_size of each machine
:verbose -- int: level of verbose
Return:
:manager -- Manager: an instance of the memory manager
"""
rank = MPI.COMM_WORLD.Get_rank()
if (rank == 0):
return Manager()
elif rank == 1:
Master(max_size).run(verbose)
else:
Slave(rank, max_size).run(verbose)
exit(0)
def __init__(self, n_mappers, n_reducers, input_path, map_func, reduce_func, kill_idx=-1):
'''
Acts as an intermediate between Master and user program
Responsible for spawning the Master worker
Args:
1. n_mappers/n_reducers - number of wrokers for each phase
2. input_path - disk location of the input file
3. map_func - handle for UDF map function
4. reduce_func - handle for UDF map function
5. kill_idx - specifies the worker to be killed; used to simulate fault tolerance when >= 0
'''
self.job_id = f'{int(time())}'
if ospath.isdir(f'./tmp/{self.job_id}'):
i = 1
while ospath.isdir(f'./tmp/{self.job_id}-{i}'):
i += 1
self.job_id += f'-{i}'
#get the number of cpu cores
n_processes = mp.cpu_count()
#adjust num_mappers and num_reducers according to num_cpu_cores
self.M, self.R = min(n_mappers, n_processes), min(n_reducers, n_processes)
print(f"Starting Job ID #{self.job_id} (M={self.M}, R={self.R})\n")
# Create a temp directory for intermediate files
self.TMP_DIR = f'./tmp/{self.job_id}'
# Create an output directory for final reducer files
self.OUT_DIR = f'./output/{self.job_id}'
pathlibpath(ospath.dirname(
f'{self.TMP_DIR}/')).mkdir(parents=True, exist_ok=True)
# Get the list of input file paths; split data into intermediate files, if required
input_files = self.__get_input_splits(input_path)
# Initialize master
self.master = Master(self.M, self.R, input_files, self.TMP_DIR, self.OUT_DIR)
# Transfer control to master and execute MapReduce
self.master.execute(map_func, reduce_func, kill_idx=kill_idx)
# Prints output directory and returns the path
print("\n{} output file(s) written to {}/\n".format(self.R, ospath.abspath(self.OUT_DIR)))
def run_game():
pygame.init()
m_setting = Setting()
screen = pygame.display.set_mode(
(m_setting.screen_width, m_setting.screen_length))
ship = Ship(screen)
i_word = Word(screen)
bullets = Group()
stats = GameStats(m_setting)
masters = Group()
master = Master(m_setting, screen)
fn.creat_master(m_setting, screen, ship, masters)
play_button = Button(m_setting, screen, 'PLAY')
pygame.display.set_caption('Hello Game')
while True:
fn.check_events(m_setting, screen, stats, play_button, ship, masters,
bullets)
if stats.game_active:
ship.updatemo()
fn.bullet_up(m_setting, screen, ship, masters, bullets)
fn.update_mon(m_setting, stats, screen, ship, masters, bullets)
fn.update(m_setting, screen, ship, bullets, masters, play_button,
stats)
pygame.display.flip()
def run(self):
print "Test: starting emulation"
# Single shuffle (one-to-many)
num_transfers = 1
size = 1024 * 1024 * 10
transfers = self.genShuffleTransfers(nodes[0], nodes, num_transfers,
size)
# Parallel shuffle (many-to-many)
# num_transfers = 1
# size = 1024
# transfers = []
# for mapper in nodes:
# transfers += self.genShuffleTransfers(mapper, nodes, num_transfers,size)
# start master
if host in master:
m = Master(host, nodes)
m.start()
# start slaves
if host in nodes:
s = Slave(host, master, nodes, transfers)
s.start()
if host in nodes:
s.join()
if host in master:
m.join()
outfile = open("./output/done.json", 'w')
json.dump(m.result, outfile, indent=4, sort_keys=True)
outfile.close()
return False
