Port of @PsiOmegaDelta's Baystation12/Baystation12#16820

Ports tg's garbage collector subsystem and Destroy() returning qdel hints.

code/controllers/ProcessScheduler/core/process.dm

@@ -387,6 +387,6 @@
 			exceptions[eid] = 0
 
 /datum/controller/process/proc/catchBadType(var/datum/caught)
-	if(isnull(caught) || !istype(caught) || !isnull(caught.gcDestroyed))
+	if(isnull(caught) || !istype(caught) || QDELETED(caught))
 		return // Only bother with types we can identify and that don't belong
 	catchException("Type [caught.type] does not belong in process' queue")

code/controllers/Processes/garbage.dm

@@ -1,254 +0,0 @@
-// The time a datum was destroyed by the GC, or null if it hasn't been
-/datum/var/gcDestroyed
-
-#define GC_COLLECTIONS_PER_RUN 300
-#define GC_COLLECTION_TIMEOUT (30 SECONDS)
-#define GC_FORCE_DEL_PER_RUN 30
-
-var/datum/controller/process/garbage_collector/garbage_collector
-var/list/delayed_garbage = list()
-
-/datum/controller/process/garbage_collector
-	var/garbage_collect = 1			// Whether or not to actually do work
-	var/total_dels 	= 0			// number of total del()'s
-	var/tick_dels 	= 0			// number of del()'s we've done this tick
-	var/soft_dels	= 0
-	var/hard_dels 	= 0			// number of hard dels in total
-	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
-
-	var/list/logging = list()	// list of all types that have failed to GC associated with the number of times that's happened.
-								// the types are stored as strings
-
-/datum/controller/process/garbage_collector/setup()
-	name = "garbage"
-	schedule_interval = 5 SECONDS
-	start_delay = 3
-
-	if(!garbage_collector)
-		garbage_collector = src
-
-	for(var/garbage in delayed_garbage)
-		qdel(garbage)
-	delayed_garbage.Cut()
-	delayed_garbage = null
-
-#ifdef GC_FINDREF
-world/loop_checks = 0
-#endif
-
-/datum/controller/process/garbage_collector/doWork()
-	if(!garbage_collect)
-		return
-
-	tick_dels = 0
-	var/time_to_kill = world.time - GC_COLLECTION_TIMEOUT
-	var/checkRemain = GC_COLLECTIONS_PER_RUN
-	var/remaining_force_dels = GC_FORCE_DEL_PER_RUN
-
-
-	while(destroyed.len && --checkRemain >= 0)
-		if(remaining_force_dels <= 0)
-			#ifdef GC_DEBUG
-			testing("GC: Reached max force dels per tick [dels] vs [maxDels]")
-			#endif
-			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)
-			#ifdef GC_DEBUG
-			testing("GC: [refID] not old enough, breaking at [world.time] for [GCd_at_time - time_to_kill] deciseconds until [GCd_at_time + collection_timeout]")
-			#endif
-			break // Everything else is newer, skip them
-		var/datum/A = locate(refID)
-		#ifdef GC_DEBUG
-		testing("GC: [refID] old enough to test: GCd_at_time: [GCd_at_time] time_to_kill: [time_to_kill] current: [world.time]")
-		#endif
-		if(A && A.gcDestroyed == 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.
-			testing("GC: -- \ref[A] | [A.type] was unable to be GC'd and was deleted --")
-			logging["[A.type]"]++
-			del(A)
-
-			hard_dels++
-			remaining_force_dels--
-		else
-			#ifdef GC_DEBUG
-			testing("GC: [refID] properly GC'd at [world.time] with timeout [GCd_at_time]")
-			#endif
-			soft_dels++
-		tick_dels++
-		total_dels++
-		destroyed.Cut(1, 2)
-		SCHECK
-
-#undef GC_FORCE_DEL_PER_TICK
-#undef GC_COLLECTION_TIMEOUT
-#undef GC_COLLECTIONS_PER_TICK
-
-#ifdef GC_FINDREF
-/datum/controller/process/garbage_collector/proc/LookForRefs(var/datum/D, var/list/targ)
-	. = 0
-	for(var/V in D.vars)
-		if(V == "contents")
-			continue
-		if(istype(D.vars[V], /atom))
-			var/atom/A = D.vars[V]
-			if(A in targ)
-				testing("GC: [A] | [A.type] referenced by [D] | [D.type], var [V]")
-				. += 1
-		else if(islist(D.vars[V]))
-			. += LookForListRefs(D.vars[V], targ, D, V)
-
-/datum/controller/process/garbage_collector/proc/LookForListRefs(var/list/L, var/list/targ, var/datum/D, var/V)
-	. = 0
-	for(var/F in L)
-		if(istype(F, /atom))
-			var/atom/A = F
-			if(A in targ)
-				testing("GC: [A] | [A.type] referenced by [D] | [D.type], list [V]")
-				. += 1
-		if(islist(F))
-			. += LookForListRefs(F, targ, D, "[F] in list [V]")
-#endif
-
-/datum/controller/process/garbage_collector/proc/AddTrash(datum/A)
-	if(!istype(A) || !isnull(A.gcDestroyed))
-		return
-	#ifdef GC_DEBUG
-	testing("GC: AddTrash(\ref[A] - [A.type])")
-	#endif
-	A.gcDestroyed = world.time
-	destroyed -= "\ref[A]" // Removing any previous references that were GC'd so that the current object will be at the end of the list.
-	destroyed["\ref[A]"] = world.time
-
-/datum/controller/process/garbage_collector/statProcess()
-	..()
-	stat(null, "[garbage_collect ? "On" : "Off"], [destroyed.len] queued")
-	stat(null, "Dels: [total_dels], [soft_dels] soft, [hard_dels] hard, [tick_dels]  last run")
-
-
-// Tests if an atom has been deleted.
-/proc/deleted(atom/A)
-	return !A || !isnull(A.gcDestroyed)
-
-// 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(!istype(A))
-		warning("qdel() passed object of type [A.type]. qdel() can only handle /datum types.")
-		crash_with("qdel() passed object of type [A.type]. qdel() can only handle /datum types.")
-		del(A)
-		if(garbage_collector)
-			garbage_collector.total_dels++
-			garbage_collector.hard_dels++
-	else if(isnull(A.gcDestroyed))
-		// Let our friend know they're about to get collected
-		. = !A.Destroy()
-		if(. && A)
-			A.finalize_qdel()
-
-/datum/proc/finalize_qdel()
-	del(src)
-
-/atom/finalize_qdel()
-	if(garbage_collector)
-		garbage_collector.AddTrash(src)
-	else
-		delayed_garbage |= src
-
-/icon/finalize_qdel()
-	del(src)
-
-/image/finalize_qdel()
-	del(src)
-
-/mob/finalize_qdel()
-	del(src)
-
-/turf/finalize_qdel()
-	del(src)
-
-// 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.
-/datum/proc/Destroy()
-	nanomanager.close_uis(src)
-	tag = null
-	return
-
-#ifdef TESTING
-/client/var/running_find_references
-
-/mob/verb/create_thing()
-	set category = "Debug"
-	set name = "Create Thing"
-
-	var/path = input("Enter path")
-	var/atom/thing = new path(loc)
-	thing.find_references()
-
-/atom/verb/find_references()
-	set category = "Debug"
-	set name = "Find References"
-	set background = 1
-	set src in world
-
-	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_collector)
-		garbage_collector.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 [thing.type]'s [varname] var.")
-			else if(islist(variable))
-				if(src in variable)
-					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_collector)
-		while(garbage_collector.destroyed.len)
-			var/datum/o = locate(garbage_collector.destroyed[1])
-			if(istype(o) && o.gcDestroyed)
-				del(o)
-				garbage_collector.dels++
-			garbage_collector.destroyed.Cut(1, 2)
-#endif
-
-#ifdef GC_DEBUG
-#undef GC_DEBUG
-#endif
-
-#ifdef GC_FINDREF
-#undef GC_FINDREF
-#endif

