public ThreadWorker (IScheduler sched, ThreadWorker[] others, IProducerConsumerCollection<Task> sharedWorkQueue,
bool createThread, int maxStackSize, ThreadPriority priority)
{
this.others = others;
// if (!string.IsNullOrEmpty (Environment.GetEnvironmentVariable ("USE_CYCLIC"))) {
// Console.WriteLine ("Using cyclic deque");
// this.dDeque = new CyclicDeque<Task> ();
// } else {
// this.dDeque = new DynamicDeque<Task> ();
// }
this.dDeque = new CyclicDeque<Task> ();
this.sharedWorkQueue = sharedWorkQueue;
this.workerLength = others.Length;
this.isLocal = !createThread;
this.childWorkAdder = delegate (Task t) {
dDeque.PushBottom (t);
sched.PulseAll ();
};
// Find the stealing start index randomly (then the traversal
// will be done in Round-Robin fashion)
do {
this.stealingStart = r.Next(0, workerLength);
} while (others[stealingStart] == this);
InitializeUnderlyingThread (maxStackSize, priority);
}
public static void AddStressTest(IProducerConsumerCollection<int> coll)
{
ParallelTestHelper.Repeat(delegate
{
int amount = -1;
const int count = 10;
const int threads = 5;
ParallelTestHelper.ParallelStressTest(coll, (q) =>
{
int t = Interlocked.Increment(ref amount);
for (int i = 0; i < count; i++)
coll.TryAdd(t);
}, threads);
Assert.AreEqual(threads * count, coll.Count, "#-1");
int[] values = new int[threads];
int temp;
while (coll.TryTake(out temp))
{
values[temp]++;
}
for (int i = 0; i < threads; i++)
Assert.AreEqual(count, values[i], "#" + i);
});
}
public SlackSendQueueService(IProducerConsumerCollection<OutputMessage> collection)
{
if (collection == null)
this.outputMessageQueue = new BlockingCollection<OutputMessage>();
else
this.outputMessageQueue = new BlockingCollection<OutputMessage>(collection);
}
public ThreadWorker (IScheduler sched, ThreadWorker[] others, IProducerConsumerCollection<Task> sharedWorkQueue,
bool createThread, int maxStackSize, ThreadPriority priority, EventWaitHandle handle)
{
this.others = others;
this.dDeque = new CyclicDeque<Task> ();
this.sharedWorkQueue = sharedWorkQueue;
this.workerLength = others.Length;
this.isLocal = !createThread;
this.waitHandle = handle;
this.childWorkAdder = delegate (Task t) {
dDeque.PushBottom (t);
sched.PulseAll ();
};
// Find the stealing start index randomly (then the traversal
// will be done in Round-Robin fashion)
do {
this.stealingStart = r.Next(0, workerLength);
} while (others[stealingStart] == this);
InitializeUnderlyingThread (maxStackSize, priority);
}
public static void RemoveStressTest(IProducerConsumerCollection<int> coll, CheckOrderingType order)
{
ParallelTestHelper.Repeat(delegate
{
const int count = 10;
const int threads = 5;
const int delta = 5;
for (int i = 0; i < (count + delta) * threads; i++)
while (!coll.TryAdd(i)) ;
bool state = true;
Assert.AreEqual((count + delta) * threads, coll.Count, "#0");
ParallelTestHelper.ParallelStressTest(coll, (q) =>
{
bool s = true;
int t;
for (int i = 0; i < count; i++)
{
s &= coll.TryTake(out t);
// try again in case it was a transient failure
if (!s && coll.TryTake(out t))
s = true;
}
if (!s)
state = false;
}, threads);
Assert.IsTrue(state, "#1");
Assert.AreEqual(delta * threads, coll.Count, "#2");
string actual = string.Empty;
int temp;
while (coll.TryTake(out temp))
{
actual += temp.ToString(); ;
}
IEnumerable<int> range = Enumerable.Range(order == CheckOrderingType.Reversed ? 0 : count * threads, delta * threads);
if (order == CheckOrderingType.Reversed)
range = range.Reverse();
string expected = range.Aggregate(string.Empty, (acc, v) => acc + v);
if (order == CheckOrderingType.DontCare)
{
actual.AreCollectionEquivalent(expected, "#3");
//--TODO Assert.That (actual, new CollectionEquivalentConstraint (expected), "#3");
}
else
Assert.AreEqual(expected, actual, "#3");
}, 10);
}
public Scheduler (int maxWorker, int maxStackSize, ThreadPriority priority)
{
workQueue = new ConcurrentQueue<Task> ();
workers = new ThreadWorker [maxWorker];
for (int i = 0; i < maxWorker; i++) {
workers [i] = new ThreadWorker (this, workers, workQueue, maxStackSize, priority);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RedisCommandQueue"/> class.
/// </summary>
/// <param name="configuration">The configuration string.</param>
/// <param name="collection">The collection to use as the underlying data store.</param>
public RedisCommandQueue(string configuration, IProducerConsumerCollection<ICommand> collection)
{
this.queue = new BlockingCollection<ICommand>(collection);
this.multiplexer = ConnectionMultiplexer.Connect(configuration);
this.database = this.multiplexer.GetDatabase();
this.pubsub = this.multiplexer.GetSubscriber();
this.pubsub.Subscribe(ChannelKey, this.HandleMessage);
this.timer = new Timer(this.FlushQueue, null, EmptyQueueInterval, EmptyQueueInterval);
}
public Scheduler (int maxWorker, ThreadPriority priority)
{
workQueue = new ConcurrentQueue<Task> ();
workers = new ThreadWorker [maxWorker];
for (int i = 0; i < maxWorker; i++) {
workers [i] = new ThreadWorker (workers, i, workQueue, new CyclicDeque<Task> (), priority, pulseHandle);
workers [i].Pulse ();
}
}
private IMessagingChannel TryConnect(string channelGroup, IProducerConsumerCollection<IMessagingChannel> items)
{
IMessagingChannel channel;
if (!items.TryTake(out channel))
{
Log.Debug("No available channel in the pool for '{0}', establishing a new channel.", channelGroup);
channel = this.connector.Connect(channelGroup);
}
Log.Verbose("Resolving channel for '{0}' from the pool of available channels.", channelGroup);
this.open.TryAdd(channel, true);
return new PooledDispatchChannel(this, channel, this.currentToken);
}
public static IObservable<Tuple<IDisposable<byte[]>, int>> ReadAsync(this Stream stream, int bufferSize, bool waitForObserver, bool refCount, IProducerConsumerCollection<IDisposable<byte[]>> cache)
{
var read = Observable.FromAsyncPattern<byte[], int, int, int> (stream.BeginRead, stream.EndRead);
return Observable.Create<Tuple<IDisposable<byte[]>, int>> (observer => {
var subscription = new BooleanDisposable ();
Action<Exception> onError = error => {
observer.OnError (error);
subscription.Dispose ();
};
Action loop = null;
Action<IDisposable<byte[]>, int> engine;
if (waitForObserver)
engine = (buffer, bytesRead) => {
// OnNext is called first
observer.OnNext (new Tuple<IDisposable<byte[]>, int> (buffer, bytesRead));
// then we begin async read
if (!subscription.IsDisposed)
loop ();
};
else
engine = (buffer, bytesRead) => {
// begin async read first
if (!subscription.IsDisposed)
loop ();
//then call OnNext
observer.OnNext (new Tuple<IDisposable<byte[]>, int> (buffer, bytesRead));
};
loop = () => {
var buffer = cache.TakeOrCreate (refCount, () =>
new byte[bufferSize]);
read (buffer.Value, 0, bufferSize).Subscribe (bytesRead => {
if (0 == bytesRead)
observer.OnCompleted ();
else
engine (buffer, bytesRead);
}, onError);
};
loop ();
return subscription;
});
}
public ThreadWorker (ThreadWorker[] others,
int workerPosition,
IProducerConsumerCollection<Task> sharedWorkQueue,
IConcurrentDeque<Task> dDeque,
ThreadPriority priority,
ManualResetEvent handle)
{
this.others = others;
this.dDeque = dDeque;
this.sharedWorkQueue = sharedWorkQueue;
this.workerLength = others.Length;
this.workerPosition = workerPosition;
this.waitHandle = handle;
this.threadPriority = priority;
InitializeUnderlyingThread ();
}
public ThreadWorker (IScheduler sched,
ThreadWorker[] others,
int workerPosition,
IProducerConsumerCollection<Task> sharedWorkQueue,
ThreadPriority priority,
EventWaitHandle handle)
{
this.others = others;
this.dDeque = new CyclicDeque<Task> ();
this.sched = sched;
this.sharedWorkQueue = sharedWorkQueue;
this.workerLength = others.Length;
this.workerPosition = workerPosition;
this.waitHandle = handle;
this.threadPriority = priority;
InitializeUnderlyingThread ();
}
static async Task RunProgram(IProducerConsumerCollection<CustomTask> collection = null)
{
var taskCollection = new BlockingCollection<CustomTask>();
if(collection != null)
taskCollection= new BlockingCollection<CustomTask>(collection);
var taskSource = Task.Run(() => TaskProducer(taskCollection));
Task[] processors = new Task[4];
for (int i = 1; i <= 4; i++)
{
string processorId = "Processor " + i;
processors[i - 1] = Task.Run(
() => TaskProcessor(taskCollection, processorId));
}
await taskSource;
await Task.WhenAll(processors);
}
public static void RemoveStressTest (IProducerConsumerCollection<int> coll, CheckOrderingType order)
{
ParallelTestHelper.Repeat (delegate {
const int count = 10;
const int threads = 5;
const int delta = 5;
for (int i = 0; i < (count + delta) * threads; i++)
coll.TryAdd (i);
bool state = true;
ParallelTestHelper.ParallelStressTest (coll, (q) => {
int t;
for (int i = 0; i < count; i++)
state &= coll.TryTake (out t);
}, threads);
Assert.IsTrue (state, "#1");
Assert.AreEqual (delta * threads, coll.Count, "#2");
string actual = string.Empty;
int temp;
while (coll.TryTake (out temp)) {
actual += temp.ToString ();;
}
IEnumerable<int> range = Enumerable.Range (order == CheckOrderingType.Reversed ? 0 : count * threads, delta * threads);
if (order == CheckOrderingType.Reversed)
range = range.Reverse ();
string expected = range.Aggregate (string.Empty, (acc, v) => acc + v);
if (order == CheckOrderingType.DontCare)
CollectionAssert.AreEquivalent (expected, actual, "#3");
else
Assert.AreEqual (expected, actual, "#3");
});
}
public IndexModificationBatch(params Action<TransactionalIndexWorker>[] work)
{
_batch = new ConcurrentQueue<Action<TransactionalIndexWorker>>(work);
}
protected override bool IsEmpty(IProducerConsumerCollection <int> pcc) => ((ConcurrentStack <int>)pcc).IsEmpty;
public FlowInputJunction(params IFlowConsumer <T>[] consumers)
{
Consumers = new ConcurrentQueue <IFlowConsumer <T> >(consumers);
}
// Almost same as above but with an added predicate and treating one item at a time.
// It's used by Scheduler Participate(...) method for special waiting case like
// Task.WaitAll(someTasks) or Task.WaitAny(someTasks)
// Predicate should be really fast and not blocking as it is called a good deal of time
// Also, the method skip tasks that are LongRunning to avoid blocking (Task are not LongRunning by default)
public static void ParticipativeWorkerMethod (Task self,
ManualResetEventSlim predicateEvt,
int millisecondsTimeout,
IProducerConsumerCollection<Task> sharedWorkQueue,
ThreadWorker[] others,
ManualResetEvent evt)
{
const int stage1 = 5, stage2 = 0;
int tries = 8;
WaitHandle[] handles = null;
Watch watch = Watch.StartNew ();
if (millisecondsTimeout == -1)
millisecondsTimeout = int.MaxValue;
while (!predicateEvt.IsSet && watch.ElapsedMilliseconds < millisecondsTimeout) {
Task value;
// If we are in fact a normal ThreadWorker, use our own deque
if (autoReference != null) {
while (autoReference.dDeque.PopBottom (out value) == PopResult.Succeed && value != null) {
evt.Set ();
if (CheckTaskFitness (self, value))
value.Execute (autoReference.ChildWorkAdder);
else {
sharedWorkQueue.TryAdd (value);
evt.Set ();
}
if (predicateEvt.IsSet || watch.ElapsedMilliseconds > millisecondsTimeout)
return;
}
}
int count = sharedWorkQueue.Count;
// Dequeue only one item as we have restriction
while (--count >= 0 && sharedWorkQueue.TryTake (out value) && value != null) {
evt.Set ();
if (CheckTaskFitness (self, value))
value.Execute (null);
else {
if (autoReference == null)
sharedWorkQueue.TryAdd (value);
else
autoReference.dDeque.PushBottom (value);
evt.Set ();
}
if (predicateEvt.IsSet || watch.ElapsedMilliseconds > millisecondsTimeout)
return;
}
// First check to see if we comply to predicate
if (predicateEvt.IsSet || watch.ElapsedMilliseconds > millisecondsTimeout)
return;
// Try to complete other work by stealing since our desired tasks may be in other worker
ThreadWorker other;
for (int i = 0; i < others.Length; i++) {
if ((other = others [i]) == autoReference || other == null)
continue;
if (other.dDeque.PopTop (out value) == PopResult.Succeed && value != null) {
evt.Set ();
if (CheckTaskFitness (self, value))
value.Execute (null);
else {
if (autoReference == null)
sharedWorkQueue.TryAdd (value);
else
autoReference.dDeque.PushBottom (value);
evt.Set ();
}
}
if (predicateEvt.IsSet || watch.ElapsedMilliseconds > millisecondsTimeout)
return;
}
if (--tries > stage1)
Thread.Yield ();
else if (tries >= stage2)
predicateEvt.Wait (ComputeTimeout (100, millisecondsTimeout, watch));
else {
if (tries == stage2 - 1)
handles = new [] { predicateEvt.WaitHandle, evt };
WaitHandle.WaitAny (handles, ComputeTimeout (1000, millisecondsTimeout, watch));
}
}
}
protected ProcessorBase(int maxThreads, IProducerConsumerCollection <T> baseCollection, CancellationToken cancelToken)
{
items = baseCollection;
MaxThreads = maxThreads;
CancelToken = cancelToken;
}
/// <summary>
/// Initializes the asynchronous producer/consumer collection.
/// </summary>
/// <param name="collection">The underlying collection to use to store
/// data.</param>
public AsyncQueue(IProducerConsumerCollection <T> collection)
{
_collection = collection ??
throw new ArgumentNullException(nameof(collection));
}
protected abstract bool IsEmpty(IProducerConsumerCollection <int> pcc);
public ResourceSearchStrategy(ApiVisibility apiVisibility, SearchRequest request, IProducerConsumerCollection <SearchResult> resultQueue)
: base(request, resultQueue)
{
this.treeNodeFactory = request.TreeNodeFactory;
this.apiVisibility = apiVisibility;
this.searchInside = true;
}
/// <summary>
/// Creates a new Transformer instance.
/// </summary>
public Transformer(IProducerConsumerCollection <TConsume> consume, Transform <TProduce, TConsume> transform, ITransformer dependentTransformer)
: this(consume, transform, dependentTransformer, dependentTransformer.ThreadCount)
{
}
/// <summary>
/// Creates a new Transformer instance.
/// </summary>
public Transformer(IProducerConsumerCollection <TConsume> consume, Transform <TProduce, TConsume> transform, ITransformer dependentTransformer, int threads)
: base(consume, dependentTransformer, threads)
{
_transform = transform;
}
/// <summary>
/// Creates a new Transformer instance.
/// </summary>
public Transformer(IProducerConsumerCollection <TConsume> consume, Transform <TProduce, TConsume> transform, int threads)
: this(consume, transform, null, threads)
{
}
/// <summary>
/// Creates a new Transformer instance.
/// </summary>
public Transformer(IProducerConsumerCollection <TConsume> consume, Transform <TProduce, TConsume> transform)
: this(consume, transform, null, DefaultThreadCount)
{
}
public TimedTokenProvider(T authConstant, int maxQueuedAuthTokens, IProducerConsumerCollection <TaskCompletionSource <T> > waitingCollection)
{
_authorizationConstant = authConstant;
_maxQueuedAuthTokens = maxQueuedAuthTokens;
_waiting = waitingCollection;
}
public CommandBus(IProducerConsumerCollection<Envelope<ICommand>> commandCollection)
{
if (commandCollection == null) throw new ArgumentNullException(nameof(commandCollection));
_commandCollection = commandCollection;
}
protected abstract bool TryPeek <T>(IProducerConsumerCollection <T> pcc, out T result);
/// <summary>
/// Initializes a new instance of <see cref="AsyncCollection{T}"/> with a specified <see cref="IProducerConsumerCollection{T}"/> as an underlying item storage.
/// </summary>
/// <param name="itemQueue">The collection to use as an underlying item storage. MUST NOT be accessed elsewhere.</param>
public AsyncCollection(IProducerConsumerCollection <T> itemQueue)
{
_itemQueue = itemQueue;
_queueBalance = _itemQueue.Count;
}
/// <summary>
/// Initializes an instance of the ObservableConcurrentCollection class with the specified
/// collection as the underlying data structure.
/// </summary>
public ObservableConcurrentCollection(IProducerConsumerCollection <T> collection) : base(collection)
{
_context = AsyncOperationManager.SynchronizationContext;
}
protected ProcessorBase(int maxThreads, IProducerConsumerCollection <T> baseCollection)
: this(maxThreads, baseCollection, CancellationToken.None)
{
}
/// <summary>Creates a new <see cref="Pool<T>"/> object.</summary>
/// <param name="store">The <see cref="IProducerConsumerCollection<T>"/> to use as a backing store to the pool.</param>
/// <exception cref="ArgumentNullException"><paramref name="store"/> was null.</exception>
public Pool(IProducerConsumerCollection <T> store)
: this(store, null, int.MaxValue)
{
}
public MemoryQueue(IProducerConsumerCollection <T> collection)
{
_Collection = collection;
}
/// <summary>Creates a new <see cref="Pool<T>"/> object.</summary>
/// <param name="store">The <see cref="IProducerConsumerCollection<T>"/> to use as a backing store to the pool.</param>
/// <param name="factory">The default factory to create new items as needed. It can be null, but in this case
/// the overload of <see cref="Get()"/> that doesn’t take a factory as a parameter will throw <see cref="InvalidOperationException"/>.</param>
/// <param name="max">A maximum size for the pool. If <see cref="int.MaxValue"/> is passed, the
/// maximum is ignored.</param>
/// <exception cref="ArgumentNullException"><paramref name="store"/> was null.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="max"/> was less than one.</exception>
public Pool(IProducerConsumerCollection <T> store, Func <T> factory, int max)
: this(store, factory, max, 0)
{
}
public BlockingCollection(IProducerConsumerCollection <T> underlyingColl)
: this(underlyingColl, -1)
{
}
// Almost same as above but with an added predicate and treating one item at a time.
// It's used by Scheduler Participate(...) method for special waiting case like
// Task.WaitAll(someTasks) or Task.WaitAny(someTasks)
// Predicate should be really fast and not blocking as it is called a good deal of time
// Also, the method skip tasks that are LongRunning to avoid blocking (Task are not LongRunning by default)
public static void WorkerMethod (Func<bool> predicate, IProducerConsumerCollection<Task> sharedWorkQueue,
ThreadWorker[] others, ManualResetEvent evt)
{
while (!predicate ()) {
Task value;
// If we are in fact a normal ThreadWorker, use our own deque
if (autoReference != null) {
while (autoReference.dDeque.PopBottom (out value) == PopResult.Succeed && value != null) {
evt.Set ();
if (CheckTaskFitness (value))
value.Execute (autoReference.ChildWorkAdder);
else {
autoReference.dDeque.PushBottom (value);
evt.Set ();
}
if (predicate ())
return;
}
}
// Dequeue only one item as we have restriction
while (sharedWorkQueue.TryTake (out value) && value != null) {
evt.Set ();
if (CheckTaskFitness (value))
value.Execute (null);
else {
sharedWorkQueue.TryAdd (value);
evt.Set ();
}
if (predicate ())
return;
}
// First check to see if we comply to predicate
if (predicate ())
return;
// Try to complete other work by stealing since our desired tasks may be in other worker
ThreadWorker other;
for (int i = 0; i < others.Length; i++) {
if ((other = others [i]) == null)
continue;
if (other.dDeque.PopTop (out value) == PopResult.Succeed && value != null) {
evt.Set ();
if (CheckTaskFitness (value))
value.Execute (null);
else {
sharedWorkQueue.TryAdd (value);
evt.Set ();
}
}
if (predicate ())
return;
}
Thread.Yield ();
}
}
private static void TestSendNotifyCore( IPEndPoint endPoint, CountdownEvent arrivalLatch, IProducerConsumerCollection<string> arrivedIds, int count )
{
using ( var clientTransportManager = new UdpClientTransportManager( new RpcClientConfiguration() { PreferIPv4 = true } ) )
using ( var connectTask = clientTransportManager.ConnectAsync( endPoint ) )
{
if ( !connectTask.Wait( Debugger.IsAttached ? Timeout.Infinite : TimeoutMilliseconds ) )
{
throw new TimeoutException();
}
using ( var clientTransport = connectTask.Result )
{
for ( int i = 0; i < count; i++ )
{
if ( arrivalLatch != null )
{
arrivalLatch.Reset();
}
var args = Enumerable.Repeat( 0, arrivalLatch.InitialCount ).Select( _ => Guid.NewGuid().ToString() ).ToArray();
var exceptions = new ConcurrentBag<Exception>();
if ( !Task.Factory.ContinueWhenAll(
args.Select(
arg =>
Task.Factory.StartNew(
() =>
{
var requestContext = clientTransport.GetClientRequestContext();
requestContext.SetNotification(
"Dummy",
( exception, completedSynchronously ) =>
{
if ( exception != null )
{
exceptions.Add( exception );
}
arrivalLatch.Signal();
}
);
requestContext.ArgumentsPacker.PackArrayHeader( 1 );
requestContext.ArgumentsPacker.Pack( arg );
return requestContext;
}
)
).ToArray(),
previouses =>
{
var contexts = previouses.Select( previous => previous.Result ).ToArray();
foreach ( var context in contexts )
{
clientTransport.Send( context );
}
}
).ContinueWith(
previous =>
{
if ( previous.IsFaulted )
{
throw previous.Exception;
}
// receive
if ( !arrivalLatch.Wait( Debugger.IsAttached ? Timeout.Infinite : TimeoutMilliseconds ) )
{
throw new TimeoutException( "Receive" );
}
if ( exceptions.Any() )
{
throw new AggregateException( exceptions );
}
}
).Wait( Debugger.IsAttached ? Timeout.Infinite : TimeoutMilliseconds ) )
{
throw new TimeoutException();
}
}
}
}
}
public ThreadWorker (IScheduler sched, ThreadWorker[] others, IProducerConsumerCollection<Task> sharedWorkQueue,
int maxStackSize, ThreadPriority priority)
: this (sched, others, sharedWorkQueue, true, maxStackSize, priority)
{
}
public PushQueue(IProducerConsumerCollection <T> source, int capacity) : this(
new BlockingCollection <T>(source, capacity), true)
{
}
public static void RemoveStressTest(IProducerConsumerCollection <int> coll, CheckOrderingType order)
{
ParallelTestHelper.Repeat(delegate {
const int count = 10;
const int threads = 5;
const int delta = 5;
for (int i = 0; i < (count + delta) * threads; i++)
{
while (!coll.TryAdd(i))
{
;
}
}
bool state = true;
Assert.AreEqual((count + delta) * threads, coll.Count, "#0");
ParallelTestHelper.ParallelStressTest(coll, (q) => {
bool s = true;
int t;
for (int i = 0; i < count; i++)
{
s &= coll.TryTake(out t);
// try again in case it was a transient failure
if (!s && coll.TryTake(out t))
{
s = true;
}
}
if (!s)
{
state = false;
}
}, threads);
Assert.IsTrue(state, "#1");
Assert.AreEqual(delta * threads, coll.Count, "#2");
string actual = string.Empty;
int temp;
while (coll.TryTake(out temp))
{
actual += temp.ToString();;
}
IEnumerable <int> range = Enumerable.Range(order == CheckOrderingType.Reversed ? 0 : count * threads, delta * threads);
if (order == CheckOrderingType.Reversed)
{
range = range.Reverse();
}
string expected = range.Aggregate(string.Empty, (acc, v) => acc + v);
if (order == CheckOrderingType.DontCare)
{
CollectionAssert.AreEquivalent(expected, actual, "#3");
}
else
{
Assert.AreEqual(expected, actual, "#3");
}
}, 1000);
}
/// <summary>
/// Custom constructor using JobExecution.
/// </summary>
/// <param name="original"></param>
public JobExecution(JobExecution original)
{
JobParameters = original.JobParameters;
JobInstance = original.JobInstance;
_stepExecutions = original._stepExecutions;
_status = original.Status;
StartTime = original.StartTime;
CreateTime = original.CreateTime;
EndTime = original.EndTime;
LastUpdated = original.LastUpdated;
_exitStatus = original.ExitStatus;
_executionContext = original.ExecutionContext;
_failureExceptions = original.FailureExceptions;
_jobConfigurationName = original.JobConfigurationName;
Id = original.Id;
Version = original.Version;
}
// Almost same as above but with an added predicate and treating one item at a time.
// It's used by Scheduler Participate(...) method for special waiting case like
// Task.WaitAll(someTasks) or Task.WaitAny(someTasks)
// Predicate should be really fast and not blocking as it is called a good deal of time
// Also, the method skip tasks that are LongRunning to avoid blocking (Task are not LongRunning by default)
public static void ParticipativeWorkerMethod (Task self,
ManualResetEventSlim predicateEvt,
int millisecondsTimeout,
IProducerConsumerCollection<Task> sharedWorkQueue,
ThreadWorker[] others,
ManualResetEvent evt,
Func<Task, Task, bool> checkTaskFitness)
{
const int stage1 = 5, stage2 = 0;
int tries = 50;
WaitHandle[] handles = null;
Watch watch = Watch.StartNew ();
if (millisecondsTimeout == -1)
millisecondsTimeout = int.MaxValue;
bool aggressive = false;
bool hasAutoReference = autoReference != null;
Action<Task> adder = null;
while (!predicateEvt.IsSet && watch.ElapsedMilliseconds < millisecondsTimeout && !self.IsCompleted) {
// We try to execute the self task as it may be the simplest way to unlock
// the situation
if (self.Status == TaskStatus.WaitingToRun) {
self.Execute (hasAutoReference ? autoReference.adder : (Action<Task>)null);
if (predicateEvt.IsSet || watch.ElapsedMilliseconds > millisecondsTimeout)
return;
}
Task value;
// If we are in fact a normal ThreadWorker, use our own deque
if (hasAutoReference) {
var enumerable = autoReference.dDeque.GetEnumerable ();
if (adder == null)
adder = hasAutoReference ? autoReference.adder : (Action<Task>)null;
if (enumerable != null) {
foreach (var t in enumerable) {
if (t == null)
continue;
if (checkTaskFitness (self, t))
t.Execute (adder);
if (predicateEvt.IsSet || watch.ElapsedMilliseconds > millisecondsTimeout)
return;
}
}
}
int count = sharedWorkQueue.Count;
// Dequeue only one item as we have restriction
while (--count >= 0 && sharedWorkQueue.TryTake (out value) && value != null) {
evt.Set ();
if (checkTaskFitness (self, value) || aggressive)
value.Execute (null);
else {
if (autoReference == null)
sharedWorkQueue.TryAdd (value);
else
autoReference.dDeque.PushBottom (value);
evt.Set ();
}
if (predicateEvt.IsSet || watch.ElapsedMilliseconds > millisecondsTimeout)
return;
}
// First check to see if we comply to predicate
if (predicateEvt.IsSet || watch.ElapsedMilliseconds > millisecondsTimeout)
return;
// Try to complete other work by stealing since our desired tasks may be in other worker
ThreadWorker other;
for (int i = 0; i < others.Length; i++) {
if ((other = others [i]) == autoReference || other == null)
continue;
if (other.dDeque.PopTop (out value) == PopResult.Succeed && value != null) {
evt.Set ();
if (checkTaskFitness (self, value) || aggressive)
value.Execute (null);
else {
if (autoReference == null)
sharedWorkQueue.TryAdd (value);
else
autoReference.dDeque.PushBottom (value);
evt.Set ();
}
}
if (predicateEvt.IsSet || watch.ElapsedMilliseconds > millisecondsTimeout)
return;
}
/* Waiting is split in 4 phases
* - until stage 1 we simply yield the thread to let others add data
* - between stage 1 and stage2 we use ManualResetEventSlim light waiting mechanism
* - after stage2 we fall back to the heavier WaitHandle waiting mechanism
* - if really the situation isn't evolving after a couple of sleep, we disable
* task fitness check altogether
*/
if (--tries > stage1)
Thread.Yield ();
else if (tries >= stage2)
predicateEvt.Wait (ComputeTimeout (5, millisecondsTimeout, watch));
else {
if (tries == stage2 - 1)
handles = new [] { predicateEvt.WaitHandle, evt };
System.Threading.WaitHandle.WaitAny (handles, ComputeTimeout (1000, millisecondsTimeout, watch));
if (tries == stage2 - 10)
aggressive = true;
}
}
}
public PushQueue(IProducerConsumerCollection <T> source) : this(new BlockingCollection <T>(source),
true)
{
}
public RateLimiter(IProducerConsumerCollection<Task> Queue)
{
}
public EventBus(IProducerConsumerCollection<Envelope<IEvent>> eventCollection)
{
if (eventCollection == null) throw new ArgumentNullException(nameof(eventCollection));
_eventCollection = eventCollection;
}
public static IProducerConsumerCollection <T> ToConsumerOnlyCollection <T>(
this IProducerConsumerCollection <T> collection)
{
return((IProducerConsumerCollection <T>) new ProducerConsumerCollectionExtensions.ProduceOrConsumeOnlyCollection <T>(collection, false));
}
public WorkQueue(IProducerConsumerCollection<WorkTask> workTaskCollection)
{
workQueue = new BlockingCollection<WorkTask>(workTaskCollection);
}
protected override bool TryPeek <T>(IProducerConsumerCollection <T> pcc, out T result) => ((ConcurrentStack <T>)pcc).TryPeek(out result);
public BlockingCollection(IProducerConsumerCollection <T> collection, int boundedCapacity)
{
this.underlyingColl = collection;
this.upperBound = boundedCapacity;
this.isComplete = new AtomicBoolean();
}
protected AbstractSearchStrategy(Language language, ApiVisibility apiVisibility, IProducerConsumerCollection <SearchResult> resultQueue, params string[] terms)
{
this.language = language;
this.apiVisibility = apiVisibility;
this.resultQueue = resultQueue;
if (terms.Length == 1 && terms[0].Length > 2)
{
string search = terms[0];
if (search.StartsWith("/", StringComparison.Ordinal) && search.Length > 4)
{
var regexString = search.Substring(1, search.Length - 1);
fullNameSearch = search.Contains("\\.");
omitGenerics = !search.Contains("<");
if (regexString.EndsWith("/", StringComparison.Ordinal))
{
regexString = regexString.Substring(0, regexString.Length - 1);
}
regex = SafeNewRegex(regexString);
}
else
{
fullNameSearch = search.Contains(".");
omitGenerics = !search.Contains("<");
}
}
searchTerm = terms;
}
/// <summary>Creates a new <see cref="Pool<T>"/> object.</summary>
/// <param name="store">The <see cref="IProducerConsumerCollection<T>"/> to use as a backing store to the pool.</param>
/// <param name="factory">The default factory to create new items as needed. It can be null, but in this case
/// the overload of <see cref="Get()"/> that doesn’t take a factory as a parameter will throw <see cref="InvalidOperationException"/>.</param>
/// <exception cref="ArgumentNullException"><paramref name="store"/> was null.</exception>
public Pool(IProducerConsumerCollection <T> store, Func <T> factory)
: this(store, factory, int.MaxValue)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="InMemoryCommandQueue"/> class.
/// </summary>
/// <param name="collection">The collection to use as the underlying data store.</param>
public InMemoryCommandQueue(IProducerConsumerCollection <ICommand> collection)
{
this.queue = new BlockingCollection <ICommand>(collection);
}
// Almost same as above but with an added predicate and treating one item at a time.
// It's used by Scheduler Participate(...) method for special waiting case like
// Task.WaitAll(someTasks) or Task.WaitAny(someTasks)
// Predicate should be really fast and not blocking as it is called a good deal of time
// Also, the method skip tasks that are LongRunning to avoid blocking (Task are not LongRunning by default)
public static void WorkerMethod (Func<bool> predicate, IProducerConsumerCollection<Task> sharedWorkQueue,
ThreadWorker[] others)
{
while (!predicate ()) {
Task value;
// Dequeue only one item as we have restriction
if (sharedWorkQueue.TryTake (out value)) {
if (value != null) {
if (CheckTaskFitness (value))
value.Execute (null);
else
sharedWorkQueue.TryAdd (value);
}
}
// First check to see if we comply to predicate
if (predicate ()) {
return;
}
// Try to complete other work by stealing since our desired tasks may be in other worker
ThreadWorker other;
for (int i = 0; i < others.Length; i++) {
if ((other = others [i]) == null)
continue;
if (other.dDeque.PopTop (out value) == PopResult.Succeed) {
if (value != null) {
if (CheckTaskFitness (value))
value.Execute (null);
else
sharedWorkQueue.TryAdd (value);
}
}
if (predicate ()) {
return;
}
}
}
}
/// <summary>Creates a new <see cref="Pool<T>"/> object.</summary>
/// <param name="store">The <see cref="IProducerConsumerCollection<T>"/> to use as a backing store to the pool.</param>
/// <param name="max">A maximum size for the pool. If <see cref="int.MaxValue"/> is passed, the
/// maximum is ignored.</param>
/// <exception cref="ArgumentNullException"><paramref name="store"/> was null.</exception>
public Pool(IProducerConsumerCollection <T> store, int max)
: this(store, null, max)
{
}
private static void TestSendNotifyCore( IPEndPoint endPoint, CountdownEvent arrivalLatch, IProducerConsumerCollection<string> arrivedIds, int count )
{
using ( var udpClient = new UdpClient( AddressFamily.InterNetwork ) )
using ( var concurrencyLatch = new CountdownEvent( arrivalLatch.InitialCount ) )
{
udpClient.Connect( endPoint );
for ( int i = 0; i < count; i++ )
{
if ( concurrencyLatch != null )
{
concurrencyLatch.Reset();
}
arrivalLatch.Reset();
// Clear ids.
string dummy;
while ( arrivedIds.TryTake( out dummy ) ) { }
var ids = Enumerable.Repeat( 0, concurrencyLatch == null ? 1 : concurrencyLatch.InitialCount ).Select( _ => Guid.NewGuid().ToString() ).ToArray();
if ( !Task.WaitAll(
ids.Select(
id =>
Task.Factory.StartNew(
_ =>
{
using ( var buffer = new MemoryStream() )
{
using ( var packer = Packer.Create( buffer, false ) )
{
PackRequest( packer, id );
}
buffer.Position = 0;
if ( concurrencyLatch != null )
{
concurrencyLatch.Signal();
if ( !concurrencyLatch.Wait( Debugger.IsAttached ? Timeout.Infinite : TimeoutMilliseconds ) )
{
throw new TimeoutException();
}
}
// send
udpClient.Send( buffer.ToArray(), ( int )buffer.Length );
}
},
id
)
).ToArray(),
Debugger.IsAttached ? Timeout.Infinite : TimeoutMilliseconds
) )
{
throw new TimeoutException();
}
// wait
if ( !arrivalLatch.Wait( Debugger.IsAttached ? Timeout.Infinite : TimeoutMilliseconds ) )
{
throw new TimeoutException();
}
Assert.That( arrivedIds, Is.EquivalentTo( ids ) );
}
}
}
public BlockingCollection(IProducerConsumerCollection <T> collection)
: this(collection, -1)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="InMemoryCommandQueue"/> class.
/// </summary>
/// <param name="collection">The collection to use as the underlying data store.</param>
public InMemoryCommandQueue(IProducerConsumerCollection<ICommand> collection)
{
this.queue = new BlockingCollection<ICommand>(collection);
}
