CODEWITHSUNDEEP
multithreadingasynchronousf#
nicolas
nicolas

Reputation: 9835

transforming a thread blocking to non thread blocking in f#

I retrieve data from the Bloomberg API, and am quite surprised by the slowness. My computation is IO bounded by this.

Therefore I decided to use some async monad builder to unthrottle it. Upon running it, the results are not so much better, which was obvious as I make a call to a function, NextEvent, which is thread blocking.

     let outerloop args dic = 
        ...
        let rec innerloop continuetoloop   =
           let eventObj = session.NextEvent();  //This blocks
            ...

     let seqtable = reader.ReadFile( @"C:\homeware\sector.csv", ";".[0], true) 

     let dic = ConcurrentDictionary<_,_> ()
     let wf = seqtable |> Seq.mapi (fun i item -> async { outerloop item dic } )
     wf  |> Async.Parallel
         |> Async.RunSynchronously
         |> ignore
     printfn "%A" ret

Is there a good way to wrap that blocking call to a nonblocking call ? Also, why is the async framework not creating as many threads as I have requests (like 200)? when I inspect the threads from which I receive values I see only 4-5 that are used..

UPDATE

I found a compelling reason of why it will never be possible. async operation take what is after the async instruction and schedule it somewhere in the threadpool. for all that matters, as long as async function are use correctly, that is, always returning to the threadpool it originated from, we can consider that we are execution on a single thread.

Being on a single thread mean all that scheduling will always be executed somewhere later, and a blocking instruction has no way to avoid the fact that, eventually, once it runs, it will have to block at some point in the future the worflow.

Upvotes: 1

Views: 301

Answers (2)

nicolas
nicolas

Reputation: 9835

Here is a solution I made that seems to be working. Of course it does not use only async (minus a), but Async as well.

I define a simple type that has one event, finished, and one method, asyncstart, with the method to run as an argument. it launches the method, then fires the event finished at the appropriate place (in my case I had to capture the synchronization context etc..)

Then in the consumer side, I use simply 

let! completion = Async.Waitfromevent wapper.finished |> Async.StartAsChild
let! completed = completion

While running this code, on the consumer side, I use only async calls, making my code non blocking. Of course, there has to be some thread somewhere which is blocked, but this happens outside of my main serving loop which remains reactive and fit.

Upvotes: 0

J D
J D

Reputation: 48707

Is there a good way to wrap that blocking call to a nonblocking call ?

No. You can never wrap blocking calls to make them non-blocking. If you could, async would just be a design pattern rather than a fundamental paradigm shift.

Also, why is the async framework not creating as many threads as I have requests (like 200)?

Async is built upon the thread pool which is designed not to create threads aggressively because they are so expensive. The whole point of (real) async is that it does not require as many threads as there are connections. You can handle 10,000 simultaneous connections with ~30 threads.

You seem to have a complete misunderstanding of what async is and what it is for. I'd suggest buying any of the F# books that cover this topic and reading up on it. In particular, your solution is not asynchronous because you just call your blocking StartGetFieldsValue member from inside your async workflow, defeating the purpose of async. You might as well just do Array.Parallel.map getFieldsValue instead.

Also, you want to use a purely functional API when doing things in parallel rather than mutating a ConcurrentDictionary in-place. So replace req.StartGetFieldsValue ret with

let! result = req.StartGetFieldsValue()
...
return result

and replace ignore with dict.

Upvotes: 2

Related Questions