F# 6: Async VS Task

async_vs_task_1.fs

(*
| Method |    Mean |   Error |  StdDev | Allocated |
|------- |--------:|--------:|--------:|----------:|
|   Task | 15.99 s | 0.107 s | 0.095 s |    314 KB |
|  Async | 16.02 s | 0.089 s | 0.079 s |    990 KB |
*)

open System.Threading.Tasks
open BenchmarkDotNet.Attributes
open BenchmarkDotNet.Running

let [<Literal>] SleepTime = 1
let [<Literal>] Count = 1000

let myAsync =
    async {
        do! Async.Sleep SleepTime
    }
let myTask () =
    task {
        do! Task.Delay SleepTime
    }

let myAsyncs =
    async {
        for _ in 1..Count do
            do! myAsync
    }
let myTasks () =
    task {
        for _ in 1..Count do
            do! myTask ()
    }

[<MemoryDiagnoser>]
type Bench () =

    [<Benchmark>]
    member _.Task () =
        myTasks().GetAwaiter().GetResult()

    [<Benchmark>]
    member _.Async () =
        myAsyncs |> Async.RunSynchronously

[<EntryPoint>]
let main _ =
    BenchmarkRunner.Run<Bench>() |> ignore
    0

async_vs_task_2.fs

(*
|        Method |     Mean |   Error |  StdDev |     Gen 0 |     Gen 1 |    Gen 2 | Allocated |
|-------------- |---------:|--------:|--------:|----------:|----------:|---------:|----------:|
|  TaskParallel | 159.1 ms | 2.54 ms | 2.25 ms |  500.0000 |  250.0000 |        - |      3 MB |
| AsyncParallel | 163.0 ms | 3.22 ms | 5.39 ms | 2000.0000 | 1000.0000 | 250.0000 |     11 MB |
*)

open System.Threading.Tasks
open BenchmarkDotNet.Attributes
open BenchmarkDotNet.Running

let [<Literal>] SleepTime = 1
let [<Literal>] Count = 10000
let [<Literal>] Degree = 1000

let sq = [| 1 .. Count |]

let myTask () =
    task {
        do! Task.Delay SleepTime
    }
    |> ValueTask

let myAsync =
    async {
        do! Async.Sleep SleepTime
    }

[<MemoryDiagnoser>]
type Bench () =

    let taskParallelOpt =
        let opt = ParallelOptions()
        opt.MaxDegreeOfParallelism <- Degree
        opt

    let asyncs = Array.map (fun _ -> myAsync) sq

    [<Benchmark>]
    member _.TaskParallel () =
        Parallel.ForEachAsync(sq, taskParallelOpt, fun _ _ -> myTask())
            .GetAwaiter().GetResult()

    [<Benchmark>]
    member _.AsyncParallel () =
        Async.Parallel(asyncs, Degree)
        |> Async.Ignore |> Async.RunSynchronously

[<EntryPoint>]
let main _ =
    BenchmarkRunner.Run<Bench>() |> ignore
    0