Free ipc software for linux

IPC::LDT is a Perl module that implements a length based IPC protocol.

Interprocess communication often uses line (or record) oriented protocols. FTP, for example, usually is such a protocol: a client sends a command (e.g. "LS") which is completed by a carriage return. This carriage return is included in the command which is sent to the server process (FTP deamon) which could implement its reading in a way like this:

while ($cmd= )
{
chomp($cmd);
performCommand($cmd);
}

Well, such record oriented, blocked protocols are very useful and simply to implement, but sometimes there is a need to transfer more complex data which has no trailing carriage return, or data which may include more carriage returns inside the message which should not cause the reciepient to think the message is already complete while it is really not. Even if you choose to replace carriage returns by some obscure delimiters, the same could happen again until you switch to a protocol which does not flag the end of a message by special strings.
On the other hand, if there is no final carriage return (or whatever flag string) within a message, the end of the message has to be marked another way to avoid blocking by endless waiting for more message parts. A simple way to provide this is to precede a message by a prefix which includes the length of the remaining (real) message. A reciepient reads this prefix, decodes the length information and continues reading until the announced number of bytes came in.

IPC::LDT provides a class to build objects which transparently perform such "length driven transfer". A user sends and receives messages by simple method calls, while the LDT objects perform the complete translation into and from LDT messages (with prefix) and all the necessary low level IO handling to transfer stream messages on non blocked handles.

IPC::LDT objects can be configured to transfer simle string messages as well as complex data structures. Additionally, they allow to delay the transfer of certain messages in a user defined way.

IPC::PubSub is Perl module for Interprocess Publish/Subscribe channels.

SYNOPSIS

# A new message bus with the DBM::Deep backend
# (Other possible backends include Memcached and PlainHash)
my $bus = IPC::PubSub->new(DBM_Deep => /tmp/pubsub.db);

# A channel is any arbitrary string
my $channel = #perl6;

# Register a new publisher (you can publish to multiple channels)
my $pub = $bus->new_publisher("#perl6", "#moose");

# Publish a message (may be a complex object) to those channels
$pub->msg("This is a message");

# Register a new subscriber (you can subscribe to multiple channels)
my $sub = $bus->new_subscriber("#moose");

# Publish an object to channels
$pub->msg("This is another message");

# Set all subsequent messages from this publisher to expire in 30 seconds
$pub->expiry(30);
$pub->msg("This message will go away in 30 seconds");

# Simple get: Returns the messages sent since the previous get,
# but only for the first channel.
my @msgs = $sub->get;

# Simple get, with an explicit channel key (must be among the ones
# it initially subscribed to)
my @moose_msgs = $sub->get("#moose");

# Complex get: Returns a hash reference from channels to array
# references of [timestamp, message].
my $hash_ref = $sub->get_all;

# Changing the list of channels we subscribe to
$sub->subscribe(some-other-channel);
$sub->unsubscribe(some-other-channel);

# Changing the list of channels we publish to
$pub->publish(some-other-channel);
$pub->unpublish(some-other-channel);

