def test_setting_random_configs_for_smart_cache_workload(self): workload_duration_s = 1 # Let's launch the smart_cache_workload smart_cache_workload = SmartCacheWorkloadGenerator(logger=self.logger) self.current_workload_config_values = smart_cache_workload.current_config.values smart_cache_workload_thread = Thread(target=smart_cache_workload.run, args=(workload_duration_s, )) smart_cache_workload_thread.start() def _set_random_workload_configuration(elapsed_time_ms): new_config_values = SmartCacheWorkloadGenerator.parameter_search_space.random( ) self.mlos_agent.set_configuration( component_type=SmartCacheWorkloadGenerator, new_config_values=new_config_values) self.current_workload_config_values = new_config_values timer = Timer(timeout_ms=100, observer_callback=_set_random_workload_configuration) random_workload_config_experiment = MlosExperiment( smart_component_types=[SmartCacheWorkloadGenerator], telemetry_aggregators=[timer]) self.mlos_agent.start_experiment(random_workload_config_experiment) time.sleep(workload_duration_s) self.mlos_agent.stop_experiment(random_workload_config_experiment)
def setUp(self): mlos_globals.init_mlos_global_context() mlos_globals.mlos_global_context.start_clock() self.logger = create_logger('TestSmartCacheWithRemoteOptimizer') self.logger.level = logging.DEBUG # Start up the gRPC service. # self.server = OptimizerMicroserviceServer(port=50051, num_threads=10) self.server.start() self.optimizer_service_grpc_channel = grpc.insecure_channel('localhost:50051') self.bayesian_optimizer_factory = BayesianOptimizerFactory(grpc_channel=self.optimizer_service_grpc_channel, logger=self.logger) self.mlos_agent = MlosAgent( logger=self.logger, communication_channel=mlos_globals.mlos_global_context.communication_channel, shared_config=mlos_globals.mlos_global_context.shared_config, bayesian_optimizer_grpc_channel=self.optimizer_service_grpc_channel ) self.mlos_agent_thread = Thread(target=self.mlos_agent.run) self.mlos_agent_thread.start() global_values.declare_singletons() # TODO: having both globals and global_values is a problem # Let's add the allowed component types self.mlos_agent.add_allowed_component_type(SmartCache) self.mlos_agent.add_allowed_component_type(SmartCacheWorkloadGenerator) self.mlos_agent.set_configuration( component_type=SmartCacheWorkloadGenerator, new_config_values=Point( workload_type='cyclical_key_from_range', cyclical_key_from_range_config=Point( min=0, range_width=2048 ) ) ) # Let's create the workload self.smart_cache_workload = SmartCacheWorkloadGenerator(logger=self.logger) self.optimizer = None self.working_set_size_estimator = WorkingSetSizeEstimator() self.hit_rate_monitor = HitRateMonitor() self.smart_cache_experiment = MlosExperiment( smart_component_types=[SmartCache], telemetry_aggregators=[self.working_set_size_estimator, self.hit_rate_monitor] ) self.optimization_problem = OptimizationProblem( parameter_space=SmartCache.parameter_search_space, objective_space=SimpleHypergrid(name="objectives", dimensions=[ContinuousDimension(name="hit_rate", min=0, max=1)]), objectives=[Objective(name="hit_rate", minimize=False)] )
def setUp(self): mlos_globals.init_mlos_global_context() mlos_globals.mlos_global_context.start_clock() self.logger = create_logger('TestSmartCacheWithRemoteOptimizer') self.logger.level = logging.INFO self.mlos_agent = MlosAgent( logger=self.logger, communication_channel=mlos_globals.mlos_global_context. communication_channel, shared_config=mlos_globals.mlos_global_context.shared_config, ) self.mlos_agent_thread = Thread(target=self.mlos_agent.run) self.mlos_agent_thread.start() global_values.declare_singletons( ) # TODO: having both globals and global_values is a problem self.workload_duration_s = 5 # Let's add the allowed component types self.mlos_agent.add_allowed_component_type(SmartCache) self.mlos_agent.add_allowed_component_type(SmartCacheWorkloadGenerator) # Let's create the workload self.smart_cache_workload = SmartCacheWorkloadGenerator( logger=self.logger) self.optimizer = None self.working_set_size_estimator = WorkingSetSizeEstimator() self.cache_config_timer = Timer( timeout_ms=200, observer_callback=self._set_new_cache_configuration) self.smart_cache_experiment = MlosExperiment( smart_component_types=[SmartCache], telemetry_aggregators=[ self.cache_config_timer, self.working_set_size_estimator ]) self.optimization_problem = OptimizationProblem( parameter_space=SmartCache.parameter_search_space, objective_space=SimpleHypergrid(name="objectives", dimensions=[ ContinuousDimension( name="miss_rate", min=0, max=1) ]), context_space=None, # TODO: add working set size estimate objectives=[Objective(name="miss_rate", minimize=True)])
def test_setting_random_configs_for_smart_cache(self): workload_duration_s = 5 # Let's create the workload smart_cache_workload = SmartCacheWorkloadGenerator(logger=self.logger) def _set_random_cache_configuration(elapsed_time_ms): """ This is where we would potentially query the optimizer. :param elapsed_time_ms: :return: """ new_config_values = SmartCache.parameter_search_space.random() self.mlos_agent.set_configuration( component_type=SmartCache, new_config_values=new_config_values) current_estimate = working_set_size_estimator.estimate_working_set_size( ) self.logger.info( f"Estimated working set size: {current_estimate.chapman_estimator}" ) cache_config_timer = Timer( timeout_ms=200, observer_callback=_set_random_cache_configuration) working_set_size_estimator = WorkingSetSizeEstimator() smart_cache_experiment = MlosExperiment( smart_component_types=[SmartCache], telemetry_aggregators=[ cache_config_timer, working_set_size_estimator ]) self.mlos_agent.start_experiment(smart_cache_experiment) ################################################################################## # Let's launch the smart_cache_workload smart_cache_workload_thread = Thread(target=smart_cache_workload.run, args=(workload_duration_s, )) smart_cache_workload_thread.start() smart_cache_workload_thread.join() self.mlos_agent.stop_experiment(smart_cache_experiment)
def test_timer(self): """ Tests if the timer works with required precision. :return: """ timeout_ms = 100 epsilon_ms = 10 def _process_clock_event(elapsed_time_ms): self.assertTrue(elapsed_time_ms + epsilon_ms > timeout_ms) self.logger.debug( f"Processed clock event. Elapsed time: {elapsed_time_ms}") timer = Timer(timeout_ms=timeout_ms, observer_callback=_process_clock_event, epsilon_ms=epsilon_ms) timer_experiment = MlosExperiment(smart_component_types=[], telemetry_aggregators=[timer]) self.mlos_agent.start_experiment(timer_experiment) time.sleep(1) self.mlos_agent.stop_experiment(timer_experiment)
def test_setting_random_configs_for_smart_cache_and_for_smart_cache_workload( self): """ Enables two experiments at once: one to set the cache parameters, the other to set the workload parameters. :return: """ workload_duration_s = 2 # Let's create the workload smart_cache_workload = SmartCacheWorkloadGenerator(logger=self.logger) self.current_workload_config_values = smart_cache_workload.current_config.values ################################################################################## # Let's configure the expriment changing the workload configuration def _set_random_workload_configuration(elapsed_time_ms): # First check that the config has been consumed #if smart_cache_workload.current_config.values != self.current_workload_config_values: # print("Put breakpoint here.") #self.assertTrue(smart_cache_workload.current_config.values == self.current_workload_config_values) new_config_values = SmartCacheWorkloadGenerator.parameter_search_space.random( ) self.mlos_agent.set_configuration( component_type=SmartCacheWorkloadGenerator, new_config_values=new_config_values) self.current_workload_config_values = new_config_values workload_timer = Timer( timeout_ms=100, observer_callback=_set_random_workload_configuration) random_workload_config_experiment = MlosExperiment( smart_component_types=[SmartCacheWorkloadGenerator], telemetry_aggregators=[workload_timer]) self.mlos_agent.start_experiment(random_workload_config_experiment) ################################################################################## # Now let's configure the smart cache tuning experiment def _set_random_cache_configuration(elapsed_time_ms): """ This is where we would potentially query the optimizer. :param elapsed_time_ms: :return: """ new_config_values = SmartCache.parameter_search_space.random() self.mlos_agent.set_configuration( component_type=SmartCache, new_config_values=new_config_values) current_estimate = working_set_size_estimator.estimate_working_set_size( ) self.logger.info( f"Estimated working set size: {current_estimate.chapman_estimator}" ) cache_config_timer = Timer( timeout_ms=200, observer_callback=_set_random_cache_configuration) working_set_size_estimator = WorkingSetSizeEstimator() smart_cache_experiment = MlosExperiment( smart_component_types=[SmartCache], telemetry_aggregators=[ cache_config_timer, working_set_size_estimator ]) self.mlos_agent.start_experiment(smart_cache_experiment) ################################################################################## # Let's launch the smart_cache_workload smart_cache_workload_thread = Thread(target=smart_cache_workload.run, args=(workload_duration_s, )) smart_cache_workload_thread.start() time.sleep(workload_duration_s) self.mlos_agent.stop_experiment(smart_cache_experiment) self.mlos_agent.stop_experiment(random_workload_config_experiment) smart_cache_workload_thread.join() all_registered_mlos_objects = set( (component_type, runtime_attributes) for component_type, runtime_attributes in self.mlos_agent.enumerate_active_smart_components()) self.assertTrue( (smart_cache_workload.mlos_object.owning_component_type, smart_cache_workload.mlos_object. owning_component_runtime_attributes ) in all_registered_mlos_objects) del smart_cache_workload self.mlos_agent.stop_all() all_registered_mlos_objects = set( mlos_object for mlos_object in self.mlos_agent.enumerate_active_smart_components()) if len(all_registered_mlos_objects) != 0: print("Put breakpoint here") self.assertTrue(len(all_registered_mlos_objects) == 0)