"Are there other ways to avoid string copies besides using references?"

There are the ugly ones, like storing the string in a global variable and not passing it around at all; just acting upon the global instance of it.

The reference approach is probably a better solution.

"Does it make sense to submit enhancement requests to these standard modules to have the possibility to get the result by reference?"

It makes more sense to submit patches that implement your request in a way that doesn't forcibly export anything additional, and doesn't cause the modules to fail their existing test suite. Additionally, you would want to include a full set of tests for the patch you submitted, along with a POD patch. In other words, you're providing the added functionality, not wrecking code that uses the module (not exporting anything new by default), not wrecking the module itself (it still passes its test suite), and providing your own proof that your patches work, and full documentation.

If that doesn't get anyone's attention, subclass the module in question, or for non-OO modules, write a wrapper module that adds your functionality while passing through all the old functionality too. Upload to CPAN.

Your tests are bad. The only copying is happening outside of the functions you are testing. Specifically, they occurring when you assign the string to $tmp in $tmp = out1() and in $tmp = fun1($str).

Right now, you have

my $str = out1();
my $ref = out2();
my $str = fun1($str);
my $ref = fun2(\$str);
[download]

If you wanted to fix the test, you'd use

my $str = out1();
my $str = ${ out2() };
my $str = fun1($str);
my $str = ${ fun2(\$str) };
[download]

or

my $ref = \out1();
my $ref = out2();
my $ref = \fun1($str);
my $ref = fun2(\$str);
[download]

As you can see, passing a string by reference seems to slow down (in2 is slower than in1)

Perl always passes by reference. in2 passes *a* reference (by reference). This reference has to be created, dereferenced and destroyed. This is all work that in2 does on top of what in1 does, so of course it will be slower.

Update: The last paragraph was saying "out1" and "out2" when I meant "in1" and "in2". Fixed.

Thanks for your comments but further tests do show a difference. Here is what I've used:

    "out1ax$len" => sub { for (1 .. COUNT) { $tmp = out1() } },
    "out1bx$len" => sub { for (1 .. COUNT) { $tmp = \out1() } },
    "out2ax$len" => sub { for (1 .. COUNT) { $tmp = ${ out2() } } },
    "out2bx$len" => sub { for (1 .. COUNT) { $tmp = out2() } },
[download]

And here is what it gives:

 out1ax100: 44 wallclock secs (43.20 usr +  0.01 sys = 43.21 CPU) @  0.23/s (n=10)
 out1bx100: 42 wallclock secs (42.03 usr +  0.01 sys = 42.04 CPU) @  0.24/s (n=10)
 out2ax100: 41 wallclock secs (40.59 usr +  0.00 sys = 40.59 CPU) @  0.25/s (n=10)
 out2bx100:  2 wallclock secs ( 1.61 usr +  0.00 sys =  1.61 CPU) @  6.21/s (n=10)

So out2b (real return by reference) is much faster than out1b (take the reference of the result). So string copy does take place when Perl handles the return value of the function. Or did I miss something?

Perfect. This is what I was expecting to see. Yes, non-lvalue functions copy their result.

$ perl -MDevel::Peek -e'Dump sub { my $x = "abc"; Dump $x; $x }->()'
SV = PV(0x8bfe730) at 0x8c1b2b0
  REFCNT = 1
  FLAGS = (PADMY,POK,pPOK)
  PV = 0x8c16088 "abc"\0           <-- Note the address
  CUR = 3
  LEN = 12
SV = PV(0x8bfe780) at 0x8c00768
  REFCNT = 1
  FLAGS = (TEMP,POK,pPOK)
  PV = 0x8c1e2e0 "abc"\0           <-- A copy
  CUR = 3
  LEN = 12
[download]

That's why returning a string ($ref = \out1()) is as expensive as assigning a string ($str = ${ out2() }).

So why is both returning a string and assigning it not ($str = out1()) twice as expensive?

When assigning a string slated to be destroyed* such as the automatic copy of a return value, the assignment will steal the buffer instead of copying it.

* — (FLAGS & TEMP) && REFCNT == 1, I think.

Are there other ways to avoid string copies besides using references?

No. Well there are aliases ( ex for my $alias ( $foo, @_ ){ } ) but they're essentially references

Does it make sense to submit enhancement requests to these standard modules to have the possibility to get the result by reference?

Sure, as long as you don't offer your benchmark with the suggestion, because it is not Coping with Scoping