R Under development (unstable) (2024-12-17 r87446 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2024 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

> source("incl/start.R")
> 
> is_fqdn <- parallelly:::is_fqdn
> is_ip_number <- parallelly:::is_ip_number
> is_localhost <- parallelly:::is_localhost
> find_rshcmd <- parallelly:::find_rshcmd
> 
> message("*** makeClusterPSOCK() ...")
*** makeClusterPSOCK() ...
> 
> message("- makeClusterPSOCK() - internal utility functions")
- makeClusterPSOCK() - internal utility functions
> 
> stopifnot(
+    is_fqdn("a.b"),
+    is_fqdn("a.b.c"),
+   !is_fqdn("a")
+ )
> 
> stopifnot(
+    is_ip_number("1.2.3.4"),
+   !is_ip_number("a"),
+   !is_ip_number("1.2.3"),
+   !is_ip_number("1.2.3.256"),
+   !is_ip_number("1.2.3.-1"),
+   !is_ip_number("1.2.3.a")
+ )
> 
> ## Reset internal cache
> stopifnot(is.na(is_localhost(worker = NULL, hostname = NULL)))
> stopifnot(
+    is_localhost("localhost"),
+    is_localhost("127.0.0.1"),
+    is_localhost(Sys.info()[["nodename"]]),
+    is_localhost(Sys.info()[["nodename"]]), ## cache hit
+   !is_localhost("not.a.localhost.hostname")
+ )
> 
> cmd <- find_rshcmd(must_work = FALSE)
> print(cmd)
$ssh
                              ssh 
"d:\\rtools44\\usr\\bin\\ssh.exe" 
attr(,"type")
[1] "ssh"
attr(,"version")
[1] "OpenSSH_9.9p1, OpenSSL 3.3.2 3 Sep 2024"

$`putty-plink`
                           plink                                  
"C:\\PROGRA~1\\PuTTY\\plink.exe"                           "-ssh" 
attr(,"type")
[1] "putty-plink"
attr(,"version")
[1] "plink: Release 0.81; Build platform: 64-bit x86 Windows; Compiler: clang 14.0.0 , emulating Visual Studio 2022 (17.2), _MSC_VER=1932, _MSC_FULL_VER=193231329; Source commit: a8601a72a918dfc2a8e8536a77139d7f37700044"

> 
> 
> message("- makeClusterPSOCK()")
- makeClusterPSOCK()
> 
> cl <- makeClusterPSOCK("<a-non-existing-hostname>", user = "johndoe", master = NULL, revtunnel = FALSE, rshcmd = "my_ssh", renice = TRUE, manual = TRUE, dryrun = TRUE)
[18:32:45.266] [local output] makeClusterPSOCK() ...
[18:32:45.331] [local output] Workers: [n = 1] '<a-non-existing-hostname>'
[18:32:45.342] [local output] Base port: 28368
[18:32:45.342] [local output] Getting setup options for 1 cluster nodes ...
[18:32:45.342] [local output]  - Node #1 of 1 ...
[18:32:45.346] [local output] Rscript port: 28368

[18:32:45.346] [local output] Using 'rshcmd': 'my_ssh' [type='<unknown>', version='<unknown>']
[18:32:45.347] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:45.347] [local output] Creating node #1 of 1 ...
[18:32:45.347] [local output] - setting up node
[18:32:45.348] [local output] - attempt #1 of 3
----------------------------------------------------------------------
Manually, (i) login into external machine '<a-non-existing-hostname>':

  "my_ssh" -l johndoe <a-non-existing-hostname>

and (ii) start worker #1 from there:

  nice --adjustment=1 'D:/RCompile/recent/R/bin/x64/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN' -e 'options(socketOptions = "no-delay")' -e 'workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()' MASTER=CRANWIN3 PORT=28368 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=sequential

Alternatively, start worker #1 from the local machine by combining both steps in a single call:

  "my_ssh" -l johndoe <a-non-existing-hostname> "nice --adjustment=1 'D:/RCompile/recent/R/bin/x64/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN' -e 'options(socketOptions = \"no-delay\")' -e 'workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()' MASTER=CRANWIN3 PORT=28368 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=sequential"

[18:32:45.349] [local output] Creating node #1 of 1 ... done
[18:32:45.349] [local output] Launching of 1 workers completed
[18:32:45.349] [local output] Number of nodes in cluster: 1
[18:32:45.349] [local output] Collecting session information from 1 workers
[18:32:45.350] [local output]  - Worker #1 of 1
[18:32:45.350] [local output] makeClusterPSOCK() ... done
> print(cl)
Socket cluster with 1 nodes where 1 node is on host 'NA' (R version and platform not queried)
> 
> cl <- makeClusterPSOCK(1L, port = "random", dryrun = TRUE)
[18:32:45.355] [local output] makeClusterPSOCK() ...
[18:32:45.366] [local output] Workers: [n = 1] 'localhost'
[18:32:45.372] [local output] Base port: 27706
[18:32:45.372] [local output] Getting setup options for 1 cluster nodes ...
[18:32:45.373] [local output]  - Node #1 of 1 ...
[18:32:45.374] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:45.376] [local output] Rscript port: 27706

[18:32:45.377] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:45.377] [local output] Creating node #1 of 1 ...
[18:32:45.377] [local output] - setting up node
[18:32:45.377] [local output] - attempt #1 of 3
----------------------------------------------------------------------
Manually, start worker #1 on local machine 'localhost' with:

  "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=27706 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=sequential

[18:32:45.378] [local output] Creating node #1 of 1 ... done
[18:32:45.378] [local output] Launching of 1 workers completed
[18:32:45.379] [local output] Number of nodes in cluster: 1
[18:32:45.379] [local output] Collecting session information from 1 workers
[18:32:45.380] [local output]  - Worker #1 of 1
[18:32:45.380] [local output] makeClusterPSOCK() ... done
> print(cl)
Socket cluster with 1 nodes where 1 node is on host 'NA' (R version and platform not queried)
> 
> cl <- makeClusterPSOCK(1L)
[18:32:45.382] [local output] makeClusterPSOCK() ...
[18:32:45.389] [local output] Workers: [n = 1] 'localhost'
[18:32:45.396] [local output] Base port: 32589
[18:32:45.396] [local output] Getting setup options for 1 cluster nodes ...
[18:32:45.396] [local output]  - Node #1 of 1 ...
[18:32:45.398] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:45.401] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0559a5cf9.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0559a5cf9.pid\")"'
[18:32:45.952] - Possible to infer worker's PID: TRUE
[18:32:45.953] [local output] Rscript port: 32589

[18:32:45.954] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:45.954] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:45.955] [local output] Setting up PSOCK nodes in parallel
[18:32:45.956] List of 36
[18:32:45.956]  $ worker          : chr "localhost"
[18:32:45.956]   ..- attr(*, "localhost")= logi TRUE
[18:32:45.956]  $ master          : chr "localhost"
[18:32:45.956]  $ port            : int 32589
[18:32:45.956]  $ connectTimeout  : num 120
[18:32:45.956]  $ timeout         : num 120
[18:32:45.956]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:45.956]  $ homogeneous     : logi TRUE
[18:32:45.956]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:45.956]  $ rscript_envs    : NULL
[18:32:45.956]  $ rscript_libs    : NULL
[18:32:45.956]  $ rscript_startup : NULL
[18:32:45.956]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:45.956]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:45.956]  $ methods         : logi TRUE
[18:32:45.956]  $ socketOptions   : chr "no-delay"
[18:32:45.956]  $ useXDR          : logi FALSE
[18:32:45.956]  $ outfile         : chr "/dev/null"
[18:32:45.956]  $ renice          : int NA
[18:32:45.956]  $ rshcmd          : NULL
[18:32:45.956]  $ user            : chr(0) 
[18:32:45.956]  $ revtunnel       : logi FALSE
[18:32:45.956]  $ rshlogfile      : NULL
[18:32:45.956]  $ rshopts         : chr(0) 
[18:32:45.956]  $ rank            : int 1
[18:32:45.956]  $ manual          : logi FALSE
[18:32:45.956]  $ dryrun          : logi FALSE
[18:32:45.956]  $ quiet           : logi FALSE
[18:32:45.956]  $ setup_strategy  : chr "parallel"
[18:32:45.956]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:45.956]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0559a5cf9.pid"
[18:32:45.956]  $ rshcmd_label    : NULL
[18:32:45.956]  $ rsh_call        : NULL
[18:32:45.956]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:45.956]  $ localMachine    : logi TRUE
[18:32:45.956]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:45.956]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:45.956]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:45.956]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:45.956]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:45.956]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:45.956]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:45.956]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:45.956]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:45.956]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:45.956]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:45.956]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:45.956]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:45.956]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:45.956]  $ arguments       :List of 28
[18:32:45.956]   ..$ worker          : chr "localhost"
[18:32:45.956]   ..$ master          : NULL
[18:32:45.956]   ..$ port            : int 32589
[18:32:45.956]   ..$ connectTimeout  : num 120
[18:32:45.956]   ..$ timeout         : num 120
[18:32:45.956]   ..$ rscript         : NULL
[18:32:45.956]   ..$ homogeneous     : NULL
[18:32:45.956]   ..$ rscript_args    : NULL
[18:32:45.956]   ..$ rscript_envs    : NULL
[18:32:45.956]   ..$ rscript_libs    : NULL
[18:32:45.956]   ..$ rscript_startup : NULL
[18:32:45.956]   ..$ rscript_sh      : chr "auto"
[18:32:45.956]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:45.956]   ..$ methods         : logi TRUE
[18:32:45.956]   ..$ socketOptions   : chr "no-delay"
[18:32:45.956]   ..$ useXDR          : logi FALSE
[18:32:45.956]   ..$ outfile         : chr "/dev/null"
[18:32:45.956]   ..$ renice          : int NA
[18:32:45.956]   ..$ rshcmd          : NULL
[18:32:45.956]   ..$ user            : NULL
[18:32:45.956]   ..$ revtunnel       : logi NA
[18:32:45.956]   ..$ rshlogfile      : NULL
[18:32:45.956]   ..$ rshopts         : NULL
[18:32:45.956]   ..$ rank            : int 1
[18:32:45.956]   ..$ manual          : logi FALSE
[18:32:45.956]   ..$ dryrun          : logi FALSE
[18:32:45.956]   ..$ quiet           : logi FALSE
[18:32:45.956]   ..$ setup_strategy  : chr "parallel"
[18:32:45.956]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:45.997] [local output] System call to launch all workers:
[18:32:45.998] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0559a5cf9.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=32589 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:45.998] [local output] Starting PSOCK main server
[18:32:46.004] [local output] Workers launched
[18:32:46.004] [local output] Waiting for workers to connect back
[18:32:46.004]  - [local output] 0 workers out of 1 ready
[18:32:46.245]  - [local output] 0 workers out of 1 ready
[18:32:46.246]  - [local output] 1 workers out of 1 ready
[18:32:46.246] [local output] Launching of 1 workers completed
[18:32:46.246] [local output] Number of nodes in cluster: 1
[18:32:46.247] [local output] Collecting session information from 1 workers
[18:32:46.248] [local output]  - Worker #1 of 1
[18:32:46.248] [local output] makeClusterPSOCK() ... done
> print(cl)
Socket cluster with 1 nodes where 1 node is on host 'localhost' (R Under development (unstable) (2024-12-17 r87446 ucrt), platform x86_64-w64-mingw32)
> node <- cl[[1]]
> utils::str(node)
List of 4
 $ con         : 'sockconn' int 4
  ..- attr(*, "conn_id")=<externalptr> 
 $ host        : chr "localhost"
  ..- attr(*, "localhost")= logi TRUE
 $ rank        : int 0
 $ session_info:List of 6
  ..$ r      :List of 16
  .. ..$ platform      : chr "x86_64-w64-mingw32"
  .. ..$ arch          : chr "x86_64"
  .. ..$ os            : chr "mingw32"
  .. ..$ crt           : chr "ucrt"
  .. ..$ system        : chr "x86_64, mingw32"
  .. ..$ status        : chr "Under development (unstable)"
  .. ..$ major         : chr "4"
  .. ..$ minor         : chr "5.0"
  .. ..$ year          : chr "2024"
  .. ..$ month         : chr "12"
  .. ..$ day           : chr "17"
  .. ..$ svn rev       : chr "87446"
  .. ..$ language      : chr "R"
  .. ..$ version.string: chr "R Under development (unstable) (2024-12-17 r87446 ucrt)"
  .. ..$ nickname      : chr "Unsuffered Consequences"
  .. ..$ os.type       : chr "windows"
  ..$ system :List of 9
  .. ..$ sysname       : chr "Windows"
  .. ..$ release       : chr "Server x64"
  .. ..$ version       : chr "build 20348"
  .. ..$ nodename      : chr "CRANWIN3"
  .. ..$ machine       : chr "x86-64"
  .. ..$ login         : chr "CRAN"
  .. ..$ user          : chr "CRAN"
  .. ..$ effective_user: chr "CRAN"
  .. ..$ udomain       : chr "CRANWIN3"
  ..$ libs   : chr [1:2] "D:/temp/2024_12_18_18_30_17_11197/RtmpAtndy0/RLIBS_164501709370a" "D:/RCompile/recent/R/library"
  ..$ pkgs   : NULL
  ..$ pwd    : chr "d:/RCompile/CRANincoming/R-devel/parallelly.Rcheck/tests"
  ..$ process:List of 1
  .. ..$ pid: int 195868
 - attr(*, "options")=List of 35
  ..$ worker          : chr "localhost"
  .. ..- attr(*, "localhost")= logi TRUE
  ..$ master          : chr "localhost"
  ..$ port            : int 32589
  ..$ connectTimeout  : num 120
  ..$ timeout         : num 120
  ..$ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
  ..$ homogeneous     : logi TRUE
  ..$ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
  ..$ rscript_envs    : NULL
  ..$ rscript_libs    : NULL
  ..$ rscript_startup : NULL
  ..$ rscript_sh      : chr [1:2] "cmd" "cmd"
  ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
  ..$ methods         : logi TRUE
  ..$ socketOptions   : chr "no-delay"
  ..$ useXDR          : logi FALSE
  ..$ outfile         : chr "/dev/null"
  ..$ renice          : int NA
  ..$ rshcmd          : NULL
  ..$ user            : chr(0) 
  ..$ revtunnel       : logi FALSE
  ..$ rshlogfile      : NULL
  ..$ rshopts         : chr(0) 
  ..$ rank            : int 0
  ..$ manual          : logi FALSE
  ..$ dryrun          : logi FALSE
  ..$ quiet           : logi FALSE
  ..$ setup_strategy  : chr "parallel"
  ..$ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
  ..$ rshcmd_label    : NULL
  ..$ rsh_call        : NULL
  ..$ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
  ..$ localMachine    : logi TRUE
  ..$ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
    master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
        2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
        30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
    rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
        "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
        "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
    socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
        "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
        FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
        NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
        NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
    setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
        "parallel"), action = c("launch", "options"), verbose = FALSE)  
  ..$ arguments       :List of 28
  .. ..$ worker          : chr "localhost"
  .. ..$ master          : NULL
  .. ..$ port            : int 32589
  .. ..$ connectTimeout  : num 120
  .. ..$ timeout         : num 120
  .. ..$ rscript         : NULL
  .. ..$ homogeneous     : NULL
  .. ..$ rscript_args    : NULL
  .. ..$ rscript_envs    : NULL
  .. ..$ rscript_libs    : NULL
  .. ..$ rscript_startup : NULL
  .. ..$ rscript_sh      : chr "auto"
  .. ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
  .. ..$ methods         : logi TRUE
  .. ..$ socketOptions   : chr "no-delay"
  .. ..$ useXDR          : logi FALSE
  .. ..$ outfile         : chr "/dev/null"
  .. ..$ renice          : int NA
  .. ..$ rshcmd          : NULL
  .. ..$ user            : NULL
  .. ..$ revtunnel       : logi NA
  .. ..$ rshlogfile      : NULL
  .. ..$ rshopts         : NULL
  .. ..$ rank            : int 1
  .. ..$ manual          : logi FALSE
  .. ..$ dryrun          : logi FALSE
  .. ..$ quiet           : logi FALSE
  .. ..$ setup_strategy  : chr "parallel"
  ..- attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
 - attr(*, "class")= chr [1:2] "RichSOCKnode" "SOCK0node"
> stopifnot(isTRUE(attr(node[["host"]], "localhost")))
> parallel::stopCluster(cl)
> 
> 
> message("- makeClusterPSOCK() - useXDR = TRUE/FALSE")
- makeClusterPSOCK() - useXDR = TRUE/FALSE
> 
> for (xdr in c(TRUE, FALSE)) {
+   cl <- makeClusterPSOCK(1L, useXDR = xdr)
+   node <- cl[[1]]
+   stopifnot(
+     is.list(node),
+     inherits(node, if (xdr) "SOCKnode" else "SOCK0node"),
+     "session_info" %in% names(node)
+   )
+   si <- node[["session_info"]]
+   stopifnot(is.list(si))
+   parallel::stopCluster(cl)
+ }
[18:32:46.358] [local output] makeClusterPSOCK() ...
[18:32:46.365] [local output] Workers: [n = 1] 'localhost'
[18:32:46.371] [local output] Base port: 33068
[18:32:46.372] [local output] Getting setup options for 1 cluster nodes ...
[18:32:46.372] [local output]  - Node #1 of 1 ...
[18:32:46.373] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:46.377] [local output] Rscript port: 33068

