Category: inter Process Communication

Process Creation & Termination ”; Previous Next Till now we know that whenever we execute a program then a process is created and would be terminated after the completion of the execution. What if we need to create a process within the program and may be wanted to schedule a different task for it. Can this be achieved? Yes, obviously through process creation. Of course, after the job is done it would get terminated automatically or you can terminate it as needed. Process creation is achieved through the fork() system call. The newly created process is called the child process and the process that initiated it (or the process when execution is started) is called the parent process. After the fork() system call, now we have two processes – parent and child processes. How to differentiate them? Very simple, it is through their return values. After creation of the child process, let us see the fork() system call details. #include <sys/types.h> #include <unistd.h> pid_t fork(void); Creates the child process. After this call, there are two processes, the existing one is called the parent process and the newly created one is called the child process. The fork() system call returns either of the three values − Negative value to indicate an error, i.e., unsuccessful in creating the child process. Returns a zero for child process. Returns a positive value for the parent process. This value is the process ID of the newly created child process. Let us consider a simple program. File name: basicfork.c #include <stdio.h> #include <sys/types.h> #include <unistd.h> int main() { fork(); printf(“Called fork() system calln”); return 0; } Execution Steps Compilation gcc basicfork.c -o basicfork Execution/Output Called fork() system call Called fork() system call Note − Usually after fork() call, the child process and the parent process would perform different tasks. If the same task needs to be run, then for each fork() call it would run 2 power n times, where n is the number of times fork() is invoked. In the above case, fork() is called once, hence the output is printed twice (2 power 1). If fork() is called, say 3 times, then the output would be printed 8 times (2 power 3). If it is called 5 times, then it prints 32 times and so on and so forth. Having seen fork() create the child process, it is time to see the details of the parent and the child processes. File name: pids_after_fork.c #include <stdio.h> #include <sys/types.h> #include <unistd.h> int main() { pid_t pid, mypid, myppid; pid = getpid(); printf(“Before fork: Process id is %dn”, pid); pid = fork(); if (pid < 0) { perror(“fork() failuren”); return 1; } // Child process if (pid == 0) { printf(“This is child processn”); mypid = getpid(); myppid = getppid(); printf(“Process id is %d and PPID is %dn”, mypid, myppid); } else { // Parent process sleep(2); printf(“This is parent processn”); mypid = getpid(); myppid = getppid(); printf(“Process id is %d and PPID is %dn”, mypid, myppid); printf(“Newly created process id or child pid is %dn”, pid); } return 0; } Compilation and Execution Steps Before fork: Process id is 166629 This is child process Process id is 166630 and PPID is 166629 Before fork: Process id is 166629 This is parent process Process id is 166629 and PPID is 166628 Newly created process id or child pid is 166630 A process can terminate in either of the two ways − Abnormally, occurs on delivery of certain signals, say terminate signal. Normally, using _exit() system call (or _Exit() system call) or exit() library function. The difference between _exit() and exit() is mainly the cleanup activity. The exit() does some cleanup before returning the control back to the kernel, while the _exit() (or _Exit()) would return the control back to the kernel immediately. Consider the following example program with exit(). File name: atexit_sample.c #include <stdio.h> #include <stdlib.h> void exitfunc() { printf(“Called cleanup function – exitfunc()n”); return; } int main() { atexit(exitfunc); printf(“Hello, World!n”); exit (0); } Compilation and Execution Steps Hello, World! Called cleanup function – exitfunc() Consider the following example program with _exit(). File name: at_exit_sample.c #include <stdio.h> #include <unistd.h> void exitfunc() { printf(“Called cleanup function – exitfunc()n”); return; } int main() { atexit(exitfunc); printf(“Hello, World!n”); _exit (0); } Compilation and Execution Steps Hello, World! Print Page Previous Next Advertisements ”;

