def _process_binding(self, binding): assert binding.calls <= binding.visits # TODO: global DEBUG mode readd = is_new = False if binding.is_dominated(): return readd, is_new if binding.is_fully_bound: action_plan = binding.skeleton.bind_action_plan(binding.mapping) self.store.add_plan(action_plan, binding.cost) is_new = True return readd, is_new binding.visits += 1 instance = binding.result.instance if (REQUIRE_DOWNSTREAM and not binding.check_downstream()): # TODO: move check_complexity here # TODO: causes redundant plan skeletons to be identified (along with complexity using visits instead of calls) # Do I need to re-enable this stream in case another skeleton needs it? # TODO: should I perform this when deciding to sample something new instead? return STANDBY, is_new #if not is_instance_ready(self.evaluations, instance): # raise RuntimeError(instance) if binding.up_to_date(): new_results, _ = process_instance(self.store, self.domain, instance, disable=self.disable) is_new = bool(new_results) for new_binding in binding.update_bindings(): self.push_binding(new_binding) readd = not instance.enumerated return readd, is_new
def _generate_results(self, instance): # assert(instance.opt_index == 0) if not is_instance_ready(self.evaluations, instance): raise RuntimeError(instance) is_new = bool(process_instance(self.store, self.domain, instance, disable=self.disable)) for i, binding in enumerate(list(self.bindings_from_instance[instance])): #print(i, binding) # Maybe this list grows but not all the things are accounted for if self.is_enabled(binding): binding.update_instances() self.update_enabled(binding) #print() return is_new
def _process_binding(self, binding): is_new = False if binding.is_dominated(): return False, is_new if binding.is_bound(): action_plan = bind_action_plan(binding.skeleton.action_plan, binding.mapping) self.store.add_plan(action_plan, binding.cost) return False, True binding.attempts += 1 instance = binding.result.instance if PRUNE_BINDINGS and not binding.do_evaluate(): # TODO: causes redudant plan skeletons to be identified (along with complexity using attempts instead of calls) # Do I need to reenable this stream in case another skeleton needs it? # TODO: should I perform this when deciding to sample something new instead? #if instance.enumerated: # return False, is_new return None, is_new #if not is_instance_ready(self.evaluations, instance): # raise RuntimeError(instance) if binding.up_to_date(): new_results, _ = process_instance(self.store, self.domain, instance, disable=self.disable) is_new = bool(new_results) for call_idx in range(binding.calls, instance.num_calls): for new_result in instance.results_history[ call_idx]: # TODO: don't readd if successful already if new_result.is_successful(): new_mapping = update_bindings(binding.mapping, binding.result, new_result) new_cost = update_cost(binding.cost, binding.result, new_result) new_history = binding.history + [call_idx] new_binding = Binding(binding.skeleton, new_cost, new_history, new_mapping, binding.index + 1) binding.children.append(new_binding) heappush(self.queue, new_binding.get_element()) binding.calls = instance.num_calls binding.attempts = max(binding.attempts, binding.calls) binding.complexity = None readd = not instance.enumerated return readd, is_new