Back to Questions
1.4k
views3
comments
Async.StartChild crashes on new 1.9.7.8 CTP of F#
f#async

Smallest example will look like following:

1
2
3
4

let shortVersion(args: string []) =
    let b = async {return 5} |> Async.StartChild
    printfn "%A" (b |> Async.RunSynchronously |> Async.RunSynchronously)
    (0)

this will crash with

1
2

Unhandled Exception: System.ObjectDisposedException: Cannot access a disposed object.
Object name: 'System.Threading.CancellationTokenSource'.

"Real world application" will look like following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

let main (args: string []) =
    let callToWebService1 i = async {return i}
    let callToWebService2 i = async {return i * 2}
    
    let worker = async {
        let work1 = List.init 10 (fun i -> async {
            let! r = Async.StartChild( callToWebService1 i )
            return r
        }) 
        let work2 = List.init 10 (fun i -> async {
            let! r = Async.StartChild( callToWebService2 i )
            return r
        }) 
        let! call1Results = work1 |> Async.Parallel
        let! call2Results = work2 |> Async.Parallel
        let work3 = 
                Array.map2 (fun resFetcher1 resFetcher2 -> async {
                    let! val1 = resFetcher1
                    let! val2 = resFetcher2
                    return val1 + val2
                }) call1Results call2Results
        let! res = work3 |> Async.Parallel
            
        return res
    }
    printfn "%A" (worker |> Async.RunSynchronously)
    (0)

In booth cases call to Async.RunSynchronously or Async.Parallel will dispose innerCTS object, but Async.StartChild relied on it to fetch results.Is it possible to rewrite second function to fetch results on demand and not crash or this is just a bug?

.

Yes, there is definitely a bug here; we're still working to understand it fully, will post an update then.

In the meantime, thanks for the report.

By on 10/28/2009 11:24 AM ()

I might be wrong but I assumed that Async.StartChild would only make sense in the context of the parent computation, and that, consequently, the disposal you mention would be natural.

That being said, is there a reason to use

1
2
3
4
5
6

let work1 = List.init 10 (fun i ->
   async {
     let! r = Async.StartChild( callToWebService1 i )
     return r
   })

instead of

1

let work1 = List.init 10 callToWebService1
By on 10/27/2009 11:49 AM ()

Idea behind this example is to call WS and not await for results until they needed. I have code which works for few seconds and after that I need results from WS. Using Async.StartChild looks like easiest way to do WS call in parallel with my code. If I modify my code in manner you proposed this will cause Async.Parallel to actually wait until last WS call completed and then fetch results from another WS and only then time will came for my own code.
Is there more natural way to achieve this goal?

By on 10/28/2009 12:48 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper