Working multithreading...

libs/utils/multithread.js

@@ -10,27 +10,28 @@ export function initWorkers(threads) {
     for (const i in workerFarm) {
         const worker = workerFarm[i]
         worker.postMessage({
-            type: 'setName',
+            type: 'initWorker',
             name: `Worker ${parseInt(i) + 1}`
         })
     }
 }
 
-export function spread(threads, script, data, shouldEval) {
+let spreadIndex = 0
-    return new Promise((resolve, reject) => {
+export function spread(script, data) {
-        const worker = new Worker(
+    return new Promise(
+        (resolve, reject) => {
+            const worker = workerFarm[spreadIndex]
+            worker.postMessage({
+                type: 'runScript',
                 script,
-            {
+                data
-                workerData: data,
+            })
-                eval: shouldEval ?? false
+
+            worker.once('message', result => resolve(result))
+            
+            ++spreadIndex
+            if(spreadIndex >= workerFarm.length)
+                spreadIndex = 0
         }
     )
-
-        worker.on('message', resolve)
-        worker.on('error', reject)
-        worker.on('exit', (code) => {
-            if (code !== 0)
-                reject(new Error(`Process stopped with code: ${code}`))
-        })
-    })
 }

libs/utils/multithread/fibonacci.js

@@ -1,8 +1,13 @@
-import { workerData, parentPort } from 'worker_threads'
+import initLog from '../log.js'
 
+const log = initLog('Fibonacci')
+
+export function main(data) {
+    return new Promise(
+        (resolve, reject) => {
             let nums = [1, 1]
             
-for (let i = 0; i < 42; i++) {
+            for (let i = 0; i < 44; i++) {
                 nums.push(nums[nums.length - 2] + nums[nums.length - 1])
             }
             
@@ -18,6 +23,7 @@ for (const num of nums) {
                     primes.push(num)
             }
 
-console.log("DONE!")
+            resolve(primes)
-
+        }
-parentPort.postMessage(primes)
+    )
+}

libs/utils/multithread/genericWorker.js

@@ -1,30 +1,37 @@
 import { workerData, parentPort } from 'worker_threads'
 import initLog from '../log.js'
 
-let script = ''
+let runScript = ''
 let myName = ''
 
 let log = initLog(myName)
 
 parentPort.on(
     'message',
-    message => {
+    async message => {
         switch (message.type) {
-            case 'setName':
+            case 'initWorker':
                 myName = message.name
                 log = initLog(myName)
-                log(`Changed name to '${myName}'.`)
+                process.env.DEBUG && log(`Started new thread -> «${myName}»`)
                 break
 
-            case 'setScript':
+            case 'runScript':
-                script = message.script
+                runScript = message.script
-                log = initLog(myName)
+                process.env.DEBUG && log(`Running script -> «${runScript}»`)
-                log(`Changed name to '${myName}'.`)
-                break
 
+                import(runScript).then(
+                    script => script.main(message.data).then(
+                        result => {
+                            parentPort.postMessage(result)
+                            process.env.DEBUG && log(`Script done -> «${runScript}»`)
+                        }
+                    )
+                )
+                break
 
             default:
-                
+                log(`Invalid message -> ${message.type ?? 'No message type provided!'}`)
                 break
         }
     }

tests/multihread.test.js

@@ -1,3 +1,21 @@
 import { initWorkers, spread } from '../libs/utils/multithread.js'
 
-initWorkers(8)
+initWorkers(10)
+
+let processes = 20
+let ran = 0
+for (let i = 0; i < processes; ++i) {
+    spread(
+        './fibonacci.js',
+        {}
+    ).then(
+        result => {
+            console.log(i)
+        
+            ++ran
+            if (ran === processes) {
+                process.exit(0)
+            }
+        }
+    )   
+}