public void LogRemainingOperations()
{
Interlocked.MemoryBarrier();
if (NetEventSource.IsEnabled)
{
NetEventSource.Info(this, $"Releasing with pending operations: {_refCount}");
}
}
void MemoryBarrier()
{
#if NETFX_CORE
Interlocked.MemoryBarrier();
#else
Thread.MemoryBarrier();
#endif
}
public static void MemoryBarrier()
{
#if NETCOREAPP1_1
Interlocked.MemoryBarrier();
#else
Thread.MemoryBarrier();
#endif
}
public static void MemoryBarrier()
{
#if NETFX_CORE || NET_4_6
Interlocked.MemoryBarrier();
#else
Thread.MemoryBarrier();
#endif
}
public void LogRemainingOperations()
{
Interlocked.MemoryBarrier();
if (GlobalLog.IsEnabled)
{
GlobalLog.Print("InnerSafeCloseSocket: Releasing with pending operations: " + _refCount);
}
}
public static void MemoryBarrier()
{
#if (LESSTHAN_NETCOREAPP20 || TARGETS_NETSTANDARD) && !PROFILE328
Interlocked.MemoryBarrier();
#else
Thread.MemoryBarrier();
#endif
}
public ushort GrantClassID()
{
Interlocked.MemoryBarrier();
lock (_guarder.TokenInterlockerGuard)
{
return(Increment(ref _vault.LastClassID));
}
}
public static void Barrier()
{
#if (NET35)
Thread.MemoryBarrier();
#else
Interlocked.MemoryBarrier();
#endif
}
public TItem Wait(CancellationToken cancellationToken)
{
using (var compositeCancellation = CancellationTokenSource
.CreateLinkedTokenSource(_disposeCancellation, cancellationToken))
{
while (true)
{
if (_disposeCancellation.IsCancellationRequested)
{
throw new ObjectDisposedException(GetType().Name);
}
Interlocked.MemoryBarrier();
Interlocked.Increment(ref _readersCount);
Interlocked.MemoryBarrier();
try
{
try
{
_readSem.Wait(compositeCancellation.Token);
}
catch (OperationCanceledException)
{
if (_disposeCancellation.IsCancellationRequested)
{
throw new ObjectDisposedException(GetType().Name);
}
throw;
}
QueueItem qitem;
if (!_queue.TryDequeue(out qitem))
{
continue;
}
qitem.DisableCancellation();
var item = qitem.Value;
if (item.Cancellation.IsCancellationRequested)
{
item.TrySetCanceled(item.Cancellation);
continue;
}
return(item);
}
finally
{
Interlocked.MemoryBarrier();
Interlocked.Decrement(ref _readersCount);
}
}
}
}
private void ThreadExecutor()
{
Interlocked.MemoryBarrier();
Window.MakeCurrent();
//Fired when the window resizes
Window.Resize += (sender, e) =>
{
GL.Viewport(Window.Size);
EventDispatcher.FireEvent(new WindowResizeEvent(Window.Size.Width, Window.Size.Height));
};
//Fired when the window is moved
Window.Move += (sender, e) => EventDispatcher.FireEvent(new WindowMovedEvent(Window.Location.X, Window.Location.Y));
//Key events
Window.KeyPress += (sender, e) => EventDispatcher.FireEvent(new KeyPressedEvent(e));
Window.KeyDown += (sender, e) => EventDispatcher.FireEvent(new KeyDownEvent(e));
Window.KeyUp += (sender, e) => EventDispatcher.FireEvent(new KeyUpEvent(e));
//Mouse events
Window.MouseEnter += (sender, e) => EventDispatcher.FireEvent(new MouseEnterEvent());
Window.MouseLeave += (sender, e) => EventDispatcher.FireEvent(new MouseLeaveEvent());
Window.MouseDown += (sender, e) => EventDispatcher.FireEvent(new MouseDownEvent(e));
Window.MouseUp += (sender, e) => EventDispatcher.FireEvent(new MouseUpEvent(e));
Window.MouseWheel += (sender, e) => EventDispatcher.FireEvent(new MouseWheelEvent(e));
Window.MouseMove += (sender, e) => EventDispatcher.FireEvent(new MouseMoveEvent(e));
while (!TerminateFlag)
{
Event.WaitOne(THREAD_WAIT);
ConcurrentQueue <Action> Frame;
if (FrameQueue.TryDequeue(out Frame))
{
while (FrameQueue.TryDequeue(out Frame))
{
;
}
Action Act;
while (Frame.TryDequeue(out Act))
{
Act();
}
Action <GameWindow> WindowTask;
while (WindowTasks.TryDequeue(out WindowTask))
{
WindowTask(Window);
}
Window.SwapBuffers();
Window.ProcessEvents();
}
}
}
private void ChangeState(CacheEvent @event, T value = default)
{
switch (@event)
{
case CacheEvent.Load:
if (StateChange(CacheState.Pending, CacheState.Loading))
{
this.Load();
}
break;
case CacheEvent.Expire:
if (StateChange(CacheState.Active, CacheState.Reloading))
{
Task.Run(async() =>
{
try
{
await this.Load();
}
catch (Exception)
{
}
});
}
break;
case CacheEvent.Error:
// TODO figure out what to do on an error.
Volatile.Write(ref _currentState, 0);
break;
case CacheEvent.Loaded:
if (StateChange(CacheState.Loading, CacheState.Loaded))
{
Volatile.Write(ref _value, value);
Interlocked.MemoryBarrier(); // Need this here to prevent read/write reordering. (LoadStore barrier)
Volatile.Write(ref _currentState, (int)CacheState.Active);
_stopWatchThreadSafe.Reset();
lock (_lock)
{
foreach (var pendingTask in _pendingTasks)
{
pendingTask.SetResult(value);
}
_pendingTasks = new List <TaskCompletionSource <T> >(0);
}
}
else if (Volatile.Read(ref _currentState) == (int)CacheState.Reloading)
{
// Don't need any ordering here.
Volatile.Write(ref _value, value);
Volatile.Write(ref _currentState, (int)CacheState.Active);
_stopWatchThreadSafe.Reset();
}
break;
}
}
/// <summary>
/// It callbacks all operations already sent / or to be written, that do not have a response.
/// Invoked from an IO Thread or a pool thread
/// </summary>
internal void CancelPending(Exception ex, SocketError?socketError = null)
{
_isCanceled = true;
var wasClosed = Interlocked.Exchange(ref _writeState, Connection.WriteStateClosed) == Connection.WriteStateClosed;
if (!wasClosed)
{
if (Closing != null)
{
Closing(this);
}
Connection.Logger.Info("Cancelling in Connection {0}, {1} pending operations and write queue {2}", Address,
InFlight, _writeQueue.Count);
if (socketError != null)
{
Connection.Logger.Verbose("The socket status received was {0}", socketError.Value);
}
}
if (ex == null || ex is ObjectDisposedException)
{
if (socketError != null)
{
ex = new SocketException((int)socketError.Value);
}
else
{
//It is closing
ex = new SocketException((int)SocketError.NotConnected);
}
}
// Dequeue all the items in the write queue
var ops = new LinkedList <OperationState>();
OperationState state;
while (_writeQueue.TryDequeue(out state))
{
ops.AddLast(state);
}
// Remove every pending operation
while (!_pendingOperations.IsEmpty)
{
Interlocked.MemoryBarrier();
// Remove using a snapshot of the keys
var keys = _pendingOperations.Keys.ToArray();
foreach (var key in keys)
{
if (_pendingOperations.TryRemove(key, out state))
{
ops.AddLast(state);
}
}
}
Interlocked.MemoryBarrier();
OperationState.CallbackMultiple(ops, ex);
Interlocked.Exchange(ref _inFlight, 0);
}
/// <summary>Tries to peek at an element from the queue, without removing it.</summary>
public bool TryPeek(out T result, bool resultUsed)
{
if (resultUsed)
{
// In order to ensure we don't get a torn read on the value, we mark the segment
// as preserving for observation. Additional items can still be enqueued to this
// segment, but no space will be freed during dequeues, such that the segment will
// no longer be reusable.
_preservedForObservation = true;
Interlocked.MemoryBarrier();
}
// Loop in case of contention...
var spinner = new SpinWait();
while (true)
{
// Get the head at which to try to peek.
int currentHead = Volatile.Read(ref _headAndTail.Head);
int slotsIndex = currentHead & _slotsMask;
// Read the sequence number for the head position.
int sequenceNumber = Volatile.Read(ref _slots[slotsIndex].SequenceNumber);
// We can peek from this slot if it's been filled by an enqueuer, which
// would have left the sequence number at pos+1.
int diff = sequenceNumber - (currentHead + 1);
if (diff == 0)
{
result = resultUsed ? _slots[slotsIndex].Item : default(T);
return(true);
}
else if (diff < 0)
{
// The sequence number was less than what we needed, which means this slot doesn't
// yet contain a value we can peek, i.e. the segment is empty. Technically it's
// possible that multiple enqueuers could have written concurrently, with those
// getting later slots actually finishing first, so there could be elements after
// this one that are available, but we need to peek in order. So before declaring
// failure and that the segment is empty, we check the tail to see if we're actually
// empty or if we're just waiting for items in flight or after this one to become available.
bool frozen = _frozenForEnqueues;
int currentTail = Volatile.Read(ref _headAndTail.Tail);
if (currentTail - currentHead <= 0 || (frozen && (currentTail - FreezeOffset - currentHead <= 0)))
{
result = default(T);
return(false);
}
// It's possible it could have become frozen after we checked _frozenForEnqueues
// and before reading the tail. That's ok: in that rare race condition, we just
// loop around again.
}
// Lost a race. Spin a bit, then try again.
spinner.SpinOnce();
}
}
// Called by the runtime when it finds a class whose static class constructor has probably not run
// (probably because it checks in the initialized flag without thread synchronization).
//
// This method should synchronize with other threads, recheck the initialized flag and execute the
// cctor method (whose address is given in the context structure) before setting the initialized flag
// to 1. Once in this state the runtime will not call this method again for the same type (barring
// race conditions).
//
// The context structure passed by reference lives in the image of one of the application's modules.
// The contents are thus fixed (do not require pinning) and the address can be used as a unique
// identifier for the context.
private static unsafe void CheckStaticClassConstruction(ref StaticClassConstructionContext context)
{
// This is a simplistic placeholder implementation. For instance it uses a busy wait spinlock and
// does not handle recursion.
while (true)
{
// Read the current state of the cctor.
int oldInitializationState = context.initialized;
// Once it transitions to 1 then the cctor has been run (another thread got there first) and
// we can simply return.
if (oldInitializationState == 1)
{
return;
}
// If the state is anything other than 0 (the initial state) then another thread is currently
// running this cctor. We must wait for it to complete doing so before continuing, so loop
// again.
if (oldInitializationState != 0)
{
continue;
}
// C# warns that passing a volatile field to a method via a reference loses the volatility of the field.
// However the method in question is Interlocked.CompareExchange so the volatility in this case is
// unimportant.
#pragma warning disable 420
// We read a state of 0 (the initial state: not initialized and not being initialized). Try to
// transition this to 2 which will let other threads know we're going to run the cctor here.
if (Interlocked.CompareExchange(ref context.initialized, 2, 0) == 0)
{
// We won the race to transition the state from 0 -> 2. So we can now run the cctor. Other
// threads trying to do the same thing will spin waiting for us to transition the state to
// 1.
// Call the cctor code directly from the address in the context. The <int> here says the
// cctor returns an int because the calli transform used doesn't handle the void case yet.
Call <int>(context.cctorMethodAddress);
// Insert a memory barrier here to order any writes executed as part of static class
// construction above with respect to the initialized flag update we're about to make
// below. This is important since the fast path for checking the cctor uses a normal read
// and doesn't come here so without the barrier it could observe initialized == 1 but
// still see uninitialized static fields on the class.
Interlocked.MemoryBarrier();
// Set the state to 1 to indicate to the runtime and other threads that this cctor has now
// been run.
context.initialized = 1;
}
// If we get here some other thread changed the initialization state to a non-zero value
// before we could. Loop at try again.
}
}
/// <summary>
/// Read the value applying full fence semantic
/// </summary>
/// <returns>The current value</returns>
public long ReadFullFence()
{
#if NETFX_CORE
Interlocked.MemoryBarrier();
#else
Thread.MemoryBarrier();
#endif
return(_value);
}
private void Leave()
{
Interlocked.Decrement(ref counter);
Interlocked.MemoryBarrier(); // is this needed?
if (isShutdown)
{
tcs.TrySetResult(null);
}
}
/// <summary>
/// Dispose.
/// </summary>
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
_disposed = true;
Interlocked.MemoryBarrier();
GrammarApi.sol_DeleteSentenceBroker(_hObject);
}
}
internal void Freeze()
{
Debug.Assert(!_frozen);
// make sure that values from all threads are visible:
Interlocked.MemoryBarrier();
_frozen = true;
}
/// <summary>
/// Write the value applying full fence semantic
/// </summary>
/// <param name="newValue">The new value</param>
public void WriteFullFence(long newValue)
{
#if NETFX_CORE
Interlocked.MemoryBarrier();
#else
Thread.MemoryBarrier();
#endif
_value = newValue;
}
public void Clear()
{
lock (sync)
{
var newTable = CreateInitialTable();
Interlocked.MemoryBarrier();
table = newTable;
}
}
public async Task <IDisposable> LockAsync(CancellationToken cancellationToken)
{
await _sem.WaitAsync(cancellationToken)
.ConfigureAwait(false);
Interlocked.MemoryBarrier();
return(GetUnlockingDisposable());
}
private void SaveResumeDataFailedAlert(Core.save_resume_data_failed_alert a)
{
Interlocked.MemoryBarrier();
Interlocked.Decrement(ref outstanding_resume_data);
if (outstanding_resume_data == 0 && no_more_resume)
{
no_more_data.Set();
}
}
private void ConnectionChanged(ConnectionStatus status)
{
Interlocked.MemoryBarrier();
if ((status.HasFlag(ConnectionStatus.Disconnected) ||
status.HasFlag(ConnectionStatus.Offline)) && _start && _borg != null)
{
_resetEvent.Set();
}
}
private void ImportDataMembers()
{
/*
* DataMembers are used for the deserialization of Exceptions.
* DataMembers represent the fields and/or settable properties that the underlying Exception has.
* The DataMembers are stored and eventually passed to a ClassDataContract created from the underlying Exception.
* The ClassDataContract uses the list of DataMembers to set the fields/properties for the newly created Exception.
* If a DataMember is a property it must be settable.
*/
Type type = this.UnderlyingType;
if (type == Globals.TypeOfException)
{
ImportSystemExceptionDataMembers(); //System.Exception must be handled specially because it is the only exception that imports private fields.
return;
}
List <DataMember> tempMembers;
if (BaseContract != null)
{
tempMembers = new List <DataMember>(BaseContract.Members); //Don't set tempMembers = BaseContract.Members and then start adding, because this alters the base's reference.
}
else
{
tempMembers = new List <DataMember>();
}
Dictionary <string, DataMember> memberNamesTable = new Dictionary <string, DataMember>();
MemberInfo[] memberInfos;
memberInfos = type.GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public);
for (int i = 0; i < memberInfos.Length; i++)
{
MemberInfo member = memberInfos[i];
//Public properties with set methods can be deserialized with the ClassDataContract
PropertyInfo publicProperty = member as PropertyInfo;
if (publicProperty != null && publicProperty.SetMethod != null)
{
DataMember memberContract = new DataMember(member);
memberContract.Name = DataContract.EncodeLocalName(member.Name);
memberContract.IsRequired = false;
memberContract.IsNullable = DataContract.IsTypeNullable(memberContract.MemberType);
if (HasNoConflictWithBaseMembers(memberContract))
{
CheckAndAddMember(tempMembers, memberContract, memberNamesTable);
}
}
}
Interlocked.MemoryBarrier();
_members = tempMembers;
}
public ValueTask <bool> MoveNextAsync()
{
if (this._isAwaiting != 0)
{
throw new InvalidOperationException("The previous task has not been completed.");
}
this._taskHelper.Reset();
this._isAwaiting = 1;
Interlocked.MemoryBarrier();
if (this._cancellationToken.IsCancellationRequested)
{
if (this.WriteResult())
{
this._taskHelper.SetResult(null);
}
}
else if (this._isCompleted)
{
if (this.WriteResult())
{
this._taskHelper.SetResult(false);
}
}
else
{
Request();
}
return(new ValueTask <bool>(this, this._taskHelper.Version));
async void Request()
{
try
{
var subscription = await this._subscription.Task.ConfigureAwait(false);
lock (this.SubscriptionLock)
{
if (!this._isCompleted)
{
subscription.Request(1);
}
}
}
catch (Exception ex)
{
if (this.WriteResult())
{
this._taskHelper.SetException(ex);
}
}
}
}
private void FlushInternal(int count)
{
_count = count;
_queue._currentBatch = new Batch(_queue);
// The full fence ensures that the current batch will never be added to the queue before _count is set.
Interlocked.MemoryBarrier();
_queue._batchQueue.Add(this);
}
public void SetComplete()
{
if (_isComplete)
{
return;
}
_isComplete = true;
Interlocked.MemoryBarrier();
_waitHandle.Set();
}
protected override void OnStart(string[] args)
{
//OnStart shoud return right away, otherwise SCM kills the service. Main processing happens in a different thread running ServiceMain
stopsignal = 0;
Interlocked.MemoryBarrier();
Thread serviceMainThread;
serviceMainThread = new Thread(this.ServiceMain);
serviceMainThread.Start();
}
void IActivityMonitorImpl.SetClientMinimalFilterDirty()
{
_actualFilterIsDirty = true;
Interlocked.MemoryBarrier();
// By signaling here the change to the bridge, we handle the case where the current
// active thread works on a bridged monitor: the bridged monitor's _actualFilterIsDirty
// is set to true and any interaction with its ActualFilter will trigger a resynchronization
// of this _actualFilter.
_output.BridgeTarget.TargetActualFilterChanged();
}
internal void StreamOperationCompletedCallback(IAsyncInfo completedOperation, AsyncStatus unusedCompletionStatus)
{
try
{
if (_callbackInvoked)
{
throw new InvalidOperationException(SR.InvalidOperation_MultipleIOCompletionCallbackInvocation);
}
_callbackInvoked = true;
// This happens in rare stress cases in Console mode and the WinRT folks said they are unlikely to fix this in Dev11.
// Moreover, this can happen if the underlying WinRT stream has a faulty user implementation.
// If we did not do this check, we would either get the same exception without the explaining message when dereferencing
// completedOperation later, or we will get an InvalidOperation when processing the Op. With the check, they will be
// aggregated and the user will know what went wrong.
if (completedOperation == null)
{
throw new NullReferenceException(SR.NullReference_IOCompletionCallbackCannotProcessNullAsyncInfo);
}
_completedOperation = completedOperation;
// processCompletedOperationInCallback == false indicates that the stream is doing a blocking wait on the waitHandle of this IAsyncResult.
// In that case calls on completedOperation may deadlock if completedOperation is not free threaded.
// By setting processCompletedOperationInCallback to false the stream that created this IAsyncResult indicated that it
// will call ProcessCompletedOperation after the waitHandle is signalled to fetch the results.
if (_processCompletedOperationInCallback)
{
ProcessCompletedOperation();
}
}
catch (Exception ex)
{
_bytesCompleted = 0;
_errorInfo = ExceptionDispatchInfo.Capture(ex);
}
finally
{
_completed = true;
Interlocked.MemoryBarrier();
// From this point on, AsyncWaitHandle would create a handle that is readily set,
// so we do not need to check if it is being produced asynchronously.
if (_waitHandle != null)
{
_waitHandle.Set();
}
}
if (_userCompletionCallback != null)
{
_userCompletionCallback(this);
}
}