memoize.3

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

.\" Automatically generated by Pod::Man 2.16 (Pod::Simple 3.05)
.\"
.\" Standard preamble:
.\" ========================================================================
.de Sh \" Subsection heading
.br
.if t .Sp
.ne 5
.PP
\fB\\$1\fR
.PP
..
.de Sp \" Vertical space (when we can't use .PP)
.if t .sp .5v
.if n .sp
..
.de Vb \" Begin verbatim text
.ft CW
.nf
.ne \\$1
..
.de Ve \" End verbatim text
.ft R
.fi
..
.\" Set up some character translations and predefined strings.  \*(-- will
.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
.\" double quote, and \*(R" will give a right double quote.  \*(C+ will
.\" give a nicer C++.  Capital omega is used to do unbreakable dashes and
.\" therefore won't be available.  \*(C` and \*(C' expand to `' in nroff,
.\" nothing in troff, for use with C<>.
.tr \(*W-
.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
.ie n \{\
.    ds -- \(*W-
.    ds PI pi
.    if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
.    if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\"  diablo 12 pitch
.    ds L" ""
.    ds R" ""
.    ds C` ""
.    ds C' ""
'br\}
.el\{\
.    ds -- \|\(em\|
.    ds PI \(*p
.    ds L" ``
.    ds R" ''
'br\}
.\"
.\" Escape single quotes in literal strings from groff's Unicode transform.
.ie \n(.g .ds Aq \(aq
.el       .ds Aq '
.\"
.\" If the F register is turned on, we'll generate index entries on stderr for
.\" titles (.TH), headers (.SH), subsections (.Sh), items (.Ip), and index
.\" entries marked with X<> in POD.  Of course, you'll have to process the
.\" output yourself in some meaningful fashion.
.ie \nF \{\
.    de IX
.    tm Index:\\$1\t\\n%\t"\\$2"
..
.    nr % 0
.    rr F
.\}
.el \{\
.    de IX
..
.\}
.\"
.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
.\" Fear.  Run.  Save yourself.  No user-serviceable parts.
.    \" fudge factors for nroff and troff
.if n \{\
.    ds #H 0
.    ds #V .8m
.    ds #F .3m
.    ds #[ \f1
.    ds #] \fP
.\}
.if t \{\
.    ds #H ((1u-(\\\\n(.fu%2u))*.13m)
.    ds #V .6m
.    ds #F 0
.    ds #[ \&
.    ds #] \&
.\}
.    \" simple accents for nroff and troff
.if n \{\
.    ds ' \&
.    ds ` \&
.    ds ^ \&
.    ds , \&
.    ds ~ ~
.    ds /
.\}
.if t \{\
.    ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
.    ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
.    ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
.    ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
.    ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
.    ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
.\}
.    \" troff and (daisy-wheel) nroff accents
.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
.ds ae a\h'-(\w'a'u*4/10)'e
.ds Ae A\h'-(\w'A'u*4/10)'E
.    \" corrections for vroff
.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
.    \" for low resolution devices (crt and lpr)
.if \n(.H>23 .if \n(.V>19 \
\{\
.    ds : e
.    ds 8 ss
.    ds o a
.    ds d- d\h'-1'\(ga
.    ds D- D\h'-1'\(hy
.    ds th \o'bp'
.    ds Th \o'LP'
.    ds ae ae
.    ds Ae AE
.\}
.rm #[ #] #H #V #F C
.\" ========================================================================
.\"
.IX Title "Memoize 3"
.TH Memoize 3 "2007-12-18" "perl v5.10.0" "Perl Programmers Reference Guide"
.\" For nroff, turn off justification.  Always turn off hyphenation; it makes
.\" way too many mistakes in technical documents.
.if n .ad l
.nh
.SH "NAME"
Memoize \- Make functions faster by trading space for time
.SH "SYNOPSIS"
.IX Header "SYNOPSIS"
.Vb 4
\&        # This is the documentation for Memoize 1.01
\&        use Memoize;
\&        memoize(\*(Aqslow_function\*(Aq);
\&        slow_function(arguments);    # Is faster than it was before
.Ve
.PP
This is normally all you need to know.  However, many options are available:
.PP
.Vb 1
\&        memoize(function, options...);
.Ve
.PP
Options include:
.PP
.Vb 2
\&        NORMALIZER => function
\&        INSTALL => new_name
\&
\&        SCALAR_CACHE => \*(AqMEMORY\*(Aq
\&        SCALAR_CACHE => [\*(AqHASH\*(Aq, \e%cache_hash ]
\&        SCALAR_CACHE => \*(AqFAULT\*(Aq
\&        SCALAR_CACHE => \*(AqMERGE\*(Aq
\&
\&        LIST_CACHE => \*(AqMEMORY\*(Aq
\&        LIST_CACHE => [\*(AqHASH\*(Aq, \e%cache_hash ]
\&        LIST_CACHE => \*(AqFAULT\*(Aq
\&        LIST_CACHE => \*(AqMERGE\*(Aq
.Ve
.SH "DESCRIPTION"
.IX Header "DESCRIPTION"
`Memoizing' a function makes it faster by trading space for time.  It
does this by caching the return values of the function in a table.
If you call the function again with the same arguments, \f(CW\*(C`memoize\*(C'\fR
jumps in and gives you the value out of the table, instead of letting
the function compute the value all over again.
.PP
Here is an extreme example.  Consider the Fibonacci sequence, defined
by the following function:
.PP
.Vb 6
\&        # Compute Fibonacci numbers
\&        sub fib {
\&          my $n = shift;
\&          return $n if $n < 2;
\&          fib($n\-1) + fib($n\-2);
\&        }
.Ve
.PP
This function is very slow.  Why?  To compute fib(14), it first wants
to compute fib(13) and fib(12), and add the results.  But to compute
fib(13), it first has to compute fib(12) and fib(11), and then it
comes back and computes fib(12) all over again even though the answer
is the same.  And both of the times that it wants to compute fib(12),
it has to compute fib(11) from scratch, and then it has to do it
again each time it wants to compute fib(13).  This function does so
much recomputing of old results that it takes a really long time to
run\-\-\-fib(14) makes 1,200 extra recursive calls to itself, to compute
and recompute things that it already computed.
.PP
This function is a good candidate for memoization.  If you memoize the
`fib' function above, it will compute fib(14) exactly once, the first
time it needs to, and then save the result in a table.  Then if you
ask for fib(14) again, it gives you the result out of the table.
While computing fib(14), instead of computing fib(12) twice, it does
it once; the second time it needs the value it gets it from the table.
It doesn't compute fib(11) four times; it computes it once, getting it
from the table the next three times.  Instead of making 1,200
recursive calls to `fib', it makes 15.  This makes the function about
150 times faster.
.PP
You could do the memoization yourself, by rewriting the function, like
this:
.PP
.Vb 9
\&        # Compute Fibonacci numbers, memoized version
\&        { my @fib;
\&          sub fib {
\&            my $n = shift;
\&            return $fib[$n] if defined $fib[$n];
\&            return $fib[$n] = $n if $n < 2;
\&            $fib[$n] = fib($n\-1) + fib($n\-2);
\&          }
\&        }
.Ve
.PP
Or you could use this module, like this:
.PP
.Vb 2
\&        use Memoize;
\&        memoize(\*(Aqfib\*(Aq);
\&
\&        # Rest of the fib function just like the original version.
.Ve
.PP
This makes it easy to turn memoizing on and off.
.PP
Here's an even simpler example: I wrote a simple ray tracer; the
program would look in a certain direction, figure out what it was
looking at, and then convert the `color' value (typically a string
like `red') of that object to a red, green, and blue pixel value, like
this:
.PP
.Vb 6
\&    for ($direction = 0; $direction < 300; $direction++) {
\&      # Figure out which object is in direction $direction
\&      $color = $object\->{color};
\&      ($r, $g, $b) = @{&ColorToRGB($color)};
\&      ...
\&    }
.Ve
.PP
Since there are relatively few objects in a picture, there are only a
few colors, which get looked up over and over again.  Memoizing
\&\f(CW\*(C`ColorToRGB\*(C'\fR sped up the program by several percent.
.SH "DETAILS"
.IX Header "DETAILS"
This module exports exactly one function, \f(CW\*(C`memoize\*(C'\fR.  The rest of the
functions in this package are None of Your Business.
.PP
You should say
.PP
.Vb 1
\&        memoize(function)
.Ve
.PP
where \f(CW\*(C`function\*(C'\fR is the name of the function you want to memoize, or
a reference to it.  \f(CW\*(C`memoize\*(C'\fR returns a reference to the new,
memoized version of the function, or \f(CW\*(C`undef\*(C'\fR on a non-fatal error.
At present, there are no non-fatal errors, but there might be some in
the future.
.PP
If \f(CW\*(C`function\*(C'\fR was the name of a function, then \f(CW\*(C`memoize\*(C'\fR hides the
old version and installs the new memoized version under the old name,
so that \f(CW\*(C`&function(...)\*(C'\fR actually invokes the memoized version.
.SH "OPTIONS"
.IX Header "OPTIONS"
There are some optional options you can pass to \f(CW\*(C`memoize\*(C'\fR to change
the way it behaves a little.  To supply options, invoke \f(CW\*(C`memoize\*(C'\fR
like this:
.PP
.Vb 5
\&        memoize(function, NORMALIZER => function,
\&                          INSTALL => newname,
\&                          SCALAR_CACHE => option,
\&                          LIST_CACHE => option
\&                         );