I have used IPC in Win32 code a while ago - critical sections, events, and semaphores.

How is the scene in the .NET environment?
Are there any tutorial explaining all available options and when to use and why?

IPC Mechanisms in C# - Usage and Best Practices

I&#39;ve never had to do IPC on Windows before. I&#39;m developing a pair of programs, a standard GUI/CLI app, and a windows service. The app has to tell the service what to do. So, assuming the communication is local only, what would be the best communication method for these two processes?  
By best I mean more robust and less error prone, not the best performance nor the easiest to code.

Note I&#39;m asking about what to use, a standard TCP socket, named pipes, or some other means of communication only.


Interprocess communication for Windows in C# (.NET 2.0)

I&#39;m looking to develop two separate (but related) Java desktop applications.

I want the ability for one application to trigger the other, passing in data that can then be edited and passed back, i.e. the communication will be two way.  If the other application is already running I want them to just communicate, i.e. I dont want to just pass arguments over the command line, etc.

Generally speaking, what strategies/techniques should I be looking at in order to achieve this?

Communication between two separate Java desktop applications

I&#39;m trying to play with inter-process communication and since I could not figure out how to use named pipes under Windows I thought I&#39;ll use network sockets. Everything happens locally. The server is able to launch slaves in a separate process and listens on some port. The slaves do their work and submit the result to the master. How do I figure out which port is available? I assume I cannot listen on port 80 or 21?

I&#39;m using Python, if that cuts the choices down.


On localhost, how do I pick a free port number?

Everyone seems to say named pipes are faster than sockets IPC. How much faster are they? I would prefer to use sockets because they can do two-way communication and are very flexible but will choose speed over flexibility if it is by considerable amount.

IPC performance: Named Pipe vs Socket

How do I write a simple--bare minimum needed for it to work--test application that illustrates how to use IPC/Named Pipes?

For example, how would one write a console application where Program 1 says &quot;Hello World&quot; to Program 2 and Program 2 receives message and replies &quot;Roger That&quot; to Program 1.


Example of Named Pipes

In Linux, what happens when a program (that possibly has multiple threads) receives a signal, like SIGTERM or SIGHUP?

Which thread intercepts the signal? Can multiple threads get the same signal? Is there a special thread dedicated entirely to handling signals? If not, what happens inside the thread that is to handle the signal? How does the execution resume after the signal handler routine finishes?

Signal handling with multiple threads in Linux

Node.js is a perfect match for our web project, but there are few computational tasks for which we would prefer Python. We also already have a Python code for them.
We are highly concerned about speed, what is the most elegant way how to call a Python &quot;worker&quot; from node.js in an asynchronous non-blocking way?

Combining node.js and Python

What is a good way to communicate between two separate Python runtimes? Thing&#39;s I&#39;ve tried:

