Example #1
0
        private void TryFinish(ConcurrentArray <TKey, TValue> newArray)
        {
            var previousValue = Interlocked.CompareExchange(ref _state, CopyingFinished, CurrentlyCopying);

            if (previousValue == Aborted)
            {
                return;
            }

            _setNewArray(OldArray, newArray);
        }
Example #2
0
        public GrowArrayProcess(ConcurrentArray <TKey, TValue> oldArray,
                                int newArraySize,
                                ExchangeArray <TKey, TValue> setNewArray,
                                int maximumNumberOfItemsCopiedDuringHelp = DefaultMaximumNumberOfItemsCopiedDuringHelp)
        {
            oldArray.MustNotBeNull(nameof(oldArray));
            newArraySize.MustBeGreaterThan(oldArray.Capacity, nameof(newArraySize));
            setNewArray.MustNotBeNull(nameof(setNewArray));
            maximumNumberOfItemsCopiedDuringHelp.MustNotBeLessThan(0, nameof(maximumNumberOfItemsCopiedDuringHelp));

            OldArray     = oldArray;
            NewArraySize = newArraySize;
            _setNewArray = setNewArray;
            MaximumNumberOfItemsCopiedDuringHelp = maximumNumberOfItemsCopiedDuringHelp;
        }
Example #3
0
        private bool CopySingleEntry(ConcurrentArray <TKey, TValue> newArray)
        {
            if (ShouldContinueCopying == false)
            {
                return(false);
            }

            var currentIndex = Interlocked.Increment(ref _currentIndex);

            if (currentIndex >= OldArray.Capacity)
            {
                return(false);
            }

            var entry = OldArray.ReadVolatileFromIndex(currentIndex);

            if (entry != null)
            {
                // ReSharper disable once UnusedVariable
                var addInfo = newArray.TryAdd(entry);

#if CONCURRENT_LOGGING
                if (addInfo.OperationResult == AddResult.AddSuccessful)
                {
                    Log($"Copied entry {entry.Key} to array {newArray.Id}");
                }
                else if (addInfo.OperationResult == AddResult.ExistingEntryFound)
                {
                    Log($"Tried to copy entry {entry.Key} to array {newArray.Id}, but entry was already there.");
                }
                else
                {
                    Log($"Tried to copy entry {entry.Key} to array {newArray.Id}, but the target entry is full. THIS MUST NEVER HAPPEN AND MIGHT LEAD TO LOST ENTRIES.");
                }
#endif
            }

            var numberOfCopiedItems = Interlocked.Increment(ref _numberOfCopiedItems);
            if (numberOfCopiedItems < OldArray.Capacity)
            {
                return(true);
            }

            TryFinish(newArray);
            return(false);
        }
 public GrowArrayProcess <TKey, TValue> CreateGrowArrayProcess(ConcurrentArray <TKey, TValue> oldArray, int newArraySize, ExchangeArray <TKey, TValue> setNewArray)
 {
     return(new GrowArrayProcess <TKey, TValue>(oldArray, newArraySize, setNewArray, _maximumNumberOfItemsCopiedDuringHelp));
 }