public void PwmProc()
{
// totalCycle = (1/n)*1000 = Total MS for the full cycle
// onCycle = totalCycle * (DutyCycle / 100)
// offCycle = totalCycle - onCycle;
SpinWait sp = new SpinWait();
Stopwatch sw = new Stopwatch();
int totalCycleTicks = (int)((1f / Frequency) * Stopwatch.Frequency);
int onTicks = (int)Math.Round(totalCycleTicks * (DutyCycle / 100f));
int offTicks = totalCycleTicks - onTicks;
Debug.WriteLine("On Ticks: " + onTicks);
while (IsRunning)
{
/**** ON ****/
// Turn the pin on for the duty cycle
Pin(true);
// Let the pin stay high until we stop or
sw.Reset();
sp.Reset();
sw.Start();
while (sw.ElapsedTicks < onTicks)
{
;
}
//sp.SpinOnce();
//Debug.WriteLine("Total Spin On: " + sw.ElapsedTicks + " and needed " + onTicks);
/**** OFF ****/
// Turn the pin off for the rest period
Pin(false);
sw.Reset();
sp.Reset();
sw.Start();
while (sw.ElapsedTicks < offTicks)
{
;
}
//sp.SpinOnce();
//Debug.WriteLine("Total Spin Off: " + sw.ElapsedTicks + " and needed " + offTicks);
}
// Turn off the PIN when we're done
Pin(false);
}
void TryDoWork(int index)
{
Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} started do work {index}");
Interlocked.Decrement(ref _notStartedThreadsCount);
var spinWait = new SpinWait();
while (!_isDisposed)
{
bool isDeququed = _workItems.TryDequeue(out var callback);
if (isDeququed)
{
callback(null);
continue;
}
_mre.Reset();
if (spinWait.NextSpinWillYield)
{
Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} WAIT ONE");
_mre.WaitOne();
spinWait.Reset();
}
spinWait.SpinOnce();
}
Interlocked.Increment(ref _notStartedThreadsCount);
Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} finished do work {index}");
}
private void DispatchThreadMethod()
{
var snipWait = new SpinWait();
while (!this.StopDispatch)
{
if (this.EventQueue.Length == 0)
{
snipWait.SpinOnce();
}
else
{
snipWait.Reset();
IEvent @event = this.EventQueue.Dequeue();
var pars = new Object[] { @event };
var subeventQueue = new PriorityQueue <EventHandleInfo>();
if (this.RegisterInfo.TryGetValue(@event.GetType(), out EventRegisterInfo registered))
{
foreach (EventHandleInfo handle in registered.EventHandleList)
{
subeventQueue.Add(handle, (Int32)handle.Priority);
}
while (subeventQueue.Length != 0)
{
EventHandleInfo handle = subeventQueue.Dequeue();
ThreadPool.QueueUserWorkItem(state => handle.Method.Invoke(handle.Instance, pars));
}
}
}
}
}
public long Run(ThroughputSessionContext sessionContext)
{
_eventHandler.Reset(_iterations - 1);
_consumer.Start();
sessionContext.Start();
var spinWait = new SpinWait();
for (long i = 0; i < _iterations; i++)
{
var data = new PerfEvent {
Value = i
};
while (_queue.Count == _bufferSize)
{
spinWait.SpinOnce();
}
_queue.Enqueue(data);
spinWait.Reset();
}
_eventHandler.WaitForSequence();
sessionContext.Stop();
_consumer.Stop();
sessionContext.SetBatchData(_eventHandler.BatchesProcessed, _iterations);
PerfTestUtil.FailIfNot(_expectedResult, _eventHandler.Value, $"Handler should have processed {_expectedResult} events, but was: {_eventHandler.Value}");
return(_iterations);
}
public void Start()
{
var started = new ManualResetEventSlim();
_running = true;
_task = Task.Run(() =>
{
started.Set();
var spinWait = new SpinWait();
while (true)
{
PerfEvent perfEvent;
while (!_queue.TryDequeue(out perfEvent))
{
if (!_running)
{
return;
}
spinWait.SpinOnce();
}
spinWait.Reset();
_eventHandler.OnBatchStart(1);
_eventHandler.OnEvent(perfEvent, perfEvent.Value, true);
}
});
started.Wait();
}
public void Start()
{
_rwh = ThreadPool.UnsafeRegisterWaitForSingleObject(_eh, OnWait, null, 100, false);
_isRunning = true;
_task = Task.Run(async() => {
var sw = new SpinWait();
while (_isRunning)
{
var currentValue = _df.Buffer.VolatileReadInt64(0);
if (currentValue > _lastSeenValue)
{
// nore that on next iteration we will see only the last value
_action.Invoke(_lastSeenValue, currentValue);
_lastSeenValue = currentValue;
}
else
{
if (!sw.NextSpinWillYield)
{
sw.SpinOnce();
}
else
{
sw.Reset();
await _sem.WaitAsync(100);
}
}
}
});
}
private void PerformCleanupImpl()
{
SpinWait wait = new SpinWait();
while (true)
{
CleanupSourceState state = this.State;
CleanupSourceState state2 = (state | CleanupSourceState.Cleaning) & ~CleanupSourceState.CleanupNeeded;
CleanupSourceState state3 = (CleanupSourceState)Interlocked.CompareExchange(ref this.state, (int)state2, (int)state);
if (state == state3)
{
break;
}
wait.SpinOnce();
}
this.OnPerformCleanup();
wait.Reset();
while (true)
{
CleanupSourceState state4 = this.State;
CleanupSourceState state5 = state4 & ~CleanupSourceState.Cleaning;
CleanupSourceState state6 = (CleanupSourceState)Interlocked.CompareExchange(ref this.state, (int)state5, (int)state4);
if (state4 == state6)
{
break;
}
wait.SpinOnce();
}
}
private void WriteToAppenders()
{
var spinWait = new SpinWait();
var stringBuffer = new StringBuffer(OutputBufferSize);
var destination = new byte[OutputBufferSize];
var flush = false;
while (_isRunning || !_queue.IsEmpty)
{
if (TryToProcessQueue(stringBuffer, destination))
{
spinWait.Reset();
flush = true;
continue;
}
if (flush && spinWait.NextSpinWillYield && Config.FlushAppenders)
{
FlushAppenders();
flush = false;
}
else
{
spinWait.SpinOnce();
}
}
FlushAppenders();
}
void TryDoWork(int index)
{
_countEvt.Signal();
Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} started do work {index}");
var spinWait = new SpinWait();
while (!_isDisposed)
{
bool isDeququed = _workItems.TryDequeue(out var callback);
if (isDeququed)
{
callback(null);
continue;
}
_mre.Reset();
if (spinWait.NextSpinWillYield)
{
Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} WAIT ONE");
_mre.WaitOne();
spinWait.Reset();
}
spinWait.SpinOnce();
}
Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} finished do work {index}");
_barrier.SignalAndWait();
}
/// <summary>
/// Adds the item to the AsyncCollection.
/// </summary>
/// <param name="item">The item to be added to the collection. The value can be a null reference.</param>
/// <exception cref="T:System.InvalidOperationException">The AsyncCollection has been marked as complete with regards to additions.</exception>
/// <exception cref="T:System.ObjectDisposedException">The AsyncCollection has been disposed.</exception>
public void Add(T item)
{
CheckDisposed();
SpinWait spinner = new SpinWait();
while (true)
{
int observedAdders = currentAdders;
if ((observedAdders & COMPLETE_ADDING_ON_MASK) != 0)
{
spinner.Reset();
while (currentAdders != COMPLETE_ADDING_ON_MASK)
{
spinner.SpinOnce();
}
throw new InvalidOperationException("Adding is completed");
}
if (Interlocked.CompareExchange(ref currentAdders, observedAdders + 1, observedAdders) == observedAdders)
{
break;
}
spinner.SpinOnce();
}
queue.Enqueue(item);
semaphore.Release();
Interlocked.Decrement(ref currentAdders);
}
public void Operate(long busy)
{
_FPS.Update();
if (_Busy <= busy && _FPS.Value > _LowPower)
{
_SpinWait.SpinOnce();
_SpinCount++;
}
else
{
_SpinWait.Reset();
_WorkCount++;
}
if (_TimeCount.Second > _Sample)
{
Power = _WorkCount / (_WorkCount + _SpinCount);
_WorkCount = 0;
_SpinCount = 0;
_TimeCount.Reset();
}
_Busy = busy;
}
public long Run(ThroughputSessionContext sessionContext)
{
_eventHandler.Reset(_iterations - 1);
_consumer.Start();
sessionContext.Start();
var spinWait = new SpinWait();
for (long i = 0; i < _iterations; i++)
{
var data = new PerfEvent {
Value = i
};
while (!_channel.Writer.TryWrite(data))
{
spinWait.SpinOnce();
}
spinWait.Reset();
}
_eventHandler.Latch.WaitOne();
sessionContext.Stop();
_consumer.Stop();
sessionContext.SetBatchData(_eventHandler.BatchesProcessedCount.Value, _iterations);
PerfTestUtil.FailIfNot(_expectedResult, _eventHandler.Value, $"Handler should have processed {_expectedResult} events, but was: {_eventHandler.Value}");
return(_iterations);
}
protected virtual void _loop_thread_func(object obj)
{
// Use a spin wait loop to get higher timing accurancy
SpinWait spin_wait = new SpinWait();
long next_wait = _stopwatch.ElapsedMilliseconds;
long now = next_wait;
while (_keep_going)
{
_run_timestep(now);
now = _stopwatch.ElapsedMilliseconds;
do
{
next_wait += _update_period;
}while (next_wait <= now);
spin_wait.Reset();
while ((now = _stopwatch.ElapsedMilliseconds) < next_wait)
{
spin_wait.SpinOnce();
}
}
}
private void StartSchedule()
{
Task.Run(() =>
{
SpinWait sw = new SpinWait();
while (!this.cancellationTokenSource.Token.IsCancellationRequested &&
(!this.controllerQueue.IsCompleted || Interlocked.Read(ref this.activeControllerItemCount) != 0))
{
this.FillInQueue(
this.activeControllerItems,
this.controllerQueue,
this.cancellationTokenSource.Token);
if (!this.cancellationTokenSource.Token.IsCancellationRequested)
{
// If we don't have the requested amount of active tasks
// running, get a task item from any active transfer item
// that has work available.
if (!this.DoWorkFrom(this.activeControllerItems))
{
sw.SpinOnce();
}
else
{
sw.Reset();
continue;
}
}
}
});
}
/// <summary>
/// Marks the <see cref="T:System.Collections.Concurrent.BlockingCollection{T}"/> instances
/// as not accepting any more additions.
/// </summary>
/// <remarks>
/// After a collection has been marked as complete for adding, adding to the collection is not permitted
/// and attempts to remove from the collection will not wait when the collection is empty.
/// </remarks>
/// <exception cref="T:System.ObjectDisposedException">The <see
/// cref="T:System.Collections.Concurrent.BlockingCollection{T}"/> has been disposed.</exception>
public void CompleteAdding()
{
CheckDisposed();
if (IsAddingCompleted)
{
return;
}
SpinWait spinner = new SpinWait();
while (true)
{
int observedAdders = m_currentAdders;
if ((observedAdders & COMPLETE_ADDING_ON_MASK) != 0)
{
spinner.Reset();
// If there is another COmpleteAdding in progress waiting the current adders, then spin until it finishes
while (m_currentAdders != COMPLETE_ADDING_ON_MASK)
{
spinner.SpinOnce();
}
return;
}
if (Interlocked.CompareExchange(ref m_currentAdders, observedAdders | COMPLETE_ADDING_ON_MASK, observedAdders) == observedAdders)
{
spinner.Reset();
while (m_currentAdders != COMPLETE_ADDING_ON_MASK)
{
spinner.SpinOnce();
}
if (Count == 0)
{
CancelWaitingConsumers();
}
// We should always wake waiting producers, and have them throw exceptions as
// Add&CompleteAdding should not be used concurrently.
CancelWaitingProducers();
return;
}
spinner.SpinOnce();
}
}
public void TickLoop()
{
logger.Info("Network loop started.");
Work work;
while (true)
{
try
{
if (Manager.Terminating)
{
break;
}
loopLock.Reset();
while (pendings.TryDequeue(out work))
{
try
{
if (Manager.Terminating)
{
return;
}
if (work.Item1.Stage == ProtocalStage.Disconnected)
{
Client client;
var accId = work.Item1?.Account?.AccountId;
if (accId != null)
{
Manager.Clients.TryRemove(accId, out client);
}
continue;
}
try
{
work.Item1.ProcessPacket(work.Item2);
}
catch (Exception ex)
{
logger.Error(ex);
}
}
catch (Exception ex)
{
logger.Error(ex);
}
}
while (pendings.Count == 0 && !Manager.Terminating)
{
loopLock.SpinOnce();
}
}
catch (Exception ex)
{
logger.Error(ex);
}
}
logger.Info("Network loop stopped.");
}
public void TickLoop()
{
log.Info("Network loop started.");
Work work;
do
{
try
{
if (Manager.Terminating)
{
break;
}
loopLock.Reset();
while (pendings.TryDequeue(out work))
{
try
{
if (Manager.Terminating)
{
return;
}
if (work.Item1.State == ProtocolState.Disconnected)
{
Client client;
Manager.Clients.TryRemove(work.Item1.Id.ToString(), out client);
continue;
}
try
{
work.Item1.ProcessMessage(work.Item2);
}
catch (Exception ex)
{
log.Error(ex);
}
}
catch (Exception ex)
{
log.Error(ex);
}
}
while (pendings.Count == 0 && !Manager.Terminating)
{
loopLock.SpinOnce();
}
}
catch (Exception ex)
{
log.Error(ex);
}
} while (true);
log.Info("Network loop stopped.");
}
public void TickLoop()
{
if (CheckConfig.IsDebugOn())
{
Console.WriteLine("Procces: Starting network loop.");
}
Work work;
while (true)
{
if (Manager.Terminating)
{
break;
}
loopLock.Reset();
while (pendings.TryDequeue(out work))
{
if (Manager.Terminating)
{
return;
}
try
{
if (work.Item1.Stage == ProtocalStage.Disconnected)
{
Client client;
var accId = work.Item1?.Account?.AccountId;
if (accId != null)
{
Manager.Clients.TryRemove(accId, out client);
}
continue;
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
try
{
Packet packet = Packet.Packets[work.Item2].CreateInstance();
packet.Read(work.Item1, work.Item3, 0, work.Item3.Length);
work.Item1.ProcessPacket(packet);
}
catch { }
}
while (pendings.Count == 0 && !Manager.Terminating)
{
loopLock.SpinOnce();
}
}
if (CheckConfig.IsDebugOn())
{
Console.WriteLine("Procces: Stopping network loop.");
}
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
private void InternalDispose()
{
if (Interlocked.CompareExchange(ref isClosed, 1, 0) == 0)
{
//closing = true;
if (LOG.IsDebugEnabled)
{
LOG.DebugFormat("Closing client for session: 0x{0:X}", SessionId);
}
try
{
SubmitRequest(new RequestHeader {
Type = (int)OpCode.CloseSession
}, null, null, null);
SpinWait spin = new SpinWait();
DateTime timeoutAt = DateTime.UtcNow.Add(SessionTimeout);
while (!producer.IsConnectionClosedByServer)
{
spin.SpinOnce();
if (spin.Count > MaximumSpin)
{
if (timeoutAt <= DateTime.UtcNow)
{
throw new TimeoutException(
string.Format("Timed out in Dispose() while closing session: 0x{0:X}", SessionId));
}
spin.Reset();
}
}
}
catch (ThreadInterruptedException)
{
// ignore, close the send/event threads
}
catch (Exception ex)
{
LOG.WarnFormat("Error disposing {0} : {1}", this.GetType().FullName, ex.Message);
}
finally
{
//fixed by Yang Li: 当从客户端传来的connectstring是个非法格式的ip地址时，producer和consumer都为null：
//producer.Dispose();
//consumer.Dispose();
if (producer != null)
{
producer.Dispose();
}
if (consumer != null)
{
consumer.Dispose();
}
}
}
}
private object ExchangeWithSentinel(object[] arr, int i, object sentinel, SpinWait spinWait)
{
spinWait.Reset();
while(true) {
var vi = Interlocked.Exchange(ref arr[i], sentinel);
if(vi != sentinel) return vi;
spinWait.SpinOnce();
}
}
private void StartDataExtrapolation(int desiredEventsCount)
{
desiredEventsCount -= _allEvents.Count;
if (desiredEventsCount <= 0)
{
_extrapolationCompleted = true;
return;
}
var thread = new Thread(() =>
{
var random = new Random();
var spinWait = new SpinWait();
int totalEventsGenerated = 0;
long lastEventTime = _allEvents[_allEvents.Count - 1].Ticks;
Console.WriteLine("\nExtrapolation started...");
while (totalEventsGenerated < desiredEventsCount)
{
var baseIndex = random.Next(0, _allEvents.Count);
if (_allEvents[baseIndex].EventType == EventType.Stop)
{
baseIndex++;
}
if (baseIndex >= _allEvents.Count)
{
continue;
}
long diff = Math.Abs(_allEvents[baseIndex].Ticks - lastEventTime) + 100;
for (var i = baseIndex; i < _allEvents.Count; i++)
{
lastEventTime = diff + _allEvents[i].Ticks;
_queue.Enqueue(new RealEvent(_allEvents[i].EventType, lastEventTime));
totalEventsGenerated++;
}
_eventsBatchGenerated.Set();
while (_queue.Count > 1000)
{
spinWait.SpinOnce();
}
spinWait.Reset();
}
_extrapolationCompleted = true;
});
thread.Start();
}
/// <summary>
/// Marks the AsyncCollection instance as not accepting any more additions.
/// </summary>
/// <remarks>
/// After a collection has been marked as complete for adding, adding to the collection is not permitted
/// and attempts to remove from the collection will not wait when the collection is empty.
/// </remarks>
/// <exception cref="T:System.ObjectDisposedException">The AsyncCollection has been disposed.</exception>
public void CompleteAdding()
{
CheckDisposed();
if (IsAddingCompleted)
{
return;
}
SpinWait spinner = new SpinWait();
while (true)
{
int observedAdders = currentAdders;
if ((observedAdders & COMPLETE_ADDING_ON_MASK) != 0)
{
spinner.Reset();
while (currentAdders != COMPLETE_ADDING_ON_MASK)
{
spinner.SpinOnce();
}
return;
}
if (Interlocked.CompareExchange(ref currentAdders, observedAdders | COMPLETE_ADDING_ON_MASK, observedAdders) == observedAdders)
{
spinner.Reset();
while (currentAdders != COMPLETE_ADDING_ON_MASK)
{
spinner.SpinOnce();
}
if (queue.Count == 0)
{
doneCancellationToken.Cancel();
}
return;
}
spinner.SpinOnce();
}
}
protected void OnRunning()
{
SpinWait wait = new SpinWait();
while (true)
{
int state = m_state;
if (state == State.ScheduledToRun && Interlocked.CompareExchange(ref m_state, State.Running, State.ScheduledToRun) == State.ScheduledToRun)
{
break;
}
if (state == State.ScheduledToRunAfterDelay && Interlocked.CompareExchange(ref m_state, State.Running, State.ScheduledToRunAfterDelay) == State.ScheduledToRunAfterDelay)
{
break;
}
wait.SpinOnce();
}
wait.Reset();
m_runAgain = false;
m_runAgainAfterDelay = -1;
Thread.MemoryBarrier();
m_args.StartDisposalCallSuccessful = m_startDisposalCallSuccessful;
bool failedRun = !m_callback.TryInvoke(m_args);
if (m_args.ShouldDispose || failedRun)
{
InternalDispose_FromWorkerThread();
Interlocked.Exchange(ref m_state, State.Disposed);
return;
}
Interlocked.Exchange(ref m_state, State.AfterRunning); //Notifies that the RunAgain and RunAgainAfterDelay variables are going to be used
// to make decisions. Therefore, if setting these variables after this point, modifying the state machine will be
// necessary
if (m_runAgain)
{
Interlocked.Exchange(ref m_state, State.ScheduledToRun);
InternalStart_FromWorkerThread();
}
else if (m_runAgainAfterDelay >= 0)
{
InternalStart_FromWorkerThread(m_runAgainAfterDelay);
Interlocked.Exchange(ref m_state, State.ScheduledToRunAfterDelay);
}
else
{
InternalDoNothing_FromWorkerThread();
Interlocked.Exchange(ref m_state, State.NotRunning);
}
}
private static void runTask(object obj)
{
if (obj is not TaskState state)
{
throw new InvalidOperationException($"Task {obj} is not a {typeof(TaskState)}");
}
try
{
Thread.CurrentThread.Priority = ThreadPriority.AboveNormal;
var spin = new SpinWait();
var sleep0Threshold = 10;
var sleepCount = 0;
while (false == state.Token.IsCancellationRequested)
{
Volatile.Write(ref state.ProcessorId, Thread.GetCurrentProcessorId());
var hasRanBatch = !state.Batches.IsEmpty;
while (state.Batches.TryTake(out var queued))
{
queued.Batch.Execute(queued.Index, queued.MaxUseIndex, state.TaskIndex, state.TaskCount);
if (Interlocked.Increment(ref state.Results[queued.BatchId].SuccessfulWrite) == state.Results[queued.BatchId].MaxIndex &&
queued.Batch is IBatchOnComplete onComplete)
{
onComplete.OnCompleted(null);
}
}
if (state.IsPerformanceCritical)
{
if (sleepCount++ > sleep0Threshold)
{
Thread.Sleep(0);
sleepCount = 0;
}
continue;
}
spin.SpinOnce(30);
if (hasRanBatch)
{
spin.Reset();
sleepCount = 0;
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public void SpinOnce()
{
if (_spinWait.NextSpinWillYield)
{
Thread.Sleep(0);
_spinWait.Reset();
}
else
{
_spinWait.SpinOnce();
}
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
private void InternalDispose()
{
if (Interlocked.CompareExchange(ref isClosed, 1, 0) == 0)
{
//closing = true;
if (LOG.IsDebugEnabled)
{
LOG.DebugFormat("Closing client for session: 0x{0:X}", SessionId);
}
try
{
ReplyHeader r = SubmitRequest(new RequestHeader {
Type = (int)OpCode.CloseSession
}, null, null, null);
// @@@ Fixed a shutdown deadlock bug
// @@@ Repro steps.
// @@@ 1. Run ZooKeeper server
// @@@ 2. Client (ZooKeeperNet) connect to the server and issue some commands
// @@@ 3. Kill ZooKeeper server
// @@@ 4. Close (exit) ZooKeeper client
// @@@
// @@@ Added error code checking in ReplayHeader to prevent the infinite spin waiting.
// @@@ TODO: It'd be a good idea add some waiting timeout inside the spin waiting loop.
if (r.Err == 0 /* (int)KeeperException.Code.OK */)
{
SpinWait spin = new SpinWait();
while (!producer.IsConnectionClosedByServer)
{
spin.SpinOnce();
if (spin.Count > maxSpin)
{
spin.Reset();
}
}
}
}
catch (ThreadInterruptedException)
{
// ignore, close the send/event threads
}
catch (Exception ex)
{
LOG.WarnFormat("Error disposing {0} : {1}", this.GetType().FullName, ex.Message);
}
finally
{
producer.Dispose();
consumer.Dispose();
}
}
}
public void TickLoop()
{
log.Info("Network loop started.");
while (true)
{
if (Manager.Terminating)
{
break;
}
loopLock.Reset();
//Do we really need this?
//foreach (var i in Manager.Clients)
//{
// if (i.Value.Stage == ProtocalStage.Disconnected)
// {
// Manager.Clients.TryRemove(i.Key, out client);
// }
//}
Work work;
while (pendings.TryDequeue(out work))
{
if (Manager.Terminating)
{
return;
}
if (work.Item1.Stage == ProtocalStage.Disconnected && work.Item1.Account != null)
{
Client client;
Manager.Clients.TryRemove(work.Item1.Account.AccountId, out client);
continue;
}
try
{
var packet = Packet.Packets[work.Item2].CreateInstance();
packet.Read(work.Item1, work.Item3, 0, work.Item3.Length);
work.Item1.ProcessPacket(packet);
}
catch (Exception ex)
{
log.Error("Error while reading or processing packet:\n", ex);
}
}
while (pendings.Count == 0 && !Manager.Terminating)
{
loopLock.SpinOnce();
}
}
log.Info("Network loop stopped.");
}
public void CompleteAdding()
{
this.CheckDisposed();
if (this.IsAddingCompleted)
{
return;
}
SpinWait spinWait = new SpinWait();
while (true)
{
int mCurrentAdders = this.m_currentAdders;
if ((mCurrentAdders & -2147483648) != 0)
{
spinWait.Reset();
while (this.m_currentAdders != -2147483648)
{
spinWait.SpinOnce();
}
return;
}
if (Interlocked.CompareExchange(ref this.m_currentAdders, mCurrentAdders | -2147483648, mCurrentAdders) == mCurrentAdders)
{
break;
}
spinWait.SpinOnce();
}
spinWait.Reset();
while (this.m_currentAdders != -2147483648)
{
spinWait.SpinOnce();
}
if (this.Count == 0)
{
this.CancelWaitingConsumers();
}
this.CancelWaitingProducers();
}
public void TickLoop()
{
log.Info("Network loop started.");
Work work;
Client client;
while (true)
{
if (Manager.Terminating)
{
break;
}
loopLock.Reset();
foreach (var i in Manager.Clients)
{
if (i.Value.Stage == ProtocalStage.Disconnected)
{
Manager.Clients.TryRemove(i.Key, out client);
}
}
while (pendings.TryDequeue(out work))
{
if (Manager.Terminating)
{
return;
}
if (work.Item1.Stage == ProtocalStage.Disconnected && work.Item1.Account != null)
{
Manager.Clients.TryRemove(work.Item1.Account.AccountId, out client);
continue;
}
try
{
Packet packet = Packet.Packets[work.Item2].CreateInstance();
packet.Read(work.Item1, work.Item3, 0, work.Item3.Length);
work.Item1.ProcessPacket(packet);
}
catch
{
}
}
while (pendings.Count == 0 && !Manager.Terminating)
{
loopLock.SpinOnce();
}
}
log.Info("Network loop stopped.");
}
public void Dispatch(Action <TWorkItem, CancellationToken> action, CancellationToken cancellationToken)
{
using var locals = new WorkQueueLocals(this);
try
{
CustomWorkQueueNonGenericStore.LocalQueue = locals.Queue;
var waitAdded = false;
var spinWait = new SpinWait();
while (!cancellationToken.IsCancellationRequested)
{
if (TryDequeue(locals, out var work, out var missedSteal))
{
if (!waitAdded)
{
SignalOneThread();
}
do
{
action(work, cancellationToken);
} while (TryDequeue(locals, out work, out missedSteal));
}
if (!waitAdded)
{
AddWaitNode(locals.WaitNode, ref spinWait);
waitAdded = true;
continue;
}
if (missedSteal)
{
spinWait.SpinOnce();
continue;
}
locals.Semaphore.Wait(cancellationToken);
spinWait.Reset();
waitAdded = false;
}
cancellationToken.ThrowIfCancellationRequested();
}
finally
{
CustomWorkQueueNonGenericStore.LocalQueue = null;
}
}
protected override void ConsumeItems( int count )
{
SpinWait spinWait = new SpinWait();
int value;
for ( int i = 0; i < count; )
{
if ( this.queue.TryDequeue( out value ) )
{
i++;
spinWait.Reset();
}
else
{
spinWait.SpinOnce();
}
}
}
private void StartSchedule()
{
Task.Run(() =>
{
SpinWait sw = new SpinWait();
while (!this.cancellationTokenSource.Token.IsCancellationRequested &&
(!this.controllerQueue.IsCompleted || this.activeControllerItems.Any()))
{
FillInQueue(
this.activeControllerItems,
this.controllerQueue,
this.cancellationTokenSource.Token);
if (!this.cancellationTokenSource.Token.IsCancellationRequested)
{
// If we don't have the requested amount of active tasks
// running, get a task item from any active transfer item
// that has work available.
if (!this.DoWorkFrom(this.activeControllerItems))
{
sw.SpinOnce();
}
else
{
sw.Reset();
continue;
}
}
}
});
}