// 1. Work item is added public void AddWork(WorkItem workItem) { // 2. Work task is decomposed List<Goal> newGoals = _decompService.Decompose(workItem); // 3. The goal's satisfied event is registered with this work enactor GoalSatisfiedHandler handler = null; handler = delegate(Goal g) { GoalSatisified(g, workItem); g.GoalSatisfied -= handler; }; newGoals.ForEach(g => g.GoalSatisfied += handler); // 4. The goals are added to this enactor's list against the workitem // and also the list of workitems being processed _workitemGoals.Add(workItem, newGoals); StartWork(workItem); // 5. Goals are registered with the world state service newGoals.ForEach(_goalService.RegisterGoal); // 6. Notify user of goals etc... foreach (var goal in newGoals) { _user.NotifyUser(workItem.taskName + " - " + goal.ToString()); } }
public WorkItemStatus Cancel(WorkItem item, bool allowAbort) { if (item == null) throw new ArgumentNullException("item"); lock (_callbacks) { LinkedListNode<WorkItem> node = _callbacks.Find(item); if (node != null) { _callbacks.Remove(node); return WorkItemStatus.Queued; } else if (_threads.ContainsKey(item)) { if (allowAbort) { _threads[item].Abort(); _threads.Remove(item); return WorkItemStatus.Aborted; } else return WorkItemStatus.Executing; } else return WorkItemStatus.Completed; } }
/// <summary> /// See <see cref="IModuleLoaderService.Load(WorkItem, IModuleInfo[])"/> for more information. /// </summary> public void Load(WorkItem workItem, params IModuleInfo[] modules) { Guard.ArgumentNotNull(workItem, "workItem"); Guard.ArgumentNotNull(modules, "modules"); InnerLoad(workItem, modules); }
private void EnqueueActiveFileItem(WorkItem item) { this.UpdateLastAccessTime(); var added = _workItemQueue.AddOrReplace(item); Logger.Log(FunctionId.WorkCoordinator_ActiveFileEnqueue, s_enqueueLogger, Environment.TickCount, item.DocumentId, !added); SolutionCrawlerLogger.LogActiveFileEnqueue(_processor._logAggregator); }
private void CheckHigherPriorityDocument(WorkItem item) { if (!item.InvocationReasons.Contains(PredefinedInvocationReasons.HighPriority)) { return; } AddHigherPriorityDocument(item.DocumentId); }
public static bool QueueUserWorkItem(WaitCallback callback, object state) { Contract.Requires(callback != null); Contract.Requires(threads != null); var item = new WorkItem(callback, state); workItemQueue.Enqueue(item); return true; }
public void CompleteWork(WorkItem workItem) { if (/*_workAgent.started.Contains(workItem) &&*/ WorkAgent.processing.Contains(workItem)) { _user.NotifyUser("Just completed workitem: " + workItem.taskName); WorkAgent.Complete(workItem, _workflow); } _completedGoals.Add(workItem, _workitemGoals[workItem]); _workitemGoals.Remove(workItem); }
/// <summary>Initializes a new instance of the IOTaskScheduler class.</summary> public unsafe IOTaskScheduler() { // Configure the object pool of work items _availableWorkItems = new ObjectPool<WorkItem>(() => { var wi = new WorkItem { _scheduler = this }; wi._pNOlap = new Overlapped().UnsafePack(wi.Callback, null); return wi; }, new ConcurrentStack<WorkItem>()); }
/// <summary> /// Initializes a new instance of the <see cref="AuthorizationService"/> class. /// </summary> /// <param name="workItem">The work item.</param> public AuthorizationService([ServiceDependency]WorkItem workItem) { lock (syncObj) { this.workItem = workItem; authorizationStoreService = workItem.Services.Get<IAuthorizationStoreService>(); if (authorizationStoreService != null) { authorizations = authorizationStoreService.GetAuthorizationsByUser(Thread.CurrentPrincipal.Identity.Name); // 获取当前用户的所有授权信息 } } }
/// <summary> /// See <see cref="IModuleLoaderService.Load(WorkItem, Assembly[])"/> for more information. /// </summary> public void Load(WorkItem workItem, params Assembly[] assemblies) { Guard.ArgumentNotNull(workItem, "workItem"); Guard.ArgumentNotNull(assemblies, "assemblies"); List<IModuleInfo> modules = new List<IModuleInfo>(); foreach (Assembly assembly in assemblies) modules.Add(new ModuleInfo(assembly)); InnerLoad(workItem, modules.ToArray()); }
public AuthenticationService([ServiceDependency]WorkItem workItem, [ServiceDependency] IUserSelectorService userSelector) { _userSelector = userSelector; if (workItem.RootWorkItem == null) { _rootWorkItem = workItem; } else { _rootWorkItem = workItem.RootWorkItem; } }
public void QueueUserWorkItem(WaitCallback callback, object parameter) { var workItem = new WorkItem(callback, parameter); lock (_jobQueue) { _jobQueue.Enqueue(workItem); if (_threadsWaiting > 0) { Monitor.Pulse(_jobQueue); } } }
public void Enqueue(WorkItem item) { this.UpdateLastAccessTime(); // Project work item = item.With(documentId: null, projectId: item.ProjectId, asyncToken: this.Processor._listener.BeginAsyncOperation("WorkItem")); var added = _workItemQueue.AddOrReplace(item); Logger.Log(FunctionId.WorkCoordinator_Project_Enqueue, s_enqueueLogger, Environment.TickCount, item.ProjectId, !added); SolutionCrawlerLogger.LogWorkItemEnqueue(this.Processor._logAggregator, item.ProjectId); }
public TimedWorker() { work = new WorkItem(); workIsWaiting = new AutoResetEvent(false); workerIsStarting = new AutoResetEvent(false); workerIsDone = new AutoResetEvent(false); workIsDone = new AutoResetEvent(false); manager = new Thread(new ThreadStart(RunManager)); worker = new Thread(new ThreadStart(RunWorker)); manager.Start(); worker.Start(); }
public override void Send(SendOrPostCallback d, object state) { if (Thread.CurrentThread == _uiThread) { d(state); } else { var workItem = new WorkItem { Callback = d, State = state, Handle = new AutoResetEvent(false) }; _workItems.Add(workItem); workItem.Handle.WaitOne(); } }
public override void Send(SendOrPostCallback d, object state) { if (Thread.CurrentThread == uiThread) { d(state); } else { EnsureUIThread(); var workItem = new WorkItem { callback = d, state = state, handle = new AutoResetEvent(false) }; workItems.Add(workItem); workItem.handle.WaitOne(); } }
public void Enqueue(WorkItem item) { Contract.ThrowIfFalse(item.DocumentId != null, "can only enqueue a document work item"); this.UpdateLastAccessTime(); var added = _workItemQueue.AddOrReplace(item); Logger.Log(FunctionId.WorkCoordinator_DocumentWorker_Enqueue, s_enqueueLogger, Environment.TickCount, item.DocumentId, !added); CheckHigherPriorityDocument(item); SolutionCrawlerLogger.LogWorkItemEnqueue( this.Processor._logAggregator, item.Language, item.DocumentId, item.InvocationReasons, item.IsLowPriority, item.ActiveMember, added); }
public LiveUpgradeService([ServiceDependency]WorkItem workItem, [ServiceDependency]IPropertyService propertyService) { this.workItem = workItem; this.propertyService = propertyService; LiveUpgradeConfigurationSection cs = ConfigurationManager.GetSection(LIVEUPGRADE_SECTION) as LiveUpgradeConfigurationSection; UpgradeSetting setting = GetSetting(); if (cs != null && setting != null) { detecter = new UpgradeDetecter(this); if (setting.CheckInterval > 0) { detecter.CheckInterval = setting.CheckInterval; detecter.Start(); } } }
public static bool QueueUserWorkItem(WaitCallback callback, object state) { if (callback == null) { throw new ArgumentNullException("callback"); } WorkItem workItem = new WorkItem() { Callback = callback, State = state, Context = ExecutionContext.Capture() }; bool success = false; // Start tracking this work item lock (_WorkItems) { _WorkItems.Add(workItem); } try { // Place work item on the thread pool queue success = ThreadPool.QueueUserWorkItem(new WaitCallback(HandleCallback), workItem); } catch { // Work item could not be queued success = false; throw; } finally { if (!success) { // Stop tracking this work item RemoveWorkItem(workItem); } } return success; }
/// <summary> /// Adds items to the work queue. /// /// If the unique for the item already exists, then the work item is discarded. /// /// If the priority is greater than previous items in the queue, then the new work item is /// inserted prior to the other items. /// /// This code maintains the sorted order of the workitems. /// </summary> /// <param name="oNewItem"></param> public void AddPrioritised(WorkItem oNewItem) { lock(m_Lock_WorkItem_AddRemove) { foreach (WorkItem oItem in m_WorkItems) if (oItem.Key.ToString() == oNewItem.Key.ToString()) { Debug.WriteLine("PrioritisedArrayList: Key Already Queued: Skipped Request"); return; } m_MREs.Add(oNewItem.MRE); int i = m_WorkItems.BinarySearch(oNewItem); if (i < 0) m_WorkItems.Insert(~i, oNewItem); else m_WorkItems.Insert(i, oNewItem); } }
public void Enqueue(WorkItem item) { Contract.ThrowIfFalse(item.DocumentId != null, "can only enqueue a document work item"); // we only put workitem in high priority queue if there is a text change. // this is to prevent things like opening a file, changing in other files keep enqueuing // expensive high priority work. if (!item.InvocationReasons.Contains(PredefinedInvocationReasons.SyntaxChanged)) { return; } // check whether given item is for active document, otherwise, nothing to do here if (_processor._documentTracker == null || _processor._documentTracker.GetActiveDocument() != item.DocumentId) { return; } // we need to clone due to waiter EnqueueActiveFileItem(item.With(Listener.BeginAsyncOperation("ActiveFile"))); }
public void Request(string cmd, int id, int credits) { switch (cmd) { case "Setup": case "Work": lock (requestsLock) { Thread req = new Thread(Req); WorkItem w = new WorkItem(req, cmd, credits); requests.Add(id, w); req.Start(new IComparable[] { cmd, id, credits }); } break; case "Cancel": lock (requestsLock) { if (requests.ContainsKey(id)) new Thread(Cancel).Start(id); } break; default: throw new Exception("Unknown command: " + cmd); } }
private static IndexEntry ReadNextNoSeek(WorkItem workItem) { //workItem.Stream.Read(workItem.Buffer, 0, IndexEntrySize); //var entry = (IndexEntry)Marshal.PtrToStructure(workItem.BufferHandle.AddrOfPinnedObject(), typeof(IndexEntry)); //return entry; return new IndexEntry(workItem.Reader.ReadUInt64(), workItem.Reader.ReadInt64()); }
private static IndexEntry ReadEntry(int indexNum, WorkItem workItem) { workItem.Stream.Seek(IndexEntrySize*(long)indexNum + PTableHeader.Size, SeekOrigin.Begin); return ReadNextNoSeek(workItem); }
private static void PositionAtEntry(int indexNum, WorkItem workItem) { workItem.Stream.Seek(IndexEntrySize * (long)indexNum + PTableHeader.Size, SeekOrigin.Begin); }
private async Task ProcessDocumentAsync(Solution solution, ImmutableArray<IIncrementalAnalyzer> analyzers, WorkItem workItem, CancellationTokenSource source) { if (this.CancellationToken.IsCancellationRequested) { return; } var processedEverything = false; var documentId = workItem.DocumentId; try { using (Logger.LogBlock(FunctionId.WorkCoordinator_ProcessDocumentAsync, source.Token)) { var cancellationToken = source.Token; var document = solution.GetDocument(documentId); if (document != null) { await ProcessDocumentAnalyzersAsync(document, analyzers, workItem, cancellationToken).ConfigureAwait(false); } if (!cancellationToken.IsCancellationRequested) { processedEverything = true; } } } catch (Exception e) when (FatalError.ReportUnlessCanceled(e)) { throw ExceptionUtilities.Unreachable; } finally { // we got cancelled in the middle of processing the document. // let's make sure newly enqueued work item has all the flag needed. if (!processedEverything) { _workItemQueue.AddOrReplace(workItem.Retry(this.Listener.BeginAsyncOperation("ReenqueueWorkItem"))); } SolutionCrawlerLogger.LogProcessActiveFileDocument(_processor._logAggregator, documentId.Id, processedEverything); // remove one that is finished running _workItemQueue.RemoveCancellationSource(workItem.DocumentId); } }
private void EnsureModuleClassesExist(WorkItem workItem) { if (moduleClasses.Count == moduleTypes.Count) return; try { foreach (Type moduleType in moduleTypes) { IModule module = (IModule)workItem.Items.AddNew(moduleType); moduleClasses.Add(module); if (traceSource != null) traceSource.TraceInformation(Properties.Resources.LogModuleAdded, moduleType); } } catch (FileNotFoundException ex) { ThrowModuleReferenceException(ex); } catch (Exception ex) { ThrowModuleLoadException(ex); } }
private void ReturnWorkItem(WorkItem workItem) { _workItems.Return(workItem); }
public void LoadServices(WorkItem workItem) { if (loadedServices) return; loadedServices = true; EnsureModuleClassesExist(workItem); try { foreach (IModule moduleClass in moduleClasses) { moduleClass.AddServices(); if (traceSource != null) traceSource.TraceInformation(Properties.Resources.AddServicesCalled, moduleClass.GetType()); } foreach (ServiceMetadata svc in services) { if (svc.AddOnDemand) { workItem.Services.AddOnDemand(svc.InstanceType, svc.RegistrationType); if (traceSource != null) traceSource.TraceInformation(Properties.Resources.ServiceAddedOnDemand, Name, svc.InstanceType); } else { workItem.Services.AddNew(svc.InstanceType, svc.RegistrationType); if (traceSource != null) traceSource.TraceInformation(Properties.Resources.ServiceAdded, Name, svc.InstanceType); } } } catch (Exception ex) { ThrowModuleLoadException(ex); } }
private bool GetNextWorkItem(out WorkItem workItem, out CancellationTokenSource documentCancellation) { // GetNextWorkItem since it can't fail. we still return bool to confirm that this never fail. var documentId = _processor._documentTracker.GetActiveDocument(); if (documentId != null) { if (_workItemQueue.TryTake(documentId, out workItem, out documentCancellation)) { return true; } } return _workItemQueue.TryTakeAnyWork( preferableProjectId: null, dependencyGraph: _processor.DependencyGraph, analyzerService: _processor.DiagnosticAnalyzerService, workItem: out workItem, source: out documentCancellation); }