public InsideRuntimeClient( Dispatcher dispatcher, Catalog catalog, ILocalGrainDirectory directory, ClusterConfiguration config, IConsistentRingProvider ring, GrainTypeManager typeManager, TypeMetadataCache typeMetadataCache, Func<ISiloStatusOracle> siloStatusOracle, OrleansTaskScheduler scheduler) { this.dispatcher = dispatcher; MySilo = catalog.LocalSilo; this.directory = directory; ConsistentRingProvider = ring; Catalog = catalog; disposables = new List<IDisposable>(); callbacks = new ConcurrentDictionary<CorrelationId, CallbackData>(); Config = config; config.OnConfigChange("Globals/Message", () => ResponseTimeout = Config.Globals.ResponseTimeout); RuntimeClient.Current = this; this.typeManager = typeManager; this.Scheduler = scheduler; this.siloStatusOracle = new Lazy<ISiloStatusOracle>(siloStatusOracle); this.ConcreteGrainFactory = new GrainFactory(this, typeMetadataCache); RuntimeClient.Current = this; }
public void Sched_AC_Test() { int n = 0; bool insideTask = false; UnitTestSchedulingContext context = new UnitTestSchedulingContext(); orleansTaskScheduler = TestHelper.InitializeSchedulerForTesting(context); Console.WriteLine("Running Main in Context=" + RuntimeContext.Current); orleansTaskScheduler.QueueWorkItem(new ClosureWorkItem(() => { for (int i = 0; i < 10; i++) { Task.Factory.StartNew(() => { // ReSharper disable AccessToModifiedClosure Console.WriteLine("Starting " + i + " in Context=" + RuntimeContext.Current); Assert.IsFalse(insideTask, "Starting new task when I am already inside task of iteration {0}", n); insideTask = true; int k = n; Thread.Sleep(100); n = k + 1; insideTask = false; // ReSharper restore AccessToModifiedClosure }).Ignore(); } }), context); // Pause to let things run Thread.Sleep(1500); // N should be 10, because all tasks should execute serially Assert.IsTrue(n != 0, "Work items did not get executed"); Assert.AreEqual(10, n, "Work items executed concurrently"); }
public OrleansTaskSchedulerAdvancedTests_Set2(ITestOutputHelper output) { this.output = output; OrleansTaskSchedulerBasicTests.InitSchedulerLogging(); context = new UnitTestSchedulingContext(); masterScheduler = TestInternalHelper.InitializeSchedulerForTesting(context); }
internal TypeManager( SiloAddress myAddr, GrainTypeManager grainTypeManager, ISiloStatusOracle oracle, OrleansTaskScheduler scheduler, TimeSpan refreshClusterMapTimeout, ImplicitStreamSubscriberTable implicitStreamSubscriberTable) : base(Constants.TypeManagerId, myAddr) { if (grainTypeManager == null) throw new ArgumentNullException(nameof(grainTypeManager)); if (oracle == null) throw new ArgumentNullException(nameof(oracle)); if (scheduler == null) throw new ArgumentNullException(nameof(scheduler)); if (implicitStreamSubscriberTable == null) throw new ArgumentNullException(nameof(implicitStreamSubscriberTable)); this.grainTypeManager = grainTypeManager; this.statusOracle = oracle; this.implicitStreamSubscriberTable = implicitStreamSubscriberTable; this.scheduler = scheduler; this.hasToRefreshClusterGrainInterfaceMap = true; this.refreshClusterGrainInterfaceMapTimer = new AsyncTaskSafeTimer( OnRefreshClusterMapTimer, null, TimeSpan.Zero, // Force to do it once right now refreshClusterMapTimeout); }
internal ClientObserverRegistrar(SiloAddress myAddr, ILocalGrainDirectory dir, OrleansTaskScheduler scheduler, ClusterConfiguration config) : base(Constants.ClientObserverRegistrarId, myAddr) { grainDirectory = dir; myAddress = myAddr; this.scheduler = scheduler; orleansConfig = config; logger = LogManager.GetLogger(typeof(ClientObserverRegistrar).Name); }
internal static OrleansTaskScheduler InitializeSchedulerForTesting(ISchedulingContext context) { StatisticsCollector.StatisticsCollectionLevel = StatisticsLevel.Info; SchedulerStatisticsGroup.Init(); var scheduler = new OrleansTaskScheduler(4); scheduler.Start(); WorkItemGroup ignore = scheduler.RegisterWorkContext(context); return scheduler; }
internal IncomingMessageAgent(Message.Categories cat, IMessageCenter mc, ActivationDirectory ad, OrleansTaskScheduler sched, Dispatcher dispatcher) : base(cat.ToString()) { category = cat; messageCenter = mc; directory = ad; scheduler = sched; this.dispatcher = dispatcher; OnFault = FaultBehavior.RestartOnFault; }
public ClientObserverRegistrar( SiloInitializationParameters initializationParameters, ILocalGrainDirectory dir, OrleansTaskScheduler scheduler, ClusterConfiguration config) : base(Constants.ClientObserverRegistrarId, initializationParameters.SiloAddress) { grainDirectory = dir; myAddress = initializationParameters.SiloAddress; this.scheduler = scheduler; orleansConfig = config; logger = LogManager.GetLogger(typeof(ClientObserverRegistrar).Name); }
public async Task Sched_AC_WaitTest() { int n = 0; bool insideTask = false; UnitTestSchedulingContext context = new UnitTestSchedulingContext(); orleansTaskScheduler = TestHelper.InitializeSchedulerForTesting(context); var result = new TaskCompletionSource<bool>(); orleansTaskScheduler.QueueWorkItem(new ClosureWorkItem(() => { var task1 = Task.Factory.StartNew(() => { Console.WriteLine("Starting 1"); Assert.IsFalse(insideTask, "Starting new task when I am already inside task of iteration {0}", n); insideTask = true; Console.WriteLine("===> 1a"); Thread.Sleep(1000); n = n + 3; Console.WriteLine("===> 1b"); insideTask = false; }); var task2 = Task.Factory.StartNew(() => { Console.WriteLine("Starting 2"); Assert.IsFalse(insideTask, "Starting new task when I am alraedy inside task of iteration {0}", n); insideTask = true; Console.WriteLine("===> 2a"); task1.Wait(); Console.WriteLine("===> 2b"); n = n * 5; Console.WriteLine("===> 2c"); insideTask = false; result.SetResult(true); }); task1.Ignore(); task2.Ignore(); }), context); var timeoutLimit = TimeSpan.FromMilliseconds(1500); try { await result.Task.WithTimeout(timeoutLimit); } catch (TimeoutException) { Assert.Fail("Result did not arrive before timeout " + timeoutLimit); } Assert.IsTrue(n != 0, "Work items did not get executed"); Assert.AreEqual(15, n, "Work items executed out of order"); }
internal WorkerPoolThread(WorkerPool gtp, OrleansTaskScheduler sched, int threadNumber, bool system = false) : base((system ? "System." : "") + threadNumber) { pool = gtp; scheduler = sched; ownsSemaphore = false; IsSystem = system; maxWorkQueueWait = IsSystem ? Constants.INFINITE_TIMESPAN : gtp.MaxWorkQueueWait; OnFault = FaultBehavior.IgnoreFault; currentWorkItemStarted = DateTime.UtcNow; currentTaskStarted = DateTime.UtcNow; CurrentWorkItem = null; if (StatisticsCollector.CollectTurnsStats) { WorkerThreadStatisticsNumber = SchedulerStatisticsGroup.RegisterWorkingThread(Name); } }
public Dispatcher( OrleansTaskScheduler scheduler, ISiloMessageCenter transport, Catalog catalog, ClusterConfiguration config) { Scheduler = scheduler; this.catalog = catalog; Transport = transport; this.config = config; logger = TraceLogger.GetLogger("Dispatcher", TraceLogger.LoggerType.Runtime); rejectionInjectionRate = config.Globals.RejectionInjectionRate; double messageLossInjectionRate = config.Globals.MessageLossInjectionRate; errorInjection = rejectionInjectionRate > 0.0d || messageLossInjectionRate > 0.0d; errorInjectionRate = rejectionInjectionRate + messageLossInjectionRate; random = new SafeRandom(); }
internal static Task RunOrQueueTask(this OrleansTaskScheduler scheduler, Func <Task> taskFunc, IGrainContext targetContext) { var currentContext = RuntimeContext.CurrentGrainContext; if (currentContext is object && currentContext.Equals(targetContext)) { try { return(taskFunc()); } catch (Exception exc) { return(Task.FromResult(exc)); } } return(scheduler.QueueTask(taskFunc, targetContext)); }
internal static Task RunOrQueueTask(this OrleansTaskScheduler scheduler, Func <Task> taskFunc, ISchedulingContext targetContext) { var currentContext = RuntimeContext.CurrentActivationContext; if (SchedulingUtils.IsAddressableContext(currentContext) && currentContext.Equals(targetContext)) { try { return(taskFunc()); } catch (Exception exc) { return(Task.FromResult(exc)); } } return(scheduler.QueueTask(taskFunc, targetContext)); }
internal WorkerPool(OrleansTaskScheduler sched, int maxActiveThreads, bool injectMoreWorkerThreads) { scheduler = sched; MaxActiveThreads = maxActiveThreads; InjectMoreWorkerThreads = injectMoreWorkerThreads; MaxWorkQueueWait = TimeSpan.FromMilliseconds(50); threadLimitingSemaphore = new Semaphore(maxActiveThreads, maxActiveThreads); pool = new HashSet<WorkerPoolThread>(); lockable = new object(); for (int i = 0; i < MaxActiveThreads; i++) { var t = new WorkerPoolThread(this, scheduler); pool.Add(t); } systemThread = new WorkerPoolThread(this, scheduler, true); running = false; runningThreadCount = 0; longTurnTimer = null; }
internal WorkerPool(OrleansTaskScheduler sched, int maxActiveThreads, bool injectMoreWorkerThreads) { scheduler = sched; MaxActiveThreads = maxActiveThreads; InjectMoreWorkerThreads = injectMoreWorkerThreads; MaxWorkQueueWait = TimeSpan.FromMilliseconds(50); threadLimitingSemaphore = new Semaphore(maxActiveThreads, maxActiveThreads); pool = new HashSet <WorkerPoolThread>(); lockable = new object(); for (int i = 0; i < MaxActiveThreads; i++) { var t = new WorkerPoolThread(this, scheduler); pool.Add(t); } systemThread = new WorkerPoolThread(this, scheduler, true); running = false; runningThreadCount = 0; longTurnTimer = null; }
internal static Task QueueAction(this OrleansTaskScheduler scheduler, Action action, ISchedulingContext targetContext) { var resolver = new TaskCompletionSource <bool>(); Action syncFunc = () => { try { action(); resolver.TrySetResult(true); } catch (Exception exc) { resolver.TrySetException(exc); } }; scheduler.QueueWorkItem(new ClosureWorkItem(() => syncFunc()), targetContext); return(resolver.Task); }
internal static Task <T> RunOrQueueTask <T>(this OrleansTaskScheduler scheduler, Func <Task <T> > taskFunc, IGrainContext targetContext) { var currentContext = RuntimeContext.CurrentGrainContext; if (currentContext is object && currentContext.Equals(targetContext)) { try { return(taskFunc()); } catch (Exception exc) { var resolver = new TaskCompletionSource <T>(TaskCreationOptions.RunContinuationsAsynchronously); resolver.TrySetException(exc); return(resolver.Task); } } return(scheduler.QueueTask(taskFunc, targetContext)); }
internal static Task QueueActionAsync(this OrleansTaskScheduler scheduler, Action action, IGrainContext targetContext) { var resolver = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously); Action syncFunc = () => { try { action(); resolver.TrySetResult(true); } catch (Exception exc) { resolver.TrySetException(exc); } }; scheduler.QueueAction(syncFunc, targetContext); return(resolver.Task); }
internal static Task <T> RunOrQueueTask <T>(this OrleansTaskScheduler scheduler, Func <Task <T> > taskFunc, ISchedulingContext targetContext) { ISchedulingContext currentContext = RuntimeContext.CurrentActivationContext; if (SchedulingUtils.IsAddressableContext(currentContext) && currentContext.Equals(targetContext)) { try { return(taskFunc()); } catch (Exception exc) { var resolver = new TaskCompletionSource <T>(); resolver.TrySetException(exc); return(resolver.Task); } } return(scheduler.QueueTask(taskFunc, targetContext)); }
internal static Task QueueNamedTask(this OrleansTaskScheduler scheduler, Func <Task> taskFunc, ISchedulingContext targetContext, string activityName = null) { var resolver = new TaskCompletionSource <bool>(); Func <Task> asyncFunc = async() => { try { await taskFunc(); resolver.TrySetResult(true); } catch (Exception exc) { resolver.TrySetException(exc); } }; scheduler.QueueWorkItem(new ClosureWorkItem(() => asyncFunc().Ignore(), () => activityName), targetContext); return(resolver.Task); }
internal WorkItemGroup(OrleansTaskScheduler sched, ISchedulingContext schedulingContext) { masterScheduler = sched; SchedulingContext = schedulingContext; state = WorkGroupStatus.Waiting; workItems = new Queue <Task>(); lockable = new Object(); totalItemsEnQueued = 0; totalItemsProcessed = 0; totalQueuingDelay = TimeSpan.Zero; quantumExpirations = 0; TaskRunner = new ActivationTaskScheduler(this); MaxPendingItemsLimit = LimitManager.GetLimit(LimitNames.LIMIT_MAX_PENDING_ITEMS); log = IsSystem ? TraceLogger.GetLogger("Scheduler." + Name + ".WorkItemGroup", TraceLogger.LoggerType.Runtime) : appLogger; if (StatisticsCollector.CollectShedulerQueuesStats) { queueTracking = new QueueTrackingStatistic("Scheduler." + SchedulingContext.Name); queueTracking.OnStartExecution(); } if (StatisticsCollector.CollectPerWorkItemStats) { workItemGroupStatisticsNumber = SchedulerStatisticsGroup.RegisterWorkItemGroup(SchedulingContext.Name, SchedulingContext, () => { var sb = new StringBuilder(); lock (lockable) { sb.Append("QueueLength = " + WorkItemCount); sb.Append(String.Format(", State = {0}", state)); if (state == WorkGroupStatus.Runnable) { sb.Append(String.Format("; oldest item is {0} old", workItems.Count >= 0 ? workItems.Peek().ToString() : "null")); } } return(sb.ToString()); }); } }
internal static Task <T> QueueTask <T>(this OrleansTaskScheduler scheduler, Func <Task <T> > taskFunc, ISchedulingContext targetContext) { var resolver = new TaskCompletionSource <T>(); Func <Task> asyncFunc = async() => { try { T result = await taskFunc(); resolver.TrySetResult(result); } catch (Exception exc) { resolver.TrySetException(exc); } }; // it appears that it's not important that we fire-and-forget asyncFunc() because we wait on the scheduler.QueueWorkItem(new ClosureWorkItem(() => asyncFunc().Ignore()), targetContext); return(resolver.Task); }
// This is the maximum number of waiting threads (blocked in WaitForResponse) allowed // per ActivationWorker. An attempt to wait when there are already too many threads waiting // will result in a TooManyWaitersException being thrown. //private static readonly int MaxWaitingThreads = 500; internal WorkItemGroup(OrleansTaskScheduler sched, ISchedulingContext schedulingContext, ILoggerFactory loggerFactory) { masterScheduler = sched; SchedulingContext = schedulingContext; state = WorkGroupStatus.Waiting; workItems = new Queue <Task>(); lockable = new Object(); totalItemsEnQueued = 0; totalItemsProcessed = 0; totalQueuingDelay = TimeSpan.Zero; quantumExpirations = 0; TaskRunner = new ActivationTaskScheduler(this, loggerFactory); log = IsSystemPriority ? loggerFactory.CreateLogger($"{this.GetType().Namespace} {Name}.{this.GetType().Name}") : loggerFactory.CreateLogger <WorkItemGroup>(); if (StatisticsCollector.CollectShedulerQueuesStats) { queueTracking = new QueueTrackingStatistic("Scheduler." + SchedulingContext.Name); queueTracking.OnStartExecution(); } if (StatisticsCollector.CollectPerWorkItemStats) { workItemGroupStatisticsNumber = SchedulerStatisticsGroup.RegisterWorkItemGroup(SchedulingContext.Name, SchedulingContext, () => { var sb = new StringBuilder(); lock (lockable) { sb.Append("QueueLength = " + WorkItemCount); sb.Append(String.Format(", State = {0}", state)); if (state == WorkGroupStatus.Runnable) { sb.Append(String.Format("; oldest item is {0} old", workItems.Count >= 0 ? workItems.Peek().ToString() : "null")); } } return(sb.ToString()); }); } }
internal WorkerPool(OrleansTaskScheduler sched, int maxActiveThreads, bool enableWorkerThreadInjection) { scheduler = sched; MaxActiveThreads = maxActiveThreads; EnableWorkerThreadInjection = enableWorkerThreadInjection; MaxWorkQueueWait = TimeSpan.FromMilliseconds(50); if (EnableWorkerThreadInjection) { threadLimitingSemaphore = new Semaphore(maxActiveThreads, maxActiveThreads); } pool = new HashSet <WorkerPoolThread>(); createThreadCount = 0; lockable = new object(); for (createThreadCount = 0; createThreadCount < MaxActiveThreads; createThreadCount++) { var t = new WorkerPoolThread(this, scheduler, createThreadCount); pool.Add(t); } createThreadCount++; systemThread = new WorkerPoolThread(this, scheduler, createThreadCount, true); running = false; runningThreadCount = 0; longTurnTimer = null; }
internal WorkerPool(OrleansTaskScheduler sched, int maxActiveThreads, bool enableWorkerThreadInjection) { scheduler = sched; MaxActiveThreads = maxActiveThreads; EnableWorkerThreadInjection = enableWorkerThreadInjection; MaxWorkQueueWait = TimeSpan.FromMilliseconds(50); if (EnableWorkerThreadInjection) { threadLimitingSemaphore = new Semaphore(maxActiveThreads, maxActiveThreads); } pool = new HashSet<WorkerPoolThread>(); createThreadCount = 0; lockable = new object(); for (createThreadCount = 0; createThreadCount < MaxActiveThreads; createThreadCount++) { var t = new WorkerPoolThread(this, scheduler, createThreadCount); pool.Add(t); } createThreadCount++; systemThread = new WorkerPoolThread(this, scheduler, createThreadCount, true); running = false; runningThreadCount = 0; longTurnTimer = null; }
internal Catalog( GrainId grainId, SiloAddress silo, string siloName, ILocalGrainDirectory grainDirectory, GrainTypeManager typeManager, OrleansTaskScheduler scheduler, ActivationDirectory activationDirectory, ClusterConfiguration config, IGrainRuntime grainRuntime, out Action<Dispatcher> setDispatcher) : base(grainId, silo) { LocalSilo = silo; localSiloName = siloName; directory = grainDirectory; activations = activationDirectory; this.scheduler = scheduler; GrainTypeManager = typeManager; this.grainRuntime = grainRuntime; collectionNumber = 0; destroyActivationsNumber = 0; logger = TraceLogger.GetLogger("Catalog", TraceLogger.LoggerType.Runtime); this.config = config.Globals; setDispatcher = d => dispatcher = d; ActivationCollector = new ActivationCollector(config); GC.GetTotalMemory(true); // need to call once w/true to ensure false returns OK value config.OnConfigChange("Globals/Activation", () => scheduler.RunOrQueueAction(Start, SchedulingContext), false); IntValueStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_COUNT, () => activations.Count); activationsCreated = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_CREATED); activationsDestroyed = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_DESTROYED); activationsFailedToActivate = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_FAILED_TO_ACTIVATE); collectionCounter = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_COLLECTION_NUMBER_OF_COLLECTIONS); inProcessRequests = IntValueStatistic.FindOrCreate(StatisticNames.MESSAGING_PROCESSING_ACTIVATION_DATA_ALL, () => { long counter = 0; lock (activations) { foreach (var activation in activations) { ActivationData data = activation.Value; counter += data.GetRequestCount(); } } return counter; }); }
public void Sched_Task_SchedulingContext() { UnitTestSchedulingContext context = new UnitTestSchedulingContext(); orleansTaskScheduler = TestHelper.InitializeSchedulerForTesting(context); ActivationTaskScheduler scheduler = orleansTaskScheduler.GetWorkItemGroup(context).TaskRunner; var result = new TaskCompletionSource<bool>(); Task endOfChain = null; int n = 0; Task wrapper = new Task(() => { CheckRuntimeContext(context); // ReSharper disable AccessToModifiedClosure Task task1 = Task.Factory.StartNew(() => { Console.WriteLine("===> 1a "); CheckRuntimeContext(context); Thread.Sleep(1000); n = n + 3; Console.WriteLine("===> 1b"); CheckRuntimeContext(context); }); Task task2 = task1.ContinueWith(task => { Console.WriteLine("===> 2"); CheckRuntimeContext(context); n = n * 5; }); Task task3 = task2.ContinueWith(task => { Console.WriteLine("===> 3"); n = n / 5; CheckRuntimeContext(context); }); Task task4 = task3.ContinueWith(task => { Console.WriteLine("===> 4"); n = n - 2; result.SetResult(true); CheckRuntimeContext(context); }); // ReSharper restore AccessToModifiedClosure endOfChain = task4.ContinueWith(task => { Console.WriteLine("Done Faulted={0}", task.IsFaulted); CheckRuntimeContext(context); Assert.IsFalse(task.IsFaulted, "Faulted with Exception=" + task.Exception); }); }); wrapper.Start(scheduler); bool ok = wrapper.Wait(TimeSpan.FromSeconds(1)); if (!ok) throw new TimeoutException(); Assert.IsFalse(wrapper.IsFaulted, "Wrapper Task Faulted with Exception=" + wrapper.Exception); Assert.IsTrue(wrapper.IsCompleted, "Wrapper Task completed"); bool finished = result.Task.Wait(TimeSpan.FromSeconds(2)); Assert.IsNotNull(endOfChain, "End of chain Task created successfully"); Assert.IsFalse(endOfChain.IsFaulted, "Task chain Faulted with Exception=" + endOfChain.Exception); Assert.IsTrue(finished, "Wrapper Task completed ok"); Assert.IsTrue(n != 0, "Work items did not get executed"); Assert.AreEqual(1, n, "Work items executed out of order"); }
public void Sched_AC_ContinueWith_2_OrleansSched() { orleansTaskScheduler = TestHelper.InitializeSchedulerForTesting(new UnitTestSchedulingContext()); var result1 = new TaskCompletionSource<bool>(); var result2 = new TaskCompletionSource<bool>(); bool failed1 = false; bool failed2 = false; Task task1 = Task.Factory.StartNew(() => { Console.WriteLine("===> 1a"); Thread.Sleep(OneSecond); throw new ArgumentException(); }); Task task2 = task1.ContinueWith((Task t) => { if (!t.IsFaulted) Console.WriteLine("===> 2"); else { Console.WriteLine("===> 3"); failed1 = true; result1.SetResult(true); } }); Task task3 = task1.ContinueWith((Task t) => { if (!t.IsFaulted) Console.WriteLine("===> 4"); else { Console.WriteLine("===> 5"); failed2 = true; result2.SetResult(true); } }); task1.Ignore(); task2.Ignore(); task3.Ignore(); Assert.IsTrue(result1.Task.Wait(TwoSeconds), "First ContinueWith did not fire."); Assert.IsTrue(result2.Task.Wait(TwoSeconds), "Second ContinueWith did not fire."); Assert.AreEqual(true, failed1, "First ContinueWith did not fire error handler."); Assert.AreEqual(true, failed2, "Second ContinueWith did not fire error handler."); }
public void Sched_Task_JoinAll() { var result = new TaskCompletionSource<bool>(); int n = 0; Task<int>[] tasks = null; Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); UnitTestSchedulingContext context = new UnitTestSchedulingContext(); orleansTaskScheduler = TestHelper.InitializeSchedulerForTesting(context); // ReSharper disable AccessToModifiedClosure orleansTaskScheduler.QueueWorkItem(new ClosureWorkItem(() => { Task<int> task1 = Task<int>.Factory.StartNew(() => { Console.WriteLine("===> 1a"); Thread.Sleep(OneSecond); n = n + 3; Console.WriteLine("===> 1b"); return 1; }); Task<int> task2 = Task<int>.Factory.StartNew(() => { Console.WriteLine("===> 2a"); Thread.Sleep(OneSecond); n = n + 3; Console.WriteLine("===> 2b"); return 2; }); Task<int> task3 = Task<int>.Factory.StartNew(() => { Console.WriteLine("===> 3a"); Thread.Sleep(OneSecond); n = n + 3; Console.WriteLine("===> 3b"); return 3; }); Task<int> task4 = Task<int>.Factory.StartNew(() => { Console.WriteLine("===> 4a"); Thread.Sleep(OneSecond); n = n + 3; Console.WriteLine("===> 4b"); return 4; }); tasks = new Task<int>[] {task1, task2, task3, task4}; result.SetResult(true); }),context); // ReSharper restore AccessToModifiedClosure Assert.IsTrue(result.Task.Wait(TwoSeconds)); // Wait for main (one that creates tasks) work item to finish. var promise = Task<int[]>.Factory.ContinueWhenAll(tasks, (res) => { List<int> output = new List<int>(); int taskNum = 1; foreach (var t in tasks) { Assert.IsTrue(t.IsCompleted, "Sub-Task completed"); Assert.IsFalse(t.IsFaulted, "Sub-Task faulted: " + t.Exception); var val = t.Result; Assert.AreEqual(taskNum, val, "Value returned by Task " + taskNum); output.Add(val); taskNum++; } int[] results = output.ToArray(); return results; }); bool ok = promise.Wait(TimeSpan.FromSeconds(8)); if (!ok) throw new TimeoutException(); Assert.IsTrue(n != 0, "Work items did not get executed"); Assert.AreEqual(12, n, "Not all work items executed"); long ms = stopwatch.ElapsedMilliseconds; Assert.IsTrue(4000 <= ms && ms <= 5000, "Wait time out of range, expected between 4000 and 5000 milliseconds, was " + ms); }
public void Sched_AC_ContinueWith_1_Test() { UnitTestSchedulingContext context = new UnitTestSchedulingContext(); orleansTaskScheduler = TestHelper.InitializeSchedulerForTesting(context); var result = new TaskCompletionSource<bool>(); int n = 0; // ReSharper disable AccessToModifiedClosure orleansTaskScheduler.QueueWorkItem(new ClosureWorkItem(() => { Task task1 = Task.Factory.StartNew(() => { Console.WriteLine("===> 1a"); Thread.Sleep(OneSecond); n = n + 3; Console.WriteLine("===> 1b"); }); Task task2 = task1.ContinueWith((_) => { n = n * 5; Console.WriteLine("===> 2"); }); Task task3 = task2.ContinueWith((_) => { n = n / 5; Console.WriteLine("===> 3"); }); Task task4 = task3.ContinueWith((_) => { n = n - 2; Console.WriteLine("===> 4"); result.SetResult(true); }); task4.Ignore(); }), context); // ReSharper restore AccessToModifiedClosure Assert.IsTrue(result.Task.Wait(TwoSeconds)); Assert.IsTrue(n != 0, "Work items did not get executed"); Assert.AreEqual(1, n, "Work items executed out of order"); }
public void Sched_AC_Current_TaskScheduler() { UnitTestSchedulingContext context = new UnitTestSchedulingContext(); OrleansTaskScheduler orleansTaskScheduler = orleansTaskScheduler = TestHelper.InitializeSchedulerForTesting(context); ActivationTaskScheduler activationScheduler = orleansTaskScheduler.GetWorkItemGroup(context).TaskRunner; // RuntimeContext.InitializeThread(masterScheduler); mainDone = false; var result = new TaskCompletionSource<bool>(); Task wrapper = null; Task finalPromise = null; orleansTaskScheduler.QueueWorkItem(new ClosureWorkItem(() => { Log(1, "Outer ClosureWorkItem " + Task.CurrentId + " starting"); Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #0"); Log(2, "Starting wrapper Task"); wrapper = Task.Factory.StartNew(() => { Log(3, "Inside wrapper Task Id=" + Task.CurrentId); Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #1"); Log(4, "Wrapper Task " + Task.CurrentId + " creating AC chain"); Task promise1 = Task.Factory.StartNew(() => { Log(5, "#1 Inside AC Task Id=" + Task.CurrentId); Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #1"); SubProcess1(1); }); Task promise2 = promise1.ContinueWith((_) => { Log(6, "#2 Inside AC Task Id=" + Task.CurrentId); Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #2"); SubProcess1(2); }); finalPromise = promise2.ContinueWith((_) => { Log(7, "#3 Inside final AC Task Id=" + Task.CurrentId); Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #3"); SubProcess1(3); result.SetResult(true); }); finalPromise.Ignore(); Log(8, "Wrapper Task Id=" + Task.CurrentId + " sleeping"); Thread.Sleep(TimeSpan.FromSeconds(1)); Log(9, "Wrapper Task Id=" + Task.CurrentId + " finished"); }); Log(10, "Outer ClosureWorkItem Task Id=" + Task.CurrentId + " sleeping"); Thread.Sleep(TimeSpan.FromSeconds(1)); Log(11, "Outer ClosureWorkItem Task Id=" + Task.CurrentId + " awake"); Log(12, "Finished Outer TaskWorkItem Task Id=" + wrapper.Id); mainDone = true; }), context); Log(13, "Waiting for ClosureWorkItem to spawn wrapper Task"); for (int i = 0; i < 5 * waitFactor; i++) { if (wrapper != null) break; Thread.Sleep(TimeSpan.FromSeconds(1).Multiply(waitFactor)); } Assert.IsNotNull(wrapper, "Wrapper Task was not created"); Log(14, "Waiting for wrapper Task Id=" + wrapper.Id + " to complete"); bool finished = wrapper.Wait(TimeSpan.FromSeconds(2 * waitFactor)); Log(15, "Done waiting for wrapper Task Id=" + wrapper.Id + " Finished=" + finished); if (!finished) throw new TimeoutException(); Assert.IsFalse(wrapper.IsFaulted, "Wrapper Task faulted: " + wrapper.Exception); Assert.IsTrue(wrapper.IsCompleted, "Wrapper Task should be completed"); Log(16, "Waiting for TaskWorkItem to complete"); for (int i = 0; i < 15 * waitFactor; i++) { if (mainDone) break; Thread.Sleep(1000 * waitFactor); } Log(17, "Done waiting for TaskWorkItem to complete MainDone=" + mainDone); Assert.IsTrue(mainDone, "Main Task should be completed"); Assert.IsNotNull(finalPromise, "AC chain not created"); Log(18, "Waiting for final AC promise to complete"); finalPromise.Wait(TimeSpan.FromSeconds(4 * waitFactor)); Log(19, "Done waiting for final promise"); Assert.IsFalse(finalPromise.IsFaulted, "Final AC faulted: " + finalPromise.Exception); Assert.IsTrue(finalPromise.IsCompleted, "Final AC completed"); Assert.IsTrue(result.Task.Result, "Timeout-1"); Assert.AreNotEqual(0, stageNum1, "Work items did not get executed-1"); Assert.AreEqual(3, stageNum1, "Work items executed out of order-1"); }
public void Sched_Task_Turn_Execution_Order() { // A unit test that checks that any turn is indeed run till completion before any other turn? // For example, you have a long running main turn and in the middle it spawns a lot of short CWs (on Done promise) and StartNew. // You test that no CW/StartNew runs until the main turn is fully done. And run in stress. UnitTestSchedulingContext context = new UnitTestSchedulingContext(); OrleansTaskScheduler masterScheduler = orleansTaskScheduler = TestHelper.InitializeSchedulerForTesting(context); WorkItemGroup workItemGroup = orleansTaskScheduler.GetWorkItemGroup(context); ActivationTaskScheduler activationScheduler = workItemGroup.TaskRunner; mainDone = false; stageNum1 = stageNum2 = 0; var result1 = new TaskCompletionSource<bool>(); var result2 = new TaskCompletionSource<bool>(); Task wrapper = null; Task finalTask1 = null; Task finalPromise2 = null; masterScheduler.QueueWorkItem(new ClosureWorkItem(() => { Log(1, "Outer ClosureWorkItem " + Task.CurrentId + " starting"); Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #0"); Log(2, "Starting wrapper Task"); wrapper = Task.Factory.StartNew(() => { Log(3, "Inside wrapper Task Id=" + Task.CurrentId); Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #1"); // Execution chain #1 Log(4, "Wrapper Task Id=" + Task.CurrentId + " creating Task chain"); Task task1 = Task.Factory.StartNew(() => { Log(5, "#11 Inside sub-Task Id=" + Task.CurrentId); Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #11"); SubProcess1(11); }); Task task2 = task1.ContinueWith((Task task) => { Log(6, "#12 Inside continuation Task Id=" + Task.CurrentId); Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #12"); if (task.IsFaulted) throw task.Exception.Flatten(); SubProcess1(12); }); Task task3 = task2.ContinueWith(task => { Log(7, "#13 Inside continuation Task Id=" + Task.CurrentId); Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #13"); if (task.IsFaulted) throw task.Exception.Flatten(); SubProcess1(13); }); finalTask1 = task3.ContinueWith(task => { Log(8, "#14 Inside final continuation Task Id=" + Task.CurrentId); Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #14"); if (task.IsFaulted) throw task.Exception.Flatten(); SubProcess1(14); result1.SetResult(true); }); // Execution chain #2 Log(9, "Wrapper Task " + Task.CurrentId + " creating AC chain"); Task promise2 = Task.Factory.StartNew(() => { Log(10, "#21 Inside sub-Task Id=" + Task.CurrentId); Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #21"); SubProcess2(21); }); finalPromise2 = promise2.ContinueWith((_) => { Log(11, "#22 Inside final continuation Task Id=" + Task.CurrentId); Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #22"); SubProcess2(22); result2.SetResult(true); }); finalPromise2.Ignore(); Log(12, "Wrapper Task Id=" + Task.CurrentId + " sleeping #2"); Thread.Sleep(TimeSpan.FromSeconds(1)); Log(13, "Wrapper Task Id=" + Task.CurrentId + " finished"); }); Log(14, "Outer ClosureWorkItem Task Id=" + Task.CurrentId + " sleeping"); Thread.Sleep(TimeSpan.FromSeconds(1)); Log(15, "Outer ClosureWorkItem Task Id=" + Task.CurrentId + " awake"); Log(16, "Finished Outer ClosureWorkItem Task Id=" + wrapper.Id); mainDone = true; }), context); Log(17, "Waiting for ClosureWorkItem to spawn wrapper Task"); for (int i = 0; i < 5 * waitFactor; i++) { if (wrapper != null) break; Thread.Sleep(TimeSpan.FromSeconds(1).Multiply(waitFactor)); } Assert.IsNotNull(wrapper, "Wrapper Task was not created"); Log(18, "Waiting for wrapper Task Id=" + wrapper.Id + " to complete"); bool finished = wrapper.Wait(TimeSpan.FromSeconds(2 * waitFactor)); Log(19, "Done waiting for wrapper Task Id=" + wrapper.Id + " Finished=" + finished); if (!finished) throw new TimeoutException(); Assert.IsFalse(wrapper.IsFaulted, "Wrapper Task faulted: " + wrapper.Exception); Assert.IsTrue(wrapper.IsCompleted, "Wrapper Task should be completed"); Log(20, "Waiting for TaskWorkItem to complete"); for (int i = 0; i < 15 * waitFactor; i++) { if (mainDone) break; Thread.Sleep(1000 * waitFactor); } Log(21, "Done waiting for TaskWorkItem to complete MainDone=" + mainDone); Assert.IsTrue(mainDone, "Main Task should be completed"); Assert.IsNotNull(finalTask1, "Task chain #1 not created"); Assert.IsNotNull(finalPromise2, "Task chain #2 not created"); Log(22, "Waiting for final task #1 to complete"); bool ok = finalTask1.Wait(TimeSpan.FromSeconds(4 * waitFactor)); Log(23, "Done waiting for final task #1 complete Ok=" + ok); if (!ok) throw new TimeoutException(); Assert.IsFalse(finalTask1.IsFaulted, "Final Task faulted: " + finalTask1.Exception); Assert.IsTrue(finalTask1.IsCompleted, "Final Task completed"); Assert.IsTrue(result1.Task.Result, "Timeout-1"); Log(24, "Waiting for final promise #2 to complete"); finalPromise2.Wait(TimeSpan.FromSeconds(4 * waitFactor)); Log(25, "Done waiting for final promise #2"); Assert.IsFalse(finalPromise2.IsFaulted, "Final Task faulted: " + finalPromise2.Exception); Assert.IsTrue(finalPromise2.IsCompleted, "Final Task completed"); Assert.IsTrue(result2.Task.Result, "Timeout-2"); Assert.AreNotEqual(0, stageNum1, "Work items did not get executed-1"); Assert.AreEqual(14, stageNum1, "Work items executed out of order-1"); Assert.AreNotEqual(0, stageNum2, "Work items did not get executed-2"); Assert.AreEqual(22, stageNum2, "Work items executed out of order-2"); }
public async Task Sched_AC_Turn_Execution_Order() { // Can we add a unit test that basicaly checks that any turn is indeed run till completion before any other turn? // For example, you have a long running main turn and in the middle it spawns a lot of short CWs (on Done promise) and StartNew. // You test that no CW/StartNew runs until the main turn is fully done. And run in stress. UnitTestSchedulingContext context = new UnitTestSchedulingContext(); orleansTaskScheduler = TestHelper.InitializeSchedulerForTesting(context); var result1 = new TaskCompletionSource<bool>(); var result2 = new TaskCompletionSource<bool>(); orleansTaskScheduler.QueueWorkItem(new ClosureWorkItem(() => { mainDone = false; stageNum1 = stageNum2 = 0; Task task1 = Task.Factory.StartNew(() => SubProcess1(11)); Task task2 = task1.ContinueWith((_) => SubProcess1(12)); Task task3 = task2.ContinueWith((_) => SubProcess1(13)); Task task4 = task3.ContinueWith((_) => { SubProcess1(14); result1.SetResult(true); }); task4.Ignore(); Task task21 = TaskDone.Done.ContinueWith((_) => SubProcess2(21)); Task task22 = task21.ContinueWith((_) => { SubProcess2(22); result2.SetResult(true); }); task22.Ignore(); Thread.Sleep(TimeSpan.FromSeconds(1)); mainDone = true; }), context); try { await result1.Task.WithTimeout(TimeSpan.FromSeconds(3)); } catch (TimeoutException) { Assert.Fail("Timeout-1"); } try { await result2.Task.WithTimeout(TimeSpan.FromSeconds(3)); } catch (TimeoutException) { Assert.Fail("Timeout-2"); } Assert.AreNotEqual(0, stageNum1, "Work items did not get executed-1"); Assert.AreNotEqual(0, stageNum2, "Work items did not get executed-2"); Assert.AreEqual(14, stageNum1, "Work items executed out of order-1"); Assert.AreEqual(22, stageNum2, "Work items executed out of order-2"); }
public void Sched_AC_MainTurnWait_Test() { orleansTaskScheduler = TestHelper.InitializeSchedulerForTesting(new UnitTestSchedulingContext()); var promise = Task.Factory.StartNew(() => { Thread.Sleep(1000); }); promise.Wait(); }
public Catalog( SiloInitializationParameters siloInitializationParameters, ILocalGrainDirectory grainDirectory, GrainTypeManager typeManager, OrleansTaskScheduler scheduler, ActivationDirectory activationDirectory, ClusterConfiguration config, GrainCreator grainCreator, NodeConfiguration nodeConfig, ISiloMessageCenter messageCenter, PlacementDirectorsManager placementDirectorsManager) : base(Constants.CatalogId, messageCenter.MyAddress) { LocalSilo = siloInitializationParameters.SiloAddress; localSiloName = siloInitializationParameters.Name; directory = grainDirectory; activations = activationDirectory; this.scheduler = scheduler; GrainTypeManager = typeManager; collectionNumber = 0; destroyActivationsNumber = 0; this.grainCreator = grainCreator; this.nodeConfig = nodeConfig; logger = LogManager.GetLogger("Catalog", Runtime.LoggerType.Runtime); this.config = config.Globals; ActivationCollector = new ActivationCollector(config); this.Dispatcher = new Dispatcher(scheduler, messageCenter, this, config, placementDirectorsManager); GC.GetTotalMemory(true); // need to call once w/true to ensure false returns OK value config.OnConfigChange("Globals/Activation", () => scheduler.RunOrQueueAction(Start, SchedulingContext), false); IntValueStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_COUNT, () => activations.Count); activationsCreated = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_CREATED); activationsDestroyed = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_DESTROYED); activationsFailedToActivate = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_FAILED_TO_ACTIVATE); collectionCounter = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_COLLECTION_NUMBER_OF_COLLECTIONS); inProcessRequests = IntValueStatistic.FindOrCreate(StatisticNames.MESSAGING_PROCESSING_ACTIVATION_DATA_ALL, () => { long counter = 0; lock (activations) { foreach (var activation in activations) { ActivationData data = activation.Value; counter += data.GetRequestCount(); } } return counter; }); maxWarningRequestProcessingTime = this.config.ResponseTimeout.Multiply(5); maxRequestProcessingTime = this.config.MaxRequestProcessingTime; }
public Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config) { Name = name; this.logger = providerRuntime.GetLogger("MockStatsSiloCollector"); this.grain = providerRuntime.GrainFactory.GetGrain<IStatsCollectorGrain>(0); this.taskScheduler = Silo.CurrentSilo.LocalScheduler; this.schedulingContext = Silo.CurrentSilo.testHook.SchedulingContext; logger.Info("{0} Init called", GetType().Name); return TaskDone.Done; }
// This is the maximum number of waiting threads (blocked in WaitForResponse) allowed // per ActivationWorker. An attempt to wait when there are already too many threads waiting // will result in a TooManyWaitersException being thrown. //private static readonly int MaxWaitingThreads = 500; internal WorkItemGroup(OrleansTaskScheduler sched, ISchedulingContext schedulingContext) { masterScheduler = sched; SchedulingContext = schedulingContext; state = WorkGroupStatus.Waiting; workItems = new Queue<ActivationTask>(); lockable = new Object(); totalItemsEnQueued = 0; totalItemsProcessed = 0; totalQueuingDelay = TimeSpan.Zero; quantumExpirations = 0; TaskRunner = new ActivationTaskScheduler(this); log = IsSystemPriority ? LogManager.GetLogger("Scheduler." + Name + ".WorkItemGroup", LoggerType.Runtime) : appLogger; if (StatisticsCollector.CollectShedulerQueuesStats) { queueTracking = new QueueTrackingStatistic("Scheduler." + SchedulingContext.Name); queueTracking.OnStartExecution(); } if (StatisticsCollector.CollectPerWorkItemStats) { workItemGroupStatisticsNumber = SchedulerStatisticsGroup.RegisterWorkItemGroup(SchedulingContext.Name, SchedulingContext, () => { var sb = new StringBuilder(); lock (lockable) { sb.Append("QueueLength = " + WorkItemCount); sb.Append(String.Format(", State = {0}", state)); if (state == WorkGroupStatus.Runnable) sb.Append(String.Format("; oldest item is {0} old", workItems.Count >= 0 ? workItems.Peek().ToString() : "null")); } return sb.ToString(); }); } }
internal Silo(SiloInitializationParameters initializationParams) { string name = initializationParams.Name; ClusterConfiguration config = initializationParams.ClusterConfig; this.initializationParams = initializationParams; SystemStatus.Current = SystemStatus.Creating; CurrentSilo = this; var startTime = DateTime.UtcNow; siloTerminatedEvent = new ManualResetEvent(false); if (!LogManager.IsInitialized) LogManager.Initialize(LocalConfig); config.OnConfigChange("Defaults/Tracing", () => LogManager.Initialize(LocalConfig, true), false); MultiClusterRegistrationStrategy.Initialize(config.Globals); StatisticsCollector.Initialize(LocalConfig); SerializationManager.Initialize(GlobalConfig.SerializationProviders, this.GlobalConfig.FallbackSerializationProvider); initTimeout = GlobalConfig.MaxJoinAttemptTime; if (Debugger.IsAttached) { initTimeout = StandardExtensions.Max(TimeSpan.FromMinutes(10), GlobalConfig.MaxJoinAttemptTime); stopTimeout = initTimeout; } var localEndpoint = this.initializationParams.SiloAddress.Endpoint; LogManager.MyIPEndPoint = localEndpoint; logger = LogManager.GetLogger("Silo", LoggerType.Runtime); logger.Info(ErrorCode.SiloGcSetting, "Silo starting with GC settings: ServerGC={0} GCLatencyMode={1}", GCSettings.IsServerGC, Enum.GetName(typeof(GCLatencyMode), GCSettings.LatencyMode)); if (!GCSettings.IsServerGC || !GCSettings.LatencyMode.Equals(GCLatencyMode.Batch)) { logger.Warn(ErrorCode.SiloGcWarning, "Note: Silo not running with ServerGC turned on or with GCLatencyMode.Batch enabled - recommend checking app config : <configuration>-<runtime>-<gcServer enabled=\"true\"> and <configuration>-<runtime>-<gcConcurrent enabled=\"false\"/>"); logger.Warn(ErrorCode.SiloGcWarning, "Note: ServerGC only kicks in on multi-core systems (settings enabling ServerGC have no effect on single-core machines)."); } logger.Info(ErrorCode.SiloInitializing, "-------------- Initializing {0} silo on host {1} MachineName {2} at {3}, gen {4} --------------", this.initializationParams.Type, LocalConfig.DNSHostName, Environment.MachineName, localEndpoint, this.initializationParams.SiloAddress.Generation); logger.Info(ErrorCode.SiloInitConfig, "Starting silo {0} with the following configuration= " + Environment.NewLine + "{1}", name, config.ToString(name)); // Configure DI using Startup type this.Services = StartupBuilder.ConfigureStartup( this.LocalConfig.StartupTypeName, (services, usingCustomServiceProvider) => { // add system types // Note: you can replace IGrainFactory with your own implementation, but // we don't recommend it, in the aspect of performance and usability services.TryAddSingleton(sp => sp); services.TryAddSingleton(this); services.TryAddSingleton(initializationParams); services.TryAddSingleton<ILocalSiloDetails>(initializationParams); services.TryAddSingleton(initializationParams.ClusterConfig); services.TryAddSingleton(initializationParams.GlobalConfig); services.TryAddTransient(sp => initializationParams.NodeConfig); services.TryAddSingleton<ITimerRegistry, TimerRegistry>(); services.TryAddSingleton<IReminderRegistry, ReminderRegistry>(); services.TryAddSingleton<IStreamProviderManager, StreamProviderManager>(); services.TryAddSingleton<GrainRuntime>(); services.TryAddSingleton<IGrainRuntime, GrainRuntime>(); services.TryAddSingleton<OrleansTaskScheduler>(); services.TryAddSingleton<GrainFactory>(sp => sp.GetService<InsideRuntimeClient>().ConcreteGrainFactory); services.TryAddExisting<IGrainFactory, GrainFactory>(); services.TryAddExisting<IInternalGrainFactory, GrainFactory>(); services.TryAddSingleton<TypeMetadataCache>(); services.TryAddSingleton<AssemblyProcessor>(); services.TryAddSingleton<ActivationDirectory>(); services.TryAddSingleton<LocalGrainDirectory>(); services.TryAddExisting<ILocalGrainDirectory, LocalGrainDirectory>(); services.TryAddSingleton<SiloStatisticsManager>(); services.TryAddSingleton<ISiloPerformanceMetrics>(sp => sp.GetRequiredService<SiloStatisticsManager>().MetricsTable); services.TryAddSingleton<SiloAssemblyLoader>(); services.TryAddSingleton<GrainTypeManager>(); services.TryAddExisting<IMessagingConfiguration, GlobalConfiguration>(); services.TryAddSingleton<MessageCenter>(); services.TryAddExisting<IMessageCenter, MessageCenter>(); services.TryAddExisting<ISiloMessageCenter, MessageCenter>(); services.TryAddSingleton<Catalog>(); services.TryAddSingleton(sp => sp.GetRequiredService<Catalog>().Dispatcher); services.TryAddSingleton<InsideRuntimeClient>(); services.TryAddExisting<IRuntimeClient, InsideRuntimeClient>(); services.TryAddExisting<ISiloRuntimeClient, InsideRuntimeClient>(); services.TryAddSingleton<MembershipFactory>(); services.TryAddSingleton<MultiClusterOracleFactory>(); services.TryAddSingleton<LocalReminderServiceFactory>(); services.TryAddSingleton<DeploymentLoadPublisher>(); services.TryAddSingleton<IMembershipTable>( sp => sp.GetRequiredService<MembershipFactory>().GetMembershipTable(sp.GetRequiredService<GlobalConfiguration>())); services.TryAddSingleton<MembershipOracle>( sp => sp.GetRequiredService<MembershipFactory>() .CreateMembershipOracle(sp.GetRequiredService<Silo>(), sp.GetRequiredService<IMembershipTable>())); services.TryAddExisting<IMembershipOracle, MembershipOracle>(); services.TryAddExisting<ISiloStatusOracle, MembershipOracle>(); services.TryAddSingleton<Func<ISiloStatusOracle>>(sp => () => sp.GetRequiredService<ISiloStatusOracle>()); services.TryAddSingleton<MultiClusterOracleFactory>(); services.TryAddSingleton<LocalReminderServiceFactory>(); services.TryAddSingleton<ClientObserverRegistrar>(); services.TryAddSingleton<SiloProviderRuntime>(); services.TryAddExisting<IStreamProviderRuntime, SiloProviderRuntime>(); services.TryAddSingleton<ImplicitStreamSubscriberTable>(); // Placement services.TryAddSingleton<PlacementDirectorsManager>(); services.TryAddSingleton<IPlacementDirector<RandomPlacement>, RandomPlacementDirector>(); services.TryAddSingleton<IPlacementDirector<PreferLocalPlacement>, PreferLocalPlacementDirector>(); services.TryAddSingleton<IPlacementDirector<StatelessWorkerPlacement>, StatelessWorkerDirector>(); services.TryAddSingleton<IPlacementDirector<ActivationCountBasedPlacement>, ActivationCountPlacementDirector>(); services.TryAddSingleton<DefaultPlacementStrategy>(); services.TryAddSingleton<ClientObserversPlacementDirector>(); services.TryAddSingleton<Func<IGrainRuntime>>(sp => () => sp.GetRequiredService<IGrainRuntime>()); services.TryAddSingleton<GrainCreator>(); if (initializationParams.GlobalConfig.UseVirtualBucketsConsistentRing) { services.TryAddSingleton<IConsistentRingProvider>( sp => new VirtualBucketsRingProvider( this.initializationParams.SiloAddress, this.initializationParams.GlobalConfig.NumVirtualBucketsConsistentRing)); } else { services.TryAddSingleton<IConsistentRingProvider>( sp => new ConsistentRingProvider(this.initializationParams.SiloAddress)); } }); this.assemblyProcessor = this.Services.GetRequiredService<AssemblyProcessor>(); this.assemblyProcessor.Initialize(); BufferPool.InitGlobalBufferPool(GlobalConfig); UnobservedExceptionsHandlerClass.SetUnobservedExceptionHandler(UnobservedExceptionHandler); AppDomain.CurrentDomain.UnhandledException += this.DomainUnobservedExceptionHandler; try { grainFactory = Services.GetRequiredService<GrainFactory>(); } catch (InvalidOperationException exc) { logger.Error(ErrorCode.SiloStartError, "Exception during Silo.Start, GrainFactory was not registered in Dependency Injection container", exc); throw; } grainTypeManager = Services.GetRequiredService<GrainTypeManager>(); // Performance metrics siloStatistics = Services.GetRequiredService<SiloStatisticsManager>(); // The scheduler scheduler = Services.GetRequiredService<OrleansTaskScheduler>(); healthCheckParticipants.Add(scheduler); runtimeClient = Services.GetRequiredService<InsideRuntimeClient>(); // Initialize the message center messageCenter = Services.GetRequiredService<MessageCenter>(); messageCenter.RerouteHandler = runtimeClient.RerouteMessage; messageCenter.SniffIncomingMessage = runtimeClient.SniffIncomingMessage; // GrainRuntime can be created only here, after messageCenter was created. grainRuntime = Services.GetRequiredService<IGrainRuntime>(); // Now the router/directory service // This has to come after the message center //; note that it then gets injected back into the message center.; localGrainDirectory = Services.GetRequiredService<LocalGrainDirectory>(); // Now the activation directory. activationDirectory = Services.GetRequiredService<ActivationDirectory>(); // Now the consistent ring provider RingProvider = Services.GetRequiredService<IConsistentRingProvider>(); // to preserve backwards compatibility, only use the service provider to inject grain dependencies if the user supplied his own // service provider, meaning that he is explicitly opting into it. catalog = Services.GetRequiredService<Catalog>(); siloStatistics.MetricsTable.Scheduler = scheduler; siloStatistics.MetricsTable.ActivationDirectory = activationDirectory; siloStatistics.MetricsTable.ActivationCollector = catalog.ActivationCollector; siloStatistics.MetricsTable.MessageCenter = messageCenter; // Now the incoming message agents incomingSystemAgent = new IncomingMessageAgent(Message.Categories.System, messageCenter, activationDirectory, scheduler, catalog.Dispatcher); incomingPingAgent = new IncomingMessageAgent(Message.Categories.Ping, messageCenter, activationDirectory, scheduler, catalog.Dispatcher); incomingAgent = new IncomingMessageAgent(Message.Categories.Application, messageCenter, activationDirectory, scheduler, catalog.Dispatcher); membershipFactory = Services.GetRequiredService<MembershipFactory>(); membershipOracle = Services.GetRequiredService<IMembershipOracle>(); SystemStatus.Current = SystemStatus.Created; StringValueStatistic.FindOrCreate(StatisticNames.SILO_START_TIME, () => LogFormatter.PrintDate(startTime)); // this will help troubleshoot production deployment when looking at MDS logs. logger.Info(ErrorCode.SiloInitializingFinished, "-------------- Started silo {0}, ConsistentHashCode {1:X} --------------", SiloAddress.ToLongString(), SiloAddress.GetConsistentHashCode()); }
internal WorkerPoolThread(WorkerPool gtp, OrleansTaskScheduler sched, int threadNumber, bool system = false) : base((system ? "System." : "") + threadNumber) { pool = gtp; scheduler = sched; ownsSemaphore = false; IsSystem = system; maxWorkQueueWait = IsSystem ? Constants.INFINITE_TIMESPAN : gtp.MaxWorkQueueWait; OnFault = FaultBehavior.IgnoreFault; currentWorkItemStarted = DateTime.UtcNow; currentTaskStarted = DateTime.UtcNow; CurrentWorkItem = null; if (StatisticsCollector.CollectTurnsStats) WorkerThreadStatisticsNumber = SchedulerStatisticsGroup.RegisterWorkingThread(Name); }
public void TestInit() { context = new UnitTestSchedulingContext(); masterScheduler = TestInternalHelper.InitializeSchedulerForTesting(context); }