Failures with dplyr update

[krlmlr]

CRAN is seeing a segfault with the current release candidate of dplyr (in tidyverse/dplyr#3060), but we're unable to replicate it:

Package: PKNCA crashed in

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

   Traceback:
    1: .Call(`_dplyr_bind_rows_`, dots, id)
    2: bind_rows_(x, .id)
    3: dplyr::bind_rows(tmp.results)
...

on Debian during revdepo checks...

Could you please take a look? Install with devtools::install("tidyverse/dplyr#3060") .

CC @hadley.

[billdenney]

I can't replicate a segfault on my system. Can you give more context to the error (does it give a row number in a file)?

I use bind_rows in two main places within PKNCA. Guessing, the one that is more likely to be sensitive is here: https://github.com/billdenney/pknca/blob/075644b33ac020524b9f5825b7fb0c7062f5bfcf/R/pk.calc.all.R#L60

tmp.results is a list that can have a mixture of data.frames with rows, data.frames without rows, and NULL. All the data.frames with rows have the same column names. The data.frames with zero rows may either have names or be totally empty. The data.frames (with or without rows) may have additional attributes added to them as well (e.g. attr(foo, "bar") <- "baz").

[krlmlr]

Thanks. Does the input depend on unstable external conditions, such as internet connectivity?

[krlmlr]

The error message I posted is all I've got.

[billdenney]

The input should be fully deterministic; there are no tests that require anything beyond the current computer (no internet connectivity).

The only (marginally) non-deterministic input is related to random number generation, but the seed is set at the beginning, so that should only change if the way that R generates random numbers changes.

[krlmlr]

I tried various combinations of bind_rows() with and without rows and NULL to no avail, but not yet in the UBSAN version.

A traceback just came in:

  Traceback:
   1: .Call(`_dplyr_bind_rows_`, dots, id)
   2: bind_rows_(x, .id)
   3: dplyr::bind_rows(tmp.results)
   4: superposition.PKNCAconc(my.conc, tau = 24)
   5: superposition(my.conc, tau = 24)
   6: eval(expr, envir, enclos)
   7: eval(expr, envir, enclos)
   8: withVisible(eval(expr, envir, enclos))
   9: withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning =
wHandler,     error = eHandler, message = mHandler)
  10: doTryCatch(return(expr), name, parentenv, handler)
  11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  12: tryCatchList(expr, classes, parentenv, handlers)
  13: tryCatch(expr, error = function(e) {    call <- conditionCall(e)   if
(!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))
call <- sys.call(-4L)        dcall <- deparse(call)[1L]        prefix <-
paste("Error in", dcall, ": ") LONG <- 75L        sm <-
strsplit(conditionMessage(e), "\n")[[1L]]  w <- 14L + nchar(dcall, type =
"w") + nchar(sm[1L], type = "w") if (is.na(w))             w <- 14L +
nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")
if (w > LONG)   prefix <- paste0(prefix, "\n  ")    }    else prefix <-
"Error : " msg <- paste0(prefix, conditionMessage(e), "\n")
.Internal(seterrmessage(msg[1L]))    if (!silent &&
identical(getOption("show.error.messages"),         TRUE)) { cat(msg, file =
outFile)        .Internal(printDeferredWarnings())    }
invisible(structure(msg, class = "try-error", condition = e))})
  14: try(f, silent = TRUE)
  15: handle(ev <- withCallingHandlers(withVisible(eval(expr, envir,
enclos)), warning = wHandler, error = eHandler, message = mHandler))
  16: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval(expr,
envir, enclos)), warning = wHandler, error = eHandler, message = mHandler)))
  17: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos,
debug = debug, last = i == length(out), use_try = stop_on_error !=
2L, keep_warning = keep_warning, keep_message = keep_message,
output_handler = output_handler, include_timing = include_timing)
  18: evaluate(code, envir = env, new_device = FALSE, keep_warning =
!isFALSE(options$warning),     keep_message = !isFALSE(options$message),
stop_on_error = if (options$error &&         options$include) 0L else 2L,
output_handler = knit_handlers(options$render,         options))
  19: in_dir(input_dir(), evaluate(code, envir = env, new_device = FALSE,
keep_warning = !isFALSE(options$warning), keep_message =
!isFALSE(options$message),     stop_on_error = if (options$error &&
options$include) 0L else 2L,     output_handler =
knit_handlers(options$render, options)))
  20: block_exec(params)
  21: call_block(x)
  22: process_group.block(group)
  23: process_group(group)
  24: withCallingHandlers(if (tangle) process_tangle(group) else
process_group(group),     error = function(e) {        setwd(wd) cat(res,
sep = "\n", file = output %n% "")        message("Quitting from lines ",
paste(current_lines(i),             collapse = "-"), " (",
knit_concord$get("infile"),             ") ")    })
  25: process_file(text, output)
  26: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet,
encoding = encoding)
  27: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir =
globalenv())
  28: vweave_rmarkdown(...)
  29: engine$weave(file, quiet = quiet, encoding = enc)
  30: doTryCatch(return(expr), name, parentenv, handler)
  31: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  32: tryCatchList(expr, classes, parentenv, handlers)
  33: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)
setwd(startdir)    find_vignette_product(name, by = "weave", engine =
engine)}, error = function(e) {    stop(gettextf("processing vignette '%s'
failed with diagnostics:\n%s",         file, conditionMessage(e)), domain =
NA, call. = FALSE)})
  34: buildVignettes(dir =
"/home/hornik/tmp/CRAN/PKNCA.Rcheck/vign_test/PKNCA")
  An irrecoverable exception occurred. R is aborting now ...
  Segmentation fault

Please let me know if you have any further insights.

[krlmlr]

Just checked with UBSAN again, no dice.

[billdenney]

It looks like you have gone ahead and merged the pull request into the current dplyr master branch, so I just tested with that (devtools::install_github("tidyverse/dplyr")).

The traceback is very helpful because it points to the superposition vignette.

I now can get an error (though not a segfault) with:

> my.conc <- PKNCAconc(as.data.frame(datasets::Theoph), conc~Time|Subject)
> steady.state <- superposition(my.conc, tau=24)
Error in bind_rows_(x, .id) : 'getCharCE' must be called on a CHARSXP
In addition: Warning message:
In parallel::mclapply(X = seq_along(tmp.data), FUN = function(x,  :
  all scheduled cores encountered errors in user code

It appears to be (ahem) unintended behavior in the vignette where it runs bind_rows on a list of try-errors (the errors are intentional, but they should be raised rather than put into a list). I can replicate the bind_rows error above with the following:

> tmp <- try({stop("failed")})
> bind_rows(list(tmp, tmp))
Error in bind_rows_(x, .id) : 'getCharCE' must be called on a CHARSXP

I'm not sure if that's the reason for the segfault, but it does indicate some additional input checking should be done with bind_rows.

[krlmlr]

Awesome, thanks! I can replicate the problem now, will open a new issue if necessary.