Optimize WeakCache

Author: AlexUstinov

Orm/Xtensive.Orm/Caching/WeakCache.cs

@@ -8,6 +8,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.Runtime.InteropServices;
 using System.Security;
 using Xtensive.Core;
@@ -34,7 +35,6 @@ public class WeakCache<TKey, TItem> :
     /// </summary>
     protected const int NoGcCount = 1024;
 
-    private const int GcOperationCost = 2;
     private readonly bool trackResurrection;
     private readonly Converter<TItem, TKey> keyExtractor;
     private Dictionary<TKey, GCHandle> items;
@@ -46,7 +46,7 @@ public class WeakCache<TKey, TItem> :
     public Converter<TItem, TKey> KeyExtractor
     {
       [DebuggerStepThrough]
-      get { return keyExtractor; }
+      get => keyExtractor;
     }
 
     /// <summary>
@@ -55,40 +55,32 @@ public Converter<TItem, TKey> KeyExtractor
     public bool TrackResurrection
     {
       [DebuggerStepThrough]
-      get { return trackResurrection; }
+      get => trackResurrection;
     }
 
     /// <inheritdoc/>
     public int Count
     {
       [DebuggerStepThrough]
-      get { return items.Count; }
+      get => items?.Count ?? 0;
     }
 
     #endregion
 
     /// <inheritdoc/>
