Now has a job queue.

libs/utils/multithread.js

@@ -6,64 +6,34 @@ const log = initLog("Worker Setup")
 
 let workerFarm = []
 let workerReady = []
+let scheduledJobs = []
+
+function scheduler() {
+    if (scheduledJobs.length === 0) return
 
-function waitForThread() {
-    return new Promise(
-        (resolve, reject) => {
-            let interval = setInterval(
-                () => {
     const readyIndex = workerReady.indexOf(true)
-                    if (readyIndex !== -1) {
-                        clearInterval(interval)
-                        resolve(readyIndex)
-                    }
-                },
-                50
-            )
-        }
-    )
-}
+    if (readyIndex === -1) return
 
-export function initWorkers(threads) {
-    for (let i = 0;  i < threads; ++i) {
-        workerFarm.push(new Worker('./libs/utils/multithread/genericWorker.js', { env: SHARE_ENV }))
-    }
-
-    for (const i in workerFarm) {
-        const worker = workerFarm[i]
-        worker.postMessage({
-            type: 'initWorker',
-            name: `Worker ${parseInt(i) + 1}`
-        })
-        workerReady[i] = true
-    }
-
-    log(`Initialised ${threads} workers!`)
-}
-
-export function spread(script, data) {
-    return new Promise(
-        async (resolve, reject) => {
-            const readyIndex = await waitForThread()
     workerReady[readyIndex] = false
-
     const worker = workerFarm[readyIndex]
-            const jobID = randomUUID()
+
+    const job = scheduledJobs.shift()
+
     worker.postMessage({
         type: 'runScript',
-                script,
-                data,
-                id: jobID
+        script: job.script,
+        data: job.data,
+        id: job.jobID
     })
 
     const messageHandler = message => {
-                if (message.id === jobID) {
+        if (message.id === job.jobID) {
             workerReady[readyIndex] = true
             worker.removeListener(
                 'message',
                 messageHandler
             )
-                    resolve(message.result)
+            return job.callback(message.result)
         }
     }
 
@@ -71,6 +41,44 @@ export function spread(script, data) {
         'message',
         messageHandler
     )
+}
+
+export function initWorkers(threads) {
+    for (let i = 0;  i < threads; ++i) {
+        workerFarm.push(new Worker('./libs/utils/multithread/genericWorker.js', { env: SHARE_ENV }))
+
+        const worker = workerFarm[i]
+        worker.postMessage({
+            type: 'initWorker',
+            name: `Worker ${parseInt(i) + 1}`
+        })
+
+        workerReady[i] = true
+    }
+
+    log(`Initialised ${threads} workers!`)
+
+    setInterval(
+        scheduler,
+        50
+    )
+
+    log(`Initialised the scheduler!`)
+}
+
+export function spread(script, data) {
+    return new Promise(
+        async (resolve, reject) => {
+            const jobID = randomUUID()
+
+            scheduledJobs.push({
+                script,
+                data,
+                jobID,
+                callback: result => {
+                    resolve(result)
+                }
+            })
         }
     )
 }

tests/multihread.test.js

@@ -5,23 +5,23 @@ import initLog from '../libs/utils/log.js'
 
 const log = initLog("Fib. Test")
 
-initWorkers(10)
+initWorkers(3)
 
-// const jobs = 100
-// let completed = 0
-// for (let i = 0; i < jobs; ++i) {
-//     spread(
-//         './fibonacci.js',
-//         {}
-//     ).then(
-//         result => {
-//             ++completed
-//             log(`Completed job ${completed}/${jobs} -> ${result}`)
+const jobs = 10
+let completed = 0
+for (let i = 0; i < jobs; ++i) {
+    spread(
+        './fibonacci.js',
+        {}
+    ).then(
+        result => {
+            ++completed
+            log(`Completed job ${completed}/${jobs} -> ${result}`)
 
-//             if (completed === jobs) process.exit(0)
-//         }
-//     )
-// }
+            if (completed === jobs) process.exit(0)
+        }
+    )
+}