Error(s) in re-building vignettes:
--- re-building ‘fme_theory.Rmd’ using rmarkdown
--- finished re-building ‘fme_theory.Rmd’

Warning: elapsed-time limit of 1 hours reached for sub-process
--- re-building ‘fmeffects.Rmd’ using rmarkdown


 *** caught segfault ***
address (nil), cause 'memory not mapped'

Traceback:
 1: rangerCpp(treetype, x, y, forest$independent.variable.names,     mtry, num.trees, verbose, seed, num.threads, write.forest,     importance, min.node.size, min.bucket, split.select.weights,     use.split.select.weights, always.split.variables, use.always.split.variables,     prediction.mode, forest, snp.data, replace, probability,     unordered.factor.variables, use.unordered.factor.variables,     save.memory, splitrule, case.weights, use.case.weights, class.weights,     predict.all, keep.inbag, sample.fraction, alpha, minprop,     poisson.tau, holdout, prediction.type, num.random.splits,     sparse.x, use.sparse.data, order.snps, oob.error, max.depth,     inbag, use.inbag, regularization.factor, use.regularization.factor,     regularization.usedepth, node.stats, time.interest, use.time.interest,     any.na)
 2: predict.ranger.forest(forest, data, predict.all, num.trees, type,     se.method, seed, num.threads, verbose, object$inbag.counts,     ...)
 3: predict(forest, data, predict.all, num.trees, type, se.method,     seed, num.threads, verbose, object$inbag.counts, ...)
 4: predict.ranger(self$model, data = newdata, type = self$predict_type,     quantiles = private$.quantiles, num.threads = 1L)
 5: predict(self$model, data = newdata, type = self$predict_type,     quantiles = private$.quantiles, num.threads = 1L)
 6: eval(expr, p)
 7: eval(expr, p)
 8: eval.parent(expr, n = 1L)
 9: invoke(predict, self$model, data = newdata, type = self$predict_type,     quantiles = private$.quantiles, .args = pv)
