mirror of
https://github.com/goonstation/goonstation-2020.git
synced 2026-07-11 15:12:22 +01:00
ZeWaka
111 lines
3.3 KiB
Plaintext
111 lines
3.3 KiB
Plaintext
datum/updateQueueWorker
|
|
var/tmp/list/objects
|
|
var/tmp/killed
|
|
var/tmp/finished
|
|
var/tmp/procName
|
|
var/tmp/list/arguments
|
|
var/tmp/lastStart
|
|
var/tmp/cpuThreshold
|
|
var/tmp/cpuDeferCount
|
|
|
|
datum/updateQueueWorker/New(var/list/objects, var/procName, var/list/arguments, var/cpuThreshold = 90)
|
|
..()
|
|
uq_dbg("updateQueueWorker created.")
|
|
|
|
init(objects, procName, arguments, cpuThreshold)
|
|
|
|
datum/updateQueueWorker/proc/init(var/list/objects, var/procName, var/list/arguments, var/cpuThreshold = 90)
|
|
src.objects = objects
|
|
src.procName = procName
|
|
src.arguments = arguments
|
|
src.cpuThreshold = cpuThreshold
|
|
cpuDeferCount = 0
|
|
|
|
killed = 0
|
|
finished = 0
|
|
|
|
datum/updateQueueWorker/proc/doWork()
|
|
// If there's nothing left to execute or we were killed, mark finished and return.
|
|
if (!objects || !objects.len) return finished()
|
|
|
|
lastStart = world.timeofday // Absolute number of ticks since the world started up
|
|
|
|
var/datum/object = objects[objects.len] // Pull out the object
|
|
objects.len-- // Remove the object from the list
|
|
|
|
if (istype(object) && !object.disposed) // We only work with real objects
|
|
#ifdef QUEUE_STAT_DEBUG
|
|
var/t = world.time
|
|
#endif
|
|
call(object, procName)(arglist(arguments))
|
|
#ifdef QUEUE_STAT_DEBUG
|
|
register_subject_time(object, world.time-t)
|
|
#endif
|
|
|
|
// If there's nothing left to execute
|
|
// or we were killed while running the above code, mark finished and return.
|
|
if (!objects || !objects.len) return finished()
|
|
|
|
if (world.cpu > cpuThreshold + cpuDeferCount * 10)
|
|
// We don't want to force a tick into overtime!
|
|
// If the tick is about to go overtime, spawn the next update to go
|
|
// in the next tick.
|
|
|
|
// We don't want to defer indefinitely. Each tick the queue defers, increment the defer count so it will tolerate a little more lag
|
|
cpuDeferCount++
|
|
|
|
uq_dbg("tick went into overtime with world.cpu = [world.cpu], deferred next update to next tick [1+(world.time / world.tick_lag)]")
|
|
|
|
SPAWN_DBG(1 DECI SECOND)
|
|
doWork()
|
|
else
|
|
SPAWN_DBG(0) // Execute anonymous function immediately as if we were in a while loop...
|
|
doWork()
|
|
|
|
datum/updateQueueWorker/proc/finished()
|
|
uq_dbg("updateQueueWorker finished.")
|
|
/**
|
|
* If the worker was killed while it was working on something, it
|
|
* should delete itself when it finally finishes working on it.
|
|
* Meanwhile, the updateQueue will have proceeded on with the rest of
|
|
* the queue. This will also terminate the spawned function that was
|
|
* created in the kill() proc.
|
|
*/
|
|
if(killed)
|
|
del(src)
|
|
|
|
finished = 1
|
|
|
|
datum/updateQueueWorker/proc/kill()
|
|
uq_dbg("updateQueueWorker killed.")
|
|
killed = 1
|
|
objects = null
|
|
|
|
/**
|
|
* If the worker is not done in 30 seconds after it's killed,
|
|
* we'll forcibly delete it, causing the anonymous function it was
|
|
* running to be terminated. Hasta la vista, baby.
|
|
*/
|
|
SPAWN_DBG(30 SECONDS)
|
|
del(src)
|
|
|
|
datum/updateQueueWorker/proc/start()
|
|
uq_dbg("updateQueueWorker started.")
|
|
SPAWN_DBG(0)
|
|
doWork()
|
|
|
|
|
|
#ifdef QUEUE_STAT_DEBUG
|
|
datum/updateQueueWorker/proc/register_subject_time(var/datum/D, var/time)
|
|
if(!D) return
|
|
var/list/qtl = queue_stat_list[D.type]
|
|
if(!qtl)
|
|
qtl = list()
|
|
qtl.len = 2
|
|
qtl[1] = 0 //The amount of time spent processing this thing in total
|
|
qtl[2] = 0 //The amount of times this thing has been processed
|
|
queue_stat_list[D.type] = qtl
|
|
|
|
qtl[1] += time
|
|
qtl[2]++
|
|
#endif |