
Security News
NIST Under Federal Audit for NVD Processing Backlog and Delays
As vulnerability data bottlenecks grow, the federal government is formally investigating NIST’s handling of the National Vulnerability Database.
Yet another tiny async control flow library, implements parallelLimit, with the ability to share the concurrency-limited queue.
miniq is yet another tiny async control flow library. It implements parallelLimit, with the ability to share the concurrency-limited queue.
v1.0.1
: when given an empty tasks array, empty
was not emitted.
v1.0.0
: reduced the overall size by using ondone
for the "wait to complete" functionality. Deprecated the removeTasks()
and concurrency()
methods. Added the isFull
and isEmpty
methods.
parallelLimit
series
= parallel(1, tasks, onDone)
parallel
without a concurrency limit = parallel(Infinity, tasks, onDone)
parallel
with a concurrency = default behaviorchain
vs. map
). I'd rather just use JavaScript's scope rules to handle all those variants rather than have specialized functions for each thing.miniq has one advanced feature, which is the ability to share the concurrency-limited queue among multiple different tasks. In other words, many different sets of operations can share the same queue and run limit. Each set of tasks can have it's own onDone
function, but they share the same concurrency limit.
For example, if you are writing something that does a recursive directory traversal and does various (file system) operations, you can push all the operations into the same queue. This will allow you to limit (file system) concurrency across multiple operations.
npm install --save miniq
parallel(limit, tasks, [onDone])
:
limit
is a number which controls the maximum number of concurrent tasks. Set limit = 1
for serial execution and limit = Infinity
for unlimited parallelism.onDone
is a callback function(err) { ... }
; it is called when the tasks it is associated with have runtasks
are callbacks function(done) { ... }
which should call done()
when they are complete.The return value is an object with the following API:
.exec(tasks, [onDone])
: appends the new set of tasks and queues the onDone
function once all of those tasks have completed.isEmpty
: returns true if the queue is empty.isFull
: returns true if the queue is currently running the maximum number of tasks.0.1.x
)miniq
uses setImmediate
when available to break call stacks.
This is done by default in order to prevent stack overflows from occurring when executing in a tight loop. However, if your workload is already asynchronous, then you will never run into a call stack overflow since async calls break up the call stack.
The .maxStack
property on the queue controls when a setImmediate
/ nextTick
call is inserted. It is set to 50
by default, which seems to retain a good balance between call stack size and avoiding scheduling overhead.
You should disable maxStack
by setting it to Infinity
if you know in advance that the work payloads are async and hence you will not need to occasionally break out of the call stack.
To set the maxStack
, set it on the return value. For example:
var queue = parallel(10, [ ... ], onDone);
queue.maxStack = Infinity;
For maximum performance when operations are cheap (e.g. stat calls), set the queue limit
to Infinity
and the maxStack
property to Infinity
. This skips a lot of management overhead as all tasks are launched immediately and no stack breaks are inserted.
parallelLimit
var parallel = require('miniq');
parallel(10, [
function(done) {
fs.readFile(function(err, result) {
if(err) {
return done(err); // done takes one argument: the error
}
}
},
], function(err) {
// err is sent if any of the tasks returned an error
});
parallel
var parallel = require('miniq');
parallel(Infinity, [
function(done) { ... },
], function(err) {
// err is sent if any of the tasks returned an error
});
series
var parallel = require('miniq');
parallel(1, [
function(done) { ... },
], function(err) {
// err is sent if any of the tasks returned an error
});
var parallel = require('miniq');
function Foo() {
this.queue = parallel(12);
}
Foo.prototype.bar = function() {
this.queue.exec(tasks, function(err) { ... });
};
Foo.prototype.all = function() {
// when the queue is empty
this.queue.once('empty', function() {
console.log('All done!');
});
this.queue.exec(tasks);
};
FAQs
Yet another tiny async control flow library, implements parallelLimit, with the ability to share the concurrency-limited queue.
The npm package miniq receives a total of 10,594 weekly downloads. As such, miniq popularity was classified as popular.
We found that miniq demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
As vulnerability data bottlenecks grow, the federal government is formally investigating NIST’s handling of the National Vulnerability Database.
Research
Security News
Socket’s Threat Research Team has uncovered 60 npm packages using post-install scripts to silently exfiltrate hostnames, IP addresses, DNS servers, and user directories to a Discord-controlled endpoint.
Security News
TypeScript Native Previews offers a 10x faster Go-based compiler, now available on npm for public testing with early editor and language support.