Distributed programming is usually hard and very different from "normal" programming. For example, to send some data to another part of the application running on a different computer, the developer often has to explicitly write code to transfer the data over the network. But there must be a simpler way!

One standard way of inter-process data exchange and synchronization under Linux is SystemV IPC. It provides system calls for sending messages from one process to another (message queues). It also lets processes share a memory space between themselves, so one process' writes will be available to another process immediately (shared memory segments). System V IPC also provides semaphores, which lets processes synchronize their activities, by allowing processes to wait for each other. Making these mechanisms work over a network, just like they do on a single computer, would make distributed programming very simple, and this is exactly what DIPC has done!

DIPC (Distributd Inter-Process Communication) eases network data transfer and synchronization by making data transfer over a network look exactly like normal System V IPC operations. It does not require any special hardware. In more technical terms, it is a software-only solution for transparent distributed data exchange on a network of Linux computers. It operates at the kernel level, and allows the programmer to use System V semaphores, message queues, and shared memory segments over the network with very little source code change.

The code at the end of this page shows a very simple program that uses DIPC to send a message from one process to another, over the network. This source code is mainly System V IPC programming. The addition required by DIPC is highlighted in bold. If you leave out the bold part, then it is normal System V IPC code. As you can see, the developer doesn't need to do much to make his or her application able to run over a network!

To read papers on DIPC please click here.

To download DIPC please click here. The DIPC package contains indformation about the system, as well as examples and the complete source code.

For more information please contact kamran@kamran-karimi.com.

DIPC's development in pursued at Source Forge. Please join the effort.



The sample program which follows sends 512 bytes, containing a message, from one process to another via a message queue. If run on a cluster with DIPC properly installed, the message will traverse the network.

A few notes about DIPC programs: They can be run on computers with no support for DIPC in the kernel, though in this case obviously all the processes should run in the same machine. DIPC does not distribute any code accross the network, so the user must start each process remotely as appropriate (maybe via 'rsh' or similar methods).

/*
* hello.h
*
* Header file for hello1.c and hello2.c
*
* By Kamran Karimi
*/

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <errno.h>
#include <linux/dipc.h>
#include <string.h>


#ifdef __GLIBC__
#define IPC_DIPC 00010000 /* make it distributed */
#endif


#define MSG_KEY 40
#define MSG_MODE (IPC_DIPC | IPC_EXCL | 0777)
/* use of 'IPC_DIPC' is the ONLY thing that makes this program a distributed
  one. Everything else is normal System V IPC programming */
#define MSG_TYPE 10
#define MSG_SIZE 512

struct message
{
  long mtype;
  char mtext[MSG_SIZE];
};



/*
* hello1.c
*
* It initializes a message structure and waits to receive a message.
* After running hello1, you should run hello2 on a remote machine.
*
* By Kamran Karimi
*/

#include "hello.h"

int main()
{
  int msgid;
  struct message mess;

  /* create the message queue. The other process will access it later */
  msgid = msgget(MSG_KEY, MSG_MODE | IPC_CREAT);
  if(msgid < 0)
  {
   fprintf(stderr,"Hello1: msgget() failed BECAUSE %s\n", strerror(errno));
   exit(20);
  }
  fprintf(stderr,"Hello1: waiting to receive a message...\n");
  if(msgrcv(msgid, (struct msgbuf *)&mess, sizeof(mess.mtext), 0, 0) < 0)
   fprintf(stderr,"Hello1: msgrcv() failed BECAUSE %s\n", strerror(errno));
  else
   fprintf(stderr,"Hello1: Received '%s'\n",mess.mtext);
  msgctl(msgid,IPC_RMID,NULL);
  exit(0);
}



/*
* hello2.c
*
* This program sends a message to hello1 process.
* You should first run hello1, and then hello2 on a machine in the
* same cluster
*
* By Kamran Karimi
*/

#include "hello.h"

int main()
{
 int msgid;
 struct message mess;

 /* gain access to the message queue that was created by hello1 */
  msgid = msgget(MSG_KEY, MSG_MODE);
  if(msgid < 0)
  {
   fprintf(stderr,"Hello2: msgget() failed BECAUSE %s\n",strerror(errno));
   exit(20);
  }
  mess.mtype = MSG_TYPE; /* not necessary here */
  strcpy(mess.mtext,"Hello, Distributed Programming!");
  /* now send the message. This will traverse the network if hello1 and
    hello2 programs are in different computers and DIPC is properly
    installed */
  if(msgsnd(msgid, (struct msgbuf *)&mess, sizeof(mess.mtext), 0) < 0)
  {
   fprintf(stderr,"Hello2: msgsnd() failed BECAUSE %s\n", strerror(errno));
   exit(20);
  }
  exit(0);
}