Beispiel #1
0
        /// <summary>
        /// Creates a micro thread out of the specified function and schedules it as last micro thread to run in this scheduler.
        /// Note that in case of multithreaded scheduling, it might start before this function returns.
        /// </summary>
        /// <param name="microThreadFunction">The function to create a micro thread from.</param>
        /// <param name="flags">The flags.</param>
        /// <returns>A micro thread.</returns>
        public MicroThread Add(Func <Task> microThreadFunction, MicroThreadFlags flags = MicroThreadFlags.None)
        {
            var microThread = new MicroThread(this, flags);

            microThread.Start(microThreadFunction);
            return(microThread);
        }
Beispiel #2
0
        public T GetResult()
        {
            // Check Task Result (exception, etc...)
            if (SuppressCancellationExceptions == false)
            {
                MicroThread.CancellationToken.ThrowIfCancellationRequested();
            }

            var result = Result;

            // After result has been taken, we can reuse this item, so put it in the pool
            // We mitigate pool size, but another approach than hard limit might be interesting
            lock (pool)
            {
                if (pool.Count < 4096)
                {
                    isCompleted = false;
                    SuppressCancellationExceptions = false;
                    MicroThread  = null;
                    Continuation = null;
                    Result       = default(T);
                }

                pool.Add(this);
            }

            return(result);
        }
Beispiel #3
0
 public void OnCompleted(Action continuation)
 {
     microThread = scheduler.Add(() =>
     {
         continuation();
         return(Task.FromResult(true));
     });
 }
        public static ChannelMicroThreadAwaiter <T> New(MicroThread microThread)
        {
            lock (pool)
            {
                if (pool.Count > 0)
                {
                    var index    = pool.Count - 1;
                    var lastItem = pool[index];
                    pool.RemoveAt(index);

                    lastItem.MicroThread = microThread;

                    return(lastItem);
                }

                return(new ChannelMicroThreadAwaiter <T>(microThread));
            }
        }
Beispiel #5
0
 public MicroThreadSynchronizationContext(MicroThread microThread)
 {
     this.microThread = microThread;
 }
 public MicroThreadYieldAwaiter(MicroThread microThread)
 {
     this.microThread = microThread;
 }
Beispiel #7
0
 public SwitchMicroThread(MicroThread microThread)
 {
     this.microThread = microThread;
     //microThread.SynchronizationContext.IncrementTaskCount();
 }
Beispiel #8
0
 public SwitchToAwaiter(Scheduler scheduler)
 {
     this.scheduler   = scheduler;
     this.microThread = null;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="SchedulerThreadEventArgs"/> class.
 /// </summary>
 /// <param name="microThread">The micro thread.</param>
 /// <param name="threadId">The managed thread identifier.</param>
 public SchedulerThreadEventArgs(MicroThread microThread, int threadId)
 {
     MicroThread = microThread;
     ThreadId    = threadId;
 }
Beispiel #10
0
 public SchedulerEntry(MicroThread microThread) : this()
 {
     MicroThread = microThread;
 }
 public ChannelMicroThreadAwaiter(MicroThread microThread)
 {
     MicroThread = microThread;
 }