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