From c6e8184b58c78c256eed76ffa110bf4b30adb2cf Mon Sep 17 00:00:00 2001 From: Leshana Date: Wed, 27 Dec 2017 19:10:15 -0500 Subject: [PATCH] Ports https://github.com/tgstation/tgstation/pull/30184 * Adds defines for world.tick_usage * This provides no useful benefit whatsoever, but /tg and Baystation12 have done it, so it will make porting future code easier if we do too. No real harm done either. --- code/__defines/MC.dm | 4 ++-- code/__defines/{tick.dm => _tick.dm} | 4 +++- code/__defines/math.dm | 2 +- code/__defines/process_scheduler.dm | 2 +- code/_helpers/time.dm | 8 ++++---- .../ProcessScheduler/core/process.dm | 12 ++++++------ code/controllers/master.dm | 18 +++++++++--------- code/controllers/subsystems/garbage.dm | 4 ++-- code/controllers/subsystems/lighting.dm | 12 ++++++------ polaris.dme | 2 +- 10 files changed, 35 insertions(+), 33 deletions(-) rename code/__defines/{tick.dm => _tick.dm} (62%) diff --git a/code/__defines/MC.dm b/code/__defines/MC.dm index fb15a693bf..b2f3c814fe 100644 --- a/code/__defines/MC.dm +++ b/code/__defines/MC.dm @@ -1,10 +1,10 @@ -#define MC_TICK_CHECK ( ( world.tick_usage > Master.current_ticklimit || src.state != SS_RUNNING ) ? pause() : 0 ) +#define MC_TICK_CHECK ( ( TICK_USAGE > Master.current_ticklimit || src.state != SS_RUNNING ) ? pause() : 0 ) // Used for splitting up your remaining time into phases, if you want to evenly divide it. #define MC_SPLIT_TICK_INIT(phase_count) var/original_tick_limit = Master.current_ticklimit; var/split_tick_phases = ##phase_count #define MC_SPLIT_TICK \ if(split_tick_phases > 1){\ - Master.current_ticklimit = ((original_tick_limit - world.tick_usage) / split_tick_phases) + world.tick_usage;\ + Master.current_ticklimit = ((original_tick_limit - TICK_USAGE) / split_tick_phases) + TICK_USAGE;\ --split_tick_phases;\ } else {\ Master.current_ticklimit = original_tick_limit;\ diff --git a/code/__defines/tick.dm b/code/__defines/_tick.dm similarity index 62% rename from code/__defines/tick.dm rename to code/__defines/_tick.dm index 4c88fd643e..4dcbe76510 100644 --- a/code/__defines/tick.dm +++ b/code/__defines/_tick.dm @@ -3,5 +3,7 @@ #define TICK_LIMIT_MC 70 #define TICK_LIMIT_MC_INIT_DEFAULT 98 -#define TICK_CHECK ( world.tick_usage > Master.current_ticklimit ) +#define TICK_CHECK ( TICK_USAGE > Master.current_ticklimit ) #define CHECK_TICK if TICK_CHECK stoplag() + +#define TICK_USAGE world.tick_usage diff --git a/code/__defines/math.dm b/code/__defines/math.dm index 0729a4526d..4f1abc44ed 100644 --- a/code/__defines/math.dm +++ b/code/__defines/math.dm @@ -2,7 +2,7 @@ //percent_of_tick_used * (ticklag * 100(to convert to ms)) / 100(percent ratio) //collapsed to percent_of_tick_used * tick_lag #define TICK_DELTA_TO_MS(percent_of_tick_used) ((percent_of_tick_used) * world.tick_lag) -#define TICK_USAGE_TO_MS(starting_tickusage) (TICK_DELTA_TO_MS(world.tick_usage-starting_tickusage)) +#define TICK_USAGE_TO_MS(starting_tickusage) (TICK_DELTA_TO_MS(TICK_USAGE-starting_tickusage)) //time of day but automatically adjusts to the server going into the next day within the same round. //for when you need a reliable time number that doesn't depend on byond time. diff --git a/code/__defines/process_scheduler.dm b/code/__defines/process_scheduler.dm index f1e30c23ed..4bc841022f 100644 --- a/code/__defines/process_scheduler.dm +++ b/code/__defines/process_scheduler.dm @@ -15,4 +15,4 @@ #define PROCESS_DEFAULT_DEFER_USAGE 90 // 90% of a tick // Sleep check macro -#define SCHECK if(world.tick_usage >= next_sleep_usage) defer() +#define SCHECK if(TICK_USAGE >= next_sleep_usage) defer() diff --git a/code/_helpers/time.dm b/code/_helpers/time.dm index 3a6bcedcd1..2e2bf505ef 100644 --- a/code/_helpers/time.dm +++ b/code/_helpers/time.dm @@ -11,7 +11,7 @@ #define DAYS *864000 #define TimeOfGame (get_game_time()) -#define TimeOfTick (world.tick_usage*0.01*world.tick_lag) +#define TimeOfTick (TICK_USAGE*0.01*world.tick_lag) /proc/get_game_time() var/global/time_offset = 0 @@ -19,7 +19,7 @@ var/global/last_usage = 0 var/wtime = world.time - var/wusage = world.tick_usage * 0.01 + var/wusage = TICK_USAGE * 0.01 if(last_time < wtime && last_usage > 1) time_offset += last_usage - 1 @@ -111,7 +111,7 @@ var/round_start_time = 0 //Increases delay as the server gets more overloaded, //as sleeps aren't cheap and sleeping only to wake up and sleep again is wasteful -#define DELTA_CALC max(((max(world.tick_usage, world.cpu) / 100) * max(Master.sleep_delta,1)), 1) +#define DELTA_CALC max(((max(TICK_USAGE, world.cpu) / 100) * max(Master.sleep_delta,1)), 1) /proc/stoplag() . = 0 @@ -120,4 +120,4 @@ var/round_start_time = 0 . += round(i*DELTA_CALC) sleep(i*world.tick_lag*DELTA_CALC) i *= 2 - while (world.tick_usage > min(TICK_LIMIT_TO_RUN, Master.current_ticklimit)) + while (TICK_USAGE > min(TICK_LIMIT_TO_RUN, Master.current_ticklimit)) diff --git a/code/controllers/ProcessScheduler/core/process.dm b/code/controllers/ProcessScheduler/core/process.dm index 9f08241978..2965a52abe 100644 --- a/code/controllers/ProcessScheduler/core/process.dm +++ b/code/controllers/ProcessScheduler/core/process.dm @@ -124,7 +124,7 @@ cpu_defer_count = 0 // Prepare usage tracking (defer() updates these) - tick_usage_start = world.tick_usage + tick_usage_start = TICK_USAGE tick_usage_accumulated = 0 running() @@ -142,7 +142,7 @@ /datum/controller/process/proc/recordRunTime() // Convert from tick usage (100/tick) to seconds of CPU time used - var/total_usage = (tick_usage_accumulated + (world.tick_usage - tick_usage_start)) / 1000 * world.tick_lag + var/total_usage = (tick_usage_accumulated + (TICK_USAGE - tick_usage_start)) / 1000 * world.tick_lag last_run_time = total_usage if(total_usage > highest_run_time) @@ -222,14 +222,14 @@ handleHung() CRASH("Process [name] hung and was restarted.") - tick_usage_accumulated += (world.tick_usage - tick_usage_start) - if(world.tick_usage < defer_usage) + tick_usage_accumulated += (TICK_USAGE - tick_usage_start) + if(TICK_USAGE < defer_usage) sleep(0) else sleep(world.tick_lag) cpu_defer_count++ - tick_usage_start = world.tick_usage - next_sleep_usage = min(world.tick_usage + sleep_interval, defer_usage) + tick_usage_start = TICK_USAGE + next_sleep_usage = min(TICK_USAGE + sleep_interval, defer_usage) /datum/controller/process/proc/update() // Clear delta diff --git a/code/controllers/master.dm b/code/controllers/master.dm index a538d887e8..ef9189f944 100644 --- a/code/controllers/master.dm +++ b/code/controllers/master.dm @@ -279,7 +279,7 @@ var/datum/controller/master/Master = new() //if there are mutiple sleeping procs running before us hogging the cpu, we have to run later // because sleeps are processed in the order received, so longer sleeps are more likely to run first - if (world.tick_usage > TICK_LIMIT_MC) + if (TICK_USAGE > TICK_LIMIT_MC) sleep_delta += 2 current_ticklimit = TICK_LIMIT_RUNNING * 0.5 sleep(world.tick_lag * (processing + sleep_delta)) @@ -288,7 +288,7 @@ var/datum/controller/master/Master = new() sleep_delta = MC_AVERAGE_FAST(sleep_delta, 0) if (last_run + (world.tick_lag * processing) > world.time) sleep_delta += 1 - if (world.tick_usage > (TICK_LIMIT_MC*0.5)) + if (TICK_USAGE > (TICK_LIMIT_MC*0.5)) sleep_delta += 1 if (make_runtime) @@ -394,13 +394,13 @@ var/datum/controller/master/Master = new() //keep running while we have stuff to run and we haven't gone over a tick // this is so subsystems paused eariler can use tick time that later subsystems never used - while (ran && queue_head && world.tick_usage < TICK_LIMIT_MC) + while (ran && queue_head && TICK_USAGE < TICK_LIMIT_MC) ran = FALSE bg_calc = FALSE current_tick_budget = queue_priority_count queue_node = queue_head while (queue_node) - if (ran && world.tick_usage > TICK_LIMIT_RUNNING) + if (ran && TICK_USAGE > TICK_LIMIT_RUNNING) break queue_node_flags = queue_node.flags @@ -412,7 +412,7 @@ var/datum/controller/master/Master = new() //(unless we haven't even ran anything this tick, since its unlikely they will ever be able run // in those cases, so we just let them run) if (queue_node_flags & SS_NO_TICK_CHECK) - if (queue_node.tick_usage > TICK_LIMIT_RUNNING - world.tick_usage && ran_non_ticker) + if (queue_node.tick_usage > TICK_LIMIT_RUNNING - TICK_USAGE && ran_non_ticker) queue_node.queued_priority += queue_priority_count * 0.10 queue_priority_count -= queue_node_priority queue_priority_count += queue_node.queued_priority @@ -424,19 +424,19 @@ var/datum/controller/master/Master = new() current_tick_budget = queue_priority_count_bg bg_calc = TRUE - tick_remaining = TICK_LIMIT_RUNNING - world.tick_usage + tick_remaining = TICK_LIMIT_RUNNING - TICK_USAGE if (current_tick_budget > 0 && queue_node_priority > 0) tick_precentage = tick_remaining / (current_tick_budget / queue_node_priority) else tick_precentage = tick_remaining - current_ticklimit = world.tick_usage + tick_precentage + current_ticklimit = TICK_USAGE + tick_precentage if (!(queue_node_flags & SS_TICKER)) ran_non_ticker = TRUE ran = TRUE - tick_usage = world.tick_usage + tick_usage = TICK_USAGE queue_node_paused = (queue_node.state == SS_PAUSED || queue_node.state == SS_PAUSING) last_type_processed = queue_node @@ -446,7 +446,7 @@ var/datum/controller/master/Master = new() if (state == SS_RUNNING) state = SS_IDLE current_tick_budget -= queue_node_priority - tick_usage = world.tick_usage - tick_usage + tick_usage = TICK_USAGE - tick_usage if (tick_usage < 0) tick_usage = 0 diff --git a/code/controllers/subsystems/garbage.dm b/code/controllers/subsystems/garbage.dm index d6db860d5d..35e7c8c667 100644 --- a/code/controllers/subsystems/garbage.dm +++ b/code/controllers/subsystems/garbage.dm @@ -150,7 +150,7 @@ SUBSYSTEM_DEF(garbage) //this is purely to seperate things profile wise. /datum/controller/subsystem/garbage/proc/HardDelete(datum/A) var/time = world.timeofday - var/tick = world.tick_usage + var/tick = TICK_USAGE var/ticktime = world.time var/type = A.type @@ -158,7 +158,7 @@ SUBSYSTEM_DEF(garbage) del(A) - tick = (world.tick_usage-tick+((world.time-ticktime)/world.tick_lag*100)) + tick = (TICK_USAGE-tick+((world.time-ticktime)/world.tick_lag*100)) if (tick > highest_del_tickusage) highest_del_tickusage = tick time = world.timeofday - time diff --git a/code/controllers/subsystems/lighting.dm b/code/controllers/subsystems/lighting.dm index 01875cc397..8817d83ad5 100644 --- a/code/controllers/subsystems/lighting.dm +++ b/code/controllers/subsystems/lighting.dm @@ -50,27 +50,27 @@ SUBSYSTEM_DEF(lighting) stage = SSLIGHTING_STAGE_LIGHTS // Start with Step 1 of course if(stage == SSLIGHTING_STAGE_LIGHTS) - timer = world.tick_usage + timer = TICK_USAGE internal_process_lights(resumed) - cost_lights = MC_AVERAGE(cost_lights, TICK_DELTA_TO_MS(world.tick_usage - timer)) + cost_lights = MC_AVERAGE(cost_lights, TICK_DELTA_TO_MS(TICK_USAGE - timer)) if(state != SS_RUNNING) return resumed = 0 stage = SSLIGHTING_STAGE_CORNERS if(stage == SSLIGHTING_STAGE_CORNERS) - timer = world.tick_usage + timer = TICK_USAGE internal_process_corners(resumed) - cost_corners = MC_AVERAGE(cost_corners, TICK_DELTA_TO_MS(world.tick_usage - timer)) + cost_corners = MC_AVERAGE(cost_corners, TICK_DELTA_TO_MS(TICK_USAGE - timer)) if(state != SS_RUNNING) return resumed = 0 stage = SSLIGHTING_STAGE_OVERLAYS if(stage == SSLIGHTING_STAGE_OVERLAYS) - timer = world.tick_usage + timer = TICK_USAGE internal_process_overlays(resumed) - cost_overlays = MC_AVERAGE(cost_overlays, TICK_DELTA_TO_MS(world.tick_usage - timer)) + cost_overlays = MC_AVERAGE(cost_overlays, TICK_DELTA_TO_MS(TICK_USAGE - timer)) if(state != SS_RUNNING) return resumed = 0 diff --git a/polaris.dme b/polaris.dme index aa828d2631..e09ddb0026 100644 --- a/polaris.dme +++ b/polaris.dme @@ -20,6 +20,7 @@ #include "code\world.dm" #include "code\__defines\_compile_options.dm" #include "code\__defines\_planes+layers.dm" +#include "code\__defines\_tick.dm" #include "code\__defines\admin.dm" #include "code\__defines\appearance.dm" #include "code\__defines\atmos.dm" @@ -45,7 +46,6 @@ #include "code\__defines\species_languages.dm" #include "code\__defines\subsystems.dm" #include "code\__defines\targeting.dm" -#include "code\__defines\tick.dm" #include "code\__defines\turfs.dm" #include "code\__defines\unit_tests.dm" #include "code\__defines\xenoarcheaology.dm"