Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / BCL / System / Threading / SpinWait.cs / 1305376 / SpinWait.cs
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
//
// SpinWait.cs
//
// [....]
//
// Central spin logic used across the entire code-base.
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
using System;
using System.Runtime.ConstrainedExecution;
using System.Security.Permissions;
using System.Threading;
using System.Diagnostics.Contracts;
namespace System.Threading
{
// SpinWait is just a little value type that encapsulates some common spinning
// logic. It ensures we always yield on single-proc machines (instead of using busy
// waits), and that we work well on HT. It encapsulates a good mixture of spinning
// and real yielding. It's a value type so that various areas of the engine can use
// one by allocating it on the stack w/out unnecessary GC allocation overhead, e.g.:
//
// void f() {
// SpinWait wait = new SpinWait();
// while (!p) { wait.SpinOnce(); }
// ...
// }
//
// Internally it just maintains a counter that is used to decide when to yield, etc.
//
// A common usage is to spin before blocking. In those cases, the NextSpinWillYield
// property allows a user to decide to fall back to waiting once it returns true:
//
// void f() {
// SpinWait wait = new SpinWait();
// while (!p) {
// if (wait.NextSpinWillYield) { /* block! */ }
// else { wait.SpinOnce(); }
// }
// ...
// }
///
/// Provides support for spin-based waiting.
///
///
///
///
///
///
///
/// While SpinWait is designed to be used in concurrent applications, it is not designed to be
/// used from multiple threads concurrently. SpinWait's members are not thread-safe. If multiple
/// threads must spin, each should use its own instance of SpinWait.
///
///
[HostProtection(Synchronization = true, ExternalThreading = true)]
public struct SpinWait
{
// These constants determine the frequency of yields versus spinning. The
// numbers may seem fairly arbitrary, but were derived with at least some
// thought in the design document. I fully expect they will need to change
// over time as we gain more experience with performance.
internal const int YIELD_THRESHOLD = 10; // When to switch over to a true yield.
internal const int SLEEP_0_EVERY_HOW_MANY_TIMES = 5; // After how many yields should we Sleep(0)?
internal const int SLEEP_1_EVERY_HOW_MANY_TIMES = 20; // After how many yields should we Sleep(1)?
// The number of times we've spun already.
private int m_count;
///
/// Gets the number of times
public int Count
{
get { return m_count; }
}
///
/// Gets whether the next call to
/// Whether the next call to
///
/// On a single-CPU machine,
public bool NextSpinWillYield
{
get { return m_count > YIELD_THRESHOLD || PlatformHelper.IsSingleProcessor; }
}
///
/// Performs a single spin.
///
///
/// This is typically called in a loop, and may change in behavior based on the number of times a
///
public void SpinOnce()
{
if (NextSpinWillYield)
{
//
// We must yield.
//
// We prefer to call Thread.Yield first, triggering a SwitchToThread. This
// unfortunately doesn't consider all runnable threads on all OS SKUs. In
// some cases, it may only consult the runnable threads whose ideal processor
// is the one currently executing code. Thus we oc----ionally issue a call to
// Sleep(0), which considers all runnable threads at equal priority. Even this
// is insufficient since we may be spin waiting for lower priority threads to
// execute; we therefore must call Sleep(1) once in a while too, which considers
// all runnable threads, regardless of ideal processor and priority, but may
// remove the thread from the scheduler's queue for 10+ms, if the system is
// configured to use the (default) coarse-grained system timer.
//
#if !FEATURE_PAL && !FEATURE_CORECLR // PAL doesn't support eventing, and we don't compile CDS providers for Coreclr
CdsSyncEtwBCLProvider.Log.SpinWait_NextSpinWillYield();
#endif
int yieldsSoFar = (m_count >= YIELD_THRESHOLD ? m_count - YIELD_THRESHOLD : m_count);
if ((yieldsSoFar % SLEEP_1_EVERY_HOW_MANY_TIMES) == (SLEEP_1_EVERY_HOW_MANY_TIMES - 1))
{
Thread.Sleep(1);
}
else if ((yieldsSoFar % SLEEP_0_EVERY_HOW_MANY_TIMES) == (SLEEP_0_EVERY_HOW_MANY_TIMES - 1))
{
Thread.Sleep(0);
}
else
{
#if PFX_LEGACY_3_5
Platform.Yield();
#else
Thread.Yield();
#endif
}
}
else
{
//
// Otherwise, we will spin.
//
// We do this using the CLR's SpinWait API, which is just a busy loop that
// issues YIELD/PAUSE instructions to ensure multi-threaded CPUs can react
// intelligently to avoid starving. (These are NOOPs on other CPUs.) We
// choose a number for the loop iteration count such that each successive
// call spins for longer, to reduce cache contention. We cap the total
// number of spins we are willing to tolerate to reduce delay to the caller,
// since we expect most callers will eventually block anyway.
//
Thread.SpinWait(4 << m_count);
}
// Finally, increment our spin counter.
m_count = (m_count == int.MaxValue ? YIELD_THRESHOLD : m_count + 1);
}
///
/// Resets the spin counter.
///
///
/// This makes
public void Reset()
{
m_count = 0;
}
#region Static Methods
#if !FEATURE_CORECLR
///
/// Spins until the specified condition is satisfied.
///
/// A delegate to be executed over and over until it returns true.
/// The
public static void SpinUntil(Func condition)
{
#if DEBUG
bool result =
#endif
SpinUntil(condition, Timeout.Infinite);
#if DEBUG
Contract.Assert(result);
#endif
}
///
/// Spins until the specified condition is satisfied or until the specified timeout is expired.
///
/// A delegate to be executed over and over until it returns true.
///
/// A True if the condition is satisfied within the timeout; otherwise, false
/// The
/// condition, TimeSpan timeout)
{
// Validate the timeout
Int64 totalMilliseconds = (Int64)timeout.TotalMilliseconds;
if (totalMilliseconds < -1 || totalMilliseconds > Int32.MaxValue)
{
throw new System.ArgumentOutOfRangeException(
"timeout", timeout, Environment.GetResourceString("SpinWait_SpinUntil_TimeoutWrong"));
}
// Call wait with the timeout milliseconds
return SpinUntil(condition, (int)timeout.TotalMilliseconds);
}
///
/// Spins until the specified condition is satisfied or until the specified timeout is expired.
///
/// A delegate to be executed over and over until it returns true.
/// The number of milliseconds to wait, or True if the condition is satisfied within the timeout; otherwise, false
/// The
/// condition, int millisecondsTimeout)
{
if (millisecondsTimeout < Timeout.Infinite)
{
throw new ArgumentOutOfRangeException(
"millisecondsTimeout", millisecondsTimeout, Environment.GetResourceString("SpinWait_SpinUntil_TimeoutWrong"));
}
if (condition == null)
{
throw new ArgumentNullException("condition", Environment.GetResourceString("SpinWait_SpinUntil_ArgumentNull"));
}
long startTicks = 0; ;
if (millisecondsTimeout != 0 && millisecondsTimeout != Timeout.Infinite)
{
startTicks = DateTime.UtcNow.Ticks;
}
SpinWait spinner = new SpinWait();
while (!condition())
{
if (millisecondsTimeout == 0)
{
return false;
}
spinner.SpinOnce();
if (millisecondsTimeout != Timeout.Infinite && spinner.NextSpinWillYield)
{
if (millisecondsTimeout <= (DateTime.UtcNow.Ticks - startTicks) / TimeSpan.TicksPerMillisecond)
{
return false;
}
}
}
return true;
}
#endif //!FEATURE_CORECLR
#endregion
}
///
/// A helper class to get the number of preocessors, it updates the numbers of processors every sampling interval
///
internal static class PlatformHelper
{
private const int PROCESSOR_COUNT_REFRESH_INTERVAL_MS = 30000; // How often to refresh the count, in milliseconds.
private static int s_processorCount = -1; // The last count seen.
private static DateTime s_nextProcessorCountRefreshTime = DateTime.MinValue; // The next time we'll refresh.
///
/// Gets the number of available processors
///
internal static int ProcessorCount
{
get
{
if (DateTime.UtcNow.CompareTo(s_nextProcessorCountRefreshTime) >= 0)
{
s_processorCount = Environment.ProcessorCount;
s_nextProcessorCountRefreshTime = DateTime.UtcNow.AddMilliseconds(PROCESSOR_COUNT_REFRESH_INTERVAL_MS);
}
Contract.Assert(s_processorCount > 0 && s_processorCount <= 64,
"Processor count not within the expected range (1 - 64).");
return s_processorCount;
}
}
///
/// Gets whether the current machine has only a single processor.
///
internal static bool IsSingleProcessor
{
get { return ProcessorCount == 1; }
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
//
// SpinWait.cs
//
// [....]
//
// Central spin logic used across the entire code-base.
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
using System;
using System.Runtime.ConstrainedExecution;
using System.Security.Permissions;
using System.Threading;
using System.Diagnostics.Contracts;
namespace System.Threading
{
// SpinWait is just a little value type that encapsulates some common spinning
// logic. It ensures we always yield on single-proc machines (instead of using busy
// waits), and that we work well on HT. It encapsulates a good mixture of spinning
// and real yielding. It's a value type so that various areas of the engine can use
// one by allocating it on the stack w/out unnecessary GC allocation overhead, e.g.:
//
// void f() {
// SpinWait wait = new SpinWait();
// while (!p) { wait.SpinOnce(); }
// ...
// }
//
// Internally it just maintains a counter that is used to decide when to yield, etc.
//
// A common usage is to spin before blocking. In those cases, the NextSpinWillYield
// property allows a user to decide to fall back to waiting once it returns true:
//
// void f() {
// SpinWait wait = new SpinWait();
// while (!p) {
// if (wait.NextSpinWillYield) { /* block! */ }
// else { wait.SpinOnce(); }
// }
// ...
// }
///
/// Provides support for spin-based waiting.
///
///
///
///
///
///
///
/// While SpinWait is designed to be used in concurrent applications, it is not designed to be
/// used from multiple threads concurrently. SpinWait's members are not thread-safe. If multiple
/// threads must spin, each should use its own instance of SpinWait.
///
///
[HostProtection(Synchronization = true, ExternalThreading = true)]
public struct SpinWait
{
// These constants determine the frequency of yields versus spinning. The
// numbers may seem fairly arbitrary, but were derived with at least some
// thought in the design document. I fully expect they will need to change
// over time as we gain more experience with performance.
internal const int YIELD_THRESHOLD = 10; // When to switch over to a true yield.
internal const int SLEEP_0_EVERY_HOW_MANY_TIMES = 5; // After how many yields should we Sleep(0)?
internal const int SLEEP_1_EVERY_HOW_MANY_TIMES = 20; // After how many yields should we Sleep(1)?
// The number of times we've spun already.
private int m_count;
///
/// Gets the number of times
public int Count
{
get { return m_count; }
}
///
/// Gets whether the next call to
/// Whether the next call to
///
/// On a single-CPU machine,
public bool NextSpinWillYield
{
get { return m_count > YIELD_THRESHOLD || PlatformHelper.IsSingleProcessor; }
}
///
/// Performs a single spin.
///
///
/// This is typically called in a loop, and may change in behavior based on the number of times a
///
public void SpinOnce()
{
if (NextSpinWillYield)
{
//
// We must yield.
//
// We prefer to call Thread.Yield first, triggering a SwitchToThread. This
// unfortunately doesn't consider all runnable threads on all OS SKUs. In
// some cases, it may only consult the runnable threads whose ideal processor
// is the one currently executing code. Thus we oc----ionally issue a call to
// Sleep(0), which considers all runnable threads at equal priority. Even this
// is insufficient since we may be spin waiting for lower priority threads to
// execute; we therefore must call Sleep(1) once in a while too, which considers
// all runnable threads, regardless of ideal processor and priority, but may
// remove the thread from the scheduler's queue for 10+ms, if the system is
// configured to use the (default) coarse-grained system timer.
//
#if !FEATURE_PAL && !FEATURE_CORECLR // PAL doesn't support eventing, and we don't compile CDS providers for Coreclr
CdsSyncEtwBCLProvider.Log.SpinWait_NextSpinWillYield();
#endif
int yieldsSoFar = (m_count >= YIELD_THRESHOLD ? m_count - YIELD_THRESHOLD : m_count);
if ((yieldsSoFar % SLEEP_1_EVERY_HOW_MANY_TIMES) == (SLEEP_1_EVERY_HOW_MANY_TIMES - 1))
{
Thread.Sleep(1);
}
else if ((yieldsSoFar % SLEEP_0_EVERY_HOW_MANY_TIMES) == (SLEEP_0_EVERY_HOW_MANY_TIMES - 1))
{
Thread.Sleep(0);
}
else
{
#if PFX_LEGACY_3_5
Platform.Yield();
#else
Thread.Yield();
#endif
}
}
else
{
//
// Otherwise, we will spin.
//
// We do this using the CLR's SpinWait API, which is just a busy loop that
// issues YIELD/PAUSE instructions to ensure multi-threaded CPUs can react
// intelligently to avoid starving. (These are NOOPs on other CPUs.) We
// choose a number for the loop iteration count such that each successive
// call spins for longer, to reduce cache contention. We cap the total
// number of spins we are willing to tolerate to reduce delay to the caller,
// since we expect most callers will eventually block anyway.
//
Thread.SpinWait(4 << m_count);
}
// Finally, increment our spin counter.
m_count = (m_count == int.MaxValue ? YIELD_THRESHOLD : m_count + 1);
}
///
/// Resets the spin counter.
///
///
/// This makes
public void Reset()
{
m_count = 0;
}
#region Static Methods
#if !FEATURE_CORECLR
///
/// Spins until the specified condition is satisfied.
///
/// A delegate to be executed over and over until it returns true.
/// The
public static void SpinUntil(Func condition)
{
#if DEBUG
bool result =
#endif
SpinUntil(condition, Timeout.Infinite);
#if DEBUG
Contract.Assert(result);
#endif
}
///
/// Spins until the specified condition is satisfied or until the specified timeout is expired.
///
/// A delegate to be executed over and over until it returns true.
///
/// A True if the condition is satisfied within the timeout; otherwise, false
/// The
/// condition, TimeSpan timeout)
{
// Validate the timeout
Int64 totalMilliseconds = (Int64)timeout.TotalMilliseconds;
if (totalMilliseconds < -1 || totalMilliseconds > Int32.MaxValue)
{
throw new System.ArgumentOutOfRangeException(
"timeout", timeout, Environment.GetResourceString("SpinWait_SpinUntil_TimeoutWrong"));
}
// Call wait with the timeout milliseconds
return SpinUntil(condition, (int)timeout.TotalMilliseconds);
}
///
/// Spins until the specified condition is satisfied or until the specified timeout is expired.
///
/// A delegate to be executed over and over until it returns true.
/// The number of milliseconds to wait, or True if the condition is satisfied within the timeout; otherwise, false
/// The
/// condition, int millisecondsTimeout)
{
if (millisecondsTimeout < Timeout.Infinite)
{
throw new ArgumentOutOfRangeException(
"millisecondsTimeout", millisecondsTimeout, Environment.GetResourceString("SpinWait_SpinUntil_TimeoutWrong"));
}
if (condition == null)
{
throw new ArgumentNullException("condition", Environment.GetResourceString("SpinWait_SpinUntil_ArgumentNull"));
}
long startTicks = 0; ;
if (millisecondsTimeout != 0 && millisecondsTimeout != Timeout.Infinite)
{
startTicks = DateTime.UtcNow.Ticks;
}
SpinWait spinner = new SpinWait();
while (!condition())
{
if (millisecondsTimeout == 0)
{
return false;
}
spinner.SpinOnce();
if (millisecondsTimeout != Timeout.Infinite && spinner.NextSpinWillYield)
{
if (millisecondsTimeout <= (DateTime.UtcNow.Ticks - startTicks) / TimeSpan.TicksPerMillisecond)
{
return false;
}
}
}
return true;
}
#endif //!FEATURE_CORECLR
#endregion
}
///
/// A helper class to get the number of preocessors, it updates the numbers of processors every sampling interval
///
internal static class PlatformHelper
{
private const int PROCESSOR_COUNT_REFRESH_INTERVAL_MS = 30000; // How often to refresh the count, in milliseconds.
private static int s_processorCount = -1; // The last count seen.
private static DateTime s_nextProcessorCountRefreshTime = DateTime.MinValue; // The next time we'll refresh.
///
/// Gets the number of available processors
///
internal static int ProcessorCount
{
get
{
if (DateTime.UtcNow.CompareTo(s_nextProcessorCountRefreshTime) >= 0)
{
s_processorCount = Environment.ProcessorCount;
s_nextProcessorCountRefreshTime = DateTime.UtcNow.AddMilliseconds(PROCESSOR_COUNT_REFRESH_INTERVAL_MS);
}
Contract.Assert(s_processorCount > 0 && s_processorCount <= 64,
"Processor count not within the expected range (1 - 64).");
return s_processorCount;
}
}
///
/// Gets whether the current machine has only a single processor.
///
internal static bool IsSingleProcessor
{
get { return ProcessorCount == 1; }
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- IntSecurity.cs
- TabletDeviceInfo.cs
- IndexedEnumerable.cs
- DesignColumnCollection.cs
- mediaeventargs.cs
- UriTemplate.cs
- CodeExporter.cs
- DataGridViewComboBoxEditingControl.cs
- ConfigXmlComment.cs
- DataRelationCollection.cs
- ClientBuildManagerCallback.cs
- QueryOperationResponseOfT.cs
- NotifyCollectionChangedEventArgs.cs
- InstanceKeyNotReadyException.cs
- Assert.cs
- XmlILIndex.cs
- Int16AnimationUsingKeyFrames.cs
- BackgroundWorker.cs
- PrtCap_Base.cs
- ValueSerializerAttribute.cs
- WebPartVerbsEventArgs.cs
- LabelTarget.cs
- FixedFindEngine.cs
- MimeWriter.cs
- SymmetricKeyWrap.cs
- HandlerFactoryCache.cs
- GeneralTransformCollection.cs
- DesignTimeTemplateParser.cs
- PagesSection.cs
- XmlSchemaValidator.cs
- GradientBrush.cs
- DependencyPropertyAttribute.cs
- CoTaskMemHandle.cs
- PlanCompiler.cs
- ToolStripItemRenderEventArgs.cs
- ImageAutomationPeer.cs
- UnsafePeerToPeerMethods.cs
- SettingsSavedEventArgs.cs
- DataListItemCollection.cs
- OleCmdHelper.cs
- PixelFormat.cs
- GridViewCancelEditEventArgs.cs
- CodeAccessPermission.cs
- TextChange.cs
- Keywords.cs
- DateTimePicker.cs
- SecurityUtils.cs
- ConstraintStruct.cs
- BitmapSizeOptions.cs
- DataSourceSelectArguments.cs
- DataAccessor.cs
- IHttpResponseInternal.cs
- DbConnectionStringCommon.cs
- JoinTreeNode.cs
- DurableInstanceProvider.cs
- Matrix3DConverter.cs
- HtmlObjectListAdapter.cs
- COM2PictureConverter.cs
- FileClassifier.cs
- GroupBoxRenderer.cs
- IgnoreFileBuildProvider.cs
- QilPatternVisitor.cs
- COAUTHINFO.cs
- PriorityBindingExpression.cs
- _KerberosClient.cs
- BindingNavigator.cs
- ExceptionNotification.cs
- FlowDocumentFormatter.cs
- SkewTransform.cs
- NonClientArea.cs
- MenuScrollingVisibilityConverter.cs
- DateTimeValueSerializer.cs
- AssemblyAttributesGoHere.cs
- StreamUpgradeInitiator.cs
- MouseEvent.cs
- PagePropertiesChangingEventArgs.cs
- RuleConditionDialog.Designer.cs
- PathFigureCollection.cs
- XmlNodeComparer.cs
- EncoderFallback.cs
- MenuItemCollectionEditor.cs
- ToggleButtonAutomationPeer.cs
- DPTypeDescriptorContext.cs
- RawTextInputReport.cs
- PersonalizationEntry.cs
- ClaimTypeElementCollection.cs
- InsufficientMemoryException.cs
- DependencyObject.cs
- FileFormatException.cs
- UpdatableGenericsFeature.cs
- AssociativeAggregationOperator.cs
- WebBrowsableAttribute.cs
- MDIClient.cs
- CustomError.cs
- NotifyInputEventArgs.cs
- Style.cs
- TypeElementCollection.cs
- brushes.cs
- UidPropertyAttribute.cs
- BuildProvider.cs