Now is a good time to review perlipc.

The only way to modify values within a Perl process is to do it within that one Perl process. Either you use threads, or you set up an API to do that modification for you.

There are other approaches, like shared memory or debuggers, but until you've understood the limitations of IPC, it doesn't make sense to bring out the heavy guns.

That's exactly the point I was glossing over when I recommended a dispatch table at the receiving end, and a JSON producer at the sending end..

The OP doesn't have to use JSON, but it's convenient, and well understood. The point is that the OP cannot simply pass references around, he has to pass plain old data. So a JSON packet that looks something like this:

'{"action":"tupitar","params":["this","that","other"]}'
[download]

...would be easy to interpret at the receiving end. And the dispatch table avoids the mess of going directly to symbolic subrefs.

Things get ugly if he's got to send huge amounts of data to the subroutines. But even there, an additional layer of indirection can help; instead of sending data as a parameter, send a link to the data; a filename, a row ID from a database, or whatever. But sending a Perl reference is an indirection that will lose its magic as it gets passed around. ...just like you wouldn't pass a C pointer to local data from one process to another.




Dave

The subroutines that I am trying to call from one process to the other do indeed pass a bunch of data, some of which is by reference. I understand that this can't be done due to the memory space separation of the two processes. I also understand that I would need to
1. serialize the parameters on the caller side, flattening out any references
2. deserialize the parameters on the receiving side into the same prototype
3. actual function executes with the deserialized parameters, potentially modifying the by reference parameters
4. then serialize the modified parameters again to capture the modified values
5. deserialize the parameters on the original caller side to update the parameter values
I've put together a very simple example of the first 3 steps where I use Data::Dump for my (de)serialization. However, I am running into an issue.

use warnings;
use strict;
use Data::Dump qw(dump);

my $a = "one";
my $b = "two";
my $c = \$b;
my @d = ($a, $b, $c);

my $str = dump(@d); # ("one", "two", \"two")

my @newD = eval $str;
$newD[0] = "A";
$newD[1] = "B";
${$newD[2]} = "C";
[download]

The problem happens on the last line which errors out with Modification of a read-only value. Why is this the case?