use parallelly

Author: philchalmers

DESCRIPTION

@@ -24,6 +24,7 @@ Imports:
     methods,
     testthat,
     parallel,
+    parallelly,
     snow,
     dplyr,
     sessioninfo,

NAMESPACE

@@ -81,6 +81,7 @@ importFrom(dplyr,mutate)
 importFrom(dplyr,select)
 importFrom(future.apply,future_lapply)
 importFrom(graphics,abline)
+importFrom(parallelly,availableCores)
 importFrom(pbapply,pblapply)
 importFrom(pbapply,pboptions)
 importFrom(progressr,progressor)

R/SimDesign.R

@@ -25,6 +25,7 @@
 #' @author Phil Chalmers \email{rphilip.chalmers@@gmail.com}
 #' @import methods parallel stats
 #' @importFrom sessioninfo session_info
+#' @importFrom parallelly availableCores
 #' @importFrom RPushbullet pbPost
 #' @importFrom graphics abline
 #' @importFrom R.utils withTimeout

R/SimSolve.R

@@ -464,15 +464,14 @@ SimSolve <- function(design, interval, b, generate, analyse, summarise,
                      integer = TRUE, formula = y ~ poly(x, 2), family = 'binomial',
                      parallel = FALSE, cl = NULL, save = TRUE, resume = TRUE,
                      method = 'ProBABLI', wait.time = NULL,
-                     ncores = parallel::detectCores() - 1L,
+                     ncores = parallelly::availableCores() - 1L,
                      type = ifelse(.Platform$OS.type == 'windows', 'PSOCK', 'FORK'),
                      maxiter = 100L, check.interval = TRUE,
                      verbose = TRUE, control = list(),
                      predCI = .95, predCI.tol = NULL, ...){
 
     # robust <- FALSE
     org.opts <- options()
-    ncores <- check_ncores(ncores)
     options(warn = 1)
     on.exit(options(org.opts), add = TRUE)
     if(is.null(control$print_RAM)) control$print_RAM <- FALSE

R/runArraySimulation.R

@@ -296,11 +296,10 @@ runArraySimulation <- function(design, ..., replications,
                                filename_suffix = paste0("-", array2row(arrayID)),
                                addArrayInfo = TRUE,
                                parallel = FALSE, cl = NULL,
-                               ncores = parallel::detectCores() - 1L,
+                               ncores = parallelly::availableCores() - 1L,
                                save_details = list(),
                                control = list()){
     dots <- list(...)
-    ncores <- check_ncores(ncores)
     if(parallel && ncores == 1L) parallel <- FALSE
     if(!is.null(dots$save_results) && isTRUE(dots$save_results))
         stop('save_results not supported for array jobs. Please use store_results only')

R/runSimulation.R

@@ -978,14 +978,13 @@ runSimulation <- function(design, replications, generate, analyse, summarise,
                           fixed_objects = NULL, packages = NULL, filename = NULL,
                           debug = 'none', load_seed = NULL, save = any(replications > 2),
                           store_results = TRUE, save_results = FALSE,
-                          parallel = FALSE, ncores = parallel::detectCores() - 1L,
+                          parallel = FALSE, ncores = parallelly::availableCores() - 1L,
                           cl = NULL, notification = 'none', beep = FALSE, sound = 1,
                           CI = .95, seed = NULL, boot_method='none', boot_draws = 1000L,
                           max_errors = 50L, resume = TRUE, save_details = list(),
                           control = list(), progress = TRUE, verbose = TRUE)
 {
     stopifnot(!missing(analyse))
-    ncores <- check_ncores(ncores)
     if(length(control)){
         stopifnot("Argument(s) to control list invalid"=
                       all(names(control) %in% valid_control.list()))

R/util.R

@@ -25,12 +25,6 @@ get_packages <- function(packages){
     sapply(packages, function(x) as.character(packageVersion(x)))
 }
 
-check_ncores <- function(ncores){
-    ncores <- ifelse(is.na(ncores), 1L, ncores)
-    ncores <- ifelse(ncores < 1L, 1L, ncores)
-    ncores
-}
-
 # base-code borrowed and modified from pbapply
 timeFormater_internal <- function(time, decimals = TRUE){
     dec <- time - floor(time)

man/SimSolve.Rd

@@ -100,7 +100,7 @@ test_that('SimDesign', {
     expect_equal(nrow(out), nrow(Design) * 2)
 
     Final <- runSimulation(Design, generate=mysim, analyse=mycompute, summarise=mycollect,
-                           replications = parallel::detectCores(),
+                           replications = parallelly::availableCores(),
                            parallel=TRUE, ncores=2L, save=FALSE, verbose = FALSE)
     expect_is(Final, 'data.frame')
 
@@ -116,15 +116,15 @@ test_that('SimDesign', {
 
     #seeds
     Final <- runSimulation(Design, generate=mysim, analyse=mycompute, summarise=mycollect, seed = 1:8,
-                           replications = parallel::detectCores(),
+                           replications = parallelly::availableCores(),
                            parallel=TRUE, ncores=2L, save=FALSE, verbose = FALSE)
     Final2 <- runSimulation(Design, generate=mysim, analyse=mycompute, summarise=mycollect, seed = 1:8,
-                           replications = parallel::detectCores(),
+                           replications = parallelly::availableCores(),
                            parallel=TRUE, ncores=2L, save=FALSE, verbose = FALSE)
     Final <- runSimulation(Design, generate=mysim, analyse=mycompute, summarise=mycollect, seed = 1:8,
-                           replications = parallel::detectCores(), parallel=FALSE, save=FALSE, verbose = FALSE)
+                           replications = parallelly::availableCores(), parallel=FALSE, save=FALSE, verbose = FALSE)
     Final2 <- runSimulation(Design, generate=mysim, analyse=mycompute, summarise=mycollect, seed = 1:8,
-                            replications = parallel::detectCores(), parallel=FALSE, save=FALSE, verbose = FALSE)
+                            replications = parallelly::availableCores(), parallel=FALSE, save=FALSE, verbose = FALSE)
 
     mycompute <- function(condition, dat, fixed_objects){
 

man/runArraySimulation.Rd

@@ -49,7 +49,7 @@ To start, the structure of the simulation code used later on to distribute the j
 
 Suppose the following simulation was to be evaluated, though for time constraint reasons would not be possible to execute on a single computer (or a smaller network of computers) and therefore should be submitted to an HPC cluster. 
 
-The following script (hypothetically written in a file called `SimDesign_simulation.R`) contains a simulation experiment whose instructions are to be submitted to the Slurm scheduler. To do so, the `sbatch` utility is used along with the set of instructions specifying the type of hardware required in the file `slurmInstructions.slurm`. In the R side of the simulation, the defined code must grab all available cores (minus 1) that are detectable via `parallel::detectCores()`, which occurs automatically when using `runSimulation(..., parallel=TRUE)`. 
+The following script (hypothetically written in a file called `SimDesign_simulation.R`) contains a simulation experiment whose instructions are to be submitted to the Slurm scheduler. To do so, the `sbatch` utility is used along with the set of instructions specifying the type of hardware required in the file `slurmInstructions.slurm`. In the R side of the simulation, the defined code must grab all available cores (minus 1) that are detectable via `parallelly::availableCores()`, which occurs automatically when using `runSimulation(..., parallel=TRUE)`. 
 ```{r}
 # SimDesign::SimFunctions()
 library(SimDesign)

man/runSimulation.Rd

@@ -35,7 +35,7 @@ The logic presented within this document is based on the notion that the front-e
 
 ## Local parallel computing 
 
-By default, `SimDesign`'s `runSimulation()` function is executed with only a single core. However, setting the argument `runSimulation(..., parallel = TRUE)` will automatically define a cluster object using one core less than the system has available (detect via `parallel::detectCores()`). This allows a straightforward way to construct a suitable, locally supported cluster object for parallel processing on just the active computer. Depending on the `verbose` and `progress` flags, the progress of each distributed replication will also be printed to the console to indicate the amount of estimated time remaining for the selection simulation condition to complete. This process is then repeated again for each condition in the supplied `design` object until all rows have been evaluated. 
+By default, `SimDesign`'s `runSimulation()` function is executed with only a single core. However, setting the argument `runSimulation(..., parallel = TRUE)` will automatically define a cluster object using one core less than the system has available (detect via `parallelly::availableCores()`). This allows a straightforward way to construct a suitable, locally supported cluster object for parallel processing on just the active computer. Depending on the `verbose` and `progress` flags, the progress of each distributed replication will also be printed to the console to indicate the amount of estimated time remaining for the selection simulation condition to complete. This process is then repeated again for each condition in the supplied `design` object until all rows have been evaluated. 
 
 This setup is the most painless way to construct and distribute the independent replications per condition, where within each evaluated condition (i.e., each row of the `design` object) high-quality random numbers are automatically used via Pierre L'Ecuyer's (1999) multiple streams method, limited only by the number of cores that are available. Alternatively, though with a bit of extra effort, users may also define their own cluster computing object by way of the `runSimulation(..., cl)` object, which can be used to link computing resources that are able to communicate via `ssh`, thereby expanding the number of available computing cores detected by `parallel::detectCores()` and friends.