- reading/writing on named pipes e.g. [`os.mkfifo`](https://docs.python.org/3/library/os.html#os.mkfifo) (feels hacky)
- [`dbus`](https://wiki.python.org/moin/DbusExamples) services (worked on desktop, but too heavyweight for headless)
- sockets (seems too low-level; surely there&#39;s a higher level module to use?)

My basic requirement is to be able to run `python listen.py` like a daemon, able to receive messages from `python client.py`. The client should just send a message to the existing process and terminate, with return code `0` for success and nonzero for failure (i.e. a two-way communication will be required.)

Interprocess communication in Python

I have a Java app, connecting through TCP socket to a &quot;server&quot; developed in C/C++.

both app &amp; server are running on the same machine, a Solaris box (but we&#39;re considering migrating to Linux eventually).
type of data exchanged is simple messages (login, login ACK, then client asks for something, server replies). each message is around 300 bytes long.

Currently we&#39;re using Sockets, and all is OK, however I&#39;m looking for a faster way to exchange data (lower latency), using IPC methods.

I&#39;ve been researching the net and came up with references to the following technologies:

 - shared memory 
 - pipes
 - queues
 - as well as what&#39;s referred as DMA (Direct Memory Access)

but I couldn&#39;t find proper analysis of their respective performances, neither how to implement them in both JAVA and C/C++ (so that they can talk to each other), except maybe pipes that I could imagine how to do.

can anyone comment about performances &amp; feasibility of each method in this context ?
any pointer / link to useful implementation information ? 

----------
EDIT / UPDATE

following the comment &amp; answers I got here, I found info about Unix Domain Sockets, which seem to be built just over pipes, and would save me the whole TCP stack.
it&#39;s platform specific, so I plan on testing it with JNI or either [juds][1] or [junixsocket][2].

next possible steps would be direct implementation of pipes, then shared memory, although I&#39;ve been warned of the extra level of complexity...

------------------------------------


thanks for your help


  [1]: http://code.google.com/p/juds/
  [2]: http://code.google.com/p/junixsocket/

fastest (low latency) method for Inter Process Communication between Java and C/C++

I have a main process which creates two or more sub processes, I want  main process to wait until all sub processes finish their operations and exits?
     
     # main_script.py

     p1 = subprocess.Popen([&#39;python script1.py&#39;]) 
     p2 = subprocess.Popen([&#39;python script2.py&#39;])
     ... 
     #wait main process until both p1, p2 finish
     ...

wait process until all subprocess finish?

 1. What are the differences between `System V IPC` and `POSIX IPC` ?
 2. Why do we have two standards ?
 3. How to decide which IPC functions to use ?

System V IPC vs POSIX IPC

Should I use Named Pipes, or .NET Remoting to communicate with a running process on my machine?


 

What is the best choice for .NET inter-process communication?

TCP has the tuple pairs (IP Addr/port/type) to tell one client from another.  UDP passes the client IP and port.  How does the unix domain keep track of different clients?

In other words the server creates a socket bound to some path say /tmp/socket.  2 or more clients connect to /tmp/socket.  What is going on underneath that keeps track of data from client1 and client2?  I imagine the network stack plays no part in domain sockets so is the kernel doing all the work here?

Is there a unix domain protocol format like there is an IP protocol format and TCP/UDP formats?  Is the format of domain socket datagram protocols published somewhere?  Is every unix different or does something like POSIX standardize it?

Thanks for any illumination.  I could not find any information that explained this.  Every source just glossed over how to use the domain sockets.

How do Unix Domain Sockets differentiate between multiple clients?

I want to create a communication between a parent and a child process, both written in C#.

It should be asynchronous, event-driven.

I don&#39;t want to run a thread in every process to handle the very rare communication.

What is the best solution for it?


What is the simplest method of inter-process communication between 2 C# processes?

Lots of IPCs are offered by Unix/Linux: pipes, sockets, shared memory, dbus, message-queues...

What are the most suitable applications for each, and how do they perform?

Comparing Unix/Linux IPC

We are still in the design-phase of our project but we are thinking of having three separate processes on an embedded Linux kernel.   One of the processes with be a communications module which handles all communications to and from the device through various mediums.

The other two processes will need to be able to send/receive messages through the communication process.  I am trying to evaluate the IPC techniques that Linux provides; the message the other processes will be sending will vary in size, from debug logs to streaming media at ~5 Mbit rate.  Also, the media could be streaming in and out simultaneously.

Which IPC technique would you suggestion for this application?
http://en.wikipedia.org/wiki/Inter-process_communication

Processor is running around 400-500 Mhz if that changes anything.
Does not need to be cross-platform, Linux only is fine.
Implementation in C or C++ is required.


Which Linux IPC technique to use?

I have the following situation:

I have 2 JVM processes (really 2 `java` processes running separately, not 2 threads) running on a local machine. Let&#39;s call them `ProcessA` an `ProcessB`.

I want them to communicate (exchange data) with one another (e.g. `ProcessA` sends a message to `ProcessB` to do something).

Now, I work around this issue by writing a temporary file and these process periodically scan this file to get message. I think this solution is not so good.

What would be a better alternative to achieve what I want?

How to have 2 JVMs talk to one another

I&#39;m looking for suggestions on possible IPC mechanisms that are:

 - **Cross platform** (Win32 and Linux at least)
 - Simple to implement in **C++** as well as the **most common scripting languages** (perl, ruby, python, etc).
 - Finally, **simple to use** from a programming point of view!

What my options are? I&#39;m programming under Linux, but I&#39;d like what I write to be portable to other OSes in the future. I&#39;ve thought about using sockets, named pipes, or something like DBus.


Cross platform IPC

I&#39;ve been playing with message queues (System V, but POSIX should be ok too) in Linux recently and they seem perfect for my application, but after reading The Art of Unix Programming I&#39;m not sure if they are really a good choice.

[http://www.faqs.org/docs/artu/ch07s02.html#id2922148][1]
&gt; The upper, message-passing layer of System V IPC has largely fallen out of use. The lower layer, which consists of shared memory and semaphores, still has significant applications under circumstances in which one needs to do mutual-exclusion locking and some global data sharing among processes running on the same machine. These System V shared memory facilities evolved into the POSIX shared-memory API, supported under Linux, the BSDs, MacOS X and Windows, but not classic MacOS.

[http://www.faqs.org/docs/artu/ch07s03.html#id2923376][2]
&gt;The System V IPC facilities are present in Linux and other modern Unixes. However, as they are a legacy feature, they are not exercised very often. The Linux version is still known to have bugs as of mid-2003. Nobody seems to care enough to fix them.

Are the System V message queues still buggy in more recent Linux versions? I&#39;m not sure if the author means that POSIX message queues should be ok?

It seems that sockets are the preferred IPC for almost anything(?), but I cannot see how it would be very simple to implement message queues with sockets or something else. Or am I thinking too complexly?

I don&#39;t know if it&#39;s relevant that I&#39;m working with embedded Linux?

  [1]: http://www.faqs.org/docs/artu/ch07s02.html#id2922148
  [2]: http://www.faqs.org/docs/artu/ch07s03.html#id2923376

Are message queues obsolete in linux?

Will any one please tell me what are all the IPC mechanisms that are present in Android.

To my knowledge are:

1. Intents
2. Binders

What are the IPC mechanisms available in the Android OS?

Is there a difference between RPC and IPC?

Does OS X (Snow Leopard in particular) have an equivalent to (some versions of) Linux&#39;s `/dev/shm` , ie something where you can write to and read from a file without necessarily touching the hard drive?

Does OS X have an equivalent to /dev/shm?

I’m writing a load balanced server system in Go.

The load balancing server will communicate with several application servers and process requests. These servers can both, be running on the same machine or on the network.

I already figured the networking out but now I need to find an optimal way for the load-balancer to communicate with a local application server. Using `localhost`-networking seems far from optimal.

I’m trying to share memory via the `shmget` and `shmat` system-calls but haven’t found any working examples and the `syscall` package is also completely undocumented.

Can someone provide me with an example of how to use these calls or a realistic alternative that works on Go for doing IPC?

All Ipc Solutions on Gang of Coders

Total of 24 Ipc Solutions