bench.pl

   1 #!/usr/local/bin/perl
   2
   3 use strict ;
   4 use warnings ;
   5
   6 use Template::Simple ;
   7 use Benchmark qw( timethese cmpthese ) ;
   8 use Data::Dumper ;
   9
  10 my @dims = @ARGV ? (shift, shift) : ( 3, 5) ;
  11
  12 my $data = generate_data( @dims ) ;
  13 #print Dumper $data ;
  14
  15 my $tmpl = Template::Simple->new() ;
  16
  17 my $template = <<TMPL ;
  18 Header
  19 Val 1: [%val_1%]
  20 [%START nest%]
  21         Level: [%level%]
  22 [%END nest%]
  23 [%START opt%]
  24         Optional Level: [%level%]
  25 [%END opt%]
  26 Val 2: [%val_2%]
  27 Footer
  28 TMPL
  29
  30 $tmpl->add_templates( { bench => $template } ) ;
  31
  32 my $x = <<XXX ;
  33 XXX
  34
  35 my $rendered = $tmpl->render( 'bench', $data ) ;
  36
  37 #$tmpl->compile( 'bench', $data ) ;
  38 #print $tmpl->get_source( 'bench' ) ;
  39 #my $comp_rendered = $tmpl->render( 'bench', $data ) ;
  40 #my $ok = $$rendered eq $$comp_rendered ;
  41
  42 my $joined = joined( $data ) ;
  43 my $appended = joined( $data ) ;
  44
  45 my $ok = $$rendered eq $$appended ;
  46
  47 print "OK [$ok]\n" ;
  48
  49 # print $$rendered ;
  50 # print "----\n" ;
  51 # print $$joined ;
  52 #print $$comp_rendered ;
  53
  54 cmpthese( shift || -2,
  55         {
  56                 render  => sub { my $x = $tmpl->render( 'bench', $data ) },
  57                 joined  => sub { my $x = joined( $data ) },
  58                 concat  => sub { my $x = concat( $data ) },
  59                 append  => sub { my $x = append( $data ) },
  60         }
  61 ) ;
  62
  63 exit ;
  64
  65 no warnings ;
  66
  67
  68 sub rendered {
  69
  70 }
  71
  72 sub joined {
  73
  74 no warnings ;
  75
  76         my( $data ) = @_ ;
  77
  78         my $out = do {
  79                 my $out ;
  80
  81                 my @data = $data ;
  82                 while( defined( my $data = shift @data ) ) {
  83
  84                         if ( ref $data eq 'ARRAY' ) {
  85                                 push @data, @{$data} ;
  86                                 next ;
  87                         }
  88
  89                         $out .= ref $data ne 'HASH' ? $data :
  90
  91                         join( '',
  92                         "Header\nVal 1: "
  93                         ,
  94                         $data->{val_1}
  95                         ,
  96                         "\n"
  97                         ,
  98                         do {
  99                                 my $data = $data->{nest} ;
 100                                 my $out ;
 101
 102                                 my @data = $data ;
 103                                 while( defined( my $data = shift @data ) ) {
 104
 105                                         if ( ref $data eq 'ARRAY' ) {
 106                                                 push @data, @{$data} ;
 107                                                 next ;
 108                                         }
 109
 110                                         $out .= ref $data ne 'HASH' ? $data :
 111                                         join( '',
 112                                         "\n\tLevel: "
 113                                         ,
 114                                         $data->{level}
 115                                         ,
 116                                         "\n" ) ;
 117                                 }
 118                                 $out ;
 119                         }
 120                         ,
 121                         "\n"
 122                         ,
 123                         do {
 124                                 my $data = $data->{opt} ;
 125                                 my $out ;
 126
 127                                 my @data = $data ;
 128                                 while( defined( my $data = shift @data ) ) {
 129
 130                                         if ( ref $data eq 'ARRAY' ) {
 131                                                 push @data, @{$data} ;
 132                                                 next ;
 133                                         }
 134
 135                                         $out .= ref $data ne 'HASH' ? $data :
 136                                         join( '',
 137                                         "\n\tOptional Level: "
 138                                         ,
 139                                         $data->{level}
 140                                         ,
 141                                         "\n" ) ;
 142                                 }
 143                                 $out ;
 144                         }
 145                         ,
 146                         "\nVal 2: "
 147                         ,
 148                         $data->{val_2}
 149                         ,
 150                         "\nFooter\n" ) ;
 151                 }
 152                 $out ;
 153         } ;
 154
 155         return \$out ;
 156 }
 157
 158
 159 sub append {
 160
 161 }
 162
 163
 164 sub concat {
 165
 166 no warnings ;
 167
 168         my( $data ) = @_ ;
 169
 170         my $out = do {
 171                 my $out ;
 172
 173                 my @data = $data ;
 174                 while( defined( my $data = shift @data ) ) {
 175
 176                         if ( ref $data eq 'ARRAY' ) {
 177                                 push @data, @{$data} ;
 178                                 next ;
 179                         }
 180
 181                         $out .= ref $data ne 'HASH' ? $data :
 182                         "Header\nVal 1: "
 183                         .
 184                         $data->{val_1}
 185                         .
 186                         "\n"
 187                         .
 188                         do {
 189                                 my $data = $data->{nest} ;
 190                                 my $out ;
 191
 192                                 my @data = $data ;
 193                                 while( defined( my $data = shift @data ) ) {
 194
 195                                         if ( ref $data eq 'ARRAY' ) {
 196                                                 push @data, @{$data} ;
 197                                                 next ;
 198                                         }
 199
 200                                         $out .= ref $data ne 'HASH' ? $data :
 201                                         "\n\tLevel: "
 202                                         .
 203                                         $data->{level}
 204                                         .
 205                                         "\n" ;
 206                                 }
 207                                 $out ;
 208                         }
 209                         .
 210                         "\n"
 211                         .
 212                         do {
 213                                 my $data = $data->{opt} ;
 214                                 my $out ;
 215
 216                                 my @data = $data ;
 217                                 while( defined( my $data = shift @data ) ) {
 218
 219                                         if ( ref $data eq 'ARRAY' ) {
 220                                                 push @data, @{$data} ;
 221                                                 next ;
 222                                         }
 223
 224                                         $out .= ref $data ne 'HASH' ? $data :
 225                                         "\n\tOptional Level: "
 226                                         .
 227                                         $data->{level}
 228                                         .
 229                                         "\n" ;
 230                                 }
 231                                 $out ;
 232                         }
 233                         .
 234                         "\nVal 2: "
 235                         .
 236                         $data->{val_2}
 237                         .
 238                         "\nFooter\n" ;
 239                 }
 240                 $out ;
 241         } ;
 242
 243         return \$out ;
 244 }
 245
 246 sub append {
 247
 248 no warnings ;
 249
 250         my( $data ) = @_ ;
 251
 252         my $out ;
 253
 254         my @data = $data ;
 255         while( defined( my $data = shift @data ) ) {
 256
 257                 if ( ref $data eq 'ARRAY' ) {
 258                         push @data, @{$data} ;
 259                         next ;
 260                 }
 261
 262                 $out .= ref $data ne 'HASH' ? $data :
 263                 "Header\nVal 1: "
 264                 .
 265                 $data->{val_1}
 266                 .
 267                 "\n" ;
 268
 269                 my @data = $data->{nest} ;
 270                 while( defined( my $data = shift @data ) ) {
 271
 272                         if ( ref $data eq 'ARRAY' ) {
 273                                 push @data, @{$data} ;
 274                                 next ;
 275                         }
 276
 277                         $out .= ref $data ne 'HASH' ? $data :
 278                         "\n\tLevel: "
 279                         .
 280                         $data->{level}
 281                         .
 282                         "\n" ;
 283                 }
 284
 285                 $out .=
 286                 "\n" ;
 287
 288                 my @data = $data->{opt} ;
 289                 while( defined( my $data = shift @data ) ) {
 290
 291                         if ( ref $data eq 'ARRAY' ) {
 292                                 push @data, @{$data} ;
 293                                 next ;
 294                         }
 295
 296                         $out .= ref $data ne 'HASH' ? $data :
 297                         "\n\tOptional Level: "
 298                         .
 299                         $data->{level}
 300                         .
 301                         "\n" ;
 302                 }
 303
 304                 $out .=
 305                 "\nVal 2: "
 306                 .
 307                 $data->{val_2}
 308                 .
 309                 "\nFooter\n" ;
 310         }
 311
 312         return \$out ;
 313 }
 314
 315
 316 sub generate_data {
 317
 318         my( $outer_size, $inner_size ) = @_ ;
 319
 320         my @outer_data ;
 321
 322         for my $outer ( 1 .. $outer_size ) {
 323
 324                 my @inner_data ;
 325
 326                 for my $inner ( 1 .. $inner_size ) {
 327
 328                         push @inner_data, {
 329
 330                                 val_1   => ($outer x 2),
 331                                 val_2   => ($inner x 3),
 332                                 nest    => {
 333                                         level => "$outer-$inner",
 334                                 },
 335                                 $inner % 2 ? () : (
 336
 337                                         opt     => {
 338                                                 level => "$outer-$inner",
 339                                         },
 340                                 ),
 341                         } ;
 342                 }
 343
 344                 push @outer_data, [@inner_data] ;
 345         }
 346
 347         return \@outer_data ;
 348 }