[18:32:46.377] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:46.378] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:46.379] [local output] Setting up PSOCK nodes in parallel
[18:32:46.379] List of 36
[18:32:46.379]  $ worker          : chr "localhost"
[18:32:46.379]   ..- attr(*, "localhost")= logi TRUE
[18:32:46.379]  $ master          : chr "localhost"
[18:32:46.379]  $ port            : int 33068
[18:32:46.379]  $ connectTimeout  : num 120
[18:32:46.379]  $ timeout         : num 120
[18:32:46.379]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:46.379]  $ homogeneous     : logi TRUE
[18:32:46.379]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:46.379]  $ rscript_envs    : NULL
[18:32:46.379]  $ rscript_libs    : NULL
[18:32:46.379]  $ rscript_startup : NULL
[18:32:46.379]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:46.379]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:46.379]  $ methods         : logi TRUE
[18:32:46.379]  $ socketOptions   : chr "no-delay"
[18:32:46.379]  $ useXDR          : logi TRUE
[18:32:46.379]  $ outfile         : chr "/dev/null"
[18:32:46.379]  $ renice          : int NA
[18:32:46.379]  $ rshcmd          : NULL
[18:32:46.379]  $ user            : chr(0) 
[18:32:46.379]  $ revtunnel       : logi FALSE
[18:32:46.379]  $ rshlogfile      : NULL
[18:32:46.379]  $ rshopts         : chr(0) 
[18:32:46.379]  $ rank            : int 1
[18:32:46.379]  $ manual          : logi FALSE
[18:32:46.379]  $ dryrun          : logi FALSE
[18:32:46.379]  $ quiet           : logi FALSE
[18:32:46.379]  $ setup_strategy  : chr "parallel"
[18:32:46.379]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:46.379]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f07e0726f7.pid"
[18:32:46.379]  $ rshcmd_label    : NULL
[18:32:46.379]  $ rsh_call        : NULL
[18:32:46.379]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:46.379]  $ localMachine    : logi TRUE
[18:32:46.379]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:46.379]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:46.379]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:46.379]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:46.379]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:46.379]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:46.379]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:46.379]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:46.379]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:46.379]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:46.379]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:46.379]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:46.379]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:46.379]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:46.379]  $ arguments       :List of 28
[18:32:46.379]   ..$ worker          : chr "localhost"
[18:32:46.379]   ..$ master          : NULL
[18:32:46.379]   ..$ port            : int 33068
[18:32:46.379]   ..$ connectTimeout  : num 120
[18:32:46.379]   ..$ timeout         : num 120
[18:32:46.379]   ..$ rscript         : NULL
[18:32:46.379]   ..$ homogeneous     : NULL
[18:32:46.379]   ..$ rscript_args    : NULL
[18:32:46.379]   ..$ rscript_envs    : NULL
[18:32:46.379]   ..$ rscript_libs    : NULL
[18:32:46.379]   ..$ rscript_startup : NULL
[18:32:46.379]   ..$ rscript_sh      : chr "auto"
[18:32:46.379]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:46.379]   ..$ methods         : logi TRUE
[18:32:46.379]   ..$ socketOptions   : chr "no-delay"
[18:32:46.379]   ..$ useXDR          : logi TRUE
[18:32:46.379]   ..$ outfile         : chr "/dev/null"
[18:32:46.379]   ..$ renice          : int NA
[18:32:46.379]   ..$ rshcmd          : NULL
[18:32:46.379]   ..$ user            : NULL
[18:32:46.379]   ..$ revtunnel       : logi NA
[18:32:46.379]   ..$ rshlogfile      : NULL
[18:32:46.379]   ..$ rshopts         : NULL
[18:32:46.379]   ..$ rank            : int 1
[18:32:46.379]   ..$ manual          : logi FALSE
[18:32:46.379]   ..$ dryrun          : logi FALSE
[18:32:46.379]   ..$ quiet           : logi FALSE
[18:32:46.379]   ..$ setup_strategy  : chr "parallel"
[18:32:46.379]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:46.421] [local output] System call to launch all workers:
[18:32:46.422] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f07e0726f7.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=33068 OUT=/dev/null TIMEOUT=120 XDR=TRUE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:46.422] [local output] Starting PSOCK main server
[18:32:46.427] [local output] Workers launched
[18:32:46.427] [local output] Waiting for workers to connect back
[18:32:46.428]  - [local output] 0 workers out of 1 ready
[18:32:46.653]  - [local output] 0 workers out of 1 ready
[18:32:46.654]  - [local output] 1 workers out of 1 ready
[18:32:46.654] [local output] Launching of 1 workers completed
[18:32:46.655] [local output] Number of nodes in cluster: 1
[18:32:46.655] [local output] Collecting session information from 1 workers
[18:32:46.656] [local output]  - Worker #1 of 1
[18:32:46.657] [local output] makeClusterPSOCK() ... done
[18:32:46.662] [local output] makeClusterPSOCK() ...
[18:32:46.669] [local output] Workers: [n = 1] 'localhost'
[18:32:46.675] [local output] Base port: 35615
[18:32:46.678] [local output] Getting setup options for 1 cluster nodes ...
[18:32:46.678] [local output]  - Node #1 of 1 ...
[18:32:46.679] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:46.682] [local output] Rscript port: 35615

[18:32:46.683] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:46.683] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:46.684] [local output] Setting up PSOCK nodes in parallel
[18:32:46.684] List of 36
[18:32:46.684]  $ worker          : chr "localhost"
[18:32:46.684]   ..- attr(*, "localhost")= logi TRUE
[18:32:46.684]  $ master          : chr "localhost"
[18:32:46.684]  $ port            : int 35615
[18:32:46.684]  $ connectTimeout  : num 120
[18:32:46.684]  $ timeout         : num 120
[18:32:46.684]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:46.684]  $ homogeneous     : logi TRUE
[18:32:46.684]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:46.684]  $ rscript_envs    : NULL
[18:32:46.684]  $ rscript_libs    : NULL
[18:32:46.684]  $ rscript_startup : NULL
[18:32:46.684]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:46.684]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:46.684]  $ methods         : logi TRUE
[18:32:46.684]  $ socketOptions   : chr "no-delay"
[18:32:46.684]  $ useXDR          : logi FALSE
[18:32:46.684]  $ outfile         : chr "/dev/null"
[18:32:46.684]  $ renice          : int NA
[18:32:46.684]  $ rshcmd          : NULL
[18:32:46.684]  $ user            : chr(0) 
[18:32:46.684]  $ revtunnel       : logi FALSE
[18:32:46.684]  $ rshlogfile      : NULL
[18:32:46.684]  $ rshopts         : chr(0) 
[18:32:46.684]  $ rank            : int 1
[18:32:46.684]  $ manual          : logi FALSE
[18:32:46.684]  $ dryrun          : logi FALSE
[18:32:46.684]  $ quiet           : logi FALSE
[18:32:46.684]  $ setup_strategy  : chr "parallel"
[18:32:46.684]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:46.684]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f03ac212b6.pid"
[18:32:46.684]  $ rshcmd_label    : NULL
[18:32:46.684]  $ rsh_call        : NULL
[18:32:46.684]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:46.684]  $ localMachine    : logi TRUE
[18:32:46.684]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:46.684]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:46.684]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:46.684]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:46.684]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:46.684]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:46.684]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:46.684]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:46.684]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:46.684]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:46.684]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:46.684]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:46.684]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:46.684]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:46.684]  $ arguments       :List of 28
[18:32:46.684]   ..$ worker          : chr "localhost"
[18:32:46.684]   ..$ master          : NULL
[18:32:46.684]   ..$ port            : int 35615
[18:32:46.684]   ..$ connectTimeout  : num 120
[18:32:46.684]   ..$ timeout         : num 120
[18:32:46.684]   ..$ rscript         : NULL
[18:32:46.684]   ..$ homogeneous     : NULL
[18:32:46.684]   ..$ rscript_args    : NULL
[18:32:46.684]   ..$ rscript_envs    : NULL
[18:32:46.684]   ..$ rscript_libs    : NULL
[18:32:46.684]   ..$ rscript_startup : NULL
[18:32:46.684]   ..$ rscript_sh      : chr "auto"
[18:32:46.684]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:46.684]   ..$ methods         : logi TRUE
[18:32:46.684]   ..$ socketOptions   : chr "no-delay"
[18:32:46.684]   ..$ useXDR          : logi FALSE
[18:32:46.684]   ..$ outfile         : chr "/dev/null"
[18:32:46.684]   ..$ renice          : int NA
[18:32:46.684]   ..$ rshcmd          : NULL
[18:32:46.684]   ..$ user            : NULL
[18:32:46.684]   ..$ revtunnel       : logi NA
[18:32:46.684]   ..$ rshlogfile      : NULL
[18:32:46.684]   ..$ rshopts         : NULL
[18:32:46.684]   ..$ rank            : int 1
[18:32:46.684]   ..$ manual          : logi FALSE
[18:32:46.684]   ..$ dryrun          : logi FALSE
[18:32:46.684]   ..$ quiet           : logi FALSE
[18:32:46.684]   ..$ setup_strategy  : chr "parallel"
[18:32:46.684]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:46.725] [local output] System call to launch all workers:
[18:32:46.725] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f03ac212b6.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=35615 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:46.726] [local output] Starting PSOCK main server
[18:32:46.731] [local output] Workers launched
[18:32:46.732] [local output] Waiting for workers to connect back
[18:32:46.732]  - [local output] 0 workers out of 1 ready
[18:32:47.016]  - [local output] 0 workers out of 1 ready
[18:32:47.019]  - [local output] 1 workers out of 1 ready
[18:32:47.019] [local output] Launching of 1 workers completed
[18:32:47.019] [local output] Number of nodes in cluster: 1
[18:32:47.020] [local output] Collecting session information from 1 workers
[18:32:47.021] [local output]  - Worker #1 of 1
[18:32:47.021] [local output] makeClusterPSOCK() ... done
> 
> message("- makeClusterPSOCK() - argument 'socketOptions'")
- makeClusterPSOCK() - argument 'socketOptions'
> 
> for (value in list(NULL, "NULL", "no-delay")) {
+   cl <- makeClusterPSOCK(1L, socketOptions = value)
+   y <- parallel::clusterEvalQ(cl, 42L)[[1]]
+   stopifnot(identical(y, 42L))
+   parallel::stopCluster(cl)
+ }
[18:32:47.033] [local output] makeClusterPSOCK() ...
[18:32:47.038] [local output] Workers: [n = 1] 'localhost'
[18:32:47.043] [local output] Base port: 25093
[18:32:47.043] [local output] Getting setup options for 1 cluster nodes ...
[18:32:47.044] [local output]  - Node #1 of 1 ...
[18:32:47.044] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:47.047] [local output] Rscript port: 25093

[18:32:47.047] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:47.048] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:47.048] [local output] Setting up PSOCK nodes in parallel
[18:32:47.049] List of 36
[18:32:47.049]  $ worker          : chr "localhost"
[18:32:47.049]   ..- attr(*, "localhost")= logi TRUE
[18:32:47.049]  $ master          : chr "localhost"
[18:32:47.049]  $ port            : int 25093
[18:32:47.049]  $ connectTimeout  : num 120
[18:32:47.049]  $ timeout         : num 120
[18:32:47.049]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:47.049]  $ homogeneous     : logi TRUE
[18:32:47.049]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:47.049]  $ rscript_envs    : NULL
[18:32:47.049]  $ rscript_libs    : NULL
[18:32:47.049]  $ rscript_startup : NULL
[18:32:47.049]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:47.049]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:47.049]  $ methods         : logi TRUE
[18:32:47.049]  $ socketOptions   : NULL
[18:32:47.049]  $ useXDR          : logi FALSE
[18:32:47.049]  $ outfile         : chr "/dev/null"
[18:32:47.049]  $ renice          : int NA
[18:32:47.049]  $ rshcmd          : NULL
[18:32:47.049]  $ user            : chr(0) 
[18:32:47.049]  $ revtunnel       : logi FALSE
[18:32:47.049]  $ rshlogfile      : NULL
[18:32:47.049]  $ rshopts         : chr(0) 
[18:32:47.049]  $ rank            : int 1
[18:32:47.049]  $ manual          : logi FALSE
[18:32:47.049]  $ dryrun          : logi FALSE
[18:32:47.049]  $ quiet           : logi FALSE
[18:32:47.049]  $ setup_strategy  : chr "parallel"
[18:32:47.049]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:47.049]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0cbd22c.pid"
[18:32:47.049]  $ rshcmd_label    : NULL
[18:32:47.049]  $ rsh_call        : NULL
[18:32:47.049]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:47.049]  $ localMachine    : logi TRUE
[18:32:47.049]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:47.049]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:47.049]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:47.049]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:47.049]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:47.049]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:47.049]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:47.049]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:47.049]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:47.049]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:47.049]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:47.049]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:47.049]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:47.049]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:47.049]  $ arguments       :List of 28
[18:32:47.049]   ..$ worker          : chr "localhost"
[18:32:47.049]   ..$ master          : NULL
[18:32:47.049]   ..$ port            : int 25093
[18:32:47.049]   ..$ connectTimeout  : num 120
[18:32:47.049]   ..$ timeout         : num 120
[18:32:47.049]   ..$ rscript         : NULL
[18:32:47.049]   ..$ homogeneous     : NULL
[18:32:47.049]   ..$ rscript_args    : NULL
[18:32:47.049]   ..$ rscript_envs    : NULL
[18:32:47.049]   ..$ rscript_libs    : NULL
[18:32:47.049]   ..$ rscript_startup : NULL
[18:32:47.049]   ..$ rscript_sh      : chr "auto"
[18:32:47.049]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:47.049]   ..$ methods         : logi TRUE
[18:32:47.049]   ..$ socketOptions   : NULL
[18:32:47.049]   ..$ useXDR          : logi FALSE
[18:32:47.049]   ..$ outfile         : chr "/dev/null"
[18:32:47.049]   ..$ renice          : int NA
[18:32:47.049]   ..$ rshcmd          : NULL
[18:32:47.049]   ..$ user            : NULL
[18:32:47.049]   ..$ revtunnel       : logi NA
[18:32:47.049]   ..$ rshlogfile      : NULL
[18:32:47.049]   ..$ rshopts         : NULL
[18:32:47.049]   ..$ rank            : int 1
[18:32:47.049]   ..$ manual          : logi FALSE
[18:32:47.049]   ..$ dryrun          : logi FALSE
[18:32:47.049]   ..$ quiet           : logi FALSE
[18:32:47.049]   ..$ setup_strategy  : chr "parallel"
[18:32:47.049]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:47.084] [local output] System call to launch all workers:
[18:32:47.084] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0cbd22c.pid\")), silent = TRUE)" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=25093 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:47.084] [local output] Starting PSOCK main server
[18:32:47.090] [local output] Workers launched
[18:32:47.090] [local output] Waiting for workers to connect back
[18:32:47.091]  - [local output] 0 workers out of 1 ready
[18:32:47.342]  - [local output] 0 workers out of 1 ready
[18:32:47.342]  - [local output] 1 workers out of 1 ready
[18:32:47.343] [local output] Launching of 1 workers completed
[18:32:47.343] [local output] Number of nodes in cluster: 1
[18:32:47.343] [local output] Collecting session information from 1 workers
[18:32:47.344] [local output]  - Worker #1 of 1
[18:32:47.345] [local output] makeClusterPSOCK() ... done
[18:32:47.351] [local output] makeClusterPSOCK() ...
[18:32:47.359] [local output] Workers: [n = 1] 'localhost'
[18:32:47.363] [local output] Base port: 30236
[18:32:47.364] [local output] Getting setup options for 1 cluster nodes ...
[18:32:47.364] [local output]  - Node #1 of 1 ...
[18:32:47.365] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:47.367] [local output] Rscript port: 30236

[18:32:47.367] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:47.368] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:47.368] [local output] Setting up PSOCK nodes in parallel
[18:32:47.368] List of 36
[18:32:47.368]  $ worker          : chr "localhost"
[18:32:47.368]   ..- attr(*, "localhost")= logi TRUE
[18:32:47.368]  $ master          : chr "localhost"
[18:32:47.368]  $ port            : int 30236
[18:32:47.368]  $ connectTimeout  : num 120
[18:32:47.368]  $ timeout         : num 120
[18:32:47.368]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:47.368]  $ homogeneous     : logi TRUE
[18:32:47.368]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:47.368]  $ rscript_envs    : NULL
[18:32:47.368]  $ rscript_libs    : NULL
[18:32:47.368]  $ rscript_startup : NULL
[18:32:47.368]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:47.368]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:47.368]  $ methods         : logi TRUE
[18:32:47.368]  $ socketOptions   : NULL
[18:32:47.368]  $ useXDR          : logi FALSE
[18:32:47.368]  $ outfile         : chr "/dev/null"
[18:32:47.368]  $ renice          : int NA
[18:32:47.368]  $ rshcmd          : NULL
[18:32:47.368]  $ user            : chr(0) 
[18:32:47.368]  $ revtunnel       : logi FALSE
[18:32:47.368]  $ rshlogfile      : NULL
[18:32:47.368]  $ rshopts         : chr(0) 
[18:32:47.368]  $ rank            : int 1
[18:32:47.368]  $ manual          : logi FALSE
[18:32:47.368]  $ dryrun          : logi FALSE
[18:32:47.368]  $ quiet           : logi FALSE
[18:32:47.368]  $ setup_strategy  : chr "parallel"
[18:32:47.368]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:47.368]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f03918bcc.pid"
[18:32:47.368]  $ rshcmd_label    : NULL
[18:32:47.368]  $ rsh_call        : NULL
[18:32:47.368]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:47.368]  $ localMachine    : logi TRUE
[18:32:47.368]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:47.368]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:47.368]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:47.368]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:47.368]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:47.368]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:47.368]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:47.368]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:47.368]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:47.368]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:47.368]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:47.368]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:47.368]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:47.368]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:47.368]  $ arguments       :List of 28
[18:32:47.368]   ..$ worker          : chr "localhost"
[18:32:47.368]   ..$ master          : NULL
[18:32:47.368]   ..$ port            : int 30236
[18:32:47.368]   ..$ connectTimeout  : num 120
[18:32:47.368]   ..$ timeout         : num 120
[18:32:47.368]   ..$ rscript         : NULL
[18:32:47.368]   ..$ homogeneous     : NULL
[18:32:47.368]   ..$ rscript_args    : NULL
[18:32:47.368]   ..$ rscript_envs    : NULL
[18:32:47.368]   ..$ rscript_libs    : NULL
[18:32:47.368]   ..$ rscript_startup : NULL
[18:32:47.368]   ..$ rscript_sh      : chr "auto"
[18:32:47.368]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:47.368]   ..$ methods         : logi TRUE
[18:32:47.368]   ..$ socketOptions   : chr "NULL"
[18:32:47.368]   ..$ useXDR          : logi FALSE
[18:32:47.368]   ..$ outfile         : chr "/dev/null"
[18:32:47.368]   ..$ renice          : int NA
[18:32:47.368]   ..$ rshcmd          : NULL
[18:32:47.368]   ..$ user            : NULL
[18:32:47.368]   ..$ revtunnel       : logi NA
[18:32:47.368]   ..$ rshlogfile      : NULL
[18:32:47.368]   ..$ rshopts         : NULL
[18:32:47.368]   ..$ rank            : int 1
[18:32:47.368]   ..$ manual          : logi FALSE
[18:32:47.368]   ..$ dryrun          : logi FALSE
[18:32:47.368]   ..$ quiet           : logi FALSE
[18:32:47.368]   ..$ setup_strategy  : chr "parallel"
[18:32:47.368]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:47.394] [local output] System call to launch all workers:
[18:32:47.394] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f03918bcc.pid\")), silent = TRUE)" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=30236 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:47.394] [local output] Starting PSOCK main server
[18:32:47.400] [local output] Workers launched
[18:32:47.400] [local output] Waiting for workers to connect back
[18:32:47.400]  - [local output] 0 workers out of 1 ready
[18:32:47.654]  - [local output] 0 workers out of 1 ready
[18:32:47.655]  - [local output] 1 workers out of 1 ready
[18:32:47.655] [local output] Launching of 1 workers completed
[18:32:47.655] [local output] Number of nodes in cluster: 1
[18:32:47.656] [local output] Collecting session information from 1 workers
[18:32:47.657] [local output]  - Worker #1 of 1
[18:32:47.657] [local output] makeClusterPSOCK() ... done
[18:32:47.663] [local output] makeClusterPSOCK() ...
[18:32:47.668] [local output] Workers: [n = 1] 'localhost'
[18:32:47.672] [local output] Base port: 36269
[18:32:47.673] [local output] Getting setup options for 1 cluster nodes ...
[18:32:47.673] [local output]  - Node #1 of 1 ...
[18:32:47.674] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:47.676] [local output] Rscript port: 36269