10: .__LearnerRegrRanger__.predict(self = self, private = private,     super = super, task = task)
11: get_private(learner)$.predict(task)
12: .f(task = <environment>, learner = <environment>)
13: eval(expr, p)
14: eval(expr, p)
15: eval.parent(expr, n = 1L)
16: invoke(.f, .args = .args, .opts = .opts, .seed = .seed, .timeout = .timeout)
17: encapsulate(learner$encapsulation["predict"], .f = predict_wrapper,     .args = list(task = task, learner = learner), .pkgs = learner$packages,     .seed = NA_integer_, .timeout = learner$timeout["predict"])
18: learner_predict(self, task, row_ids)
19: .__Learner__predict(self = self, private = private, super = super,     task = task, row_ids = row_ids)
20: self$predict(task)
21: .__Learner__predict_newdata(self = self, private = private, super = super,     newdata = newdata, task = task)
22: self$model$predict_newdata(newdata)
23: as.data.table(self$model$predict_newdata(newdata))
24: predictor$predict(observation.t)
25: f(0/s + m)
26: simpson(prediction.s, subintervals)
27: private$nlmCompute(self$predictor, self$observation, self$feature,     self$step.size, self$nlm.intervals)
28: initialize(...)
29: NonLinearityMeasure$new(predictor, data[row_id, ], feature, step.size,     nlm.intervals)
30: nlm_id(.x)
31: ...furrr_fn(...)
32: .f(.x[[i]], ...)
33: .Primitive(".Call")(list(name = "map_impl", address = <pointer: 0x4a47c250>,     dll = list(name = "purrr", path = "/data/gannet/ripley/R/test-dev/purrr/libs/purrr.so",         dynamicLookup = FALSE, handle = <pointer: 0x4c2dc050>,         info = <pointer: 0x4c82cab0>, forceSymbols = FALSE),     numParameters = 6L), <environment>, "double", FALSE, 196L,     NULL, 190L)
34: call_with_cleanup(map_impl, environment(), .type, .progress,     n, names, i)
35: withCallingHandlers(expr, error = function(cnd) {    if (i == 0L) {    }    else {        message <- c(i = "In index: {i}.")        if (!is.null(names) && !is.na(names[[i]]) && names[[i]] !=             "") {            name <- names[[i]]            message <- c(message, i = "With name: {name}.")        }        else {            name <- NULL        }        cli::cli_abort(message, location = i, name = name, parent = cnd,             call = error_call, class = "purrr_error_indexed")    }})
36: with_indexed_errors(i = i, names = names, error_call = .purrr_error_call,     call_with_cleanup(map_impl, environment(), .type, .progress,         n, names, i))
37: map_("double", .x, .f, ..., .progress = .progress)
38: (function (.x, .f, ..., .progress = FALSE) {    map_("double", .x, .f, ..., .progress = .progress)})(.x = 1:196, .f = function (...) {    NULL    NULL    ...furrr_out <- ...furrr_fn(...)    ...furrr_out})
39: do.call(...furrr_map_fn, args)
40: eval(quote({    {        future_globals_max_size <- getOption("future.globals.maxSize")        if (!identical(future_globals_max_size, ...furrr_globals_max_size)) {            options(future.globals.maxSize = ...furrr_globals_max_size)            on.exit(options(future.globals.maxSize = future_globals_max_size),                 add = TRUE)        }        {            ...furrr_chunk_x <- ...furrr_chunk_args            NULL            NULL            ...furrr_fn_wrapper <- function(...) {                NULL                NULL                ...furrr_out <- ...furrr_fn(...)                ...furrr_out            }            args <- list(.x = ...furrr_chunk_x, .f = ...furrr_fn_wrapper)            args <- c(args, ...furrr_dots)            do.call(...furrr_map_fn, args)        }    }}), new.env())
41: eval(quote({    {        future_globals_max_size <- getOption("future.globals.maxSize")        if (!identical(future_globals_max_size, ...furrr_globals_max_size)) {            options(future.globals.maxSize = ...furrr_globals_max_size)            on.exit(options(future.globals.maxSize = future_globals_max_size),                 add = TRUE)        }        {            ...furrr_chunk_x <- ...furrr_chunk_args            NULL            NULL            ...furrr_fn_wrapper <- function(...) {                NULL                NULL                ...furrr_out <- ...furrr_fn(...)                ...furrr_out            }            args <- list(.x = ...furrr_chunk_x, .f = ...furrr_fn_wrapper)            args <- c(args, ...furrr_dots)            do.call(...furrr_map_fn, args)        }    }}), new.env())
42: eval(expr, p)
43: eval(expr, p)
44: eval.parent(substitute(eval(quote(expr), envir)))
45: local({    {        future_globals_max_size <- getOption("future.globals.maxSize")        if (!identical(future_globals_max_size, ...furrr_globals_max_size)) {            options(future.globals.maxSize = ...furrr_globals_max_size)            on.exit(options(future.globals.maxSize = future_globals_max_size),                 add = TRUE)        }        {            ...furrr_chunk_x <- ...furrr_chunk_args            NULL            NULL            ...furrr_fn_wrapper <- function(...) {                NULL                NULL                ...furrr_out <- ...furrr_fn(...)                ...furrr_out            }            args <- list(.x = ...furrr_chunk_x, .f = ...furrr_fn_wrapper)            args <- c(args, ...furrr_dots)            do.call(...furrr_map_fn, args)        }    }})
46: eval(expr, envir = globalenv())
47: eval(expr, envir = globalenv())
48: withVisible({    eval(expr, envir = globalenv())})
49: withCallingHandlers({    ...future.value <- withVisible({        eval(expr, envir = globalenv())    })    seed <- globalenv()[[".Random.seed"]]    FutureResult(value = ...future.value[["value"]], visible = ...future.value[["visible"]],         conditions = ...future.conditions, rng = !identical(seed,             ...future.rng), seed = seed, uuid = uuid, misuseGlobalEnv = if (checkGlobalenv)             list(added = diff_globalenv(...future.globalenv.names))        else NULL, misuseConnections = if (checkConnections)             diff_connections(get_connections(details = isTRUE(attr(checkConnections,                 "details", exact = TRUE))), ...future.connections)        else NULL, misuseDevices = if (checkDevices)             diff_devices(...future.devices, base::.Devices)        else NULL, misuseDefaultDevice = ...future.option.defaultDevice,         started = ...future.startTime)}, condition = onEvalCondition)
50: tryCatchList(expr, classes, parentenv, handlers)
51: tryCatch({    withCallingHandlers({        ...future.value <- withVisible({            eval(expr, envir = globalenv())        })        seed <- globalenv()[[".Random.seed"]]        FutureResult(value = ...future.value[["value"]], visible = ...future.value[["visible"]],             conditions = ...future.conditions, rng = !identical(seed,                 ...future.rng), seed = seed, uuid = uuid, misuseGlobalEnv = if (checkGlobalenv)                 list(added = diff_globalenv(...future.globalenv.names))            else NULL, misuseConnections = if (checkConnections)                 diff_connections(get_connections(details = isTRUE(attr(checkConnections,                   "details", exact = TRUE))), ...future.connections)            else NULL, misuseDevices = if (checkDevices)                 diff_devices(...future.devices, base::.Devices)            else NULL, misuseDefaultDevice = ...future.option.defaultDevice,             started = ...future.startTime)    }, condition = onEvalCondition)}, finally = {    setTimeLimit(cpu = Inf, elapsed = Inf, transient = FALSE)})
52: doTryCatch(return(expr), name, parentenv, handler)
53: tryCatchOne(expr, names, parentenv, handlers[[1L]])
54: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
55: doTryCatch(return(expr), name, parentenv, handler)
56: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),     names[nh], parentenv, handlers[[nh]])
57: tryCatchList(expr, classes, parentenv, handlers)
58: tryCatch({    tryCatch({        withCallingHandlers({            ...future.value <- withVisible({                eval(expr, envir = globalenv())            })            seed <- globalenv()[[".Random.seed"]]            FutureResult(value = ...future.value[["value"]],                 visible = ...future.value[["visible"]], conditions = ...future.conditions,                 rng = !identical(seed, ...future.rng), seed = seed,                 uuid = uuid, misuseGlobalEnv = if (checkGlobalenv)                   list(added = diff_globalenv(...future.globalenv.names))                else NULL, misuseConnections = if (checkConnections)                   diff_connections(get_connections(details = isTRUE(attr(checkConnections,                     "details", exact = TRUE))), ...future.connections)                else NULL, misuseDevices = if (checkDevices)                   diff_devices(...future.devices, base::.Devices)                else NULL, misuseDefaultDevice = ...future.option.defaultDevice,                 started = ...future.startTime)        }, condition = onEvalCondition)    }, finally = {        setTimeLimit(cpu = Inf, elapsed = Inf, transient = FALSE)    })}, interrupt = onEvalErrorOrInterrupt, error = onEvalErrorOrInterrupt)
59: evalFutureInternal(data)
60: doTryCatch(return(expr), name, parentenv, handler)
61: tryCatchOne(expr, names, parentenv, handlers[[1L]])
62: tryCatchList(expr, classes, parentenv, handlers)
63: tryCatch({    evalFutureInternal(data)}, error = function(ex) {    msg <- sprintf("future::evalFuture() failed on %s (pid %s) at %s",         Sys.info()[["nodename"]], Sys.getpid(), format(Sys.time(),             "%FT%T"))    if (!requireNamespace("future")) {        msg <- sprintf("%s. Package 'future' is not available (worker library path: %s)",             msg, paste(sQuote(.libPaths()), collapse = ", "))    }    else {        ns <- getNamespace("future")        if (!exists("evalFutureInternal", mode = "function",             envir = ns, inherits = FALSE)) {            msg <- sprintf("%s. Package 'future' version %s is too old. Please update and retry",                 msg, packageVersion("future"))        }        else {            msg <- sprintf("%s. Using package 'future' v%s",                 msg, packageVersion("future"))        }    }    msg <- sprintf("%s. Possible other reasons: %s", msg, conditionMessage(ex))    ex <- simpleError(msg)    class(ex) <- c("FutureLaunchError", "FutureError", class(ex))    ex})
64: evalFuture(data)
65: launchFuture.SequentialFutureBackend(backend, future = future)
66: launchFuture(backend, future = future)
67: doTryCatch(return(expr), name, parentenv, handler)
68: tryCatchOne(expr, names, parentenv, handlers[[1L]])
69: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
70: doTryCatch(return(expr), name, parentenv, handler)
71: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),     names[nh], parentenv, handlers[[nh]])
72: tryCatchList(expr, classes, parentenv, handlers)
73: tryCatch(launchFuture(backend, future = future), FutureError = function(ex) {    stop(ex)}, error = function(ex) {    msg <- conditionMessage(ex)    label <- sQuoteLabel(future)    msg <- sprintf("Caught an unexpected error of class %s when trying to launch future (%s) on backend of class %s. The reason was: %s",         class(ex)[1], label, class(backend)[1], msg)    stop(FutureLaunchError(msg, future = future))})
74: run.Future(future)
75: run(future)
76: future::future(expr, substitute = FALSE, envir = env_globals,     stdout = options$stdout, conditions = options$conditions,     globals = chunk_globals, packages = chunk_packages, seed = options$seed,     label = labels[[i]])
77: furrr_template(args = x, fn = fn, dots = dots, n = n, options = options,     progress = progress, type = type, map_fn = map_fn, names = names,     env_globals = env_globals, expr = expr, extract = furrr_map_extract)
78: furrr_map_template(x = .x, fn = .f, dots = list(...), options = .options,     progress = .progress, type = "double", map_fn = purrr::map_dbl,     env_globals = .env_globals)
79: furrr::future_map_dbl(ids, ~{    furrr::furrr_options(globals = list(predictor = predictor,         data = data, feature = feature, step.size = step.size,         nlm.intervals = nlm.intervals), packages = c("fmeffects"))    utils::setTxtProgressBar(pb, .x)    nlm_id(.x)})
80: private$fme(self$feature, self$predictor, self$data.step, self$step.size,     self$step.type, self$extrapolation.ids, self$compute.nlm,     self$nlm.intervals)
81: ForwardMarginalEffect$new(makePredictor(model, data), features = features,     ep.method = ep.method, compute.nlm = compute.nlm, nlm.intervals = nlm.intervals)$compute()
82: fme(model = forest, data = bikes[1:200, ], features = list(temp = -3,     humidity = -0.1), ep.method = "envelope", compute.nlm = TRUE)
83: eval(expr, envir)
84: eval(expr, envir)
85: withVisible(eval(expr, envir))
86: withCallingHandlers(code, message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
87: eval(call)
88: eval(call)
89: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
90: doWithOneRestart(return(expr), restart)
91: withOneRestart(expr, restarts[[1L]])
92: withRestartList(expr, restarts[-nr])
93: doWithOneRestart(return(expr), restart)
94: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
95: withRestartList(expr, restarts)
96: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
97: evaluate::evaluate(...)
98: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
99: in_dir(input_dir(), expr)
100: in_input_dir(evaluate(code, envir = env, new_device = FALSE,     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
101: eng_r(options)
102: block_exec(params)
103: call_block(x)
104: process_group(group)
105: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (xfun::pkg_available("rlang", "1.0.0")) {            if (is_R_CMD_build() || is_R_CMD_check()) {                cnd = tryCatch(rlang::entrace(e), error = identity)                error <<- format(cnd)            }            else {                rlang::entrace(e)            }        }    })
106: xfun:::handle_error(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (xfun::pkg_available("rlang", "1.0.0")) {            if (is_R_CMD_build() || is_R_CMD_check()) {                cnd = tryCatch(rlang::entrace(e), error = identity)                error <<- format(cnd)            }            else {                rlang::entrace(e)            }        }    }), function(loc) {    setwd(wd)    write_utf8(res, output %n% stdout())    paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
107: process_file(text, output)
108: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
109: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
110: vweave_rmarkdown(...)
111: engine$weave(file, quiet = quiet, encoding = enc)
112: doTryCatch(return(expr), name, parentenv, handler)
113: tryCatchOne(expr, names, parentenv, handlers[[1L]])
114: tryCatchList(expr, classes, parentenv, handlers)
115: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)    if (!have.makefile && vignette_is_tex(output)) {        texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
116: tools:::.buildOneVignette("fmeffects.Rmd", "/data/gannet/ripley/R/packages/tests-devel/fmeffects.Rcheck/vign_test/fmeffects",     TRUE, FALSE, "fmeffects", "UTF-8", "/tmp/Rtmpl9AFhS/working_dir/RtmpJLYkuX/file5b0f06717455a.rds")
An irrecoverable exception occurred. R is aborting now ...
SUMMARY: processing the following file failed:
  ‘fmeffects.Rmd’

Error: Vignette re-building failed.
Execution halted