[
https://issues.apache.org/jira/browse/ARROW-11841?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17565148#comment-17565148
]
Weston Pace commented on ARROW-11841:
-------------------------------------
{quote}If we have a Future that we can cancel, we could rig something similar,
maybe using our own event loop (currently we use Arrow's RunInSerialExecutor
and I don't know how customizable that is).{quote}
Cancellation is supported in C++ but not via cancellable futures (and probably
won't be). Instead, operations which support cancellation take in a stop
token. A stop token is something that the C++ code can poll on a regular basis
to see if cancellation has been requested (very similar to
{{cpp11::check_user_interrupt()}} but not global).
The stop token is connected to a stop source which the user holds onto. If the
user marks the stop source as cancelled then the stop token will see the
cancellation the next time it is polled and exit.
It sounds like, for R, this stop source approach won't work (is there no way to
register a callback that gets called on cancellation instead of requiring
polling?) In that case maybe we want a custom stop token implementation for R.
This stop token's poll method could check {{cpp11::check_user_interrupt()}}.
However, we'd probably want to debounce the call as a stop token might be
polled very frequently and should be pretty fast.
> [R][C++] Allow cancelling long-running commands
> -----------------------------------------------
>
> Key: ARROW-11841
> URL: https://issues.apache.org/jira/browse/ARROW-11841
> Project: Apache Arrow
> Issue Type: Improvement
> Components: C++, R
> Reporter: Antoine Pitrou
> Priority: Major
> Fix For: 10.0.0
>
>
> When calling a long-running task (for example reading a CSV file) from the R
> prompt, users may want to interrupt with Ctrl-C.
> Allowing this will require integrating R's user interruption facility with
> the cancellation API that's going to be exposed in C++ (see ARROW-8732).
> Below some information I've gathered on the topic:
> There is some hairy discussion of how to interrupt C++ code from R at
> https://stackoverflow.com/questions/40563522/r-how-to-write-interruptible-c-function-and-recover-partial-results
> and https://stat.ethz.ch/pipermail/r-devel/2011-April/060714.html .
> It seems it may involve polling cpp11::check_user_interrupt() and catching
> any cpp11::unwind_exception that may signal an interruption. A complication
> is that apparently R APIs should only be called from the main thread. There's
> also a small library which claims to make writing all this easier:
> https://github.com/tnagler/RcppThread/blob/master/inst/include/RcppThread/RMonitor.hpp
> But since user interruptions will only be noticed by the R main thread, the
> solution may be to launch heavy computations (e.g. CSV reading) in a separate
> thread and have the main R thread periodically poll for interrupts while
> waiting for the separate thread. This is what this dedicated thread class
> does in its join method:
> https://github.com/tnagler/RcppThread/blob/master/inst/include/RcppThread/Thread.hpp#L79
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
