[ViewVC] Diff of: cvs/Faster/Faster.pm

Comparing Faster/Faster.pm (file contents):
Revision 1.27 by root, Sat Mar 11 23:06:59 2006 UTC vs.
Revision 1.33 by root, Mon Mar 13 17:10:32 2006 UTC

  perl -MFaster ...
 =head1 DESCRIPTION
-This module implements a very simple-minded JIT. It works by more or less
+This module implements a very simple-minded "JIT" (or actually AIT, ahead
-translating every function it sees into a C program, compiling it and then
+of time compiler). It works by more or less translating every function it
-replacing the function by the compiled code.
+sees into a C program, compiling it and then replacing the function by the
+compiled code.
 As a result, startup times are immense, as every function might lead to a
 full-blown compilation.
 The speed improvements are also not great, you can expect 20% or so on
-average, for code that runs very often.
+average, for code that runs very often. The reason for this is that data
+handling is mostly being done by the same old code, it just gets called
+a bit faster. Regexes and string operations won't get faster. Airhtmetic
+doresn't become any faster. Just the operands and other stuff is put on
+the stack faster, and the opcodes themselves have a bit less overhead.
 Faster is in the early stages of development. Due to its design its
 relatively safe to use (it will either work or simply slowdown the program
 immensely, but rarely cause bugs).
+More intelligent algorithms (loop optimisation, type inference) could
+improve that easily, but requires a much more elaborate presentation and
+optimiser than what is in place. There are no plans to improve Faster in
+this way, yet, but it would provide a reasonably good place to start.
 Usage is very easy, just C<use Faster> and every function called from then
 on will be compiled.
-Right now, Faster will leave lots of F<*.c>, F<*.o> and F<*.so> files in
+Right now, Faster can leave lots of F<*.c> and F<*.so> files in your
-F</tmp>, and it will even create those temporary files in an insecure
+F<$FASTER_CACHEDIR> (by default F<$HOME/.perl-faster-cache>), and it will
-manner, so watch out.
+even create those temporary files in an insecure manner, so watch out.
 =over 4
 =cut
 no warnings;
 use strict;
 use Config;
 use B ();
-#use Digest::MD5 ();
 use DynaLoader ();
 use Digest::MD5 ();
 use Storable ();
+use Fcntl ();
 BEGIN {
    our $VERSION = '0.01';
    require XSLoader;
    XSLoader::load __PACKAGE__, $VERSION;
 }
-my $CACHEDIR = $ENV{FASTER_CACHE} || do {
+my $CACHEDIR =
+   $ENV{FASTER_CACHE}
+   || (exists $ENV{HOME} && "$ENV{HOME}/.perl-faster-cache")
+   || do {
-   require File::Temp;
+      require File::Temp;
-   File::Temp::tempdir (CLEANUP => 1)
+      File::Temp::tempdir (CLEANUP => 1)
-};
+   };
 my $COMPILE = "$Config{cc} -c -I$Config{archlibexp}/CORE $Config{optimize} $Config{ccflags} $Config{cccdlflags}";
 my $LINK    = "$Config{ld} $Config{ldflags} $Config{lddlflags} $Config{ccdlflags}";
 my $LIBS    = "$Config{libs}";
 my $_o      = $Config{_o};
 # we don't need no steenking PIC on x86
 $COMPILE =~ s/-f(?:PIC|pic)//g
    if $Config{archname} =~ /^(i[3456]86)-/;
-my $opt_assert = $ENV{FASTER_DEBUG};
+my $opt_assert = $ENV{FASTER_DEBUG} > 1;
 my $verbose    = $ENV{FASTER_VERBOSE}+0;
