/// <summary> /// Assign a worker to the shift. /// </summary> /// <param name="worker"></param> public void Assign(TestWorker worker) { log.Debug("{0} shift assigned worker {1}", _name, worker.Name); Workers.Add(worker); worker.Busy += (s, ea) => Interlocked.Increment(ref _busyCount); worker.Idle += (s, ea) => { // Quick check first using Interlocked.Decrement if (Interlocked.Decrement(ref _busyCount) == 0) { lock (_syncRoot) { // Check busy count again under the lock if (_busyCount == 0 && !HasWork) { this.EndShift(); } } } }; worker.Start(); }
public void StopQueue_WithWorkers() { var workers = new TestWorker[] { new TestWorker(_queue, "1", ApartmentState.MTA), new TestWorker(_queue, "2", ApartmentState.MTA), new TestWorker(_queue, "3", ApartmentState.MTA) }; foreach (var worker in workers) { worker.Start(); Assert.That(worker.IsAlive, "Worker thread {0} did not start", worker.Name); } _queue.Start(); _queue.Stop(); Assert.That(_queue.State, Is.EqualTo(WorkItemQueueState.Stopped)); Thread.Sleep(20); // Allow time for workers to stop foreach (var worker in workers) { Assert.False(worker.IsAlive, "Worker thread {0} did not stop", worker.Name); } }
private void InitializeShifts() { foreach (var shift in Shifts) { shift.EndOfShift += OnEndOfShift; } // Assign queues to shifts ParallelShift.AddQueue(ParallelQueue); ParallelShift.AddQueue(ParallelSTAQueue); NonParallelShift.AddQueue(NonParallelQueue); NonParallelSTAShift.AddQueue(NonParallelSTAQueue); // Create workers and assign to shifts and queues // TODO: Avoid creating all the workers till needed for (int i = 1; i <= LevelOfParallelism; i++) { string name = string.Format("ParallelWorker#" + i.ToString()); ParallelShift.Assign(new TestWorker(ParallelQueue, name)); } ParallelShift.Assign(new TestWorker(ParallelSTAQueue, "ParallelSTAWorker")); var worker = new TestWorker(NonParallelQueue, "NonParallelWorker"); worker.Busy += OnStartNonParallelWorkItem; NonParallelShift.Assign(worker); worker = new TestWorker(NonParallelSTAQueue, "NonParallelSTAWorker"); worker.Busy += OnStartNonParallelWorkItem; NonParallelSTAShift.Assign(worker); }
private void OnStartNonParallelWorkItem(TestWorker worker, WorkItem work) { if (work is CompositeWorkItem) { SaveQueueState(work); } }
private void OnStartNonParallelWorkItem(TestWorker worker, WorkItem work) { // This captures the startup of TestFixtures and SetUpFixtures, // but not their teardown items, which are not composite items if (work.IsolateChildTests) { IsolateQueues(work); } }
public void SetUp() { _queue = new WorkItemQueue("TestQ"); #if NETCF _worker = new TestWorker(_queue, "TestQ_Worker"); #else _worker = new TestWorker(_queue, "TestQ_Worker", ApartmentState.MTA); #endif }
public void SetUp() { #if APARTMENT_STATE _queue = new WorkItemQueue("TestQ", true, ApartmentState.MTA); #else _queue = new WorkItemQueue("TestQ", true); #endif _worker = new TestWorker(_queue, "TestQ_Worker"); }
private void OnStartNonParallelWorkItem(TestWorker worker, WorkItem work) { // This captures the startup of TestFixtures and SetUpFixtures, // but not their teardown items, which are not composite items if (work is CompositeWorkItem && work.Test.TypeInfo != null) { IsolateQueues(work); } }
public void SetUp() { _queue = new WorkItemQueue("TestQ"); #if NETCF _worker = new TestWorker(_queue, "TestQ_Worker"); #else _worker = new TestWorker(_queue, "TestQ_Worker", ApartmentState.MTA); #endif }
public void StopQueue_WithWorkers() { var workers = new TestWorker[] { new TestWorker(_queue, "1"), new TestWorker(_queue, "2"), new TestWorker(_queue, "3") }; foreach (var worker in workers) { worker.Start(); Assert.That(worker.IsAlive, "Worker thread {0} did not start", worker.Name); } _queue.Start(); _queue.Stop(); Assert.That(_queue.State, Is.EqualTo(WorkItemQueueState.Stopped)); int iters = 10; int alive = workers.Length; while (iters-- > 0 && alive > 0) { Thread.Sleep(60); // Allow time for workers to stop alive = 0; foreach (var worker in workers) { if (worker.IsAlive) { alive++; } } } if (alive > 0) { foreach (var worker in workers) { Assert.False(worker.IsAlive, "Worker thread {0} did not stop", worker.Name); } } }
public void StopQueue_WithWorkers() { var workers = new TestWorker[] { new TestWorker(_queue, "1", ApartmentState.MTA), new TestWorker(_queue, "2", ApartmentState.MTA), new TestWorker(_queue, "3", ApartmentState.MTA) }; foreach (var worker in workers) { worker.Start(); Assert.That(worker.IsAlive, "Worker thread {0} did not start", worker.Name); } _queue.Start(); _queue.Stop(); Assert.That(_queue.State, Is.EqualTo(WorkItemQueueState.Stopped)); Thread.Sleep(20); // Allow time for workers to stop foreach (var worker in workers) Assert.False(worker.IsAlive, "Worker thread {0} did not stop", worker.Name); }
/// <summary> /// Construct a ParallelWorkItemDispatcher /// </summary> /// <param name="levelOfParallelism">Number of workers to use</param> public ParallelWorkItemDispatcher(int levelOfParallelism) { // Create Shifts ParallelShift = new WorkShift("Parallel"); NonParallelShift = new WorkShift("NonParallel"); NonParallelSTAShift = new WorkShift("NonParallelSTA"); foreach (var shift in Shifts) { shift.EndOfShift += OnEndOfShift; } // Assign queues to shifts ParallelShift.AddQueue(ParallelQueue); ParallelShift.AddQueue(ParallelSTAQueue); NonParallelShift.AddQueue(NonParallelQueue); NonParallelSTAShift.AddQueue(NonParallelSTAQueue); // Create workers and assign to shifts and queues // TODO: Avoid creating all the workers till needed for (int i = 1; i <= levelOfParallelism; i++) { string name = string.Format("Worker#" + i.ToString()); ParallelShift.Assign(new TestWorker(ParallelQueue, name)); } ParallelShift.Assign(new TestWorker(ParallelSTAQueue, "Worker#STA")); var worker = new TestWorker(NonParallelQueue, "Worker#STA_NP"); worker.Busy += OnStartNonParallelWorkItem; NonParallelShift.Assign(worker); worker = new TestWorker(NonParallelSTAQueue, "Worker#NP_STA"); worker.Busy += OnStartNonParallelWorkItem; NonParallelSTAShift.Assign(worker); }
/// <summary> /// Assign a worker to this shift. The worker is already /// associated with a queue, which must be one of those /// owned by the shift. /// </summary> /// <param name="worker"></param> public void Assign(TestWorker worker) { _workers.Add(worker); worker.Busy += (s, ea) => { Interlocked.Increment(ref _busyCount); }; worker.Idle += (s, ea) => { // Quick check first if (Interlocked.Decrement(ref _busyCount) == 0) { lock (_syncRoot) { // Double-check that all workers are idle if (_busyCount > 0) { return; } // Check that the queues are empty foreach (var q in _queues) { if (!q.IsEmpty) { return; } } // End the shift this.Pause(); // Signal the dispatcher if (EndOfShift != null) { EndOfShift(this, EventArgs.Empty); } } } }; worker.Start(); }
public void StopQueue_WithWorkers() { var workers = new TestWorker[] { new TestWorker(_queue, "1", ApartmentState.MTA), new TestWorker(_queue, "2", ApartmentState.MTA), new TestWorker(_queue, "3", ApartmentState.MTA) }; foreach (var worker in workers) { worker.Start(); Assert.That(worker.IsAlive, "Worker thread {0} did not start", worker.Name); } _queue.Start(); _queue.Stop(); Assert.That(_queue.State, Is.EqualTo(WorkItemQueueState.Stopped)); int iters = 10; int alive = workers.Length; while (iters-- > 0 && alive > 0) { Thread.Sleep(60); // Allow time for workers to stop alive = 0; foreach (var worker in workers) if (worker.IsAlive) alive++; } if (alive > 0) foreach (var worker in workers) Assert.False(worker.IsAlive, "Worker thread {0} did not stop", worker.Name); }
public void SetUp() { _queue = new WorkItemQueue("TestQ"); _worker = new TestWorker(_queue, "TestQ_Worker", ApartmentState.MTA); }
/// <summary> /// Assign a worker to the shift. /// </summary> /// <param name="worker"></param> public void Assign(TestWorker worker) { log.Debug("{0} shift assigned worker {1}", Name, worker.Name); Workers.Add(worker); }
public void SetUp() { _queue = new WorkItemQueue("TestQ"); _worker = new TestWorker(_queue, "TestQ_Worker", ApartmentState.MTA); }
/// <summary> /// Assign a worker to the shift. /// </summary> /// <param name="worker"></param> public void Assign(TestWorker worker) { log.Debug("{0} shift assigned worker {1}", _name, worker.Name); Workers.Add(worker); worker.Busy += (s, ea) => Interlocked.Increment(ref _busyCount); worker.Idle += (s, ea) => { // Quick check first using Interlocked.Decrement if (Interlocked.Decrement(ref _busyCount) == 0) lock (_syncRoot) { // Check busy count again under the lock if (_busyCount == 0 && !HasWork) this.EndShift(); } }; worker.Start(); }
/// <summary> /// Assign a worker to this shift. The worker is already /// associated with a queue, which must be one of those /// owned by the shift. /// </summary> /// <param name="worker"></param> public void Assign(TestWorker worker) { _workers.Add(worker); worker.Busy += (s, ea) => { Interlocked.Increment(ref _busyCount); }; worker.Idle += (s, ea) => { // Quick check first if (Interlocked.Decrement(ref _busyCount) == 0) lock (_syncRoot) { // Double-check that all workers are idle if (_busyCount > 0) return; // Check that the queues are empty foreach (var q in _queues) if (!q.IsEmpty) return; // End the shift this.Pause(); // Signal the dispatcher if (EndOfShift != null) EndOfShift(this, EventArgs.Empty); } }; worker.Start(); }