-    public TItem this[TKey key, bool markAsHit]
-    {
-      get {
-        TItem item;
-        if (TryGetItem(key, markAsHit, out item))
-          return item;
-        else
-          return null;
-      }
-    }
+    public TItem this[TKey key, bool markAsHit] => TryGetItem(key, markAsHit, out var item) ? item : null;
 
     /// <inheritdoc/>
     [SecuritySafeCritical]
     public virtual bool TryGetItem(TKey key, bool markAsHit, out TItem item)
     {
       RegisterOperation(1);
-      GCHandle cached;
-      if (items.TryGetValue(key, out cached)) {
-        item = (TItem) cached.Target;
-        if (item != null)
+      if (items != null && items.TryGetValue(key, out var cached)) {
+        item = ExtractTarget(cached);
+        if (item != null) {
           return true;
+        }
+
         items.Remove(key);
         cached.Free();
         return false;
@@ -98,113 +90,105 @@ public virtual bool TryGetItem(TKey key, bool markAsHit, out TItem item)
     }
 
     /// <inheritdoc/>
-    public bool Contains(TItem item)
-    {
-      return ContainsKey(KeyExtractor(item));
-    }
+    public bool Contains(TItem item) => ContainsKey(KeyExtractor(item));
 
     /// <inheritdoc/>
-    public bool ContainsKey(TKey key)
-    {
-      TItem item;
-      return TryGetItem(key, false, out item);
-    }
+    public bool ContainsKey(TKey key) => TryGetItem(key, false, out var _);
 
     #region Modification methods: Add, Remove, Clear
 
     /// <inheritdoc/>
-    public void Add(TItem item)
-    {
-      Add(item, true);
-    }
+    public void Add(TItem item) => Add(item, true);
+
+    private static Dictionary<TKey, GCHandle> CreateDictionary() => new Dictionary<TKey, GCHandle>();
 
     /// <inheritdoc/>
     [SecuritySafeCritical]
     public virtual TItem Add(TItem item, bool replaceIfExists)
     {
-      ArgumentValidator.EnsureArgumentNotNull(item, "item");
+      ArgumentValidator.EnsureArgumentNotNull(item, nameof(item));
       RegisterOperation(2);
       var key = KeyExtractor(item);
-      GCHandle cached;
-      if (items.TryGetValue(key, out cached)) {
-        if (!replaceIfExists) {
-          var cachedItem = (TItem) cached.Target;
-          if (cachedItem != null)
-            return cachedItem;
+      if (items == null) {
+        items = CreateDictionary();
+      }
+      else if (replaceIfExists) {
+        if (items.Remove(key, out var cached)) {
+          cached.Free();
+        }
+      }
+      else if (items.TryGetValue(key, out var cached)) {
+        if (ExtractTarget(cached) is TItem cachedItem) {
+          return cachedItem;
         }
         items.Remove(key);
         cached.Free();
       }
-      items[key] = GCHandle.Alloc(item,
-        trackResurrection ? GCHandleType.WeakTrackResurrection : GCHandleType.Weak);
+      items[key] = GCHandle.Alloc(item, trackResurrection ? GCHandleType.WeakTrackResurrection : GCHandleType.Weak);
       return item;
     }
 
     /// <inheritdoc/>
     public void Remove(TItem item)
     {
-      ArgumentValidator.EnsureArgumentNotNull(item, "item");
+      ArgumentValidator.EnsureArgumentNotNull(item, nameof(item));
       RemoveKey(KeyExtractor(item));
     }
 
     /// <inheritdoc/>
     [SecuritySafeCritical]
     public virtual void RemoveKey(TKey key)
     {
-      GCHandle cached;
-      if (items.TryGetValue(key, out cached)) {
-        items.Remove(key);
+      if (items != null && items.Remove(key, out var cached) == true) {
         cached.Free();
       }
     }
 
     /// <inheritdoc/>
-    public void RemoveKey(TKey key, bool removeCompletely)
-    {
-      RemoveKey(key);
-    }
+    public void RemoveKey(TKey key, bool removeCompletely) => RemoveKey(key);
 
     /// <inheritdoc/>
     [SecuritySafeCritical]
     public virtual void Clear()
     {
+      if (items == null) {
+        return;
+      }
       try {
-        foreach (var pair in items)
+        foreach (var pair in items) {
           try {
             pair.Value.Free();
           }
           catch { }
+        }
       }
       finally {
-        items = new Dictionary<TKey, GCHandle>();
+        items = null;
         time = 0;
       }
     }
 
     /// <inheritdoc/>
-    public void Invalidate()
-    {
-      Clear();
-    }
+    public void Invalidate() => Clear();
 
     /// <inheritdoc/>
     [SecuritySafeCritical]
     public virtual void CollectGarbage()
     {
-      int count = items.Count;
-      if (count <= NoGcCount)
+      var count = items?.Count ?? 0;
+      if (count <= NoGcCount) {
         return;
+      }
 
       Exception error = null;
       int removedCount = 0;
       try {
         // Filtering
-        var newItems = new Dictionary<TKey, GCHandle>();
-        foreach (var pair in items) {
-          var cached = pair.Value;
+        var newItems = CreateDictionary();
+        foreach (var (key, cached) in items) {
           var item = cached.Target;
           if (item != null)
-            newItems.Add(pair.Key, cached);
+            newItems.Add(key, cached);
           else
             cached.Free();
         }
@@ -233,26 +217,19 @@ public virtual void CollectGarbage()
 
     /// <inheritdoc/>
     [DebuggerStepThrough]
-    IEnumerator IEnumerable.GetEnumerator()
-    {
-      return GetEnumerator();
-    }
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
     /// <inheritdoc/>
     public virtual IEnumerator<TItem> GetEnumerator()
     {
-      foreach (var pair in items) {
-        var item = ExtractTarget(pair.Value);
-        if (item != null)
+      foreach (var pair in items ?? Enumerable.Empty<KeyValuePair<TKey, GCHandle>>()) {
+        if (ExtractTarget(pair.Value) is TItem item)
           yield return item;
       }
     }
 
     [SecuritySafeCritical]
-    private static TItem ExtractTarget(GCHandle handle)
-    {
-      return (TItem) handle.Target;
-    }
+    private static TItem ExtractTarget(GCHandle handle) => (TItem) handle.Target;
 
     #endregion
 
@@ -261,11 +238,10 @@ private static TItem ExtractTarget(GCHandle handle)
     private void RegisterOperation(int weight)
     {
       time += weight;
-      var count = items.Count;
-      if (count <= NoGcCount)
-        return;
-      if (time > ((count << 1) + count))
+      var count = items?.Count ?? 0;
+      if (count > NoGcCount && time > (count << 1) + count) {
         CollectGarbage();
+      }
     }
 
     #endregion
@@ -283,7 +259,6 @@ public WeakCache(bool trackResurrection, Converter<TItem, TKey> keyExtractor)
       ArgumentValidator.EnsureArgumentNotNull(keyExtractor, "keyExtractor");
       this.trackResurrection = trackResurrection;
       this.keyExtractor = keyExtractor;
-      items = new Dictionary<TKey, GCHandle>(1024);
     }
 
     // Dispose pattern
@@ -294,14 +269,7 @@ public WeakCache(bool trackResurrection, Converter<TItem, TKey> keyExtractor)
     [SecuritySafeCritical]
     protected virtual void Dispose(bool disposing)
     {
-      if (items != null) {
-        try {
-          Clear();
-        }
-        finally {
-          items = null;
-        }
-      }
+      Clear();
     }
 
     /// <summary>

Orm/Xtensive.Orm/Core/Pair{T}.cs

@@ -18,7 +18,7 @@ namespace Xtensive.Core
   /// <typeparam name="T">The type of both stored values.</typeparam>
   [Serializable]
   [DebuggerDisplay("{First}, {Second}")]
-  public struct Pair<T> : 
+  public readonly struct Pair<T> :
     IEquatable<Pair<T>>,
     IComparable<Pair<T>>
   {

Orm/Xtensive.Orm/Orm/Internals/FieldAccessors/EntityFieldAccessor.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2008-2020 Xtensive LLC.
+// Copyright (C) 2008-2021 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Alexey Gamzov
@@ -54,4 +54,4 @@ public override T GetValue(Persistent obj)
       return (T) (object) obj.Session.Query.SingleOrDefault(key);
     }
   }
-}
+}

Orm/Xtensive.Orm/Orm/Internals/Prefetch/GraphContainer.cs

@@ -139,8 +139,9 @@ private static bool AreAllForeignKeyColumnsLoaded(EntityState state, FieldInfo f
         return false;
       var tuple = state.Tuple;
       var fieldStateMap = tuple.GetFieldStateMap(TupleFieldState.Available);
-      for (var i = 0; i < field.MappingInfo.Length; i++)
-        if (!fieldStateMap[field.MappingInfo.Offset + i])
+      var fieldMappingInfo = field.MappingInfo;
+      for (var i = 0; i < fieldMappingInfo.Length; i++)
+        if (!fieldStateMap[fieldMappingInfo.Offset + i])
           return false;
       return true;
     }

Orm/Xtensive.Orm/Orm/Internals/Prefetch/PrefetchHelper.cs

@@ -1,6 +1,6 @@
-// Copyright (C) 2003-2010 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2009-2021 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
 // Created by: Alexander Nikolaev
 // Created:    2009.10.22
 
@@ -61,7 +61,6 @@ public static bool AddColumns(IEnumerable<ColumnInfo> candidateColumns,
       SortedDictionary<int, ColumnInfo> columns, TypeInfo type)
     {
       var result = false;
-      var primaryIndex = type.Indexes.PrimaryIndex;
       foreach (var column in candidateColumns) {
         result = true;
         if (type.IsInterface == column.Field.DeclaringType.IsInterface)

Orm/Xtensive.Orm/Orm/Linq/Expressions/EntityFieldExpression.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2009-2020 Xtensive LLC.
+// Copyright (C) 2009-2021 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Alexis Kochetov
@@ -165,7 +165,7 @@ public static EntityFieldExpression CreateEntityField(FieldInfo entityField, int
       var entityType = entityField.ValueType;
       var persistentType = entityField.ReflectedType.Model.Types[entityType];
 
-      ref var mappingInfo = ref entityField.mappingInfo;
+      var mappingInfo = entityField.MappingInfo;
       var mapping = new Segment<int>(mappingInfo.Offset + offset, mappingInfo.Length);
       var keyFields = persistentType.Key.Fields;
       var keyExpression = KeyExpression.Create(persistentType, offset + mappingInfo.Offset);

Orm/Xtensive.Orm/Orm/Linq/Expressions/FieldExpression.cs

@@ -126,7 +126,7 @@ public static FieldExpression CreateField(FieldInfo field, int offset)
         throw new ArgumentException(string.Format(Strings.ExFieldXIsNotPrimitive, field.Name), nameof(field));
       }
 
-      ref var mappingInfo = ref field.mappingInfo;
+      var mappingInfo = field.MappingInfo;
       var mapping = new Segment<int>(mappingInfo.Offset + offset, mappingInfo.Length);
       return new FieldExpression(ExtendedExpressionType.Field, field, mapping, null, false);
     }

Orm/Xtensive.Orm/Orm/Linq/Expressions/StructureFieldExpression.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2009-2020 Xtensive LLC.
+// Copyright (C) 2009-2021 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Alexis Kochetov
@@ -176,12 +176,13 @@ public static StructureFieldExpression CreateStructure(FieldInfo structureField,
       }
 
       var persistentType = structureField.ReflectedType.Model.Types[structureField.ValueType];
-      var mapping = new Segment<int>(offset + structureField.MappingInfo.Offset, structureField.MappingInfo.Length);
+      var fieldMappingInfo = structureField.MappingInfo;
+      var mapping = new Segment<int>(offset + fieldMappingInfo.Offset, fieldMappingInfo.Length);
       var result = new StructureFieldExpression(persistentType, structureField, mapping, null, false);
       var processedFields = new List<PersistentFieldExpression>(persistentType.Fields.Count);
       foreach (var field in persistentType.Fields) {
         // Do not convert to LINQ. We want to avoid a closure creation here.
-        processedFields.Add(BuildNestedFieldExpression(field, offset + structureField.MappingInfo.Offset));
+        processedFields.Add(BuildNestedFieldExpression(field, offset + fieldMappingInfo.Offset));
       }
 
       result.Fields = processedFields;