How to determine when a process started with system(..., wait=FALSE) has ended

Question

I'm trying to set up an asynchronous system() call in R. In order for this to be useful, the user needs a way to check whether the process has ended. The question is how to test for that? In how to run an executable file and then later kill or terminate the same process with R in Windows the suggestion seems to be to capture all pid's before and after the system() call in order to get the pid of the just-launched process (which can then be used to test whether it has ended), but this seems like an error prone way of doing it, on top of it being OS dependant...

Is there other approaches to this problem (doesn't have to involve pid's)

edit: The current scenario this should be used in:

I'm developing a Shiny GUI that handles potentially very long running calculations that are implemented in Java. The calculations are done in batches, and during these runs, even though R is idle, the GUI is locked from interacting with the R server as it is waiting for the Java process to finish. I want a way to initiate the Java process and not wait for it to finish (using the wait=FALSE parameter), but have a fail-safe way of checking that it has completed, so the GUI can be updated accordingly...

Answer 1

If we are willing to make calls to system to launch a process, then this question really seems to simplify to how can one get the PID to a just-launched process in Windows. This isn't really so much an R specific problem, but a Windows general problem. Looking through some answers here on SO, I see one answer that seems reasonable. Process the string result, and get your PID.

Alternatively, you can launch another Rscript asyncronously with system(...,wait=FALSE) and have it report its own PID back to the host process (via file or socket). That Rscript could in turn make your system call and then self-terminate when the system call is done. Then you just watch for the PID of the wrapping Rscript. This is slightly better than a lock file because you don't have to rely on the process you've called to complete successfully to clean up its own lock file.

I'd take some exception to agstudy's solution (even if it were on point). As ThomasP85 says, you can get asynchronous operation via system(..., wait=FALSE). In addition you can get asynchronous operation via sockets, e.g. svSocket and parallel (via a single node PSOCK cluster). There is nothing in either of those socket based approaches that will be fundamentally different from what the above deferred calls launched in python via rpy2 are accomplishing.

Answer 2

Try the processx library. Using it, one runs a new process in the background and can check its status with a built-in function:

library(processx)
p <- process$new(command = "sleep", args="10")
p$is_alive()
   [1] TRUE
# After 10 seconds
p$is_alive()
   [1] FALSE

Answer 3

R does not even support multi threaded system. So calling it asynchronously will not be very easy. One way to do this is to use call it over a language that supports asynchrnous call. For example python:

• Use twisted for asynchronous operations.
• Use rpy2 to call R calls in a python functions

Here a complete example, that calls 2 R functions asynchronously:

1. given a radius it computes perimeter after sleeping a random time
2. given the perimeter already computed it gives back the original radius

It is a dummy example, but it is enough flexible to be extended to any R scripts.

from twisted.internet.defer import Deferred
from twisted.internet import reactor
import rpy2.robjects as robjects

 ## define the functions 
 def get_perimeter(r):
     robjects.r('''
        f <- function(r) {
            Sys.sleep(sample(1:3,1))
            2 * pi * r

        }
        ''')
    r_f = robjects.r['f']
    print  r_f(r)
    return r_f(r)

def get_radius(p):
    robjects.r('''
        f <- function(p)    p/2 / pi
        ''')
    r_f = robjects.r['f']
    print  r_f(p)
    return r_f(p)


def job_done(_):
    from twisted.internet import reactor
    reactor.stop()

## the asynchronous call 
d = Deferred()
d.addCallback(get_perimeter)
d.addCallback(get_radius)
d.addCallback(job_done)


reactor.callWhenRunning(d.callback, 25410)

reactor.run()