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.