Create a program to calculate the maximum number of processes in the system

Question

I have the following code, which I'm trying to calculate all process. I do not understand how to calculate the maximum number of process.

#include <stdio.h>
#include <stdlib.h>

int main() 
{
   int pid, pidmax = 0;
   while(1) 
   {
       pid = fork();
       pidmax = getpid();
       if(pid == 0){
           if(pidmax < getpid())
               pidmax = getpid();
           printf("pid: %d, max: %d\n", getpid(), pidmax);  
           return 0;
       }

       if(pid == -1) {
        printf("Maximum process: %d\n", pidmax);
        exit(-1);
       }
    }
    return 0;
}

Answer 1

There are much easier ways to do this rather than via experimentation.

Most Unix systems provide ulimit to show you the various soft (ie. user defined) and hard (ie. admin defined) limits on your account. For example, here's my soft and hard limits on OS X.

$ ulimit -a -S
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
file size               (blocks, -f) unlimited
max locked memory       (kbytes, -l) unlimited
max memory size         (kbytes, -m) unlimited
open files                      (-n) 256
pipe size            (512 bytes, -p) 1
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 709
virtual memory          (kbytes, -v) unlimited

$ ulimit -a -H
core file size          (blocks, -c) unlimited
data seg size           (kbytes, -d) unlimited
file size               (blocks, -f) unlimited
max locked memory       (kbytes, -l) unlimited
max memory size         (kbytes, -m) unlimited
open files                      (-n) unlimited
pipe size            (512 bytes, -p) 1
stack size              (kbytes, -s) 65532
cpu time               (seconds, -t) unlimited
max user processes              (-u) 1064
virtual memory          (kbytes, -v) unlimited

While the system may support more processes, your program will be limited by these limits. I am limited to 709 (what an odd number) processes and can raise it to 1064.

The maximum number of processes at a single time is limited by the size of pid_t and often by a restriction defined in the kernel. See this answer and also this answer for more detail.

Answer 2

This can be possible by counting number of numbered directories present inside /proc directory. These numbered directories are the PID's of processes which are currently running.

/proc referred to as a process information pseudo-file system. For more information, you can visit, http://tldp.org/LDP/Linux-Filesystem-Hierarchy/html/proc.html

I have written small code which gives number of processes running.

#include <stdio.h>
#include <dirent.h>

int main()
{
        DIR* proc = opendir("/proc");
        struct dirent* ent;
        int count = 0;

        if(proc == NULL) {
                perror("opendir(/proc)");
                return 1;
        }       

        while(ent = readdir(proc)) {
            if(!isdigit(*ent->d_name))
                continue;
            count++; //if directory name is number then increment the count.
        }

        closedir(proc);

        printf("Number of Processes=%d\n",count);
        return 0;
}

Answer 3

Look at the documentation for proc(5), and you'll see this for the processes field:

Number of forks since boot.

So it's simply not the number you're looking for. ps will give you that as you already know, counting the directories with only numbers in their name under /proc is another approach.

ulimit might limit the max per-user processes to less than the maximum pid.

ulimit -u which says the total processes a user can have at a particular time. The above command returns me the output as 63203. This means for all the processes that a user has created at a point of time the user can have 63203 processes running.

You will get total number of running processes on a given machine

 ps -e | wc -l