Investigate TaskBuilder test failures

[gusty]

We want to enable TaskBuilder tests, however we're getting some "random failures".

Right now the test just print failures,
Recent history shows:

Bump to Fable 4.27 and adjust ifdef for Fable4 (#649) #2498
-> Exception:  System.Exception: ran next too early at FSharpPlus.Tests.Task.TaskBuilderTests.test2ndExceptionThrownInFinally() in D:\a\FSharpPlus\FSharpPlus\tests\FSharpPlus.Tests\Task.fs:line 718

Rename non-sequential applicative CEs to zapp (#650) #2511
-> Exception: FSharpPlus.Tests.Task+TaskBuilderTests+TestException: TestException "finally exn!"
            at FSharpPlus.Tests.Task.TaskBuilderTests.t@688-126.Invoke(Unit unitVar) in D:\a\FSharpPlus\FSharpPlus\tests\FSharpPlus.Tests\Task.fs:line 689

Add InlineIfLambda to Free (#628) #2512
-> Exception: 
         FSharpPlus.Tests.Task+TaskBuilderTests+TestException: TestException "finally exn!"

Add missing type param to Task.raise #2513
-> Exception:
         FSharpPlus.Tests.Task+TaskBuilderTests+TestException: TestException "finally exn!"
            at FSharpPlus.Tests.Task.TaskBuilderTests.t@688-126.Invoke(Unit unitVar) in D:\a\FSharpPlus\FSharpPlus\tests\FSharpPlus.Tests\Task.fs:line 689

Run dotnet workflows on Ubuntu (#651) #2518
-> Exception: 
         System.Exception: sleep blocked caller
            at FSharpPlus.Tests.Task.TaskBuilderTests.testNonBlocking() in /home/runner/work/FSharpPlus/FSharpPlus/tests/FSharpPlus.Tests/Task.fs:line 316
            at FSharpPlus.Tests.Task.TaskBuilderTests.taskbuilderTests() in /home/runner/work/FSharpPlus/FSharpPlus/tests/FSharpPlus.Tests/Task.fs:line 945
         Running taskbuilder tests...

Add note about style #2532
-> FSharpPlus.Tests.Task+TaskBuilderTests+TestException: TestException "finally exn!"

Fix several functions in ResizeArray #2545
-> Exception: 
         FSharpPlus.Tests.Task+TaskBuilderTests+TestException: TestException "finally exn!"

Use nullArgCheck and pin signatures (#653)
-> Exception: 
         System.Exception: sleep blocked caller
            at FSharpPlus.Tests.Task.TaskBuilderTests.testNonBlocking() in /home/runner/work/FSharpPlus/FSharpPlus/tests/FSharpPlus.Tests/Task.fs:line 316

Add missing type param to ValueTask.raise #2580
-> Passed all tests!

Fix ValueTask.ignore #2581
-> Exception: 
         System.Exception: sleep blocked caller
            at FSharpPlus.Tests.Task.TaskBuilderTests.testNonBlocking() in /home/runner/work/FSharpPlus/FSharpPlus/tests/FSharpPlus.Tests/Task.fs:line 316

+ orElse(With) for (Value)Task #2605
-> Exception: 
         System.Exception: sleep blocked caller
            at FSharpPlus.Tests.ValueTask.ValueTaskBuilderTests.testNonBlocking() in /home/runner/work/FSharpPlus/FSharpPlus/tests/FSharpPlus.Tests/ValueTask.fs:line 266

Fix parameters order in tryWith/Finally for Task #2608
-> Exception: 
         System.Exception: sleep blocked caller
            at FSharpPlus.Tests.ValueTask.ValueTaskBuilderTests.testNonBlocking() in /home/runner/work/FSharpPlus/FSharpPlus/tests/FSharpPlus.Tests/ValueTask.fs:line 266

Apart from that #653 gave

-> Exception: 
         System.AggregateException: One or more errors occurred. (Stack depth increased!)
          ---> System.Exception: Stack depth increased!
            at FSharpPlus.Tests.Task.TaskBuilderTests.t@736-135.Invoke(Unit _arg1) in /home/runner/work/FSharpPlus/FSharpPlus/tests/FSharpPlus.Tests/Task.fs:line 739
            at FSharpPlus.Task.map[T,U](FSharpFunc`2 f, Task`1 source) in /home/runner/work/FSharpPlus/FSharpPlus/src/FSharpPlus/Extensions/Task.fs:line 24

[gusty]

open System
open System.Threading
open System.Threading.Tasks
open System.Diagnostics

let sw = Stopwatch()
let logRecord = ResizeArray<string>()
let log (str: string) = logRecord.Add (str + sprintf " - %i ms - [ThreadId=%d]" sw.ElapsedMilliseconds Thread.CurrentThread.ManagedThreadId)
let logf str = Printf.kprintf (log) str

let dumpLog () =
    logRecord |> Seq.iter (printfn "%s")
    logRecord.Clear() |> ignore

let Yield () = task {
            logf "=> Yield:start"
            do! Task. Yield()
            logf "=> Yield:end" }

let bind (f: 'T -> Task<'U>) (source: Task<'T>) : Task<'U> =
        logf "=> Bind"
        if source.IsCompleted then
            logf "=> Bind sync"
            if source.IsCompletedSuccessfully then
                try f source.Result with e -> Task.FromException<'U> e
            elif source.IsFaulted then Task.FromException<'U>(source.Exception.InnerExceptions.[0])
            elif source.IsCanceled then Task.FromCanceled<'U>(CancellationToken(true))
            else failwithf "Unreachable"
        else
        source.ContinueWith(fun (t: Task<'T>) ->
            if t.IsCompletedSuccessfully then
                try f t.Result with e -> Task.FromException<'U> e
            elif t.IsFaulted then Task.FromException<'U>(t.Exception.InnerExceptions.[0])
            elif t.IsCanceled then Task.FromCanceled<'U>(CancellationToken(true))
            else failwithf "Unreachable"
        ).Unwrap()

let sleep (x: int) =
    logf "=> Start sleep"
    Thread.Sleep x
    logf "=> End sleep"

let quicktest () =
    sw.Restart()    
    let t =
        Yield()
        |> bind (fun () -> 
            sleep(2000)
            Task.FromResult ())
    
    logf "Next sentence"
    t.Wait()
    dumpLog()


(*




> quicktest () ;;
=> Yield:start - 12 ms - [ThreadId=2]
=> Yield:end - 21 ms - [ThreadId=4]
=> Bind - 22 ms - [ThreadId=2]
=> Bind sync - 23 ms - [ThreadId=2]
=> Start sleep - 23 ms - [ThreadId=2]
=> End sleep - 2035 ms - [ThreadId=2]
Next sentence - 2035 ms - [ThreadId=2]
val it: unit = ()

> quicktest () ;;
=> Yield:start - 0 ms - [ThreadId=2]
=> Bind - 0 ms - [ThreadId=2]
=> Yield:end - 0 ms - [ThreadId=4]
Next sentence - 2 ms - [ThreadId=2]
=> Start sleep - 3 ms - [ThreadId=4]
=> End sleep - 2012 ms - [ThreadId=4]
val it: unit = ()

> quicktest () ;;
=> Yield:start - 0 ms - [ThreadId=2]
=> Bind - 0 ms - [ThreadId=2]
Next sentence - 0 ms - [ThreadId=2]
=> Yield:end - 0 ms - [ThreadId=4]
=> Start sleep - 0 ms - [ThreadId=4]
=> End sleep - 2014 ms - [ThreadId=4]
val it: unit = ()

> quicktest () ;;
=> Yield:start - 0 ms - [ThreadId=2]
=> Bind - 0 ms - [ThreadId=2]
Next sentence - 0 ms - [ThreadId=2]
=> Yield:end - 0 ms - [ThreadId=4]
=> Start sleep - 0 ms - [ThreadId=4]
=> End sleep - 2008 ms - [ThreadId=4]
val it: unit = ()

As we can see, the first run takes longer because of the JIT compilation and other warm-up costs.
We see the Yields always finish in a different thread (ThreadId=4) than the one they started on (ThreadId=2).
The problem we see is that the sleep is executed on the same thread as the Bind, therefore it puts the whole CE mechanism to sleep.
This happens because the Yields finishes before the Bind is executed, therefore the sleep is executed by the Bind synchronously and puts the Bind thread to sleep.
In subsequent runs, after the warm up, the Bind is executed before the Yield finishes, therefore the sleep is executed in aynchronously on the same thread as the Yield:end.

So, these kind of tests in the end are testing the performance of the CE machinery, not the operations being dispatched by the CE.
In TaskBuilder the performance is better because it uses a state machine which has less warm up cost, however I tried adding log to it's CE and this effect is them observed.
With F# task CE this effect is even less visible because of the optimizations in the compiler for the task CE, but once I mamaged to observe it as well, after a "cold" operation.

Notice that:

• By removing the Bind optimization for synchronous completions, the sleep is always executed asynchronously on a different thread than the Bind, therefore the CE machinery is never blocked.
• The number of seconds specified in the sleep don't have any effect on the behavior.
• Putting a Thread to sleep "outside" a Task is not a good idea in anycase, a Task operation should be used instead, like Task.Delay

Conclusion: we'll re-enable the tests and we'll by-pass these kind of tests.

This is fixed in #657