|
|
using System;
|
|
|
using System.Collections.Generic;
|
|
|
using System.Linq;
|
|
|
using System.Text;
|
|
|
using System.Threading;
|
|
|
using System.Diagnostics;
|
|
|
|
|
|
namespace Implab.Parallels {
|
|
|
public class WorkerPool : IDisposable {
|
|
|
readonly int m_minThreads;
|
|
|
readonly int m_maxThreads;
|
|
|
int m_runningThreads;
|
|
|
object m_lock = new object();
|
|
|
|
|
|
bool m_disposed = false;
|
|
|
|
|
|
// this event will signal that workers can try to fetch a task from queue or the pool has been disposed
|
|
|
ManualResetEvent m_hasTasks = new ManualResetEvent(false);
|
|
|
Queue<Action> m_queue = new Queue<Action>();
|
|
|
|
|
|
public WorkerPool(int min, int max) {
|
|
|
if (min < 0)
|
|
|
throw new ArgumentOutOfRangeException("min");
|
|
|
if (max <= 0)
|
|
|
throw new ArgumentOutOfRangeException("max");
|
|
|
|
|
|
if (min > max)
|
|
|
min = max;
|
|
|
m_minThreads = min;
|
|
|
m_maxThreads = max;
|
|
|
|
|
|
InitPool();
|
|
|
}
|
|
|
|
|
|
public WorkerPool(int max)
|
|
|
: this(0, max) {
|
|
|
}
|
|
|
|
|
|
public WorkerPool() {
|
|
|
int maxThreads, maxCP;
|
|
|
ThreadPool.GetMaxThreads(out maxThreads, out maxCP);
|
|
|
|
|
|
m_minThreads = 0;
|
|
|
m_maxThreads = maxThreads;
|
|
|
|
|
|
InitPool();
|
|
|
}
|
|
|
|
|
|
void InitPool() {
|
|
|
for (int i = 0; i < m_minThreads; i++)
|
|
|
StartWorker();
|
|
|
}
|
|
|
|
|
|
public int ThreadCount {
|
|
|
get {
|
|
|
return m_runningThreads;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public Promise<T> Invoke<T>(Func<T> task) {
|
|
|
if (m_disposed)
|
|
|
throw new ObjectDisposedException(ToString());
|
|
|
if (task == null)
|
|
|
throw new ArgumentNullException("task");
|
|
|
|
|
|
var promise = new Promise<T>();
|
|
|
|
|
|
var queueLen = EnqueueTask(delegate() {
|
|
|
try {
|
|
|
promise.Resolve(task());
|
|
|
} catch (Exception e) {
|
|
|
promise.Reject(e);
|
|
|
}
|
|
|
});
|
|
|
|
|
|
if (queueLen > 1)
|
|
|
StartWorker();
|
|
|
|
|
|
return promise;
|
|
|
}
|
|
|
|
|
|
bool StartWorker() {
|
|
|
var current = m_runningThreads;
|
|
|
// use spins to allocate slot for the new thread
|
|
|
do {
|
|
|
if (current >= m_maxThreads)
|
|
|
// no more slots left
|
|
|
return false;
|
|
|
} while (current != Interlocked.CompareExchange(ref m_runningThreads, current + 1, current));
|
|
|
|
|
|
// slot successfully allocated
|
|
|
|
|
|
var worker = new Thread(this.Worker);
|
|
|
worker.IsBackground = true;
|
|
|
worker.Start();
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
int EnqueueTask(Action task) {
|
|
|
Debug.Assert(task != null);
|
|
|
lock (m_queue) {
|
|
|
m_queue.Enqueue(task);
|
|
|
m_hasTasks.Set();
|
|
|
return m_queue.Count;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
bool FetchTask(out Action task) {
|
|
|
task = null;
|
|
|
|
|
|
while (true) {
|
|
|
|
|
|
m_hasTasks.WaitOne();
|
|
|
|
|
|
if (m_disposed)
|
|
|
return false;
|
|
|
|
|
|
lock (m_queue) {
|
|
|
if (m_queue.Count > 0) {
|
|
|
task = m_queue.Dequeue();
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
// no tasks left
|
|
|
// signal that no more tasks left, current lock ensures that this event won't suppress newly added task
|
|
|
m_hasTasks.Reset();
|
|
|
}
|
|
|
|
|
|
bool exit = true;
|
|
|
|
|
|
var current = m_runningThreads;
|
|
|
do {
|
|
|
if (current <= m_minThreads) {
|
|
|
exit = false; // this thread should return and wait for the new events
|
|
|
break;
|
|
|
}
|
|
|
} while (current != Interlocked.CompareExchange(ref m_runningThreads, current - 1, current));
|
|
|
|
|
|
if (exit)
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void Worker() {
|
|
|
Action task;
|
|
|
while (FetchTask(out task))
|
|
|
task();
|
|
|
}
|
|
|
|
|
|
protected virtual void Dispose(bool disposing) {
|
|
|
if (disposing) {
|
|
|
lock (m_lock) {
|
|
|
if (m_disposed)
|
|
|
return;
|
|
|
m_disposed = true;
|
|
|
}
|
|
|
m_hasTasks.Set();
|
|
|
GC.SuppressFinalize(this);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public void Dispose() {
|
|
|
Dispose(true);
|
|
|
}
|
|
|
|
|
|
~WorkerPool() {
|
|
|
Dispose(false);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
