def do_get_node_ttl_dist_map_job(node_ttl_dist_map_list, sub_pipe=None):
"""
:param node_ttl_dist_map_list: [... node_ttl_dist_map_k ...]
:param sub_pipe: Corresponding to a master pipe owned by the master process,
if sub_pipe is not empty, we put some information into it and send to the master pipe.
:return:
"""
"""
node_ttl_dist_map_pattern(reference pattern):
[graph_name_str, tree_method_info_str, node_ttl_dist_map_str]
tree_method_info : 'tree num'_'tree method'
"""
"""
Instantiate node_ttl_dist_map_msg_pattern:
[graph_name_str, tree_method_info_str, elapsed_time_str]
"""
msg_list = get_instances(node_ttl_dist_map_pattern,
node_ttl_dist_map_msg_pattern,
node_ttl_dist_map_list, sep)
msg_to_send = []
"""
Parse parameter tree_num
"""
tree_method_info_list = get_instances(node_ttl_dist_map_pattern,
tree_method_info_str,
node_ttl_dist_map_list, sep)
tree_num_list = [parse_tree_num(item) for item in tree_method_info_list]
related_graph_list = get_graph_instances(graph_dir, graph_name_str,
node_ttl_dist_map_list,
node_ttl_dist_map_pattern, sep)
for i in range(0, len(node_ttl_dist_map_list)):
graph_path = path.join(graph_dir, related_graph_list[i])
adj_table = get_adjtable(graph_path)
node_ttl_dist_map_path = path.join(node_ttl_dist_map_dir,
node_ttl_dist_map_list[i])
start_time = clock()
node_ttl_dist_map = get_node_ttl_dist_map(adj_table, tree_num_list[i])
end_time = clock()
pickle_to_disk(node_ttl_dist_map_path, node_ttl_dist_map)
"""
Instantiate elapsed_time_str in node_ttl_dist_map_msg_pattern.
"""
msg_list[i] = msg_list[i].replace(
elapsed_time_str, str(get_elapsed_minute(start_time, end_time)))
msg_list[i] = format_message(msg_list[i], sep)
print msg_list[i]
msg_to_send.append(msg_list[i])
if sub_pipe:
sub_pipe.send(msg_to_send)
def do_improve_init_sols_job(monitor_list, sub_pipe):
"""
:param monitor_list: [..., monitor_k,...]
:param sub_pipe: Corresponding to a master pipe owned by the master process,
if sub_pipe is not empty, we put some information into it and send to the master pipe.
:return:
"""
"""
monitor_pattern(reference pattern):
[graph_name_str, monitor_info_fmt, monitor_str]
"""
"""
Instantiate init_sol_pattern from instances of monitor_pattern.
init_sol_pattern:
******************** *********************
[graph_name_str, tree_method_info_str, init_sol_monitor_info, init_sol_str]
"""
init_sol_list = get_instances(monitor_pattern, init_sol_pattern,
monitor_list, sep)
"""
Instantiate monitor_msg_pattern from instances of monitor_pattern.
monitor_msg_pattern:
*********** ****************
[graph_name_str, monitor_info_fmt, penalty_str, elapsed_time_str]
"""
msg_list = get_instances(monitor_pattern, monitor_msg_pattern,
monitor_list, sep)
"""
Parse parameter trunc number and trunc step
"""
monitor_info_list = get_instances(monitor_pattern, monitor_info_str,
monitor_list, sep)
"""
[... (trunc number, trunc step) ...]
"""
trunc_num_step_list = [
parse_trunc_num_step(item) for item in monitor_info_list
]
related_graph_id_list = get_graph_instances(graph_dir, graph_name_str,
monitor_list, monitor_pattern,
sep)
for i in range(0, len(monitor_list)):
"""
Load graph_title.
"""
graph_path = os.path.join(graph_dir, related_graph_id_list[i])
adj_table = get_adjtable(graph_path)
"""
Instantiate tree_method_info_str, init_sol_monitor_info_str.
"""
node_num = len(adj_table)
tree_num = get_tree_num(node_num)
init_sol_list[i] = init_sol_list[i].replace(
tree_method_info_str, tree_num_method.format(tree_num))
max_monitor_num = get_max_monitor_num(node_num)
init_sol_list[i] = init_sol_list[i].replace(
init_sol_monitor_info_str,
max_monitor_num_method.format(max_monitor_num))
"""
Load initial solution.
"""
init_sol_path = os.path.join(init_sol_dir, init_sol_list[i])
init_sol = pickle_from_disk(init_sol_path)
"""
Improve initial solution and write to disk.
"""
start_time = clock()
monitors, penalty = improve_init_sols(adj_table, init_sol,
*trunc_num_step_list[i])
end_time = clock()
monitor_path = os.path.join(monitor_dir, monitor_list[i])
pickle_to_disk(monitor_path, monitors)
"""
Instantiate penalty_str and elapsed_time_str in monitor_msg_pattern.
"""
msg_list[i] = msg_list[i].replace(penalty_str, str(penalty))
msg_list[i] = msg_list[i].replace(
elapsed_time_str, str(get_elapsed_minute(start_time, end_time)))
msg_list[i] = format_message(msg_list[i], sep)
print msg_list[i]
if sub_pipe:
sub_pipe.send(msg_list)
def do_get_init_sol_job(init_sol_list, sub_pipe=None):
"""
:param init_sol_list: [..., init_sol_k, ...]
:param sub_pipe: Corresponding to a master pipe owned by the master process,
if sub_pipe is not empty, we put some information into it and send to the master pipe.
"""
"""
init_sol_pattern(reference pattern):
[graph_name_str, tree_method_info_str, init_sol_monitor_info_str, init_sol_str]
tree_method_info : tree-num_tree-method
init_sol_monitor_info: max-monitor-num_method
"""
"""
Instantiate node_ttl_dist_map_pattern.
node_ttl_dist_map_pattern:
[graph_name_str, tree_method_info_str, node_ttl_dist_map_str]
"""
node_ttl_dist_map_list = get_instances(init_sol_pattern,
node_ttl_dist_map_pattern,
init_sol_list, sep)
"""
Instantiate init_sol_message_pattern.
init_sol_message_pattern:
[graph_name_str, tree_method_info_str, init_sol_monitor_info_str,
*********** ****************
penalty_str, elapsed_time_str]
"""
msg_list = get_instances(init_sol_pattern, init_sol_msg_pattern,
init_sol_list, sep)
msg_to_send = []
"""
Parse parameter max_monitor_num.
"""
init_sol_monitor_info_list = get_instances(init_sol_pattern,
init_sol_monitor_info_str,
init_sol_list, sep)
max_monitor_num_list = [
parse_max_monitor_num(item) for item in init_sol_monitor_info_list
]
related_graph_id_list = get_graph_instances(graph_dir, graph_name_str,
init_sol_list,
init_sol_pattern, sep)
for i in range(0, len(init_sol_list)):
"""
Load adjacent table.
"""
graph_path = path.join(graph_dir, related_graph_id_list[i])
adj_table = get_adjtable(graph_path)
"""
Load node_ttl_dist_map.
"""
node_ttl_dist_map_path = path.join(node_ttl_dist_map_dir,
node_ttl_dist_map_list[i])
node_ttl_dist_map = pickle_from_disk(node_ttl_dist_map_path)
"""
Get initial solution and write to disk.
"""
init_sol_path = path.join(init_sol_dir, init_sol_list[i])
start_time = clock()
monitors, penalty = get_init_sol(adj_table, node_ttl_dist_map,
max_monitor_num_list[i])
end_time = clock()
pickle_to_disk(init_sol_path, monitors)
"""
Instantiate penalty_str and elapsed_time_str in init_sol_message_pattern.
"""
msg_list[i] = msg_list[i].replace(penalty_str, str(penalty))
msg_list[i] = msg_list[i].replace(
elapsed_time_str, str(get_elapsed_minute(start_time, end_time)))
"""
Process msg.
"""
msg_list[i] = format_message(msg_list[i], sep)
print msg_list[i]
msg_to_send.append(msg_list[i])
if sub_pipe:
sub_pipe.send(msg_to_send)
def do_maximize_degree_discount_heuristic_job(monitor_list, sub_pipe=None):
"""
:param monitor_list: [..., monitor_k,...]
:param sub_pipe:
Corresponding to a master pipe owned by the master process,
if sub_pipe is not empty, we put some information into it and send to the master pipe.
:return:
"""
related_graph_id_list = get_graph_instances(graph_dir,
graph_name_str,
monitor_list,
monitor_pattern,
sep)
"""
monitor_pattern (reference pattern):
[graph_name_str, monitor_info_fmt, monitor_str]
monitor_message_pattern:
*********** ****************
[graph_name_str, monitor_info_fmt, penalty_str, elapsed_time_str]
"""
message_list = get_instances(monitor_pattern,
monitor_msg_pattern,
monitor_list,
sep)
"""
Parse parameter trunc number and trunc step
"""
monitor_info_list = get_instances(monitor_pattern,
monitor_info_str,
monitor_list,
sep)
"""
[... (trunc number, trunc step) ...]
"""
trunc_num_step_list = [parse_trunc_num_step(item) for item in monitor_info_list]
for i in range(0, len(monitor_list)):
graph_path = os.path.join(graph_dir, related_graph_id_list[i])
adj_table = get_adjtable(graph_path)
monitor_path = os.path.join(monitor_dir, monitor_list[i])
node_num = len(adj_table)
start_time = clock()
monitors, penalty = maximize_degree_discount_heuristic(adj_table,
get_max_monitor_num(node_num))
end_time = clock()
trunc_num, trunc_step = trunc_num_step_list[i]
monitors = [monitors[0: trunc_idx * trunc_step] for trunc_idx in range(1, trunc_num+1, 1)]
pickle_to_disk(monitor_path, monitors)
message_list[i] = message_list[i].replace(penalty_str, str(penalty))
message_list[i] = message_list[i].replace(elapsed_time_str,
str(get_elapsed_minute(start_time, end_time)))
message_list[i] = format_message(message_list[i],
sep)
print message_list[i]
if sub_pipe:
sub_pipe.send(message_list)