memoize.3

视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.

.Sp
.Vb 1
\&        tie my %cache => \*(AqMLDBM\*(Aq, \*(AqDB_File\*(Aq, $filename, ...;
\&
\&        memoize \*(Aqmyfunc\*(Aq,
\&          NORMALIZER => \*(Aqn\*(Aq,
\&          SCALAR_CACHE => [HASH => \e%cache],
\&          LIST_CACHE => MERGE,
\&        ;
\&
\&        sub n {
\&          my $context = wantarray() ? \*(AqL\*(Aq : \*(AqS\*(Aq;
\&          # ... now compute the hash key from the arguments ...
\&          $hashkey = "$context:$hashkey";
\&        }
.Ve
.Sp
This normalizer function will store scalar context return values in
the disk file under keys that begin with \f(CW\*(C`S:\*(C'\fR, and list context
return values under keys that begin with \f(CW\*(C`L:\*(C'\fR.
.SH "OTHER FACILITIES"
.IX Header "OTHER FACILITIES"
.ie n .Sh """unmemoize"""
.el .Sh "\f(CWunmemoize\fP"
.IX Subsection "unmemoize"
There's an \f(CW\*(C`unmemoize\*(C'\fR function that you can import if you want to.
Why would you want to?  Here's an example: Suppose you have your cache
tied to a \s-1DBM\s0 file, and you want to make sure that the cache is
written out to disk if someone interrupts the program.  If the program
exits normally, this will happen anyway, but if someone types
control-C or something then the program will terminate immediately
without synchronizing the database.  So what you can do instead is
.PP
.Vb 1
\&    $SIG{INT} = sub { unmemoize \*(Aqfunction\*(Aq };
.Ve
.PP
\&\f(CW\*(C`unmemoize\*(C'\fR accepts a reference to, or the name of a previously
memoized function, and undoes whatever it did to provide the memoized
version in the first place, including making the name refer to the
unmemoized version if appropriate.  It returns a reference to the
unmemoized version of the function.
.PP
If you ask it to unmemoize a function that was never memoized, it
croaks.
.ie n .Sh """flush_cache"""
.el .Sh "\f(CWflush_cache\fP"
.IX Subsection "flush_cache"
\&\f(CW\*(C`flush_cache(function)\*(C'\fR will flush out the caches, discarding \fIall\fR
the cached data.  The argument may be a function name or a reference
to a function.  For finer control over when data is discarded or
expired, see the documentation for \f(CW\*(C`Memoize::Expire\*(C'\fR, included in
this package.
.PP
Note that if the cache is a tied hash, \f(CW\*(C`flush_cache\*(C'\fR will attempt to
invoke the \f(CW\*(C`CLEAR\*(C'\fR method on the hash.  If there is no \f(CW\*(C`CLEAR\*(C'\fR
method, this will cause a run-time error.
.PP
An alternative approach to cache flushing is to use the \f(CW\*(C`HASH\*(C'\fR option
(see above) to request that \f(CW\*(C`Memoize\*(C'\fR use a particular hash variable
as its cache.  Then you can examine or modify the hash at any time in
any way you desire.  You may flush the cache by using \f(CW\*(C`%hash = ()\*(C'\fR.
.SH "CAVEATS"
.IX Header "CAVEATS"
Memoization is not a cure-all:
.IP "\(bu" 4
Do not memoize a function whose behavior depends on program
state other than its own arguments, such as global variables, the time
of day, or file input.  These functions will not produce correct
results when memoized.  For a particularly easy example:
.Sp
.Vb 3
\&        sub f {
\&          time;
\&        }
.Ve
.Sp
This function takes no arguments, and as far as \f(CW\*(C`Memoize\*(C'\fR is
concerned, it always returns the same result.  \f(CW\*(C`Memoize\*(C'\fR is wrong, of
course, and the memoized version of this function will call \f(CW\*(C`time\*(C'\fR once
to get the current time, and it will return that same time
every time you call it after that.
.IP "\(bu" 4
Do not memoize a function with side effects.
.Sp
.Vb 5
\&        sub f {
\&          my ($a, $b) = @_;
\&          my $s = $a + $b;
\&          print "$a + $b = $s.\en";
\&        }
.Ve
.Sp
This function accepts two arguments, adds them, and prints their sum.
Its return value is the numuber of characters it printed, but you
probably didn't care about that.  But \f(CW\*(C`Memoize\*(C'\fR doesn't understand
that.  If you memoize this function, you will get the result you
expect the first time you ask it to print the sum of 2 and 3, but
subsequent calls will return 1 (the return value of
\&\f(CW\*(C`print\*(C'\fR) without actually printing anything.
.IP "\(bu" 4
Do not memoize a function that returns a data structure that is
modified by its caller.
.Sp
Consider these functions:  \f(CW\*(C`getusers\*(C'\fR returns a list of users somehow,
and then \f(CW\*(C`main\*(C'\fR throws away the first user on the list and prints the
rest:
.Sp
.Vb 7
\&        sub main {
\&          my $userlist = getusers();
\&          shift @$userlist;
\&          foreach $u (@$userlist) {
\&            print "User $u\en";
\&          }
\&        }
\&
\&        sub getusers {
\&          my @users;
\&          # Do something to get a list of users;
\&          \e@users;  # Return reference to list.
\&        }
.Ve
.Sp
If you memoize \f(CW\*(C`getusers\*(C'\fR here, it will work right exactly once.  The
reference to the users list will be stored in the memo table.  \f(CW\*(C`main\*(C'\fR
will discard the first element from the referenced list.  The next
time you invoke \f(CW\*(C`main\*(C'\fR, \f(CW\*(C`Memoize\*(C'\fR will not call \f(CW\*(C`getusers\*(C'\fR; it will
just return the same reference to the same list it got last time.  But
this time the list has already had its head removed; \f(CW\*(C`main\*(C'\fR will
erroneously remove another element from it.  The list will get shorter
and shorter every time you call \f(CW\*(C`main\*(C'\fR.
.Sp
Similarly, this:
.Sp
.Vb 3
\&        $u1 = getusers();    
\&        $u2 = getusers();    
\&        pop @$u1;
.Ve
.Sp
will modify \f(CW$u2\fR as well as \f(CW$u1\fR, because both variables are references
to the same array.  Had \f(CW\*(C`getusers\*(C'\fR not been memoized, \f(CW$u1\fR and \f(CW$u2\fR
would have referred to different arrays.
.IP "\(bu" 4
Do not memoize a very simple function.
.Sp
Recently someone mentioned to me that the Memoize module made his
program run slower instead of faster.  It turned out that he was
memoizing the following function:
.Sp
.Vb 3
\&    sub square {
\&      $_[0] * $_[0];
\&    }
.Ve
.Sp
I pointed out that \f(CW\*(C`Memoize\*(C'\fR uses a hash, and that looking up a
number in the hash is necessarily going to take a lot longer than a
single multiplication.  There really is no way to speed up the
\&\f(CW\*(C`square\*(C'\fR function.
.Sp
Memoization is not magical.
.SH "PERSISTENT CACHE SUPPORT"
.IX Header "PERSISTENT CACHE SUPPORT"
You can tie the cache tables to any sort of tied hash that you want
to, as long as it supports \f(CW\*(C`TIEHASH\*(C'\fR, \f(CW\*(C`FETCH\*(C'\fR, \f(CW\*(C`STORE\*(C'\fR, and
\&\f(CW\*(C`EXISTS\*(C'\fR.  For example,
.PP
.Vb 2
\&        tie my %cache => \*(AqGDBM_File\*(Aq, $filename, O_RDWR|O_CREAT, 0666;
\&        memoize \*(Aqfunction\*(Aq, SCALAR_CACHE => [HASH => \e%cache];
.Ve
.PP
works just fine.  For some storage methods, you need a little glue.
.PP
\&\f(CW\*(C`SDBM_File\*(C'\fR doesn't supply an \f(CW\*(C`EXISTS\*(C'\fR method, so included in this
package is a glue module called \f(CW\*(C`Memoize::SDBM_File\*(C'\fR which does
provide one.  Use this instead of plain \f(CW\*(C`SDBM_File\*(C'\fR to store your
cache table on disk in an \f(CW\*(C`SDBM_File\*(C'\fR database:
.PP
.Vb 2
\&        tie my %cache => \*(AqMemoize::SDBM_File\*(Aq, $filename, O_RDWR|O_CREAT, 0666;
\&        memoize \*(Aqfunction\*(Aq, SCALAR_CACHE => [HASH => \e%cache];
.Ve
.PP
\&\f(CW\*(C`NDBM_File\*(C'\fR has the same problem and the same solution.  (Use
\&\f(CW\*(C`Memoize::NDBM_File instead of plain NDBM_File.\*(C'\fR)
.PP
\&\f(CW\*(C`Storable\*(C'\fR isn't a tied hash class at all.  You can use it to store a
hash to disk and retrieve it again, but you can't modify the hash while
it's on the disk.  So if you want to store your cache table in a
\&\f(CW\*(C`Storable\*(C'\fR database, use \f(CW\*(C`Memoize::Storable\*(C'\fR, which puts a hashlike
front-end onto \f(CW\*(C`Storable\*(C'\fR.  The hash table is actually kept in
memory, and is loaded from your \f(CW\*(C`Storable\*(C'\fR file at the time you
memoize the function, and stored back at the time you unmemoize the
function (or when your program exits):
.PP
.Vb 2
\&        tie my %cache => \*(AqMemoize::Storable\*(Aq, $filename;
\&        memoize \*(Aqfunction\*(Aq, SCALAR_CACHE => [HASH => \e%cache];
\&
\&        tie my %cache => \*(AqMemoize::Storable\*(Aq, $filename, \*(Aqnstore\*(Aq;
\&        memoize \*(Aqfunction\*(Aq, SCALAR_CACHE => [HASH => \e%cache];
.Ve
.PP
Include the `nstore' option to have the \f(CW\*(C`Storable\*(C'\fR database written
in `network order'.  (See Storable for more details about this.)
.PP
The \f(CW\*(C`flush_cache()\*(C'\fR function will raise a run-time error unless the
tied package provides a \f(CW\*(C`CLEAR\*(C'\fR method.
.SH "EXPIRATION SUPPORT"
.IX Header "EXPIRATION SUPPORT"
See Memoize::Expire, which is a plug-in module that adds expiration
functionality to Memoize.  If you don't like the kinds of policies
that Memoize::Expire implements, it is easy to write your own plug-in
module to implement whatever policy you desire.  Memoize comes with
several examples.  An expiration manager that implements a \s-1LRU\s0 policy
is available on \s-1CPAN\s0 as Memoize::ExpireLRU.
.SH "BUGS"
.IX Header "BUGS"
The test suite is much better, but always needs improvement.
.PP
There is some problem with the way \f(CW\*(C`goto &f\*(C'\fR works under threaded
Perl, perhaps because of the lexical scoping of \f(CW@_\fR.  This is a bug
in Perl, and until it is resolved, memoized functions will see a
slightly different \f(CW\*(C`caller()\*(C'\fR and will perform a little more slowly
on threaded perls than unthreaded perls.
.PP
Some versions of \f(CW\*(C`DB_File\*(C'\fR won't let you store data under a key of
length 0.  That means that if you have a function \f(CW\*(C`f\*(C'\fR which you
memoized and the cache is in a \f(CW\*(C`DB_File\*(C'\fR database, then the value of
\&\f(CW\*(C`f()\*(C'\fR (\f(CW\*(C`f\*(C'\fR called with no arguments) will not be memoized.  If this
is a big problem, you can supply a normalizer function that prepends
\&\f(CW"x"\fR to every key.
.SH "MAILING LIST"
.IX Header "MAILING LIST"
To join a very low-traffic mailing list for announcements about
\&\f(CW\*(C`Memoize\*(C'\fR, send an empty note to \f(CW\*(C`mjd\-perl\-memoize\[e-mail]\*(C'\fR.
.SH "AUTHOR"
.IX Header "AUTHOR"
Mark-Jason Dominus (\f(CW\*(C`mjd\-perl\[e-mail]\*(C'\fR), Plover Systems co.
.PP
See the \f(CW\*(C`Memoize.pm\*(C'\fR Page at http://www.plover.com/~mjd/perl/Memoize/
for news and upgrades.  Near this page, at
http://www.plover.com/~mjd/perl/MiniMemoize/ there is an article about
memoization and about the internals of Memoize that appeared in The
Perl Journal, issue #13.  (This article is also included in the
Memoize distribution as `article.html'.)
.PP
My upcoming book will discuss memoization (and many other fascinating
topics) in tremendous detail.  It will be published by Morgan Kaufmann
in 2002, possibly under the title \fIPerl Advanced Techniques
Handbook\fR.  It will also be available on-line for free.  For more
information, visit http://perl.plover.com/book/ .
.PP
To join a mailing list for announcements about \f(CW\*(C`Memoize\*(C'\fR, send an
empty message to \f(CW\*(C`mjd\-perl\-memoize\[e-mail]\*(C'\fR.  This mailing
list is for announcements only and has extremely low traffic\-\-\-about
two messages per year.
.SH "COPYRIGHT AND LICENSE"
.IX Header "COPYRIGHT AND LICENSE"
Copyright 1998, 1999, 2000, 2001  by Mark Jason Dominus
.PP
This library is free software; you may redistribute it and/or modify
it under the same terms as Perl itself.
.SH "THANK YOU"
.IX Header "THANK YOU"
Many thanks to Jonathan Roy for bug reports and suggestions, to
Michael Schwern for other bug reports and patches, to Mike Cariaso for
helping me to figure out the Right Thing to Do About Expiration, to
Joshua Gerth, Joshua Chamas, Jonathan Roy (again), Mark D. Anderson,
and Andrew Johnson for more suggestions about expiration, to Brent
Powers for the Memoize::ExpireLRU module, to Ariel Scolnicov for
delightful messages about the Fibonacci function, to Dion Almaer for
thought-provoking suggestions about the default normalizer, to Walt
Mankowski and Kurt Starsinic for much help investigating problems
under threaded Perl, to Alex Dudkevich for reporting the bug in
prototyped functions and for checking my patch, to Tony Bass for many
helpful suggestions, to Jonathan Roy (again) for finding a use for
\&\f(CW\*(C`unmemoize()\*(C'\fR, to Philippe Verdret for enlightening discussion of
\&\f(CW\*(C`Hook::PrePostCall\*(C'\fR, to Nat Torkington for advice I ignored, to Chris
Nandor for portability advice, to Randal Schwartz for suggesting the
\&'\f(CW\*(C`flush_cache\*(C'\fR function, and to Jenda Krynicky for being a light in
the world.
.PP
Special thanks to Jarkko Hietaniemi, the 5.8.0 pumpking, for including
this module in the core and for his patient and helpful guidance
during the integration process.