keep_busy <- function(n = 1e3) {
  r <- rnorm(n)
  p <- pnorm(r)
  q <- qnorm(p)
  o <- order(q)
}
bench::mark(parallel::mclapply(seq_len(1e3), keep_busy))
#> Error in parse(text = trace): <text>:1:158: unexpected symbol
#> 1: c("rnorm", "FUN", "lapply", "doTryCatch", "tryCatchOne", "tryCatchList", "tryCatch", "try", "sendMaster", "FUN", "lapply", "<Anonymous>", "eval", "eval", " "tryCatchOne
#>                                                                                                                                                                  ^

bench::mark(parallel::parLapply(seq_len(1e3), keep_busy,
                                cl = parallel::makeCluster(3)))
#> # A tibble: 1 x 6
#> # … with 6 more variables: expression <bch:expr>, min <bch:tm>,
#> #   median <bch:tm>, `itr/sec` <dbl>, mem_alloc <bch:byt>, `gc/sec` <dbl>

library(foreach)
library(doParallel); registerDoParallel(cores = 3)
#> Loading required package: iterators
#> Loading required package: parallel
bench::mark({foreach(x = seq_len(1e3)) %dopar% keep_busy})
#> Error in parse(text = trace): <text>:1:255: unexpected symbol
#> 1: lize", "sendMaster", "FUN", "lapply", "mclapply", "<Anonymous>", "%dopar%", "eval", "eval", "eval_one", "<Anonymous>", "eval", "eval", "withVisible", "withCallingHandlers", "doTryCatch", "tryC
#>                                                                                                                                                                                                                                                                   ^

future::plan("multicore")
bench::mark(future.apply::future_lapply(seq_len(1e3), keep_busy))
#> # A tibble: 1 x 6
#>   expression                                              min median
#>   <bch:expr>                                            <bch> <bch:>
#> 1 future.apply::future_lapply(seq_len(1000), keep_busy) 107ms  107ms
#> # … with 3 more variables: `itr/sec` <dbl>, mem_alloc <bch:byt>,
#> #   `gc/sec` <dbl>

future::plan("multisession")
bench::mark(future.apply::future_lapply(seq_len(1e3), keep_busy))
#> Warning: Some expressions had a GC in every iteration; so filtering is
#> disabled.
#> # A tibble: 1 x 6
#>   expression                                              min median
#>   <bch:expr>                                            <bch> <bch:>
#> 1 future.apply::future_lapply(seq_len(1000), keep_busy) 552ms  552ms
#> # … with 3 more variables: `itr/sec` <dbl>, mem_alloc <bch:byt>,
#> #   `gc/sec` <dbl>

future::plan("sequential")
bench::mark(future.apply::future_lapply(seq_len(1e3), keep_busy))
#> # A tibble: 1 x 6
#>   expression                                              min median
#>   <bch:expr>                                            <bch> <bch:>
#> 1 future.apply::future_lapply(seq_len(1000), keep_busy) 113ms  113ms
#> # … with 3 more variables: `itr/sec` <dbl>, mem_alloc <bch:byt>,
#> #   `gc/sec` <dbl>

> p <- profmem::profmem({ x <- integer(1e4); y <- foo(1e6) })
> p
Rprofmem memory profiling of:
{
    x <- integer(10000)
    y <- foo(1e+06)
}

Memory allocations:
       what   bytes              calls
1     alloc   40048          integer()
2     alloc 4000048 foo() -> integer()
total       4040096                   
> str(p)
Classes 'Rprofmem' and 'data.frame':	2 obs. of  3 variables:
 $ what : chr  "alloc" "alloc"
 $ bytes: num  4e+04 4e+06
 $ trace:List of 2
  ..$ : chr "integer"
  ..$ : chr  "integer" "foo"
 - attr(*, "threshold")= int 0
 - attr(*, "expression")= language {  x <- integer(10000); y <- foo(1e+06) }
  ..- attr(*, "srcref")=List of 3
  .. ..$ : 'srcref' int  1 23 1 23 23 23 1 1
  .. .. ..- attr(*, "srcfile")=Classes 'srcfilecopy', 'srcfile' <environment: 0x556b805fa4e0> 
  .. ..$ : 'srcref' int  1 25 1 41 25 41 1 1
  .. .. ..- attr(*, "srcfile")=Classes 'srcfilecopy', 'srcfile' <environment: 0x556b805fa4e0> 
  .. ..$ : 'srcref' int  1 44 1 56 44 56 1 1
  .. .. ..- attr(*, "srcfile")=Classes 'srcfilecopy', 'srcfile' <environment: 0x556b805fa4e0> 
  ..- attr(*, "srcfile")=Classes 'srcfilecopy', 'srcfile' <environment: 0x556b805fa4e0> 
  ..- attr(*, "wholeSrcref")= 'srcref' int  1 0 1 58 0 58 1 1
  .. ..- attr(*, "srcfile")=Classes 'srcfilecopy', 'srcfile' <environment: 0x556b805fa4e0> 
 - attr(*, "value")= int  0 0 0 0 0 0 0 0 0 0 ...

> p <- profmem({
+     small <- (x < 5000)
+ })
> p
Rprofmem memory profiling of:
{
    small <- (x < 5000)
}
Memory allocations:
       bytes      calls
1      80040 <internal>
2      40040 <internal>
total 120080           

p <- profmem({
  expressions profiled
})

profmem_begin()
{
 expressions profiled 
}
p <- profmem_end()

> p <- profmem::profmem(log("a"))
> print(p)
Rprofmem memory profiling of:
log("a")
<environment: R_EmptyEnv>

Memory allocations:
      what bytes calls
total          0  

> attr(p, "error")
<simpleError in log("a"): non-numeric argument to mathematical function>

> capabilities("profmem")

p1 <- profmem({
  x <- 1:1000
  p2 <- profmem({
     y <- as.double(x)
  })
  z <- x * y
})

Memory allocations (>= 1000 bytes):
[...]

> p <- profmem::profmem({ y <- log("a") })
> p
Rprofmem memory profiling of:
{
    y <- log("a")
}

Memory allocations:
      what bytes calls
total          0

> p <- profmem::profmem({ y <- non.existing::foo() })
> p
Rprofmem memory profiling of:
{
    y <- non.existing::foo()
}

Memory allocations:
      what bytes calls
total          0

> p <- profmem::profmem({ stop("boom") })
> p
Rprofmem memory profiling of:
{
    stop("boom")
}

Memory allocations:
      what bytes calls
total          0      

p <- profvis::profvis(log("a"), errors = "ignore")  ## the default

p <- profvis::profvis(log("a"), errors = "warn")
Warning: profvis() detected a run-time error: 
Error in log("a") : non-numeric argument to mathematical function

p <- profvis::profvis(log("a"), errors = "error")
Error in log("a") : non-numeric argument to mathematical function

> R.utils::withCapture(list(a=5000, b=5000L))
> list(a = 5000, b = 5000L)
$a
[1] 5000
$b
[1] 5000

> list(a = 5000, b = 5000L)
$a
[1] 5000
$b
[1] 5000
> 5000
[1] 5000
> 5000L
[1] 5000