[18:32:47.676] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:47.677] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:47.677] [local output] Setting up PSOCK nodes in parallel
[18:32:47.678] List of 36
[18:32:47.678]  $ worker          : chr "localhost"
[18:32:47.678]   ..- attr(*, "localhost")= logi TRUE
[18:32:47.678]  $ master          : chr "localhost"
[18:32:47.678]  $ port            : int 36269
[18:32:47.678]  $ connectTimeout  : num 120
[18:32:47.678]  $ timeout         : num 120
[18:32:47.678]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:47.678]  $ homogeneous     : logi TRUE
[18:32:47.678]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:47.678]  $ rscript_envs    : NULL
[18:32:47.678]  $ rscript_libs    : NULL
[18:32:47.678]  $ rscript_startup : NULL
[18:32:47.678]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:47.678]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:47.678]  $ methods         : logi TRUE
[18:32:47.678]  $ socketOptions   : chr "no-delay"
[18:32:47.678]  $ useXDR          : logi FALSE
[18:32:47.678]  $ outfile         : chr "/dev/null"
[18:32:47.678]  $ renice          : int NA
[18:32:47.678]  $ rshcmd          : NULL
[18:32:47.678]  $ user            : chr(0) 
[18:32:47.678]  $ revtunnel       : logi FALSE
[18:32:47.678]  $ rshlogfile      : NULL
[18:32:47.678]  $ rshopts         : chr(0) 
[18:32:47.678]  $ rank            : int 1
[18:32:47.678]  $ manual          : logi FALSE
[18:32:47.678]  $ dryrun          : logi FALSE
[18:32:47.678]  $ quiet           : logi FALSE
[18:32:47.678]  $ setup_strategy  : chr "parallel"
[18:32:47.678]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:47.678]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f02af22507.pid"
[18:32:47.678]  $ rshcmd_label    : NULL
[18:32:47.678]  $ rsh_call        : NULL
[18:32:47.678]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:47.678]  $ localMachine    : logi TRUE
[18:32:47.678]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:47.678]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:47.678]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:47.678]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:47.678]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:47.678]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:47.678]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:47.678]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:47.678]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:47.678]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:47.678]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:47.678]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:47.678]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:47.678]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:47.678]  $ arguments       :List of 28
[18:32:47.678]   ..$ worker          : chr "localhost"
[18:32:47.678]   ..$ master          : NULL
[18:32:47.678]   ..$ port            : int 36269
[18:32:47.678]   ..$ connectTimeout  : num 120
[18:32:47.678]   ..$ timeout         : num 120
[18:32:47.678]   ..$ rscript         : NULL
[18:32:47.678]   ..$ homogeneous     : NULL
[18:32:47.678]   ..$ rscript_args    : NULL
[18:32:47.678]   ..$ rscript_envs    : NULL
[18:32:47.678]   ..$ rscript_libs    : NULL
[18:32:47.678]   ..$ rscript_startup : NULL
[18:32:47.678]   ..$ rscript_sh      : chr "auto"
[18:32:47.678]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:47.678]   ..$ methods         : logi TRUE
[18:32:47.678]   ..$ socketOptions   : chr "no-delay"
[18:32:47.678]   ..$ useXDR          : logi FALSE
[18:32:47.678]   ..$ outfile         : chr "/dev/null"
[18:32:47.678]   ..$ renice          : int NA
[18:32:47.678]   ..$ rshcmd          : NULL
[18:32:47.678]   ..$ user            : NULL
[18:32:47.678]   ..$ revtunnel       : logi NA
[18:32:47.678]   ..$ rshlogfile      : NULL
[18:32:47.678]   ..$ rshopts         : NULL
[18:32:47.678]   ..$ rank            : int 1
[18:32:47.678]   ..$ manual          : logi FALSE
[18:32:47.678]   ..$ dryrun          : logi FALSE
[18:32:47.678]   ..$ quiet           : logi FALSE
[18:32:47.678]   ..$ setup_strategy  : chr "parallel"
[18:32:47.678]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:47.711] [local output] System call to launch all workers:
[18:32:47.712] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f02af22507.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=36269 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:47.712] [local output] Starting PSOCK main server
[18:32:47.717] [local output] Workers launched
[18:32:47.717] [local output] Waiting for workers to connect back
[18:32:47.718]  - [local output] 0 workers out of 1 ready
[18:32:47.964]  - [local output] 0 workers out of 1 ready
[18:32:47.964]  - [local output] 1 workers out of 1 ready
[18:32:47.965] [local output] Launching of 1 workers completed
[18:32:47.965] [local output] Number of nodes in cluster: 1
[18:32:47.965] [local output] Collecting session information from 1 workers
[18:32:47.967] [local output]  - Worker #1 of 1
[18:32:47.967] [local output] makeClusterPSOCK() ... done
> 
> 
> message("- makeClusterPSOCK() - argument 'rscript_startup'")
- makeClusterPSOCK() - argument 'rscript_startup'
> 
> for (value in list(NULL, "options(abc = 42L)", quote(options(abc = 42L)))) {
+   cl <- makeClusterPSOCK(1L, rscript_startup = value)
+   y <- parallel::clusterEvalQ(cl, getOption("abc", NA_integer_))[[1]]
+   stopifnot(is.integer(y), length(y) == 1L)
+   if (!is.null(value)) stopifnot(identical(y, 42L))
+   parallel::stopCluster(cl)
+ }
[18:32:47.984] [local output] makeClusterPSOCK() ...
[18:32:47.990] [local output] Workers: [n = 1] 'localhost'
[18:32:47.994] [local output] Base port: 37505
[18:32:47.994] [local output] Getting setup options for 1 cluster nodes ...
[18:32:47.994] [local output]  - Node #1 of 1 ...
[18:32:47.995] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:47.997] [local output] Rscript port: 37505

[18:32:47.998] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:47.998] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:47.998] [local output] Setting up PSOCK nodes in parallel
[18:32:47.999] List of 36
[18:32:47.999]  $ worker          : chr "localhost"
[18:32:47.999]   ..- attr(*, "localhost")= logi TRUE
[18:32:47.999]  $ master          : chr "localhost"
[18:32:47.999]  $ port            : int 37505
[18:32:47.999]  $ connectTimeout  : num 120
[18:32:47.999]  $ timeout         : num 120
[18:32:47.999]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:47.999]  $ homogeneous     : logi TRUE
[18:32:47.999]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:47.999]  $ rscript_envs    : NULL
[18:32:47.999]  $ rscript_libs    : NULL
[18:32:47.999]  $ rscript_startup : NULL
[18:32:47.999]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:47.999]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:47.999]  $ methods         : logi TRUE
[18:32:47.999]  $ socketOptions   : chr "no-delay"
[18:32:47.999]  $ useXDR          : logi FALSE
[18:32:47.999]  $ outfile         : chr "/dev/null"
[18:32:47.999]  $ renice          : int NA
[18:32:47.999]  $ rshcmd          : NULL
[18:32:47.999]  $ user            : chr(0) 
[18:32:47.999]  $ revtunnel       : logi FALSE
[18:32:47.999]  $ rshlogfile      : NULL
[18:32:47.999]  $ rshopts         : chr(0) 
[18:32:47.999]  $ rank            : int 1
[18:32:47.999]  $ manual          : logi FALSE
[18:32:47.999]  $ dryrun          : logi FALSE
[18:32:47.999]  $ quiet           : logi FALSE
[18:32:47.999]  $ setup_strategy  : chr "parallel"
[18:32:47.999]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:47.999]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0277f5613.pid"
[18:32:47.999]  $ rshcmd_label    : NULL
[18:32:47.999]  $ rsh_call        : NULL
[18:32:47.999]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:47.999]  $ localMachine    : logi TRUE
[18:32:47.999]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:47.999]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:47.999]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:47.999]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:47.999]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:47.999]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:47.999]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:47.999]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:47.999]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:47.999]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:47.999]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:47.999]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:47.999]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:47.999]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:47.999]  $ arguments       :List of 28
[18:32:47.999]   ..$ worker          : chr "localhost"
[18:32:47.999]   ..$ master          : NULL
[18:32:47.999]   ..$ port            : int 37505
[18:32:47.999]   ..$ connectTimeout  : num 120
[18:32:47.999]   ..$ timeout         : num 120
[18:32:47.999]   ..$ rscript         : NULL
[18:32:47.999]   ..$ homogeneous     : NULL
[18:32:47.999]   ..$ rscript_args    : NULL
[18:32:47.999]   ..$ rscript_envs    : NULL
[18:32:47.999]   ..$ rscript_libs    : NULL
[18:32:47.999]   ..$ rscript_startup : NULL
[18:32:47.999]   ..$ rscript_sh      : chr "auto"
[18:32:47.999]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:47.999]   ..$ methods         : logi TRUE
[18:32:47.999]   ..$ socketOptions   : chr "no-delay"
[18:32:47.999]   ..$ useXDR          : logi FALSE
[18:32:47.999]   ..$ outfile         : chr "/dev/null"
[18:32:47.999]   ..$ renice          : int NA
[18:32:47.999]   ..$ rshcmd          : NULL
[18:32:47.999]   ..$ user            : NULL
[18:32:47.999]   ..$ revtunnel       : logi NA
[18:32:47.999]   ..$ rshlogfile      : NULL
[18:32:47.999]   ..$ rshopts         : NULL
[18:32:47.999]   ..$ rank            : int 1
[18:32:47.999]   ..$ manual          : logi FALSE
[18:32:47.999]   ..$ dryrun          : logi FALSE
[18:32:47.999]   ..$ quiet           : logi FALSE
[18:32:47.999]   ..$ setup_strategy  : chr "parallel"
[18:32:47.999]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:48.033] [local output] System call to launch all workers:
[18:32:48.033] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0277f5613.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=37505 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:48.033] [local output] Starting PSOCK main server
[18:32:48.039] [local output] Workers launched
[18:32:48.039] [local output] Waiting for workers to connect back
[18:32:48.040]  - [local output] 0 workers out of 1 ready
[18:32:48.301]  - [local output] 0 workers out of 1 ready
[18:32:48.301]  - [local output] 1 workers out of 1 ready
[18:32:48.301] [local output] Launching of 1 workers completed
[18:32:48.301] [local output] Number of nodes in cluster: 1
[18:32:48.302] [local output] Collecting session information from 1 workers
[18:32:48.303] [local output]  - Worker #1 of 1
[18:32:48.303] [local output] makeClusterPSOCK() ... done
[18:32:48.310] [local output] makeClusterPSOCK() ...
[18:32:48.316] [local output] Workers: [n = 1] 'localhost'
[18:32:48.320] [local output] Base port: 23264
[18:32:48.321] [local output] Getting setup options for 1 cluster nodes ...
[18:32:48.321] [local output]  - Node #1 of 1 ...
[18:32:48.322] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:48.325] [local output] Rscript port: 23264

[18:32:48.325] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:48.326] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:48.327] [local output] Setting up PSOCK nodes in parallel
[18:32:48.327] List of 36
[18:32:48.327]  $ worker          : chr "localhost"
[18:32:48.327]   ..- attr(*, "localhost")= logi TRUE
[18:32:48.327]  $ master          : chr "localhost"
[18:32:48.327]  $ port            : int 23264
[18:32:48.327]  $ connectTimeout  : num 120
[18:32:48.327]  $ timeout         : num 120
[18:32:48.327]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:48.327]  $ homogeneous     : logi TRUE
[18:32:48.327]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:48.327]  $ rscript_envs    : NULL
[18:32:48.327]  $ rscript_libs    : NULL
[18:32:48.327]  $ rscript_startup : chr [1:2] "-e" "\"invisible({options(abc = 42L)})\""
[18:32:48.327]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:48.327]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:48.327]  $ methods         : logi TRUE
[18:32:48.327]  $ socketOptions   : chr "no-delay"
[18:32:48.327]  $ useXDR          : logi FALSE
[18:32:48.327]  $ outfile         : chr "/dev/null"
[18:32:48.327]  $ renice          : int NA
[18:32:48.327]  $ rshcmd          : NULL
[18:32:48.327]  $ user            : chr(0) 
[18:32:48.327]  $ revtunnel       : logi FALSE
[18:32:48.327]  $ rshlogfile      : NULL
[18:32:48.327]  $ rshopts         : chr(0) 
[18:32:48.327]  $ rank            : int 1
[18:32:48.327]  $ manual          : logi FALSE
[18:32:48.327]  $ dryrun          : logi FALSE
[18:32:48.327]  $ quiet           : logi FALSE
[18:32:48.327]  $ setup_strategy  : chr "parallel"
[18:32:48.327]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:48.327]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f085a5aeb.pid"
[18:32:48.327]  $ rshcmd_label    : NULL
[18:32:48.327]  $ rsh_call        : NULL
[18:32:48.327]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:48.327]  $ localMachine    : logi TRUE
[18:32:48.327]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:48.327]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:48.327]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:48.327]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:48.327]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:48.327]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:48.327]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:48.327]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:48.327]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:48.327]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:48.327]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:48.327]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:48.327]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:48.327]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:48.327]  $ arguments       :List of 28
[18:32:48.327]   ..$ worker          : chr "localhost"
[18:32:48.327]   ..$ master          : NULL
[18:32:48.327]   ..$ port            : int 23264
[18:32:48.327]   ..$ connectTimeout  : num 120
[18:32:48.327]   ..$ timeout         : num 120
[18:32:48.327]   ..$ rscript         : NULL
[18:32:48.327]   ..$ homogeneous     : NULL
[18:32:48.327]   ..$ rscript_args    : NULL
[18:32:48.327]   ..$ rscript_envs    : NULL
[18:32:48.327]   ..$ rscript_libs    : NULL
[18:32:48.327]   ..$ rscript_startup : chr "options(abc = 42L)"
[18:32:48.327]   ..$ rscript_sh      : chr "auto"
[18:32:48.327]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:48.327]   ..$ methods         : logi TRUE
[18:32:48.327]   ..$ socketOptions   : chr "no-delay"
[18:32:48.327]   ..$ useXDR          : logi FALSE
[18:32:48.327]   ..$ outfile         : chr "/dev/null"
[18:32:48.327]   ..$ renice          : int NA
[18:32:48.327]   ..$ rshcmd          : NULL
[18:32:48.327]   ..$ user            : NULL
[18:32:48.327]   ..$ revtunnel       : logi NA
[18:32:48.327]   ..$ rshlogfile      : NULL
[18:32:48.327]   ..$ rshopts         : NULL
[18:32:48.327]   ..$ rank            : int 1
[18:32:48.327]   ..$ manual          : logi FALSE
[18:32:48.327]   ..$ dryrun          : logi FALSE
[18:32:48.327]   ..$ quiet           : logi FALSE
[18:32:48.327]   ..$ setup_strategy  : chr "parallel"
[18:32:48.327]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:48.370] [local output] System call to launch all workers:
[18:32:48.370] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f085a5aeb.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "invisible({options(abc = 42L)})" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=23264 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:48.370] [local output] Starting PSOCK main server
[18:32:48.375] [local output] Workers launched
[18:32:48.376] [local output] Waiting for workers to connect back
[18:32:48.376]  - [local output] 0 workers out of 1 ready
[18:32:48.615]  - [local output] 0 workers out of 1 ready
[18:32:48.616]  - [local output] 1 workers out of 1 ready
[18:32:48.616] [local output] Launching of 1 workers completed
[18:32:48.616] [local output] Number of nodes in cluster: 1
[18:32:48.617] [local output] Collecting session information from 1 workers
[18:32:48.618] [local output]  - Worker #1 of 1
[18:32:48.618] [local output] makeClusterPSOCK() ... done
[18:32:48.625] [local output] makeClusterPSOCK() ...
[18:32:48.630] [local output] Workers: [n = 1] 'localhost'
[18:32:48.635] [local output] Base port: 33749
[18:32:48.635] [local output] Getting setup options for 1 cluster nodes ...
[18:32:48.636] [local output]  - Node #1 of 1 ...
[18:32:48.636] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:48.639] [local output] Rscript port: 33749

[18:32:48.640] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:48.640] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:48.641] [local output] Setting up PSOCK nodes in parallel
[18:32:48.641] List of 36
[18:32:48.641]  $ worker          : chr "localhost"
[18:32:48.641]   ..- attr(*, "localhost")= logi TRUE
[18:32:48.641]  $ master          : chr "localhost"
[18:32:48.641]  $ port            : int 33749
[18:32:48.641]  $ connectTimeout  : num 120
[18:32:48.641]  $ timeout         : num 120
[18:32:48.641]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:48.641]  $ homogeneous     : logi TRUE
[18:32:48.641]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:48.641]  $ rscript_envs    : NULL
[18:32:48.641]  $ rscript_libs    : NULL
[18:32:48.641]  $ rscript_startup : chr [1:2] "-e" "\"invisible({options(abc = 42L)})\""
[18:32:48.641]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:48.641]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:48.641]  $ methods         : logi TRUE
[18:32:48.641]  $ socketOptions   : chr "no-delay"
[18:32:48.641]  $ useXDR          : logi FALSE
[18:32:48.641]  $ outfile         : chr "/dev/null"
[18:32:48.641]  $ renice          : int NA
[18:32:48.641]  $ rshcmd          : NULL
[18:32:48.641]  $ user            : chr(0) 
[18:32:48.641]  $ revtunnel       : logi FALSE
[18:32:48.641]  $ rshlogfile      : NULL
[18:32:48.641]  $ rshopts         : chr(0) 
[18:32:48.641]  $ rank            : int 1
[18:32:48.641]  $ manual          : logi FALSE
[18:32:48.641]  $ dryrun          : logi FALSE
[18:32:48.641]  $ quiet           : logi FALSE
[18:32:48.641]  $ setup_strategy  : chr "parallel"
[18:32:48.641]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:48.641]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0701d5597.pid"
[18:32:48.641]  $ rshcmd_label    : NULL
[18:32:48.641]  $ rsh_call        : NULL
[18:32:48.641]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:48.641]  $ localMachine    : logi TRUE
[18:32:48.641]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:48.641]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:48.641]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:48.641]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:48.641]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:48.641]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:48.641]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:48.641]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:48.641]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:48.641]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:48.641]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:48.641]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:48.641]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:48.641]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:48.641]  $ arguments       :List of 28
[18:32:48.641]   ..$ worker          : chr "localhost"
[18:32:48.641]   ..$ master          : NULL
[18:32:48.641]   ..$ port            : int 33749
[18:32:48.641]   ..$ connectTimeout  : num 120
[18:32:48.641]   ..$ timeout         : num 120
[18:32:48.641]   ..$ rscript         : NULL
[18:32:48.641]   ..$ homogeneous     : NULL
[18:32:48.641]   ..$ rscript_args    : NULL
[18:32:48.641]   ..$ rscript_envs    : NULL
[18:32:48.641]   ..$ rscript_libs    : NULL
[18:32:48.641]   ..$ rscript_startup : language options(abc = 42L)
[18:32:48.641]   ..$ rscript_sh      : chr "auto"
[18:32:48.641]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:48.641]   ..$ methods         : logi TRUE
[18:32:48.641]   ..$ socketOptions   : chr "no-delay"
[18:32:48.641]   ..$ useXDR          : logi FALSE
[18:32:48.641]   ..$ outfile         : chr "/dev/null"
[18:32:48.641]   ..$ renice          : int NA
[18:32:48.641]   ..$ rshcmd          : NULL
[18:32:48.641]   ..$ user            : NULL
[18:32:48.641]   ..$ revtunnel       : logi NA
[18:32:48.641]   ..$ rshlogfile      : NULL
[18:32:48.641]   ..$ rshopts         : NULL
[18:32:48.641]   ..$ rank            : int 1
[18:32:48.641]   ..$ manual          : logi FALSE
[18:32:48.641]   ..$ dryrun          : logi FALSE
[18:32:48.641]   ..$ quiet           : logi FALSE
[18:32:48.641]   ..$ setup_strategy  : chr "parallel"
[18:32:48.641]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:48.678] [local output] System call to launch all workers:
[18:32:48.678] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0701d5597.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "invisible({options(abc = 42L)})" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=33749 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:48.678] [local output] Starting PSOCK main server
[18:32:48.684] [local output] Workers launched
[18:32:48.684] [local output] Waiting for workers to connect back
[18:32:48.684]  - [local output] 0 workers out of 1 ready
[18:32:48.947]  - [local output] 0 workers out of 1 ready
[18:32:48.948]  - [local output] 1 workers out of 1 ready
[18:32:48.948] [local output] Launching of 1 workers completed
[18:32:48.949] [local output] Number of nodes in cluster: 1
[18:32:48.949] [local output] Collecting session information from 1 workers
[18:32:48.950] [local output]  - Worker #1 of 1
[18:32:48.951] [local output] makeClusterPSOCK() ... done
> 
> 
> message("- makeClusterPSOCK() - setup_strategy = TRUE/FALSE")
- makeClusterPSOCK() - setup_strategy = TRUE/FALSE
> 
> for (setup_strategy in c("sequential", "parallel")) {
+   dt <- system.time({
+     cl <- makeClusterPSOCK(2L, setup_strategy = setup_strategy)
+   })
+   print(dt)
+   print(cl)
+   parallel::stopCluster(cl)
+ }
[18:32:49.003] [local output] makeClusterPSOCK() ...
[18:32:49.008] [local output] Workers: [n = 2] 'localhost', 'localhost'
[18:32:49.013] [local output] Base port: 25551
[18:32:49.013] [local output] Getting setup options for 2 cluster nodes ...
[18:32:49.013] [local output]  - Node #1 of 2 ...
[18:32:49.014] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:49.016] [local output] Rscript port: 25551