Process Image ”; Previous Next Now that we have seen how to get the basic information of process and its parent process, it is time to look into the details of process/program information. What exactly is process image? Process image is an executable file required while executing the program. This image usually contains the following sections − Code segment or text segment Data segment Stack segment Heap segment Following is the pictorial representation of the process image. Code segment is a portion of object file or program’s virtual address space that consists of executable instructions. This is usually read-only data segment and has a fixed size. Data segment is of two types. Initialized Un-initialized Initialized data segment is a portion of the object file or program’s virtual address space that consists of initialized static and global variables. Un-initialized data segment is a portion of the object file or program’s virtual address space that consists of uninitialized static and global variables. Un-initialized data segment is also called BSS (Block Started by Symbol) segment. Data segment is read-write, since the values of variables could be changed during run time. This segment also has a fixed size. Stack segment is an area of memory allotted for automatic variables and function parameters. It also stores a return address while executing function calls. Stack uses LIFO (Last-In-First-Out) mechanism for storing local or automatic variables, function parameters and storing next address or return address. The return address refers to the address to return after completion of function execution. This segment size is variable as per local variables, function parameters, and function calls. This segment grows from a higher address to a lower address. Heap segment is area of memory allotted for dynamic memory storage such as for malloc() and calloc() calls. This segment size is also variable as per user allocation. This segment grows from a lower address to a higher address. Let us now check how the segments (data and bss segments) size vary with a few sample programs. Segment size is known by executing the command “size”. Initial program File: segment_size1.c #include<stdio.h> int main() { printf(“Hello Worldn”); return 0; } In the following program, an uninitialized static variable is added. This means uninitialized segment (BSS) size would increase by 4 Bytes. Note − In Linux operating system, the size of int is 4 bytes. Size of the integer data type depends on the compiler and operating system support. File: segment_size2.c #include<stdio.h> int main() { static int mystaticint1; printf(“Hello Worldn”); return 0; } In the following program, an initialized static variable is added. This means initialized segment (DATA) size would increase by 4 Bytes. File: segment_size3.c #include<stdio.h> int main() { static int mystaticint1; static int mystaticint2 = 100; printf(“Hello Worldn”); return 0; } In the following program, an initialized global variable is added. This means initialized segment (DATA) size would increase by 4 Bytes. File: segment_size4.c #include<stdio.h> int myglobalint1 = 500; int main() { static int mystaticint1; static int mystaticint2 = 100; printf(“Hello Worldn”); return 0; } In the following program, an uninitialized global variable is added. This means uninitialized segment (BSS) size would increase by 4 Bytes. File: segment_size5.c #include<stdio.h> int myglobalint1 = 500; int myglobalint2; int main() { static int mystaticint1; static int mystaticint2 = 100; printf(“Hello Worldn”); return 0; } Execution Steps Compilation babukrishnam $ gcc segment_size1.c -o segment_size1 babukrishnam $ gcc segment_size2.c -o segment_size2 babukrishnam $ gcc segment_size3.c -o segment_size3 babukrishnam $ gcc segment_size4.c -o segment_size4 babukrishnam $ gcc segment_size5.c -o segment_size5 Execution/Output babukrishnam size segment_size1 segment_size2 segment_size3 segment_size4 segment_size5 text data bss dec hex filename 878 252 8 1138 472 segment_size1 878 252 12 1142 476 segment_size2 878 256 12 1146 47a segment_size3 878 260 12 1150 47e segment_size4 878 260 16 1154 482 segment_size5 babukrishnam Print Page Previous Next Advertisements ”;

