ch17_01.htm

用perl编写CGI的好书。本书从解释CGI和底层HTTP协议如何工作开始

<blockquote><pre class="code">...
while (&lt;FILE&gt;) {
    chomp;
    $count++;  
    $some_large_array[$count] .= int ($_);
}
...
 
@some_large_array = (  );     ## Good
undef @some_large_array;    ## Not so good</pre></blockquote>


<p>If you undefine <tt class="literal">@some_large_array</tt> to clear it out,
Perl will deallocate the space containing the data. And when you
populate the array with new data, Perl will have to reallocate the
necessary space again. This can slow things down.</p>
</div>




<a name="ch17-6-fm2xml" /><div class="sect2">
<h3 class="sect2">17.1.6. SelfLoader</h3>


<p>The SelfLoader module <a name="INDEX-3229" /> <a name="INDEX-3230" /> <a name="INDEX-3231" />
<a name="INDEX-3232" />allows
you to hide <a name="INDEX-3233" />
<a name="INDEX-3234" />functions and subroutines,
so the Perl interpreter does not compile them into internal opcodes
when it loads up your application, but compiles them only where there
is a need to do so. This can yield great savings, especially if your
program is quite large and contains many subroutines that may not all
be run for any given request.</p>


<p>Let's look at how to convert your program to use self-loading,
and then we can look at the internals of how it works. Here's a
simple framework:</p>


<blockquote><pre class="code">use SelfLoader;

## step 1: subroutine stubs

sub one;
sub two;
...

## your main body of code
...

## step 2: necessary/required subroutines

sub one {
    ...
}

__DATA__

## step 3: all other subroutines

sub two {
    ...
}
...
__END__</pre></blockquote>


<p>It's a three-step process:</p>


<ol><li><p>Create stubs for all the functions and subroutines in your
application.</p></li><li><p>Determine which functions are used often enough that they should be
loaded by default.</p></li><li><p>Take the rest of your functions and move them between the <tt class="literal">__DATA__</tt> and <tt class="literal">__END__</tt> tokens.</p></li></ol>
<p>Congratulations, Perl will now load these functions only on demand!</p>


<p>Now, how does it actually work? The <tt class="literal">__DATA__</tt>
token has a special significance to Perl; everything after the token
is available for reading through the DATA filehandle. When Perl
reaches the <tt class="literal">__DATA__</tt> token, it stops compiling,
and all the subroutines defined after the token do not exist, as far
as Perl is concerned.</p>


<p>When you call an unavailable function, SelfLoader reads in all the
subroutines from the DATA filehandle, and caches them in a hash. This
is a one-time process, and is performed the first time you call an
unavailable function. It then checks to see if the specified function
exists, and if so, will <tt class="function">eval</tt> it within the
caller's namespace. As a result, that function now exists in
the caller's namespace, and any subsequent calls to that
function are handled via symbol table lookups.</p>


<p>The costs of this process are the one time reading and parsing of the
self-loaded subroutines, and a <tt class="function">eval</tt> for each
function that is invoked. Despite this overhead, the performance of
large programs with many functions and subroutines can improve
dramatically.</p>
</div>




<a name="ch17-7-fm2xml" /><div class="sect2">
<h3 class="sect2">17.1.7. autouse</h3>


<p>If you use many <a name="INDEX-3235" />
<a name="INDEX-3236" />
<a name="INDEX-3237" />
<a name="INDEX-3238" />external
modules in your application, you may consider using the
<em class="emphasis">autouse</em> feature to delay loading them until a
specific function from a module is used:</p>


<blockquote><pre class="code">use autouse DB_File;</pre></blockquote>


<p>You have to be very careful when using this feature, since a portion
of the chain of execution will shift from compile time to runtime.
Also, if a module needs to execute a particular sequence of steps
early on in the compile phase, using <em class="emphasis">autouse</em> can
potentially break your applications.</p>


<p>If the modules you need behave as expected, using
<em class="emphasis">autouse</em> for modules can yield a big savings when
it comes time to "load" your application.</p>
</div>




<a name="ch17-8-fm2xml" /><div class="sect2">
<h3 class="sect2">17.1.8. Avoid the Shell</h3>


<p>Avoid accessing the <a name="INDEX-3239" />
<a name="INDEX-3240" />
<a name="INDEX-3241" />shell from your
application, unless you have no other choice. Perl has equivalent
functions to many Unix commands. Whenever possible, use the functions
to avoid the shell overhead. For example, use the
<em class="emphasis">unlink</em> function, instead of executing the
external <tt class="command">rm</tt> command:</p>


<blockquote><pre class="code">system( "/bin/rm", $file );                     ## External command
unlink $file or die "Cannot remove $file: $!";  ## Internal function</pre></blockquote>


