/ 
Cache-Adaptive-0.03
River stage one • 2 direct dependents • 2 total dependents
++
 / Cache::Adaptive

NAME

Cache::Adaptive - A Cache Engine with Adaptive Lifetime Control

SYNOPSIS

  use Cache::Adaptive;
  use Cache::FileCache;
  
  my $cache = Cache::Adaptive->new({
    backend     => Cache::FileCache->new({
      namespace => 'html_cache',
      max_size  => 10 * 1024 * 1024,
    }),
    expires_min => 3,
    expires_max => 60,
    check_load  => sub {
      my $entry = shift;
      int($entry->{process_time} * 2) - 1;
    },
  });
  
  ...
  
  print "Content-Type: text/html\n\n";
  print $cache->access({
    key     => $uri,
    builder => sub {
      # your HTML generation logic here
      $html;
    },
  });

DESCRIPTION

Cache::Adaptive is a cache engine with adaptive lifetime control. Cache lifetimes can be increased or decreased by any factor, e.g. load average, process time for building the cache entry, etc., through the definition of the check_load callback.

PROPERTIES

Cache::Adaptive recognizes following properties. The properties can be set though the constructor, or by calling the accessors.

backend

Backend storage to be used. Should be a Cache::Cache object. Note: do not use Cache::SizeAwareFileCache, since its get method might overwrite data saved by other processes. The update algorithm of Cache::Adaptive needs a reliable set method.

check_interval

Interval between calls to the check_load callback for each cache entry. Default is 0, meaning that check_load will be called every time the cache entry is being built.

check_load

User supplied callback for deciding the cache policy. If a positive number is returned, cache lifetime for the entry will be increased. If a negative number is returned, the lifetime will be decreased. If 0 is returned, the lifetime will not be modified. For detail, see the "DEFINING THE CACHE STRATEGY" section.

increase_factor, decrease_factor

Cache lifetime will be increased or decreased by applying either factor to current lifetime.

expires_min, expires_max

Minimal and maximal expiration times, in seconds.

log

An optional callback for logging.

purge_after

Seconds until per-entry information used for deciding caching algorithm will be purged. Defaults to expires_max * 2.

METHODS

new

See above.

access({ key => cache_key, builder => sub { ... } })

Returns the cached entry if possible, or builds the entry by calling the builder function, and optionally stores the build entry to cache.

DEFINING THE CACHE STRATEGY

A variety of cache strategies can be implemented by defining the check_load callback. Below are some examples.

CACHING HEAVY OPERATIONS

  my $cache = Cache::Adaptive->new({
    ...
    check_load => sub {
      my ($entry, $params) = @_;
      int($entry->{process_time} * 2) - 1;
    },
  });

Assume that the process time of each operation increases as the system becomes heavily loaded. Above code will start caching or increase cache lifetime if the process time for each operation takes more than a second. As more entries become cached, the system load will become lighter, leading to faster process times, and cache lifetimes will no more be increased. When the process time becomes smaller than 0.5 seconds, the cache lifetime will be decreased.

CACHING FREQUENTLY ACCESSED ENTRIES

  my $cache = Cache::Adaptive->new({
    ...
    check_interval => 60,
    check_load     => sub {
      my ($entry, $params) = @_;
      int($params->{load} * 4) - 1;
    },
  });

$params-{load}> contains $entry-{process_time}> divided by build frequency. The above code increases cache lifetime if the system is building the entry during more than 50% of its operation recently. Note that the system may be running multiple processes simultaneously. This value represents the real time, not CPU cycles that were actually spent for handling the operation.

UTILIZING CACHE UNDER HEAVY LOAD

  use BSD::Sysctl qw(sysctl);

  my $cache = Cache::Adaptive->new({
    ...
    check_interval => 60,
    check_load     => sub {
      my $load_avg = sysctl('vm.loadavg');
      int($load_avg->[0] * 2) - 1;
    },
  });

The example updates the cache lifetime by referring to the load average. The example should only work on BSD systems.

A COMPLEX EXAMPLE

  my $cache = Cache::Adaptive->new({
    ...
    check_interval => 60,
    check_load     => sub {
      my ($entry, $params) = @_;
      my $load_avg = sysctl('vm.loadavg');
      int($params{load} * 4 * $load_avg->[0] ** 2) - 1;
    },
  });

The example utilizes the cache for heavily accessed entries under heavy load.

UPDATES

For updates, see

  http://labs.cybozu.co.jp/blog/kazuho/
  http://labs.cybozu.co.jp/blog/kazuhoatwork/

AUTHOR

Copyright (c) 2007 Cybozu Labs, Inc. All rights reserved.

written by Kazuho Oku <kazuhooku@gmail.com>

CONTRIBUTORS

Toru Yamaguchi <zigorou@cpan.org>

LICENSE

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

See http://www.perl.com/perl/misc/Artistic.html