/tmp/y.jl
> \> t = @async begin
> \> while true
> \> sleep(5)
> \> end
> \> end
> \>
> \> @assert !istaskdone(t)
> \>
> \> Base.throwto(t, InterruptException())
> \> EOF
> $ julia /tmp/y.jl
>
> WARNING: Workqueue inconsistency detected: popfirst!(Workqueue).state != :queued
> ERROR (unhandled task failure): InterruptException:
> ^C
> signal (2): Interrupt
> in expression starting at /tmp/y.jl:13
> unknown function (ip: 0x7fc08e075498)
> uv\_\_epoll\_wait at /data/Work/julia/sources/julia/deps/srccache/libuv-d8ab1c6a33e77bf155facb54215dd8798e13825d/src/unix/linux-syscalls.c:321
> uv\_\_io\_poll at /data/Work/julia/sources/julia/deps/srccache/libuv-d8ab1c6a33e77bf155facb54215dd8798e13825d/src/unix/linux-core.c:267
> uv\_run at /data/Work/julia/sources/julia/deps/srccache/libuv-d8ab1c6a33e77bf155facb54215dd8798e13825d/src/unix/core.c:354
> process\_events at ./libuv.jl:82 \[inlined\]
> wait at ./event.jl:258
> task\_done\_hook at ./task.jl:257
> jl\_call\_fptr\_internal at /data/Work/julia/sources/julia/src/julia\_internal.h:380 \[inlined\]
> jl\_call\_method\_internal at /data/Work/julia/sources/julia/src/julia\_internal.h:399 \[inlined\]
> jl\_apply\_generic at /data/Work/julia/sources/julia/src/gf.c:2082
> jl\_apply at /data/Work/julia/sources/julia/src/julia.h:1474 \[inlined\]
> finish\_task at /data/Work/julia/sources/julia/src/task.c:233
> start\_task at /data/Work/julia/sources/julia/src/task.c:276
> unknown function (ip: 0xffffffffffffffff)
> unknown function (ip: 0xffffffffffffffff)
> Allocations: 826398 (Pool: 825762; Big: 636); GC: 1
> \`\`\`
> Does this mean that a task that _does_ explicitly yields control can be interrupted?
Yes
```julia
julia> t = @async try while true sleep(1) ; println("tick") ; end catch e println("stopped on $e") endtick
tick
tick
tick
julia> @async Base.throwto(t, EOFError())
stopped on EOFError()
Task (runnable) @0x000000011555b610
julia> t
Task (done) @0x000000011555b3d0
```
---
### Author:  [@captchanjack](https://discourse.julialang.org/u/captchanjack)
#### Post date: [June 7, 2021, 5:09pm UTC](https://discourse.julialang.org/t/help-writing-a-timeout-macro/16591/5 "2021-06-07T17:09:00Z")
I’ll just leave my approach here…
```julia
macro timeout(expr, seconds=-1, cb=(tsk) -> Base.throwto(tsk, InterruptException()))
quote
tsk = @task $expr
schedule(tsk)
if $seconds > -1
Timer((timer) -> $cb(tsk), $seconds)
end
return fetch(tsk)
end
end
julia> @timeout (sleep(3); println("done")) 3.1
done
julia> @timeout (sleep(3); println("done")) 3
ERROR: TaskFailedException:
InterruptException:
Stacktrace:
[1] try_yieldto(::typeof(Base.ensure_rescheduled)) at ./task.jl:656
[2] wait at ./task.jl:713 [inlined]
[3] wait(::Base.GenericCondition{Base.Threads.SpinLock}) at ./condition.jl:106
[4] _trywait(::Timer) at ./asyncevent.jl:110
[5] wait at ./asyncevent.jl:128 [inlined]
[6] sleep at ./asyncevent.jl:213 [inlined]
[7] (::var"#29#31")() at ./task.jl:112
Stacktrace:
[1] wait at ./task.jl:267 [inlined]
[2] fetch(::Task) at ./task.jl:282
[3] top-level scope at REPL[3]:10
```
---
### Author:  [@fredcallaway](https://discourse.julialang.org/u/fredcallaway)
#### Post date: [June 21, 2021, 4:33pm UTC](https://discourse.julialang.org/t/help-writing-a-timeout-macro/16591/6 "2021-06-21T16:33:57Z")
Thanks, this was super helpful! I found two problems with this approach though. First, the `return` confusingly just terminates the expression; it doesn’t allow you to assign a variable to the output of the task (compare to `x = return 4`). Second, when you queue up multiple tasks in a row, the Timer from the old task is still active and will end up throwing the interrupt exception to the main program (not sure why that happens). Here’s my version, which fixes these issues (also switches the argument order)
```julia
macro timeout(seconds, expr)
quote
tsk = @task $expr
schedule(tsk)
Timer($seconds) do timer
istaskdone(tsk) || Base.throwto(tsk, InterruptException())
end
fetch(tsk)
end
end
x = @timeout 1 begin
sleep(0.5)
println("done")
1
end
@assert x == 1
```
---
### Author:  [@hhaensel](https://discourse.julialang.org/u/hhaensel)
#### Post date: [November 7, 2022, 2:23pm UTC](https://discourse.julialang.org/t/help-writing-a-timeout-macro/16591/7 "2022-11-07T14:23:04Z")
Thanks for this useful snippet.
I wanted something very similar but with the possibility of a default value in case of failure. So I came up with this:
```julia
macro timeout(seconds, expr, fail)
quote
tsk = @task $expr
schedule(tsk)
Timer($seconds) do timer
istaskdone(tsk) || Base.throwto(tsk, InterruptException())
end
try
fetch(tsk)
catch _
$fail
end
end
end
x = @timeout 1 begin
sleep(1.1)
println("done")
1
end "failed"
```
---
### Author:  [@floswald](https://discourse.julialang.org/u/floswald)
#### Post date: [November 24, 2022, 9:27am UTC](https://discourse.julialang.org/t/help-writing-a-timeout-macro/16591/8 "2022-11-24T09:27:54Z")
this is amazing guys. thanks!
---
### Author:  [@ErwanMeunier](https://discourse.julialang.org/u/ErwanMeunier)
#### Post date: [February 19, 2023, 4:55pm UTC](https://discourse.julialang.org/t/help-writing-a-timeout-macro/16591/9 "2023-02-19T16:55:51Z")
I have tried all day long to replicate @hhaensel’s snippet above considering some arguments to be given to the function. Since I know Julia’s `@task` doesn’t allow any function to be called with arguments, I have tried fixing the latter by calling the function with the variable. However, nothing happens.
My main hypothesis is that `i` is interpreted by the macro as a symbol and not as a value. Is there a trick to overcome this problem in non-interactive mode?
Here is my minimal (non)-working example:
```julia
function test()
f(x) = begin 2*x ; println(2*x) ; sleep(1.) end
#println("Testing f: f(3)")
for i in 1:10
@timeout 10 f(i) "fail"
#println(i)
end
end
```
I apologize for my poor English ^^’
---
### Author:  [@ErwanMeunier](https://discourse.julialang.org/u/ErwanMeunier)
#### Post date: [February 20, 2023, 8:37am UTC](https://discourse.julialang.org/t/help-writing-a-timeout-macro/16591/10 "2023-02-20T08:37:02Z")
I dived more deeply in the `@timeout` macro by removing the `try catch_ end` statement and just leaving `fetch(tsk)` instead. Now, I get the following error:
```julia
julia> test()
ERROR: TaskFailedException
Stacktrace:
[1] wait
@ ./task.jl:345 [inlined]
[2] fetch
@ ./task.jl:360 [inlined]
[3] test()
@ Main ~/Documents/GIT/GravityMachine/src/solveSPAexactly/solveSPA.jl:28
[4] top-level scope
@ REPL[7]:1
nested task error: UndefVarError: f not defined
Stacktrace:
[1] (::var"#170#173")()
@ Main ./task.jl:134
```
When I bring `f` out of `test` (so that `f` becomes global), Julia yields the same error but with `i` instead of `f`:
```julia
nested task error: UndefVarError: i not defined
Stacktrace:
[1] (::var"#187#189")()
@ Main ./task.jl:134
```
I feel that my problem is related to a misunderstanding of meta-programming. In my opinion I am trying to evaluate the code before parsing it (which is impossible?!).
---
### Author:  [@ErwanMeunier](https://discourse.julialang.org/u/ErwanMeunier)
#### Post date: [February 27, 2023, 1:59pm UTC](https://discourse.julialang.org/t/help-writing-a-timeout-macro/16591/11 "2023-02-27T13:59:47Z")
It seems what i was looking for is the following **function** (and not a macro):
```julia
function timeout(f, arg, seconds, fail)
tsk = @task f(arg...)
schedule(tsk)
Timer(seconds) do timer
istaskdone(tsk) || Base.throwto(tsk, InterruptException())
end
try
fetch(tsk)
catch _;
fail
end
end
```
---
### Author:  [@louisponet](https://discourse.julialang.org/u/louisponet)
#### Post date: [February 27, 2023, 4:13pm UTC](https://discourse.julialang.org/t/help-writing-a-timeout-macro/16591/12 "2023-02-27T16:13:50Z")
I’ve ran into issues with this one when using it in tasks where the task mostly completes within seconds but sometimes takes minutes with good reason, i.e. having a long timeout.
It would essentially flood the scheduler with many timers that were waiting to finish.
I changed it a bit to this, and it seems to not run into the same issues anymore:
```julia
macro timeout(seconds, expr, err_expr=:(nothing))
esc(quote
tsk__ = @task $expr
schedule(tsk__)
start_time__ = time()
curt__ = time()
Base.Timer(0.001, interval=0.001) do timer__
if tsk__=== nothing || istaskdone(tsk__)
close(timer__)
else
curt__ = time()
if curt __- start_time__ > $seconds
Base.throwto(tsk__, InterruptException())
end
end
end
try
fetch(tsk__)
catch err__
if err__.task.exception isa InterruptException
RemoteHPC.log_error(RemoteHPC.StallException(err__))
$err_expr
else
rethrow(err__.task.exception)
end
end
end)
end
```
---
### Author:  [@ErwanMeunier](https://discourse.julialang.org/u/ErwanMeunier)
#### Post date: [March 26, 2023, 12:32pm UTC](https://discourse.julialang.org/t/help-writing-a-timeout-macro/16591/13 "2023-03-26T12:32:16Z")
I successfully reached the solution i was looking for by using the `esc(.)` function. Then, I get the following snippet:
```julia
macro timeout(seconds, expr, fail)
quote
tsk = @task $esc(expr)
schedule(tsk)
Timer($(esc(seconds))) do timer
istaskdone(tsk) || Base.throwto(tsk, InterruptException())
end
try
fetch(tsk)
catch _
$(esc(fail))
end
end
end
```