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/lovrManager/extensions.lua

@@ -118,13 +118,13 @@ function multi:newSystemThreadedJobQueue(n)
             local rets
             link = c.OnJobCompleted(function(jid,...)
                 if id==jid then
-                    rets = {...}
+                    rets = multi.pack(...)
                     link:Destroy()
                 end
             end)
             return thread.hold(function()
                 if rets then
-                    return unpack(rets) or multi.NIL
+                    return multi.unpack(rets) or multi.NIL
                 end
             end)
         end,holup),name
@@ -134,7 +134,7 @@ function multi:newSystemThreadedJobQueue(n)
 			thread.yield()
 			local dat = c.queueReturn:pop()
 			if dat then
-				c.OnJobCompleted:Fire(unpack(dat))
+				c.OnJobCompleted:Fire(multi.unpack(dat))
 			end
 		end
 	end)
@@ -152,6 +152,7 @@ function multi:newSystemThreadedJobQueue(n)
 			local lastProc = clock()
 			local queueAll = lovr.thread.getChannel("__JobQueue_"..jqc.."_queueAll")
 			local registry = {}
+			_G["__QR"] = queueReturn
 			setmetatable(_G,{__index = funcs})
 			thread:newThread("startUp",function()
 				while true do
@@ -177,7 +178,7 @@ function multi:newSystemThreadedJobQueue(n)
 						lastProc = os.clock()
 						local name = table.remove(dat,1)
 						local id = table.remove(dat,1)
-						local tab = {funcs[name](unpack(dat))}
+						local tab = {funcs[name](multi.unpack(dat))}
 						table.insert(tab,1,id)
 						queueReturn:push(tab)
 					end

integration/lovrManager/init.lua

@@ -36,12 +36,14 @@ __THREADNAME__=table.remove(__IMPORTS,1)
 stab = THREAD.createStaticTable(__THREADNAME__)
 GLOBAL = THREAD.getGlobal()
 multi, thread = require("multi").init()
-stab["returns"] = {THREAD.loadDump(__FUNC__)(unpack(__IMPORTS))}
+stab["returns"] = {THREAD.loadDump(__FUNC__)(multi.unpack(__IMPORTS))}
 ]]
 local multi, thread = require("multi.compat.lovr2d"):init()
 local THREAD = {}
 __THREADID__ = 0
 __THREADNAME__ = "MainThread"
+_G.THREAD_NAME = "MAIN_THREAD"
+_G.THREAD_ID = 0
 multi.integration={}
 multi.integration.lovr2d={}
 local THREAD = require("multi.integration.lovrManager.threads")
@@ -58,7 +60,7 @@ function THREAD:newFunction(func,holup)
                 if t.stab["returns"] then
                     local dat = t.stab.returns
                     t.stab.returns = nil
-                    return unpack(dat)
+                    return multi.unpack(dat)
                 end
 			end)
 		end,holup)()
@@ -74,16 +76,23 @@ function multi:newSystemThread(name,func,...)
     GLOBAL["__THREAD_"..c.ID] = {ID=c.ID,Name=c.name,Thread=c.thread}
     GLOBAL["__THREAD_COUNT"] = THREAD_ID
     THREAD_ID=THREAD_ID+1
+    	
+	if self.isActor then
+		self:create(c)
+	else
+		multi.create(multi, c)
+	end
+
     return c
 end
 THREAD.newSystemThread = multi.newSystemThread
 function lovr.threaderror(thread, errorstr)
-  print("Thread error!\n"..errorstr)
+    multi.print("Thread error!\n"..errorstr)
 end
 multi.integration.GLOBAL = GLOBAL
 multi.integration.THREAD = THREAD
 require("multi.integration.lovrManager.extensions")
-print("Integrated lovr Threading!")
+multi.print("Integrated lovr Threading!")
 return {init=function()
     return GLOBAL,THREAD
 end}

integration/lovrManager/threads.lua

@@ -156,7 +156,7 @@ function threads.getConsole()
     local c = {}
     c.queue = lovr.thread.getChannel("__CONSOLE__")
     function c.print(...)
-        c.queue:push{...}
+        c.queue:push(multi.pack(...))
     end
     function c.error(err)
         c.queue:push{"ERROR in <"..__THREADNAME__..">: "..err,__THREADID__}
@@ -174,7 +174,7 @@ if not ISTHREAD then
             dat = queue:pop()
             if dat then
                 lastproc = clock()
-                print(unpack(dat))
+                print(multi.unpack(dat))
             end
             if clock()-lastproc>2 then
                 thread.sleep(.1)