code/controllers/Processes/machinery.dm

@@ -20,7 +20,7 @@
 /datum/controller/process/machinery/proc/internal_process_machinery()
 	for(last_object in machines)
 		var/obj/machinery/M = last_object
-		if(M && !M.gcDestroyed)
+		if(M && !QDELETED(M))
 			if(M.process() == PROCESS_KILL)
 				//M.inMachineList = 0 We don't use this debugging function
 				machines.Remove(M)
@@ -34,7 +34,7 @@
 /datum/controller/process/machinery/proc/internal_process_power()
 	for(last_object in powernets)
 		var/datum/powernet/powerNetwork = last_object
-		if(istype(powerNetwork) && isnull(powerNetwork.gcDestroyed))
+		if(istype(powerNetwork) && !QDELETED(powerNetwork))
 			powerNetwork.reset()
 			SCHECK
 			continue
@@ -52,7 +52,7 @@
 /datum/controller/process/machinery/proc/internal_process_pipenets()
 	for(last_object in pipe_networks)
 		var/datum/pipe_network/pipeNetwork = last_object
-		if(istype(pipeNetwork) && isnull(pipeNetwork.gcDestroyed))
+		if(istype(pipeNetwork) && !QDELETED(pipeNetwork))
 			pipeNetwork.process()
 			SCHECK
 			continue