Overlaying Process Image ”; Previous Next Assume that we are running a program and we want to run another program from the current program. Is this possible? Why not, if we implement the concept of overlaying the process image. That’s fine but what about the current running program, can that be run too. How is it possible, since we overlaid the current program with the new program. What to do, if I want to run the two programs without losing the current running program, is it possible? Yes, it is possible. Create a child process, so that we have a parent process and a newly created child process. Already we are running the current program in the parent process, so run the newly created process in the child. In this way, we can run another program from the current program. Not only a single program but we can run any number of programs from the current program by creating that many number of child processes. Let us consider the following program as an example. /* File Name: helloworld.c */ #include<stdio.h> void main() { printf(“Hello Worldn”); return; } /* File Name: execl_test.c */ #include<stdio.h> #include<unistd.h> void main() { execl(“./helloworld”, “./helloworld”, (char *)0); printf(“This wouldn”t printn”); return; } The above program would overlay the process image of execl_test with helloworld. That is the reason, the process image code of execl_test (printf()) is not executed. Compilation and Execution Steps Hello World Now, we will run the following two programs from one program, i.e., execl_run_two_prgms.c. Hello World program (helloworld.c) While loop program to print from 1 to 10 (while_loop.c) /* File Name: while_loop.c */ /* Prints numbers from 1 to 10 using while loop */ #include<stdio.h> void main() { int value = 1; while (value <= 10) { printf(“%dt”, value); value++; } printf(“n”); return; } Following is the program to run two programs (one program from child and another program from parent). /* Filename: execl_run_two_prgms.c */ #include<stdio.h> #include<unistd.h> void main() { int pid; pid = fork(); /* Child process */ if (pid == 0) { printf(“Child process: Running Hello World Programn”); execl(“./helloworld”, “./helloworld”, (char *)0); printf(“This wouldn”t printn”); } else { /* Parent process */ sleep(3); printf(“Parent process: Running While loop Programn”); execl(“./while_loop”, “./while_loop”, (char *)0); printf(“Won”t reach heren”); } return; } Note − Place sleep() call to make sure the child and parent processes run sequentially (do not overlap the result). Compilation and Execution Steps Child process: Running Hello World Program This wouldn”t print Parent process: Running While loop Program Won”t reach here Now we would run two programs from one program i.e., execl_run_two_prgms.c, same program as above but with command line arguments. So, we are running two programs namely, helloworld.c in the child process, and the program while_loop.c in the parent process. This is as follows − Hello World program (helloworld.c) While loop program to print from 1 to num_times_str as per command line arguments (while_loop.c) This program broadly performs the following actions − Creates a child process Child process executes helloworld.c program Parent process executes while_loop.c program passing the command line argument value as an argument to the program. If the command line arguments are not passed, then the default is taken as 10. Otherwise, it takes the given argument value. The argument value should be numeric; code would not validate if given in alphabets. /* Filename: execl_run_two_prgms.c */ #include<stdio.h> #include<string.h> #include<unistd.h> void main(int argc, char *argv[0]) { int pid; int err; int num_times; char num_times_str[5]; /* In no command line arguments are passed, then loop maximum count taken as 10 */ if (argc == 1) { printf(“Taken loop maximum as 10n”); num_times = 10; sprintf(num_times_str, “%d”, num_times); } else { strcpy(num_times_str, argv[1]); printf(“num_times_str is %sn”, num_times_str); pid = fork(); } /* Child process */ if (pid == 0) { printf(“Child process: Running Hello World Programn”); err = execl(“./helloworld”, “./helloworld”, (char *)0); printf(“Error %dn”, err); perror(“Execl error: “); printf(“This wouldn”t printn”); } else { /* Parent process */ sleep(3); printf(“Parent process: Running While loop Programn”); execl(“./while_loop”, “./while_loop”, (char *)num_times_str, (char *)0); printf(“Won”t reach heren”); } return; } Following is the helloworld.c program called from the child process of the program, execl_run_two_prgms.c. /* File Name: helloworld.c */ #include<stdio.h> void main() { printf(“Hello Worldn”); return; } Following is the while_loop.c program called from the parent process of the program, execl_run_two_prgms.c. The argument to this program is passed from the program which runs this i.e., execl_run_two_prgms.c. /* Filename: while_loop.c */ #include<stdio.h> void main(int argc, char *argv[]) { int start_value = 1; int end_value; if (argc == 1) end_value = 10; else end_value = atoi(argv[1]); printf(“Argv[1] is %sn”, argv[1]); while (start_value <= end_value) { printf(“%dt”, start_value); start_value++; } printf(“n”); return; } Compilation and Execution Steps Taken loop maximum as 10 num_times_str is 10 Child process: Running Hello World Program Hello World Parent process: Running While loop Program Argv[1] is 10 1 2 3 4 5 6 7 8 9 10 Taken loop maximum as 15 num_times_str is 15 Child process: Running Hello World Program Hello World Parent process: Running While loop Program Argv[1] is 15 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Let us now see the overlaying image related library functions. #include<unistd.h> int execl(const char *path, const char *arg, …); This function would overlay the current running process image with the new process as mentioned in the arguments, path and arg. If any argument needs to passed to a new process image, that would be send through “arg” arguments and the last argument should be NULL. This function would return a value only in case of an error. The process overlaying image related calls are as mentioned below − int execl(const char *path, const char *arg, …); int execlp(const char *file, const char *arg, …); int execle(const char *path, const char *arg, …, char * const envp[]); int execv(const char *path, char *const argv[]); int execvp(const char *file, char *const argv[]); int execvpe(const char *file, char *const argv[], char *const envp[]); These

