@quenty/signal 7.8.1 → 7.9.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [7.9.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/signal@7.8.1...@quenty/signal@7.9.0) (2024-11-06)
+
+
+### Performance Improvements
+
+* Better perf check on category ([594d5bb](https://github.com/Quenty/NevermoreEngine/commit/594d5bb8f56817b501f7c47053615d6cc3f8e313))
+
+
+
+
+
 ## [7.8.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/signal@7.8.0...@quenty/signal@7.8.1) (2024-11-04)
 
 **Note:** Version bump only for package @quenty/signal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/signal",
-  "version": "7.8.1",
+  "version": "7.9.0",
   "description": "A simple signal implementation for Roblox",
   "keywords": [
     "Roblox",
@@ -32,5 +32,5 @@
   "dependencies": {
     "@quenty/loader": "^10.7.1"
   },
-  "gitHead": "01c43a0ddd3c5e0cb2d9027313dbfa9852eedef1"
+  "gitHead": "00e6f71716216dd6ecbc8505ad898a1ab7f72756"
 }

package/src/Shared/EventHandlerUtils.lua

@@ -0,0 +1,66 @@
+--[=[
+	Utility methods to fire an event in a free thread, reusing threads
+
+	@class EventHandlerUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local EventHandlerUtils = {}
+
+-- The currently idle thread to run the next handler on
+local freeThreads = 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.
+function EventHandlerUtils._fireEvent(memoryCategory, fn, ...)
+	local acquiredRunnerThread = freeThreads[memoryCategory]
+	freeThreads[memoryCategory] = nil
+	fn(...)
+	-- The handler finished running, this runner thread is free again.
+	freeThreads[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.
+function EventHandlerUtils._initializeThread(memoryCategory)
+	if memoryCategory == "" then
+		debug.setmemorycategory("signal_unknown")
+	else
+		debug.setmemorycategory(memoryCategory)
+	end
+
+	-- Note: We cannot use the initial set of arguments passed to
+	-- initializeThread for a call to the handler, because those
+	-- arguments would stay on the stack for the duration of the thread's
+	-- existence, temporarily leaking references. Without access to raw bytecode
+	-- there's no way for us to clear the "..." references from the stack.
+	while true do
+		EventHandlerUtils._fireEvent(coroutine.yield())
+	end
+end
+
+--[=[
+	Safely fires an event in the given memory category we're in
+
+	@param memoryCategory string
+	@param callback any
+	@param ... any
+]=]
+function EventHandlerUtils.fire(memoryCategory, callback, ...)
+	assert(type(memoryCategory) == "string", "Bad memoryCategory")
+	assert(type(callback) == "function", "Bad callback")
+
+	if not freeThreads[memoryCategory] then
+		freeThreads[memoryCategory] = coroutine.create(EventHandlerUtils._initializeThread)
+		coroutine.resume(freeThreads[memoryCategory], memoryCategory)
+	end
+
+	task.spawn(freeThreads[memoryCategory], memoryCategory, callback, ...)
+end
+
+return EventHandlerUtils

package/src/Shared/GoodSignal.lua

@@ -43,41 +43,9 @@
 	@class GoodSignal
 ]=]
 
--- The currently idle thread to run the next handler on
-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(memoryCategory, fn, ...)
-	local acquiredRunnerThread = weakFreeRunnerThreadLookup[memoryCategory]
-	weakFreeRunnerThreadLookup[memoryCategory] = nil
-	fn(...)
-	-- The handler finished running, this runner thread is free again.
-	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(memoryCategory)
-	if #memoryCategory == 0 then
-		debug.setmemorycategory("signal_unknown")
-	else
-		debug.setmemorycategory(memoryCategory)
-	end
+	local require = require(script.Parent.loader).load(script)
 
-	-- 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
-	-- existence, temporarily leaking references. Without access to raw bytecode
-	-- there's no way for us to clear the "..." references from the stack.
-	while true do
-		acquireRunnerThreadAndCallEventHandler(coroutine.yield())
-	end
-end
+local EventHandlerUtils = require("EventHandlerUtils")
 
 -- Connection class
 local Connection = {}
@@ -216,15 +184,7 @@ function Signal:Fire(...)
 		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(weakFreeRunnerThreadLookup[memoryCategory], memoryCategory, connection._fn, ...)
+			EventHandlerUtils.fire(connection._memoryCategory, connection._fn, ...)
 		end
 
 		connection = nextNode