[18:32:49.017] [local output]  - Node #2 of 2 ...
[18:32:49.017] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:49.019] [local output] Rscript port: 25551

[18:32:49.020] [local output] Getting setup options for 2 cluster nodes ... done
[18:32:49.020] [local output] Creating node #1 of 2 ...
[18:32:49.020] [local output] - setting up node
[18:32:49.021] [local output] - attempt #1 of 3
[18:32:49.021] [local output] Starting worker #1 on 'localhost': "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f02d3075ad.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=25551 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=sequential
[18:32:49.027] [local output] - Exit code of system() call: 0
[18:32:49.027] [local output] Waiting for worker #1 on 'localhost' to connect back
[18:32:49.287] [local output] Connection with worker #1 on 'localhost' established
[18:32:49.288] [local output] Creating node #1 of 2 ... done
[18:32:49.288] [local output] Creating node #2 of 2 ...
[18:32:49.288] [local output] - setting up node
[18:32:49.288] [local output] - attempt #1 of 3
[18:32:49.289] [local output] Starting worker #2 on 'localhost': "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=2.parallelly.parent=71664.117f0239d3883.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=25551 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=sequential
[18:32:49.294] [local output] - Exit code of system() call: 0
[18:32:49.295] [local output] Waiting for worker #2 on 'localhost' to connect back
[18:32:49.540] [local output] Connection with worker #2 on 'localhost' established
[18:32:49.541] [local output] Creating node #2 of 2 ... done
[18:32:49.541] [local output] Launching of 2 workers completed
[18:32:49.541] [local output] Number of nodes in cluster: 2
[18:32:49.542] [local output] Collecting session information from 2 workers
[18:32:49.543] [local output]  - Worker #1 of 2
[18:32:49.544] [local output]  - Worker #2 of 2
[18:32:49.544] [local output] makeClusterPSOCK() ... done
   user  system elapsed 
   0.03    0.00    0.53 
Socket cluster with 2 nodes where 2 nodes are on host 'localhost' (R Under development (unstable) (2024-12-17 r87446 ucrt), platform x86_64-w64-mingw32)
[18:32:49.589] [local output] makeClusterPSOCK() ...
[18:32:49.595] [local output] Workers: [n = 2] 'localhost', 'localhost'
[18:32:49.598] [local output] Base port: 38599
[18:32:49.598] [local output] Getting setup options for 2 cluster nodes ...
[18:32:49.599] [local output]  - Node #1 of 2 ...
[18:32:49.599] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:49.601] [local output] Rscript port: 38599

[18:32:49.602] [local output]  - Node #2 of 2 ...
[18:32:49.602] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:49.604] [local output] Rscript port: 38599

[18:32:49.604] [local output] Getting setup options for 2 cluster nodes ... done
[18:32:49.604] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:49.605] [local output] Setting up PSOCK nodes in parallel
[18:32:49.605] List of 36
[18:32:49.605]  $ worker          : chr "localhost"
[18:32:49.605]   ..- attr(*, "localhost")= logi TRUE
[18:32:49.605]  $ master          : chr "localhost"
[18:32:49.605]  $ port            : int 38599
[18:32:49.605]  $ connectTimeout  : num 120
[18:32:49.605]  $ timeout         : num 120
[18:32:49.605]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:49.605]  $ homogeneous     : logi TRUE
[18:32:49.605]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:49.605]  $ rscript_envs    : NULL
[18:32:49.605]  $ rscript_libs    : NULL
[18:32:49.605]  $ rscript_startup : NULL
[18:32:49.605]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:49.605]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:49.605]  $ methods         : logi TRUE
[18:32:49.605]  $ socketOptions   : chr "no-delay"
[18:32:49.605]  $ useXDR          : logi FALSE
[18:32:49.605]  $ outfile         : chr "/dev/null"
[18:32:49.605]  $ renice          : int NA
[18:32:49.605]  $ rshcmd          : NULL
[18:32:49.605]  $ user            : chr(0) 
[18:32:49.605]  $ revtunnel       : logi FALSE
[18:32:49.605]  $ rshlogfile      : NULL
[18:32:49.605]  $ rshopts         : chr(0) 
[18:32:49.605]  $ rank            : int 1
[18:32:49.605]  $ manual          : logi FALSE
[18:32:49.605]  $ dryrun          : logi FALSE
[18:32:49.605]  $ quiet           : logi FALSE
[18:32:49.605]  $ setup_strategy  : chr "parallel"
[18:32:49.605]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:49.605]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f030ae2a18.pid"
[18:32:49.605]  $ rshcmd_label    : NULL
[18:32:49.605]  $ rsh_call        : NULL
[18:32:49.605]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:49.605]  $ localMachine    : logi TRUE
[18:32:49.605]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:49.605]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:49.605]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:49.605]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:49.605]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:49.605]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:49.605]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:49.605]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:49.605]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:49.605]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:49.605]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:49.605]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:49.605]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:49.605]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:49.605]  $ arguments       :List of 28
[18:32:49.605]   ..$ worker          : chr "localhost"
[18:32:49.605]   ..$ master          : NULL
[18:32:49.605]   ..$ port            : int 38599
[18:32:49.605]   ..$ connectTimeout  : num 120
[18:32:49.605]   ..$ timeout         : num 120
[18:32:49.605]   ..$ rscript         : NULL
[18:32:49.605]   ..$ homogeneous     : NULL
[18:32:49.605]   ..$ rscript_args    : NULL
[18:32:49.605]   ..$ rscript_envs    : NULL
[18:32:49.605]   ..$ rscript_libs    : NULL
[18:32:49.605]   ..$ rscript_startup : NULL
[18:32:49.605]   ..$ rscript_sh      : chr "auto"
[18:32:49.605]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:49.605]   ..$ methods         : logi TRUE
[18:32:49.605]   ..$ socketOptions   : chr "no-delay"
[18:32:49.605]   ..$ useXDR          : logi FALSE
[18:32:49.605]   ..$ outfile         : chr "/dev/null"
[18:32:49.605]   ..$ renice          : int NA
[18:32:49.605]   ..$ rshcmd          : NULL
[18:32:49.605]   ..$ user            : NULL
[18:32:49.605]   ..$ revtunnel       : logi NA
[18:32:49.605]   ..$ rshlogfile      : NULL
[18:32:49.605]   ..$ rshopts         : NULL
[18:32:49.605]   ..$ rank            : int 1
[18:32:49.605]   ..$ manual          : logi FALSE
[18:32:49.605]   ..$ dryrun          : logi FALSE
[18:32:49.605]   ..$ quiet           : logi FALSE
[18:32:49.605]   ..$ setup_strategy  : chr "parallel"
[18:32:49.605]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:49.636] [local output] System call to launch all workers:
[18:32:49.636] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f030ae2a18.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=38599 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:49.637] [local output] Starting PSOCK main server
[18:32:49.646] [local output] Workers launched
[18:32:49.646] [local output] Waiting for workers to connect back
[18:32:49.647]  - [local output] 0 workers out of 2 ready
[18:32:49.884]  - [local output] 0 workers out of 2 ready
[18:32:49.885]  - [local output] 1 workers out of 2 ready
[18:32:49.901]  - [local output] 1 workers out of 2 ready
[18:32:49.901]  - [local output] 2 workers out of 2 ready
[18:32:49.902] [local output] Launching of 2 workers completed
[18:32:49.902] [local output] Number of nodes in cluster: 2
[18:32:49.902] [local output] Collecting session information from 2 workers
[18:32:49.904] [local output]  - Worker #1 of 2
[18:32:49.905] [local output]  - Worker #2 of 2
[18:32:49.906] [local output] makeClusterPSOCK() ... done
   user  system elapsed 
   0.05    0.00    0.33 
Socket cluster with 2 nodes where 2 nodes are on host 'localhost' (R Under development (unstable) (2024-12-17 r87446 ucrt), platform x86_64-w64-mingw32)
> 
> 
> message("- makeClusterPSOCK() - with and w/out validation")
- makeClusterPSOCK() - with and w/out validation
> 
> cl <- makeClusterPSOCK(1L, validate = TRUE) ## default
[18:32:49.918] [local output] makeClusterPSOCK() ...
[18:32:49.924] [local output] Workers: [n = 1] 'localhost'
[18:32:49.929] [local output] Base port: 37170
[18:32:49.929] [local output] Getting setup options for 1 cluster nodes ...
[18:32:49.929] [local output]  - Node #1 of 1 ...
[18:32:49.930] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:49.933] [local output] Rscript port: 37170

[18:32:49.934] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:49.934] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:49.935] [local output] Setting up PSOCK nodes in parallel
[18:32:49.935] List of 36
[18:32:49.935]  $ worker          : chr "localhost"
[18:32:49.935]   ..- attr(*, "localhost")= logi TRUE
[18:32:49.935]  $ master          : chr "localhost"
[18:32:49.935]  $ port            : int 37170
[18:32:49.935]  $ connectTimeout  : num 120
[18:32:49.935]  $ timeout         : num 120
[18:32:49.935]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:49.935]  $ homogeneous     : logi TRUE
[18:32:49.935]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:49.935]  $ rscript_envs    : NULL
[18:32:49.935]  $ rscript_libs    : NULL
[18:32:49.935]  $ rscript_startup : NULL
[18:32:49.935]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:49.935]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:49.935]  $ methods         : logi TRUE
[18:32:49.935]  $ socketOptions   : chr "no-delay"
[18:32:49.935]  $ useXDR          : logi FALSE
[18:32:49.935]  $ outfile         : chr "/dev/null"
[18:32:49.935]  $ renice          : int NA
[18:32:49.935]  $ rshcmd          : NULL
[18:32:49.935]  $ user            : chr(0) 
[18:32:49.935]  $ revtunnel       : logi FALSE
[18:32:49.935]  $ rshlogfile      : NULL
[18:32:49.935]  $ rshopts         : chr(0) 
[18:32:49.935]  $ rank            : int 1
[18:32:49.935]  $ manual          : logi FALSE
[18:32:49.935]  $ dryrun          : logi FALSE
[18:32:49.935]  $ quiet           : logi FALSE
[18:32:49.935]  $ setup_strategy  : chr "parallel"
[18:32:49.935]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:49.935]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f07f963c6a.pid"
[18:32:49.935]  $ rshcmd_label    : NULL
[18:32:49.935]  $ rsh_call        : NULL
[18:32:49.935]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:49.935]  $ localMachine    : logi TRUE
[18:32:49.935]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:49.935]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:49.935]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:49.935]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:49.935]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:49.935]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:49.935]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:49.935]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:49.935]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:49.935]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:49.935]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:49.935]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:49.935]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:49.935]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:49.935]  $ arguments       :List of 28
[18:32:49.935]   ..$ worker          : chr "localhost"
[18:32:49.935]   ..$ master          : NULL
[18:32:49.935]   ..$ port            : int 37170
[18:32:49.935]   ..$ connectTimeout  : num 120
[18:32:49.935]   ..$ timeout         : num 120
[18:32:49.935]   ..$ rscript         : NULL
[18:32:49.935]   ..$ homogeneous     : NULL
[18:32:49.935]   ..$ rscript_args    : NULL
[18:32:49.935]   ..$ rscript_envs    : NULL
[18:32:49.935]   ..$ rscript_libs    : NULL
[18:32:49.935]   ..$ rscript_startup : NULL
[18:32:49.935]   ..$ rscript_sh      : chr "auto"
[18:32:49.935]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:49.935]   ..$ methods         : logi TRUE
[18:32:49.935]   ..$ socketOptions   : chr "no-delay"
[18:32:49.935]   ..$ useXDR          : logi FALSE
[18:32:49.935]   ..$ outfile         : chr "/dev/null"
[18:32:49.935]   ..$ renice          : int NA
[18:32:49.935]   ..$ rshcmd          : NULL
[18:32:49.935]   ..$ user            : NULL
[18:32:49.935]   ..$ revtunnel       : logi NA
[18:32:49.935]   ..$ rshlogfile      : NULL
[18:32:49.935]   ..$ rshopts         : NULL
[18:32:49.935]   ..$ rank            : int 1
[18:32:49.935]   ..$ manual          : logi FALSE
[18:32:49.935]   ..$ dryrun          : logi FALSE
[18:32:49.935]   ..$ quiet           : logi FALSE
[18:32:49.935]   ..$ setup_strategy  : chr "parallel"
[18:32:49.935]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:49.976] [local output] System call to launch all workers:
[18:32:49.977] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f07f963c6a.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=37170 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:49.977] [local output] Starting PSOCK main server
[18:32:49.984] [local output] Workers launched
[18:32:49.984] [local output] Waiting for workers to connect back
[18:32:49.984]  - [local output] 0 workers out of 1 ready
[18:32:50.244]  - [local output] 0 workers out of 1 ready
[18:32:50.245]  - [local output] 1 workers out of 1 ready
[18:32:50.245] [local output] Launching of 1 workers completed
[18:32:50.245] [local output] Number of nodes in cluster: 1
[18:32:50.246] [local output] Collecting session information from 1 workers
[18:32:50.247] [local output]  - Worker #1 of 1
[18:32:50.247] [local output] makeClusterPSOCK() ... done
> node <- cl[[1]]
> stopifnot(
+   is.list(node),
+   inherits(node, if (useXDR) "SOCKnode" else "SOCK0node"),
+   "session_info" %in% names(node)
+ )
> si <- node[["session_info"]]
> stopifnot(is.list(si))
> parallel::stopCluster(cl)
> 
> cl <- makeClusterPSOCK(1L, validate = FALSE)
[18:32:50.254] [local output] makeClusterPSOCK() ...
[18:32:50.260] [local output] Workers: [n = 1] 'localhost'
[18:32:50.264] [local output] Base port: 32013
[18:32:50.264] [local output] Getting setup options for 1 cluster nodes ...
[18:32:50.264] [local output]  - Node #1 of 1 ...
[18:32:50.265] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:50.268] [local output] Rscript port: 32013

[18:32:50.268] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:50.268] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:50.269] [local output] Setting up PSOCK nodes in parallel
[18:32:50.269] List of 36
[18:32:50.269]  $ worker          : chr "localhost"
[18:32:50.269]   ..- attr(*, "localhost")= logi TRUE
[18:32:50.269]  $ master          : chr "localhost"
[18:32:50.269]  $ port            : int 32013
[18:32:50.269]  $ connectTimeout  : num 120
[18:32:50.269]  $ timeout         : num 120
[18:32:50.269]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:50.269]  $ homogeneous     : logi TRUE
[18:32:50.269]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:50.269]  $ rscript_envs    : NULL
[18:32:50.269]  $ rscript_libs    : NULL
[18:32:50.269]  $ rscript_startup : NULL
[18:32:50.269]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:50.269]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:50.269]  $ methods         : logi TRUE
[18:32:50.269]  $ socketOptions   : chr "no-delay"
[18:32:50.269]  $ useXDR          : logi FALSE
[18:32:50.269]  $ outfile         : chr "/dev/null"
[18:32:50.269]  $ renice          : int NA
[18:32:50.269]  $ rshcmd          : NULL
[18:32:50.269]  $ user            : chr(0) 
[18:32:50.269]  $ revtunnel       : logi FALSE
[18:32:50.269]  $ rshlogfile      : NULL
[18:32:50.269]  $ rshopts         : chr(0) 
[18:32:50.269]  $ rank            : int 1
[18:32:50.269]  $ manual          : logi FALSE
[18:32:50.269]  $ dryrun          : logi FALSE
[18:32:50.269]  $ quiet           : logi FALSE
[18:32:50.269]  $ setup_strategy  : chr "parallel"
[18:32:50.269]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:50.269]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f06e454796.pid"
[18:32:50.269]  $ rshcmd_label    : NULL
[18:32:50.269]  $ rsh_call        : NULL
[18:32:50.269]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:50.269]  $ localMachine    : logi TRUE
[18:32:50.269]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:50.269]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:50.269]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:50.269]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:50.269]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:50.269]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:50.269]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:50.269]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:50.269]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:50.269]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:50.269]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:50.269]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:50.269]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:50.269]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:50.269]  $ arguments       :List of 28
[18:32:50.269]   ..$ worker          : chr "localhost"
[18:32:50.269]   ..$ master          : NULL
[18:32:50.269]   ..$ port            : int 32013
[18:32:50.269]   ..$ connectTimeout  : num 120
[18:32:50.269]   ..$ timeout         : num 120
[18:32:50.269]   ..$ rscript         : NULL
[18:32:50.269]   ..$ homogeneous     : NULL
[18:32:50.269]   ..$ rscript_args    : NULL
[18:32:50.269]   ..$ rscript_envs    : NULL
[18:32:50.269]   ..$ rscript_libs    : NULL
[18:32:50.269]   ..$ rscript_startup : NULL
[18:32:50.269]   ..$ rscript_sh      : chr "auto"
[18:32:50.269]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:50.269]   ..$ methods         : logi TRUE
[18:32:50.269]   ..$ socketOptions   : chr "no-delay"
[18:32:50.269]   ..$ useXDR          : logi FALSE
[18:32:50.269]   ..$ outfile         : chr "/dev/null"
[18:32:50.269]   ..$ renice          : int NA
[18:32:50.269]   ..$ rshcmd          : NULL
[18:32:50.269]   ..$ user            : NULL
[18:32:50.269]   ..$ revtunnel       : logi NA
[18:32:50.269]   ..$ rshlogfile      : NULL
[18:32:50.269]   ..$ rshopts         : NULL
[18:32:50.269]   ..$ rank            : int 1
[18:32:50.269]   ..$ manual          : logi FALSE
[18:32:50.269]   ..$ dryrun          : logi FALSE
[18:32:50.269]   ..$ quiet           : logi FALSE
[18:32:50.269]   ..$ setup_strategy  : chr "parallel"
[18:32:50.269]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:50.310] [local output] System call to launch all workers:
[18:32:50.311] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f06e454796.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=32013 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:50.311] [local output] Starting PSOCK main server
[18:32:50.319] [local output] Workers launched
[18:32:50.319] [local output] Waiting for workers to connect back
[18:32:50.319]  - [local output] 0 workers out of 1 ready
[18:32:50.577]  - [local output] 0 workers out of 1 ready
[18:32:50.578]  - [local output] 1 workers out of 1 ready
[18:32:50.579] [local output] Launching of 1 workers completed
[18:32:50.579] [local output] Number of nodes in cluster: 1
[18:32:50.579] [local output] makeClusterPSOCK() ... done
> node <- cl[[1]]
> stopifnot(
+   is.list(node),
+   inherits(node, if (useXDR) "SOCKnode" else "SOCK0node"),
+   ! "session_info" %in% names(node)
+ )
> parallel::stopCluster(cl)
> 
> 
> message("- makeClusterPSOCK() - w/out 'parallelly' on worker")
- makeClusterPSOCK() - w/out 'parallelly' on worker
> 
> ovalue <- Sys.getenv("R_LIBS_USER")
> Sys.setenv(R_LIBS_USER = tempdir())
> cl <- makeClusterPSOCK(1L, outfile = "")
[18:32:50.588] [local output] makeClusterPSOCK() ...
[18:32:50.594] [local output] Workers: [n = 1] 'localhost'
[18:32:50.599] [local output] Base port: 22761
[18:32:50.600] [local output] Getting setup options for 1 cluster nodes ...
[18:32:50.600] [local output]  - Node #1 of 1 ...
[18:32:50.601] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:50.603] [local output] Rscript port: 22761

