Use Storable freeze/thaw to do the serialisation and then Win32::API::Prototype to access the APIs for one of the 9 forms of IPC available.

Win32::Clipboard is one of the easiest (and fastest) IPC mechanisms, though with the binary data produced by Storable, you will probably have to pass the data as CF_BITMAP to fake out the formatting.

The suggestion to use the clipboard as an IPC method is a pretty sad commentary. The clipboard is a user interface concept, not another anonymous pipe you can open between two processes.

Scenario: The user starts your scripts, then goes on to do something entirely different, and on the first Ctrl+C, hoses your scripts. Of course, it's not obvious that the scripts have failed, and it probably won't be obvious why they failed. Unless the user does a Ctrl+V at some point, and chunks of perl object data are spewed into their document.

From an architectural point of view, it's merely a lack of thought about the data flow: other processes may poison or be poisoned by your use of that particular IPC channel. From a user design point of view, it's damaging the user interaction model by subverting the user's metaphor to grasp of what's going on in the computer.

Poking stuff into the clipboard is pretty cool: when the user directs the activity. Grabbing stuff from the clipboard is pretty cool: when the user directs the activity. The APIs were made quick and simple, to facilitate application designers who wanted to make their apps quick and simple.

--
[ e d @ h a l l e y . c c ]

Then the answer is to use one of the other 8 IPC channels.

---

Examine what is said, not who speaks.

"Efficiency is intelligent laziness." -David Dunham
"Think for yourself!" - Abigail
Timing (and a little luck) are everything!

Win32::Clipboard can only write text to the clipboard (doesn't rule out Data::Dumper or MIME::Base64, although the concept still sounds messy). Will investigate Win32::API::Prototype - any examples? It's been a while since i played with the win32 api...

- ><iper

use japh; print;
[download]

Sounds good, although Cache::SharedMemoryCache requires IPC::ShareLite which requires ... you guessed it!

- ><iper

use japh; print;
[download]

The IPC::Sharable module basically serializes the shared variable, transports it, then re-creates it (with fancy locking and 2-way Ties). I don't see any way to avoid the serialization/re-assembly.

You could potentially re-design your app such that instead of exposing the data, you expose methods to manipulate the data. Then your problem comes down to (relatively) simple RPC.

Does Data::Dumper or the YAML module count as "manual serialization"? They are pretty painless to me, and work great for this sort of thing.

The sentence you quoted actually meant to emphasise the latter half, not the former.

The data is actually serialisable using the methods you mention, the issue is transferring that data between processes 'asynchronously, without blocking' (for lack of a better way to describe it - i’ve just added a background <readmore> to the original post).

- ><iper

use japh; print;
[download]

use strict;
use warnings;
use Win32::MMF;
use Data::Dumper;
use CGI;

# fork a process
defined(my $pid = fork()) or die "Can not fork a child process!";

if ($pid) {
    my $ns1 = Win32::MMF->new ( -namespace => "My.data1" );
    my $ns2 = Win32::MMF->new ( -namespace => "My.data2" );

    my $cgi = new CGI;
    my $data = {a=>[1,2,3], b=>4, c=>"A\0B\0C\0"};

    $ns1->write($data);  # automatic locking by default
    $ns2->write($cgi);

    print "--- Sent ---\n";
    print Dumper($data), "\n";
    print Dumper($cgi), "\n";

    sleep(1);

} else {

    # in child
    sleep(1);
    my $ns1 = Win32::MMF->new ( -namespace => "My.data1",
                                -reuse => 1 )
            or die "Namespace does not exist!";

    my $ns2 = Win32::MMF->new ( -namespace => "My.data2",
                                -reuse => 1 )
            or die "Namespace does not exist!";

    my $data = $ns1->read();
    my $cgi = $ns2->read();

    print "--- Received ---\n";
    print Dumper($data), "\n";
    print Dumper($cgi), "\n";
    
    print "--- Use Received Object ---\n";
    # use the object from another process :-)
    print $cgi->header(),
          $cgi->start_html(), "\n",
          $cgi->end_html(), "\n";
}
[download]

# turn off built-in auto-locking
my $ns = Win32::MMF->new ( -namespace => "My.data1",
                           -size => 2*1024*1024,
                           -autolock => 0 );

- use Win32::Semaphore module
- Create a read and a write semaphore.
- In server:
    wait($read_semaphore);
    $xml = $ns->read();
    release($write_semaphore);
- In client:
    wait($write_semaphore);
    $ns->write($xml);
    release($read_semaphore);
[download]