Boost Interprocess has support for Shared Memory. Boost Lockfree has a Single-Producer Single-Consumer queue type (spsc_queue). This is basically what you refer to as a circular buffer. Here’s a demonstration that passes IPC messages (in this case, of type string) using this queue, in a lock-free fashion. Defining the types First, let’s define our types: … Read more
When selecting your IPC you should consider causes for performance differences including transfer buffer sizes, data transfer mechanisms, memory allocation schemes, locking mechanism implementations, and even code complexity. Of the available IPC mechanisms, the choice for performance often comes down to Unix domain sockets or named pipes (FIFOs). I read a paper on Performance Analysis … Read more
pthreads(7) describes that POSIX.1 requires all threads in a process share attributes, including: signal dispositions POSIX.1 also requires some attributes to be distinct for each thread, including: signal mask (pthread_sigmask(3)) alternate signal stack (sigaltstack(2)) The Linux kernel’s complete_signal routine has the following code block — the comments are quite useful: /* * Now find a … Read more
You can just do it. { local @ARGV = qw<param1 param2 param3>; do ‘/home/buddy/myscript.pl’; } Prevents the overhead of loading in another copy of perl.
To show how easy it is to let two applications communicate with each other, check out this network-clipboard demo using JGroups. Just start two instances and begin dropping files into one of them. The second instance will instantly show the same files. import java.io.Serializable; import java.awt.*; import java.awt.datatransfer.*; import javax.swing.*; import org.jgroups.*; public class JGroupsTest … Read more
Do not bind to a specific port. Instead, bind to port 0: import socket sock = socket.socket() sock.bind((”, 0)) sock.getsockname()[1] The OS will then pick an available port for you. You can get the port that was chosen using sock.getsockname()[1], and pass it on to the slaves so that they can connect back. sock is … Read more
Multiple options for IPC: Socket-Based (Bare-Bones) Networking not necessarily hard, but: might be verbose for not much, might offer more surface for bugs, as you write more code. you could rely on existing frameworks, like Netty RMI Technically, that’s also network communication, but that’s transparent for you. Fully-fledged Message Passing Architectures usually built on either … Read more
IPC in .Net can be achieved using: WCF using named pipes requires .Net 3.0 and above. Code example The WCF class NetNamedPipeBinding can be used for interprocess communication on the same machine. The MSDN documentaion for this class includes a code sample covering this scenario http://msdn.microsoft.com/en-us/library/system.servicemodel.netnamedpipebinding.aspx Remoting The original IPC framework released with .Net 1.0. … Read more
using System; using System.IO; using System.IO.Pipes; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { StartServer(); Task.Delay(1000).Wait(); //Client var client = new NamedPipeClientStream(“PipesOfPiece”); client.Connect(); StreamReader reader = new StreamReader(client); StreamWriter writer = new StreamWriter(client); while (true) { string input = Console.ReadLine(); if (String.IsNullOrEmpty(input)) break; writer.WriteLine(input); writer.Flush(); Console.WriteLine(reader.ReadLine()); … Read more
The multiprocessing library provides listeners and clients that wrap sockets and allow you to pass arbitrary python objects. Your server could listen to receive python objects: from multiprocessing.connection import Listener address = (‘localhost’, 6000) # family is deduced to be ‘AF_INET’ listener = Listener(address, authkey=b’secret password’) conn = listener.accept() print ‘connection accepted from’, listener.last_accepted while … Read more