node-cpulimit - Limit the CPU usage of a process.

  •        470

A module which limits the CPU usage of a process. Useful when your computer is performing some heavy work that takes too much of the CPU cycles but you want to perform other tasks. It works by sending SIGSTOP and SIGCONT signals at regular intervals depending on the specified limit.


child_pids : ^1.0.0
commander : ^2.9.0
expand-tilde : ^1.2.0
ps-man : ^1.1.3



Related Projects

cpulimit - CPU usage limiter for Linux

  •    C

Cpulimit is a tool which limits the CPU usage of a process (expressed in percentage, not in CPU time). It is useful to control batch jobs, when you don't want them to eat too many CPU cycles. The goal is prevent a process from running for more than a specified time ratio. It does not change the nice value or other scheduling priority settings, but the real CPU usage. Also, it is able to adapt itself to the overall system load, dynamically and quickly. The control of the used CPU amount is done sending SIGSTOP and SIGCONT POSIX signals to processes. All the children processes and threads of the specified process will share the same percentage of CPU. Developed by Angelo Marletta. Please send your feedback, bug reports, feature requests or just thanks.

CPU Usage Limiter for Linux

  •    C

cpulimit is a per-process cpu usage limiter (expressed in percentage, not in cpu time). This is useful to control batch jobs, when you don't want them to eat too much cpu. It is able to adapt itself to the overall system load, dynamically and quickly.

async-profile - Asynchronous CPU profiling for node

  •    CoffeeScript

Node async-profile profiles CPU usage in node apps. It lets you see at a glance how much CPU time is being taken up by a given part of your app, even if that part of your app is also doing asynchronous IO.

node-usage - process usage lookup with nodejs

  •    Javascript

But If you call usage.lookup() continuously for a given pid, you can turn on keepHistory flag and you'll get the CPU usage since last time you track the usage. This reflects the current CPU usage.

node-threads-a-gogo - TAGG :: threads_a_gogo :: Simple and fast JavaScript threads for Node.js

  •    Javascript

Threads à gogo (*) is a native module for Node.js that provides an asynchronous, evented and/or continuation passing style API for moving blocking/longish CPU-bound tasks out of Node's event loop to JavaScript threads that run in parallel in the background and that use all the available CPU cores automatically; all from within a single Node process. You need a node with a v8 >= 3.2.4 to run this module. Any node >= 0.5.1 comes with a v8 >= 3.2.4.

pidusage - Cross-platform process cpu % and memory usage of a PID

  •    Javascript

Cross-platform process cpu % and memory usage of a PID. Ideas from but with no C-bindings.

microjob - A tiny wrapper for turning Node

  •    TypeScript

A tiny wrapper for turning Node.js threads in easy-to-use routines for CPU-bound. Microjob is a tiny wrapper for Node.js threads and is intended to perform heavy CPU loads using anonymous functions. So, Microjob treats Node.js threads as temporary working units: if you need to spawn a long-living thread, then you should use the default API.

heroku-cra-node - How to use create-react-app with a custom Node server on Heroku

  •    Javascript

A minimal example of using a Node backend (server for API, proxy, & routing) with a React frontend. Includes a minimal Node Cluster implementation to parallelize the single-threaded Node process across the available CPU cores.

sympact - 🔥 Simple stupid CPU/MEM "Profiler" for your JS code.

  •    Javascript

🔥 An easy way to calculate the 'impact' of running a task in Node.JS Coded with ❤️ by Simone Primarosa. Sympact runs a script and profiles its execution time, CPU usage, and memory usage. Sympact then returns an execution report containing the averages of the results.

node-worker-nodes - A node

  •    Javascript

A library to run cpu-intensive tasks without blocking the event loop.