+warn "Faster: CACHEDIR is $CACHEDIR\n" if $verbose > 2;
 our $source;
 our @ops;
 our $insn;
 # ops that do not need an ASYNC_CHECK
 my %f_noasync = map +($_ => undef), qw(
    mapstart grepstart match entereval
    enteriter entersub leaveloop
-   pushmark nextstate
+   pushmark nextstate caller
    const stub unstack
-   last next redo seq
+   last next redo goto seq
    padsv padav padhv padany
    aassign sassign orassign
    rv2av rv2cv rv2gv rv2hv refgen
    gv gvsv
    add subtract multiply divide
    complement cond_expr and or not
+   bit_and bit_or bit_xor
    defined
    method method_named bless
    preinc postinc predec postdec
    aelem aelemfast helem delete exists
-   pushre subst list join split concat
+   pushre subst list lslice join split concat
    length substr stringify ord
    push pop shift unshift
    eq ne gt lt ge le
    regcomp regcreset regcmaybe
 );
    out_next;
 }
 sub op_pushmark {
-   $source .= "  PUSHMARK (PL_stack_sp);\n";
+   $source .= "  faster_PUSHMARK (PL_stack_sp);\n";
    out_next;
 }
 if ($Config{useithreads} ne "define") {
    local %op_regcomp;
    my %opsseen;
    my @todo = $cv->START;
    my %op_target;
+   my $numpushmark;
    while (my $op = shift @todo) {
       for (; $$op; $op = $op->next) {
          last if $opsseen{$$op}++;
             push @op_loop, \@targ;
             push @todo, @targ;
             $op_target{$$_}++ for @targ;
          } elsif ($class eq "COP") {
             $insn->{bblock}++ if defined $op->label;
+         } else {
+            if ($name eq "pushmark") {
+               $numpushmark++;
+            }
          }
       }
    }
    $_->{bblock}++ for grep $op_target{${$_->{op}}}, @ops;
    local $source = <<EOF;
 OP *%%%FUNC%%% (pTHX)
 {
   register OP *nextop = (OP *)${$ops[0]->{op}}L;
 EOF
+   $source .= "  faster_PUSHMARK_PREALLOC ($numpushmark);\n"
+      if $numpushmark;
    while (@ops) {
       $insn = shift @ops;
       $op = $insn->{op};
 sub func2ptr {
    my (@func) = @_;
    #LOCK
+   mkdir $CACHEDIR, 0777;
+   sysopen my $meta_fh, "$CACHEDIR/meta", &Fcntl::O_RDWR | &Fcntl::O_CREAT, 0666
+      or die "$$CACHEDIR/meta: $!";
+   binmode $meta_fh, ":raw:perlio";
+   fcntl_lock fileno $meta_fh
+      or die "$CACHEDIR/meta: $!";
-   my $meta = eval { Storable::retrieve "$CACHEDIR/meta" } || { version => 1 };
+   my $meta = eval { Storable::fd_retrieve $meta_fh } || { version => 1 };
    for my $f (@func) {
       $f->{func} = "F" . Digest::MD5::md5_hex ($f->{source});
       $f->{so}   = $meta->{$f->{func}};
    }
 #include "EXTERN.h"
 #include "perl.h"
 #include "XSUB.h"
+#if 1
+# define faster_PUSHMARK_PREALLOC(count) while (PL_markstack_ptr + (count) >= PL_markstack_max) markstack_grow ()
+# define faster_PUSHMARK(p) *++PL_markstack_ptr = (p) - PL_stack_base
+#else
+# define faster_PUSHMARK_PREALLOC(count) 1
+# define faster_PUSHMARK(p) PUSHMARK(p)
+#endif
 #define RUNOPS_TILL(op)						\\
   while (nextop != (op))					\\
     {								\\
       PERL_ASYNC_CHECK ();					\\
       PL_op = nextop; nextop = (PL_op->op_ppaddr)(aTHX);	\\
          $meta->{$f->{func}} = $f->{so} = $stem;
       }
       close $fh;
       system "$COMPILE -o $stem$_o $stem.c";
-      #d#unlink "$stem.c";
+      unlink "$stem.c" unless $ENV{FASTER_DEBUG} > 0;
       system "$LINK -o $stem$_so $stem$_o $LIBS";
       unlink "$stem$_o";
    }
    for my $f (@func) {
       $f->{ptr} = DynaLoader::dl_find_symbol $so, $f->{func}
          or die "$f->{func} not found in $stem$_so: $!";
    }
+   seek $meta_fh, 0,  0 or die "$CACHEDIR/meta: $!";
-   Storable::nstore $meta, "$CACHEDIR/meta";
+   Storable::nstore_fd $meta, $meta_fh;
-   # UNLOCK
+   truncate $meta_fh, tell $meta_fh;
+   # UNLOCK (by closing $meta_fh)
 }
 my %ignore;
 sub entersub {
    warn "optimising ", $cv->STASH->NAME, "\n"
       if $verbose;
    eval {
       my @func;
+      push @func, {
+         cv     => $cv,
+         name   => "<>",
+         source => cv2c $cv,
+      };
       # always compile the whole stash
       my %stash = $cv->STASH->ARRAY;
       while (my ($k, $v) = each %stash) {
          $v->isa (B::GV::)
 =over 4
 =item FASTER_VERBOSE
 Faster will output more informational messages when set to values higher
-than C<0>. Currently, C<1> outputs which packages are being compiled.
+than C<0>. Currently, C<1> outputs which packages are being compiled, C<3>
+outputs the cache directory and C<10> outputs information on which perl
+function is compiled into which shared object.
 =item FASTER_DEBUG
 Add debugging code when set to values higher than C<0>. Currently, this
-adds 1-3 C<assert>'s per perl op, to ensure that opcode order and C
+adds 1-3 C<assert>'s per perl op (FASTER_DEBUG > 1), to ensure that opcode
-execution order are compatible.
+order and C execution order are compatible.
 =item FASTER_CACHE
-NOT YET IMPLEMENTED CORRECTLY, SHARING BEETWEEN INSTANCES IS IMPOSSIBLE
-Set a persistent cache directory that caches compiled code
+Set a persistent cache directory that caches compiled code fragments. The
-fragments. Normally, code compiled by Faster will be deleted immediately,
+default is C<$HOME/.perl-faster-cache> if C<HOME> is set and a temporary
-and every restart will recompile everything. Setting this variable to a
+directory otherwise.
-directory makes Faster cache the generated files for re-use.
-This directory will always grow in contents, so you might need to erase it
+This directory will always grow in size, so you might need to erase it
 from time to time.
 =back
 =head1 BUGS/LIMITATIONS

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing Faster/Faster.pm (file contents): Revision 1.27 by root, Sat Mar 11 23:06:59 2006 UTC vs. Revision 1.33 by root, Mon Mar 13 17:10:32 2006 UTC

Diff Legend

Comparing Faster/Faster.pm (file contents):
Revision 1.27 by root, Sat Mar 11 23:06:59 2006 UTC vs.
Revision 1.33 by root, Mon Mar 13 17:10:32 2006 UTC