[18:32:50.604] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:50.604] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:50.605] [local output] Setting up PSOCK nodes in parallel
[18:32:50.605] List of 36
[18:32:50.605]  $ worker          : chr "localhost"
[18:32:50.605]   ..- attr(*, "localhost")= logi TRUE
[18:32:50.605]  $ master          : chr "localhost"
[18:32:50.605]  $ port            : int 22761
[18:32:50.605]  $ connectTimeout  : num 120
[18:32:50.605]  $ timeout         : num 120
[18:32:50.605]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:50.605]  $ homogeneous     : logi TRUE
[18:32:50.605]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:50.605]  $ rscript_envs    : NULL
[18:32:50.605]  $ rscript_libs    : NULL
[18:32:50.605]  $ rscript_startup : NULL
[18:32:50.605]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:50.605]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:50.605]  $ methods         : logi TRUE
[18:32:50.605]  $ socketOptions   : chr "no-delay"
[18:32:50.605]  $ useXDR          : logi FALSE
[18:32:50.605]  $ outfile         : chr ""
[18:32:50.605]  $ renice          : int NA
[18:32:50.605]  $ rshcmd          : NULL
[18:32:50.605]  $ user            : chr(0) 
[18:32:50.605]  $ revtunnel       : logi FALSE
[18:32:50.605]  $ rshlogfile      : NULL
[18:32:50.605]  $ rshopts         : chr(0) 
[18:32:50.605]  $ rank            : int 1
[18:32:50.605]  $ manual          : logi FALSE
[18:32:50.605]  $ dryrun          : logi FALSE
[18:32:50.605]  $ quiet           : logi FALSE
[18:32:50.605]  $ setup_strategy  : chr "parallel"
[18:32:50.605]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:50.605]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f032ac7cd4.pid"
[18:32:50.605]  $ rshcmd_label    : NULL
[18:32:50.605]  $ rsh_call        : NULL
[18:32:50.605]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:50.605]  $ localMachine    : logi TRUE
[18:32:50.605]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:50.605]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:50.605]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:50.605]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:50.605]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:50.605]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:50.605]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:50.605]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:50.605]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:50.605]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:50.605]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:50.605]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:50.605]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:50.605]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:50.605]  $ arguments       :List of 28
[18:32:50.605]   ..$ worker          : chr "localhost"
[18:32:50.605]   ..$ master          : NULL
[18:32:50.605]   ..$ port            : int 22761
[18:32:50.605]   ..$ connectTimeout  : num 120
[18:32:50.605]   ..$ timeout         : num 120
[18:32:50.605]   ..$ rscript         : NULL
[18:32:50.605]   ..$ homogeneous     : NULL
[18:32:50.605]   ..$ rscript_args    : NULL
[18:32:50.605]   ..$ rscript_envs    : NULL
[18:32:50.605]   ..$ rscript_libs    : NULL
[18:32:50.605]   ..$ rscript_startup : NULL
[18:32:50.605]   ..$ rscript_sh      : chr "auto"
[18:32:50.605]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:50.605]   ..$ methods         : logi TRUE
[18:32:50.605]   ..$ socketOptions   : chr "no-delay"
[18:32:50.605]   ..$ useXDR          : logi FALSE
[18:32:50.605]   ..$ outfile         : chr ""
[18:32:50.605]   ..$ renice          : int NA
[18:32:50.605]   ..$ rshcmd          : NULL
[18:32:50.605]   ..$ user            : NULL
[18:32:50.605]   ..$ revtunnel       : logi NA
[18:32:50.605]   ..$ rshlogfile      : NULL
[18:32:50.605]   ..$ rshopts         : NULL
[18:32:50.605]   ..$ rank            : int 1
[18:32:50.605]   ..$ manual          : logi FALSE
[18:32:50.605]   ..$ dryrun          : logi FALSE
[18:32:50.605]   ..$ quiet           : logi FALSE
[18:32:50.605]   ..$ setup_strategy  : chr "parallel"
[18:32:50.605]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:50.638] [local output] System call to launch all workers:
[18:32:50.638] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f032ac7cd4.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=22761 OUT= TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:50.638] [local output] Starting PSOCK main server
[18:32:50.646] [local output] Workers launched
[18:32:50.646] [local output] Waiting for workers to connect back
[18:32:50.646]  - [local output] 0 workers out of 1 ready
starting worker pid=135080 on localhost:22761 at 18:32:50.897
[18:32:50.909]  - [local output] 0 workers out of 1 ready
[18:32:50.910]  - [local output] 1 workers out of 1 ready
[18:32:50.910] [local output] Launching of 1 workers completed
[18:32:50.910] [local output] Number of nodes in cluster: 1
[18:32:50.911] [local output] Collecting session information from 1 workers
[18:32:50.912] [local output]  - Worker #1 of 1
[18:32:50.912] [local output] makeClusterPSOCK() ... done
> print(cl)
Socket cluster with 1 nodes where 1 node is on host 'localhost' (R Under development (unstable) (2024-12-17 r87446 ucrt), platform x86_64-w64-mingw32)
> parallel::stopCluster(cl)
> Sys.setenv(R_LIBS_USER = ovalue)
> 
> 
> message("- makeClusterPSOCK() - assert 'parallelly' is not loaded")
- makeClusterPSOCK() - assert 'parallelly' is not loaded
> 
> cl <- makeClusterPSOCK(1L)
[18:32:50.921] [local output] makeClusterPSOCK() ...
[18:32:50.926] [local output] Workers: [n = 1] 'localhost'
[18:32:50.931] [local output] Base port: 28175
[18:32:50.931] [local output] Getting setup options for 1 cluster nodes ...
[18:32:50.931] [local output]  - Node #1 of 1 ...
[18:32:50.932] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:50.935] [local output] Rscript port: 28175

[18:32:50.935] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:50.936] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:50.936] [local output] Setting up PSOCK nodes in parallel
[18:32:50.937] List of 36
[18:32:50.937]  $ worker          : chr "localhost"
[18:32:50.937]   ..- attr(*, "localhost")= logi TRUE
[18:32:50.937]  $ master          : chr "localhost"
[18:32:50.937]  $ port            : int 28175
[18:32:50.937]  $ connectTimeout  : num 120
[18:32:50.937]  $ timeout         : num 120
[18:32:50.937]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:50.937]  $ homogeneous     : logi TRUE
[18:32:50.937]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:50.937]  $ rscript_envs    : NULL
[18:32:50.937]  $ rscript_libs    : NULL
[18:32:50.937]  $ rscript_startup : NULL
[18:32:50.937]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:50.937]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:50.937]  $ methods         : logi TRUE
[18:32:50.937]  $ socketOptions   : chr "no-delay"
[18:32:50.937]  $ useXDR          : logi FALSE
[18:32:50.937]  $ outfile         : chr "/dev/null"
[18:32:50.937]  $ renice          : int NA
[18:32:50.937]  $ rshcmd          : NULL
[18:32:50.937]  $ user            : chr(0) 
[18:32:50.937]  $ revtunnel       : logi FALSE
[18:32:50.937]  $ rshlogfile      : NULL
[18:32:50.937]  $ rshopts         : chr(0) 
[18:32:50.937]  $ rank            : int 1
[18:32:50.937]  $ manual          : logi FALSE
[18:32:50.937]  $ dryrun          : logi FALSE
[18:32:50.937]  $ quiet           : logi FALSE
[18:32:50.937]  $ setup_strategy  : chr "parallel"
[18:32:50.937]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:50.937]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f072153e17.pid"
[18:32:50.937]  $ rshcmd_label    : NULL
[18:32:50.937]  $ rsh_call        : NULL
[18:32:50.937]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:50.937]  $ localMachine    : logi TRUE
[18:32:50.937]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:50.937]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:50.937]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:50.937]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:50.937]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:50.937]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:50.937]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:50.937]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:50.937]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:50.937]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:50.937]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:50.937]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:50.937]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:50.937]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:50.937]  $ arguments       :List of 28
[18:32:50.937]   ..$ worker          : chr "localhost"
[18:32:50.937]   ..$ master          : NULL
[18:32:50.937]   ..$ port            : int 28175
[18:32:50.937]   ..$ connectTimeout  : num 120
[18:32:50.937]   ..$ timeout         : num 120
[18:32:50.937]   ..$ rscript         : NULL
[18:32:50.937]   ..$ homogeneous     : NULL
[18:32:50.937]   ..$ rscript_args    : NULL
[18:32:50.937]   ..$ rscript_envs    : NULL
[18:32:50.937]   ..$ rscript_libs    : NULL
[18:32:50.937]   ..$ rscript_startup : NULL
[18:32:50.937]   ..$ rscript_sh      : chr "auto"
[18:32:50.937]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:50.937]   ..$ methods         : logi TRUE
[18:32:50.937]   ..$ socketOptions   : chr "no-delay"
[18:32:50.937]   ..$ useXDR          : logi FALSE
[18:32:50.937]   ..$ outfile         : chr "/dev/null"
[18:32:50.937]   ..$ renice          : int NA
[18:32:50.937]   ..$ rshcmd          : NULL
[18:32:50.937]   ..$ user            : NULL
[18:32:50.937]   ..$ revtunnel       : logi NA
[18:32:50.937]   ..$ rshlogfile      : NULL
[18:32:50.937]   ..$ rshopts         : NULL
[18:32:50.937]   ..$ rank            : int 1
[18:32:50.937]   ..$ manual          : logi FALSE
[18:32:50.937]   ..$ dryrun          : logi FALSE
[18:32:50.937]   ..$ quiet           : logi FALSE
[18:32:50.937]   ..$ setup_strategy  : chr "parallel"
[18:32:50.937]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:50.975] [local output] System call to launch all workers:
[18:32:50.976] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f072153e17.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=28175 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:50.976] [local output] Starting PSOCK main server
[18:32:50.982] [local output] Workers launched
[18:32:50.982] [local output] Waiting for workers to connect back
[18:32:50.983]  - [local output] 0 workers out of 1 ready
[18:32:51.246]  - [local output] 0 workers out of 1 ready
[18:32:51.247]  - [local output] 1 workers out of 1 ready
[18:32:51.247] [local output] Launching of 1 workers completed
[18:32:51.247] [local output] Number of nodes in cluster: 1
[18:32:51.248] [local output] Collecting session information from 1 workers
[18:32:51.249] [local output]  - Worker #1 of 1
[18:32:51.249] [local output] makeClusterPSOCK() ... done
> ns <- parallel::clusterCall(cl, function() { loadedNamespaces() })
> print(ns)
[[1]]
[1] "compiler"  "graphics"  "parallel"  "utils"     "grDevices" "stats"    
[7] "datasets"  "methods"   "base"     

> stopifnot(!is.element("parallelly", ns))
> parallel::stopCluster(cl)
> 
> 
> message("- makeClusterPSOCK() - launch via the R executable")
- makeClusterPSOCK() - launch via the R executable
> 
> if (.Platform$OS.type == "windows") {
+   ## R and R.exe fails on MS Windows, cf. R-devel thread "MS Windows: R does
+   ## not escape quotes in CLI options the same way as Rterm and Rscript"
+   ## on 2021-12-15.
+   rscripts <- file.path(R.home("bin"), c("Rterm", "Rterm.exe"))
+ } else {
+   rscripts <- file.path(R.home("bin"), "R")
+ }
> 
> for (rscript in rscripts) {
+   message("  Launcher: ", sQuote(rscript))
+   rscript_args <- c("--no-echo", "--no-restore", "*", "--args")
+   cl <- tryCatch({
+     makeClusterPSOCK(1L, rscript = rscript, rscript_args = rscript_args)
+   }, warning = identity)
+   stopifnot(inherits(cl, "cluster"))
+   parallel::stopCluster(cl)
+ }
  Launcher: 'D:/RCompile/recent/R/bin/x64/Rterm'
[18:32:51.263] [local output] makeClusterPSOCK() ...
[18:32:51.268] [local output] Workers: [n = 1] 'localhost'
[18:32:51.272] [local output] Base port: 30238
[18:32:51.273] [local output] Getting setup options for 1 cluster nodes ...
[18:32:51.273] [local output]  - Node #1 of 1 ...
[18:32:51.274] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:51.276] Testing if worker's PID can be inferred: '"D:\RCompile\recent\R\bin\x64\Rterm.exe" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0753913fe.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0753913fe.pid\")"'
[18:32:51.718] - Possible to infer worker's PID: TRUE
[18:32:51.719] [local output] Rscript port: 30238

[18:32:51.720] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:51.720] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:51.721] [local output] Setting up PSOCK nodes in parallel
[18:32:51.721] List of 36
[18:32:51.721]  $ worker          : chr "localhost"
[18:32:51.721]   ..- attr(*, "localhost")= logi TRUE
[18:32:51.721]  $ master          : chr "localhost"
[18:32:51.721]  $ port            : int 30238
[18:32:51.721]  $ connectTimeout  : num 120
[18:32:51.721]  $ timeout         : num 120
[18:32:51.721]  $ rscript         : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\""
[18:32:51.721]  $ homogeneous     : logi TRUE
[18:32:51.721]  $ rscript_args    : chr "R_DEFAULT_PACKAGES=datasets,utils,grDevices,graphics,stats,methods --no-echo --no-restore -e \"#label=makeClust"| __truncated__
[18:32:51.721]  $ rscript_envs    : NULL
[18:32:51.721]  $ rscript_libs    : NULL
[18:32:51.721]  $ rscript_startup : NULL
[18:32:51.721]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:51.721]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:51.721]  $ methods         : logi TRUE
[18:32:51.721]  $ socketOptions   : chr "no-delay"
[18:32:51.721]  $ useXDR          : logi FALSE
[18:32:51.721]  $ outfile         : chr "/dev/null"
[18:32:51.721]  $ renice          : int NA
[18:32:51.721]  $ rshcmd          : NULL
[18:32:51.721]  $ user            : chr(0) 
[18:32:51.721]  $ revtunnel       : logi FALSE
[18:32:51.721]  $ rshlogfile      : NULL
[18:32:51.721]  $ rshopts         : chr(0) 
[18:32:51.721]  $ rank            : int 1
[18:32:51.721]  $ manual          : logi FALSE
[18:32:51.721]  $ dryrun          : logi FALSE
[18:32:51.721]  $ quiet           : logi FALSE
[18:32:51.721]  $ setup_strategy  : chr "parallel"
[18:32:51.721]  $ local_cmd       : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\" R_DEFAULT_PACKAGES=datasets,utils,grDevices,graphics,stats,met"| __truncated__
[18:32:51.721]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0753913fe.pid"
[18:32:51.721]  $ rshcmd_label    : NULL
[18:32:51.721]  $ rsh_call        : NULL
[18:32:51.721]  $ cmd             : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\" R_DEFAULT_PACKAGES=datasets,utils,grDevices,graphics,stats,met"| __truncated__
[18:32:51.721]  $ localMachine    : logi TRUE
[18:32:51.721]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:51.721]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:51.721]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:51.721]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:51.721]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:51.721]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:51.721]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:51.721]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:51.721]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:51.721]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:51.721]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:51.721]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:51.721]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:51.721]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:51.721]  $ arguments       :List of 28
[18:32:51.721]   ..$ worker          : chr "localhost"
[18:32:51.721]   ..$ master          : NULL
[18:32:51.721]   ..$ port            : int 30238
[18:32:51.721]   ..$ connectTimeout  : num 120
[18:32:51.721]   ..$ timeout         : num 120
[18:32:51.721]   ..$ rscript         : chr "D:/RCompile/recent/R/bin/x64/Rterm"
[18:32:51.721]   ..$ homogeneous     : NULL
[18:32:51.721]   ..$ rscript_args    : chr [1:4] "--no-echo" "--no-restore" "*" "--args"
[18:32:51.721]   ..$ rscript_envs    : NULL
[18:32:51.721]   ..$ rscript_libs    : NULL
[18:32:51.721]   ..$ rscript_startup : NULL
[18:32:51.721]   ..$ rscript_sh      : chr "auto"
[18:32:51.721]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:51.721]   ..$ methods         : logi TRUE
[18:32:51.721]   ..$ socketOptions   : chr "no-delay"
[18:32:51.721]   ..$ useXDR          : logi FALSE
[18:32:51.721]   ..$ outfile         : chr "/dev/null"
[18:32:51.721]   ..$ renice          : int NA
[18:32:51.721]   ..$ rshcmd          : NULL
[18:32:51.721]   ..$ user            : NULL
[18:32:51.721]   ..$ revtunnel       : logi NA
[18:32:51.721]   ..$ rshlogfile      : NULL
[18:32:51.721]   ..$ rshopts         : NULL
[18:32:51.721]   ..$ rank            : int 1
[18:32:51.721]   ..$ manual          : logi FALSE
[18:32:51.721]   ..$ dryrun          : logi FALSE
[18:32:51.721]   ..$ quiet           : logi FALSE
[18:32:51.721]   ..$ setup_strategy  : chr "parallel"
[18:32:51.721]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:51.755] [local output] System call to launch all workers:
[18:32:51.755] [local output] "D:\RCompile\recent\R\bin\x64\Rterm.exe" R_DEFAULT_PACKAGES=datasets,utils,grDevices,graphics,stats,methods --no-echo --no-restore -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0753913fe.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" --args MASTER=localhost PORT=30238 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:51.756] [local output] Starting PSOCK main server
[18:32:51.762] [local output] Workers launched
[18:32:51.763] [local output] Waiting for workers to connect back
[18:32:51.763]  - [local output] 0 workers out of 1 ready
[18:32:52.071]  - [local output] 0 workers out of 1 ready
[18:32:52.072]  - [local output] 1 workers out of 1 ready
[18:32:52.072] [local output] Launching of 1 workers completed
[18:32:52.072] [local output] Number of nodes in cluster: 1
[18:32:52.073] [local output] Collecting session information from 1 workers
[18:32:52.074] [local output]  - Worker #1 of 1
[18:32:52.074] [local output] makeClusterPSOCK() ... done
  Launcher: 'D:/RCompile/recent/R/bin/x64/Rterm.exe'
