https://github.com/beh01der/memory-savvy-queue
https://github.com/beh01der/memory-savvy-queue
Last synced: about 1 month ago
JSON representation
- Host: GitHub
- URL: https://github.com/beh01der/memory-savvy-queue
- Owner: Beh01der
- Created: 2023-07-24T02:01:52.000Z (almost 3 years ago)
- Default Branch: master
- Last Pushed: 2023-07-24T03:25:12.000Z (almost 3 years ago)
- Last Synced: 2025-09-14T07:19:12.803Z (10 months ago)
- Language: TypeScript
- Size: 3.91 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
A simple FIFO queue that limits memory usage
It's designed to be used in case when we want to postpone item consumption but at the same time limiting memory usage.
Consider 2 scenarios:
1. Memory limit is not reached
```typescript
async function run() {
const queue = new MemSavvyQueue({
memoryUsageLimitBytes: 1200,
itemConsumer: async (item) => {
console.log("Consuming item %d", item[0]);
return Promise.resolve();
},
});
for (let i = 0; i < 3; i++) {
await queue.push(new Uint32Array(100).fill(i));
console.log("Added item %d", i);
}
console.log("Consuming all items");
await queue.consumeAll();
}
run().then(() => console.log("Done"));
```
output would be:
```
Added item 0
Added item 1
Added item 2
Consuming all items
Consuming item 0
Consuming item 1
Consuming item 2
Done
```
As we can see, when there is no memory pressure, our queue acts like a buffer allowing us to consume stored items at our own pace.
2. Memory limit is exceeded
```typescript
async function run() {
const queue = new MemSavvyQueue({
memoryUsageLimitBytes: 800,
itemConsumer: async (item) => {
console.log("Consuming item %d", item[0]);
return Promise.resolve();
},
});
for (let i = 0; i < 5; i++) {
await queue.push(new Uint32Array(100).fill(i));
console.log("Added item %d", i);
}
console.log("Consuming all items");
await queue.consumeAll();
}
run().then(() => console.log("Done"));
```
output would be:
```
Added item 0
Added item 1
Consuming item 0
Added item 2
Consuming item 1
Added item 3
Consuming item 2
Added item 4
Consuming all items
Consuming item 3
Consuming item 4
Done
```
In this case we exceeded defined memory limit at some point, and queue started calling `itemConsumer` on the "oldest" items to free up memory required to store new item.
## API
```typescript
export type MemSavvyQueueConfig = {
// consumer function
itemConsumer: (item: ITEM) => Promise;
// memory usage limit in bytes (default = 1Mb)
memoryUsageLimitBytes?: number;
};
export class MemSavvyQueue {
constructor(config: MemSavvyQueueConfig);
// push new item - returns number of forcefully consumed items
public async push(item: ITEM): Promise;
// consume one oldest item - returns true if item was consumed
public async consumeOne(): Promise;
// consume all items - returns number of consumed items
public async consumeAll(): Promise;
// returns item count
public getCount(): number;
// returns true if there are some items
public hasItems(): boolean;
}
```