Or communicate it thru Socket:

Client:
use Storable qw(freeze);
use IO::Socket;

use strict;
use warnings;

my $c = new IO::Socket::INET(Proto => "udp",
                                  PeerAddr => "localhost",
                                  PeerPort => 3000,
                                  Timeout => 1);

print "Connected\n";
my $h = {"key" => [1,2,3,4,5,6,7,8,9,10]};
my $arr_freezed = freeze($h);
$c->send($arr_freezed);
close $c;

Server:
use IO::Socket;
use Storable qw(thaw);
use Data::Dumper;

use strict;
use warnings;

my $server = new IO::Socket::INET(Timeout => 7200,
                                 Proto => "udp",
                                  LocalPort => 3000,
                                  LocalHost => "localhost");
print "Server is listening ...\n";
my $arr_freezed;
$server->recv($arr_freezed, 1000);
my $h = thaw($arr_freezed);
print Dumper($h);
close $server;
[download]

Modified above example a little bit, so now it sends a freezed object over:

blah.pm:

package blah;

sub new {
    $self = {};
    bless($self);
    return $self;
}

sub setA {
    my ($self, $a) = @_;
    $self->{"A"} = $a;
}

sub getA {
    my $self = shift;
    return $self->{"A"}
}

1;

s.pl:

use IO::Socket;
use blah;
use Storable qw(thaw);
use Data::Dumper;

use strict;
use warnings;

my $server = new IO::Socket::INET(Timeout => 7200,
                                 Proto => "udp",
                                  LocalPort => 3000,
                                  LocalHost => "localhost");
print "Server is listening ...\n";
my $blah_freezed;
$server->recv($blah_freezed, 1000);
my $blah = thaw($blah_freezed);
print $blah->getA();
close $server;

c.pl:

use Storable qw(freeze);
use blah;
use IO::Socket;

use strict;
use warnings;

my $c = new IO::Socket::INET(Proto => "udp",
                                  PeerAddr => "localhost",
                                  PeerPort => 3000,
                                  Timeout => 1);
print "Connected\n";
my $blah = blah->new();
$blah->setA(123);
my $blah_freezed = freeze($blah);
$c->send($blah_freezed);
close $c;
[download]

Cache::Memcached does exactly what I descibed above: it serializes objects using Storable and sends them to a server. If you don't need to share data across a cluster of machines, BerkeleyDB and Cache::FastMmap both offer better performance than Cache:Memcached.

Perrin's right, those are faster options than Cache::Memcached. It was just the first option that came to mind when I read the question.

Frank Wiles <frank@wiles.org>
http://www.wiles.org

Also, you might want to look at threading your application. It's basically multi-process, but data is shared by default, not unshared by default. Of course, there's a host of new problems that goes along with that, but if you want to ...

Another option is to use SOAP or XML-RPC or some other client/server option. I do that with XML-RPC and it works out really great.

mod_perl dooes not do something similar. There is no read/write sharing of data. Threads do not share objects either, although you can sort of work around this by blessing the data structures in every thread.