# Listing and checking if we are in a channel
my @sub_channels = $sub->channels;
my @pub_channels = $pub->channels;
print "Sub is in #moose" if $sub->channels->{#moose};
print "Pub is in #moose" if $pub->channels->{#moose};

# Raw cache manipulation APIs (not advised; use ->modify instead)
$bus->lock(channel);
$bus->unlock(channel);
my @timed_msgs = $bus->fetch(key1, key2, key3);
$bus->store(key, value, time, 30);

# Atomic updating of cache content; $_ is stored back on the
# end of the callback.
my $rv = $bus->modify(key => sub { delete $_->{foo} });

# Shorthand for $bus->modify(key => sub { $_ = val });
$bus->modify(key => val);

# Shorthand for $bus->modify(key => sub { $_ });
$bus->modify(key);

This module provides a simple API for publishing messages to channels and for subscribing to them.

When a message is published on a channel, all subscribers currently in that channel will get it on their next get or get_all call.

Currently, it offers three backends: DBM_Deep for on-disk storage, Memcached for possibly multi-host storage, and PlainHash for single-process storage.

Please see the tests in t/ for this distribution, as well as "SYNOPSIS" above, for some usage examples; detailed documentation is not yet available.

IPC::SharedCache is a Perl module to manage a cache in SysV IPC shared memory.

SYNOPSIS

use IPC::SharedCache;

# the cache is accessed using a tied hash.
tie %cache, IPC::SharedCache, ipc_key => AKEY,
load_callback => &load,
validate_callback => &validate;

# get an item from the cache
$config_file = $cache{/some/path/to/some.config};

This module provides a shared memory cache accessed as a tied hash.
Shared memory is an area of memory that is available to all processes. It is accessed by choosing a key, the ipc_key arguement to tie. Every process that accesses shared memory with the same key gets access to the same region of memory. In some ways it resembles a file system, but it is not hierarchical and it is resident in memory. This makes it harder to use than a filesystem but much faster. The data in shared memory persists until the machine is rebooted or it is explicitely deleted.

This module attempts to make shared memory easy to use for one specific application - a shared memory cache. For other uses of shared memory see the documentation to the excelent module I use, IPC::ShareLite (IPC::ShareLite).
A cache is a place where processes can store the results of their computations for use at a later time, possibly by other instances of the application. A good example of the use of a cache is a web server.

When a web server receieves a request for an html page it goes to the file system to read it. This is pretty slow, so the web server will probably save the file in memory and use the in memory copy the next time a request for that file comes in, as long as the file hasnt changed on disk.

This certainly speeds things up but web servers have to serve multiple clients at once, and that means multiple copies of the in-memory data. If the web server uses a shared memory cache, like the one this module provides, then all the servers can use the same cache and much less memory is consumed.

This module handles all shared memory interaction using the IPC::ShareLite module (version 0.06 and higher) and all data serialization using Storable. See IPC::ShareLite and Storable for details.

mod_example_ipc is an Apache module that showcases the use in an Apache 2.0 module of the Shared Memory and Mutex routines found in the Apache Portable Runtime. The module itself does nothing useful.

Installation:

There are two ways to install mod_example_ipc in your server: apxs and the build system integration using config.m4. Using apxs is the easiest. It requires perl to run the apxs script, and the same C compiler that you built Apache with. Simply run

$ /path/to/apache2/bin/apxs -c -i mod_example_ipc.c

from the module source directory. This compiles the source as a shared module and installs it under /path/to/apache2/modules.

To integrate the module, copy mod_example_ipc.c and config2.m4 to the modules/experimental directory under your Apache 2.0 source tree. Then run ./buildconf from the top of the source tree. You need to have GNU autoconf and libtool installed to do this. After this step, you can run configure and enable mod_example_ipc:

$ ./configure ... --enable-example_ipc ...

and build Apache as you normally would.

Once you build the module, you can activate it in the Apache configuration as follows:

# You only need this if you built the module as a shared library
LoadModule example_ipc_module modules/mod_example_ipc.so

< Location /example_ipc >
SetHandler example_ipc
< /Location >

Now, any call to http://yourserver/example_ipc will cause the modules handler to grab the lock, increment the shared memory counter and return a small HTML page. Run a benchmark tool with multiple parallel sessions (like ab which comes with Apache) against this URL to see the effect of the IPC.

PicoTK is a C GUI toolkit that requires only a minimum of memory resources. It readily works with the RTEMS real time kernel - its minimum complexity and OS independency makes a port to any operating system easy. It is not comparable featurewise with real full blown windowing toolkits like nanoX or Qt/Embedded, but serves the needs for simple memory mapped graphic presentation.
Main features:
- Draw graphical primitives: points, lines, texts (different fonts, fixed and proportionally spaced using any X-Windows font ), filled rectangles, pixmaps
- Driver is easily adaptable to "homebrew" embedded display hardware based on memory-mapped framebuffer
- Generic drivers for 1, 4 and 8 bit per pixel color depth. Readily supporting VGA mode 0x11 (640x480x2), VGA mode 0x13 (320x200x8) and the VESA linear frame buffer modes (480x640x8 to 1280x1024x8) on graphic cards, which support VBE2.0 or higher.
- Framebuffer emulator (fbe) for Linux using shared memory IPC. This is used for the development of the toolkit and can be used for the development of your application as well. That is you can have a simulation version of your application that run under Linux - and look at its emulated screen. Than you can cross-compile the same application for the target system.
- Tool "fontripper" for converting X11 fonts into picoTK fonts. Use "ppmripper" for converting ppm portable pixmaps into picoTK pixmaps. Fonts and Pixmaps are encoded into linkable binaries, i.e. the system will be compiled into a single binary and does not require to have a filesystem.
- Together with RTEMS (www.oarcorp.com) you can have a nice embedded system graphical output solely using GNU technology.
- Use Linux as a development host for cross-compiling and as an emulation environment.
- Allows easy adaption/porting to your favorite operating system or hardware architecture.
Enhancements:
- Extensions to demo application
- Updated HOWTO (currently only the ASCII version is included in the sources)
- Added support for VESA VBE2.0 flat linear frame buffer
- picoTermPrintf(): Added support for VT100/320 Escapes: Change color and move cursor.
- toolkit: Change graphics configuration by changing toolkit/Makefile

IPC is a program that calculates the isotopic distribution of a given chemical formula. It gives the rel. intensities and the propability of the masses belonging to a molecule ion, fragment or whatever is represented by the given chemical formula.
Furthernmore it can use GNUPlot to visualize the result. Only masses with a rel. Intensity bigger then 0.009% are shown. Additionaly ipc prints the overall number of peaks and the needed computation time.
The program uses an algorithm which computes the exact isotopic distribution. This leads to a large number of peaks which have very low rel. abundances. Even for a small molecule as Acetylsalicylic acid ( C9H8O4, Mr=180.15) there are 1350 peaks but only nine of them have a rel. abundance higher then 0.01%.
Enhancements:
- A complete list of elements and isotopes is now used.
- The list of elements is taken from the NIST.

Untie is a small tool used to create namespaces and lauch processes in them. It uses Linuxs virtualization features.
The project allows the user to call clone(2) with any flag as a parameter. Note that superuser privileges are needed to create namespaces.
Untie is a small tool used to create namespaces and lauch processes in them. It uses Linuxs virtualization features. Basically it allows to call clone(2) with any flag as parameter. Note that superuser privileges are needed to create namespaces.
Here is a sample usage with the mount namespace:
[root ~]# untie -h
untie 0.1
Usage: untie [OPTIONS]... [COMMAND]...
-h, --help Print help and exit
-V, --version Print version and exit
--mount New mount namespace (default=off)
--uname New uname (default=off)
--ipc New IPC context (default=off)
--mask=MASK Pass user defined flag
[root ~]# mkdir dir1 dir2
[root ~]# touch dir1/file1 dir2/file2
[root ~]# untie --mount
A new shell has been spawned by untie
[root ~]# mount --bind dir1 dir2
[root ~]# ls dir1 dir2
dir1:
file1
dir2:
file1
[root ~]# exit
Back to the original namespace
[root ~]# ls dir1 dir2
dir1:
file1
dir2:
file2
[root ~]#
In this "demo" a new mount namespace is created and a bind mount is made in this new namespace. This mount is invisible to other namespaces. Leaving the namespace destroys it and cancels the mount.
Enhancements:
- The possibility of running a program as a daemon, the setting of an alarm timer, the nice level setting, and changing the scheduling policy as well as its priority were added.