| Cache {reproducible} | R Documentation |
Saves a wide variety function call outputs to disk and optionally RAM, for recovery later
Description
A function that can be used to wrap around other functions to cache function calls
for later use. This is normally most effective when the function to cache is
slow to run, yet the inputs and outputs are small. The benefit of caching, therefore,
will decline when the computational time of the "first" function call is fast and/or
the argument values and return objects are large. The default setting (and first
call to Cache) will always save to disk. The 2nd call to the same function will return
from disk, unless options("reproducible.useMemoise" = TRUE), then the 2nd time
will recover the object from RAM and is normally much faster (at the expense of RAM use).
Usage
Cache(
FUN,
...,
notOlderThan = NULL,
.objects = NULL,
.cacheExtra = NULL,
.functionName = NULL,
outputObjects = NULL,
algo = "xxhash64",
cacheRepo = NULL,
cachePath = NULL,
length = getOption("reproducible.length", Inf),
compareRasterFileLength,
userTags = c(),
omitArgs = NULL,
classOptions = list(),
debugCache = character(),
sideEffect = FALSE,
makeCopy = FALSE,
quick = getOption("reproducible.quick", FALSE),
verbose = getOption("reproducible.verbose", 1),
cacheId = NULL,
useCache = getOption("reproducible.useCache", TRUE),
useCloud = FALSE,
cloudFolderID = NULL,
showSimilar = getOption("reproducible.showSimilar", FALSE),
drv = getDrv(getOption("reproducible.drv", NULL)),
conn = getOption("reproducible.conn", NULL)
)
Arguments
FUN |
Either a function (e.g., |
... |
Arguments passed to |
notOlderThan |
A time. Load an object from the Cache if it was created after this. |
.objects |
Character vector of objects to be digested. This is only applicable if there is a list, environment (or similar) with named objects within it. Only this/these objects will be considered for caching, i.e., only use a subset of the list, environment or similar objects. In the case of nested list-type objects, this will only be applied outermost first. |
.cacheExtra |
A an arbitrary R object that will be included in the |
.functionName |
A an arbitrary character string that provides a name that is different
than the actual function name (e.g., "rnorm") which will be used for messaging. This
can be useful when the actual function is not helpful for a user, such as |
outputObjects |
Optional character vector indicating which objects to return. This is only relevant for list, environment (or similar) objects |
algo |
The algorithms to be used; currently available choices are
|
cacheRepo |
Same as |
cachePath |
A repository used for storing cached objects.
This is optional if |
length |
Numeric. If the element passed to Cache is a |
compareRasterFileLength |
Being deprecated; use |
userTags |
A character vector with descriptions of the Cache function call. These
will be added to the Cache so that this entry in the Cache can be found using
|
omitArgs |
Optional character string of arguments in the FUN to omit from the digest. |
classOptions |
Optional list. This will pass into |
debugCache |
Character or Logical. Either |
sideEffect |
Now deprecated. Logical or path. Determines where the function will look for new files following function completion. See Details. NOTE: this argument is experimental and may change in future releases. |
makeCopy |
Now deprecated. Ignored if used. |
quick |
Logical or character. If |
verbose |
Numeric, -1 silent (where possible), 0 being very quiet,
1 showing more messaging, 2 being more messaging, etc.
Default is 1. Above 3 will output much more information about the internals of
Caching, which may help diagnose Caching challenges. Can set globally with an
option, e.g., |
cacheId |
Character string. If passed, this will override the calculated hash
of the inputs, and return the result from this cacheId in the |
useCache |
Logical, numeric or |
useCloud |
Logical. See Details. |
cloudFolderID |
A googledrive dribble of a folder, e.g., using |
showSimilar |
A logical or numeric. Useful for debugging.
If |
drv |
if using a database backend, drv must be an object that inherits from DBIDriver e.g., from package RSQLite, e.g., SQLite |
conn |
an optional DBIConnection object, as returned by dbConnect(). |
Details
There are other similar functions in the R universe. This version of Cache has been used as part of a robust continuous workflow approach. As a result, we have tested it with many "non-standard" R objects (e.g., RasterLayer, terra objects) and environments (which are always unique, so do not cache readily).
This version of the Cache function accommodates those four special,
though quite common, cases by:
converting any environments into list equivalents;
identifying the dispatched S4 method (including those made through inheritance) before hashing so the correct method is being cached;
by hashing the linked file, rather than the Raster object. Currently, only file-backed
Raster*orterra*objects are digested (e.g., notffobjects, or any other R object where the data are on disk instead of in RAM);Uses
digest::digest()This is used for file-backed objects as well.Cache will save arguments passed by user in a hidden environment. Any nested Cache functions will use arguments in this order 1) actual arguments passed at each Cache call, 2) any inherited arguments from an outer Cache call, 3) the default values of the Cache function. See section on Nested Caching.
Cache will add a tag to the entry in the cache database called accessed,
which will assign the time that it was accessed, either read or write.
That way, cached items can be shown (using showCache) or removed (using
clearCache) selectively, based on their access dates, rather than only
by their creation dates. See example in clearCache().
Value
Returns the value of the function call or the cached version (i.e., the result from a previous call to this same cached function with identical arguments).
Nested Caching
Commonly, Caching is nested, i.e., an outer function is wrapped in a Cache
function call, and one or more inner functions are also wrapped in a Cache
function call. A user can always specify arguments in every Cache function
call, but this can get tedious and can be prone to errors. The normal way that
R handles arguments is it takes the user passed arguments if any, and
default arguments for all those that have no user passed arguments. We have inserted
a middle step. The order or precedence for any given Cache function call is
user arguments, 2. inherited arguments, 3. default arguments. At this time, the top level
Cachearguments will propagate to all inner functions unless each individualCachecall has other arguments specified, i.e., "middle" nestedCachefunction calls don't propagate their arguments to further "inner"Cachefunction calls. See example.
userTags is unique of all arguments: its values will be appended to the
inherited userTags.
quick
The quick argument is attempting to sort out an ambiguity with character strings:
are they file paths or are they simply character strings. When quick = TRUE,
Cache will treat these as character strings; when quick = FALSE,
they will be attempted to be treated as file paths first; if there is no file, then
it will revert to treating them as character strings. If user passes a
character vector to this, then this will behave like omitArgs:
quick = "file" will treat the argument "file" as character string.
The most often encountered situation where this ambiguity matters is in arguments about
filenames: is the filename an input pointing to an object whose content we want to
assess (e.g., a file-backed raster), or an output (as in saveRDS) and it should not
be assessed. If only run once, the output file won't exist, so it will be treated
as a character string. However, once the function has been run once, the output file
will exist, and Cache(...) will assess it, which is incorrect. In these cases,
the user is advised to use quick = "TheOutputFilenameArgument" to
specify the argument whose content on disk should not be assessed, but whose
character string should be assessed (distinguishing it from omitArgs = "TheOutputFilenameArgument", which will not assess the file content nor the
character string).
This is relevant for objects of class character, Path and
Raster currently. For class character, it is ambiguous whether
this represents a character string or a vector of file paths. If it is known
that character strings should not be treated as paths, then quick = TRUE is appropriate, with no loss of information. If it is file or
directory, then it will digest the file content, or basename(object).
For class Path objects, the file's metadata (i.e., filename and file
size) will be hashed instead of the file contents if quick = TRUE. If
set to FALSE (default), the contents of the file(s) are hashed. If
quick = TRUE, length is ignored. Raster objects are
treated as paths, if they are file-backed.
Caching Speed
Caching speed may become a critical aspect of a final product. For example,
if the final product is a shiny app, rerunning the entire project may need
to take less then a few seconds at most. There are 3 arguments that affect
Cache speed: quick, length, and
algo. quick is passed to .robustDigest, which currently
only affects Path and Raster* class objects. In both cases, quick
means that little or no disk-based information will be assessed.
Filepaths
If a function has a path argument, there is some ambiguity about what should be done. Possibilities include:
hash the string as is (this will be very system specific, meaning a
Cachecall will not work if copied between systems or directories);hash the
basename(path);hash the contents of the file.
If paths are passed in as is (i.e,. character string), the result will not be predictable.
Instead, one should use the wrapper function asPath(path), which sets the
class of the string to a Path, and one should decide whether one wants
to digest the content of the file (using quick = FALSE),
or just the filename ((quick = TRUE)). See examples.
Stochasticity or randomness
In general, it is expected that caching will only be used when randomness is not
desired, e.g., Cache(rnorm(1)) is unlikely to be useful in many cases. However,
Cache captures the call that is passed to it, leaving all functions unevaluated.
As a result Cache(glm, x ~ y, rnorm(1)) will not work as a means of forcing
a new evaluation each time, as the rnorm(1) is not evaluated before the call
is assessed against the cache database. To force a new call each time, evaluate
the randomness prior to the Cache call, e.g., ran = rnorm(1) then pass this
to .cacheExtra, e.g., Cache(glm, x ~ y, .cacheExtra = ran)
drv and conn
By default, drv uses an SQLite database. This can be sufficient for most cases.
However, if a user has dozens or more cores making requests to the Cache database,
it may be insufficient. A user can set up a different database backend, e.g.,
PostgreSQL that can handle multiple simultaneous read-write situations. See
https://github.com/PredictiveEcology/SpaDES/wiki/Using-alternate-database-backends-for-Cache.
useCache
Logical or numeric. If FALSE or 0, then the entire Caching
mechanism is bypassed and the
function is evaluated as if it was not being Cached. Default is
getOption("reproducible.useCache")), which is TRUE by default,
meaning use the Cache mechanism. This may be useful to turn all Caching on or
off in very complex scripts and nested functions. Increasing levels of numeric
values will cause deeper levels of Caching to occur (though this may not
work as expected in all cases). The following is no longer supported:
Currently, only implemented
in postProcess: to do both caching of inner cropInputs, projectInputs
and maskInputs, and caching of outer postProcess, use
useCache = 2; to skip the inner sequence of 3 functions, use useCache = 1.
For large objects, this may prevent many duplicated save to disk events.
If useCache = "overwrite"
(which can be set with options("reproducible.useCache" = "overwrite")), then the function invoke the caching mechanism but will purge
any entry that is matched, and it will be replaced with the results of the
current call.
If useCache = "devMode": The point of this mode is to facilitate using the Cache when
functions and datasets are continually in flux, and old Cache entries are
likely stale very often. In devMode, the cache mechanism will work as
normal if the Cache call is the first time for a function OR if it
successfully finds a copy in the cache based on the normal Cache mechanism.
It differs from the normal Cache if the Cache call does not find a copy
in the cachePath, but it does find an entry that matches based on
userTags. In this case, it will delete the old entry in the cachePath
(identified based on matching userTags), then continue with normal Cache.
For this to work correctly, userTags must be unique for each function call.
This should be used with caution as it is still experimental. Currently, if
userTags are not unique to a single entry in the cachePath, it will
default to the behaviour of useCache = TRUE with a message. This means
that "devMode" is most useful if used from the start of a project.
useCloud
This is experimental and there are many conditions under which this is known
to not work correctly. This is a way to store all or some of the local Cache in the cloud.
Currently, the only cloud option is Google Drive, via googledrive.
For this to work, the user must be or be able to be authenticated
with googledrive::drive_auth. The principle behind this
useCloud is that it will be a full or partial mirror of a local Cache.
It is not intended to be used independently from a local Cache. To share
objects that are in the Cloud with another person, it requires 2 steps. 1)
share the cloudFolderID$id, which can be retrieved by
getOption("reproducible.cloudFolderID")$id after at least one Cache
call has been made. 2) The other user must then set their cacheFolderID in a
Cache\(..., reproducible.cloudFolderID = \"the ID here\"\) call or
set their option manually
options\(\"reproducible.cloudFolderID\" = \"the ID here\"\).
If TRUE, then this Cache call will download
(if local copy doesn't exist, but cloud copy does exist), upload
(local copy does or doesn't exist and
cloud copy doesn't exist), or
will not download nor upload if object exists in both. If TRUE will be at
least 1 second slower than setting this to FALSE, and likely even slower as the
cloud folder gets large. If a user wishes to keep "high-level" control, set this to
getOption("reproducible.useCloud", FALSE) or
getOption("reproducible.useCloud", TRUE) (if the default behaviour should
be FALSE or TRUE, respectively) so it can be turned on and off with
this option. NOTE: This argument will not be passed into inner/nested Cache calls.)
Object attributes
Users should be cautioned that object attributes may not be preserved, especially
in the case of objects that are file-backed, such as Raster or SpatRaster objects.
If a user needs to keep attributes, they may need to manually re-attach them to
the object after recovery. With the example of SpatRaster objects, saving
to disk requires terra::wrap if it is a memory-backed object. When running
terra::unwrap on this object, any attributes that a user had added are lost.
sideEffect
This feature is now deprecated. Do not use as it is ignored.
Note
As indicated above, several objects require pre-treatment before
caching will work as expected. The function .robustDigest accommodates this.
It is an S4 generic, meaning that developers can produce their own methods for
different classes of objects. Currently, there are methods for several types
of classes. See .robustDigest().
Author(s)
Eliot McIntire
See Also
showCache(), clearCache(), keepCache(),
CacheDigest() to determine the digest of a given function or expression,
as used internally within Cache, movedCache(), .robustDigest(), and
for more advanced uses there are several helper functions,
e.g., rmFromCache(), CacheStorageDir()
Examples
data.table::setDTthreads(2)
tmpDir <- file.path(tempdir())
opts <- options(reproducible.cachePath = tmpDir)
# Usage -- All below are equivalent; even where args are missing or provided,
# Cache evaluates using default values, if these are specified in formals(FUN)
a <- list()
b <- list(fun = rnorm)
bbb <- 1
ee <- new.env(parent = emptyenv())
ee$qq <- bbb
a[[1]] <- Cache(rnorm(1)) # no evaluation prior to Cache
a[[2]] <- Cache(rnorm, 1) # no evaluation prior to Cache
a[[3]] <- Cache(do.call, rnorm, list(1))
a[[4]] <- Cache(do.call(rnorm, list(1)))
a[[5]] <- Cache(do.call(b$fun, list(1)))
a[[6]] <- Cache(do.call, b$fun, list(1))
a[[7]] <- Cache(b$fun, 1)
a[[8]] <- Cache(b$fun(1))
a[[10]] <- Cache(quote(rnorm(1)))
a[[11]] <- Cache(stats::rnorm(1))
a[[12]] <- Cache(stats::rnorm, 1)
a[[13]] <- Cache(rnorm(1, 0, get("bbb", inherits = FALSE)))
a[[14]] <- Cache(rnorm(1, 0, get("qq", inherits = FALSE, envir = ee)))
a[[15]] <- Cache(rnorm(1, bbb - bbb, get("bbb", inherits = FALSE)))
a[[16]] <- Cache(rnorm(sd = 1, 0, n = get("bbb", inherits = FALSE))) # change order
a[[17]] <- Cache(rnorm(1, sd = get("ee", inherits = FALSE)$qq), mean = 0)
# with base pipe -- this is put in quotes ('') because R version 4.0 can't understand this
# if you are using R >= 4.1 or R >= 4.2 if using the _ placeholder,
# then you can just use pipe normally
usingPipe1 <- "b$fun(1) |> Cache()" # base pipe
# For long pipe, need to wrap sequence in { }, or else only last step is cached
usingPipe2 <-
'{"bbb" |>
parse(text = _) |>
eval() |>
rnorm()} |>
Cache()'
if (getRversion() >= "4.1") {
a[[9]] <- eval(parse(text = usingPipe1)) # recovers cached copy
}
if (getRversion() >= "4.2") { # uses the _ placeholder; only available in R >= 4.2
a[[18]] <- eval(parse(text = usingPipe2)) # recovers cached copy
}
length(unique(a)) == 1 # all same
### Pipe -- have to use { } or else only final function is Cached
if (getRversion() >= "4.1") {
b1a <- 'sample(1e5, 1) |> rnorm() |> Cache()'
b1b <- 'sample(1e5, 1) |> rnorm() |> Cache()'
b2a <- '{sample(1e5, 1) |> rnorm()} |> Cache()'
b2b <- '{sample(1e5, 1) |> rnorm()} |> Cache()'
b1a <- eval(parse(text = b1a))
b1b <- eval(parse(text = b1b))
b2a <- eval(parse(text = b2a))
b2b <- eval(parse(text = b2b))
all.equal(b1a, b1b) # Not TRUE because the sample is run first
all.equal(b2a, b2b) # TRUE because of { }
}
#########################
# Advanced examples
#########################
# .cacheExtra -- add something to digest
Cache(rnorm(1), .cacheExtra = "sfessee11") # adds something other than fn args
Cache(rnorm(1), .cacheExtra = "nothing") # even though fn is same, the extra is different
# omitArgs -- remove something from digest (kind of the opposite of .cacheExtra)
Cache(rnorm(2, sd = 1), omitArgs = "sd") # removes one or more args from cache digest
Cache(rnorm(2, sd = 2), omitArgs = "sd") # b/c sd is not used, this is same as previous
# cacheId -- force the use of a digest -- can give undesired consequences
Cache(rnorm(3), cacheId = "k323431232") # sets the cacheId for this call
Cache(runif(14), cacheId = "k323431232") # recovers same as above, i.e, rnorm(3)
# Turn off Caching session-wide
opts <- options(reproducible.useCache = FALSE)
Cache(rnorm(3)) # doesn't cache
options(opts)
# showSimilar can help with debugging why a Cache call isn't picking up a cached copy
Cache(rnorm(4), showSimilar = TRUE) # shows that the argument `n` is different
###############################################
# devMode -- enables cache database to stay
# small even when developing code
###############################################
opt <- options("reproducible.useCache" = "devMode")
clearCache(tmpDir, ask = FALSE)
centralTendency <- function(x) {
mean(x)
}
funnyData <- c(1, 1, 1, 1, 10)
uniqueUserTags <- c("thisIsUnique", "reallyUnique")
ranNumsB <- Cache(centralTendency, funnyData, cachePath = tmpDir,
userTags = uniqueUserTags) # sets new value to Cache
showCache(tmpDir) # 1 unique cacheId -- cacheId is 71cd24ec3b0d0cac
# During development, we often redefine function internals
centralTendency <- function(x) {
median(x)
}
# When we rerun, we don't want to keep the "old" cache because the function will
# never again be defined that way. Here, because of userTags being the same,
# it will replace the entry in the Cache, effetively overwriting it, even though
# it has a different cacheId
ranNumsD <- Cache(centralTendency, funnyData, cachePath = tmpDir, userTags = uniqueUserTags)
showCache(tmpDir) # 1 unique artifact -- cacheId is 632cd06f30e111be
# If it finds it by cacheID, doesn't matter what the userTags are
ranNumsD <- Cache(centralTendency, funnyData, cachePath = tmpDir, userTags = "thisIsUnique")
options(opt)
#########################################
# For more in depth uses, see vignette
if (interactive())
browseVignettes(package = "reproducible")