ciorent 0.0.20 → 0.0.22

package/README.md

@@ -6,9 +6,7 @@ Semaphore is a concurrency primitive used to control access to a common resource
 import * as semaphore from 'ciorent/semaphore';
 import * as cio from 'ciorent';
 
-// Only allow 2 of these tasks to run concurrently
-const task = semaphore.task(
-  semaphore.init(2),
+const task = semaphore.wrap(
   async (task: number) => {
     for (let i = 1; i <= 5; i++) {
       console.log('Task', task, 'iteration', i);
@@ -19,42 +17,54 @@ const task = semaphore.task(
   }
 );
 
+// Only allow 2 task to run concurrently
+const sem = semaphore.init(2);
+
 // Try to run 6 tasks concurrently
-cio.concurrent(6, task);
+cio.concurrent(6, (sem, id) => task(sem, id), sem);
 ```
 
-## Fibers
-Virtual threads with more controlled execution.
+## Latch
+Latch is a synchronization primitive that allows one process to wait until another completes an operation before continuing execution.
 
 ```ts
+import * as latch from 'ciorent/latch';
 import * as cio from 'ciorent';
-import * as fiber from 'ciorent/fiber';
 
-const thread1 = fiber.fn(function* () {
-  console.log('Fiber 1 started');
+const fetchLatch = latch.init();
 
-  // Thread1 will be interrupted by thread2
-  // As thread2 will end first
-  yield cio.sleep(1000);
+const task = async () => {
+  // Blocks until the latch is open
+  await latch.pause(fetchLatch);
 
-  console.log('Fiber 1 done');
-})
+  const res = await fetch('http://example.com');
+  console.log('Fetch status:', res.status);
+}
 
-const thread2 = fiber.fn(function* (thread) {
-  console.log('Fiber 2 started');
+const prepare = () => {
+  console.log('Run before fetch:', performance.now().toFixed(2));
+}
 
-  yield;
-  console.log('Fiber 2 resumed');
+const main = async () => {
+  const p = task();
+  await cio.sleep(500);
+  prepare();
 
-  // Start thread 1 and make thread1
-  // lifetime depends on thread2
-  fiber.mount(fiber.start(thread1), thread);
+  // Allows all previously blocked tasks to run
+  latch.open(fetchLatch);
 
-  console.log('Fiber 2 done');
-});
+  // Reclose the latch
+  // Tasks that aren't blocked yet will be blocked
+  latch.reset(fetchLatch);
 
-// Start running the thread
-fiber.start(thread2);
+  return p;
+}
+
+// Run fetch after 500ms
+await main();
+
+// Run fetch after another 500ms
+await main();
 ```
 
 ## Pubsub
@@ -93,47 +103,38 @@ cio.concurrent(5, async (id: number) => {
 publisher();
 ```
 
-## Latch
-Latch is a synchronization primitive that allows one process to wait until another completes an operation before continuing execution.
+## Fibers
+Virtual threads with more controlled execution.
 
 ```ts
-import * as latch from 'ciorent/latch';
 import * as cio from 'ciorent';
+import * as fiber from 'ciorent/fiber';
 
-const fetchLatch = latch.init();
-
-const task = async () => {
-  // Blocks until the latch is open
-  await latch.pause(fetchLatch);
-
-  const res = await fetch('http://example.com');
-  console.log('Fetch status:', res.status);
-}
+const thread1 = fiber.fn(function* () {
+  console.log('Fiber 1 started');
 
-const prepare = () => {
-  console.log('Run before fetch:', performance.now().toFixed(2));
-}
+  // Thread1 will be interrupted by thread2
+  // As thread2 will end first
+  yield cio.sleep(1000);
 
-const main = async () => {
-  const p = task();
-  await cio.sleep(500);
-  prepare();
+  console.log('Fiber 1 done');
+});
 
-  // Allows all previously blocked tasks to run
-  latch.open(fetchLatch);
+const thread2 = fiber.fn(function* (thread) {
+  console.log('Fiber 2 started');
 
-  // Reclose the latch
-  // Tasks that aren't blocked yet will be blocked
-  latch.reset(fetchLatch);
+  yield;
+  console.log('Fiber 2 resumed');
 
-  return p;
-}
+  // Start thread 1 and make thread1
+  // lifetime depends on thread2
+  fiber.mount(fiber.spawn(thread1), thread);
 
-// Run fetch after 500ms
-await main();
+  console.log('Fiber 2 done');
+});
 
-// Run fetch after another 500ms
-await main();
+// Start running the thread
+fiber.spawn(thread2);
 ```
 
 ## Channel
@@ -183,20 +184,23 @@ import * as cio from 'ciorent';
 // Expensive sync task
 const task1 = async () => {
   let x = 0;
-  for (let i = 0; i < (Math.random() + 15) * 1e7; i++) {
-    // Frequent pausing
-    if (i % 2e6 === 0)
-      await cio.pause;
 
+  // Pause to let task2 to run
+  await cio.pause;
+
+  for (let i = 0; i < (Math.random() + 15) * 1e6; i++)
     x += Math.random() * 32 + i * Math.round(Math.random() * 16);
-  }
+
   console.log('Finish task 1:', x);
 };
 
 // Short async task
 const task2 = async () => {
   console.log('Fetch start', performance.now().toFixed(2) + 'ms');
+
+  // This will pause task2 to let task1 to continue running
   const txt = await fetch('http://example.com');
+
   console.log('Fetch status', txt.status);
 };
 

package/fiber.d.ts

@@ -47,7 +47,7 @@ export declare const fn: <const Fn extends (thread: Thread, ...args: any[]) => G
  * A basic fiber runtime
  * @param g
  */
-export declare const start: Runtime;
+export declare const spawn: Runtime;
 /**
  * Pause the execution of a fiber
  * @param t
@@ -79,6 +79,12 @@ export declare const finish: <T extends Thread>(t: T) => T[1];
  * @param parent
  */
 export declare const mount: (child: Thread, parent: Thread) => void;
+/**
+ * Control the fiber with an abort signal
+ * @param t
+ * @param signal
+ */
+export declare const control: (t: Thread, signal: AbortSignal) => void;
 /**
  * Unwrap a promise result
  */

package/fiber.js

@@ -1 +1 @@
-export let paused=(t)=>t[1]===0;export let running=(t)=>t[1]===1;export let done=(t)=>t[1]===2;let invoke=async(g,thread)=>{let t=g.next();while(!t.done){let v=await t.value;if(thread[1]===0){let r;let p=new Promise((res)=>{r=res});thread[2]=r;await p}if(thread[1]===2){thread[3].forEach(stop);return v}t=g.next(v)}thread[1]=2;thread[3].forEach(stop);return t.value};export let fn=(f)=>f;export let start=(f,...args)=>{let thread=[null,1,null,[]];thread[0]=invoke(f(thread,...args),thread);return thread};export let pause=(t)=>{if(t[1]===1)t[1]=0};export let resume=(t)=>{if(t[1]===0){t[1]=1;t[2]?.()}};export let stop=(t)=>{if(t[1]===0){t[1]=2;t[2]()}else t[1]=2};export function*join(t){return yield t[1]}export let finish=(t)=>t[1];export let mount=(child,parent)=>{parent[3].push(child)};export function*unwrap(t){return yield t}
+export let paused=(t)=>t[1]===0;export let running=(t)=>t[1]===1;export let done=(t)=>t[1]===2;let invoke=async(g,thread)=>{let t=g.next();while(!t.done){let v=await t.value;if(thread[1]===0){let r;let p=new Promise((res)=>{r=res});thread[2]=r;await p}if(thread[1]===2){thread[3].forEach(stop);return v}t=g.next(v)}thread[1]=2;thread[3].forEach(stop);return t.value};export let fn=(f)=>f;export let spawn=(f,...args)=>{let thread=[null,1,null,[]];thread[0]=invoke(f(thread,...args),thread);return thread};export let pause=(t)=>{if(t[1]===1)t[1]=0};export let resume=(t)=>{if(t[1]===0){t[1]=1;t[2]?.()}};export let stop=(t)=>{if(t[1]===0){t[1]=2;t[2]?.()}else t[1]=2};export function*join(t){return yield t[1]}export let finish=(t)=>t[1];export let mount=(child,parent)=>{parent[3].push(child)};export let control=(t,signal)=>{signal.addEventListener("abort",()=>{stop(t)})};export function*unwrap(t){return yield t}

package/index.d.ts

@@ -26,10 +26,10 @@ export declare const sleepSync: (ms: number) => void;
  * @param n
  * @param task - The function to run
  */
-export declare const sequential: (n: number, task: (id: number) => Promise<any>) => Promise<void>;
+export declare const sequential: <const T extends any[]>(n: number, task: (...args: [...T, id: number]) => Promise<any>, ...args: T) => Promise<void>;
 /**
  * Spawn n tasks that runs concurrently
  * @param n
  * @param task - The function to run
  */
-export declare const concurrent: (n: number, task: (id: number) => Promise<any>) => Promise<any>;
+export declare const concurrent: <const T extends any[]>(n: number, task: (...args: [...T, id: number]) => Promise<any>, ...args: T) => Promise<any>;

package/index.js

@@ -1 +1 @@
-export let pause=Promise.resolve();export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.("timers/promises").setTimeout??((ms)=>new Promise((res)=>{setTimeout(res,ms)}));let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??((ms)=>{Atomics.wait(sharedBuf,0,0,ms)});export let sequential=async(n,task)=>{for(let i=0;i<n;i++)await task(i)};export let concurrent=(n,task)=>{let arr=new Array(n);for(let i=0;i<n;i++)arr[i]=task(i);return Promise.all(arr)};
+export let pause=Promise.resolve();export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.("timers/promises").setTimeout??((ms)=>new Promise((res)=>{setTimeout(res,ms)}));let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??((ms)=>{Atomics.wait(sharedBuf,0,0,ms)});export let sequential=async(n,task,...args)=>{for(let i=0;i<n;i++)await task(...args,i)};export let concurrent=(n,task,...args)=>{let arr=new Array(n);for(let i=0;i<n;i++)arr[i]=task(...args,i);return Promise.all(arr)};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ciorent",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "A lightweight, low-overhead concurrency library",
   "homepage": "https://ciorent.netlify.app",
   "repository": {
@@ -18,14 +18,14 @@
   "main": "./index.js",
   "types": "./index.d.ts",
   "exports": {
-    "./fixed-queue": "./fixed-queue.js",
     "./sliding-queue": "./sliding-queue.js",
-    "./fiber": "./fiber.js",
-    "./channel": "./channel.js",
+    "./fixed-queue": "./fixed-queue.js",
+    "./latch": "./latch.js",
     "./dropping-queue": "./dropping-queue.js",
-    "./topic": "./topic.js",
+    "./channel": "./channel.js",
     ".": "./index.js",
+    "./topic": "./topic.js",
     "./semaphore": "./semaphore.js",
-    "./latch": "./latch.js"
+    "./fiber": "./fiber.js"
   }
 }

package/semaphore.d.ts

@@ -35,7 +35,3 @@ export declare const signal: (s: Semaphore) => void;
  * Wrap a task to bind to a custom semaphore later
  */
 export declare const wrap: <Args extends any[], Return extends Promise<any>>(f: (...args: Args) => Return) => ((s: Semaphore, ...a: Args) => Return);
-/**
- * Create a task that acquire a semaphore and release the access when it's finished
- */
-export declare const task: <F extends (...args: any[]) => Promise<any>>(s: Semaphore, f: F) => F;

package/semaphore.js

@@ -1 +1 @@
-import{pause as resolvedPromise}from"./index.js";export let init=(n)=>{let root=[null,null];return[n,root,root]};export let pause=(s)=>{s[0]--;if(s[0]<0){let r;let p=new Promise((res)=>{r=res});s[1]=s[1][1]=[r,null];return p}return resolvedPromise};export let signal=(s)=>{if(s[0]<0)(s[2]=s[2][1])[0]();s[0]++};export let wrap=(f)=>async(s,...a)=>{s[0]--;if(s[0]<0){let r;let p=new Promise((res)=>{r=res});s[1]=s[1][1]=[r,null];await p}try{return await f(...a)}finally{signal(s)}};export let task=(s,f)=>{f=wrap(f);return(...a)=>f(s,...a)};
+import{pause as resolvedPromise}from"./index.js";export let init=(n)=>{let root=[null,null];return[n,root,root]};export let pause=(s)=>{s[0]--;if(s[0]<0){let r;let p=new Promise((res)=>{r=res});s[1]=s[1][1]=[r,null];return p}return resolvedPromise};export let signal=(s)=>{if(s[0]<0)(s[2]=s[2][1])[0]();s[0]++};export let wrap=(f)=>async(s,...a)=>{s[0]--;if(s[0]<0){let r;let p=new Promise((res)=>{r=res});s[1]=s[1][1]=[r,null];await p}try{return await f(...a)}finally{signal(s)}};