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); }