Working on 16.0.0 (#53)

* Fixed spelling, started ideaing for 16.0.0

* Updated files

* Updated readme

* Updated version

* Concat conns now properly transfer events

* Testing types

* Connections can be % with functions

* Updated connections

* Fixed issue with double thread activations (Looking for another solution)

* Working on issue with love threaded functions not waiting when in a thread

* Working on issue where threads created in threads don't work

* Fixed broken threads for love

* Fixed some issues with threads

* removed test

* Updated changes.md

* Plan on testing parity between the threading modules

* Writing tests for system threading

* Added test cases for threading, fixed issues. Todo test love2d

* Fixed love2d to succeed with tests

* All tests working

* Updated files for testing

* Modified tests to make it more seamless

* removed extra __cores in lanes/pseudo

* Working on new priority scheme

* Working on priority management

* Working on custom prioritySchemes

* Fixed issues with missing code

* Threaded processors

* THREAD.exposeENV(), thread:newProcessor()

* Typo in changes.md

* Fixed typo in pseudoManager

* fixing

* Trying to fix exposeENV with pseudoThreading

* Changes to threads

* updated changes.md

* Working on systemthreadedprocess, and experimental newProxy for threading

* newProxy and STP work

* newProxy implemented

* Proxies work with connections now :D

* Added tstep to STP, updated changes.md

* thread.hold(proxy.conn)

* Clean up connection events when holding, working on scheduling tasks/threads to system threaded processors

* Getting loads of processors implemented

* Finished getLoad(type)

* Fixed some bugs

* Added an easy way to share a table, found some limitations with lanes threading.

* THREAD_NAME set for main thread, connections break the rules for proxies

* Testing

* Really close to portable proxies, currently extreamly unstable!

* Debugging what is going on...

* Fixed critical issue with coroutine based threads

* Removed extra bloat, proxies are portable now!

* Started work on the debugManager

* Testing actions, fixing bugs with lanes

* Testing...

* fixing actions

* typo fixed

* Throw an error when things break

* fixing stuff

* Fixed issue with errors not going through

* Removed system threaded connections, soon to be replaced by proxies

* Testing love2d tests

* Test love2d

* Use later love-build

* Use ubuntu for build

* Fixed path

* Use appimage

* use sudo

* No window for love2d

* Fixed love2d tests

* Testing love2d

* Use workspace

* Moved other tests while testing

* actually pull the repo

* packagepath set

* Fixed pull

* Update multi

* Removed link

* Edited symlink

* Added timeout to build

* Rewriting loveManager, too much outdated code

* Still implementing new love2d threading code

* Rewriting love2d threading binding

* Working on adding a Hold method to all objects. Will document how they all work when done.

* jobqueues having isues with stp

* new pack/unpack for tables, current issue is things being turned into strings

* Fixed packing of values into threads, need to fix system proxies and system threaded processors

* testing...

* Not hard crashing when error is encountered

* Should now push non 0 exit codes

* Push error when an error happens

* Closer to getting things working...

* Working on new type system, planning out debugmanager

* Fixed error code issue

* Test for 5.1

* Planning out debugManager

* Some work on the debug manager, proxies working on lanes, todo get pseudo manager and love2d working

* Working on getting pseudoThreading tests to work

* Added function / connection

* Added boost method

* Document new features to conns, todo fix newTask

* Fixed newTask()

* Updated changes.md and fixed some bugs

* Added thread.defer(func)

* Fixed tests on lanes and pseudo threading, todo fix love2d threading

* Fixed paths

* Working on paths

* Testing paths

* Add test for rockspec

* Fixed issues

* Fixed typo

* Added test for defer

* Threading working in love2d

* Fixed, conf

* lanes uses a threaded function like waitfor function

* Cleaned up changes.md

* added priorityManager to rockspec

integration/lanesManager/init.lua

@@ -36,6 +36,9 @@ lanes = require("lanes").configure()
 multi.SystemThreads = {}
 multi.isMainThread = true
 
+_G.THREAD_NAME = "MAIN_THREAD"
+_G.THREAD_ID = 0
+
 function multi:canSystemThread()
 	return true
 end
@@ -55,10 +58,10 @@ local count = 1
 local started = false
 local livingThreads = {}
 
-function THREAD:newFunction(func,holdme)
+function THREAD:newFunction(func, holdme)
 	return thread:newFunctionBase(function(...)
 		return multi:newSystemThread("TempSystemThread",func,...)
-	end,holdme)()
+	end, holdme, multi.registerType("s_function"))()
 end
 
 function multi:newSystemThread(name, func, ...)
@@ -67,35 +70,43 @@ function multi:newSystemThread(name, func, ...)
 	local rand = math.random(1, 10000000)
 	local return_linda = lanes.linda()
 	c = {}
-	c.name = name
 	c.Name = name
-	c.Id = count
+	c.ID = count
 	c.loadString = {"base","package","os","io","math","table","string","coroutine"}
 	livingThreads[count] = {true, name}
 	c.returns = return_linda
-	c.Type = "sthread"
+	c.Type = multi.registerType("s_thread")
 	c.creationTime = os.clock()
 	c.alive = true
 	c.priority = THREAD.Priority_Normal
 	local multi_settings = multi.defaultSettings
