@nxtedition/shared 0.0.1

package/.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false

package/.husky/pre-commit

@@ -0,0 +1,3 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+npx lint-staged

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 nxtedition
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# shared
+
+Ring Buffer for NodeJS cross Worker communication.
+
+## Install
+
+```
+npm i @nxtedition/shared
+```
+
+## Quick Start
+
+```js
+// index.js
+
+import * as shared from '@nxtedition/shared'
+import tp from 'timers/promise'
+
+const writer = shared.alloc(16 * 1024 * 1024)
+const reader = shared.alloc(16 * 1024 * 1024)
+
+const worker = new Worker(new URL('worker.js', import.meta.url), {
+  workerData: { reader, writer },
+})
+
+const writeToWorker = shared.writer(reader)
+
+shared.reader(writer, async (buffer) => {
+  console.log(`From worker ${buffer}`)
+  await tp.setTimeout(1e3) // Backpressure
+})
+
+while (true) {
+  await writeToParent(Buffer.from('Hello from parent')
+}
+```
+
+```js
+// worker.js
+
+import * as shared from '@nxtedition/shared'
+import tp from 'timers/promise'
+
+const writeToParent = shared.writer(workerData.writer)
+
+shared.reader(workerData.reader, (buffer) => {
+  console.log(`From parent ${buffer}`)
+  await tp.setTimeout(1e3) // Backpressure
+})
+
+while (true) {
+  await writeToParent(Buffer.from('Hello from worker')
+}
+```

package/index.js

@@ -0,0 +1,113 @@
+const WRITE_INDEX = 0
+const READ_INDEX = 1
+
+export function alloc(size) {
+  return {
+    sharedState: new SharedArrayBuffer(8),
+    sharedBuffer: new SharedArrayBuffer(size),
+  }
+}
+
+export async function reader({ sharedState, sharedBuffer }, cb) {
+  const state = new Int32Array(sharedState)
+  const buffer = Buffer.from(sharedBuffer)
+
+  let readPos = 0
+  let writePos = 0
+
+  while (true) {
+    const { async, value } = Atomics.waitAsync(state, WRITE_INDEX, writePos)
+    if (async) {
+      await value
+    }
+    writePos = Atomics.load(state, WRITE_INDEX)
+
+    while (readPos !== writePos) {
+      const len = buffer.readInt32LE(readPos)
+
+      if (len === -1) {
+        readPos = 0
+      } else {
+        const raw = buffer.slice(readPos + 4, readPos + len)
+        readPos += len
+
+        await cb(raw)
+      }
+
+      Atomics.store(state, READ_INDEX, readPos)
+    }
+
+    Atomics.notify(state, READ_INDEX)
+  }
+}
+
+export function writer({ sharedState, sharedBuffer }) {
+  const state = new Int32Array(sharedState)
+  const buffer = Buffer.from(sharedBuffer)
+  const size = buffer.byteLength
+  const queue = []
+
+  let readPos = 0
+  let writePos = 0
+  let flushing = null
+
+  function tryWrite(...raw) {
+    readPos = Atomics.load(state, READ_INDEX)
+
+    const len = raw.reduce((len, buf) => len + buf.byteLength, 4)
+
+    if (size - writePos < len + 4) {
+      if (readPos < len + 4) {
+        return false
+      }
+
+      buffer.writeInt32LE(-1, writePos)
+      writePos = 0
+    } else {
+      const available = writePos >= readPos ? size - writePos : readPos - writePos
+
+      if (available < len + 4) {
+        return false
+      }
+    }
+
+    buffer.writeInt32LE(len, writePos)
+    writePos += 4
+
+    for (const buf of raw) {
+      buffer.set(buf, writePos)
+      writePos += buf.byteLength
+    }
+
+    Atomics.store(state, WRITE_INDEX, writePos)
+    Atomics.notify(state, WRITE_INDEX)
+
+    return true
+  }
+
+  async function flush() {
+    while (queue.length) {
+      while (!tryWrite(queue[0])) {
+        const { async, value } = Atomics.waitAsync(state, READ_INDEX, readPos)
+        if (async) {
+          await value
+        }
+      }
+      queue.shift()
+    }
+
+    flushing = null
+  }
+
+  async function write(...raw) {
+    if (!queue.length && tryWrite(...raw)) {
+      return
+    }
+
+    queue.push(Buffer.concat(raw))
+
+    await (flushing ??= flush())
+  }
+
+  return write
+}