Multitasking

Process Management beings with an understanding concept of Multitasking. Linux is what is referred to as a preemptive multitasking operating system. Preemptive multitasking systems rely on a scheduler. The function of the scheduler is to control the process that is currently using the CPU.

so there is parent process and child process. The process which creates another process is called parent process and latter is called child process. And each process has its own PID i.e. process identity number to distinguish the child from the parent.

To get these process IDs, we use following functions

a)      getpid() // to get the current process id

b)      getppid() // to get the creator/ parent process id

There are three methods of creating a process:

a)      Create a process with the use  of loader from file system.

b)      Create a process from the code segment of the current program using system call

c)      Duplication of the program

To create a process using this method (Duplicate) is done by using “fork()”

fork function is a special function use to create a child process from a parent process. Using fork(), child process shares the code segment of its parent but both processes have different physical address. After completion of the child process, child process returns its control to parent and the parent process returns its control to the shell.

child PID= parent PID + 1

PPID of child = PID of parent

fork() function returns three values

a)      0 (zero)    :  if the process is executed by child

b)      +ve value :  means child is created and +ve value is child’s PID

c)      -ve value  :  ERROR…! i.e. child process is not created

and we can use these values to know which process  is executing.

IPC (Inter Process Communicaton) is a set of methods for the exchange of data between multiple threads in one or more processes. Processes may be running on one or more computers connected by a network. There are several methods to do this like:

a) file : A record stored on the disk that can be accessed by name by any process.

b) Signal: A system message sent from one process to another, not usually used to store information but instead give commands.

c) Socket: A data stream sent over a network interface, either to a different process on the same computer or to another computer.

d) Message Queue: An anonymous data stream similar to the pipe, but stores and retrieves information in packets.

e) Pipe: A two-way data stream interfaced through standard input and output and is read character by character.

f) Named Pipe: A pipe implemented through a file on the file system instead of standard input and output.

g) Semaphore: A simple structure that synchronizes threads or processes acting on shared resources.

h) Shared Memory: Multiple processes given access to the same memory, allowing all to change it and read changes made by other processes.

Process table: It is like a data structure describing all of the processes that are currently loaded with their PID, status, command string, and sort of information. Operating system manages processes using their PID’s. To see the list of processes, we use “ps” command.

eg: ps -ax, ps-af, etc

Pipes:

Pipes provide unidirectional flow of communication between processes within the same system. In other words, they are half-duplex, that is, data flows in only one direction. A pipe is created by invoking the pipe system call, which creates a pair of file descriptors. These descriptors point to a pipe inode and the file descriptors are returned through the filedes argument. In the file descriptor pair, filedes[0] is used for reading whereas filedes[1] is used for writing.
One of the major disadvantage of pipes is that the they can not be accesed using their names by any other process other than child and the parent as they do not get listed in the directory tree.

The work around for this porblem is to create a named pipe which is also called as a FIFO, which stands for First in First out, meaning the data that is written into the pipe first will be read out first always.

FIFO: The fifos get listed in the directory tree and any process can access it using its name by providing the approproiate path.

fifo are created using the function mkfifo() which takes as arguments

1. The name of the fifo that has to be created
2. The permissions for the file.

Once the file is created, it needs to be opened using the system call open() and the data can be read and written from the file using read() and write system calls.

One of the examples you can think of using a named pipe is communication between a server and a client. If ther are two fifos one of the server and the other of the client, then the client can send request to the server on the server fifo which the server will read and respond back with the reply on the client’s fifo.

Another advantage of a fifo over the pipes is that fifo are birectoinal, that is the same fifo can be read from as well and written into.

Shared Memory

Shared memory allows one or more processes to communicate via memory that appears in all of their virtual address space.

shared memory mechanism consisting of four steps. in order of:

• Creating the segment and connecting -shmget (shared memory get)
• Using the pointer to get the shared memory address – shmat (shared memory attach),
• Detaching the shared memory area after use – shmdt (shared memory detach) and
• Finally using the address to control accesses, permissions, receive information and destroy the shared memory area – shmctl (shared memory control).