in DSE_utils/hill_climbing.py [0:0]
def sel_moves_based_on_dis(self, des_tup):
ex_dp, sim_dp = des_tup
if config.DEBUG_FIX: random.seed(0)
else: time.sleep(.00001), random.seed(datetime.now().microsecond)
# select move components
t_0 = time.time()
selected_metric, metric_prob_dir_dict, sorted_metric_dir = self.select_metric(sim_dp)
t_1 = time.time()
move_dir = self.select_dir(sim_dp, selected_metric)
t_2 = time.time()
selected_krnl, krnl_prob_dict, krnl_prob_dir_dict_sorted = self.select_kernel(ex_dp, sim_dp, selected_metric, sorted_metric_dir)
t_3 = time.time()
selected_block, block_prob_dict = self.select_block(sim_dp, ex_dp, selected_krnl, selected_metric)
t_4 = time.time()
transformation_name,transformation_sub_name, transformation_batch_mode, total_transformation_cnt = self.select_transformation(ex_dp, sim_dp, selected_block, selected_metric, selected_krnl, sorted_metric_dir)
t_5 = time.time()
"""
if sim_dp.dp_stats.fits_budget(1) and self.dram_feasibility_check_pass(ex_dp) and self.can_improve_locality(selected_block, selected_krnl):
transformation_sub_name = "transfer_no_prune"
transformation_name = "improve_locality"
transformation_batch_mode = "single"
selected_metric = "cost"
"""
# prepare for move
# if bus, (forgot which exception), if IP, avoid split .
"""
if sim_dp.dp_stats.fits_budget(1) and not self.dram_feasibility_check_pass(ex_dp):
transformation_name = "dram_fix"
transformation_sub_name = "dram_fix_no_prune"
transformation_batch_mode = "single"
selected_metric = "cost"
"""
if self.is_cleanup_iter():
transformation_name = "cleanup"
transformation_sub_name = "non"
transformation_batch_mode = "single"
selected_metric = "cost"
#config.VIS_GR_PER_GEN = True
self.cleanup_ctr += 1
#config.VIS_GR_PER_GEN = False
# log the data for future profiling/data collection/debugging
move_to_apply = move(transformation_name, transformation_sub_name, transformation_batch_mode, move_dir, selected_metric, selected_block, selected_krnl, krnl_prob_dir_dict_sorted)
move_to_apply.set_sorted_metric_dir(sorted_metric_dir)
move_to_apply.set_logs(sim_dp.database.db_input.task_workload[selected_krnl.get_task_name()],"workload")
move_to_apply.set_logs(sim_dp.dp_stats.get_system_complex_metric("cost"), "cost")
move_to_apply.set_logs(krnl_prob_dict, "kernels")
move_to_apply.set_logs(metric_prob_dir_dict, "metrics")
move_to_apply.set_logs(block_prob_dict, "blocks")
move_to_apply.set_logs(self.krnel_rnk_to_consider, "kernel_rnk_to_consider")
move_to_apply.set_logs(sim_dp.dp_stats.dist_to_goal(["power", "area", "latency", "cost"],
config.metric_sel_dis_mode),"ref_des_dist_to_goal_all")
move_to_apply.set_logs(sim_dp.dp_stats.dist_to_goal(["power", "area", "latency"],
config.metric_sel_dis_mode),"ref_des_dist_to_goal_non_cost")
for blck_of_interest in ex_dp.get_blocks():
self.get_transformation_design_space_size(move_to_apply, ex_dp, sim_dp, blck_of_interest, selected_metric, sorted_metric_dir)
move_to_apply.set_logs(t_1 - t_0, "metric_selection_time")
move_to_apply.set_logs(t_2 - t_1, "dir_selection_time")
move_to_apply.set_logs(t_3 - t_2, "kernel_selection_time")
move_to_apply.set_logs(t_4 - t_3, "block_selection_time")
move_to_apply.set_logs(t_5 - t_4, "transformation_selection_time")
blck_ref = move_to_apply.get_block_ref()
gc.disable()
blck_ref_cp = cPickle.loads(cPickle.dumps(blck_ref, -1))
gc.enable()
# ------------------------
# prepare for the move
# ------------------------
if move_to_apply.get_transformation_name() == "identity":
pass
#move_to_apply.set_validity(False, "NoValidTransformationException")
if move_to_apply.get_transformation_name() == "swap":
self.dh.unload_read_mem(ex_dp) # unload memories
if not blck_ref.type == "ic":
self.dh.unload_buses(ex_dp) # unload buses
else:
self.dh.unload_read_buses(ex_dp) # unload buses
# get immediate superior/inferior block (based on the desired direction)
imm_block = self.dh.get_immediate_block_multi_metric(blck_ref,
move_to_apply.get_metric(), move_to_apply.get_sorted_metric_dir(),
blck_ref.get_tasks_of_block()) # immediate block either superior or
move_to_apply.set_dest_block(imm_block)
move_to_apply.set_customization_type(blck_ref, imm_block)
move_to_apply.set_tasks(blck_ref.get_tasks_of_block())
elif move_to_apply.get_transformation_name() in ["split_swap"]:
self.dh.unload_buses(ex_dp) # unload buses
# get immediate superior/inferior block (based on the desired direction)
succeeded,migrant = blck_ref.get_tasks_by_name(move_to_apply.get_kernel_ref().get_task_name())
if not succeeded:
move_to_apply.set_validity(False, "NoMigrantException")
else:
imm_block = self.dh.get_immediate_block_multi_metric(blck_ref,
move_to_apply.get_metric(), move_to_apply.get_sorted_metric_dir(),
[migrant]) # immediate block either superior or
move_to_apply.set_dest_block(imm_block)
self.dh.unload_read_mem(ex_dp) # unload memories
self.change_read_task_to_write_if_necessary(ex_dp, sim_dp, move_to_apply, selected_krnl)
migrant_tasks = self.dh.migrant_selection(ex_dp, sim_dp, blck_ref, blck_ref_cp, move_to_apply.get_kernel_ref(),
move_to_apply.get_transformation_batch())
#migrant_tasks = list(set(move_to_apply.get_block_ref().get_tasks()) - set(migrant_tasks_)) # reverse the order to allow for swap to happen on the ref_block
move_to_apply.set_tasks(migrant_tasks)
move_to_apply.set_customization_type(blck_ref, imm_block)
elif move_to_apply.get_transformation_name() in ["split"]:
# select tasks to migrate
#self.change_read_task_to_write_if_necessary(ex_dp, sim_dp, move_to_apply, selected_krnl)
migrant_tasks = self.dh.migrant_selection(ex_dp, sim_dp, blck_ref, blck_ref_cp, move_to_apply.get_kernel_ref(),
move_to_apply.get_transformation_batch())
# determine the parallelism type
parallelism_type_ = [] #with repetition
parallelism_type = []
migrant_tasks_names = [el.get_name() for el in migrant_tasks]
for task_ in migrant_tasks_names:
parallelism_type_.append(self.get_task_parallelism_type(sim_dp, task_, selected_krnl.get_task_name()))
parallelism_type = list(set(parallelism_type_))
move_to_apply.set_parallelism_type(parallelism_type)
move_to_apply.set_tasks(migrant_tasks)
if len(migrant_tasks) == 0:
move_to_apply.set_validity(False, "NoParallelTaskException")
if blck_ref.subtype == "ip": # makes no sense to split the IPs,
# it can actually cause problems where
# we end up duplicating the hardware
move_to_apply.set_validity(False, "IPSplitException")
elif move_to_apply.get_transformation_name() == "migrate":
if not selected_block.type == "ic": # ic migration is not supported
# check and see if tasks exist (if not, it was a read)
imm_block_present, found_blck_to_mig_to, mig_selection_mode, parallelism_type, locality_type = self.select_block_to_migrate_to(ex_dp,
sim_dp,
blck_ref_cp,
move_to_apply.get_metric(),
move_to_apply.get_sorted_metric_dir(),
move_to_apply.get_kernel_ref())
move_to_apply.set_parallelism_type(parallelism_type)
move_to_apply.set_locality_type(locality_type)
self.dh.unload_buses(ex_dp) # unload buses
self.dh.unload_read_mem(ex_dp) # unload memories
if not imm_block_present.subtype == "ip":
self.change_read_task_to_write_if_necessary(ex_dp, sim_dp, move_to_apply, selected_krnl)
if not found_blck_to_mig_to:
move_to_apply.set_validity(False, "NoMigrantException")
imm_block_present = blck_ref
elif move_to_apply.get_kernel_ref().get_task_name() in ["souurce", "siink", "dummy_last"]:
move_to_apply.set_validity(False, "NoMigrantException")
imm_block_present = blck_ref
else:
migrant_tasks = self.dh.migrant_selection(ex_dp, sim_dp, blck_ref, blck_ref_cp, move_to_apply.get_kernel_ref(),
mig_selection_mode)
move_to_apply.set_tasks(migrant_tasks)
move_to_apply.set_dest_block(imm_block_present)
else:
move_to_apply.set_validity(False, "ICMigrationException")
elif move_to_apply.get_transformation_name() == "dram_fix":
any_block = ex_dp.get_hardware_graph().get_blocks()[0] # this is just dummmy to prevent breaking the plotting
any_task = any_block.get_tasks_of_block()[0]
move_to_apply.set_tasks([any_task]) # this is just dummmy to prevent breaking the plotting
move_to_apply.set_dest_block(any_block)
pass
elif move_to_apply.get_transformation_name() == "transfer":
if move_to_apply.get_transformation_sub_name() == "locality_improvement":
succeeded, dest_block = self.find_block_with_sharing_tasks(ex_dp, selected_block, selected_krnl)
if succeeded:
move_to_apply.set_dest_block(dest_block)
move_to_apply.set_tasks([move_to_apply.get_kernel_ref().get_task()])
else:
move_to_apply.set_validity(False, "TransferException")
else:
move_to_apply.set_validity(False, "TransferException")
pass
elif move_to_apply.get_transformation_name() == "routing":
if move_to_apply.get_transformation_sub_name() == "routing_improvement":
succeeded, dest_block = self.find_improve_routing(ex_dp, sim_dp, selected_block, selected_krnl)
if succeeded:
move_to_apply.set_dest_block(dest_block)
move_to_apply.set_tasks([move_to_apply.get_kernel_ref().get_task()])
else:
move_to_apply.set_validity(False, "RoutingException")
else:
move_to_apply.set_validity(False, "RoutingException")
pass
elif move_to_apply.get_transformation_name() == "cleanup":
if self.can_absorb_block(ex_dp, sim_dp, move_to_apply.get_kernel_ref().get_task_name()):
move_to_apply.set_transformation_sub_name("absorb")
absorbee, absorber = self.find_absorbing_block_tuple(ex_dp, sim_dp, move_to_apply.get_kernel_ref().get_task_name())
if absorber == None or absorbee == "None":
move_to_apply.set_validity(False, "NoAbsorbee(er)Exception")
else:
move_to_apply.set_ref_block(absorbee)
move_to_apply.set_dest_block(absorber)
else:
move_to_apply.set_validity(False, "CostPairingException")
self.dh.unload_buses(ex_dp) # unload buses
self.dh.unload_read_mem(ex_dp) # unload memories
task_1, block_task_1, task_2, block_task_2 = self.find_task_with_similar_mappable_ips(des_tup)
# we also randomize
if not (task_1 is None) and (random.choice(np.arange(0,1,.1))>.5):
move_to_apply.set_ref_block(block_task_1)
migrant_tasks = [task_1]
imm_block_present = block_task_2
move_to_apply.set_tasks(migrant_tasks)
move_to_apply.set_dest_block(imm_block_present)
else:
pair = self.gen_block_match_cleanup_move(des_tup)
if len(pair) == 0:
move_to_apply.set_validity(False, "CostPairingException")
else:
ref_block = pair[0]
if not ref_block.type == "ic": # ic migration is not supported
move_to_apply.set_ref_block(ref_block)
migrant_tasks = ref_block.get_tasks_of_block()
imm_block_present = pair[1]
move_to_apply.set_tasks(migrant_tasks)
move_to_apply.set_dest_block(imm_block_present)
move_to_apply.set_breadth_depth(self.SA_current_breadth, self.SA_current_depth, self.SA_current_mini_breadth) # set depth and breadth (for debugging/ plotting)
return move_to_apply, total_transformation_cnt