public void Enter(out bool taken) { // Taken is an out parameter so that we set it *inside* the critical // region, rather than returning it and permitting aborts to creep in. // Without this, the caller could take the lock, but not release it // because it didn't know it had to. taken = false; while (!taken) { if (isSingleProc) { // Don't busy wait on 1-logical processor machines; try // a single swap, and if it fails, drop back to EventWaitHandle. Thread.BeginCriticalRegion(); taken = Interlocked.CompareExchange(ref state, 1, 0) == 0; if (!taken) { Thread.EndCriticalRegion(); } } else { for (int i = 0; !taken && i < outerTryCount; i++) { // Tell the CLR we're in a critical region; // interrupting could lead to deadlocks. Thread.BeginCriticalRegion(); // Try 'cexTryCount' times to CEX the state variable: int tries = 0; while (!(taken = Interlocked.CompareExchange(ref state, 1, 0) == 0) && tries++ < cexTryCount) { Thread.SpinWait(1); } if (!taken) { // We failed to acquire in the busy spin, mark the end // of our critical region and yield to let another // thread make forward progress. Thread.EndCriticalRegion(); Thread.Sleep(0); } } } // If we didn't acquire the lock, block. if (!taken) { available.WaitOne(); } } }
public EntryBlockUC Enter() { Thread.BeginCriticalRegion(); int ticket = Interlocked.Increment(ref _tickets); while (Interlocked.Add(ref _activeTicket, 0) != ticket) { } Thread.EndCriticalRegion(); return(new EntryBlockUC(EntryTypeUC.Exclusive, EntryCompletion)); }
//-------------------------------------------------------------------------------- public void connect() { //while (true) //{ Thread.BeginCriticalRegion(); MakeConnection(); Thread.EndCriticalRegion(); //} }
static void CriticalAbort() { Console.WriteLine("CritialAbort"); Thread.BeginCriticalRegion(); z = new Temp(); z.isValid = true; Thread.SpinWait(50); z.isComplete = true; Thread.EndCriticalRegion(); Console.WriteLine(z.ToString()); }
public override void WriteTime(string fmt, params object[] args) { Thread.BeginCriticalRegion(); writer.Write(DateTime.Now.ToString("u") + ": "); writer.WriteLine(fmt, args); if (_autoflush) { Flush(); } Thread.EndCriticalRegion(); }
/// <summary> /// Aborts execution of the thread, if there is any. /// </summary> public void Abort() { Thread.BeginCriticalRegion(); executing = false; Thread.EndCriticalRegion(); endExecution(); if (thread != null) { thread.Abort(); } }
private StorageInfo CreateStorageInfo() { // we do our own locking, tell hosts this is a bad time to interrupt us. #if !SILVERLIGHT Thread.BeginCriticalRegion(); #endif StorageInfo[] curStorage = Updating; try { int threadId = Thread.CurrentThread.ManagedThreadId; StorageInfo newInfo = new StorageInfo(Thread.CurrentThread); // set to updating while potentially resizing/mutating, then we'll // set back to the current value. while ((curStorage = Interlocked.Exchange(ref _stores, Updating)) == Updating) { // another thread is already updating... Thread.Sleep(0); } // check and make sure we have a space in the array for our value if (curStorage == null) { curStorage = new StorageInfo[threadId + 1]; } else if (curStorage.Length <= threadId) { StorageInfo[] newStorage = new StorageInfo[threadId + 1]; for (int i = 0; i < curStorage.Length; i++) { // leave out the threads that have exited if (curStorage[i] != null && curStorage[i].Thread.IsAlive) { newStorage[i] = curStorage[i]; } } curStorage = newStorage; } // create our StorageInfo in the array, the empty check ensures we're only here // when we need to create. Debug.Assert(curStorage[threadId] == null || curStorage[threadId].Thread != Thread.CurrentThread); return(curStorage[threadId] = newInfo); } finally { if (curStorage != Updating) { // let others access the storage again Interlocked.Exchange(ref _stores, curStorage); } #if !SILVERLIGHT Thread.EndCriticalRegion(); #endif } }
public void Enter() { Thread.BeginCriticalRegion(); while (Interlocked.Exchange(ref this._lockState, 1) != 0) { while (Thread.VolatileRead(ref this._lockState) == 1) { SpinLock.StallThread(); } } }
public void compute() { Thread current = Thread.CurrentThread; current.Priority = ThreadPriority.Highest; int position; Thread.BeginCriticalRegion(); position = mutex; mutex++; Thread.EndCriticalRegion(); solve(position); }
private void StartDisposingThread() { if (_disposingThread != null && _disposingThread.IsAlive) { return; } _disposingThread = new Thread( () => { Thread.Sleep(5000); while (true) { TimeSpan span; lock (this) { if (!_dereferenceTime.HasValue) { return; } if (_dereferenceTime.Value.AddMilliseconds(4500) < DateTime.Now) { if (_connection != null) { #if !NETCOREAPP1_0 try { Thread.BeginCriticalRegion(); #endif DbConnection connection = _connection; _connection = null; connection.Dispose(); _disposingThread = null; #if !NETCOREAPP1_0 } finally { Thread.EndCriticalRegion(); } #endif } return; } span = _dereferenceTime.HasValue ? (_dereferenceTime.Value.AddMilliseconds(5000) - DateTime.Now) : TimeSpan.Zero; } if (span > TimeSpan.Zero) { Thread.Sleep(span); } } }); _disposingThread.Start(); }
public bool TryEnterWriteLock(int millisecondsTimeout) { Thread.BeginCriticalRegion(); this.lockHeldRegion.Value.Enter(); if (!this.rwLock.TryEnterWriteLock(millisecondsTimeout)) { this.lockHeldRegion.Value.Exit(); Thread.EndCriticalRegion(); return(false); } return(true); }
/// <summary> /// If a writer is open, flush, close, and dispose it. /// </summary> public static void Close() { Thread.BeginCriticalRegion(); if (writer != null) { Flush(); writer.Close(); writer.Dispose(); } Thread.EndCriticalRegion(); }
/// <summary> /// If log is already open with the same filename, do nothing. /// Otherwise open (in append mode, if file exists). /// </summary> /// <remarks> /// Be aware that log files that are never truncated can become very large. /// </remarks> /// <param name="fileName">the filename</param> public static void Reopen(string fileName) { Thread.BeginCriticalRegion(); FileInfo temp = new FileInfo(fileName); if (Ready && _fInfo.FullName == temp.FullName) { return; } OpenAppend(fileName); Thread.EndCriticalRegion(); }
internal void RemoveClient(SSLClient client) { Thread.BeginCriticalRegion(); lock (clientList) { client.Dispose(); clientList.Remove(client); } Thread.EndCriticalRegion(); }
private void ProcessAsyncOperations(object ownerForm) { var f = (TContext)ownerForm; var w = _OperationSemaphore; while (true) { w.WaitOne(); Thread.BeginCriticalRegion(); try { if (_OperationQueue.Count > 0) { var op = AsyncDeQueueOperation(); try { f.AsyncOperationBegins(op.Name); var res = op.Action(f); if (op.Notifier != null) { op.Notifier(f, res); } } finally { f.AsyncOperationsCompleted(); } } } catch (SqlCommandException e) { _OperationQueue.Clear(); f.AsyncError(e.Message); } catch (InvalidDBVersionException e) { _OperationQueue.Clear(); f.AsyncError(string.Format("Invalid DB Version: {0}. Cannot run script!!!", e.Version)); } catch (Exception e) { _OperationQueue.Clear(); f.AsyncError(e.Message); } finally { Thread.EndCriticalRegion(); OperationCompleted(); } } }
private static void ProcessMessages() { while (true) { try { foreach (string client in clients.Keys) { if (!clients[client].StillConnected) { Thread.BeginCriticalRegion(); clients.Remove(client); clients[client].Dispose(); Thread.EndCriticalRegion(); foreach (string c in clients.Keys) { if (!c.Equals(client)) { clients[c].SendMessage(string.Format("{0} has left the server.", client)); } } continue; } if (!clients[client].HasMessages) { continue; } Message nextMessage = clients[client].GetNextMessage(); foreach (string recipient in nextMessage.destinations) { if (recipient.Equals("server")) { serverMessages.Add(nextMessage); continue; } if (clients.ContainsKey(recipient)) { clients[recipient].SendMessage(nextMessage); } else { clients[client].SendMessage(string.Format("{0} doesn't seem to be connected.", recipient)); } } } } catch { } } }
public static void ErrorLog(Exception ex, String ErrorData, String FileName) { try { Thread.BeginCriticalRegion(); String ErrorFilename = FileName; Utility.LogFile(ErrorFilename, ErrorData); Utility.LogFile(ErrorFilename, ex.Message); Utility.LogFile(ErrorFilename, ex.StackTrace); Thread.EndCriticalRegion(); } catch { } }
/// <summary> /// Releases the lock. /// </summary> /// <exception cref="System.InvalidOperationException">lock is not held</exception> /// <exception cref="T:System.Threading.SynchronizationLockException">Thread ownership tracking is enabled, and the current thread is not the owner of this lock.</exception> public void Release() { Thread.BeginCriticalRegion(); if ((this.mOwner & LockAnonymousOwned) == LockUnowned) { Thread.EndCriticalRegion(); throw new InvalidOperationException("lock is not held"); } Interlocked.Decrement(ref this.mOwner); Thread.EndCriticalRegion(); }
/// <summary> /// Debug program. /// </summary> public void Debug() { cpu.Constants.GetRegister("pc").Val = entryPoint; Thread.BeginCriticalRegion(); next = 0; Thread.EndCriticalRegion(); Thread.BeginCriticalRegion(); stepByStepMode = false; Thread.EndCriticalRegion(); thread = new Thread(new ThreadStart(executeStepByStep)); Console.WriteLine("Executor thread id = " + thread.ManagedThreadId); thread.Start(); }
public void compute() { Thread current = Thread.CurrentThread; current.Priority = ThreadPriority.Highest; int secondNode; Thread.BeginCriticalRegion(); secondNode = mutex; mutex++; Thread.EndCriticalRegion(); solve(secondNode); }
public static void Save(Config config, string filename) { if (config == null) { throw new ArgumentNullException("config"); } Thread.BeginCriticalRegion(); Stream stream = null; XmlTextWriter writer = null; XmlSerializer serializer = null; try { FileInfo file = new FileInfo(filename); if (config.Avatar != null && config.Avatar.SmallBytes.Length > 0) { File.WriteAllBytes(Path.Combine(file.Directory.FullName, "avatar_small.jpg"), config.Avatar.SmallBytes); File.WriteAllBytes(Path.Combine(file.Directory.FullName, "avatar_large.jpg"), config.Avatar.LargeBytes); } stream = file.Open(FileMode.Create, FileAccess.Write); writer = new XmlTextWriter(stream, Encoding.UTF8); writer.Formatting = Formatting.Indented; writer.Indentation = 2; writer.IndentChar = '\x20'; serializer = new XmlSerializer(typeof(Config)); serializer.Serialize(writer, config); writer.Flush(); } catch (UnauthorizedAccessException) { } finally { if (writer != null) { writer.Close(); } if (stream != null) { stream.Close(); stream.Dispose(); } } Thread.EndCriticalRegion(); }
public void ReleaseLock(LockToken <T> token, LockRuleset rules) { if (!_locks.TryGetValue(token.LockedObject, out var h)) { throw new InvalidOperationException("Object not locked"); } var lockType = token.LockLevel; var matrix = rules.LockMatrix; unchecked { if (matrix.IsSelfShared(lockType)) { int i; Thread.BeginCriticalRegion(); do //переводим комбинацию блокировок в новое состояние и поднимаем флаг проверки разделямых блокировок { i = (int)(h.LockInfo & LockMatrix.SharenessCheckLockDrop); //мы исключаем из возможных переходы, результатом которых будет поднятый флаг проверки разделяемой блокировки (проверки разделяемой блокировки смогут пересечься) } while (Interlocked.CompareExchange(ref h.LockInfo, i | (int)LockMatrix.SharenessCheckLock, i) != i); if (h.GetSharedLockCount(matrix.SelfSharedLockShift(lockType)) == 0)//если текущий переход убирает существующую разделяемую блокировку (т.е. их сейчас нет). { //делаем переход в новое состояние h.LockInfo = (int)matrix.ExitPair(lockType, (int)(LockMatrix.SharenessCheckLockDrop & (uint)h.LockInfo)).Value.BlockEntrance; } else//если же видим, что освобождение текущей блокировки только уменьшает количество разделяемых блокировок её типа { var sharedLockCount = h.DecrLock(matrix.SelfSharedLockShift(lockType));//то уменьшаем счётчик блокировок Debug.Print($"{sharedLockCount}"); h.LockInfo = h.LockInfo & (int)LockMatrix.SharenessCheckLockDrop;//и сбрасываем флаг проверки } Thread.EndCriticalRegion(); } else { while (true) { var entrancePair = matrix.ExitPair(lockType, (int)(h.LockInfo & LockMatrix.SharenessCheckLockDrop)); if (entrancePair.HasValue) { if (Interlocked.CompareExchange(ref h.LockInfo, (int)entrancePair.Value.BlockEntrance, (int)entrancePair.Value.BlockExit) == (int)entrancePair.Value.BlockExit) { break; } } } } } }
public void AutoSizeColumn(TreeColumn col, ColumnHeaderAutoResizeStyle headerAutoSize) { if (!Columns.Contains(col)) { throw new ArgumentException("column is not a part of treeviewadv", "col"); } if (headerAutoSize == ColumnHeaderAutoResizeStyle.None) { return; } Thread.BeginCriticalRegion(); foreach (TreeNodeAdv tna in this.VisibleNodes) { foreach (NodeControlInfo nci in this.GetNodeControls(tna)) { if (nci.Control.ParentColumn == col) { int nWidth = 0; Size sizeCntrl = nci.Control.GetActualSize(tna, this._measureContext); if (col.Index == 0) { nWidth += nci.Bounds.X; } if (!sizeCntrl.IsEmpty) { col.Width = Math.Max(col.Width, (sizeCntrl.Width + nWidth)); } if (headerAutoSize == ColumnHeaderAutoResizeStyle.HeaderSize) { //Size sizeText = TextRenderer.MeasureText(col.Header, this._measureContext.Font); SizeF sizeText = this._measureContext.Graphics.MeasureString(col.Header, this._measureContext.Font); if (!sizeText.IsEmpty) { col.Width = Math.Max(col.Width, (int)sizeText.Width); } } } } } Thread.EndCriticalRegion(); }
public static void ErrorLog(Exception ex, String ErrorData) { try { if (Settings.GetValue("ErrorsToFile") == true) { Thread.BeginCriticalRegion(); String ErrorFilename = Constants.ApplicationLogFile; // Settings.GetValue("ErrorFileName"); ErrorLog(ex, ErrorData, ErrorFilename); Thread.EndCriticalRegion(); } } catch { } }
/// <summary> /// Write a plain string to the output, then a newline. /// </summary> /// <param name="output">the string</param> /// <returns>the string</returns> public static string WriteLine(string output) { Thread.BeginCriticalRegion(); if (Ready) { _writer.WriteLine(output); if (_autoflush) { Flush(); } } Thread.EndCriticalRegion(); return(output + "\n"); }
public void AcquireWriterLock() { Thread.BeginCriticalRegion(); while (Interlocked.CompareExchange(ref fBusy, 1, 0) != 0) { Thread.Sleep(1); } while (Interlocked.CompareExchange(ref fReadCount, 0, 0) != 0) { Thread.Sleep(1); } }
public bool Return(T item) { if (m_count >= m_items.Length) { return(false); } Thread.BeginCriticalRegion(); m_items[m_count++] = item; Thread.EndCriticalRegion(); return(true); }
public void SimulationTick() { if (NumberContinuousSignals == 0) { SimulatedSignal = GetSimulatedSignal(); NumberContinuousSignals = RanSim.Next(MinSimChange, MaxSimChange); if (AdjustToTarget) { if (MinSimChange > MinSimChangeTarget) { MinSimChange--; } if (MaxSimChange > MaxSimChangeTarget) { MaxSimChangeTarget--; } } if (SimulatedSignal == 0) { NumberContinuousSignals += 3; } bx.SignalProcessor.PerformDiscreteSignalAction(SimulatedSignal, FeedbackType.Audio); bx.SignalProcessor.PerformDiscreteSignalAction(SimulatedSignal, FeedbackType.Keyboard); bx.SignalProcessor.PerformDiscreteSignalAction(SimulatedSignal, FeedbackType.Visual); } else if (NumberContinuousSignals > 0) { if (SimulatedSignal < 0 || SimulatedSignal > 1) { SimulatedSignal = GetSimulatedSignal(); } bx.SignalProcessor.PerformDiscreteSignalAction(SimulatedSignal, FeedbackType.Audio); bx.SignalProcessor.PerformDiscreteSignalAction(SimulatedSignal, FeedbackType.Keyboard); bx.SignalProcessor.PerformDiscreteSignalAction(SimulatedSignal, FeedbackType.Visual); Thread.BeginCriticalRegion(); if (NumberContinuousSignals > 0) { NumberContinuousSignals--; Thread.EndCriticalRegion(); } } else { throw new ApplicationException("Simulator error"); } }
/// <summary> /// Decreases the reference count of the object. /// </summary> /// <param name="count">The number of times to dereference the object.</param> /// <param name="managed">Whether to dispose managed resources.</param> /// <returns>The new reference count.</returns> public int Dereference(int count, bool managed) { // Initial parameter validation. if (count == 0) return Interlocked.Add(ref _refCount, 0); if (count < 0) throw new ArgumentException("Cannot dereference a negative number of times."); // Critical, prevent thread abortion. Thread.BeginCriticalRegion(); try { if (!_owned) return 0; #if ENABLE_STATISTICS // Statistics. Interlocked.Add(ref _dereferencedCount, count); #endif // Decrease the reference count. int newRefCount = Interlocked.Add(ref _refCount, -count); // Should not ever happen. if (newRefCount < 0) throw new InvalidOperationException("Reference count cannot be negative."); // Dispose the object if the reference count is 0. if (newRefCount == 0 && !_disposed) { // If the dispose object method throws an exception, nothing bad // should happen if it does not invalidate any state. this.DisposeObject(managed); // Prevent the object from being disposed twice. _disposed = true; #if ENABLE_STATISTICS Interlocked.Increment(ref _freedCount); #endif } return newRefCount; } finally { Thread.EndCriticalRegion(); } }
private bool EnterLock() { Thread.BeginCriticalRegion(); // If resource available, set it to in-use and return if (Interlocked.Exchange( ref _lock, c_lsOwned) == c_lsFree) { return(true); } else { Thread.EndCriticalRegion(); return(false); } }