Alternative to #1365: reduce deep copies of objects

[wlandau]

branch_init() creates deep copies of environments when it creates dynamic branches:

targets/R/class_branch.R

Lines 10 to 17 in 3760219

	command <- command_clone(command)
	deps <- union(command$deps, deps)
	command$deps <- setdiff(deps, settings$dimensions)
	command$seed <- tar_seed_create(child)
	pedigree <- pedigree_new(settings$name, child, index)
	settings <- settings_clone(settings)
	settings$name <- child
	store <- settings_produce_store(settings)

This could be responsible for much of the slowness and memory consumption we see in heavily dynamically-branched pipelines. To test empirically, let's consider an environment with deep copies of nested environments (current approach in targets):

list_deep <- function(n, data) {
  out <- lapply(seq_len(n), function(x) {
    outer <- new.env(parent = emptyenv())
    outer$inner <- new.env(parent = emptyenv())
    outer$inner$data <- data
    outer
  })
  names(out) <- as.character(seq_len(n))
  list2env(out, parent = emptyenv())
}

After much refactoring, targets could adopt the following approach where certain inner environments are common to all branches:

list_shallow <- function(n, inner) {
  out <- lapply(seq_len(n), function(x) {
    outer <- new.env(parent = emptyenv())
    outer$inner <- inner
    outer
  })
  names(out) <- as.character(seq_len(n))
  list2env(out, parent = emptyenv())
}

Let's see how speed and memory differ:

benchmarks <- function(n) {
  inner <- new.env(parent = emptyenv())
  data <- data.frame(x = rnorm(10))
  inner$data <- data
  seconds_shallow <- system.time(
    bytes_shallow <- as.numeric(lobstr::obj_size(list_shallow(n, inner)))
  )["elapsed"]
  seconds_deep <- system.time(
    bytes_deep <- as.numeric(lobstr::obj_size(list_deep(n, data)))
  )["elapsed"] 
  tibble::tibble(
    n = n,
    bytes_shallow = bytes_shallow,
    bytes_deep = bytes_deep,
    bytes_proportion = bytes_shallow / bytes_deep,
    seconds_shallow = seconds_shallow,
    seconds_deep = seconds_deep,
    seconds_proportion = seconds_shallow / seconds_deep
  )
}

dplyr::bind_rows(lapply(10 ^ seq(3, 6), benchmarks))
#> # A tibble: 4 × 7
#>         n bytes_shallow bytes_deep bytes_proportion seconds_shallow seconds_deep seconds_proportion
#>     <dbl>         <dbl>      <dbl>            <dbl>           <dbl>        <dbl>              <dbl>
#> 1    1000        515072     906680            0.568          0.0360      0.00500              7.20 
#> 2   10000       5137472    9057080            0.567          0.0320      0.0530               0.604
#> 3  100000      51361472   90561080            0.567          0.341       0.570                0.598
#> 4 1000000     513601472  905601080            0.567          5.75       10.3                  0.558

In this experiment, switching to list_shallow() cuts down slowness and memory consumption nearly by half.

[wlandau]

To implement this approach, we have to look at the branch and bud classes:

targets/R/class_branch.R

Lines 1 to 52 in d7c1454

	branch_init <- function(
	command = NULL,
	settings = NULL,
	cue = NULL,
	value = NULL,
	deps = character(0),
	child = character(0),
	index = integer(0)
	) {
	command <- command_clone(command)
	deps <- union(command$deps, deps)
	command$deps <- setdiff(deps, settings$dimensions)
	command$seed <- tar_seed_create(child)
	pedigree <- pedigree_new(settings$name, child, index)
	settings <- settings_clone(settings)
	settings$name <- child
	store <- settings_produce_store(settings)
	branch_new(
	command = command,
	settings = settings,
	cue = cue,
	value = value,
	metrics = NULL,
	store = store,
	subpipeline = NULL,
	pedigree = pedigree
	)
	}
	branch_new <- function(
	command = NULL,
	settings = NULL,
	cue = NULL,
	value = NULL,
	metrics = NULL,
	store = NULL,
	subpipeline = NULL,
	pedigree = NULL
	) {
	out <- new.env(parent = emptyenv(), hash = FALSE)
	out$command <- command
	out$settings <- settings
	out$cue <- cue
	out$value <- value
	out$metrics <- metrics
	out$store <- store
	out$subpipeline <- subpipeline
	out$pedigree <- pedigree
	enclass(out, branch_s3_class)
	}
	branch_s3_class <- c("tar_branch", "tar_builder", "tar_target")

targets/R/class_bud.R

Lines 1 to 35 in d7c1454

	bud_init <- function(
	settings = settings_init(),
	child = character(0),
	index = integer(0)
	) {
	parent <- settings$name
	command <- command_null
	settings <- settings_clone(settings)
	settings$name <- child
	bud_new(
	command = command,
	settings = settings,
	cue = NULL,
	value = NULL,
	pedigree = pedigree_new(parent, child, index)
	)
	}
	bud_new <- function(
	command = NULL,
	settings = NULL,
	cue = NULL,
	value = NULL,
	pedigree = NULL
	) {
	out <- new.env(parent = emptyenv(), hash = FALSE)
	out$command <- command
	out$settings <- settings
	out$cue <- cue
	out$value <- value
	out$pedigree <- pedigree
	enclass(out, bud_s3_class)
	}
	bud_s3_class <- c("tar_bud", "tar_target")

Proposed changes:

• Store the name, deps, seed at the top level of the target.
• Remove deps and seed from their original nested objects. (settings can still keep its name to refer to the parent target.)
• use top-level name for target name
• use settings$name for the parent name
• Remove the pedigree class
• remove the index field from the junction class
• Remove the command and cue objects from the bud class.
• Do not clone the command object
• Do not clone the settings object.
• Put file at the top level as well. I am putting this one as a separate list item because it is much harder to move than the rest.
• do not clone the store object.
• remove placeholders that are just NULL anyway when the branch/bud is created.
• Update https://github.com/ropensci-books/targets-design with the refactor.

[wlandau]

Also:

• consider a more efficient junction structure which does not require a transpose

[wlandau]

Just tested c53ac0d on this pipeline:

library(targets)
if (tar_active()) {
  autometric::log_start("log.txt")
}
list(
  tar_target(x1, seq_len(1e3L)),
  tar_target(x2, seq_len(4L)),
  tar_target(x3, seq_len(4L)),
  tar_target(y, x1 + x2 + x3, pattern = cross(x1, x2, x3)),
  tar_target(z, y, pattern = map(y))
)

No noticeable speed difference, and the reduction in memory consumption was only about 42 MB (666.47 vs 623.76). But if we avoid cloning the store object, maybe we can do better.

[wlandau]

After 6ae4c98, the same test reached a max of 603 MB. The memory savings were not that impressive, but defining branches is much faster now. And the refactor clears the way for other improvements I have in mind.

[wlandau]

Got most of this done as of 7478056. Will open a separate thread to continue optimizing.