Child Process Monitoring ”; Previous Next As we have seen, whenever we create a child process from a program using fork, the following happens − Current process now becomes the parent process The new process becomes the child process What happens if the parent process finishes its task early than the child process and then quits or exits? Now who would be the parent of the child process? The parent of the child process is init process, which is the very first process initiating all the tasks. To monitor the child process execution state, to check whether the child process is running or stopped or to check the execution status, etc. the wait() system calls and its variants is used. Let us consider an example program, where the parent process does not wait for the child process, which results into init process becoming the new parent for the child process. File name: parentprocess_nowait.c #include<stdio.h> int main() { int pid; pid = fork(); // Child process if (pid == 0) { system(“ps -ef”); sleep(10); system(“ps -ef”); } else { sleep(3); } return 0; } Compilation and Execution Steps UID PID PPID C STIME TTY TIME CMD root 1 0 0 Jan20 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe mysql 101 1 0 Jan20 ? 00:04:41 /usr/libexec/mysqld –basedir=/usr –datadir=/var/lib/mysql –plugin-dir=/usr/lib64/mysql/plugin –user=mysql –log-error=/var/log/mariadb/mariadb.log –pid-file=/run/mariadb/mariadb.pid –socket=/var/lib/mysql/mysql.sock 3108506 5445 0 0 Jan22 ? 00:01:19 [/sbin/klogd -c ] <defunct> 4688328 5446 0 0 Jan22 ? 00:01:19 [/sbin/klogd -c ] <defunct> 4688328 21894 0 0 Jan22 ? 00:01:19 [/sbin/klogd -c ] <defunct> 3108506 21895 0 0 Jan22 ? 00:01:19 [/sbin/klogd -c ] <defunct> 4688328 27309 0 0 Jan22 ? 00:00:00 [/sbin/klogd -c ] <defunct> 3108506 27311 0 0 Jan22 ? 00:00:00 [/sbin/klogd -c ] <defunct> 8295652 32407 0 0 Jan20 ? 00:00:39 /sbin/klogd -c 1 -x -x 4688328 49830 0 0 Jan20 ? 00:00:18 /sbin/klogd -c 1 -x -x 3108506 50854 0 0 Jan20 ? 00:00:18 /sbin/klogd -c 1 -x -x 4688328 64936 0 0 Jan22 ? 00:00:59 [/sbin/klogd -c ] <defunct> 3108506 64937 0 0 Jan22 ? 00:00:59 [/sbin/klogd -c ] <defunct> 4688328 67563 0 0 Jan22 ? 00:00:59 [/sbin/klogd -c ] <defunct> 5942779 68128 0 0 Jan22 ? 00:00:07 /sbin/klogd -c 1 -x -x 3108506 68238 0 0 Jan22 ? 00:00:59 [/sbin/klogd -c ] <defunct> 4688328 68999 0 0 Jan22 ? 00:00:14 [/sbin/klogd -c ] <defunct> 3108506 69212 0 0 Jan22 ? 00:00:14 [/sbin/klogd -c ] <defunct> 4688328 74090 0 0 Jan22 ? 00:00:00 [/sbin/klogd -c ] <defunct> 3108506 74091 0 0 Jan22 ? 00:00:00 [/sbin/klogd -c ] <defunct> 4688328 74298 0 0 Jan22 ? 00:01:19 [/sbin/klogd -c ] <defunct> 3108506 74299 0 0 Jan22 ? 00:01:19 [/sbin/klogd -c ] <defunct> 6327201 74901 0 0 Jan20 ? 00:00:38 /sbin/klogd -c 1 -x -x 6327201 77274 0 0 Jan20 ? 00:00:27 /sbin/klogd -c 1 -x -x 7528790 78621 0 0 Jan20 ? 00:00:33 /sbin/klogd -c 1 -x -x 7528790 80536 0 0 Jan20 ? 00:01:09 [/sbin/klogd -c ] <defunct> 6327201 80542 0 0 Jan20 ? 00:01:09 [/sbin/klogd -c ] <defunct> 4688328 82050 0 0 Jan22 ? 00:01:59 [/sbin/klogd -c ] <defunct> 3108506 82051 0 0 Jan22 ? 00:01:59 [/sbin/klogd -c ] <defunct> 7528790 84116 0 0 Jan20 ? 00:00:27 /sbin/klogd -c 1 -x -x 7528790 84136 0 19 Jan20 ? 21:13:38 /sbin/klogd -c 1 -x -x 7528790 84140 0 0 Jan20 ? 00:00:28 /sbin/klogd -c 1 -x -x 3108506 84395 0 0 Jan22 ? 00:00:29 [/sbin/klogd -c ] <defunct> 4688328 84396 0 0 Jan22 ? 00:00:29 [/sbin/klogd -c ] <defunct> 5942779 84397 0 0 Jan22 ? 00:00:29 [/sbin/klogd -c ] <defunct> 3108506 84928 0 0 Jan22 ? 00:00:29 [/sbin/klogd -c ] <defunct> 4688328 84929 0 0 Jan22 ? 00:00:29 [/sbin/klogd -c ] <defunct> 5942779 84930 0 0 Jan22 ? 00:00:30 [/sbin/klogd -c ] <defunct> 7528790 84970 0 0 Jan20 ? 00:00:34 /sbin/klogd -c 1 -x -x 3108506 85787 0 0 Jan22 ? 00:00:14 [/sbin/klogd -c ] <defunct> 4688328 85789 0 0 Jan22 ? 00:00:14 [/sbin/klogd -c ] <defunct> 5942779 86368 0 0 Jan22 ? 00:00:14 [/sbin/klogd -c ] <defunct> 5942779 86402 0 0 Jan22 ? 00:00:14 [/sbin/klogd -c ] <defunct> 5942779 87027 0 0 Jan22 ? 00:00:14 [/sbin/klogd -c ] <defunct> 7528790 87629 0 0 Jan20 ? 00:00:39 /sbin/klogd -c 1 -x -x 7528790 87719 0 0 Jan20 ? 00:00:27 /sbin/klogd -c 1 -x -x 4688328 88138 0 0 Jan22 ? 00:00:14 [/sbin/klogd -c ] <defunct> 4688328 88140 0 0 Jan22 ? 00:00:14 [/sbin/klogd -c ] <defunct> 5942779 89353 0 99 Jan22 ? 2-07:35:14 /sbin/klogd -c 1 -x -x 5942779 91836 0 0 Jan22 ? 00:00:00 [/sbin/klogd -c ] <defunct> 4688328 125358 0 0 Jan22 ? 00:01:19 [/sbin/klogd -c ] <defunct> 3108506 125359 0 0 Jan22 ? 00:01:19 [/sbin/klogd -c ] <defunct> 4688328 127456 0 0 Jan22 ? 00:01:19 [/sbin/klogd -c ] <defunct> 3108506 127457 0 0 Jan22 ? 00:01:19 [/sbin/klogd -c ] <defunct> 8023807 163891 0 0 05:41 ? 00:00:00 main 8023807 164130 0 0 05:41 ? 00:00:00 sh -c cd /home/cg/root/8023807; timeout 10s main 8023807 164136 164130 0 05:41 ? 00:00:00 timeout 10s main 8023807 164137 164136 0 05:41 ? 00:00:00 main 8023807 164138 164137 0 05:41 ? 00:00:00 main 8023807 164139 164138 0 05:41 ? 00:00:00 ps -ef UID PID PPID C STIME TTY TIME CMD root 1 0 0 Jan20 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe mysql 101 1 0 Jan20 ? 00:04:41 /usr/libexec/mysqld –basedir=/usr –datadir=/var/lib/mysql –plugin-dir=/usr/lib64/mysql/plugin –user=mysql –log-error=/var/log/mariadb/mariadb.log –pid-file=/run/mariadb/mariadb.pid –socket=/var/lib/mysql/mysql.sock 3108506 5445 0 0 Jan22 ? 00:01:19 [/sbin/klogd -c ] <defunct> 4688328 5446 0 0 Jan22 ? 00:01:19 [/sbin/klogd -c ] <defunct> 4688328 21894 0 0 Jan22 ? 00:01:19 [/sbin/klogd -c ] <defunct> 3108506 21895 0 0 Jan22 ? 00:01:19 [/sbin/klogd -c ] <defunct> 4688328 27309 0 0 Jan22 ? 00:00:00 [/sbin/klogd -c ] <defunct> 3108506 27311 0 0 Jan22 ? 00:00:00 [/sbin/klogd -c ] <defunct> 8295652 32407 0 0 Jan20 ? 00:00:39 /sbin/klogd -c 1 -x -x 4688328 49830 0 0 Jan20 ? 00:00:18 /sbin/klogd -c 1 -x -x 3108506 50854 0 0 Jan20 ? 00:00:18 /sbin/klogd -c 1 -x -x

