def __init__(self, *args, ticks=None, **kwargs): super().__init__() date_and_time.send_clock_tuning() if ticks is None: ticks = services.server_clock_service().ticks() self._initial_server_ticks = ticks new_game_start_time = GameClock.NEW_GAME_START_TIME() self._initial_ticks = new_game_start_time.absolute_ticks() self._time_of_last_save = None self._client_connect_world_time = None self._previous_absolute_ticks = ticks self._game_clock = Clock(0) self._clock_speed = ClockSpeedMode.PAUSED self._previous_non_pause_speed = ClockSpeedMode.NORMAL self._tick_to_next_message = 0 self._error_accumulation = 0 self._sim_game_speed_requests = {} self._last_speed_change_server_time = self._initial_server_ticks self._server_ticks_spent_in_speed = [0 for _ in ClockSpeedMode] self._client_connect_speed = None self._pause_requests = [] self._zone_init_world_game_time = None self._interaction_loading = False self._loading_monotonic_ticks = 0 self.clock_speed_multiplier_type = ClockSpeedMultiplierType.DEFAULT
def alarm_callback(_): global previous_log_time_stamp, previous_log_time_ticks generate_statistics() _log_performance_metrics() previous_log_time_stamp = time.time() previous_log_time_ticks = services.server_clock_service().now( ).absolute_ticks()
def update(self, time_slice=True): ts4mp_log("simulate", "Client is online?: {}".format(execution.client_online), force=False) if execution.client_online: # ts4mp_log("simulate", "Client is online?: {}".format(ts4mp.core.mp_essential.client_online), force=True) return max_time_ms = self.MAX_TIME_SLICE_MILLISECONDS if time_slice else None t1 = time.time() result = self.sim_timeline.simulate(services.game_clock_service().now(), max_time_ms=max_time_ms) t2 = time.time() # ts4mp_log("simulate", "{} ms".format((t2 - t1) * 1000), force=True) if not result: logger.debug( 'Did not finish processing Sim Timeline. Current element: {}', self.sim_timeline.heap[0]) result = self.wall_clock_timeline.simulate( services.server_clock_service().now()) if not result: logger.error( 'Too many iterations processing wall-clock Timeline. Likely culprit: {}', self.wall_clock_timeline.heap[0])
def enable_performance_logging(*args, enableLog=False, **kwargs): global previous_log_time_stamp, previous_log_time_ticks, performance_log_alarm if enableLog: def alarm_callback(_): global previous_log_time_stamp, previous_log_time_ticks generate_statistics() _log_performance_metrics() previous_log_time_stamp = time.time() previous_log_time_ticks = services.server_clock_service().now( ).absolute_ticks() previous_log_time_stamp = time.time() previous_log_time_ticks = services.server_clock_service().now( ).absolute_ticks() set_gsi_performance_metric('ticks_per_sec', 'N/A') _log_performance_metrics() current_zone = services.current_zone() if performance_log_alarm is not None: alarms.cancel_alarm(performance_log_alarm) performance_log_alarm = alarms.add_alarm_real_time( current_zone, clock.interval_in_real_seconds(SECONDS_BETWEEN_LOGGING), alarm_callback, repeating=True, use_sleep_time=False) elif performance_log_alarm is not None: alarms.cancel_alarm(performance_log_alarm) performance_log_alarm = None previous_log_time_stamp = 0 set_gsi_performance_metric('ticks_per_sec', 'N/A')
def _save_game_gen(self, timeline, save_game_data, check_cooldown=True): save_lock_reason = self.get_save_lock_tooltip() if save_lock_reason is not None: return (SaveGameResult.FAILED_SAVE_LOCKED, save_lock_reason) current_time = services.server_clock_service().now() result_code = SaveGameResult.FAILED_ON_COOLDOWN if self._time_of_last_save is not None: cooldown = (current_time - self._time_of_last_save).in_real_world_seconds() else: cooldown = PersistenceTuning.SAVE_GAME_COOLDOWN + 1 if not check_cooldown or cooldown > PersistenceTuning.SAVE_GAME_COOLDOWN: result_code = SaveGameResult.SUCCESS error_code_string = None try: yield self._fill_and_send_save_game_protobufs_gen(timeline, save_game_data.slot_id, save_game_data.slot_name, auto_save_slot_id=save_game_data.auto_save_slot_id) except Exception as e: result_code = SaveGameResult.FAILED_EXCEPTION_OCCURRED error_code_string = persistence_error_types.generate_exception_code(self.save_error_code, e) logger.exception('Save failed due to Exception', exc=e) finally: self.save_error_code = persistence_error_types.ErrorCodes.NO_ERROR if check_cooldown and result_code == SaveGameResult.SUCCESS: self._time_of_last_save = current_time failure_reason = self._get_failure_reason_for_result_code(result_code, error_code_string) return (result_code, failure_reason)
def _sync_clock_and_broadcast_gameclock(self, immediate=False): global g_set_game_time_serial_number server_time = services.server_clock_service().ticks() clock_speed = self.clock_speed game_speed = self.current_clock_speed_scale() super_speed = clock_speed == ClockSpeedMode.SUPER_SPEED3 if super_speed: clock_speed = ClockSpeedMode.SPEED3 if clock_speed == ClockSpeedMode.INTERACTION_STARTUP_SPEED: game_time = self._loading_monotonic_ticks monotonic_time = self._loading_monotonic_ticks else: game_time = self._game_clock._ticks monotonic_time = game_time + self._loading_monotonic_ticks g_set_game_time_serial_number += 1 op = distributor.ops.SetGameTime(server_time, monotonic_time, game_time, game_speed, clock_speed, self._initial_ticks, super_speed, g_set_game_time_serial_number) if immediate: distributor.system.Distributor.instance( ).send_op_with_no_owner_immediate(op) else: distributor.system.Distributor.instance().add_op_with_no_owner(op) if self.set_game_time_callback is not None: self.set_game_time_callback(server_time, monotonic_time, game_time, game_speed, clock_speed, self._initial_ticks, super_speed)
def _save_game_gen(self, timeline, save_game_data, check_cooldown=True): save_lock_reason = self.get_save_lock_tooltip() if save_lock_reason is not None: return (SaveGameResult.FAILED_SAVE_LOCKED, save_lock_reason) yield current_time = services.server_clock_service().now() result_code = SaveGameResult.FAILED_ON_COOLDOWN if self._time_of_last_save is not None: cooldown = (current_time - self._time_of_last_save).in_real_world_seconds() else: cooldown = PersistenceTuning.SAVE_GAME_COOLDOWN + 1 if not check_cooldown or cooldown > PersistenceTuning.SAVE_GAME_COOLDOWN: result_code = SaveGameResult.SUCCESS error_code_string = None try: yield from self._fill_and_send_save_game_protobufs_gen(timeline, save_game_data.slot_id, save_game_data.slot_name, auto_save_slot_id=save_game_data.auto_save_slot_id) except Exception as e: result_code = SaveGameResult.FAILED_EXCEPTION_OCCURRED error_code_string = persistence_error_types.generate_exception_code(self.save_error_code, e) logger.exception('Save failed due to Exception', exc=e) with telemetry_helper.begin_hook(save_telemetry_writer, TELEMETRY_HOOK_SAVE_FAIL) as hook: hook.write_int(TELEMETRY_FIELD_ERROR_CODE, self.save_error_code) hook.write_int(TELEMETRY_FIELD_STACK_HASH, sims4.hash_util.hash64(error_code_string)) finally: self.save_error_code = persistence_error_types.ErrorCodes.NO_ERROR if check_cooldown: if result_code == SaveGameResult.SUCCESS: self._time_of_last_save = current_time failure_reason = self._get_failure_reason_for_result_code(result_code, error_code_string) return (result_code, failure_reason) yield
def set_update_alarm(self): self.sim_time_on_connect = services.time_service().sim_now self.server_time_on_connect = services.server_clock_service().now() self.sim_time_last_update = self.sim_time_on_connect self.server_time_last_update = self.server_time_on_connect self.update_alarm_handle = alarms.add_alarm( self, TimeSpan(self.TIME_DATA_UPDATE_RATE), self._update_timer_alarm, True)
def now(_connection=None): output = sims4.commands.Output(_connection) game_clock_ticks = services.time_service().sim_now.absolute_ticks() server_ticks = services.server_clock_service().ticks() output('Gameclock ticks: {} Server Ticks: {}'.format(game_clock_ticks, server_ticks)) timeline_now = services.time_service().sim_now game_clock_now = services.game_clock_service().now() output('Sim timeline now: {}'.format(timeline_now)) output('Game clock now: {}'.format(game_clock_now))
def start(self): sim_debugger = None self.sim_timeline = scheduling.Timeline( services.game_clock_service().now(), exception_reporter=self._on_exception, debugger=sim_debugger) self.wall_clock_timeline = scheduling.Timeline( services.server_clock_service().now(), exception_reporter=self._on_exception) self.sim_timeline.on_time_advanced.append(caches.clear_all_caches)
def on_client_disconnect(self, client): self._update_time_spent_in_speed(self.clock_speed) total_time_spent = services.server_clock_service().ticks( ) - self._initial_server_ticks for speed in ClockSpeedMode: time_spent_in_speed = self._server_ticks_spent_in_speed[speed] precentage_time_in_speed = time_spent_in_speed / float( total_time_spent) * 100 time_spent_in_speed = time_spent_in_speed / date_and_time.TICKS_PER_REAL_WORLD_SECOND clock_telemetry_helper.report_change_speed( speed, time_spent_in_speed, precentage_time_in_speed) self.set_clock_speed(ClockSpeedMode.PAUSED)
def update(self, time_slice=True): max_time_ms = self.MAX_TIME_SLICE_MILLISECONDS if time_slice else None result = self.sim_timeline.simulate( services.game_clock_service().now(), max_time_ms=max_time_ms) if not result: logger.debug( 'Did not finish processing Sim Timeline. Current element: {}', self.sim_timeline.heap[0]) result = self.wall_clock_timeline.simulate( services.server_clock_service().now()) if not result: logger.error( 'Too many iterations processing wall-clock Timeline. Likely culprit: {}', self.wall_clock_timeline.heap[0])
def _get_game_clock_sync_variables(self): server_time = services.server_clock_service().ticks() if self._interaction_loading: game_time = self._loading_monotonic_ticks monotonic_time = self._loading_monotonic_ticks game_speed = self._clock_speed_to_scale( ClockSpeedMode.INTERACTION_STARTUP_SPEED) clock_speed = ClockSpeedMode.INTERACTION_STARTUP_SPEED super_speed = False else: game_time = self._game_clock._ticks monotonic_time = game_time + self._loading_monotonic_ticks game_speed = self.current_clock_speed_scale() clock_speed = self.clock_speed() super_speed = services.get_super_speed_three_service( ).in_super_speed_three_mode() return (server_time, monotonic_time, game_time, game_speed, clock_speed, super_speed)
def c_api_server_tick(absolute_ticks): sims4.core_services.on_tick() game_services.on_tick() clock_service = services.server_clock_service() previous_ticks = clock_service.ticks() if absolute_ticks < previous_ticks: absolute_ticks = previous_ticks clock_service.tick_server_clock(absolute_ticks) if services._zone_manager is not None: zone = services._zone_manager.current_zone if zone is not None and zone.is_instantiated: persistence_service = services.get_persistence_service() if persistence_service is not None and persistence_service.save_timeline: persistence_service.save_timeline.simulate( services.time_service().sim_now) return SUCCESS_CODE zone.update(absolute_ticks) services.get_distributor_service().on_tick() return SUCCESS_CODE
def c_api_server_tick(absolute_ticks): sims4.core_services.on_tick() clock_service = services.server_clock_service() previous_ticks = clock_service.ticks() if absolute_ticks < previous_ticks: absolute_ticks = previous_ticks clock_service.tick_server_clock(absolute_ticks) if services._zone_manager is not None: for zone in services._zone_manager.objects: while zone.is_instantiated: with sims4.zone_utils.global_zone_lock(zone.id): persistence_service = services.get_persistence_service() if persistence_service is not None and persistence_service.save_timeline: persistence_service.save_timeline.simulate( services.time_service().sim_now) return SUCCESS_CODE zone.update(absolute_ticks) services.get_distributor_service().on_tick() return SUCCESS_CODE
def __init__(self): super().__init__() date_and_time.send_clock_tuning() ticks = services.server_clock_service().ticks() self._initial_server_ticks = ticks new_game_start_time = GameClock.NEW_GAME_START_TIME() self._initial_ticks = new_game_start_time.absolute_ticks() self._previous_absolute_ticks = ticks self._game_clock = Clock(0) self._tick_to_next_message = 0 self._error_accumulation = 0 self._last_speed_change_server_time = self._initial_server_ticks self._server_ticks_spent_in_speed = collections.Counter() self._loading_monotonic_ticks = 0 self.clock_speed_multiplier_type = ClockSpeedMultiplierType.DEFAULT self._clock_speed = ClockSpeedMode.PAUSED self._non_ui_clock_speed = ClockSpeedMode.PAUSED self.speed_controllers = collections.defaultdict(_SpeedController) self.speed_controllers[GameSpeedChangeSource.INITIAL].push_speed( ClockSpeedMode.PAUSED, reason='Initial Speed') self.set_game_time_callback = None
def on_client_disconnect(self, client): self._update_time_spent_in_speed(self.clock_speed()) total_time_spent = services.server_clock_service().ticks( ) - self._initial_server_ticks for speed in ClockSpeedMode: time_spent_in_speed = self._server_ticks_spent_in_speed[speed] precentage_time_in_speed = time_spent_in_speed / float( total_time_spent) * 100 time_spent_in_speed = time_spent_in_speed / date_and_time.TICKS_PER_REAL_WORLD_SECOND with telemetry_helper.begin_hook( clock_telemetry_writer, TELEMETRY_HOOK_CHANGE_SPEED_REPORT, household=client.household) as hook: hook.write_int(TELEMETRY_FIELD_CLOCK_SPEED, speed) hook.write_int(TELEMETRY_FIELD_TIME_SPENT_IN_SPEED, time_spent_in_speed) hook.write_float( TELEMETRY_FIELD_PERCENTAGE_TIME_SPENT_IN_SPEED, precentage_time_in_speed) if GameClock._is_single_player(): self.set_clock_speed(ClockSpeedMode.PAUSED) self._time_of_last_save = self.now()
def _get_cooldown(self): if self._time_of_last_save is not None: current_time = services.server_clock_service().now() cooldown = PersistenceTuning.SAVE_GAME_COOLDOWN - (current_time - self._time_of_last_save).in_real_world_seconds() return cooldown return 0
def generate_statistics(): now_ticks = services.server_clock_service().now().absolute_ticks() ticks_elapsed = now_ticks - previous_log_time_ticks now_time = time.time() time_elapsed = now_time - previous_log_time_stamp ticks_per_sec = 0 if time_elapsed != 0: ticks_per_sec = ticks_elapsed / time_elapsed else: ticks_per_sec = 'Zero time elapsed. ticks elapsed = {}'.format( ticks_elapsed) num_sim_infos = 0 num_sims = 0 for sim_info in services.sim_info_manager().objects: num_sim_infos += 1 if sim_info.is_instanced(allow_hidden_flags=ALL_HIDDEN_REASONS): num_sims += 1 all_props = [] if services.prop_manager(): all_props = list(services.prop_manager().objects) all_objects = list(services.object_manager().objects) all_inventory_objects = list( services.current_zone().inventory_manager.objects) objects_active_lot_interactive = [] objects_active_lot_decorative = [] objects_open_street_interactive = [] objects_open_street_decorative = [] for obj in all_objects: if obj.is_on_active_lot(): if obj.definition.has_build_buy_tag( *PerformanceHandlerTuning.DECORATIVE_OBJECT_TAGS_ACTIVE_LOT ): objects_active_lot_decorative.append(obj) else: objects_active_lot_interactive.append(obj) elif obj.definition.has_build_buy_tag( *PerformanceHandlerTuning.DECORATIVE_OBJECT_TAGS_OPEN_STREET): objects_open_street_decorative.append(obj) else: objects_open_street_interactive.append(obj) objects_active_lot_autonomous = [] objects_open_street_autonomous = [] objects_active_lot_user_directed = [] objects_open_street_user_directed = [] autonomous_counter = Counter() user_directed_counter = Counter() def process_interactive_objects(objects, autonomous_list, user_directed_list, autonomous_counter, user_directed_counter, location='undefined'): for obj in objects: in_autonomous_list = False in_user_directed_list = False in_user_directed_counter = (obj.definition.name, location) in user_directed_counter for sa in obj.super_affordances(): if sa.allow_autonomous: autonomous_counter.update({(sa, location): 1}) if not in_autonomous_list: in_autonomous_list = True autonomous_list.append(obj) if not in_user_directed_counter: user_directed_counter.update({ (obj.definition.name, location): 1 }) if not (sa.allow_user_directed and in_user_directed_list): in_user_directed_list = True user_directed_list.append(obj) process_interactive_objects(objects_active_lot_interactive, objects_active_lot_autonomous, objects_active_lot_user_directed, autonomous_counter, user_directed_counter, location='active_lot') process_interactive_objects(objects_open_street_interactive, objects_open_street_autonomous, objects_open_street_user_directed, autonomous_counter, user_directed_counter, location='open_street') performance_metrics.clear() set_gsi_performance_metric('num_sims', num_sims) set_gsi_performance_metric('num_sim_infos', num_sim_infos) set_gsi_performance_metric( 'num_objects_active_lot', len(objects_active_lot_interactive) + len(objects_active_lot_decorative)) set_gsi_performance_metric( 'num_objects_open_street', len(objects_open_street_interactive) + len(objects_open_street_decorative)) set_gsi_performance_metric('num_props', len(all_props)) set_gsi_performance_metric('total_objects_props', len(all_props) + len(all_objects)) set_gsi_performance_metric(consts.TICKS_PER_SECOND, ticks_per_sec) metrics = [ (consts.OBJS_ACTIVE_LOT_INTERACTIVE, lambda: len(objects_active_lot_interactive)), (consts.OBJS_ACTIVE_LOT_DECORATIVE, lambda: len(objects_active_lot_decorative)), (consts.OBJS_OPEN_STREET_INTERACTIVE, lambda: len(objects_open_street_interactive)), (consts.OBJS_OPEN_STREET_DECORATIVE, lambda: len(objects_open_street_decorative)), (consts.OBJS_TOTAL, lambda: len(all_objects)), (consts.PROPS_TOTAL, lambda: len(all_props)), (consts.OBJS_INVENTORY_TOTAL, lambda: len(all_inventory_objects)), (consts.OBJS_GRAND_TOTAL, lambda: len(all_props) + len(all_objects) + len(all_inventory_objects) ), (consts.OBJS_ACTIVE_LOT_AUTONOMOUS_AFFORDANCE, lambda: len(objects_active_lot_autonomous)), (consts.OBJS_OPEN_STREET_AUTONOMOUS_AFFORDANCE, lambda: len(objects_open_street_autonomous)), (consts.OBJS_AUTONOMOUS_AFFORDANCE, lambda: sum(autonomous_counter.values())) ] details = list() for (name, func) in metrics: entry = {'metric': name, 'count': func()} details.append(entry) set_gsi_performance_metric('AdditionalMetrics', details) def generate_histogram(name, objects, fill_gsi_func, histogram_counter=None, object_name_func=None): if histogram_counter is None: histogram_counter = Counter(objects) histogram = list() for (obj, freq) in histogram_counter.most_common(): entry = fill_gsi_func(obj, freq, object_name_func=object_name_func) histogram.append(entry) set_gsi_performance_metric(name, histogram) def fill_gsi_object_location_histogram_entry(object_location_pair, frequency, object_name_func=None): obj_name = object_name_func( object_location_pair[0] ) if object_name_func is not None else object_location_pair[0] return { 'name': obj_name, 'location': object_location_pair[1], 'frequency': frequency } def combine_object_location_lists(active_lot_list, open_street_list): all_objects = [(active_lot_obj.definition.name, 'active_lot') for active_lot_obj in active_lot_list] all_objects.extend([(open_street_obj.definition.name, 'open_street') for open_street_obj in open_street_list]) return all_objects all_objects_locations_interactive = combine_object_location_lists( objects_active_lot_interactive, objects_open_street_interactive) all_objects_locations_decorative = combine_object_location_lists( objects_active_lot_decorative, objects_open_street_decorative) all_objects_locations_autonomous = combine_object_location_lists( objects_active_lot_autonomous, objects_open_street_autonomous) sa_name_func = lambda x: x.__name__ generate_histogram(consts.OBJECT_CLASSIFICATIONS[0], all_objects_locations_interactive, fill_gsi_object_location_histogram_entry) generate_histogram(consts.OBJECT_CLASSIFICATIONS[1], all_objects_locations_decorative, fill_gsi_object_location_histogram_entry) generate_histogram(consts.OBJECT_CLASSIFICATIONS[2], all_objects_locations_autonomous, fill_gsi_object_location_histogram_entry) generate_histogram(consts.OBJECT_CLASSIFICATIONS[3], [], fill_gsi_object_location_histogram_entry, autonomous_counter, sa_name_func) generate_histogram(consts.OBJECT_CLASSIFICATIONS[4], [], fill_gsi_object_location_histogram_entry, user_directed_counter) return performance_metrics
def _update_time_spent_in_speed(self, current_speed): server_time = services.server_clock_service().ticks() server_ticks_spent_in_current_speed = server_time - self._last_speed_change_server_time self._server_ticks_spent_in_speed[ current_speed] += server_ticks_spent_in_current_speed self._last_speed_change_server_time = server_time
def server_time_since_update(self): time_delta = services.server_clock_service().now( ) - self.server_time_last_update self.server_time_last_update = services.server_clock_service().now() return time_delta.in_ticks()
def generate_statistics(): now_ticks = services.server_clock_service().now().absolute_ticks() ticks_elapsed = now_ticks - previous_log_time_ticks now_time = time.time() time_elapsed = now_time - previous_log_time_stamp ticks_per_sec = 0 if time_elapsed != 0: ticks_per_sec = ticks_elapsed / time_elapsed else: ticks_per_sec = 'Zero time elapsed. ticks elapsed = {}'.format( ticks_elapsed) num_sim_infos = 0 num_sims = 0 for sim_info in services.sim_info_manager().objects: num_sim_infos += 1 while sim_info.is_instanced(allow_hidden_flags=ALL_HIDDEN_REASONS): num_sims += 1 all_props = [] if services.prop_manager(): all_props = list(services.prop_manager().objects) all_objects = list(services.object_manager().objects) all_inventory_objects = list( services.current_zone().inventory_manager.objects) objects_active_lot_interactive = [] objects_active_lot_decorative = [] objects_open_street_interactive = [] objects_open_street_decorative = [] for obj in all_objects: tags = obj.definition.build_buy_tags if obj.is_on_active_lot(): if PerformanceHandlerTuning.DECORATIVE_OBJECT_TAGS_ACTIVE_LOT & tags: objects_active_lot_decorative.append(obj) else: objects_active_lot_interactive.append(obj) if PerformanceHandlerTuning.DECORATIVE_OBJECT_TAGS_OPEN_STREET & tags: objects_open_street_decorative.append(obj) else: objects_open_street_interactive.append(obj) elif PerformanceHandlerTuning.DECORATIVE_OBJECT_TAGS_OPEN_STREET & tags: objects_open_street_decorative.append(obj) else: objects_open_street_interactive.append(obj) performance_metrics.clear() set_gsi_performance_metric('num_sims', num_sims) set_gsi_performance_metric('num_sim_infos', num_sim_infos) set_gsi_performance_metric( 'num_objects_active_lot', len(objects_active_lot_interactive) + len(objects_active_lot_decorative)) set_gsi_performance_metric( 'num_objects_open_street', len(objects_open_street_interactive) + len(objects_open_street_decorative)) set_gsi_performance_metric('num_props', len(all_props)) set_gsi_performance_metric('total_objects_props', len(all_props) + len(all_objects)) set_gsi_performance_metric('ticks_per_sec', ticks_per_sec) metrics = [ ('#Objects (Active Lot) Interactive', lambda: len(objects_active_lot_interactive)), ('#Objects (Active Lot) Decorative', lambda: len(objects_active_lot_decorative)), ('#Objects (OpenStreet) Interactive', lambda: len(objects_open_street_interactive)), ('#Objects (OpenStreet) Decorative', lambda: len(objects_open_street_decorative)), ('Total Objects', lambda: len(all_objects)), ('Total Props', lambda: len(all_props)), ('Total Inventory Objects', lambda: len(all_inventory_objects)), ('Grand Total (Objs,Props,InventoryObjs)', lambda: len(all_props) + len(all_objects) + len(all_inventory_objects) ) ] details = list() for (name, func) in metrics: entry = {'metric': name, 'count': func()} details.append(entry) set_gsi_performance_metric('AdditionalMetrics', details) def generate_histogram(name, objects): histogram_counter = Counter([obj.definition.name for obj in objects]) histogram = list() for (obj_name, freq) in histogram_counter.most_common(): entry = {'object_name': obj_name, 'frequency': freq} histogram.append(entry) set_gsi_performance_metric(name, histogram) generate_histogram(OBJECT_CLASSIFICATIONS[0], objects_active_lot_interactive) generate_histogram(OBJECT_CLASSIFICATIONS[1], objects_active_lot_decorative) generate_histogram(OBJECT_CLASSIFICATIONS[2], objects_open_street_interactive) generate_histogram(OBJECT_CLASSIFICATIONS[3], objects_open_street_decorative) return performance_metrics
def server_time_since_update(self): time_delta = services.server_clock_service().now() - self.server_time_last_update self.server_time_last_update = services.server_clock_service().now() return time_delta.in_ticks()
def set_update_alarm(self): self.sim_time_on_connect = services.time_service().sim_now self.server_time_on_connect = services.server_clock_service().now() self.sim_time_last_update = self.sim_time_on_connect self.server_time_last_update = self.server_time_on_connect self.update_alarm_handle = alarms.add_alarm(self, TimeSpan(self.TIME_DATA_UPDATE_RATE), self._update_timer_alarm, True)