F# async workflow with timeout

Question

I really like F#'s async workflow, but as for me, it has one serious issue: it does not allow creating workflows which should execute no longer than some specific timespan.

To make it clearer, here's a simple function I wrote for myself:

let withTimeout operation timeout = async {
    try
        return Some <| Async.RunSynchronously (operation, timeout)
    with :? TimeoutException -> return None
}

I.e. signature is

val withTimeout : operation:Async<'a> -> timeout:int -> Async<'a option>

Example usage here:

let op = async { 
    do! Async.Sleep(1000) 
    return 1
}
#time
withTimeout op 2000 |> Async.RunSynchronously;;
// Real: 00:00:01.116, CPU: 00:00:00.015, GC gen0: 0, gen1: 0, gen2: 0
// val it : unit option = Some 1
withTimeout op 2000 |> Async.RunSynchronously;;
// Real: 00:00:01.004, CPU: 00:00:00.000, GC gen0: 0, gen1: 0, gen2: 0
// val it : unit option = Some 1
withTimeout op 500 |> Async.RunSynchronously;;
// Real: 00:00:00.569, CPU: 00:00:00.000, GC gen0: 0, gen1: 0, gen2: 0
// val it : unit option = None

You can see, it works as expected. And it's very nice, but it is also a bit awkward and I'm not sure of it's safety and other issues which might arise. Maybe I am reinventing the wheel, and there's nice and concise way to write such workflows?

The problem with this approach is that the workflow will continue executing after the timeout. You should look at using cancellation instead and then signalling the cancellation token after the timeout period. This requires the stages in your workflow respond to cancellation notifications however. — Lee
– Lee, Commented Mar 7, 2014 at 13:15
When you do Async.RunSynchronously, you block the current thread and lose efficiency if underlying async operation is I/O bound. I think I haven't seen a working implementation in the wild yet, but I remember using an ugly hack to do this by converting async comps to observables and then merging them. — MisterMetaphor
– MisterMetaphor, Commented Mar 8, 2014 at 21:54
@MisterMetaphor That's why I wrap RunSynchronously into another async. I guess that will allow to keep it concurrent. But that's ugly, I agree. I am more concerned with what @Lee said - that I don't actually kill the running task. But at the moment I have no idea how to fix that nicely — Rustam
– Rustam, Commented Mar 9, 2014 at 6:11

Community · Accepted Answer · 2017-05-23 12:13:57Z

UPD: Best option at the moment was proposed by Vesa A.J.K here: https://stackoverflow.com/a/26230245/1554463. With my edits its like that:

type Async with
    static member WithTimeout (timeout : int option) operation = 
        match timeout with
        | Some time  when time > 0 -> 
            async { 
                let! child = Async.StartChild (operation, time) 
                try 
                    let! result = child 
                    return Some result
                with :? TimeoutException -> return None 
            }
        | _ -> 
            async { 
                let! result = operation
                return Some result
            }

Here's another option:

type Async with
    static member WithCancellation (token:CancellationToken) operation = 
        async {
            try
                let task = Async.StartAsTask (operation, cancellationToken = token)
                task.Wait ()
                return Some task.Result
            with 
                | :? TaskCanceledException -> return None
                | :? AggregateException -> return None
        }

    static member WithTimeout (timeout:int option) operation = 
        match timeout with
        | Some(time) -> 
            async {
                use tokenSource = new CancellationTokenSource (time)
                return! operation |> Async.WithCancellation tokenSource.Token
            }

        | _ -> 
            async { 
                let! res = operation
                return Some res
            }

Here I use .Net tasks and CancellationToken.

Siro Mateos · Accepted Answer · 2015-09-23 15:58:13Z

9

Just use Async.StartChild : computation:Async<'T> * ?millisecondsTimeout:int -> Async<Async<'T>>:

let with_timeout timeout action =
  async {
    let! child = Async.StartChild( action, timeout )
    return! child
  }

answered Sep 23, 2015 at 15:58

Siro Mateos

4084 silver badges5 bronze badges

Comments

MisterMetaphor · Accepted Answer · 2014-03-09 09:25:08Z

7

Please see this implementation of Async.WhenAny, which is supposed to behave similar to Task.WhenAny.

By using it, you can implement withTimeout similarly to how it is implemented for Task here:

let withTimeout dueTime comp =
    let success = async {
        let! x = comp
        return (Some x)
    }
    let timeout = async {
        do! Async.Delay(dueTime)
        return None
    }
    Async.WhenAny(success, timeout)

I'm not confident that it will cancel the other computation when the first one finishes, but at least this implementation won't block a thread unnecessarily.

answered Mar 9, 2014 at 9:25

MisterMetaphor

6,0283 gold badges30 silver badges31 bronze badges

2 Comments

Rustam Over a year ago

+1 Thanks for consideration. I will think how could I extend it so that take care of cancellation

Nghia Bui Over a year ago

Only this solution works for me - tested on Xamarin.

Collectives™ on Stack Overflow

F# async workflow with timeout

3 Answers 3

Comments

Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related