<p>It as also much safer to avoid the shell, as we saw in <a href="ch08_01.htm">Chapter 8, "Security"</a>. However, there are some instances when you
may get better performance using some standard external programs than
you can get in Perl. If you need to find all occurrences of a certain
term in a very large text file, it may be faster to use
<tt class="command">grep</tt>
<a name="INDEX-3242" />
<a name="INDEX-3243" /> than performing the same task in Perl:</p>


<blockquote><pre class="code">system( "/bin/grep", $expr, $file );</pre></blockquote>


<p>Note however, that the circumstances under which you might need to do
this are rare. First, Perl must do a lot of extra work to invoke a
system call, so the performance difference gained by an external
command is seldom worth the overhead. Second, if you only were
interested in the first match and not all the matches, then Perl
gains speed because your script can exit the loop as soon as it finds
a match:</p>


<blockquote><pre class="code">my $match;
open FILE, $file or die "Could not open $file: $!";
while (&lt;FILE&gt;) {
    chomp;
    if ( /$expr/ ) {
        $match = $_;
        last;
    }
}</pre></blockquote>


<p><tt class="command">grep</tt> will always read the entire file. Third, if
you find yourself needing to resort to using <tt class="command">grep</tt>
to handle text files, it likely means that the problem isn't so
much with Perl as with the structure of your data. You should
probably consider a different data format, such as a DBM file or a
RDBMS.</p>


<p>Also avoid using the <a name="INDEX-3244" />
<a name="INDEX-3245" />
<a name="INDEX-3246" />glob
<tt class="literal">&lt;*&gt;</tt> notation to get a list of files in a
particular directory. Perl must invoke a subshell to expand this. In
addition to this being inefficient, it can also be erroneous; certain
shells have an internal glob limit, and will return files only up to
that limit. Note that Perl 5.6, when released, will solve these
limitations by handling globs internally.</p>


<p>Instead, use Perl's <tt class="function">opendir</tt>,
<tt class="function">readdir,</tt> and <tt class="function">closedir</tt>
functions. Here is an example:</p>