[18:32:52.081] [local output] makeClusterPSOCK() ...
[18:32:52.085] [local output] Workers: [n = 1] 'localhost'
[18:32:52.088] [local output] Base port: 21880
[18:32:52.089] [local output] Getting setup options for 1 cluster nodes ...
[18:32:52.089] [local output]  - Node #1 of 1 ...
[18:32:52.090] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:52.092] [local output] Rscript port: 21880

[18:32:52.092] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:52.092] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:52.093] [local output] Setting up PSOCK nodes in parallel
[18:32:52.093] List of 36
[18:32:52.093]  $ worker          : chr "localhost"
[18:32:52.093]   ..- attr(*, "localhost")= logi TRUE
[18:32:52.093]  $ master          : chr "localhost"
[18:32:52.093]  $ port            : int 21880
[18:32:52.093]  $ connectTimeout  : num 120
[18:32:52.093]  $ timeout         : num 120
[18:32:52.093]  $ rscript         : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\""
[18:32:52.093]  $ homogeneous     : logi TRUE
[18:32:52.093]  $ rscript_args    : chr "R_DEFAULT_PACKAGES=datasets,utils,grDevices,graphics,stats,methods --no-echo --no-restore -e \"#label=makeClust"| __truncated__
[18:32:52.093]  $ rscript_envs    : NULL
[18:32:52.093]  $ rscript_libs    : NULL
[18:32:52.093]  $ rscript_startup : NULL
[18:32:52.093]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:52.093]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:52.093]  $ methods         : logi TRUE
[18:32:52.093]  $ socketOptions   : chr "no-delay"
[18:32:52.093]  $ useXDR          : logi FALSE
[18:32:52.093]  $ outfile         : chr "/dev/null"
[18:32:52.093]  $ renice          : int NA
[18:32:52.093]  $ rshcmd          : NULL
[18:32:52.093]  $ user            : chr(0) 
[18:32:52.093]  $ revtunnel       : logi FALSE
[18:32:52.093]  $ rshlogfile      : NULL
[18:32:52.093]  $ rshopts         : chr(0) 
[18:32:52.093]  $ rank            : int 1
[18:32:52.093]  $ manual          : logi FALSE
[18:32:52.093]  $ dryrun          : logi FALSE
[18:32:52.093]  $ quiet           : logi FALSE
[18:32:52.093]  $ setup_strategy  : chr "parallel"
[18:32:52.093]  $ local_cmd       : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\" R_DEFAULT_PACKAGES=datasets,utils,grDevices,graphics,stats,met"| __truncated__
[18:32:52.093]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0f59489e.pid"
[18:32:52.093]  $ rshcmd_label    : NULL
[18:32:52.093]  $ rsh_call        : NULL
[18:32:52.093]  $ cmd             : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\" R_DEFAULT_PACKAGES=datasets,utils,grDevices,graphics,stats,met"| __truncated__
[18:32:52.093]  $ localMachine    : logi TRUE
[18:32:52.093]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:52.093]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:52.093]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:52.093]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:52.093]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:52.093]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:52.093]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:52.093]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:52.093]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:52.093]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:52.093]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:52.093]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:52.093]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:52.093]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:52.093]  $ arguments       :List of 28
[18:32:52.093]   ..$ worker          : chr "localhost"
[18:32:52.093]   ..$ master          : NULL
[18:32:52.093]   ..$ port            : int 21880
[18:32:52.093]   ..$ connectTimeout  : num 120
[18:32:52.093]   ..$ timeout         : num 120
[18:32:52.093]   ..$ rscript         : chr "D:/RCompile/recent/R/bin/x64/Rterm.exe"
[18:32:52.093]   ..$ homogeneous     : NULL
[18:32:52.093]   ..$ rscript_args    : chr [1:4] "--no-echo" "--no-restore" "*" "--args"
[18:32:52.093]   ..$ rscript_envs    : NULL
[18:32:52.093]   ..$ rscript_libs    : NULL
[18:32:52.093]   ..$ rscript_startup : NULL
[18:32:52.093]   ..$ rscript_sh      : chr "auto"
[18:32:52.093]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:52.093]   ..$ methods         : logi TRUE
[18:32:52.093]   ..$ socketOptions   : chr "no-delay"
[18:32:52.093]   ..$ useXDR          : logi FALSE
[18:32:52.093]   ..$ outfile         : chr "/dev/null"
[18:32:52.093]   ..$ renice          : int NA
[18:32:52.093]   ..$ rshcmd          : NULL
[18:32:52.093]   ..$ user            : NULL
[18:32:52.093]   ..$ revtunnel       : logi NA
[18:32:52.093]   ..$ rshlogfile      : NULL
[18:32:52.093]   ..$ rshopts         : NULL
[18:32:52.093]   ..$ rank            : int 1
[18:32:52.093]   ..$ manual          : logi FALSE
[18:32:52.093]   ..$ dryrun          : logi FALSE
[18:32:52.093]   ..$ quiet           : logi FALSE
[18:32:52.093]   ..$ setup_strategy  : chr "parallel"
[18:32:52.093]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:52.119] [local output] System call to launch all workers:
[18:32:52.119] [local output] "D:\RCompile\recent\R\bin\x64\Rterm.exe" R_DEFAULT_PACKAGES=datasets,utils,grDevices,graphics,stats,methods --no-echo --no-restore -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f0f59489e.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" --args MASTER=localhost PORT=21880 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:52.120] [local output] Starting PSOCK main server
[18:32:52.125] [local output] Workers launched
[18:32:52.125] [local output] Waiting for workers to connect back
[18:32:52.125]  - [local output] 0 workers out of 1 ready
[18:32:52.401]  - [local output] 0 workers out of 1 ready
[18:32:52.402]  - [local output] 1 workers out of 1 ready
[18:32:52.403] [local output] Launching of 1 workers completed
[18:32:52.403] [local output] Number of nodes in cluster: 1
[18:32:52.403] [local output] Collecting session information from 1 workers
[18:32:52.405] [local output]  - Worker #1 of 1
[18:32:52.405] [local output] makeClusterPSOCK() ... done
> 
> 
> message("- makeClusterPSOCK() - default packages")
- makeClusterPSOCK() - default packages
> 
> if (.Platform$OS.type == "windows") {
+   ## R and R.exe fails on MS Windows, cf. R-devel thread "MS Windows: R does
+   ## not escape quotes in CLI options the same way as Rterm and Rscript"
+   ## on 2021-12-15.
+   rscripts <- file.path(R.home("bin"), c("Rscript", "Rterm", "Rterm.exe"))
+ } else {
+   rscripts <- file.path(R.home("bin"), c("Rscript", "R"))
+ }
> default_packages <- c("utils", "tools")
> for (rscript in rscripts) {
+   message("  Launcher: ", sQuote(rscript))
+   if (tools::file_path_sans_ext(basename(rscript)) %in% c("R", "Rterm")) {
+     rscript_args <- c("--no-echo", "--no-restore", "*", "--args")
+   } else {
+     rscript_args <- NULL
+   }
+   cl <- tryCatch({
+     makeClusterPSOCK(1L, rscript = rscript, rscript_args = rscript_args, default_packages = default_packages)
+   }, warning = identity)
+   stopifnot(inherits(cl, "cluster"))
+   pkgs <- parallel::clusterEvalQ(cl, { getOption("defaultPackages") })[[1]]
+   stopifnot(identical(pkgs, default_packages))
+   parallel::stopCluster(cl)
+ }
  Launcher: 'D:/RCompile/recent/R/bin/x64/Rscript'
[18:32:52.430] [local output] makeClusterPSOCK() ...
[18:32:52.434] [local output] Workers: [n = 1] 'localhost'
[18:32:52.438] [local output] Base port: 20384
[18:32:52.438] [local output] Getting setup options for 1 cluster nodes ...
[18:32:52.438] [local output]  - Node #1 of 1 ...
[18:32:52.439] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:52.440] Testing if worker's PID can be inferred: '"D:\RCompile\recent\R\bin\x64\Rscript.exe" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f07b8a1f81.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f07b8a1f81.pid\")"'
[18:32:52.765] - Possible to infer worker's PID: TRUE
[18:32:52.766] [local output] Rscript port: 20384

[18:32:52.767] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:52.767] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:52.768] [local output] Setting up PSOCK nodes in parallel
[18:32:52.768] List of 36
[18:32:52.768]  $ worker          : chr "localhost"
[18:32:52.768]   ..- attr(*, "localhost")= logi TRUE
[18:32:52.768]  $ master          : chr "localhost"
[18:32:52.768]  $ port            : int 20384
[18:32:52.768]  $ connectTimeout  : num 120
[18:32:52.768]  $ timeout         : num 120
[18:32:52.768]  $ rscript         : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rscript.exe\""
[18:32:52.768]  $ homogeneous     : logi TRUE
[18:32:52.768]  $ rscript_args    : chr "--default-packages=utils,tools -e \"#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN\" -e \"try(suppressWarnings(c"| __truncated__
[18:32:52.768]  $ rscript_envs    : NULL
[18:32:52.768]  $ rscript_libs    : NULL
[18:32:52.768]  $ rscript_startup : NULL
[18:32:52.768]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:52.768]  $ default_packages: chr [1:2] "utils" "tools"
[18:32:52.768]  $ methods         : logi TRUE
[18:32:52.768]  $ socketOptions   : chr "no-delay"
[18:32:52.768]  $ useXDR          : logi FALSE
[18:32:52.768]  $ outfile         : chr "/dev/null"
[18:32:52.768]  $ renice          : int NA
[18:32:52.768]  $ rshcmd          : NULL
[18:32:52.768]  $ user            : chr(0) 
[18:32:52.768]  $ revtunnel       : logi FALSE
[18:32:52.768]  $ rshlogfile      : NULL
[18:32:52.768]  $ rshopts         : chr(0) 
[18:32:52.768]  $ rank            : int 1
[18:32:52.768]  $ manual          : logi FALSE
[18:32:52.768]  $ dryrun          : logi FALSE
[18:32:52.768]  $ quiet           : logi FALSE
[18:32:52.768]  $ setup_strategy  : chr "parallel"
[18:32:52.768]  $ local_cmd       : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rscript.exe\" --default-packages=utils,tools -e \"#label=makeClusterPSOCK."| __truncated__
[18:32:52.768]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f07b8a1f81.pid"
[18:32:52.768]  $ rshcmd_label    : NULL
[18:32:52.768]  $ rsh_call        : NULL
[18:32:52.768]  $ cmd             : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rscript.exe\" --default-packages=utils,tools -e \"#label=makeClusterPSOCK."| __truncated__
[18:32:52.768]  $ localMachine    : logi TRUE
[18:32:52.768]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:52.768]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:52.768]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:52.768]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:52.768]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:52.768]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:52.768]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:52.768]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:52.768]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:52.768]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:52.768]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:52.768]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:52.768]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:52.768]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:52.768]  $ arguments       :List of 28
[18:32:52.768]   ..$ worker          : chr "localhost"
[18:32:52.768]   ..$ master          : NULL
[18:32:52.768]   ..$ port            : int 20384
[18:32:52.768]   ..$ connectTimeout  : num 120
[18:32:52.768]   ..$ timeout         : num 120
[18:32:52.768]   ..$ rscript         : chr "D:/RCompile/recent/R/bin/x64/Rscript"
[18:32:52.768]   ..$ homogeneous     : NULL
[18:32:52.768]   ..$ rscript_args    : NULL
[18:32:52.768]   ..$ rscript_envs    : NULL
[18:32:52.768]   ..$ rscript_libs    : NULL
[18:32:52.768]   ..$ rscript_startup : NULL
[18:32:52.768]   ..$ rscript_sh      : chr "auto"
[18:32:52.768]   ..$ default_packages: chr [1:2] "utils" "tools"
[18:32:52.768]   ..$ methods         : logi TRUE
[18:32:52.768]   ..$ socketOptions   : chr "no-delay"
[18:32:52.768]   ..$ useXDR          : logi FALSE
[18:32:52.768]   ..$ outfile         : chr "/dev/null"
[18:32:52.768]   ..$ renice          : int NA
[18:32:52.768]   ..$ rshcmd          : NULL
[18:32:52.768]   ..$ user            : NULL
[18:32:52.768]   ..$ revtunnel       : logi NA
[18:32:52.768]   ..$ rshlogfile      : NULL
[18:32:52.768]   ..$ rshopts         : NULL
[18:32:52.768]   ..$ rank            : int 1
[18:32:52.768]   ..$ manual          : logi FALSE
[18:32:52.768]   ..$ dryrun          : logi FALSE
[18:32:52.768]   ..$ quiet           : logi FALSE
[18:32:52.768]   ..$ setup_strategy  : chr "parallel"
[18:32:52.768]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:52.801] [local output] System call to launch all workers:
[18:32:52.801] [local output] "D:\RCompile\recent\R\bin\x64\Rscript.exe" --default-packages=utils,tools -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f07b8a1f81.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=20384 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:52.801] [local output] Starting PSOCK main server
[18:32:52.808] [local output] Workers launched
[18:32:52.808] [local output] Waiting for workers to connect back
[18:32:52.808]  - [local output] 0 workers out of 1 ready
[18:32:52.941]  - [local output] 0 workers out of 1 ready
[18:32:52.942]  - [local output] 1 workers out of 1 ready
[18:32:52.942] [local output] Launching of 1 workers completed
[18:32:52.942] [local output] Number of nodes in cluster: 1
[18:32:52.943] [local output] Collecting session information from 1 workers
[18:32:52.944] [local output]  - Worker #1 of 1
[18:32:52.945] [local output] makeClusterPSOCK() ... done
  Launcher: 'D:/RCompile/recent/R/bin/x64/Rterm'
[18:32:52.955] [local output] makeClusterPSOCK() ...
[18:32:52.962] [local output] Workers: [n = 1] 'localhost'
[18:32:52.968] [local output] Base port: 33624
[18:32:52.968] [local output] Getting setup options for 1 cluster nodes ...
[18:32:52.968] [local output]  - Node #1 of 1 ...
[18:32:52.969] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:52.972] [local output] Rscript port: 33624

[18:32:52.973] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:52.973] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:52.974] [local output] Setting up PSOCK nodes in parallel
[18:32:52.974] List of 36
[18:32:52.974]  $ worker          : chr "localhost"
[18:32:52.974]   ..- attr(*, "localhost")= logi TRUE
[18:32:52.974]  $ master          : chr "localhost"
[18:32:52.974]  $ port            : int 33624
[18:32:52.974]  $ connectTimeout  : num 120
[18:32:52.974]  $ timeout         : num 120
[18:32:52.974]  $ rscript         : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\""
[18:32:52.974]  $ homogeneous     : logi TRUE
[18:32:52.974]  $ rscript_args    : chr "R_DEFAULT_PACKAGES=utils,tools --no-echo --no-restore -e \"#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN\" -e \"| __truncated__
[18:32:52.974]  $ rscript_envs    : NULL
[18:32:52.974]  $ rscript_libs    : NULL
[18:32:52.974]  $ rscript_startup : NULL
[18:32:52.974]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:52.974]  $ default_packages: chr [1:2] "utils" "tools"
[18:32:52.974]  $ methods         : logi TRUE
[18:32:52.974]  $ socketOptions   : chr "no-delay"
[18:32:52.974]  $ useXDR          : logi FALSE
[18:32:52.974]  $ outfile         : chr "/dev/null"
[18:32:52.974]  $ renice          : int NA
[18:32:52.974]  $ rshcmd          : NULL
[18:32:52.974]  $ user            : chr(0) 
[18:32:52.974]  $ revtunnel       : logi FALSE
[18:32:52.974]  $ rshlogfile      : NULL
[18:32:52.974]  $ rshopts         : chr(0) 
[18:32:52.974]  $ rank            : int 1
[18:32:52.974]  $ manual          : logi FALSE
[18:32:52.974]  $ dryrun          : logi FALSE
[18:32:52.974]  $ quiet           : logi FALSE
[18:32:52.974]  $ setup_strategy  : chr "parallel"
[18:32:52.974]  $ local_cmd       : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\" R_DEFAULT_PACKAGES=utils,tools --no-echo --no-restore -e \"#la"| __truncated__
[18:32:52.974]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f024514eee.pid"
[18:32:52.974]  $ rshcmd_label    : NULL
[18:32:52.974]  $ rsh_call        : NULL
[18:32:52.974]  $ cmd             : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\" R_DEFAULT_PACKAGES=utils,tools --no-echo --no-restore -e \"#la"| __truncated__
[18:32:52.974]  $ localMachine    : logi TRUE
[18:32:52.974]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:52.974]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:52.974]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:52.974]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:52.974]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:52.974]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:52.974]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:52.974]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:52.974]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:52.974]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:52.974]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:52.974]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:52.974]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:52.974]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:52.974]  $ arguments       :List of 28
[18:32:52.974]   ..$ worker          : chr "localhost"
[18:32:52.974]   ..$ master          : NULL
[18:32:52.974]   ..$ port            : int 33624
[18:32:52.974]   ..$ connectTimeout  : num 120
[18:32:52.974]   ..$ timeout         : num 120
[18:32:52.974]   ..$ rscript         : chr "D:/RCompile/recent/R/bin/x64/Rterm"
[18:32:52.974]   ..$ homogeneous     : NULL
[18:32:52.974]   ..$ rscript_args    : chr [1:4] "--no-echo" "--no-restore" "*" "--args"
[18:32:52.974]   ..$ rscript_envs    : NULL
[18:32:52.974]   ..$ rscript_libs    : NULL
[18:32:52.974]   ..$ rscript_startup : NULL
[18:32:52.974]   ..$ rscript_sh      : chr "auto"
[18:32:52.974]   ..$ default_packages: chr [1:2] "utils" "tools"
[18:32:52.974]   ..$ methods         : logi TRUE
[18:32:52.974]   ..$ socketOptions   : chr "no-delay"
[18:32:52.974]   ..$ useXDR          : logi FALSE
[18:32:52.974]   ..$ outfile         : chr "/dev/null"
[18:32:52.974]   ..$ renice          : int NA
[18:32:52.974]   ..$ rshcmd          : NULL
[18:32:52.974]   ..$ user            : NULL
[18:32:52.974]   ..$ revtunnel       : logi NA
[18:32:52.974]   ..$ rshlogfile      : NULL
[18:32:52.974]   ..$ rshopts         : NULL
[18:32:52.974]   ..$ rank            : int 1
[18:32:52.974]   ..$ manual          : logi FALSE
[18:32:52.974]   ..$ dryrun          : logi FALSE
[18:32:52.974]   ..$ quiet           : logi FALSE
[18:32:52.974]   ..$ setup_strategy  : chr "parallel"
[18:32:52.974]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:53.008] [local output] System call to launch all workers:
[18:32:53.008] [local output] "D:\RCompile\recent\R\bin\x64\Rterm.exe" R_DEFAULT_PACKAGES=utils,tools --no-echo --no-restore -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f024514eee.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" --args MASTER=localhost PORT=33624 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:53.008] [local output] Starting PSOCK main server
[18:32:53.015] [local output] Workers launched
[18:32:53.016] [local output] Waiting for workers to connect back
[18:32:53.016]  - [local output] 0 workers out of 1 ready
[18:32:53.148]  - [local output] 0 workers out of 1 ready
[18:32:53.148]  - [local output] 1 workers out of 1 ready
[18:32:53.149] [local output] Launching of 1 workers completed
[18:32:53.149] [local output] Number of nodes in cluster: 1
[18:32:53.149] [local output] Collecting session information from 1 workers
[18:32:53.150] [local output]  - Worker #1 of 1
[18:32:53.151] [local output] makeClusterPSOCK() ... done
  Launcher: 'D:/RCompile/recent/R/bin/x64/Rterm.exe'