-	for i,v in pairs(multi_settings) do
-		print(i,v)
+	local globe = {
+		THREAD_NAME = name,
+		THREAD_ID = count,
+		THREAD = THREAD,
+		GLOBAL = GLOBAL,
+		_Console = __ConsoleLinda,
+		_DEFER = {}
+	}
+	if GLOBAL["__env"] then
+		for i,v in pairs(GLOBAL["__env"]) do
+			globe[i] = v
+		end
 	end
 	c.thread = lanes.gen("*",
 	{
-		globals={ -- Set up some globals
-			THREAD_NAME = name,
-			THREAD_ID = count,
-			THREAD = THREAD,
-			GLOBAL = GLOBAL,
-			_Console = __ConsoleLinda
-		},
-		priority=c.priority
+		globals = globe,
+		priority = c.priority
 	},function(...)
-		require("multi"):init(multi_settings)
+		multi, thread = require("multi"):init(multi_settings)
 		require("multi.integration.lanesManager.extensions")
+		require("multi.integration.sharedExtensions")
 		local has_error = true
-		return_linda:set("returns",{func(...)})
+		returns = {pcall(func, ...)}
+		return_linda:set("returns", returns)
+		for i,v in pairs(_DEFER) do
+			pcall(v)
+		end
 		has_error = false
 	end)(...)
 	count = count + 1
@@ -110,10 +121,20 @@ function multi:newSystemThread(name, func, ...)
 	c.OnDeath = multi:newConnection()
 	c.OnError = multi:newConnection()
 	GLOBAL["__THREADS__"] = livingThreads
+	c.OnError(multi.error)
+
+	if self.isActor then
+		self:create(c)
+	else
+		multi.create(multi, c)
+	end
+
 	return c
 end
 
-THREAD.newSystemThread = multi.newSystemThread
+THREAD.newSystemThread = function(...)
+    multi:newSystemThread(...)
+end
 
 function multi.InitSystemThreadErrorHandler()
 	if started == true then
@@ -126,18 +147,26 @@ function multi.InitSystemThreadErrorHandler()
 		while true do
 			thread.yield()
 			_,data = __ConsoleLinda:receive(0, "Q")
-			if data then print(unpack(data)) end
+			if data then
+				--print(data[1])
+			end
 			for i = #threads, 1, -1 do
 				temp = threads[i]
 				status = temp.thread.status
-				push = __StatusLinda:get(temp.Id)
+				push = __StatusLinda:get(temp.ID)
 				if push then
-					temp.statusconnector:Fire(unpack(({__StatusLinda:receive(nil, temp.Id)})[2]))
+					temp.statusconnector:Fire(multi.unpack(({__StatusLinda:receive(nil, temp.ID)})[2]))
 				end
 				if status == "done" or temp.returns:get("returns") then
-					livingThreads[temp.Id] = {false, temp.Name}
+					returns = ({temp.returns:receive(0, "returns")})[2]
+					livingThreads[temp.ID] = {false, temp.Name}
 					temp.alive = false
-					temp.OnDeath:Fire(unpack(({temp.returns:receive(0, "returns")})[2]))
+					if returns[1] == false then
+						temp.OnError:Fire(temp, returns[2])
+					else
+						table.remove(returns,1)
+						temp.OnDeath:Fire(multi.unpack(returns))
+					end
 					GLOBAL["__THREADS__"] = livingThreads
 					table.remove(threads, i)
 				elseif status == "running" then
@@ -145,19 +174,15 @@ function multi.InitSystemThreadErrorHandler()
 				elseif status == "waiting" then
 					--
 				elseif status == "error" then
-					livingThreads[temp.Id] = {false, temp.Name}
-					temp.alive = false
-					temp.OnError:Fire(temp,unpack(temp.returns:receive(0,"returns") or {"Thread Killed!"}))
-					GLOBAL["__THREADS__"] = livingThreads
-					table.remove(threads, i)
+					-- The thread never really errors, we handle this through our linda object
 				elseif status == "cancelled" then
-					livingThreads[temp.Id] = {false, temp.Name}
+					livingThreads[temp.ID] = {false, temp.Name}
 					temp.alive = false
 					temp.OnError:Fire(temp,"thread_cancelled")
 					GLOBAL["__THREADS__"] = livingThreads
 					table.remove(threads, i)
 				elseif status == "killed" then
-					livingThreads[temp.Id] = {false, temp.Name}
+					livingThreads[temp.ID] = {false, temp.Name}
 					temp.alive = false
 					temp.OnError:Fire(temp,"thread_killed")
 					GLOBAL["__THREADS__"] = livingThreads
@@ -165,10 +190,10 @@ function multi.InitSystemThreadErrorHandler()
 				end
 			end
 		end
-	end)
+	end).OnError(multi.error)
 end
 
-multi.print("Integrated Lanes!")
+multi.print("Integrated Lanes Threading!")
 multi.integration = {} -- for module creators
 multi.integration.GLOBAL = GLOBAL
 multi.integration.THREAD = THREAD