Related System Calls (System V) ”; Previous Next Following table lists the various System calls along with their description. Category System Call Description General open () This system call either opens an already existing file or creates and opens a new file. General creat () Creates and opens a new file. General read () Reads the contents of the file into the required buffer. General write () Writes the contents of buffer into the file. General close () Closes the file descriptor. General stat () Provides information on the file. Pipes pipe () Creates pipe for communication which returns two file descriptors for reading and writing. Named Pipes or Fifo mknod () Creates a memory device file or special file to create FIFOs Named Pipes or Fifo mkfifo () Creates a new FIFO Shared Memory shmget () Creates a new shared memory segment or gets the identifier of the existing segment. Shared Memory shmat () Attaches the shared memory segment and makes the segment a part of the virtual memory of the calling process. Shared Memory shmdt () Detaches the shared memory segment. Shared Memory shmctl () Performs control operations for the shared memory. Few of the generic control operations for the shared memory are removing the shared memory segment (IPC_RMID), receiving the information of the shared memory (IPC_STAT) and updating new values of the existing shared memory (IPC_SET). Message Queues msgget () Creates a new message queue or accesses an already existing message queue and gets the handle or identifier to perform operations with regard to message queue, such as sending message/s to queue and receiving message/s from the queue. Message Queues msgsnd () Sends a message to the required message queue with the required identification number. Message Queues msgrcv () Receives a message from the message queue. By default, this is infinite wait operation, means the call will be blocked until it receives a message. Message Queues msgctl () Performs control operations for the message queue. Few of the generic control operations for the message queue are removing the message queue (IPC_RMID), receiving the information of the message queue (IPC_STAT) and updating new values of the existing message queue (IPC_SET). Semaphores semget () Creates a new semaphore or gets the identifier of the existing semaphore. Semaphores are used to perform synchronization between various IPCs working on the same object. Semaphores semop () Performs semaphore operations on semaphore values. The basic semaphore operations are either acquiring or releasing the lock on the semaphore. Semaphores semctl () Performs control operations for the semaphore. Few of the generic control operations for the semaphore are removing the semaphore (IPC_RMID), receiving the information of the semaphore (IPC_STAT) and updating new values of the existing semaphore (IPC_SET). Signals signal () Setting the disposition of the signal (signal number) and the signal handler. In other terms, registering the routine, which gets executed when that signal is raised. Signals sigaction () Same as signal(), setting the disposition of the signal i.e., performing certain action as per the registered signal handler after the receipt of the registered signal. This system call supports finer control over signal() such as blocking certain signals, restoring signal action to the default state after calling the signal handler, providing information such as consumed time of the user and the system, process id of sending process, etc. Memory Mapping mmap () Mapping files into the memory. Once mapped into the memory, accessing files is as easy as accessing data using addresses and also in this way, the call is not expensive as system calls. Memory Mapping munmap () Un-mapping the mapped files from the memory. Print Page Previous Next Advertisements ”;