<blockquote><pre class="code">@files = &lt;/usr/local/apache/htdocs/*.html&gt;;      ## Uses the shell
....
$directory = "/usr/local/apache/htdocs";         ## A better solution
if (opendir (HTDOCS, $directory)) {
    while ($file = readdir (HTDOCS)) {
        push (@files, "$directory/$file") if ($file =~ /\.html$/);
    }
}</pre></blockquote>
</div>




<a name="ch17-9-fm2xml" /><div class="sect2">
<h3 class="sect2">17.1.9. Find Existing Solutions for Your Problems</h3>


<p>Chances are, if you find <a name="INDEX-3247" /> <a name="INDEX-3248" /> <a name="INDEX-3249" />yourself stuck with a
problem, someone else has encountered it elsewhere and has spent a
lot of time developing a solution. And thanks to the spirit of Perl,
you can likely borrow it. Throughout this book, we have referred to
many modules that are available on CPAN. There are countless more.
Take the time to browse through CPAN regularly to see what is
available there.</p>


<p>You should also check out the Perl
newsgroups. <em class="emphasis">news:comp.lang.perl.modules</em> is a good
place to go to check in with new module announcements or to get help
with particular modules. <em class="emphasis">news:comp.lang.perl</em> and
<em class="emphasis">news:comp.lang.perl.misc</em> are more general
newsgroups.</p>


<p>Finally, there are many very good books available that discuss
algorithms or useful tricks and tips. The <em class="citetitle">Perl
Cookbook</em> by Tom Christiansen and Nathan Torkington and
<em class="citetitle">Mastering Algorithms with Perl</em> by Jon Orwant,
Jarkko Hietaniemi, and John Macdonald are full of gems specifically
for Perl. Of course, don't overlook books whose focus is not
Perl. <em class="citetitle">Programming Pearls</em> by John Bentley,
<em class="citetitle">The C Programming Language</em> by Brian Kernighan
and Dennis Ritchie, and <em class="citetitle">Code Complete</em> by Steve
McConnell are also all excellent references.</p>
</div>




<a name="ch17-10-fm2xml" /><div class="sect2">
<h3 class="sect2">17.1.10. Regular Expressions </h3>


<p>Regular <a name="INDEX-3250" /> <a name="INDEX-3251" /> <a name="INDEX-3252" />expressions are an integral part of
Perl, and we use them in many CGI applications. There are many
different ways that we can improve the performance of regular
expressions.</p>


<p>First, avoid using <tt class="literal">$&amp;</tt>, <tt class="literal">$`</tt>,
and <tt class="literal">$'</tt>. If Perl spots one of these variables in
your application, or in a module that you imported, it will make a
copy of the search string for possible future reference. This is
highly inefficient, and can really bog down your application. You can
use the <a name="INDEX-3253" />
<a name="INDEX-3254" />
<a name="INDEX-3255" />Devel::SawAmpersand module, available
on CPAN, to check for these variables.</p>


<p>Second, the following type of regular expressions are highly
inefficient:</p>


<blockquote><pre class="code">while (&lt;FILE&gt;) {
    next if (/^(?:select|update|drop|insert|alter)\b/);     
    ...  
}</pre></blockquote>


<p>Instead, use the following syntax:</p>


<blockquote><pre class="code">while (&lt;FILE&gt;) {
    next if (/^select/);
    next if (/^update/);
    ...
}</pre></blockquote>


<p>Or, consider building a runtime compile pattern if you do not know
what you are searching against at compile time:</p>


<blockquote><pre class="code">@keywords = qw (select update drop insert);
$code = "while (&lt;FILE&gt;) {\n";

foreach $keyword (@keywords) {
    $code .= "next if (/^$keyword/);\n";
}

$code .= "}\n";
eval $code;</pre></blockquote>


<p>This will build a code snippet that is identical to the one shown
above, and evaluate it on the fly. Of course, you will incur an
overhead for using <em class="emphasis">eval</em>, but you will have to
weigh that against the savings you will gain.</p>


<p>Third, consider using <em class="emphasis">o</em> modifier in expressions
to compile the pattern only once. Take a look at this example:</p>


<blockquote><pre class="code">@matches = (  );
...
while (&lt;FILE&gt;) {
    push @matches, $_ if /$query/i;
}
...</pre></blockquote>


<p>Code like this is typically used to search for a string in a file.
Unfortunately, this code will execute very slowly, because Perl has
to compile the pattern each time through the loop. However, you can
use the <em class="emphasis">o</em> modifier to ask Perl to compile the
regex just once:</p>


<blockquote><pre class="code">push @matches, $_ if /$query/io;</pre></blockquote>


<p>If the value of <tt class="literal">$query</tt> changes in your script,
this won't work, since Perl will use the first compiled value.
The compiled regex features introduced in Perl 5.005 address this;
refer to the <em class="citetitle">perlre</em> manpage for more
information.</p>


<p>Finally, there are often multiple ways that you can build a regular
expression for any given task, but some ways are more efficient than
others. If you want to learn how to write more <a name="INDEX-3256" /> <a name="INDEX-3257" /> <a name="INDEX-3258" />efficient regular
expressions, <a name="INDEX-3259" /> <a name="INDEX-3260" /> <a name="INDEX-3261" />we highly <a name="INDEX-3262" /> <a name="INDEX-3263" />recommend Jeffrey Friedl's
<em class="citetitle">Mastering Regular Expressions</em>.</p>


<p>These tips are general optimization tips. You'll get a lot of
mileage from some, and not so much from the others, depending on your
application. Now, it's time to look at more complicated ways to
optimize our CGI applications.</p>
</div>
</div>






















<hr align="left" width="515" />
<div class="navbar"><table border="0" width="515"><tr><td width="172" valign="top" align="left"><a href="ch16_02.htm"><img src="../gifs/txtpreva.gif" alt="Previous" border="0" /></a></td><td width="171" valign="top" align="center"><a href="index.htm"><img src="../gifs/txthome.gif" alt="Home" border="0" /></a></td><td width="172" valign="top" align="right"><a href="ch17_02.htm"><img src="../gifs/txtnexta.gif" alt="Next" border="0" /></a></td></tr><tr><td width="172" valign="top" align="left">16.2. Coding Guidelines</td><td width="171" valign="top" align="center"><a href="index/index.htm"><img src="../gifs/index.gif" alt="Book Index" border="0" /></a></td><td width="172" valign="top" align="right">17.2. FastCGI</td></tr></table></div>
<hr align="left" width="515" />

<img src="../gifs/navbar.gif" alt="Library Navigation Links" usemap="#library-map" border="0" />
<p><font size="-1"><a href="copyrght.htm">Copyright &copy; 2001</a> O'Reilly &amp; Associates. All rights reserved.</font></p>

<map name="library-map"><area href="../index.htm" coords="1,1,83,102" shape="rect" /><area href="../lnut/index.htm" coords="81,0,152,95" shape="rect" /><area href="../run/index.htm" coords="172,2,252,105" shape="rect" /><area href="../apache/index.htm" coords="238,2,334,95" shape="rect" /><area href="../sql/index.htm" coords="336,0,412,104" shape="rect" /><area href="../dbi/index.htm" coords="415,0,507,101" shape="rect" /><area href="../cgi/index.htm" coords="511,0,601,99" shape="rect" /></map>

</body></html>