|
|
using System;
|
|
|
using System.Collections.Generic;
|
|
|
using System.Linq;
|
|
|
using System.Text;
|
|
|
using System.Threading;
|
|
|
using System.Diagnostics;
|
|
|
using Implab.Diagnostics;
|
|
|
|
|
|
namespace Implab.Parallels {
|
|
|
public class WorkerPool : DispatchPool<Action> {
|
|
|
|
|
|
MTQueue<Action> m_queue = new MTQueue<Action>();
|
|
|
int m_queueLength = 0;
|
|
|
readonly int m_threshold = 1;
|
|
|
int m_workers = 0;
|
|
|
|
|
|
public WorkerPool(int minThreads, int maxThreads, int threshold)
|
|
|
: base(minThreads, maxThreads) {
|
|
|
m_threshold = threshold;
|
|
|
m_workers = minThreads;
|
|
|
InitPool();
|
|
|
}
|
|
|
|
|
|
public WorkerPool(int minThreads, int maxThreads) :
|
|
|
base(minThreads, maxThreads) {
|
|
|
m_workers = minThreads;
|
|
|
InitPool();
|
|
|
}
|
|
|
|
|
|
public WorkerPool(int threads)
|
|
|
: base(threads) {
|
|
|
m_workers = threads;
|
|
|
InitPool();
|
|
|
}
|
|
|
|
|
|
public WorkerPool()
|
|
|
: base() {
|
|
|
InitPool();
|
|
|
}
|
|
|
|
|
|
public Promise<T> Invoke<T>(Func<T> task) {
|
|
|
if (task == null)
|
|
|
throw new ArgumentNullException("task");
|
|
|
if (IsDisposed)
|
|
|
throw new ObjectDisposedException(ToString());
|
|
|
|
|
|
var promise = new Promise<T>();
|
|
|
|
|
|
var caller = TraceContext.Snapshot();
|
|
|
|
|
|
EnqueueTask(delegate() {
|
|
|
caller.Invoke(delegate() {
|
|
|
try {
|
|
|
promise.Resolve(task());
|
|
|
} catch (Exception e) {
|
|
|
promise.Reject(e);
|
|
|
}
|
|
|
});
|
|
|
});
|
|
|
|
|
|
return promise;
|
|
|
}
|
|
|
|
|
|
protected void EnqueueTask(Action unit) {
|
|
|
Debug.Assert(unit != null);
|
|
|
var len = Interlocked.Increment(ref m_queueLength);
|
|
|
m_queue.Enqueue(unit);
|
|
|
|
|
|
if (len > m_threshold * m_workers) {
|
|
|
Interlocked.Increment(ref m_workers);
|
|
|
GrowPool();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
protected override bool TryDequeue(out Action unit) {
|
|
|
if (m_queue.TryDequeue(out unit)) {
|
|
|
Interlocked.Decrement(ref m_queueLength);
|
|
|
return true;
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
protected override bool Suspend() {
|
|
|
// This override solves race condition
|
|
|
// WORKER CLIENT
|
|
|
// ---------------------------------------
|
|
|
// TryDeque == false
|
|
|
// Enqueue(unit), queueLen++
|
|
|
// GrowPool? == NO
|
|
|
// ActiveThreads--
|
|
|
// Suspend
|
|
|
// queueLength > 0
|
|
|
// continue
|
|
|
Thread.MemoryBarrier();
|
|
|
if (m_queueLength > 0)
|
|
|
return true;
|
|
|
Interlocked.Decrement(ref m_workers);
|
|
|
return base.Suspend();
|
|
|
}
|
|
|
|
|
|
protected override void InvokeUnit(Action unit) {
|
|
|
unit();
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