Inter Process Communication Tutorial PDF Version Quick Guide Resources Job Search Discussion Inter Process Communication (IPC) refers to a mechanism, where the operating systems allow various processes to communicate with each other. This involves synchronizing their actions and managing shared data. This tutorial covers a foundational understanding of IPC. Each of the chapters contain related topics with simple and useful examples. Audience This tutorial is designed for beginners who seek to understand the basic concepts of inter process communication and how its different components function. Prerequisites There are no particular prerequisites for this tutorial, however, a sound knowledge of operating systems and its various concepts will be an added advantage in understanding this tutorial. Print Page Previous Next Advertisements ”;

Inter Process Communication – Overview ”; Previous Next Inter Process Communication (IPC) is a mechanism that involves communication of one process with another process. This usually occurs only in one system. Communication can be of two types − Between related processes initiating from only one process, such as parent and child processes. Between unrelated processes, or two or more different processes. Following are some important terms that we need to know before proceeding further on this topic. Pipes − Communication between two related processes. The mechanism is half duplex meaning the first process communicates with the second process. To achieve a full duplex i.e., for the second process to communicate with the first process another pipe is required. FIFO − Communication between two unrelated processes. FIFO is a full duplex, meaning the first process can communicate with the second process and vice versa at the same time. Message Queues − Communication between two or more processes with full duplex capacity. The processes will communicate with each other by posting a message and retrieving it out of the queue. Once retrieved, the message is no longer available in the queue. Shared Memory − Communication between two or more processes is achieved through a shared piece of memory among all processes. The shared memory needs to be protected from each other by synchronizing access to all the processes. Semaphores − Semaphores are meant for synchronizing access to multiple processes. When one process wants to access the memory (for reading or writing), it needs to be locked (or protected) and released when the access is removed. This needs to be repeated by all the processes to secure data. Signals − Signal is a mechanism to communication between multiple processes by way of signaling. This means a source process will send a signal (recognized by number) and the destination process will handle it accordingly. Note − Almost all the programs in this tutorial are based on system calls under Linux Operating System (executed in Ubuntu). Print Page Previous Next Advertisements ”;