How to Limit CPU Computation Consumption for Builds and Compilation

This guide provides strategies to limit CPU usage for CPU-intensive processes like compilation or builds.

1. Limit Parallel Jobs

Many build systems and compilers allow you to control the number of parallel jobs, which directly affects CPU usage.

For make: Use the -j flag to specify the number of parallel jobs:
```
make -j2 # Limits to 2 parallel jobs
```
Dynamically limit based on the number of CPU cores:
```
make -j$(nproc --ignore=2) # Uses all but 2 CPU cores
```
For cmake or ninja: Use the -j flag similarly:
```
ninja -j2 # Limits to 2 parallel jobs
```
For gcc or clang: Use -j with lto (Link-Time Optimization):
```
gcc -flto=2 -o my_program my_program.c
```

2. Use `nice` and `renice`

Lower the priority of the build process to reduce its CPU impact on other tasks.

Start the build with nice:
```
nice -n 10 make -j$(nproc)
```
Adjust the priority of an ongoing build process:
```
renice 10 -p <PID>
```

3. Limit CPU Cores with `taskset`

Restrict the build process to specific CPU cores to reduce overall CPU usage.

Example: Limit the build to 2 CPU cores (e.g., cores 0 and 1):
```
taskset -c 0,1 make -j2
```

4. Use `cpulimit`

Dynamically limit the CPU usage of the build process to a specific percentage.

Example: Limit make to 50% CPU:
```
cpulimit -l 50 -e make
```

5. Control System-Wide CPU Usage

If you’re running builds in a shared environment, you can use system-wide tools to limit CPU usage.

Using cgroups (Linux): Create a control group and limit CPU usage for the build process:

cgcreate -g cpu:/buildgroup
echo 100000 > /sys/fs/cgroup/cpu/buildgroup/cpu.cfs_quota_us # Limit to 10% CPU
echo <PID> > /sys/fs/cgroup/cpu/buildgroup/tasks

Using Docker: If you’re running the build in a Docker container, limit CPU usage:
```
docker run --cpus="1.5" <image_name> # Limit to 1.5 CPU cores
```

6. Throttle I/O and CPU Together

Build processes often involve heavy I/O operations. Use tools like ionice to prioritize I/O and reduce overall system load.

Example:
```
ionice -c 3 nice -n 10 make -j$(nproc)
```

7. Pause and Resume Builds

If you need to temporarily free up CPU resources, you can pause and resume the build process.

Pause a process:
```
kill -STOP <PID>
```
Resume a process:
```
kill -CONT <PID>
```

8. Use Build System-Specific Options

Some build systems have built-in options to limit resource usage.

For bazel``**:** Use the ``--local_cpu_resources flag:

bazel build --local_cpu_resources=2 //my:target

For gradle: Use the --max-workers flag:
```
./gradlew build --max-workers=2
```

9. Monitor and Adjust

Use monitoring tools to observe CPU usage and adjust limits as needed.

Linux: Use htop, top, or glances to monitor CPU usage.
Windows: Use Task Manager or Resource Monitor.
macOS: Use Activity Monitor.

—

By combining these techniques, you can effectively limit CPU consumption during compilation or builds while still maintaining reasonable performance.