code/controllers/Processes/mob.dm

@@ -14,7 +14,7 @@
 /datum/controller/process/mob/doWork()
 	for(last_object in mob_list)
 		var/mob/M = last_object
-		if(M && isnull(M.gcDestroyed))
+		if(M && !QDELETED(M))
 			try
 				M.Life()
 			catch(var/exception/e)

code/controllers/Processes/nanoui.dm

@@ -9,7 +9,7 @@
 /datum/controller/process/nanoui/doWork()
 	for(last_object in nanomanager.processing_uis)
 		var/datum/nanoui/NUI = last_object
-		if(istype(NUI) && isnull(NUI.gcDestroyed))
+		if(istype(NUI) && !QDELETED(NUI))
 			try
 				NUI.process()
 			catch(var/exception/e)

code/controllers/Processes/obj.dm

@@ -11,7 +11,7 @@
 /datum/controller/process/obj/doWork()
 	for(last_object in processing_objects)
 		var/datum/O = last_object
-		if(O && isnull(O.gcDestroyed))
+		if(!QDELETED(O))
 			try
 				O:process()
 			catch(var/exception/e)

code/controllers/Processes/scheduler.dm

@@ -30,8 +30,8 @@
 // Note: We won't be informed about tasks being destroyed, but this is the best we can do.
 /datum/controller/process/scheduler/copyStateFrom(var/datum/controller/process/scheduler/target)
 	scheduled_tasks = list()
-	for(var/st in target.scheduled_tasks)
-		if(!deleted(st) && istype(st, /datum/scheduled_task))
+	for(var/datum/scheduled_task/st in target.scheduled_tasks)
+		if(!QDELETED(st) && istype(st))
 			schedule(st)
 	scheduler = src
 

code/controllers/failsafe.dm

@@ -33,13 +33,13 @@ var/datum/controller/failsafe/Failsafe
 /datum/controller/failsafe/Initialize()
 	set waitfor = 0
 	Failsafe.Loop()
-	if(!deleted(src))
+	if(!QDELETED(src))
 		qdel(src) //when Loop() returns, we delete ourselves and let the mc recreate us
 
 /datum/controller/failsafe/Destroy()
 	running = FALSE
 	..()
-	// return QDEL_HINT_HARDDEL_NOW // TODO - Once we port garbage.dm
+	return QDEL_HINT_HARDDEL_NOW
 
 /datum/controller/failsafe/proc/Loop()
 	while(running)

code/controllers/master.dm

@@ -66,7 +66,7 @@ var/CURRENT_TICKLIMIT = TICK_LIMIT_RUNNING
 /datum/controller/master/Destroy()
 	..()
 	// Tell qdel() to Del() this object.
