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 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 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 _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 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)