[18:32:53.160] [local output] makeClusterPSOCK() ...
[18:32:53.166] [local output] Workers: [n = 1] 'localhost'
[18:32:53.173] [local output] Base port: 34835
[18:32:53.174] [local output] Getting setup options for 1 cluster nodes ...
[18:32:53.174] [local output]  - Node #1 of 1 ...
[18:32:53.175] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:53.178] [local output] Rscript port: 34835

[18:32:53.178] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:53.179] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:53.179] [local output] Setting up PSOCK nodes in parallel
[18:32:53.180] List of 36
[18:32:53.180]  $ worker          : chr "localhost"
[18:32:53.180]   ..- attr(*, "localhost")= logi TRUE
[18:32:53.180]  $ master          : chr "localhost"
[18:32:53.180]  $ port            : int 34835
[18:32:53.180]  $ connectTimeout  : num 120
[18:32:53.180]  $ timeout         : num 120
[18:32:53.180]  $ rscript         : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\""
[18:32:53.180]  $ homogeneous     : logi TRUE
[18:32:53.180]  $ rscript_args    : chr "R_DEFAULT_PACKAGES=utils,tools --no-echo --no-restore -e \"#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN\" -e \"| __truncated__
[18:32:53.180]  $ rscript_envs    : NULL
[18:32:53.180]  $ rscript_libs    : NULL
[18:32:53.180]  $ rscript_startup : NULL
[18:32:53.180]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:53.180]  $ default_packages: chr [1:2] "utils" "tools"
[18:32:53.180]  $ methods         : logi TRUE
[18:32:53.180]  $ socketOptions   : chr "no-delay"
[18:32:53.180]  $ useXDR          : logi FALSE
[18:32:53.180]  $ outfile         : chr "/dev/null"
[18:32:53.180]  $ renice          : int NA
[18:32:53.180]  $ rshcmd          : NULL
[18:32:53.180]  $ user            : chr(0) 
[18:32:53.180]  $ revtunnel       : logi FALSE
[18:32:53.180]  $ rshlogfile      : NULL
[18:32:53.180]  $ rshopts         : chr(0) 
[18:32:53.180]  $ rank            : int 1
[18:32:53.180]  $ manual          : logi FALSE
[18:32:53.180]  $ dryrun          : logi FALSE
[18:32:53.180]  $ quiet           : logi FALSE
[18:32:53.180]  $ setup_strategy  : chr "parallel"
[18:32:53.180]  $ local_cmd       : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\" R_DEFAULT_PACKAGES=utils,tools --no-echo --no-restore -e \"#la"| __truncated__
[18:32:53.180]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f096f1e6b.pid"
[18:32:53.180]  $ rshcmd_label    : NULL
[18:32:53.180]  $ rsh_call        : NULL
[18:32:53.180]  $ cmd             : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\" R_DEFAULT_PACKAGES=utils,tools --no-echo --no-restore -e \"#la"| __truncated__
[18:32:53.180]  $ localMachine    : logi TRUE
[18:32:53.180]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:53.180]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:53.180]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:53.180]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:53.180]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:53.180]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:53.180]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:53.180]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:53.180]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:53.180]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:53.180]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:53.180]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:53.180]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:53.180]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:53.180]  $ arguments       :List of 28
[18:32:53.180]   ..$ worker          : chr "localhost"
[18:32:53.180]   ..$ master          : NULL
[18:32:53.180]   ..$ port            : int 34835
[18:32:53.180]   ..$ connectTimeout  : num 120
[18:32:53.180]   ..$ timeout         : num 120
[18:32:53.180]   ..$ rscript         : chr "D:/RCompile/recent/R/bin/x64/Rterm.exe"
[18:32:53.180]   ..$ homogeneous     : NULL
[18:32:53.180]   ..$ rscript_args    : chr [1:4] "--no-echo" "--no-restore" "*" "--args"
[18:32:53.180]   ..$ rscript_envs    : NULL
[18:32:53.180]   ..$ rscript_libs    : NULL
[18:32:53.180]   ..$ rscript_startup : NULL
[18:32:53.180]   ..$ rscript_sh      : chr "auto"
[18:32:53.180]   ..$ default_packages: chr [1:2] "utils" "tools"
[18:32:53.180]   ..$ methods         : logi TRUE
[18:32:53.180]   ..$ socketOptions   : chr "no-delay"
[18:32:53.180]   ..$ useXDR          : logi FALSE
[18:32:53.180]   ..$ outfile         : chr "/dev/null"
[18:32:53.180]   ..$ renice          : int NA
[18:32:53.180]   ..$ rshcmd          : NULL
[18:32:53.180]   ..$ user            : NULL
[18:32:53.180]   ..$ revtunnel       : logi NA
[18:32:53.180]   ..$ rshlogfile      : NULL
[18:32:53.180]   ..$ rshopts         : NULL
[18:32:53.180]   ..$ rank            : int 1
[18:32:53.180]   ..$ manual          : logi FALSE
[18:32:53.180]   ..$ dryrun          : logi FALSE
[18:32:53.180]   ..$ quiet           : logi FALSE
[18:32:53.180]   ..$ setup_strategy  : chr "parallel"
[18:32:53.180]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:53.214] [local output] System call to launch all workers:
[18:32:53.215] [local output] "D:\RCompile\recent\R\bin\x64\Rterm.exe" R_DEFAULT_PACKAGES=utils,tools --no-echo --no-restore -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f096f1e6b.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" --args MASTER=localhost PORT=34835 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:53.215] [local output] Starting PSOCK main server
[18:32:53.221] [local output] Workers launched
[18:32:53.221] [local output] Waiting for workers to connect back
[18:32:53.222]  - [local output] 0 workers out of 1 ready
[18:32:53.376]  - [local output] 0 workers out of 1 ready
[18:32:53.377]  - [local output] 1 workers out of 1 ready
[18:32:53.377] [local output] Launching of 1 workers completed
[18:32:53.378] [local output] Number of nodes in cluster: 1
[18:32:53.378] [local output] Collecting session information from 1 workers
[18:32:53.379] [local output]  - Worker #1 of 1
[18:32:53.379] [local output] makeClusterPSOCK() ... done
> 
> if (.Platform$OS.type == "windows") {
+   ## R and R.exe fails on MS Windows, cf. R-devel thread "MS Windows: R does
+   ## not escape quotes in CLI options the same way as Rterm and Rscript"
+   ## on 2021-12-15.
+   rscripts <- file.path(R.home("bin"), c("Rscript", "Rterm", "Rterm.exe"))
+ } else {
+   rscripts <- file.path(R.home("bin"), c("Rscript", "R"))
+ }
> default_packages <- c("parallelly", "*")
> truth <- unique(c("parallelly", getOption("defaultPackages")))
> for (rscript in rscripts) {
+   message("  Launcher: ", sQuote(rscript))
+   if (tools::file_path_sans_ext(basename(rscript)) %in% c("R", "Rterm")) {
+     rscript_args <- c("--no-echo", "--no-restore", "*", "--args")
+   } else {
+     rscript_args <- NULL
+   }
+   cl <- tryCatch({
+     makeClusterPSOCK(1L, rscript = rscript, rscript_args = rscript_args, default_packages = default_packages)
+   }, warning = identity)
+   stopifnot(inherits(cl, "cluster"))
+   pkgs <- parallel::clusterEvalQ(cl, { getOption("defaultPackages") })[[1]]
+   stopifnot(identical(pkgs, truth))
+   parallel::stopCluster(cl)
+ }
  Launcher: 'D:/RCompile/recent/R/bin/x64/Rscript'
[18:32:53.401] [local output] makeClusterPSOCK() ...
[18:32:53.406] [local output] Workers: [n = 1] 'localhost'
[18:32:53.410] [local output] Base port: 31766
[18:32:53.410] [local output] Getting setup options for 1 cluster nodes ...
[18:32:53.410] [local output]  - Node #1 of 1 ...
[18:32:53.411] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:53.413] [local output] Rscript port: 31766

[18:32:53.414] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:53.414] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:53.414] [local output] Setting up PSOCK nodes in parallel
[18:32:53.414] List of 36
[18:32:53.414]  $ worker          : chr "localhost"
[18:32:53.414]   ..- attr(*, "localhost")= logi TRUE
[18:32:53.414]  $ master          : chr "localhost"
[18:32:53.414]  $ port            : int 31766
[18:32:53.414]  $ connectTimeout  : num 120
[18:32:53.414]  $ timeout         : num 120
[18:32:53.414]  $ rscript         : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rscript.exe\""
[18:32:53.414]  $ homogeneous     : logi TRUE
[18:32:53.414]  $ rscript_args    : chr "--default-packages=parallelly,datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71"| __truncated__
[18:32:53.414]  $ rscript_envs    : NULL
[18:32:53.414]  $ rscript_libs    : NULL
[18:32:53.414]  $ rscript_startup : NULL
[18:32:53.414]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:53.414]  $ default_packages: chr [1:7] "parallelly" "datasets" "utils" "grDevices" ...
[18:32:53.414]  $ methods         : logi TRUE
[18:32:53.414]  $ socketOptions   : chr "no-delay"
[18:32:53.414]  $ useXDR          : logi FALSE
[18:32:53.414]  $ outfile         : chr "/dev/null"
[18:32:53.414]  $ renice          : int NA
[18:32:53.414]  $ rshcmd          : NULL
[18:32:53.414]  $ user            : chr(0) 
[18:32:53.414]  $ revtunnel       : logi FALSE
[18:32:53.414]  $ rshlogfile      : NULL
[18:32:53.414]  $ rshopts         : chr(0) 
[18:32:53.414]  $ rank            : int 1
[18:32:53.414]  $ manual          : logi FALSE
[18:32:53.414]  $ dryrun          : logi FALSE
[18:32:53.414]  $ quiet           : logi FALSE
[18:32:53.414]  $ setup_strategy  : chr "parallel"
[18:32:53.414]  $ local_cmd       : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rscript.exe\" --default-packages=parallelly,datasets,utils,grDevices,graph"| __truncated__
[18:32:53.414]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f037fe4e81.pid"
[18:32:53.414]  $ rshcmd_label    : NULL
[18:32:53.414]  $ rsh_call        : NULL
[18:32:53.414]  $ cmd             : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rscript.exe\" --default-packages=parallelly,datasets,utils,grDevices,graph"| __truncated__
[18:32:53.414]  $ localMachine    : logi TRUE
[18:32:53.414]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:53.414]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:53.414]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:53.414]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:53.414]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:53.414]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:53.414]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:53.414]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:53.414]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:53.414]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:53.414]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:53.414]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:53.414]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:53.414]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:53.414]  $ arguments       :List of 28
[18:32:53.414]   ..$ worker          : chr "localhost"
[18:32:53.414]   ..$ master          : NULL
[18:32:53.414]   ..$ port            : int 31766
[18:32:53.414]   ..$ connectTimeout  : num 120
[18:32:53.414]   ..$ timeout         : num 120
[18:32:53.414]   ..$ rscript         : chr "D:/RCompile/recent/R/bin/x64/Rscript"
[18:32:53.414]   ..$ homogeneous     : NULL
[18:32:53.414]   ..$ rscript_args    : NULL
[18:32:53.414]   ..$ rscript_envs    : NULL
[18:32:53.414]   ..$ rscript_libs    : NULL
[18:32:53.414]   ..$ rscript_startup : NULL
[18:32:53.414]   ..$ rscript_sh      : chr "auto"
[18:32:53.414]   ..$ default_packages: chr [1:2] "parallelly" "*"
[18:32:53.414]   ..$ methods         : logi TRUE
[18:32:53.414]   ..$ socketOptions   : chr "no-delay"
[18:32:53.414]   ..$ useXDR          : logi FALSE
[18:32:53.414]   ..$ outfile         : chr "/dev/null"
[18:32:53.414]   ..$ renice          : int NA
[18:32:53.414]   ..$ rshcmd          : NULL
[18:32:53.414]   ..$ user            : NULL
[18:32:53.414]   ..$ revtunnel       : logi NA
[18:32:53.414]   ..$ rshlogfile      : NULL
[18:32:53.414]   ..$ rshopts         : NULL
[18:32:53.414]   ..$ rank            : int 1
[18:32:53.414]   ..$ manual          : logi FALSE
[18:32:53.414]   ..$ dryrun          : logi FALSE
[18:32:53.414]   ..$ quiet           : logi FALSE
[18:32:53.414]   ..$ setup_strategy  : chr "parallel"
[18:32:53.414]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:53.445] [local output] System call to launch all workers:
[18:32:53.446] [local output] "D:\RCompile\recent\R\bin\x64\Rscript.exe" --default-packages=parallelly,datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f037fe4e81.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=31766 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:53.446] [local output] Starting PSOCK main server
[18:32:53.452] [local output] Workers launched
[18:32:53.452] [local output] Waiting for workers to connect back
[18:32:53.453]  - [local output] 0 workers out of 1 ready
[18:32:53.793]  - [local output] 0 workers out of 1 ready
[18:32:53.794]  - [local output] 1 workers out of 1 ready
[18:32:53.794] [local output] Launching of 1 workers completed
[18:32:53.795] [local output] Number of nodes in cluster: 1
[18:32:53.795] [local output] Collecting session information from 1 workers
[18:32:53.796] [local output]  - Worker #1 of 1
[18:32:53.797] [local output] makeClusterPSOCK() ... done
  Launcher: 'D:/RCompile/recent/R/bin/x64/Rterm'
[18:32:53.805] [local output] makeClusterPSOCK() ...
[18:32:53.813] [local output] Workers: [n = 1] 'localhost'
[18:32:53.819] [local output] Base port: 24209
[18:32:53.819] [local output] Getting setup options for 1 cluster nodes ...
[18:32:53.820] [local output]  - Node #1 of 1 ...
[18:32:53.821] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:53.827] [local output] Rscript port: 24209

[18:32:53.828] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:53.828] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:53.829] [local output] Setting up PSOCK nodes in parallel
[18:32:53.830] List of 36
[18:32:53.830]  $ worker          : chr "localhost"
[18:32:53.830]   ..- attr(*, "localhost")= logi TRUE
[18:32:53.830]  $ master          : chr "localhost"
[18:32:53.830]  $ port            : int 24209
[18:32:53.830]  $ connectTimeout  : num 120
[18:32:53.830]  $ timeout         : num 120
[18:32:53.830]  $ rscript         : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\""
[18:32:53.830]  $ homogeneous     : logi TRUE
[18:32:53.830]  $ rscript_args    : chr "R_DEFAULT_PACKAGES=parallelly,datasets,utils,grDevices,graphics,stats,methods --no-echo --no-restore -e \"#labe"| __truncated__
[18:32:53.830]  $ rscript_envs    : NULL
[18:32:53.830]  $ rscript_libs    : NULL
[18:32:53.830]  $ rscript_startup : NULL
[18:32:53.830]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:53.830]  $ default_packages: chr [1:7] "parallelly" "datasets" "utils" "grDevices" ...
[18:32:53.830]  $ methods         : logi TRUE
[18:32:53.830]  $ socketOptions   : chr "no-delay"
[18:32:53.830]  $ useXDR          : logi FALSE
[18:32:53.830]  $ outfile         : chr "/dev/null"
[18:32:53.830]  $ renice          : int NA
[18:32:53.830]  $ rshcmd          : NULL
[18:32:53.830]  $ user            : chr(0) 
[18:32:53.830]  $ revtunnel       : logi FALSE
[18:32:53.830]  $ rshlogfile      : NULL
[18:32:53.830]  $ rshopts         : chr(0) 
[18:32:53.830]  $ rank            : int 1
[18:32:53.830]  $ manual          : logi FALSE
[18:32:53.830]  $ dryrun          : logi FALSE
[18:32:53.830]  $ quiet           : logi FALSE
[18:32:53.830]  $ setup_strategy  : chr "parallel"
[18:32:53.830]  $ local_cmd       : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\" R_DEFAULT_PACKAGES=parallelly,datasets,utils,grDevices,graphic"| __truncated__
[18:32:53.830]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f08bd2dbf.pid"
[18:32:53.830]  $ rshcmd_label    : NULL
[18:32:53.830]  $ rsh_call        : NULL
[18:32:53.830]  $ cmd             : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\" R_DEFAULT_PACKAGES=parallelly,datasets,utils,grDevices,graphic"| __truncated__
[18:32:53.830]  $ localMachine    : logi TRUE
[18:32:53.830]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:53.830]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:53.830]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:53.830]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:53.830]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:53.830]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:53.830]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:53.830]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:53.830]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:53.830]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:53.830]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:53.830]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:53.830]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:53.830]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:53.830]  $ arguments       :List of 28
[18:32:53.830]   ..$ worker          : chr "localhost"
[18:32:53.830]   ..$ master          : NULL
[18:32:53.830]   ..$ port            : int 24209
[18:32:53.830]   ..$ connectTimeout  : num 120
[18:32:53.830]   ..$ timeout         : num 120
[18:32:53.830]   ..$ rscript         : chr "D:/RCompile/recent/R/bin/x64/Rterm"
[18:32:53.830]   ..$ homogeneous     : NULL
[18:32:53.830]   ..$ rscript_args    : chr [1:4] "--no-echo" "--no-restore" "*" "--args"
[18:32:53.830]   ..$ rscript_envs    : NULL
[18:32:53.830]   ..$ rscript_libs    : NULL
[18:32:53.830]   ..$ rscript_startup : NULL
[18:32:53.830]   ..$ rscript_sh      : chr "auto"
[18:32:53.830]   ..$ default_packages: chr [1:2] "parallelly" "*"
[18:32:53.830]   ..$ methods         : logi TRUE
[18:32:53.830]   ..$ socketOptions   : chr "no-delay"
[18:32:53.830]   ..$ useXDR          : logi FALSE
[18:32:53.830]   ..$ outfile         : chr "/dev/null"
[18:32:53.830]   ..$ renice          : int NA
[18:32:53.830]   ..$ rshcmd          : NULL
[18:32:53.830]   ..$ user            : NULL
[18:32:53.830]   ..$ revtunnel       : logi NA
[18:32:53.830]   ..$ rshlogfile      : NULL
[18:32:53.830]   ..$ rshopts         : NULL
[18:32:53.830]   ..$ rank            : int 1
[18:32:53.830]   ..$ manual          : logi FALSE
[18:32:53.830]   ..$ dryrun          : logi FALSE
[18:32:53.830]   ..$ quiet           : logi FALSE
[18:32:53.830]   ..$ setup_strategy  : chr "parallel"
[18:32:53.830]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:53.865] [local output] System call to launch all workers:
[18:32:53.865] [local output] "D:\RCompile\recent\R\bin\x64\Rterm.exe" R_DEFAULT_PACKAGES=parallelly,datasets,utils,grDevices,graphics,stats,methods --no-echo --no-restore -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f08bd2dbf.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" --args MASTER=localhost PORT=24209 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:53.865] [local output] Starting PSOCK main server
[18:32:53.872] [local output] Workers launched
[18:32:53.872] [local output] Waiting for workers to connect back
[18:32:53.873]  - [local output] 0 workers out of 1 ready
[18:32:54.194]  - [local output] 0 workers out of 1 ready
[18:32:54.195]  - [local output] 1 workers out of 1 ready
[18:32:54.195] [local output] Launching of 1 workers completed
[18:32:54.195] [local output] Number of nodes in cluster: 1
[18:32:54.196] [local output] Collecting session information from 1 workers
[18:32:54.197] [local output]  - Worker #1 of 1
[18:32:54.197] [local output] makeClusterPSOCK() ... done
  Launcher: 'D:/RCompile/recent/R/bin/x64/Rterm.exe'
