in reply to Pre-grow a string

The somewhat sucky way is: 

my $string= ' ' x 2**19;
$string= '';

[download]

It'd be cool if the following worked but it doesn't: 

length( $string )= 2**19; # Doesn't work

[download]

Or you can get creative: 

open NUL, "<", File::Spec->devnull();
sysread( NUL, $string, 2**19-length($string), length($string) );
close NUL;

[download]

Testing in my environment shows that you can even get away with: 

sysread( STDOUT, $string, 2**19 );

[download]

which leaves $string's current value unchanged while extending the storage allocated to it. Of course, there is a risk of running into a system where STDOUT is open for both read and write access. I wonder if there is another Perl built-in that reads into a buffer that can be used more conveniently.

Update: Testing also shows the following works well: 

sub grow
{
    sysread( DATA, $_[0], $_[1] );
}
__DATA__

[download]

- tye        

Replies are listed 'Best First'.
Re^2: Pre-grow a string (MTOW)
by almut (Canon) on Aug 02, 2007 at 17:36 UTC 
    my $string= ' ' x 2**19;
$string= '';

    [download]

    I dimly remember having seen this being suggested somewhere else... However it doesn't actually seem to result in speeding up things (if that's the idea behind avoiding reallocations). On my machine and version of Perl it's in fact marginally slower. 

    use Benchmark "cmpthese";

sub pre {
    my $str = " " x 2**19;
    $str = "";
    $str .= "aaaa" for 1..2**17;
}

sub std {
    my $str = "";
    $str .= "aaaa" for 1..2**17;
}

cmpthese( -1, {
    'pre' => 'pre()',
    'std' => 'std()'
});

    [download]

    Results: 

          Rate pre std
pre 43.6/s  -- -7%
std 46.7/s  7%  --

    [download]
[reply]
[d/l]
[select]

      Yes, what is somewhat sucky about it is that it allocates the space twice, initializes one copy then copies it (then frees one); though I haven't checked this assumption of mine. Which means iterating over the requested size twice. Pre-sizing avoids reallocating. Reallocating is done exponentially (doubling the size each time) and so averages out to copying the maximum size about twice (unless you get lucky and reallocate in-place, rather unlikely in my experience). So it isn't surprising that the performance difference is minimal between those two choices.

      But note that pre-allocating will likely reduce a bit of memory fragmentation by avoiding leaving those power-of-two-sized buffers of now-free space in its wake.

      - tye        

[reply]

In Section Seekers of Perl Wisdom