Process Creation

• There are four principal events that cause processes to be created:
  1. System initialization. When an OS is booted, typically several processes are created.
  2. Execution of a process creation system call by a running process. Often a running process will issue system calls to create one or more new processes to help it do its job. Creating new processes is particularly useful when the work to be done can easily be formulated in terms of several related, but otherwise independent interacting processes.
  3. A user request to create a new process. In interactive systems, users can start a program by typing a command or (double) clicking an icon.
  4. Initiation of a batch job. Here users can submit batch jobs to the system (possibly remotely). When the OS decides that it has the resources to run another job, it creates a new process and runs the next job from the input queue in it.
• In all these cases, a new process is created by having an existing process execute a process creation system call (in UNIX,$fork()$).
• The creating process is called a parent process, and the new processes are called the children of that process. Each of these new processes may in turn create other processes, forming a tree of processes.
• Most OSs (including UNIX and the Windows family of OSs) identify processes according to a unique process identifier (or pid), which is typically an integer number.
• In general, a process will need certain resources (CPU time, memory, files, I/0 devices) to accomplish its task. When a process creates a subprocess, that subprocess may be able to obtain its resources directly from the OS, or it may be constrained to a subset of the resources of the parent process.
  • The parent may have to partition its resources among its children,
  • or it may be able to share some resources (such as memory or files) among several of its children.
• Restricting a child process to a subset of the parent's resources prevents any process from overloading the system by creating too many subprocesses.
• When a process creates a new process, two possibilities exist in terms of execution:
  1. The parent continues to execute concurrently with its children, competing equally for the CPU.
  2. The parent waits until some or all of its children have terminated (on UNIX, see the man pages for {wait, waitpid, wait4, wait3}.).
• There are also two possibilities in terms of the address space of the new process:
  1. The child process is a duplicate of the parent process (it has the same program and data as the parent, an exact clone). The two processes, the parent and the child, have the same memory image, the same environment strings, and the same open files.
  2. The child process has a new program loaded into it.
• The C program shown below illustrates the UNIX system calls previously described.

   #include <sys/types.h>
   #include <stdio.h>
   #include <unistd.h>
   int main ()
   {
   pid_t pid;
    /* fork a child process */
    pid = fork();
    if (pid < 0) {/* error occurred */
     fprintf (stderr,"Fork Failed");
     exit(-1);
    }
    else if (pid == 0) {/* child process * /
     execlp("/bin/ls","ls",NULL);
    }
    else {/* parent process */
     /* parent will wait for the child to complete */
     wait (NULL);
     printf ("Child Complete");
     exit(O);
    }
   }
  

  • We now have two different processes running a copy of the same program.
  • The value of pid for the child process is zero; that for the parent is an integer value greater than zero.
  • The child process overlays its address space with the UNIX command $/bin/ls$ (used to get a directory listing) using the $execlp()$ system call ($execlp()$ is a version of the $exec()$ system call).
  • The parent waits for the child process to complete with the $wait()$ system call.
  • When the child process completes (by either implicitly or explicitly invoking $exit()$ ) the parent process resumes from the call to $wait()$ , where it completes using the $exit()$ system call.
  • This is also illustrated in Fig. 3.12.

    Figure 3.12: Process creation.