public void Can_set_value()
{
var array = new AtomicIntArray(1);
array.SetValue(0, 1);
array.GetValue(0).Should().Be(1);
}
public void Can_create_from_readonly_list()
{
var list = new[] { 1, 2, 3 };
var array = new AtomicIntArray(list);
list.Length.Should().Be(array.Length);
}
public void Can_set_without_volatile_read_fence_and_ordering()
{
var array = new AtomicIntArray(1);
array.NonVolatileSetValue(0, 1);
array.GetValue(0).Should().Be(1);
}
public void int_array_is_correct_with_concurrency(int total, int threadCount)
{
var array = new AtomicIntArray(100);
var thread = new List <Thread>();
for (var i = 0; i < threadCount; i++)
{
thread.Add(new Thread(() =>
{
int index = 0;
for (long j = 0; j < total; j++)
{
array.Increment(index++);
if (index == array.Length)
{
index = 0;
}
}
}));
}
thread.ForEach(t => t.Start());
thread.ForEach(t => t.Join());
long sum = 0;
for (int i = 0; i < array.Length; i++)
{
sum += array.GetValue(i);
}
sum.Should().Be(total * threadCount);
}
public void Can_get_and_increment_by_value()
{
var array = new AtomicIntArray(1);
var value = array.GetAndIncrement(0, 2);
value.Should().Be(0);
array.GetValue(0).Should().Be(2);
}
public void Can_get_and_decrement()
{
var array = new AtomicIntArray(1);
var value = array.GetAndDecrement(0);
value.Should().Be(0);
array.GetValue(0).Should().Be(-1);
}
public void Can_get_and_add()
{
var array = new AtomicIntArray(1);
var value = array.GetAndAdd(0, 2);
value.Should().Be(0);
array.GetValue(0).Should().Be(2);
}
public void Can_decrement_by_value()
{
var array = new AtomicIntArray(1);
array.Increment(0, 10);
array.Decrement(0, 2);
array.GetValue(0).Should().Be(8);
}
public void Can_decrement()
{
var list = new[] { 1, 2, 3 };
var array = new AtomicIntArray(list);
array.Decrement(0);
array.GetValue(0).Should().Be(0);
}
public void Throws_when_lenght_smaller_than_zero()
{
Action action = () =>
{
var unused = new AtomicIntArray(-2);
};
action.Should().Throw <ArgumentException>();
}
public void Can_get_without_volatile_read_fence_and_ordering()
{
var array = new AtomicIntArray(1);
array.Add(0, 1);
var val = array.NonVolatileGetValue(0);
val.Should().Be(1);
}
public void Can_add_value_to_item()
{
var list = new[] { 1, 2, 3 };
var array = new AtomicIntArray(list);
array.Add(0, 4);
array.GetValue(0).Should().Be(5);
}
public void can_increment_value()
{
var list = new[] { 1, 2, 3 };
var array = new AtomicIntArray(list);
array.Increment(0);
array.GetValue(0).Should().Be(2);
}
public void Can_get_estimated_bytes()
{
var list = new[] { 1, 2, 3 };
var expected = (list.Length * sizeof(int)) + 16 + IntPtr.Size;
var array = new AtomicIntArray(list);
var estimate = AtomicIntArray.GetEstimatedFootprintInBytes(array);
estimate.Should().Be(expected);
}
public void Can_get_and_reset()
{
var array = new AtomicIntArray(1);
array.Increment(0);
var value = array.GetAndReset(0);
value.Should().Be(1);
array.Length.Should().Be(1);
array.GetValue(0).Should().Be(0);
}
/// <summary>
/// Construct a <see cref="IntConcurrentHistogram"/> given the lowest and highest values to be tracked and a number of significant decimal digits.
/// </summary>
/// <param name="instanceId">An identifier for this instance.</param>
/// <param name="lowestTrackableValue">The lowest value that can be tracked (distinguished from 0) by the histogram.
/// Must be a positive integer that is >= 1.
/// May be internally rounded down to nearest power of 2.
/// </param>
/// <param name="highestTrackableValue">The highest value to be tracked by the histogram.
/// Must be a positive integer that is >= (2 * lowestTrackableValue).
/// </param>
/// <param name="numberOfSignificantValueDigits">
/// The number of significant decimal digits to which the histogram will maintain value resolution and separation.
/// Must be a non-negative integer between 0 and 5.
/// </param>
/// <remarks>
/// Providing a lowestTrackableValue is useful in situations where the units used for the histogram's values are much
/// smaller that the minimal accuracy required.
/// For example when tracking time values stated in ticks (100 nanoseconds), where the minimal accuracy required is a
/// microsecond, the proper value for lowestTrackableValue would be 10.
/// </remarks>
public IntConcurrentHistogram(long instanceId, long lowestTrackableValue, long highestTrackableValue, int numberOfSignificantValueDigits)
: base(instanceId, lowestTrackableValue, highestTrackableValue, numberOfSignificantValueDigits)
{
_counts = new AtomicIntArray(CountsArrayLength);
}