[18:32:54.204] [local output] makeClusterPSOCK() ...
[18:32:54.208] [local output] Workers: [n = 1] 'localhost'
[18:32:54.211] [local output] Base port: 31953
[18:32:54.211] [local output] Getting setup options for 1 cluster nodes ...
[18:32:54.212] [local output]  - Node #1 of 1 ...
[18:32:54.213] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:54.215] [local output] Rscript port: 31953

[18:32:54.216] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:54.216] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:54.217] [local output] Setting up PSOCK nodes in parallel
[18:32:54.217] List of 36
[18:32:54.217]  $ worker          : chr "localhost"
[18:32:54.217]   ..- attr(*, "localhost")= logi TRUE
[18:32:54.217]  $ master          : chr "localhost"
[18:32:54.217]  $ port            : int 31953
[18:32:54.217]  $ connectTimeout  : num 120
[18:32:54.217]  $ timeout         : num 120
[18:32:54.217]  $ rscript         : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\""
[18:32:54.217]  $ homogeneous     : logi TRUE
[18:32:54.217]  $ rscript_args    : chr "R_DEFAULT_PACKAGES=parallelly,datasets,utils,grDevices,graphics,stats,methods --no-echo --no-restore -e \"#labe"| __truncated__
[18:32:54.217]  $ rscript_envs    : NULL
[18:32:54.217]  $ rscript_libs    : NULL
[18:32:54.217]  $ rscript_startup : NULL
[18:32:54.217]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:54.217]  $ default_packages: chr [1:7] "parallelly" "datasets" "utils" "grDevices" ...
[18:32:54.217]  $ methods         : logi TRUE
[18:32:54.217]  $ socketOptions   : chr "no-delay"
[18:32:54.217]  $ useXDR          : logi FALSE
[18:32:54.217]  $ outfile         : chr "/dev/null"
[18:32:54.217]  $ renice          : int NA
[18:32:54.217]  $ rshcmd          : NULL
[18:32:54.217]  $ user            : chr(0) 
[18:32:54.217]  $ revtunnel       : logi FALSE
[18:32:54.217]  $ rshlogfile      : NULL
[18:32:54.217]  $ rshopts         : chr(0) 
[18:32:54.217]  $ rank            : int 1
[18:32:54.217]  $ manual          : logi FALSE
[18:32:54.217]  $ dryrun          : logi FALSE
[18:32:54.217]  $ quiet           : logi FALSE
[18:32:54.217]  $ setup_strategy  : chr "parallel"
[18:32:54.217]  $ local_cmd       : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\" R_DEFAULT_PACKAGES=parallelly,datasets,utils,grDevices,graphic"| __truncated__
[18:32:54.217]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f018a97f02.pid"
[18:32:54.217]  $ rshcmd_label    : NULL
[18:32:54.217]  $ rsh_call        : NULL
[18:32:54.217]  $ cmd             : chr "\"D:\\RCompile\\recent\\R\\bin\\x64\\Rterm.exe\" R_DEFAULT_PACKAGES=parallelly,datasets,utils,grDevices,graphic"| __truncated__
[18:32:54.217]  $ localMachine    : logi TRUE
[18:32:54.217]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:54.217]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:54.217]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:54.217]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:54.217]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:54.217]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:54.217]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:54.217]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:54.217]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:54.217]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:54.217]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:54.217]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:54.217]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:54.217]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:54.217]  $ arguments       :List of 28
[18:32:54.217]   ..$ worker          : chr "localhost"
[18:32:54.217]   ..$ master          : NULL
[18:32:54.217]   ..$ port            : int 31953
[18:32:54.217]   ..$ connectTimeout  : num 120
[18:32:54.217]   ..$ timeout         : num 120
[18:32:54.217]   ..$ rscript         : chr "D:/RCompile/recent/R/bin/x64/Rterm.exe"
[18:32:54.217]   ..$ homogeneous     : NULL
[18:32:54.217]   ..$ rscript_args    : chr [1:4] "--no-echo" "--no-restore" "*" "--args"
[18:32:54.217]   ..$ rscript_envs    : NULL
[18:32:54.217]   ..$ rscript_libs    : NULL
[18:32:54.217]   ..$ rscript_startup : NULL
[18:32:54.217]   ..$ rscript_sh      : chr "auto"
[18:32:54.217]   ..$ default_packages: chr [1:2] "parallelly" "*"
[18:32:54.217]   ..$ methods         : logi TRUE
[18:32:54.217]   ..$ socketOptions   : chr "no-delay"
[18:32:54.217]   ..$ useXDR          : logi FALSE
[18:32:54.217]   ..$ outfile         : chr "/dev/null"
[18:32:54.217]   ..$ renice          : int NA
[18:32:54.217]   ..$ rshcmd          : NULL
[18:32:54.217]   ..$ user            : NULL
[18:32:54.217]   ..$ revtunnel       : logi NA
[18:32:54.217]   ..$ rshlogfile      : NULL
[18:32:54.217]   ..$ rshopts         : NULL
[18:32:54.217]   ..$ rank            : int 1
[18:32:54.217]   ..$ manual          : logi FALSE
[18:32:54.217]   ..$ dryrun          : logi FALSE
[18:32:54.217]   ..$ quiet           : logi FALSE
[18:32:54.217]   ..$ setup_strategy  : chr "parallel"
[18:32:54.217]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:54.248] [local output] System call to launch all workers:
[18:32:54.249] [local output] "D:\RCompile\recent\R\bin\x64\Rterm.exe" R_DEFAULT_PACKAGES=parallelly,datasets,utils,grDevices,graphics,stats,methods --no-echo --no-restore -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f018a97f02.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" --args MASTER=localhost PORT=31953 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:32:54.249] [local output] Starting PSOCK main server
[18:32:54.254] [local output] Workers launched
[18:32:54.254] [local output] Waiting for workers to connect back
[18:32:54.255]  - [local output] 0 workers out of 1 ready
[18:32:54.615]  - [local output] 0 workers out of 1 ready
[18:32:54.616]  - [local output] 1 workers out of 1 ready
[18:32:54.616] [local output] Launching of 1 workers completed
[18:32:54.616] [local output] Number of nodes in cluster: 1
[18:32:54.617] [local output] Collecting session information from 1 workers
[18:32:54.618] [local output]  - Worker #1 of 1
[18:32:54.619] [local output] makeClusterPSOCK() ... done
> 
> 
> message("- makeClusterPSOCK() - exceptions")
- makeClusterPSOCK() - exceptions
> 
> res <- tryCatch({
+   cl <- makeClusterPSOCK(1:2)
+ }, error = identity)
[18:32:54.626] [local output] makeClusterPSOCK() ...
> print(res)
<simpleError: When numeric, argument 'workers' must be a single value: 2>
> stopifnot(inherits(res, "error"))
> 
> res <- tryCatch({
+   cl <- makeClusterPSOCK(0L)
+ }, error = identity)
[18:32:54.627] [local output] makeClusterPSOCK() ...
> print(res)
<simpleError: Number of 'workers' must be one or greater: 0>
> stopifnot(inherits(res, "error"))
> 
> res <- tryCatch({
+   cl <- makeClusterPSOCK(1L, rshcmd = character(0L))
+ }, error = identity)
[18:32:54.628] [local output] makeClusterPSOCK() ...
[18:32:54.633] [local output] Workers: [n = 1] 'localhost'
[18:32:54.636] [local output] Base port: 28066
[18:32:54.637] [local output] Getting setup options for 1 cluster nodes ...
[18:32:54.637] [local output]  - Node #1 of 1 ...
> print(res)
<simpleError: 'length(rshcmd) >= 1L' is not TRUE>
> stopifnot(inherits(res, "error"))
> 
> res <- tryCatch({
+   cl <- makeClusterPSOCK(1L, port = integer(0L))
+ }, error = identity)
[18:32:54.638] [local output] makeClusterPSOCK() ...
[18:32:54.643] [local output] Workers: [n = 1] 'localhost'
> print(res)
<simpleError in makeClusterPSOCK(1L, port = integer(0L)): Argument 'port' must be of length one or more: 0>
> stopifnot(inherits(res, "error"))
> 
> res <- tryCatch({
+   cl <- makeClusterPSOCK(1L, port = NA_integer_)
+ }, error = identity)
[18:32:54.644] [local output] makeClusterPSOCK() ...
[18:32:54.650] [local output] Workers: [n = 1] 'localhost'
> print(res)
<simpleError in isTcpPortAvailable(port): !is.na(port) is not TRUE>
> stopifnot(inherits(res, "error"))
> 
> 
> message("- makeClusterPSOCK() - exceptions")
- makeClusterPSOCK() - exceptions
> 
> ## Non-existing hostname
> res <- tryCatch({
+   cl <- makeNodePSOCK("not.a.localhost.hostname", revtunnel = TRUE)
+ }, error = identity)
> print(res)
<getvarError in makeNodePSOCK("not.a.localhost.hostname", revtunnel = TRUE): argument "port" is missing, with no default>
> stopifnot(inherits(res, "error"))
> 
> ## Invalid port
> res <- tryCatch({
+   cl <- makeNodePSOCK("localhost", port = NA_integer_)
+ }, error = identity)
> print(res)
<simpleError: Invalid port: NA>
> stopifnot(inherits(res, "error"))
> 
> ## Don't test on CRAN
> if (fullTest || covr_testing) {
+   ## Occupied/blocked port
+   res <- tryCatch(
+     cl <- parallelly::makeClusterPSOCK("localhost", port = 80L, tries = 1L),
+   error = identity)
+   print(res)
+   ## Skip error assertion in case this actually works on some machine.
+   ## But where it fails, we are testing the port-failure exception code.
+ }
> 
> 
> ## https://github.com/futureverse/parallelly/issues/95
> if (getRversion() >= "4.0.0") {
+   res <- tryCatch({
+     parallelly::makeClusterPSOCK(1L, rscript_startup = quote(Sys.sleep(6.0)),
+                                  connectTimeout = 0.1, timeout = 7.0)
+   }, error = identity)
+   print(res)
+   stopifnot(
+     inherits(res, "error"),
+     grepl("^Cluster setup failed", conditionMessage(res))
+   )
+ 
+   ## Make sure to wait for background process to timeout before continuing,
+   ## when on MS Windows
+   if (.Platform$OS.type == "windows") Sys.sleep(5.0)
+ }
[18:32:54.655] [local output] makeClusterPSOCK() ...
[18:32:54.660] [local output] Workers: [n = 1] 'localhost'
[18:32:54.664] [local output] Base port: 26188
[18:32:54.664] [local output] Getting setup options for 1 cluster nodes ...
[18:32:54.665] [local output]  - Node #1 of 1 ...
[18:32:54.665] [local output] localMachine=TRUE => revtunnel=FALSE

[18:32:54.667] [local output] Rscript port: 26188

[18:32:54.668] [local output] Getting setup options for 1 cluster nodes ... done
[18:32:54.668] [local output]  - Parallel setup requested for some PSOCK nodes
[18:32:54.669] [local output] Setting up PSOCK nodes in parallel
[18:32:54.669] List of 36
[18:32:54.669]  $ worker          : chr "localhost"
[18:32:54.669]   ..- attr(*, "localhost")= logi TRUE
[18:32:54.669]  $ master          : chr "localhost"
[18:32:54.669]  $ port            : int 26188
[18:32:54.669]  $ connectTimeout  : num 0.1
[18:32:54.669]  $ timeout         : num 7
[18:32:54.669]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:32:54.669]  $ homogeneous     : logi TRUE
[18:32:54.669]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=makeClusterPSOCK.R:71664:CRANWIN"| __truncated__
[18:32:54.669]  $ rscript_envs    : NULL
[18:32:54.669]  $ rscript_libs    : NULL
[18:32:54.669]  $ rscript_startup : chr [1:2] "-e" "\"invisible({Sys.sleep(6)})\""
[18:32:54.669]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:32:54.669]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:54.669]  $ methods         : logi TRUE
[18:32:54.669]  $ socketOptions   : chr "no-delay"
[18:32:54.669]  $ useXDR          : logi FALSE
[18:32:54.669]  $ outfile         : chr "/dev/null"
[18:32:54.669]  $ renice          : int NA
[18:32:54.669]  $ rshcmd          : NULL
[18:32:54.669]  $ user            : chr(0) 
[18:32:54.669]  $ revtunnel       : logi FALSE
[18:32:54.669]  $ rshlogfile      : NULL
[18:32:54.669]  $ rshopts         : chr(0) 
[18:32:54.669]  $ rank            : int 1
[18:32:54.669]  $ manual          : logi FALSE
[18:32:54.669]  $ dryrun          : logi FALSE
[18:32:54.669]  $ quiet           : logi FALSE
[18:32:54.669]  $ setup_strategy  : chr "parallel"
[18:32:54.669]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:54.669]  $ pidfile         : chr "D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f02fcd14f3.pid"
[18:32:54.669]  $ rshcmd_label    : NULL
[18:32:54.669]  $ rsh_call        : NULL
[18:32:54.669]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:32:54.669]  $ localMachine    : logi TRUE
[18:32:54.669]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:32:54.669]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:32:54.669]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:32:54.669]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:32:54.669]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:32:54.669]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:32:54.669]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:32:54.669]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:32:54.669]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:32:54.669]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:32:54.669]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:32:54.669]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:32:54.669]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:32:54.669]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:32:54.669]  $ arguments       :List of 28
[18:32:54.669]   ..$ worker          : chr "localhost"
[18:32:54.669]   ..$ master          : NULL
[18:32:54.669]   ..$ port            : int 26188
[18:32:54.669]   ..$ connectTimeout  : num 0.1
[18:32:54.669]   ..$ timeout         : num 7
[18:32:54.669]   ..$ rscript         : NULL
[18:32:54.669]   ..$ homogeneous     : NULL
[18:32:54.669]   ..$ rscript_args    : NULL
[18:32:54.669]   ..$ rscript_envs    : NULL
[18:32:54.669]   ..$ rscript_libs    : NULL
[18:32:54.669]   ..$ rscript_startup : language Sys.sleep(6)
[18:32:54.669]   ..$ rscript_sh      : chr "auto"
[18:32:54.669]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:32:54.669]   ..$ methods         : logi TRUE
[18:32:54.669]   ..$ socketOptions   : chr "no-delay"
[18:32:54.669]   ..$ useXDR          : logi FALSE
[18:32:54.669]   ..$ outfile         : chr "/dev/null"
[18:32:54.669]   ..$ renice          : int NA
[18:32:54.669]   ..$ rshcmd          : NULL
[18:32:54.669]   ..$ user            : NULL
[18:32:54.669]   ..$ revtunnel       : logi NA
[18:32:54.669]   ..$ rshlogfile      : NULL
[18:32:54.669]   ..$ rshopts         : NULL
[18:32:54.669]   ..$ rank            : int 1
[18:32:54.669]   ..$ manual          : logi FALSE
[18:32:54.669]   ..$ dryrun          : logi FALSE
[18:32:54.669]   ..$ quiet           : logi FALSE
[18:32:54.669]   ..$ setup_strategy  : chr "parallel"
[18:32:54.669]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:32:54.705] [local output] System call to launch all workers:
[18:32:54.706] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=makeClusterPSOCK.R:71664:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/2024_12_18_18_30_17_11197/RtmpwJmcmg/worker.rank=1.parallelly.parent=71664.117f02fcd14f3.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e "invisible({Sys.sleep(6)})" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=26188 OUT=/dev/null TIMEOUT=7 XDR=FALSE SETUPTIMEOUT=0.1 SETUPSTRATEGY=parallel
[18:32:54.706] [local output] Starting PSOCK main server
[18:32:54.711] [local output] Workers launched
[18:32:54.711] [local output] Waiting for workers to connect back
[18:32:54.711]  - [local output] 0 workers out of 1 ready
[18:32:54.905]  - [local output] 0 workers out of 1 ready
[18:32:55.108]  - [local output] 0 workers out of 1 ready
[18:32:55.311]  - [local output] 0 workers out of 1 ready
[18:32:55.514]  - [local output] 0 workers out of 1 ready
[18:32:55.717]  - [local output] 0 workers out of 1 ready
[18:32:55.920]  - [local output] 0 workers out of 1 ready
[18:32:56.124]  - [local output] 0 workers out of 1 ready
[18:32:56.327]  - [local output] 0 workers out of 1 ready
[18:32:56.530]  - [local output] 0 workers out of 1 ready
[18:32:56.733]  - [local output] 0 workers out of 1 ready
[18:32:56.936]  - [local output] 0 workers out of 1 ready
[18:32:57.139]  - [local output] 0 workers out of 1 ready
[18:32:57.342]  - [local output] 0 workers out of 1 ready
[18:32:57.545]  - [local output] 0 workers out of 1 ready
[18:32:57.748]  - [local output] 0 workers out of 1 ready
[18:32:57.952]  - [local output] 0 workers out of 1 ready
[18:32:58.155]  - [local output] 0 workers out of 1 ready
[18:32:58.358]  - [local output] 0 workers out of 1 ready
[18:32:58.561]  - [local output] 0 workers out of 1 ready
[18:32:58.764]  - [local output] 0 workers out of 1 ready
[18:32:58.967]  - [local output] 0 workers out of 1 ready
[18:32:59.170]  - [local output] 0 workers out of 1 ready
[18:32:59.374]  - [local output] 0 workers out of 1 ready
[18:32:59.577]  - [local output] 0 workers out of 1 ready
[18:32:59.780]  - [local output] 0 workers out of 1 ready
[18:32:59.983]  - [local output] 0 workers out of 1 ready
<simpleError in parallelly::makeClusterPSOCK(1L, rscript_startup = quote(Sys.sleep(6)),     connectTimeout = 0.1, timeout = 7): Cluster setup failed (connectTimeout=5.1 seconds). 1 worker of 1 failed to connect.>
> 
> message("*** makeClusterPSOCK() ... DONE")
*** makeClusterPSOCK() ... DONE
> 
> source("incl/end.R")
> 
> proc.time()
   user  system elapsed 
   1.96    0.21   20.56