Data-StreamSerializer

 view release on metacpan or  search on metacpan

benchmark/vs_dumper.pl  view on Meta::CPAN

sub max(@);
sub sum(@);
sub avg(@);

$| = 1;
getopts 'hn:b:' => \my %opts or usage;
usage if $opts{h};
my $file = $ARGV[0] or usage;
die "File not found: $file\n" unless -f $file;
my $data = `cat $file`;
my $iterations = $opts{n} || 1000;
my $block_size = $opts{b} || 512;

printf "%s bytes were read\n", length $data;

print "First serializing by eval...";
my $object = eval $data;
die "Can't eval input data: $@" if $@;
print " done\n";

print "First serializing by Data::StreamSerializer... ";

benchmark/vs_dumper.pl  view on Meta::CPAN

}
my $dobject = eval $dsld;
die $dsld if $@;

die "Serialize error" unless compare_object $dobject, $object;
print "done\n";


my @dumper_time;
my $time = time;
printf "Starting %d iterations for Dumper... ", $iterations;

for (1 .. $iterations) {
    my $start_time = time;
    my $str = Dumper($object);
    push @dumper_time, time - $start_time;
}

my $dumper_time = time - $time;

printf "done (%2.3f seconds)\n", $dumper_time;


my @ss_time;
$time = time;
printf "Starting %d iterations for Data::StreamSerializer... ", $iterations;

my $counter = 0;

for (1 .. $iterations) {
    my $start_time = time;

    $sr = new Data::StreamSerializer($object);
    $sr->block_size($block_size);
    $counter++ while defined $sr->next;
    push @ss_time, time - $start_time;
}

my $ss_time = time - $time;

printf "done (%2.3f seconds)\n", $ss_time;


print  "\nDumper statistic:\n";
printf "\t%d iterations were done\n", $iterations;
printf "\tmaximum serialization time: %2.4f seconds\n", max(@dumper_time);
printf "\tminimum serialization time: %2.4f seconds\n", min(@dumper_time);
printf "\taverage serialization time: %2.4f seconds\n", avg(@dumper_time);

print  "\nData::StreamSerializer statistic:\n";
printf "\t%d iterations were done\n", $iterations;
printf "\t%d SUBiterations were done\n", $counter;
printf "\tmaximum serialization time: %2.4f seconds\n", max(@ss_time);
printf "\tminimum serialization time: %2.4f seconds\n", min(@ss_time);
printf "\taverage serialization time: %2.4f seconds\n", avg(@ss_time);
printf "\taverage subiteration  time: %2.5f seconds\n", $ss_time / $counter;

sub compare_object($$)
{
    my ($o1, $o2) = @_;
    return 0 unless ref($o1) eq ref $o2;
    return $o1 eq $o2 unless ref $o1;                        # SCALAR

benchmark/vs_dumper.pl  view on Meta::CPAN

sub usage()
{
    print <<eof;

    usage: perl $0 [OPTIONS] test_file

    OPTIONS:

        -h              - this helpscreen
        -n count        - iterations (default 1000)
        -b count        - bytes in one subiteration (default 512),
                            see perldoc Data::StreamDeserializer
                                hint: block_size
eof
    exit 0;
}

sub min(@) {
    my $min = shift;
    for (@_) {

lib/Data/StreamSerializer.pm  view on Meta::CPAN

  }

=head1 DESCRIPTION

Sometimes You need to serialize a lot of data. If You use 'Dumper'
it can take You for much time. If Your code is executed in event
machine it can be inadmissible. So using the module You can serialize
Your data progressively and do something between serialization itearions.

This module works slower than L<Data::Dumper>, but it can serialize object
progressively and You can do something else between serialization iterations.

=head2 Recognized types.

=head3 HASH

=head3 ARRAY

=head3 REF

=head3 Regexp

lib/Data/StreamSerializer.pm  view on Meta::CPAN

test arrays in this directory.

Here are a few test results of my system.

=head2 Array which contains 100 hashes:

    $ perl benchmark/vs_dumper.pl -n 1000 -b 512 benchmark/tests/01_100x10
    38296 bytes were read
    First serializing by eval... done
    First serializing by Data::StreamSerializer... done
    Starting 1000 iterations for Dumper... done (40.376 seconds)
    Starting 1000 iterations for Data::StreamSerializer... done (137.960 seconds)

    Dumper statistic:
            1000 iterations were done
            maximum serialization time: 0.0867 seconds
            minimum serialization time: 0.0396 seconds
            average serialization time: 0.0404 seconds

    Data::StreamSerializer statistic:
            1000 iterations were done
            58000 SUBiterations were done
            maximum serialization time: 0.1585 seconds
            minimum serialization time: 0.1356 seconds
            average serialization time: 0.1380 seconds
            average subiteration  time: 0.00238 seconds

=head2 Array which contains 1000 hashes:

    $  perl benchmark/vs_dumper.pl -n 1000 -b 512 benchmark/tests/02_1000x10
    355623 bytes were read
    First serializing by eval... done
    First serializing by Data::StreamSerializer... done
    Starting 1000 iterations for Dumper... done (405.334 seconds)
    Starting 1000 iterations for Data::StreamSerializer... done (1407.899 seconds)

    Dumper statistic:
            1000 iterations were done
            maximum serialization time: 0.4564 seconds
            minimum serialization time: 0.4018 seconds
            average serialization time: 0.4053 seconds

    Data::StreamSerializer statistic:
            1000 iterations were done
            520000 SUBiterations were done
            maximum serialization time: 2.0050 seconds
            minimum serialization time: 1.3862 seconds
            average serialization time: 1.4079 seconds
            average subiteration  time: 0.00271 seconds


You can see that in any cases one iteration gets the same time.

=head1 AUTHOR

t/05_memory_leak.t  view on Meta::CPAN

    } elsif($count++ < 100) {
        $size_end = Data::StreamSerializer::_memory_size;
        last unless $size_end <= $size;
    } else {
        last;
    }
}

my $leak = $size_end - $size;
ok $size_end <= $size, "Check memory leak ($leak bytes)";
note "$i iterations were done, $len bytes were produced";


if (Data::StreamSerializer::_memory_size > $size_start) {
    ok 1, "Check memory checker";
} elsif (hostname =~ /^(apache|marish|nbw)$/) {
    fail "Check memory checker";
} else {
    ok 1, "Check memory checker: Failed"; # BSD and darwin
    diag "sbrk returns value: " . Data::StreamSerializer::_memory_size;
}