-	// return QDEL_HINT_HARDDEL_NOW  // TODO - Once we port garbage.dm
+	return QDEL_HINT_HARDDEL_NOW
 
 /datum/controller/master/Shutdown()
 	processing = FALSE

code/controllers/master_controller.dm

@@ -49,7 +49,7 @@ datum/controller/game_controller/proc/setup_objects()
 	admin_notice("<span class='danger'>Initializing objects</span>", R_DEBUG)
 	sleep(-1)
 	for(var/atom/movable/object in world)
-		if(isnull(object.gcDestroyed))
+		if(!QDELETED(object))
 			object.initialize()
 
 	admin_notice("<span class='danger'>Initializing areas</span>", R_DEBUG)
@@ -80,8 +80,8 @@ datum/controller/game_controller/proc/setup_objects()
 
 	admin_notice("<span class='danger'>Initializing turbolifts</span>", R_DEBUG)
 	for(var/thing in turbolifts)
-		if(!deleted(thing))
-			var/obj/turbolift_map_holder/lift = thing
+		var/obj/turbolift_map_holder/lift = thing
+		if(!QDELETED(lift))
 			lift.initialize()
 			sleep(-1)
 

code/controllers/subsystems/garbage.dm

@@ -0,0 +1,354 @@
+var/datum/controller/subsystem/garbage_collector/SSgarbage
+
+/datum/controller/subsystem/garbage_collector
+	name = "Garbage"
+	priority = 15
+	wait = 5
+	flags = SS_FIRE_IN_LOBBY|SS_POST_FIRE_TIMING|SS_BACKGROUND|SS_NO_INIT
+
+	var/collection_timeout = 3000// deciseconds to wait to let running procs finish before we just say fuck it and force del() the object
+	var/delslasttick = 0		// number of del()'s we've done this tick
+	var/gcedlasttick = 0		// number of things that gc'ed last tick
+	var/totaldels = 0
+	var/totalgcs = 0
+
+	var/highest_del_time = 0
+	var/highest_del_tickusage = 0
+
+	var/list/queue = 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
+
+	var/list/tobequeued = list()	//We store the references of things to be added to the queue seperately so we can spread out GC overhead over a few ticks
+
+	var/list/didntgc = list()	// list of all types that have failed to GC associated with the number of times that's happened.
+								// the types are stored as strings
+	var/list/sleptDestroy = list()	//Same as above but these are paths that slept during their Destroy call
+
+	var/list/noqdelhint = list()// list of all types that do not return a QDEL_HINT
+	// all types that did not respect qdel(A, force=TRUE) and returned one
+	// of the immortality qdel hints
+	var/list/noforcerespect = list()
+
+#ifdef TESTING
+	var/list/qdel_list = list()	// list of all types that have been qdel()eted
+#endif
+
+/datum/controller/subsystem/garbage_collector/New()
+	NEW_SS_GLOBAL(SSgarbage)
+
+/datum/controller/subsystem/garbage_collector/stat_entry(msg)
+	msg += "Q:[queue.len]|D:[delslasttick]|G:[gcedlasttick]|"
+	msg += "GR:"
+	if (!(delslasttick+gcedlasttick))
+		msg += "n/a|"
+	else
+		msg += "[round((gcedlasttick/(delslasttick+gcedlasttick))*100, 0.01)]%|"
+
+	msg += "TD:[totaldels]|TG:[totalgcs]|"
+	if (!(totaldels+totalgcs))
+		msg += "n/a|"
+	else
+		msg += "TGR:[round((totalgcs/(totaldels+totalgcs))*100, 0.01)]%"
+	..(msg)
+
+/datum/controller/subsystem/garbage_collector/fire()
+	HandleToBeQueued()
+	if(state == SS_RUNNING)
+		HandleQueue()
+
+//If you see this proc high on the profile, what you are really seeing is the garbage collection/soft delete overhead in byond.
+//Don't attempt to optimize, not worth the effort.
+/datum/controller/subsystem/garbage_collector/proc/HandleToBeQueued()
+	var/list/tobequeued = src.tobequeued
+	var/starttime = world.time
+	var/starttimeofday = world.timeofday
+	while(tobequeued.len && starttime == world.time && starttimeofday == world.timeofday)
+		if (MC_TICK_CHECK)
+			break
+		var/ref = tobequeued[1]
+		Queue(ref)
+		tobequeued.Cut(1, 2)
+
+/datum/controller/subsystem/garbage_collector/proc/HandleQueue()
+	delslasttick = 0
+	gcedlasttick = 0
+	var/time_to_kill = world.time - collection_timeout // Anything qdel() but not GC'd BEFORE this time needs to be manually del()
+	var/list/queue = src.queue
+	var/starttime = world.time
+	var/starttimeofday = world.timeofday
+	while(queue.len && starttime == world.time && starttimeofday == world.timeofday)
+		if (MC_TICK_CHECK)
+			break
+		var/refID = queue[1]
+		if (!refID)
+			queue.Cut(1, 2)
+			continue
+
+		var/GCd_at_time = queue[refID]
+		if(GCd_at_time > time_to_kill)
+			break // Everything else is newer, skip them
+		queue.Cut(1, 2)
+		var/datum/A
+		A = locate(refID)
+		if (A && A.gc_destroyed == GCd_at_time) // So if something else coincidently gets the same ref, it's not deleted by mistake
+			#ifdef GC_FAILURE_HARD_LOOKUP
+			A.find_references()
+			#endif
+
+			// Something's still referring to the qdel'd object.  Kill it.
+			var/type = A.type
+			testing("GC: -- \ref[A] | [type] was unable to be GC'd and was deleted --")
+			didntgc["[type]"]++
+			var/time = world.timeofday
+			var/tick = world.tick_usage
+			var/ticktime = world.time
+			del(A)
+			tick = (world.tick_usage-tick+((world.time-ticktime)/world.tick_lag*100))
+
+			if (tick > highest_del_tickusage)
+				highest_del_tickusage = tick
+			time = world.timeofday - time
+			if (!time && TICK_DELTA_TO_MS(tick) > 1)
+				time = TICK_DELTA_TO_MS(tick)/100
+			if (time > highest_del_time)
+				highest_del_time = time
+			if (time > 10)
+				log_game("Error: [type]([refID]) took longer then 1 second to delete (took [time/10] seconds to delete)")
+				message_admins("Error: [type]([refID]) took longer then 1 second to delete (took [time/10] seconds to delete).")
+				postpone(time/5)
+				break
+			++delslasttick
+			++totaldels
+		else
+			++gcedlasttick
+			++totalgcs
+
+/datum/controller/subsystem/garbage_collector/proc/QueueForQueuing(datum/A)
+	if (istype(A) && A.gc_destroyed == GC_CURRENTLY_BEING_QDELETED)
+		tobequeued += A
+		A.gc_destroyed = GC_QUEUED_FOR_QUEUING
+
+/datum/controller/subsystem/garbage_collector/proc/Queue(datum/A)
+	if (!istype(A) || (!isnull(A.gc_destroyed) && A.gc_destroyed >= 0))
+		return
+	if (A.gc_destroyed == GC_QUEUED_FOR_HARD_DEL)
+		del(A)
+		return
+	var/gctime = world.time
+	var/refid = "\ref[A]"
+
+	A.gc_destroyed = gctime
+
+	if (queue[refid])
+		queue -= refid // Removing any previous references that were GC'd so that the current object will be at the end of the list.
+
+	queue[refid] = gctime
+
+/datum/controller/subsystem/garbage_collector/proc/HardQueue(datum/A)
+	if (istype(A) && A.gc_destroyed == GC_CURRENTLY_BEING_QDELETED)
+		tobequeued += A
+		A.gc_destroyed = GC_QUEUED_FOR_HARD_DEL
+
+/datum/controller/subsystem/garbage_collector/Recover()
+	if (istype(SSgarbage.queue))
+		queue |= SSgarbage.queue
+	if (istype(SSgarbage.tobequeued))
+		tobequeued |= SSgarbage.tobequeued
+
+// 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(datum/D, force=FALSE)
+	if(!D)
+		return
+#ifdef TESTING
+	SSgarbage.qdel_list += D.type
+#endif
+	if(!istype(D))
+		log_debug("qdel() was passed [log_info_line(D)]. qdel() can only handle instances of (sub)type /datum.")
+		del(D)
+	else if(isnull(D.gc_destroyed))
+		D.gc_destroyed = GC_CURRENTLY_BEING_QDELETED
+		var/start_time = world.time
+		var/hint = D.Destroy(force) // Let our friend know they're about to get fucked up.
+		if(world.time != start_time)
+			SSgarbage.sleptDestroy[D.type]++
+		if(!D)
+			return
+		switch(hint)
+			if (QDEL_HINT_QUEUE)		//qdel should queue the object for deletion.
+				SSgarbage.QueueForQueuing(D)
+			if (QDEL_HINT_IWILLGC)
+				D.gc_destroyed = world.time
+				return
+			if (QDEL_HINT_LETMELIVE)	//qdel should let the object live after calling destory.
+				if(!force)
+					D.gc_destroyed = null //clear the gc variable (important!)
+					return
+				// Returning LETMELIVE after being told to force destroy
+				// indicates the objects Destroy() does not respect force
+				if(!SSgarbage.noforcerespect[D.type])
+					SSgarbage.noforcerespect[D.type] = D.type
+					crash_with("[D.type] has been force deleted, but is \
+						returning an immortal QDEL_HINT, indicating it does \
+						not respect the force flag for qdel(). It has been \
+						placed in the queue, further instances of this type \
+						will also be queued.")
+				SSgarbage.QueueForQueuing(D)
+			if (QDEL_HINT_HARDDEL)		//qdel should assume this object won't gc, and queue a hard delete using a hard reference to save time from the locate()
+				SSgarbage.HardQueue(D)
+			if (QDEL_HINT_HARDDEL_NOW)	//qdel should assume this object won't gc, and hard del it post haste.
+				del(D)
+			if (QDEL_HINT_FINDREFERENCE)//qdel will, if TESTING is enabled, display all references to this object, then queue the object for deletion.
+				SSgarbage.QueueForQueuing(D)
+				#ifdef TESTING
+				D.find_references()
+				#endif
+			else
+				if(!SSgarbage.noqdelhint[D.type])
+					SSgarbage.noqdelhint[D.type] = D.type
+					crash_with("[D.type] is not returning a qdel hint. It is being placed in the queue. Further instances of this type will also be queued.")
+				SSgarbage.QueueForQueuing(D)
+	else if(D.gc_destroyed == GC_CURRENTLY_BEING_QDELETED)
+		CRASH("[D.type] destroy proc was called multiple times, likely due to a qdel loop in the Destroy logic")
+
+// Default implementation of clean-up code.
+// This should be overridden to remove all references pointing to the object being destroyed.
+// Return the appropriate QDEL_HINT; in most cases this is QDEL_HINT_QUEUE.
+/datum/proc/Destroy(force=FALSE)
+	tag = null
+	nanomanager.close_uis(src)
+	return QDEL_HINT_QUEUE
+
+/datum/var/gc_destroyed //Time when this object was destroyed.
+
+#ifdef TESTING
+/datum/var/running_find_references
+/datum/var/last_find_references = 0
+
+/datum/verb/find_refs()
+	set category = "Debug"
+	set name = "Find References"
+	set background = 1
+	set src in world
+
+	find_references(FALSE)
+
+/datum/proc/find_references(skip_alert)
+	running_find_references = type
+	if(usr && usr.client)
+		if(usr.client.running_find_references)
+			testing("CANCELLED search for references to a [usr.client.running_find_references].")
+			usr.client.running_find_references = null
+			running_find_references = null
+			//restart the garbage collector
+			SSgarbage.can_fire = 1
+			SSgarbage.next_fire = world.time + world.tick_lag
+			return
+
+		if(!skip_alert)
+			if(alert("Running this will lock everything up for about 5 minutes.  Would you like to begin the search?", "Find References", "Yes", "No") == "No")
+				running_find_references = null
+				return
+
+	//this keeps the garbage collector from failing to collect objects being searched for in here
+	SSgarbage.can_fire = 0
+
+	if(usr && usr.client)
+		usr.client.running_find_references = type
+
+	testing("Beginning search for references to a [type].")
+	last_find_references = world.time
+	find_references_in_globals()
+	for(var/datum/thing in world)
+		DoSearchVar(thing, "WorldRef: [thing]")
+	testing("Completed search for references to a [type].")
+	if(usr && usr.client)
+		usr.client.running_find_references = null
+	running_find_references = null
+
+	//restart the garbage collector
+	SSgarbage.can_fire = 1
+	SSgarbage.next_fire = world.time + world.tick_lag
+
+/client/verb/purge_all_destroyed_objects()
+	set category = "Debug"
+	if(SSgarbage)
+		while(SSgarbage.queue.len)
+			var/datum/o = locate(SSgarbage.queue[1])
+			if(istype(o) && o.gc_destroyed)
+				del(o)
+				SSgarbage.totaldels++
+			SSgarbage.queue.Cut(1, 2)
+
+/datum/verb/qdel_then_find_references()
+	set category = "Debug"
+	set name = "qdel() then Find References"
+	set background = 1
+	set src in world
+
+	qdel(src)
+	if(!running_find_references)
+		find_references(TRUE)
+
+/client/verb/show_qdeleted()
+	set category = "Debug"
+	set name = "Show qdel() Log"
+	set desc = "Render the qdel() log and display it"
+
+	var/dat = "<B>List of things that have been qdel()eted this round</B><BR><BR>"
+
+	var/tmplist = list()
+	for(var/elem in SSgarbage.qdel_list)
+		if(!(elem in tmplist))
+			tmplist[elem] = 0
+		tmplist[elem]++
+
+	for(var/path in tmplist)
+		dat += "[path] - [tmplist[path]] times<BR>"
+
+	usr << browse(dat, "window=qdeletedlog")
+
+/datum/proc/DoSearchVar(X, Xname)
+	if(usr && usr.client && !usr.client.running_find_references) return
+	if(istype(X, /datum))
+		var/datum/D = X
+		if(D.last_find_references == last_find_references)
+			return
+		D.last_find_references = last_find_references
+		for(var/V in D.vars)
+			for(var/varname in D.vars)
+				var/variable = D.vars[varname]
+				if(variable == src)
+					testing("Found [src.type] \ref[src] in [D.type]'s [varname] var. [Xname]")
+				else if(islist(variable))
+					if(src in variable)
+						testing("Found [src.type] \ref[src] in [D.type]'s [varname] list var. Global: [Xname]")
+#ifdef GC_FAILURE_HARD_LOOKUP
+					for(var/I in variable)
+						DoSearchVar(I, TRUE)
+				else
+					DoSearchVar(variable, "[Xname]: [varname]")
+#endif
+	else if(islist(X))
+		if(src in X)
+			testing("Found [src.type] \ref[src] in list [Xname].")
+#ifdef GC_FAILURE_HARD_LOOKUP
+		for(var/I in X)
+			DoSearchVar(I, Xname + ": list")
+#else
+	CHECK_TICK
+#endif
+
+//if find_references isn't working for some datum
+//update this list using tools/GenerateGlobalVarAccess
+/datum/proc/find_references_in_globals()
+	// TODO - Impement Global Variable Access
+	// for(var/global_var in _all_globals)
+	// 	DoSearchVar(readglobal(global_var), "Global: [global_var]")
+#endif
+
+
+/image/Destroy()
+	..()
+	return QDEL_HINT_HARDDEL_NOW