SpicyPixel.Threading
Represents a fiber instruction to be processed by a
.
Specific instructions understood by a scheduler are to be derived
from this abstract type.
An instruction to cause the current fiber to yield to any ready fiber.
An instruction to terminate execution of the current fiber.
Initializes a new instance of the class.
that can execute fibers (yieldable coroutines).
Regular non-blocking tasks can also be scheduled on a ,
but have the distinct ability to yield execution.
Gets the cancellation token set when the scheduler is destroyed.
The cancellation token.
Initializes a new instance of the class.
Derived classes should invoke EnableQueueTask() in their constructor when ready to begin executing
tasks.
Initializes a new instance of the class.
Derived classes should invoke EnableQueueTask() in their constructor when ready to begin executing
tasks.
Gets the fiber scheduler associated with this task scheduler.
The fiber scheduler.
Queues a non-blocking task.
If the task is queued from the scheduler thread it will begin executing to its
first yield immediately.
The non-blocking task to queue.
Tries to execute the task inline.
Tasks executed on a fiber scheduler have thread affinity and must run on
the thread the scheduler was created online. Inline execution will therefore
fail if attempted from another thread besides the scheduler thread.
A cannot run inline because yieldable tasks
can only be processed by a when queued.
Because of these restrictions, only standard non-blocking actions invoked
on the scheduler thread are eligible for inlining.
Returns true if the task was executed inline, false otherwise.
The task to execute.
Set to true if the task was previously queued, false otherwise.
Tries to dequeue a task.
Only delay start tasks can be dequeued. Although the Fiber scheduler does
delay start tasks queued from a non-scheduler thread, de-queuing is not
supported right now and so this method always returns false.
Returns true if the task was dequeued, false otherwise.
The task to dequeue.
For debugger support only, generates an enumerable of Task instances
currently queued to the scheduler waiting to be executed.
This is not supported and will always return null.
The scheduled tasks.
Execute the specified task as a coroutine.
The task to be executed.
or other scheduler specific instruction.
Execute the specified coroutine associated with a yieldable task.
Any exceptions that occur while executing the fiber will be
associated with the specified task and rethrown by the framework.
The task associated with the executing fiber.
or other scheduler specific instruction.
Releases unmanaged resources and performs other cleanup operations before the
is reclaimed by garbage collection.
Tracks whether the object has been disposed already
Releases all resource used by the object.
Call the method when you are finished using the
. The method leaves the
in an unusable state. After calling
the method, you must release all references to the
so the garbage collector can reclaim the memory that
the was occupying.
Dispose the scheduler.
When the scheduler is disposed, the is set.
Disposing is true when called manually,
false when called by the finalizer.
Yieldable task for execution on a fiber.
Regular non-blocking tasks can also be scheduled on a ,
but yieldable tasks have the distinct ability to yield execution.
Initializes a new instance of the class.
The task.
The coroutine to execute.
Initializes a new instance of the class.
The task.
The coroutine to execute.
Creation options.
Initializes a new instance of the class.
The task.
The coroutine to execute.
Cancellation token.
Initializes a new instance of the class.
The task.
The coroutine to execute.
Cancellation token.
Creation options.
Initializes a new instance of the class.
The task.
The coroutine to execute.
Initializes a new instance of the class.
The task.
The coroutine to execute.
Creation options.
Initializes a new instance of the class.
The task.
The coroutine to execute.
Cancellation token.
Initializes a new instance of the class.
The task.
The instruction to execute.
Cancellation token.
Creation options.
Initializes a new instance of the class.
The task.
The coroutine to execute.
Initializes a new instance of the class.
The task.
The coroutine to execute.
Creation options.
Initializes a new instance of the class.
The task.
The coroutine to execute.
Cancellation token.
Initializes a new instance of the class.
The task.
The coroutine to execute.
Cancellation token.
Creation options.
Initializes a new instance of the class.
The task.
The coroutine to execute.
State to pass to the function.
Initializes a new instance of the class.
The task.
The coroutine to execute.
State to pass to the function.
Creation options.
Initializes a new instance of the class.
The task.
The coroutine to execute.
State to pass to the function.
Cancellation token.
Initializes a new instance of the class.
The task.
The coroutine to execute.
State to pass to the function.
Cancellation token.
Creation options.
Extends the and classes with methods to support coroutines.
Continues the task with a coroutine.
The continued task.
Task to continue.
The coroutine to continue with.
Continues the task with a coroutine.
The continued task.
Task to continue.
The coroutine to continue with.
Continuation options.
Continues the task with a coroutine.
The continued task.
Task to continue.
The coroutine to continue with.
Cancellation token.
Continues the task with a coroutine.
The continued task.
Task to continue.
The coroutine to continue with.
Scheduler.
Continues the task with a coroutine.
The continued task.
Task to continue.
The coroutine to continue with.
Cancellation token.
Continuation options.
Scheduler to use when scheduling the task.
Continues the task with a coroutine.
The continued task.
Task to continue.
The instruction to continue with.
Continues the task with a coroutine.
The continued task.
Task to continue.
The instruction to continue with.
Continuation options.
Continues the task with a coroutine.
The continued task.
Task to continue.
The instruction to continue with.
Cancellation token.
Continues the task with a coroutine.
The continued task.
Task to continue.
The instruction to continue with.
Scheduler.
Continues the task with a coroutine.
The continued task.
Task to continue.
The instruction to continue with.
Cancellation token.
Continuation options.
Scheduler to use when scheduling the task.
Creates a new task and starts executing it.
The new executing task.
Task factory to start with.
The coroutine to start.
Creates a new task and starts executing it.
The new executing task.
Task factory to start with.
The coroutine to start.
Cancellation token.
Creates a new task and starts executing it.
The new executing task.
Task factory to start with.
The coroutine to start.
Creation options.
Creates a new task and starts executing it.
The new executing task.
Task factory to start with.
The coroutine to start.
Cancellation token.
Creation options.
Scheduler.
Creates a new task and starts executing it.
The new executing task.
Task factory to start with.
The instruction to start.
Creates a new task and starts executing it.
The new executing task.
Task factory to start with.
The instruction to start.
Cancellation token.
Creates a new task and starts executing it.
The new executing task.
Task factory to start with.
The instruction to start.
Creation options.
Creates a new task and starts executing it.
The new executing task.
Task factory to start with.
The instruction to start.
Cancellation token.
Creation options.
Scheduler.
A Fiber is a lightweight means of scheduling work that enables multiple
units of processing to execute concurrently by co-operatively
sharing execution time on a single thread. Fibers are also known
as "micro-threads" and can be implemented using programming language
facilities such as "coroutines".
Fibers simplify many concurrency issues generally associated with
multithreading because a given fiber has complete control over
when it yields execution to another fiber. A fiber does not need
to manage resource locking or handle changing data in the same way as a
thread does because access to a resource is never preempted by
another fiber without co-operation.
Fibers can improve performance in certain applications with concurrency
requirements. Because many fibers can run on a thread, this can relieve
pressure on precious resources in the thread pool and reduce latency.
Additionally, some applications have concurrent, interdependent processes
that naturally lend themselves to co-operative scheduling which can
result in greater efficiency when the application manages the context
switch instead of a pre-emptive scheduler.
Fibers can also be a convenient way to express a state machine. The
master fiber implementing the machine can test state conditions, start
new fibers for state actions, yield to an action fiber until it completes,
and then handle the transition out of the state and into a new state.
The currently executing fiber on the thread.
The next unique identifier.
Gets the currently executing fiber on this thread.
The currently executing fiber on this thread.
Gets the default factory for creating fibers.
The factory.
Gets user-defined properties associated with the fiber.
Similar to thread local storage, callers may associate
data with a fiber. A FiberStorage<T> class
could retrieve data from the this property collection
on the .
Schedulers may also use this storage to associate
additional data needed to perform scheduling operations.
The properties.
Gets the scheduler used to start the fiber.
The scheduler that was used to start the fiber.
Gets or sets the name.
The name.
Gets or sets the result of the fiber's execution as an object.
The result of the fiber's execution as an object.
Gets a value indicating whether this instance is canceled.
true if this instance is canceled; otherwise, false.
Gets a value indicating whether this instance is completed.
"Completed" means:
* FiberStatus.RanToCompletion
* FiberStatus.Canceled
* FiberStatus.Faulted
true if this instance is completed; otherwise, false.
Gets a value indicating whether this instance is faulted.
See `Fiber.Exception` for the exception causing the fault.
true if this instance is faulted; otherwise, false.
Gets the exception that led to the Faulted state.
The exception.
Gets or sets the state of the fiber.
The state of the fiber (Unstarted, Running, Stopped).
Gets the antecedent, which is the fiber that this fiber was dependent upon
for starting execution.
The antecedent provides access to a prior result through `GetAsResultObject()`.
The antecedent.
Gets the cancellation token for the Fiber.
The token is made available because coroutines don't have a convenient way
to get at it otherwise. This way, an executing coroutine can:
```
Fiber.CurrentFiber.CancellationToken.ThrowIfCancellationRequested();
```
The cancellation token.
Run to finish transitioning to Completed by execution continuations.
Called by a continuation to cancel the task and trigger other continuations.
true if this instance cancel continuation; otherwise, false.
Faults the continuation.
The continuation.
Ex.
Gets the thread unique identifier for the fiber.
The identifier.
Initializes a new instance of the class.
A couroutine to execute on the fiber.
Initializes a new instance of the class.
A couroutine to execute on the fiber.
Cancellation token.
Initializes a new instance of the class.
A non-blocking action to execute on the fiber.
Initializes a new instance of the class.
A non-blocking action to execute on the fiber.
Cancellation token.
Initializes a new instance of the class.
A non-blocking action to execute on the fiber.
State to pass to the action.
Initializes a new instance of the class.
A non-blocking action to execute on the fiber.
State to pass to the action.
Cancellation token.
Initializes a new instance of the class.
A non-blocking function that returns a when complete.
Initializes a new instance of the class.
A non-blocking function that returns a when complete.
Cancellation token.
Initializes a new instance of the class.
A non-blocking function that returns a when complete.
State to pass to the function.
Initializes a new instance of the class.
A non-blocking function that returns a when complete.
State to pass to the function.
Cancellation token.
Start executing the fiber using the default scheduler on the thread.
Start executing the fiber using the specified scheduler.
This method is safe to call from any thread even if different
than the scheduler execution thread.
The scheduler to start the fiber on.
Throws if canceled.
Throws if faulted.
Throws if canceled or faulted.
Executes the fiber until it ends or yields.
A fiber instruction to be processed by the scheduler.
Returns a fiber that waits on all fibers to complete.
`Fiber.ResultAsObject` will be `true` if all fibers complete
successfully or `false` if cancelled or timeout.
A fiber that waits on all fibers to complete.
Fibers to wait for completion.
Returns a fiber that waits on all fibers to complete.
`Fiber.ResultAsObject` will be `true` if all fibers complete
successfully or `false` if cancelled or timeout.
A fiber that waits on all fibers to complete.
Fibers to wait for completion.
Cancellation token.
Returns a fiber that waits on all fibers to complete.
`Fiber.ResultAsObject` will be `true` if all fibers complete
successfully or `false` if cancelled or timeout.
A fiber that waits on all fibers to complete.
Fibers to wait for completion.
Timeout.
Returns a fiber that waits on all fibers to complete.
`Fiber.ResultAsObject` will be `true` if all fibers complete
successfully or `false` if cancelled or timeout.
A fiber that waits on all fibers to complete.
Fibers to wait for completion.
Milliseconds timeout.
Returns a fiber that waits on all fibers to complete.
`Fiber.ResultAsObject` will be `true` if all fibers complete
successfully or `false` if cancelled or timeout.
A fiber that waits on all fibers to complete.
Fibers to wait for completion.
Milliseconds timeout.
Cancellation token.
Returns a fiber that waits on all fibers to complete.
`Fiber.ResultAsObject` will be `true` if all fibers complete
successfully or `false` if cancelled or timeout.
A fiber that waits on all fibers to complete.
Fibers to wait for completion.
Milliseconds timeout.
Cancellation token.
Scheduler.
Returns a fiber that waits on all fibers to complete.
`Fiber.ResultAsObject` will be `true` if all fibers complete
successfully or `false` if cancelled or timeout.
A fiber that waits on all fibers to complete.
Fibers to wait for completion.
Milliseconds timeout.
Cancellation token.
Scheduler.
Returns a fiber that waits on all tasks to complete.
`Fiber.ResultAsObject` will be `true` if all tasks complete
successfully or `false` if cancelled or timeout.
A fiber that waits on all tasks to complete.
Tasks to wait for completion.
Returns a fiber that waits on all tasks to complete.
`Fiber.ResultAsObject` will be `true` if all tasks complete
successfully or `false` if cancelled or timeout.
A fiber that waits on all tasks to complete.
Tasks to wait for completion.
Cancellation token.
Returns a fiber that waits on all tasks to complete.
`Fiber.ResultAsObject` will be `true` if all tasks complete
successfully or `false` if cancelled or timeout.
A fiber that waits on all tasks to complete.
Tasks to wait for completion.
Timeout.
Returns a fiber that waits on all tasks to complete.
`Fiber.ResultAsObject` will be `true` if all tasks complete
successfully or `false` if cancelled or timeout.
A fiber that waits on all tasks to complete.
Tasks to wait for completion.
Milliseconds timeout.
Returns a fiber that waits on all tasks to complete.
`Fiber.ResultAsObject` will be `true` if all tasks complete
successfully or `false` if cancelled or timeout.
A fiber that waits on all tasks to complete.
Tasks to wait for completion.
Milliseconds timeout.
Cancellation token.
Returns a fiber that waits on all tasks to complete.
`Fiber.ResultAsObject` will be `true` if all tasks complete
successfully or `false` if cancelled or timeout.
A fiber that waits on all tasks to complete.
Tasks to wait for completion.
Milliseconds timeout.
Cancellation token.
Scheduler.
Returns a fiber that waits on all tasks to complete.
`Fiber.ResultAsObject` will be `true` if all tasks complete
successfully or `false` if cancelled or timeout.
A fiber that waits on all tasks to complete.
Tasks to wait for completion.
Milliseconds timeout.
Cancellation token.
Scheduler.
Returns a fiber that completes when any fiber finishes.
`Fiber.ResultAsObject` will be the `Fiber` that completed.
A fiber that completes when any fiber finishes.
Fibers to wait for completion.
Returns a fiber that completes when any fiber finishes.
`Fiber.ResultAsObject` will be the `Fiber` that completed.
A fiber that completes when any fiber finishes.
Fibers to wait for completion.
Cancellation token.
Returns a fiber that completes when any fiber finishes.
`Fiber.ResultAsObject` will be the `Fiber` that completed.
A fiber that completes when any fiber finishes.
Fibers to wait for completion.
Timeout.
Returns a fiber that completes when any fiber finishes.
`Fiber.ResultAsObject` will be the `Fiber` that completed.
A fiber that completes when any fiber finishes.
Fibers to wait for completion.
Milliseconds timeout.
Returns a fiber that completes when any fiber finishes.
`Fiber.ResultAsObject` will be the `Fiber` that completed.
A fiber that completes when any fiber finishes.
Fibers to wait for completion.
Milliseconds timeout.
Cancellation token.
Returns a fiber that completes when any fiber finishes.
`Fiber.ResultAsObject` will be the `Fiber` that completed.
A fiber that completes when any fiber finishes.
Fibers to wait for completion.
Milliseconds timeout.
Cancellation token.
Scheduler.
Returns a fiber that completes when any fiber finishes.
`Fiber.ResultAsObject` will be the `Fiber` that completed.
A fiber that completes when any fiber finishes.
Fibers to wait for completion.
Milliseconds timeout.
Cancellation token.
Scheduler.
Returns a fiber that completes when any task finishes.
`Fiber.ResultAsObject` will be the `Task` that completed.
A fiber that completes when any task finishes.
Tasks to wait for completion.
Returns a fiber that completes when any task finishes.
`Fiber.ResultAsObject` will be the `Task` that completed.
A fiber that completes when any task finishes.
Tasks to wait for completion.
Cancellation token.
Returns a fiber that completes when any task finishes.
`Fiber.ResultAsObject` will be the `Task` that completed.
A fiber that completes when any task finishes.
Tasks to wait for completion.
Timeout.
Returns a fiber that completes when any task finishes.
`Fiber.ResultAsObject` will be the `Task` that completed.
A fiber that completes when any task finishes.
Tasks to wait for completion.
Milliseconds timeout.
Returns a fiber that completes when any task finishes.
`Fiber.ResultAsObject` will be the `Task` that completed.
A fiber that completes when any task finishes.
Tasks to wait for completion.
Milliseconds timeout.
Cancellation token.
Returns a fiber that completes when any task finishes.
`Fiber.ResultAsObject` will be the `Task` that completed.
A fiber that completes when any task finishes.
Tasks to wait for completion.
Milliseconds timeout.
Cancellation token.
Scheduler.
Returns a fiber that completes when any task finishes.
`Fiber.ResultAsObject` will be the `Task` that completed.
A fiber that completes when any task finishes.
Tasks to wait for completion.
Milliseconds timeout.
Cancellation token.
Scheduler.
Crates a Fiber that waits for a delay before completing.
Milliseconds to delay.
Crates a Fiber that waits for a delay before completing.
Time span to delay.
Crates a Fiber that waits for a delay before completing.
Time span to delay.
Cancellation token.
Crates a Fiber that waits for a delay before completing.
Milliseconds to delay.
Cancellation token.
Crates a Fiber that waits for a delay before completing.
Milliseconds to delay.
Cancellation token.
Scheduler.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation coroutine.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation coroutine.
Cancellation token.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation coroutine.
Continuation options.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation coroutine.
Scheduler.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation coroutine.
Cancellation token.
Continuation options.
Scheduler.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation action.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation action.
Cancellation token.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation action.
Continuation options.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation action.
Scheduler.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation action.
Cancellation token.
Continuation options.
Scheduler.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation action.
State.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation action.
State.
Cancellation token.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation action.
State.
Continuation options.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation action.
State.
Scheduler.
Creates a continuation that executes asynchronously when the target fiber completes.
A fiber that executes when the target fiber completes.
Continuation action.
State.
Cancellation token.
Continuation options.
Scheduler.
Interface used by Fiber to access protected methods of the scheduler.
Queues the fiber for execution on the scheduler.
Fibers queued from the scheduler thread will generally be executed
inline whenever possible on most schedulers.
Returns true if the fiber was executed inline false if it was queued.
The fiber to queue.
This class is the system default implementation of a
and is capable of scheduling and executing fibers on the current thread.
Although no fibers execute after the scheduler is shutdown, none of the
fibers are transitioned to a state and therefore
it's not safe for a fiber to wait on a fiber outside of its own scheduler.
This is currently enforced by for now although it would be
possible to support fiber waits across schedulers in the future.
Starts a new thread, creates a scheduler, starts it running, and returns it to the calling thread.
The scheduler from the spawned thread.
Starts a new thread, creates a scheduler, starts it running, and returns it to the calling thread.
The scheduler from the spawned thread.
A token to cancel the thread.
Updates to run per second.
Starts a new thread, creates a scheduler, starts it running, and returns it to the calling thread.
The scheduler from the spawned thread.
A fiber to start execution from.
Starts a new thread, creates a scheduler, starts it running, and returns it to the calling thread.
The scheduler from the spawned thread.
A fiber to start execution from.
Updates to run per second.
A token to cancel the thread.
The max stack depth before breaking out of recursion.
Tracks the number of times QueueFiber is called to avoid
inlining too much
Currently executing fibers
Fibers sleeping until a timeout
The current time since the start of the run loop.
The run wait handle is set when not running and used to coordinate Dispose and Run
Set when disposed
Run() waits on this handle when it has nothing to do.
Signaling wakes up the thread.
Gets the run wait handle.
The run wait handle is set when not running and used to coordinate Dispose and Run.
The run wait handle.
Gets the dispose wait handle.
Run monitors this handle for a Dispose to know when to terminate.
The dispose wait handle.
Gets a wait handle which can be used to wait for a scheduler
event to occur.
Scheduler events trigger this handle to be signaled.
Events occur any time a fiber is added to an execution queue,
whether because it is new or because it is moving from
a wait queue to an execution queue.
This handle is used to sleep in Run() when there are
no events to process, and a scheduler with a custom
run loop may do the same.
The scheduler event wait handle.
Gets the executing fiber count.
This can be used to optimize a custom run loop.
The executing fiber count.
Gets the sleeping fiber count.
This can be used to optimize a custom run loop.
The sleeping fiber count.
True if running
Is running.
Initializes a new instance of the class.
Queues the fiber for execution on the scheduler.
Fibers queued from the scheduler thread will generally be executed
inline whenever possible on most schedulers.
The fiber to queue.
Adds a fiber to the execution queue without inlining and sets the wait handle.
The fiber to queue.
Adds a fiber to the sleep queue and sets the wait handle.
The fiber to queue.
The future time to wake.
Update the scheduler which causes all queued tasks to run
for a cycle.
This method is useful when updating the scheduler manually
with a custom run loop instead of calling .
Time in seconds since the scheduler or application began running.
This value is used to determine when to wake sleeping fibers.
Using float instead of TimeSpan spares the GC.
Gets the time of the first fiber wake up.
This method is primarily useful when manually calling Update()
instead of Run() to know how long the thread can sleep for.
True if there was a sleeping fiber, false otherwise.
The time marker in seconds the first sleeping fiber needs to wake up.
This is based on a previously passed time value to Update().
This value may be 0 if a sleeping fiber was aborted and
therefore an update should process immediately.
Run the blocking scheduler loop and perform the specified number of updates per second.
Not all schedulers support a blocking run loop that can be invoked by the caller.
The system scheduler is designed so that a custom run loop could be implemented
by a derived type. Everything used to execute Run() is available to a derived scheduler.
The optional fiber to start execution from. If this is null, the loop
will continue to execute until cancelled. Otherwise, the loop will terminate
when the fiber terminates.
Updates to all fibers per second. A value of 0 (the default) will execute fibers
any time they are ready to do work instead of waiting to execute on a specific frequency.
A cancellation token that can be used to stop execution.
Executes the fiber.
Fibers executed by this method do not belong to a queue
and must be added to one by method end if the fiber
execution did not complete this invocation. Otherwise,
the fiber would fall off the scheduler.
The unqueued fiber to execute.
Removes a fiber from the current queues.
The fiber being yielded to needs to be removed from the queues
because it's about to be processed directly.
Fiber.
Tracks whether the object has been disposed already
Dispose the scheduler.
When the scheduler is disposed, the is set.
Disposing is true when called manually,
false when called by the finalizer.
Schedules fibers for execution.
Schedulers are bound to the thread they are created on
and they install a SynchronizationContext which is active during
execution. Schedulers have an implementation specific update
method or run loop. The interface is otherwise thin since schedulers
are generally not intended to be used directly.
Scheduling work is accomplished by invoking methods on
or .
Default scheduler for the thread to support Fiber.Start()
Gets the cancellation token set when the scheduler is destroyed.
The cancellation token.
Gets the default fiber scheduler for the thread.
Every thread has a default scheduler which Fiber.Start() uses.
The default fiber scheduler for the thread.
The thread the scheduler was started on to know when inlining can be allowed.
The scheduler thread.
Gets the synchronization context to dispatch work items to the scheduler.
Schedulers and consumers don't need to worry about this. They are expected
to access the sync context from within an executing fiber by using
SynchronizationContext.Current. This is here so that Fiber.Execute() can
automatically setup the proper context as needed.
The synchronization context.
Gets the thread the scheduler is running on.
The scheduler thread.
Gets or sets a value indicating whether this allows inlining.
true if inlining of tasks on the scheduler thread is allowed; otherwise, false. Default is true.
Initializes a new instance of the class.
Run the blocking scheduler loop and perform the specified number of updates per second.
Not all schedulers support a blocking run loop that can be invoked by the caller.
The initial fiber to start on the scheduler.
Run the blocking scheduler loop and perform the specified number of updates per second.
Not all schedulers support a blocking run loop that can be invoked by the caller.
The optional fiber to start execution from. If this is null, the loop
will continue to execute until cancelled. Otherwise, the loop will terminate
when the fiber terminates.
Updates to all fibers per second. A value of 0 (the default) will execute fibers
any time they are ready to do work instead of waiting to execute on a specific frequency.
A cancellation token that can be used to stop execution.
Run the blocking scheduler loop and perform the specified number of updates per second.
Not all schedulers support a blocking run loop that can be invoked by the caller.
Run the blocking scheduler loop and perform the specified number of updates per second.
Not all schedulers support a blocking run loop that can be invoked by the caller.
Updates to all fibers per second. A value of 0 (the default) will execute fibers
any time they are ready to do work instead of waiting to execute on a specific frequency.
A cancellation token that can be used to stop execution.
Queues the fiber for execution on the scheduler.
Fibers queued from the scheduler thread will generally be executed
inline whenever possible on most schedulers.
Returns true if the fiber was executed inline false if it was queued.
The fiber to queue.
Executes the fiber until it ends or yields.
Custom schedulers will need to invoke this method in order
to actually perform the work of the fiber and cause the correct
state transitions to occur.
A fiber instruction to be processed by the scheduler.
The fiber to execute.
Releases unmanaged resources and performs other cleanup operations before the
is reclaimed by garbage collection.
Tracks whether the object has been disposed already
Releases all resource used by the object.
Call the method when you are finished using the
. The method leaves the
in an unusable state. After calling
the method, you must release all references to the
so the garbage collector can reclaim the memory that
the was occupying.
Dispose the scheduler.
When the scheduler is disposed, the is set.
Disposing is true when called manually,
false when called by the finalizer.
The exception that is thrown when a call is made to the Abort method. This class cannot be inherited.
An instruction to terminate execution of the current fiber.
Use to generate one of these.
An instruction to yield execution to any fiber.
Use to generate one of these.
Yield execution to a specific fiber belonging to the same
scheduler as the current fiber.
Gets the fiber to yield to.
The fiber to yield to.
Initializes a new instance of the class.
The fiber to yield to.
Yield execution until the watched fiber on the same scheduler is complete.
Gets the fiber to yield to.
The fiber to yield to.
Initializes a new instance of the class.
The fiber to yield to.
A to pause execution
of a fiber for the specified duration.
Gets the seconds.
The seconds to pause execution for.
Initializes a new instance of the class.
The seconds to pause execution for.
Fiber scheduler synchronization context to support task
synchronization across schedulers or other synchronization
models.
Initializes a new instance of the class.
The scheduler to send or post callbacks to.
Dispatches an asynchronous message to a synchronization context (the ).
The scheduler may choose to inline the callback if the Post is
executed from the scheduler thread.
Callback to invoke
State to pass
Dispatches an synchronous message to a synchronization context (the ).
The callback is always inlined if Send is executed from the
scheduler thread regardless of any scheduler specific inline settings.
Because inlining always occurs when on the scheduler thread, the
caller must manage stack depth.
Callback to invoke
State to pass
Wraps an object as an instruction
Gets the object
The object
Initializes a new instance of the class.
The object.
This static class exposes convenience coroutines that can be
passed to a fiber or task.
Convenience coroutine to repeat an action for the specified number of iterations at the scheduler frequency.
A .
The action to execute.
The iterations to execute for.
An instruction to stop fiber execution and set a result on the fiber.
Gets the result of the fiber execution.
The result of the fiber execution.
Initializes a new instance of the class.
Result of the fiber execution.
Specifies the behavior for a fiber that is created by using the `Fiber.ContinueWith` method.
When no continuation options are specified, default behavior should be used
to execute a continuation. The continuation runs asynchronously when the antecedent
completes, regardless of the antecedent's final Fiber.Status property value.
The continuation should not be scheduled if its antecedent ran to completion.
An antecedent runs to completion if its Fiber.Status property upon completion
is FiberStatus.RanToCompletion. This option is not valid for multi-fiber continuations.
Specifies that the continuation should not be scheduled if its antecedent threw
an unhandled exception. An antecedent throws an unhandled exception if its Fiber.Status
property upon completion is FiberStatus.Faulted. This option is not valid for multi-fiber
continuations.
The continuation should not be scheduled if its antecedent was canceled. An antecedent
is canceled if its Fiber.Status property upon completion is FiberStatus.Canceled. This option
is not valid for multi-fiber continuations.
The continuation should be scheduled only if its antecedent ran to completion.
An antecedent runs to completion if its Fiber.Status property upon completion is
FiberStatus.RanToCompletion. This option is not valid for multi-fiber continuations.
The continuation should be scheduled only if its antecedent threw an unhandled
exception. An antecedent throws an unhandled exception if its Fiber.Status property
upon completion is FiberStatus.Faulted.
The OnlyOnFaulted option guarantees that the Fiber.Exception property in the antecedent
is not null. You can use that property to catch the exception and see which exception
caused the fiber to fault. If you do not access the Exception property, the exception
is unhandled. If you attempt to access the Result property of a fiber that has been
canceled or has faulted, a new exception is thrown.
This option is not valid for multi-fiber continuations.
Specifies that the continuation should be scheduled only if its antecedent was canceled.
An antecedent is canceled if its Fiber.Status property upon completion is
FiberStatus.Canceled. This option is not valid for multi-fiber continuations.
Represents the current state of a fiber.
The fiber has been initialized but has not yet been scheduled.
The fiber is waiting to be activated and scheduled internally.
Generally this indicates a `ContinueWith` state because the fiber
is not queued to the scheduler, it's waiting to activate and be
scheduled once the antecdent fiber completes.
The fiber has been scheduled for execution but has not yet begun executing.
The fiber is running but has not yet completed.
The fiber completed execution successfully.
The fiber acknowledged cancellation by throwing an OperationCanceledException
with its own CancellationToken while the token was in signaled state, or the
fiber's CancellationToken was already signaled before the fiber started executing.
The fiber completed due to an unhandled exception.
A Fiber Factory for creating fibers with the same options.
Initializes a new instance of the class.
Initializes a new instance of the class.
Cancellation token.
Initializes a new instance of the class.
Scheduler.
Initializes a new instance of the class.
Continuation options.
Initializes a new instance of the class.
Cancellation token.
Continuation options.
Scheduler.
Gets the scheduler.
The scheduler.
Gets the continuation options.
The continuation options.
Gets the cancellation token.
The cancellation token.
Start executing a new fiber using the default scheduler on the thread.
Returns a
that can be yielded against to wait for the fiber to complete.
A couroutine to execute on the fiber.
Start executing a new fiber using the default scheduler on the thread.
Returns a
that can be yielded against to wait for the fiber to complete.
A couroutine to execute on the fiber.
Cancellation token.
Start executing a new fiber using the specified scheduler.
Returns a
that can be yielded against to wait for the fiber to complete.
A couroutine to execute on the fiber.
A scheduler to execute the fiber on.
Start executing a new fiber using the specified scheduler.
Returns a
that can be yielded against to wait for the fiber to complete.
A couroutine to execute on the fiber.
Cancellation token.
A scheduler to execute the fiber on.
Start executing a new fiber using the default scheduler on the thread.
Returns a
that can be yielded against to wait for the fiber to complete.
A non-blocking action to execute on the fiber.
Start executing a new fiber using the default scheduler on the thread.
Returns a
that can be yielded against to wait for the fiber to complete.
A non-blocking action to execute on the fiber.
Cancellation token.
Start executing a new fiber using the default scheduler on the thread.
Returns a
that can be yielded against to wait for the fiber to complete.
A non-blocking action to execute on the fiber.
A scheduler to execute the fiber on.
Start executing a new fiber using the default scheduler on the thread.
Returns a
that can be yielded against to wait for the fiber to complete.
A non-blocking action to execute on the fiber.
Cancellation token.
A scheduler to execute the fiber on.
Start executing a new fiber using the default scheduler on the thread.
Returns a
that can be yielded against to wait for the fiber to complete.
A non-blocking action to execute on the fiber.
State to pass to the action.
Start executing a new fiber using the default scheduler on the thread.
Returns a
that can be yielded against to wait for the fiber to complete.
A non-blocking action to execute on the fiber.
State to pass to the action.
Cancellation token.
Start executing a new fiber using the default scheduler on the thread.
Returns a
that can be yielded against to wait for the fiber to complete.
A non-blocking action to execute on the fiber.
State to pass to the action.
A scheduler to execute the fiber on.
Start executing a new fiber using the default scheduler on the thread.
Returns a
that can be yielded against to wait for the fiber to complete.
A non-blocking action to execute on the fiber.
State to pass to the action.
Cancellation token.
A scheduler to execute the fiber on.
Initializes a new instance of the class.
A non-blocking function that returns a when complete.
Initializes a new instance of the class.
A non-blocking function that returns a when complete.
Cancellation token.
Initializes a new instance of the class.
A non-blocking function that returns a when complete.
A scheduler to execute the fiber on.
Initializes a new instance of the class.
A non-blocking function that returns a when complete.
Cancellation token.
A scheduler to execute the fiber on.
Initializes a new instance of the class.
A non-blocking function that returns a when complete.
State to pass to the function.
Initializes a new instance of the class.
A non-blocking function that returns a when complete.
State to pass to the function.
Cancellation token.
Initializes a new instance of the class.
A non-blocking function that returns a when complete.
State to pass to the function.
A scheduler to execute the fiber on.
Initializes a new instance of the class.
A non-blocking function that returns a when complete.
State to pass to the function.
Cancellation token.
A scheduler to execute the fiber on.
Opportunistically parallelize on platforms where supported.
Threads are not currently supported on web platforms, though it would
be possible to create a native plugin that leverages web workers.
```c
#include <emscripten.h>
extern "C"
{
void process (char* input)
{
worker_handle ai_worker = emscripten_create_worker ("worker.js");
emscripten_call_worker (ai_worker, "start", input, strlen (input) + 1, workerCallback, (void*)0);
}
}
```
Gets or sets whether parallelism is supported.
The platform supports parallelism.
Parallel for loop.
From inclusive.
To exclusive.
Body.
Parallel for loop.
From inclusive.
To exclusive.
Body.
Parallel for loop.
From inclusive.
To exclusive.
Parallel options.
Body.
Parallel for loop.
From inclusive.
To exclusive.
Parallel options.
Body.
Parallel for loop.
From inclusive.
To exclusive.
Local init.
Body.
Local finally.
The 1st type parameter.
Parallel for loop.
From inclusive.
To exclusive.
Parallel options.
Local init.
Body.
Local finally.
The 1st type parameter.
Parallel for each loop.
Loop result.
Source.
Body.
The 1st type parameter.
Parallel for each loop.
Loop result.
Source.
Body.
The 1st type parameter.
Parallel for each loop.
Loop result.
Source.
Body.
The 1st type parameter.
Parallel for each loop.
Loop result.
Source.
Body.
The 1st type parameter.
Parallel for each loop.
Loop result.
Source.
Body.
The 1st type parameter.
Parallel for each loop.
Loop result.
Source.
Body.
The 1st type parameter.
Parallel for each loop.
Loop result.
Source.
Parallel options.
Body.
The 1st type parameter.
Parallel for each loop.
Loop result.
Source.
Parallel options.
Body.
The 1st type parameter.
Parallel for each loop.
Loop result.
Source.
Parallel options.
Body.
The 1st type parameter.
Parallel for each loop.
Loop result.
Source.
Parallel options.
Body.
The 1st type parameter.
Parallel for each loop.
Loop result.
Source.
Parallel options.
Body.
The 1st type parameter.
Parallel for each loop.
Loop result.
Source.
Parallel options.
Body.
The 1st type parameter.
Parallel for each loop.
Loop result.
Source.
Local init.
Body.
Local finally.
The 1st type parameter.
The 2nd type parameter.
Parallel for each loop.
Loop result.
Source.
Local init.
Body.
Local finally.
The 1st type parameter.
The 2nd type parameter.
Parallel for each loop.
Loop result.
Source.
Local init.
Body.
Local finally.
The 1st type parameter.
The 2nd type parameter.
Parallel for each loop.
Loop result.
Source.
Local init.
Body.
Local finally.
The 1st type parameter.
The 2nd type parameter.
Parallel for each loop.
Loop result.
Source.
Parallel options.
Local init.
Body.
Local finally.
The 1st type parameter.
The 2nd type parameter.
Parallel for each loop.
Loop result.
Source.
Parallel options.
Local init.
Body.
Local finally.
The 1st type parameter.
The 2nd type parameter.
Parallel for each loop.
Loop result.
Source.
Parallel options.
Local init.
Body.
Local finally.
The 1st type parameter.
The 2nd type parameter.
Parallel for each loop.
Loop result.
Source.
Parallel options.
Local init.
Body.
Local finally.
The 1st type parameter.
The 2nd type parameter.
Invoke the specified actions.
Actions.
Invoke the specified actions.
Parallel options.
Actions.