@quenty/signal 7.5.0 → 7.7.0

package/CHANGELOG.md

@@ -3,6 +3,38 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [7.7.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/signal@7.6.0...@quenty/signal@7.7.0) (2024-10-04)
+
+
+### Bug Fixes
+
+* GoodSignal now uses the connection memory category instead of the original items memory category, resulting in even more accurate tracking ([c18353d](https://github.com/Quenty/NevermoreEngine/commit/c18353d61a4b4966ad4025c3b7e58b895dcb16a8))
+
+
+### Performance Improvements
+
+* Connection clears references, and avoids storing _connected and _next, which reduces memory usage of signal ([8738269](https://github.com/Quenty/NevermoreEngine/commit/8738269c457b8075b89dd18e7371a103413879d6))
+
+
+
+
+
+# [7.6.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/signal@7.5.0...@quenty/signal@7.6.0) (2024-09-25)
+
+
+### Bug Fixes
+
+* Selene doesn't know debug.getmemorycategory() ([0c613a3](https://github.com/Quenty/NevermoreEngine/commit/0c613a3ae0b6ba6a4cda511f572220bfa951c70d))
+
+
+### Features
+
+* MemoryCategory is tracked properly in signal (Not sure what the perf implications of this are) ([4d43b0c](https://github.com/Quenty/NevermoreEngine/commit/4d43b0c0c07fd5d24335b1801ca96c58d37ba149))
+
+
+
+
+
 # [7.5.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/signal@7.4.0...@quenty/signal@7.5.0) (2024-09-25)
 
 **Note:** Version bump only for package @quenty/signal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/signal",
-  "version": "7.5.0",
+  "version": "7.7.0",
   "description": "A simple signal implementation for Roblox",
   "keywords": [
     "Roblox",
@@ -30,7 +30,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@quenty/loader": "^10.5.0"
+    "@quenty/loader": "^10.6.0"
   },
-  "gitHead": "41715b15e2b48b2d22ff4f5277a8d4b7a0d32ef3"
+  "gitHead": "035abfa088c854a73e1c65b350267eaa17669646"
 }

package/src/Shared/GoodSignal.lua

@@ -44,25 +44,31 @@
 ]=]
 
 -- The currently idle thread to run the next handler on
-local freeRunnerThread = nil
+local weakFreeRunnerThreadLookup = setmetatable({}, {__mode = "kv"})
 
 -- Function which acquires the currently idle handler runner thread, runs the
 -- function fn on it, and then releases the thread, returning it to being the
 -- currently idle one.
 -- If there was a currently idle runner thread already, that's okay, that old
 -- one will just get thrown and eventually GCed.
-local function acquireRunnerThreadAndCallEventHandler(fn, ...)
-	local acquiredRunnerThread = freeRunnerThread
-	freeRunnerThread = nil
+local function acquireRunnerThreadAndCallEventHandler(memoryCategory, fn, ...)
+	local acquiredRunnerThread = weakFreeRunnerThreadLookup[memoryCategory]
+	weakFreeRunnerThreadLookup[memoryCategory] = nil
 	fn(...)
 	-- The handler finished running, this runner thread is free again.
-	freeRunnerThread = acquiredRunnerThread
+	weakFreeRunnerThreadLookup[memoryCategory] = acquiredRunnerThread
 end
 
 -- Coroutine runner that we create coroutines of. The coroutine can be
 -- repeatedly resumed with functions to run followed by the argument to run
 -- them with.
-local function runEventHandlerInFreeThread()
+local function runEventHandlerInFreeThread(memoryCategory)
+	if #memoryCategory == 0 then
+		debug.setmemorycategory("signal_unknown")
+	else
+		debug.setmemorycategory(memoryCategory)
+	end
+
 	-- Note: We cannot use the initial set of arguments passed to
 	-- runEventHandlerInFreeThread for a call to the handler, because those
 	-- arguments would stay on the stack for the duration of the thread's
@@ -75,40 +81,56 @@ end
 
 -- Connection class
 local Connection = {}
+Connection.ClassName = "Connection"
 Connection.__index = Connection
 
 function Connection.new(signal, fn)
 	return setmetatable({
-		_connected = true,
+		-- selene: allow(incorrect_standard_library_use)
+		_memoryCategory = debug.getmemorycategory(),
 		_signal = signal,
 		_fn = fn,
-		_next = false,
 	}, Connection)
 end
 
+function Connection:IsConnected()
+	return rawget(self, "_signal") ~= nil
+end
+
 function Connection:Disconnect()
-	self._connected = false
-
-	-- Unhook the node, but DON'T clear it. That way any fire calls that are
-	-- currently sitting on this node will be able to iterate forwards off of
-	-- it, but any subsequent fire calls will not hit it, and it will be GCed
-	-- when no more fire calls are sitting on it.
-	if self._signal._handlerListHead == self then
-		self._signal._handlerListHead = self._next
+	local signal = rawget(self, "_signal")
+	if not signal then
+		return
+	end
+
+	-- Unhook the node. Originally the good signal would not clear this signal and
+	-- rely upon GC. However, this means that connections would keep themselves and other
+	-- disconnected nodes in the chain alive, keeping the function closure alive, and in return
+	-- keeping the signal alive. This means a `Maid` could keep full object trees alive if a
+	-- connection was made to them.
+
+	local ourNext = rawget(self, "_next")
+
+	if signal._handlerListHead == self then
+		signal._handlerListHead = ourNext or false
 	else
-		local prev = self._signal._handlerListHead
-		while prev and prev._next ~= self do
-			prev = prev._next
+		local prev = signal._handlerListHead
+		while prev and rawget(prev, "_next") ~= self do
+			prev = rawget(prev, "_next")
 		end
 		if prev then
-			prev._next = self._next
+			rawset(prev, "_next", ourNext)
 		end
 	end
+
+	-- Clear all member variables that aren't _next so keeping a connection
+	-- indexed allows for GC of other components
+	table.clear(self)
 end
 
 Connection.Destroy = Connection.Disconnect
 
--- Make Connection strict
+-- Make signal strict
 setmetatable(Connection, {
 	__index = function(_, key)
 		error(string.format("Attempt to get Connection::%s (not a valid member)", tostring(key)), 2)
@@ -153,7 +175,7 @@ end
 function Signal:Connect(fn)
 	local connection = Connection.new(self, fn)
 	if self._handlerListHead then
-		connection._next = self._handlerListHead
+		rawset(connection, "_next", self._handlerListHead)
 		self._handlerListHead = connection
 	else
 		self._handlerListHead = connection
@@ -186,17 +208,26 @@ end
 	@param ... T -- Variable arguments to pass to handler
 ]=]
 function Signal:Fire(...)
-	local item = self._handlerListHead
-	while item do
-		if item._connected then
-			if not freeRunnerThread then
-				freeRunnerThread = coroutine.create(runEventHandlerInFreeThread)
-				-- Get the freeRunnerThread to the first yield
-				coroutine.resume(freeRunnerThread)
+	local connection = self._handlerListHead
+	while connection do
+		-- capture our next node, which could after this be cleared or disconnected.
+		-- any connections occuring during fire will be added to the _handerListHead and not be fired
+		-- in this round. Any disconnections in the chain will still work here.
+		local nextNode = rawget(connection, "_next")
+
+		if rawget(connection, "_signal") ~= nil then -- isConnected
+			local memoryCategory = connection._memoryCategory
+
+			-- Get the freeRunnerThread to the first yield
+			if not weakFreeRunnerThreadLookup[memoryCategory] then
+				weakFreeRunnerThreadLookup[memoryCategory] = coroutine.create(runEventHandlerInFreeThread)
+				coroutine.resume(weakFreeRunnerThreadLookup[memoryCategory], memoryCategory)
 			end
-			task.spawn(freeRunnerThread, item._fn, ...)
+
+			task.spawn(weakFreeRunnerThreadLookup[memoryCategory], memoryCategory, connection._fn, ...)
 		end
-		item = item._next
+
+		connection = nextNode
 	end
 end
 
@@ -213,11 +244,13 @@ end
 ]=]
 function Signal:Wait()
 	local waitingCoroutine = coroutine.running()
-	local cn;
-	cn = self:Connect(function(...)
-		cn:Disconnect()
+
+	local connection
+	connection = self:Connect(function(...)
+		connection:Disconnect()
 		task.spawn(waitingCoroutine, ...)
 	end)
+
 	return coroutine.yield()
 end
 
@@ -233,14 +266,12 @@ end
 	@return RBXScriptConnection
 ]=]
 function Signal:Once(fn)
-	local cn;
-	cn = self:Connect(function(...)
-		if cn._connected then
-			cn:Disconnect()
-		end
+	local connection
+	connection = self:Connect(function(...)
+		connection:Disconnect()
 		fn(...)
 	end)
-	return cn
+	return connection
 end
 
 --[=[