cyberpresidentvanellope/fulpstation
1
0
Fork 0
mirror of https://github.com/fulpstation/fulpstation.git synced 2025-12-10 18:11:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Modified qdel() to accept any datum.

Browse Source 
The garbage controller no longer bothers nulling out every variable on destroyed objects.
An object can opt to not be collected by returning true from Destroy().  Useful for pools or other edge cases.
Fixed boxes not being collected, along with a couple other things.
Turfs will not be monitored for collection.
generate_ion_law() is no longer a /datum proc, and I am an admin in the repo.  Deal with it.
This commit is contained in:
YotaXP
2014-03-10 16:19:48 -04:00
parent ad43f3ecba
commit 3656217c29
11 changed files with 101 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

170
code/controllers/garbage.dm
View File

@@ -1,67 +1,31 @@
#define GC_COLLECTIONS_PER_TICK 100 // how many objects we're going to null the vars of per tick
#define GC_COLLECTION_TIMEOUT 300 // deciseconds to wait to let running procs finish before we just say fuck it and force del() the object
#define GC_DEL_CHECK_PER_TICK 100 // number of tests per tick to make sure our GC'd objects are actually GC'd
#define GC_FORCE_DEL_PER_TICK 20 // max force del() calls per tick
#define GC_COLLECTION_TIMEOUT 300 // deciseconds to wait to let running procs finish before we just say fuck it and force del() the object
#define GC_DEL_CHECK_PER_CYCLE 100 // number of tests per cycle to make sure our GC'd objects are actually GC'd
#define GC_FORCE_DEL_PER_CYCLE 20 // max force del() calls per cycle
var/datum/controller/garbage_collector/garbage = new()
var/list/uncollectable_vars=list(
// "bounds", // bounds and its ilk are all caught by the issaved() check later on
"contents",
"gc_destroyed",
"invisibility",
"gender", // Causes runtimes if the logging is on
"parent",
"step_size",
)
// These are the vars left from /vg/'s implementation that aren't const or global
// I dunno how many are necessary but since most of these are numbers anyways, I don't care.
/datum/controller/garbage_collector
var/dels = 0 // number of del()'s we've done this tick
var/list/queue = list() // list of things that have yet to have all their vars nulled out
var/list/destroyed = list() // list of refID's of things that should be garbage collected
// refID's are associated with the time at which they time out and need to be manually del()
// we do this so we aren't constantly locating them and preventing them from being gc'd
/datum/controller/garbage_collector/proc/AddTrash(var/atom/movable/A)
if(!istype(A))
/datum/controller/garbage_collector/proc/AddTrash(var/datum/A)
if(!istype(A) || A.gc_destroyed)
return
// testing("GC: AddTrash([A.type])")
queue |= A
/datum/controller/garbage_collector/proc/Pop()
var/atom/movable/A = queue[1]
if(!A)
queue.Cut(1, 2)
// testing("GC: Pop() given null")
return
if(!istype(A,/atom/movable))
// testing("GC: -- Pop() given [A.type] --")
queue.Cut(1, 2)
dels++
del(A)
return
for(var/vname in A.vars)
if(!issaved(A.vars[vname]))
// testing("GC: Skipping [vname] in [A.type]: it's const|global|tmp")
continue
if(vname in uncollectable_vars)
// testing("GC: Skipping [vname] in [A.type]: it's uncollectable")
continue
// testing("GC: Unsetting [vname] in [A.type]")
A.vars[vname] = null
// testing("GC: Pop([A.type]) - destroyed\[\ref[A]\] = [A.gc_destroyed] current time: [world.time] first:[queue[1]] second:[queue.len > 1 ? "[queue[2]]" : "NOTHING"]")
destroyed["\ref[A]"] = A.gc_destroyed
queue.Cut(1, 2)
A.gc_destroyed = world.time
destroyed["\ref[A]"] = world.time
/datum/controller/garbage_collector/proc/process()
dels = 0
var/i
for(i = 1, queue.len && i <= GC_COLLECTIONS_PER_TICK, i++)
Pop()
var/time_to_kill = world.time - GC_COLLECTION_TIMEOUT // Anything qdel() but not GC'd BEFORE this time needs to be manually del()
for(i = 1, destroyed.len && i <= GC_DEL_CHECK_PER_TICK, i++)
var/checkRemain = GC_DEL_CHECK_PER_CYCLE
while(destroyed.len && --checkRemain >= 0)
if(dels > GC_FORCE_DEL_PER_CYCLE)
// testing("GC: Reached max force dels per tick [dels] vs [GC_FORCE_DEL_PER_TICK]")
break // Server's already pretty pounded, everything else can wait 2 seconds
var/refID = destroyed[1]
var/GCd_at_time = destroyed[refID]
if(GCd_at_time > time_to_kill)
@@ -71,61 +35,93 @@ var/list/uncollectable_vars=list(
// testing("GC: [refID] old enough to test: GCd_at_time: [GCd_at_time] time_to_kill: [time_to_kill] current: [world.time]")
if(A && A.gc_destroyed == GCd_at_time) // So if something else coincidently gets the same ref, it's not deleted by mistake
// Something's still referring to the qdel'd object. Kill it.
if(dels >= GC_FORCE_DEL_PER_TICK)
// testing("GC: Reached max force dels per tick [dels] vs [GC_FORCE_DEL_PER_TICK]")
break // Server's already pretty pounded, everything else can wait 2 seconds
testing("GC: -- \ref[A] | [A.type] was unable to be garbage collected and was force del() --")
testing("GC: -- \ref[A] | [A.type] was unable to be GC'd and was deleted --")
del(A)
dels++
// else
// testing("GC: [refID] properly GC'd at [world.time] with timeout [GCd_at_time]")
destroyed.Cut(1, 2)
/**
* NEVER USE THIS FOR ANYTHING OTHER THAN /atom/movable
* OTHER TYPES CANNOT BE QDEL'D BECAUSE THEIR LOC IS LOCKED OR THEY DON'T HAVE ONE.
* While I'm leaving the above comment in since /atoms cannot be garbage collected, datums and lists can be garbage collected just fine.
* Read the DM guide on it. Hit f1 and search for "garbage collection"
*/
/proc/qdel(var/atom/movable/A)
// Should be treated as a replacement for the 'del' keyword.
// Datums passed to this will be given a chance to clean up references to allow the GC to collect them.
/proc/qdel(var/datum/A)
if(!A)
return
if(!garbage)
del(A)
return
if(!istype(A))
warning("qdel() passed object of type [A.type]. qdel() can only handle /atom/movable types.")
garbage.dels++
//warning("qdel() passed object of type [A.type]. qdel() can only handle /datum types.")
del(A)
return
// Let our friend know they're about to get fucked up.
A.Destroy()
garbage.AddTrash(A)
if(garbage)
garbage.dels++
else
// Let our friend know they're about to get fucked up.
. = !A.Destroy()
if(. && A)
if(garbage && !isturf(A))
garbage.AddTrash(A)
else
del(A)
// Default implementation of clean-up code.
// This should be overridden to remove all references pointing to the object being destroyed.
// Return true if the the GC controller should allow the object to continue existing. (Useful if pooling objects.)
/datum/proc/Destroy()
del(src)
/*
// Uncomment this verb and run it on things to report blockages.
/atom/verb/qdel_test()
set name = "qdel with test"
/datum/var/gc_destroyed //Time when this object was destroyed.
#ifdef TESTING
/client/var/running_find_references
/atom/verb/find_references()
set category = "Debug"
set name = "Find References"
set background = 1
set src in world
qdel(src)
for(var/datum/everything) //Yes this works.
for(var/everyvar in everything.vars)
var/variable = everything.vars[everyvar]
if(!usr || !usr.client)
return
if(usr.client.running_find_references)
testing("CANCELLED search for references to a [usr.client.running_find_references].")
usr.client.running_find_references = null
return
if(alert("Running this will create a lot of lag until it finishes. You can cancel it by running it again. Would you like to begin the search?", "Find References", "Yes", "No") == "No")
return
// Remove this object from the list of things to be auto-deleted.
if(garbage)
garbage.destroyed -= "\ref[src]"
usr.client.running_find_references = type
testing("Beginning search for references to a [type].")
var/list/things = list()
for(var/client/thing)
things += thing
for(var/datum/thing)
things += thing
for(var/atom/thing)
things += thing
testing("Collected list of things in search for references to a [type]. ([things.len] Thing\s)")
for(var/datum/thing in things)
if(!usr.client.running_find_references) return
for(var/varname in thing.vars)
var/variable = thing.vars[varname]
if(variable == src)
testing("Found [src.type] \ref[src] in [everything.type]'s [everyvar] var.")
testing("Found [src.type] \ref[src] in [thing.type]'s [varname] var.")
else if(islist(variable))
if(src in variable)
testing("Found [src.type]\ref[src] in [everything.type]'s [everyvar] var.")
for(var/atom/movable/everything) //The slow part.
for(var/everyvar in everything.vars)
var/variable = everything.vars[everyvar]
if(variable == src)
testing("Found [src.type] \ref[src] in [everything.type]'s [everyvar] var.")
else if(islist(variable))
if(src in variable)
testing("Found [src.type]\ref[src] in [everything.type]'s [everyvar] var.")
*/
testing("Found [src.type] \ref[src] in [thing.type]'s [varname] list var.")
testing("Completed search for references to a [type].")
usr.client.running_find_references = null
/client/verb/purge_all_destroyed_objects()
set category = "Debug"
if(garbage)
while(garbage.destroyed.len)
var/datum/o = locate(garbage.destroyed[1])
if(istype(o) && o.gc_destroyed)
del(o)
garbage.dels++
garbage.destroyed.Cut(1, 2)
#endif