fgprof - 🚀 fgprof is a sampling Go profiler that allows you to analyze On-CPU as well as Off-CPU (e

  •    Go

fgprof is a sampling Go profiler that allows you to analyze On-CPU as well as Off-CPU (e.g. I/O) time together. Go's builtin sampling CPU profiler can only show On-CPU time, but it's better than fgprof at that. Go also includes tracing profilers that can analyze I/O, but they can't be combined with the CPU profiler.

better-sqllite3 - The fastest and simplest library for SQLite3 in Node.js

  •    Javascript

The fastest and simplest library for SQLite3 in Node.js. It has Full transaction support, High performance, efficiency, and safety, Support for user-defined functions, aggregates, and extensions.

node-webkit-agent - NodeJS agent for WebKit devtools front-end

  •    Javascript

This module is an implementation of Chrome developer tools protocol. It is still pretty much a work in progress and only heap and CPU profilers are working right now. Help is wanted to finish implementing debugger, networking and console agents as well as a implementing from scratch a flamegraphs agent. This module allows you to debug and profile remotely your nodejs applications leveraging the following features by re-using the built-in devtools front-end that comes with any webkit-based browsers such as Chrome or Safari.

Bull - Premium package for handling jobs and messages in NodeJS

  •    Javascript

The fastest, most reliable, Redis-based queue for Node. Carefully written for rock solid stability and atomicity.

go-disruptor - A port of the LMAX Disruptor to the Go language.

  •    Go

This is a port of the LMAX Disruptor into the Go programming language. It retains the essence and spirit of the Disruptor and utilizes a lot of the same abstractions and concepts, but does not maintain the same API.On my MacBook Pro (Intel Core i7-4960HQ CPU @ 2.60GHz) using Go 1.4.2, I was able to push over 900 million messages per second (yes, you read that right) from one goroutine to another goroutine. The message being transferred between the two CPU cores was a simple, incrementing number, but literally could be anything. Note that your mileage may vary and that different operating systems can introduce significant “jitter” into the application by taking control of the CPU and invalidating the various CPU caches. Linux and Windows have the ability to assign a given process to specific CPU cores which reduces jitter significantly by keeping all the CPU caches hot. Parenthetically, when the Disruptor code is compiled and run on a Nexus 5, it can push about 15-20 million messages per second.

chillout - Reduce CPU usage in JavaScript

  •    Javascript

Reduce JavaScript CPU usage by asynchronous iteration. Provides asynchronous iteration functions that have a Promise based interface and it can execute with low CPU usage. Each iteration adds delay if the processing is heavy to maintain the CPU stability. Iterate without delay if processing is fast. Therefore, it will realize friendly processing for your machine. It can execute JavaScript without "Warning: Unresponsive Script" alert in the browser.

node-profiler - Access the V8 profiler from node.js

  •    C++

This module is effectively deprecated. Newer versions of V8 have removed much of the functionality that node-profiler depends on. As a result, it's become much less effective. Consider using strong-agent if you want on-demand CPU profiling.

My Cpu Monitor

  •    CSharp

Monitors CPU activity (% usage, temperature etc) and then records them for easy reviewing. records such information as processes taking up the most cpu, how much memory etc that process it taking.


  •    Java

Java Library that implements and integrates concepts from TCP congestion control to auto-detect concurrency limits to achieve optimal throughput with optimal latency. When thinking of service availability operators traditionally think in terms of RPS (requests per second). Stress tests are normally performed to determine the RPS at which point the service tips over. RPS limits are then set somewhere below this tipping point (say 75% of this value) and enforced via a token bucket. However, in large distributed systems that auto-scale this value quickly goes out of date and the service falls over anyway and becomes non-responsive to a point where it is unable to gracefully shed load. Instead of thinking in terms of RPS, we should be thinking in terms of concurrent request where we apply queuing theory to determine the number of concurrent requests a service can handle before a queue starts to build up, latencies increase and the service eventually exhausts a hard limit such as CPU, memory, disk or network. This relationship is covered very nicely with Little's Law where Limit = Average RPS * Average Latency.

We have large collection of open source products. Follow the tags from Tag Cloud >>

Open source products are scattered around the web. Please provide information about the open source projects you own / you use. Add Projects.