Wenn schon dann richtig: ~~~perl use strict; use warnings; use Benchmark qw(cmpthese); use JSON; use IO::File; # data struct my $ds = { name => 'boo', nixdef => undef, addr => { addr_name => 'foo', addr_vname => 'bar' }, base => { base_addr => { base_addr_name => 'foo', base_addr_vname => 'bar', base_addr_undef => undef, base_addr_hash => { base_addr_hash_name => 'otto' }, }, }, #env => \%ENV }; my $freezer = sub{ my $fr = FreezeHash->new( file => 'd:/tmp/freeze.bin' ) or die $@; $fr->freeze( $ds ); $fr->write; my $res = $fr->thaw; }; my $json = sub{ my $js = JSON->new; my $FH = IO::File->new; $FH->open("d:/tmp/json.asc", O_CREAT|O_RDWR) or die $!; my $s = $js->encode($ds); $FH->truncate(0); $FH->seek(0,0); $FH->print($s); $FH->seek(0,0); read($FH, my $content, -s $FH); my $res = $js->decode( $content ); }; cmpthese(1000, { 'freezer' => $freezer, 'json' => $json }); Rate freezer json freezer 577/s -- -2% json 587/s 2% -- ~~~ Das ergibt quasi einen Gleichstand aber in keinster Weise das was Du hier versuchst der Welt beizubringen: Dass mein Algorithmus 10x langsamer sein soll ist eine glatte Lüge! Wobei hierzu aber auch anzumerken ist, dass mit meinem Algorithmus die Datenstrukur tatsächlich zweimal durchlaufen wird, einmal beim Linearisieren und ein zweites Mal beim eigentlichen Serialisieren. Das Benchmark Modul ist jedoch nicht das allein entscheidende Kriterium, entscheidend ist das Verhalten auf dem produktiven System und das hat infolge meines neuen Serializer einen kleinen aber deutlichen Performanceschub bekommen -- gegenüber `Storable::freeze+thaw` und das obwohl Letzerer in c implementiert ist. Im Übrigen ist JSON für meine Zwecke völlig indiskutabel. MfG PS: Wenn ich %ENV mit reinnehme siehts so aus: ~~~perl Rate json freezer json 108/s -- -43% freezer 189/s 75% -- ~~~ Also ist mein Serializer **doppelt so schnell** aber das schrieb ich ja gestern bereits.

Wenn schon dann richtig: ~~~perl use strict; use warnings; use Benchmark qw(cmpthese); use JSON; use IO::File; # data struct my $ds = { name => 'boo', nixdef => undef, addr => { addr_name => 'foo', addr_vname => 'bar' }, base => { base_addr => { base_addr_name => 'foo', base_addr_vname => 'bar', base_addr_undef => undef, base_addr_hash => { base_addr_hash_name => 'otto' }, }, }, #env => \%ENV }; my $freezer = sub{ my $fr = FreezeHash->new( file => 'd:/tmp/freeze.bin' ) or die $@; $fr->freeze( $ds ); $fr->write; my $res = $fr->thaw; }; my $json = sub{ my $js = JSON->new; my $FH = IO::File->new; $FH->open("d:/tmp/json.asc", O_CREAT|O_RDWR) or die $!; my $s = $js->encode($ds); $FH->truncate(0); $FH->seek(0,0); $FH->print($s); $FH->seek(0,0); read($FH, my $content, -s $FH); my $res = $js->decode( $content ); }; cmpthese(1000, { 'freezer' => $freezer, 'json' => $json }); Rate freezer json freezer 577/s -- -2% json 587/s 2% -- ~~~ Das ergibt quasi einen Gleichstand aber in keinster Weise das was Du hier versuchst der Welt beizubringen: Dass mein Algorithmus 10x langsamer sein soll ist eine glatte Lüge! Wobei hierzu aber auch anzumerken ist, dass mit meinem Algorithmus die Datenstrukur tatsächlich zweimal durchlaufen wird, einmal beim Linearisieren und ein zweites Mal beim eigentlichen Serialisieren. Das Benchmark Modul ist jedoch nicht das allein entscheidende Kriterium, entscheidend ist das Verhalten auf dem produktiven System und das hat infolge meines neuen Serializer einen kleinen aber deutlichen Performanceschub bekommen -- gegenüber `Storable::freeze+thaw` und das obwohl Letzerer in c implementiert ist. Im Übrigen ist JSON für meine Zwecke völlig indiskutabel. MfG PS: Wenn ich %ENV mit reinnehme siehts so aus: ~~~perl Rate json freezer json 108/s -- -43% freezer 189/s 75% -- ~~~

Wenn schon dann richtig: ~~~perl use strict; use warnings; use Benchmark qw(cmpthese); use JSON; use IO::File; # data struct my $ds = { name => 'boo', nixdef => undef, addr => { addr_name => 'foo', addr_vname => 'bar' }, base => { base_addr => { base_addr_name => 'foo', base_addr_vname => 'bar', base_addr_undef => undef, base_addr_hash => { base_addr_hash_name => 'otto' }, }, }, #env => \%ENV }; my $freezer = sub{ my $fr = FreezeHash->new( file => 'd:/tmp/freeze.bin' ) or die $@; $fr->freeze( $ds ); $fr->write; my $res = $fr->thaw; }; my $json = sub{ my $js = JSON->new; my $FH = IO::File->new; $FH->open("d:/tmp/json.asc", O_CREAT|O_RDWR) or die $!; my $s = $js->encode($ds); $FH->truncate(0); $FH->seek(0,0); $FH->print($s); $FH->seek(0,0); read($FH, my $content, -s $FH); my $res = $js->decode( $content ); }; cmpthese(1000, { 'freezer' => $freezer, 'json' => $json }); Rate freezer json freezer 577/s -- -2% json 587/s 2% -- ~~~ Das ergibt quasi einen Gleichstand aber in keinster Weise das was Du hier versuchst der Welt beizubringen: Dass mein Algorithmus 10x langsamer sein soll ist eine glatte Lüge! Wobei hierzu aber auch anzumerken ist, dass mit meinem Algorithmus die Datenstrukur tatsächlich zweimal durchlaufen wird, einmal beim Linearisieren und ein zweites Mal beim eigentlichen Serialisieren. Das Benchmark Modul ist jedoch nicht das allein entscheidende Kriterium, entscheidend ist das Verhalten auf dem produktiven System und das hat infolge meines neuen Serializer einen kleinen aber deutlichen Performanceschub bekommen -- gegenüber `Storable::freeze+thaw` und das obwohl Letzerer in c implementiert ist. Im Übrigen ist JSON für meine Zwecke völlig indiskutabel. MfG