Muhammad Sufiyan's Blog

Understanding the Limits of Node.js Clustering and Enhancing Performance

Muhammad Sufiyan's photo
Muhammad Sufiyan
·

3 min read

Welcome back! In the last session, we observed the significant improvement in server response time achieved through clustering. However, clustering has its limitations. Let's explore these limits and optimize our implementation further.

Experimenting with Clustering Limits

Continuing from our previous example, let's perform another experiment. Open multiple browser tabs and:

  1. Open the Network Console in each tab.

  2. Ensure the Disable Cache option is enabled.

  3. Access the /timer endpoint in all tabs almost simultaneously.

Observations:

  • The first two requests completed in approximately 9 seconds each.

  • The third request took around 16 seconds—double the expected time.

  • The process IDs for the requests indicate that:

    • The first two requests utilized different worker processes.

    • The subsequent requests reused the same processes, creating a bottleneck.

Why This Happens

Using clustering is not a "silver bullet" for performance problems. The number of concurrent requests your server can handle depends on the number of worker processes. In our previous setup, we had two workers, allowing only two simultaneous requests. Additional requests had to wait, increasing response times.

Optimizing Worker Creation

To maximize performance, we need to:

  1. Dynamically create worker processes based on the number of CPU cores.

  2. Limit the number of workers to avoid exceeding the available CPU resources.

Step 1: Using the os Module

The os module provides information about the system's CPU cores. We'll use this to determine the optimal number of workers:

const os = require('os');
const cluster = require('cluster');

if (cluster.isMaster) {
    const numWorkers = os.cpus().length;
    console.log(`Master process started. Forking ${numWorkers} workers.`);

    for (let i = 0; i < numWorkers; i++) {
        cluster.fork();
    }

    cluster.on('exit', (worker, code, signal) => {
        console.log(`Worker ${worker.process.pid} exited.`);
    });
} else {
    const express = require('express');
    const app = express();

    app.get('/timer', (req, res) => {
        setTimeout(() => {
            res.send(`Timer completed by process ${process.pid}`);
        }, 9000);
    });

    app.listen(3000, () => {
        console.log(`Worker ${process.pid} is listening on port 3000`);
    });
}

Step 2: Observing the Results

  1. Restart the server.

  2. On a machine with 8 logical cores, this code creates 8 worker processes, I have 4 cores machine, so 8 worker processes are connected.

  3. Send 3 simultaneous requests to the /timer endpoint.

  4. Observe the following:

    • All requests complete in approximately 9 seconds.

    • Each worker process handles one request, demonstrating efficient load distribution.

Understanding CPU Cores

  • Physical Cores: Separate processors in your CPU.

  • Logical Cores: Virtual cores created through technologies like Hyper-Threading, allowing additional parallelism.

Using logical cores, we maximize server performance without overloading the CPU.

Key Takeaways

  1. Clustering significantly improves performance by utilizing all CPU cores.

  2. Dynamically determining the number of workers ensures optimal resource usage.

  3. Proper configuration and testing are essential to avoid bottlenecks.

By following these principles, we can handle high concurrency and ensure efficient server performance. Great work—see you in the next session!

Node.jscluster