Solaris

A curious question. If i execute same program multiple times and print its process id, its not in sequential order, the pattern i observed is, if first run shows 5737, second run shows 5739, third shows 5741, I am wondering why its 2 units apart everytime.. Any answer appreciated.. Thanks

Hi.

So another process ran in the mean time.

How did you "print" its'process ID? With ps? ps is a process too, and has a process ID...

Hi, I am using a simple program

Code:

int
main(void)
{
    printf("hello world from process ID %d\n", getpid());
    exit(0);
}

Sample output -

Code:

bpatil zdwsmiddle01:/home/bpatil/UNIX{132}$ a.out
hello world from process ID 28921
bpatil zdwsmiddle01:/home/bpatil/UNIX{133}$ a.out
hello world from process ID 28923
bpatil zdwsmiddle01:/home/bpatil/UNIX{134}$ a.out
hello world from process ID 28930

Thanks

It may not be sequential for a few reasons; there may be other already-existing PID's at those spots, or, other things are getting run in the meantime. Try running it quickly three times and seeing if your PIDs are sequential then.

As others have posted, depending on system load it is very likely that multiple processes are being started simultaneously and that two commands executed sequentially will likely not have sequential PIDs. Even on a host with one active user, the presence of a browser, or other application, is likely to induce some 'noise' that would give you the results you are seeing.

I was curious about the fact that the PIDs seemed very regularly spaced and that it seemed fairly repeatable, so I did a bit of testing. I wrote a small script (t16) that does nothing but echo the pid:

Code:

echo $$
exit

On a quiet linux host, running it back to back under kshell yields the 'skipping' behaviour was noticed:

Code:

$ ksh -c "t16;t16;t16;t16;t16"
24756
24758
24760
24762
24754

Yet running it via bash there was no skipping:

Code:

$ bash -c "t16;t16;t16;t16;t16"
24764
24765
24766
24767
24768

Using strace I observe that Kshell is invoking vfork() between the execution of the commands. The nature of vfork() is that it does 'consume' a PID and thus the 'gap.' I believe that I know why vfork() is being invoked by kshell, but because I'm not absolutely positive I'm not going to post my guessing.

Another 'odd' thing with the execution under Kshell is that the last command actually has the lowest PID. This is because Kshell doesn't fork a process to run the last command in; instead it exec's the command overtop of itself and so the last command's PID was the same as the Kshell process that was invoked to run the commands and thus the lowest PID in the list. This is not something that would be observed if I had just executed the commands from my prompt:

Code:

$ t16;t16;t16;t16
24977
24979
24981
24983

So, if you are using Kshell, this is yet another possible explanation of the behaviour you were seeing.

Specifying the shell script interpreter, i.e.:

Code:

#!/bin/ksh
echo $$
exit

will likely make ksh behaving the expected way.

Afraid not. The #! directive in the script being executed has nothing to do with it. It is the parent shell, the shell that is doing the fork()/exec() on the command (script in this case), that is affecting the environment such that PID values appear to be skipping. The only important thing about what is being executed is that it terminates quickly and writes its PID to stdout/stderr.