Example #1
0
        /// <summary>
        /// A default static constructor that initializes the pool threads.
        /// </summary>
        static SmartThreadPool()
        {
            //create a scheduler for threads created outside the computation system.
            //By default this is a heap scheduller since there can be much more threads,
            //thus heap sort is more efficient.
            artificialThreadScheduler = Configuration.ArtificialThreadScheduler;

            uint physicalProcessors = Unsafe.GetPhysicalCores();

            //the idea here is {core_count} * 2 the rest should be spawned as fibers.
            ISchedulableThread[] threads = new ISchedulableThread[physicalProcessors * 2];

            for (int i = 0; i < threads.Length; i++)
            {
                threads[i] = new SmartThread(true, -1);
                threads[i].SchedulableIndex = i;

                if (Configuration.SmartThreadPoolPreLoadThreads)
                {
                    threads[i].Start();
                }
            }

            //Load the default thread scheduler.
            threadScheduler = Configuration.SmartPoolScheduler;

            threadScheduler.Create(threads);
        }
Example #2
0
        /// <summary>
        /// Tries to steal workload from other heavy loaded threads.
        /// </summary>
        /// <returns>a boolan flag indicating the steal success or failure.</returns>
        internal bool TryStealWork()
        {
            //1. Ask the pool for a thread with the worst stats.
            //2. Access it's internal queue by calling count and then doing Dequeue
            // Here we eith hold a lock or we dont lock at all and handle all queue empty exception.

            SmartThread threadToSteal = (SmartThread)SmartThreadPool.GetThreadToSteal(isInitializedInPool);

            //This code is needed as ThreadPool might tell us that in some sittuations that we can steal
            //work from ourselvs for e.g if other thread will join or we will fork ourselfs and the operations
            //is running.
            if (threadToSteal.id != this.id)
            {
                //perform a steal but only if the window is grater then 1 this means that we will
                //try to snach the item when no one is asking for it, if we fail we still do it in lock free
                //fashion but we may spin.

                bool result = TryStealFromQueue(threadToSteal.scheduler, stealCondition);

                //update the stats.
                if (result)
                {
                    SmartThreadPool.Reschedule(isInitializedInPool, threadToSteal, SchedulerAction.Dequeue);
                }

                return(result);
            }

            return(false);
        }
Example #3
0
        public static int GetThreadLoad()
        {
            SmartThread thread = (SmartThread)threadScheduler.GetBestThread();

            return(thread.scheduler.UnsafeCount);
        }
Example #4
0
 /// <summary>
 /// Removes the given thread that not orginated in a thread pool from the artificial scheduler.
 /// </summary>
 /// <param name="thread">SmartThread</param>
 internal static void RemoveFromArtificialScheduler(SmartThread thread)
 {
     artificialThreadScheduler.Remove(thread);
 }
Example #5
0
 /// <summary>
 /// Inserts a thread that not orginated in a thread pool to the artificial scheduler,
 /// in order to enable fair work scheduling and work stealing.
 /// </summary>
 /// <param name="thread">SmartThread.</param>
 internal static void InsertToArtificialScheduler(SmartThread thread)
 {
     artificialThreadScheduler.Add(thread);
 }