// Token: 0x06003F30 RID: 16176 RVA: 0x000EB7EC File Offset: 0x000E99EC
internal static void Break(long iteration, ParallelLoopStateFlags64 pflags)
{
int pls_NONE = ParallelLoopStateFlags.PLS_NONE;
if (pflags.AtomicLoopStateUpdate(ParallelLoopStateFlags.PLS_BROKEN, ParallelLoopStateFlags.PLS_STOPPED | ParallelLoopStateFlags.PLS_EXCEPTIONAL | ParallelLoopStateFlags.PLS_CANCELED, ref pls_NONE))
{
long lowestBreakIteration = pflags.LowestBreakIteration;
if (iteration < lowestBreakIteration)
{
SpinWait spinWait = default(SpinWait);
while (Interlocked.CompareExchange(ref pflags.m_lowestBreakIteration, iteration, lowestBreakIteration) != lowestBreakIteration)
{
spinWait.SpinOnce();
lowestBreakIteration = pflags.LowestBreakIteration;
if (iteration > lowestBreakIteration)
{
break;
}
}
}
return;
}
if ((pls_NONE & ParallelLoopStateFlags.PLS_STOPPED) != 0)
{
throw new InvalidOperationException(Environment.GetResourceString("ParallelState_Break_InvalidOperationException_BreakAfterStop"));
}
}
internal static void Break(long iteration, ParallelLoopStateFlags64 pflags)
{
int oldState = ParallelLoopStateFlags.PLS_NONE;
if (!pflags.AtomicLoopStateUpdate(ParallelLoopStateFlags.PLS_BROKEN, (ParallelLoopStateFlags.PLS_STOPPED | ParallelLoopStateFlags.PLS_EXCEPTIONAL) | ParallelLoopStateFlags.PLS_CANCELED, ref oldState))
{
if ((oldState & ParallelLoopStateFlags.PLS_STOPPED) != 0)
{
throw new InvalidOperationException(Environment.GetResourceString("ParallelState_Break_InvalidOperationException_BreakAfterStop"));
}
}
else
{
long lowestBreakIteration = pflags.LowestBreakIteration;
if (iteration < lowestBreakIteration)
{
SpinWait wait = new SpinWait();
while (Interlocked.CompareExchange(ref pflags.m_lowestBreakIteration, iteration, lowestBreakIteration) != lowestBreakIteration)
{
wait.SpinOnce();
lowestBreakIteration = pflags.LowestBreakIteration;
if (iteration > lowestBreakIteration)
{
return;
}
}
}
}
}
// Helper method to avoid repeating Break() logic between ParallelState64 and ParallelState64<TLocal>
internal static void Break(long iteration, ParallelLoopStateFlags64 parallelFlags)
{
// Attempt to change state from "not stopped or broken or canceled or exceptional" to "broken".
if
(
!parallelFlags.AtomicLoopStateUpdate
(
ParallelLoopStateFlags.ParallelLoopStateBroken,
ParallelLoopStateFlags.ParallelLoopStateStopped | ParallelLoopStateFlags.ParallelLoopStateExceptional | ParallelLoopStateFlags.ParallelLoopStateCanceled,
out var oldValue
)
)
{
// If we were already stopped, we have a problem
if ((oldValue & ParallelLoopStateFlags.ParallelLoopStateStopped) != 0)
{
throw new InvalidOperationException
(
"SR.ParallelState_Break_InvalidOperationException_BreakAfterStop"
);
}
// Apparently we previously got cancelled or became exceptional. No action necessary
return;
}
// replace shared LowestBreakIteration with CurrentIteration, but only if CurrentIteration
// is less than LowestBreakIteration.
var lowestBreakIteration = parallelFlags.LowestBreakIteration;
if (iteration >= lowestBreakIteration)
{
return;
}
var wait = new SpinWait();
while (Interlocked.CompareExchange(ref parallelFlags._lowestBreakIteration, iteration, lowestBreakIteration) != lowestBreakIteration)
{
wait.SpinOnce();
lowestBreakIteration = parallelFlags.LowestBreakIteration;
if (iteration > lowestBreakIteration)
{
break;
}
}
}
// Helper method to avoid repeating Break() logic between ParallelState64 and ParallelState64<TLocal>
internal static void Break(long iteration, ParallelLoopStateFlags64 pflags)
{
int oldValue = ParallelLoopStateFlags.PLS_NONE;
// Attempt to change state from "not stopped or broken or canceled or exceptional" to "broken".
if (!pflags.AtomicLoopStateUpdate(ParallelLoopStateFlags.PLS_BROKEN,
ParallelLoopStateFlags.PLS_STOPPED | ParallelLoopStateFlags.PLS_EXCEPTIONAL | ParallelLoopStateFlags.PLS_CANCELED,
ref oldValue))
{
// If we were already stopped, we have a problem
if ((oldValue & ParallelLoopStateFlags.PLS_STOPPED) != 0)
{
throw new InvalidOperationException(
Environment.GetResourceString("ParallelState_Break_InvalidOperationException_BreakAfterStop"));
}
else
{
// Apparently we previously got cancelled or became exceptional. No action necessary
return;
}
}
// replace shared LowestBreakIteration with CurrentIteration, but only if CurrentIteration
// is less than LowestBreakIteration.
long oldLBI = pflags.LowestBreakIteration;
if (iteration < oldLBI)
{
SpinWait wait = new SpinWait();
while (Interlocked.CompareExchange(
ref pflags.m_lowestBreakIteration,
iteration,
oldLBI) != oldLBI)
{
wait.SpinOnce();
oldLBI = pflags.LowestBreakIteration;
if (iteration > oldLBI)
{
break;
}
}
}
}
// Helper method to avoid repeating Break() logic between ParallelState64 and ParallelState64<TLocal>
internal static void Break(long iteration, ParallelLoopStateFlags64 pflags)
{
int oldValue = ParallelLoopStateFlags.ParallelLoopStateNone;
// Attempt to change state from "not stopped or broken or canceled or exceptional" to "broken".
if (!pflags.AtomicLoopStateUpdate(ParallelLoopStateFlags.ParallelLoopStateBroken,
ParallelLoopStateFlags.ParallelLoopStateStopped | ParallelLoopStateFlags.ParallelLoopStateExceptional | ParallelLoopStateFlags.ParallelLoopStateCanceled,
ref oldValue))
{
// If we were already stopped, we have a problem
if ((oldValue & ParallelLoopStateFlags.ParallelLoopStateStopped) != 0)
{
throw new InvalidOperationException(
SR.ParallelState_Break_InvalidOperationException_BreakAfterStop);
}
else
{
// Apparently we previously got cancelled or became exceptional. No action necessary
return;
}
}
// replace shared LowestBreakIteration with CurrentIteration, but only if CurrentIteration
// is less than LowestBreakIteration.
long oldLBI = pflags.LowestBreakIteration;
if (iteration < oldLBI)
{
SpinWait wait = default;
while (Interlocked.CompareExchange(
ref pflags._lowestBreakIteration,
iteration,
oldLBI) != oldLBI)
{
wait.SpinOnce();
oldLBI = pflags.LowestBreakIteration;
if (iteration > oldLBI)
{
break;
}
}
}
}
/// <summary>
/// Internal constructor to ensure an instance isn't created by users.
/// </summary>
/// <param name="sharedParallelStateFlags">A flag shared among all threads participating
/// in the execution of a certain loop.</param>
internal ParallelLoopState64(ParallelLoopStateFlags64 sharedParallelStateFlags)
: base(sharedParallelStateFlags)
{
m_sharedParallelStateFlags = sharedParallelStateFlags;
}
/// <summary>
/// Internal constructor to ensure an instance isn't created by users.
/// </summary>
/// <param name="sharedParallelStateFlags">A flag shared among all threads participating
/// in the execution of a certain loop.</param>
internal ParallelLoopState64(ParallelLoopStateFlags64 sharedParallelStateFlags)
: base(sharedParallelStateFlags)
{
m_sharedParallelStateFlags = sharedParallelStateFlags;
}
// Helper method to avoid repeating Break() logic between ParallelState64 and ParallelState64<TLocal>
internal static void Break(long iteration, ParallelLoopStateFlags64 pflags)
{
int oldValue = ParallelLoopStateFlags.PLS_NONE;
// Attempt to change state from "not stopped or broken or canceled or exceptional" to "broken".
if (!pflags.AtomicLoopStateUpdate(ParallelLoopStateFlags.PLS_BROKEN,
ParallelLoopStateFlags.PLS_STOPPED | ParallelLoopStateFlags.PLS_EXCEPTIONAL | ParallelLoopStateFlags.PLS_CANCELED,
ref oldValue))
{
// If we were already stopped, we have a problem
if ((oldValue & ParallelLoopStateFlags.PLS_STOPPED) != 0)
{
throw new InvalidOperationException(
Environment.GetResourceString("ParallelState_Break_InvalidOperationException_BreakAfterStop"));
}
else
{
// Apparently we previously got cancelled or became exceptional. No action necessary
return;
}
}
// replace shared LowestBreakIteration with CurrentIteration, but only if CurrentIteration
// is less than LowestBreakIteration.
long oldLBI = pflags.LowestBreakIteration;
if (iteration < oldLBI)
{
SpinWait wait = new SpinWait();
while (Interlocked.CompareExchange(
ref pflags.m_lowestBreakIteration,
iteration,
oldLBI) != oldLBI)
{
wait.SpinOnce();
oldLBI = pflags.LowestBreakIteration;
if (iteration > oldLBI) break;
}
}
}