Replace function exceptwith and unionwith with faster functions

neo.UnitTests/IO/Caching/UT_FIFOSet.cs

@@ -144,6 +144,24 @@ public void TestExceptWith()
             };
             set.ExceptWith(new UInt256[] { b, c });
             CollectionAssert.AreEqual(set.ToArray(), new UInt256[] { a });
+
+            set = new FIFOSet<UInt256>(10)
+            {
+                a,
+                b,
+                c
+            };
+            set.ExceptWith(new UInt256[] { a });
+            CollectionAssert.AreEqual(set.ToArray(), new UInt256[] { b, c });
+
+            set = new FIFOSet<UInt256>(10)
+            {
+                a,
+                b,
+                c
+            };
+            set.ExceptWith(new UInt256[] { c });
+            CollectionAssert.AreEqual(set.ToArray(), new UInt256[] { a, b });
         }
     }
 }

neo/Helper.cs

@@ -1,4 +1,5 @@
 using Microsoft.Extensions.Configuration;
+using Neo.IO.Caching;
 using Neo.Plugins;
 using System;
 using System.Collections.Generic;
@@ -54,6 +55,43 @@ internal static int GetLowestSetBit(this BigInteger i)
             throw new Exception();
         }
 
+        internal static void Remove<T>(this HashSet<T> set, HashSet<T> remove)
+        {
+            if (set.Count > 600_000)
+            {
+                set.ExceptWith(remove);
+            }
+            else
+            {
+                set.RemoveWhere(u => remove.Contains(u));
+            }
+        }
+
+        internal static void Remove<T>(this HashSet<T> set, FIFOSet<T> remove)
+            where T : IEquatable<T>
+        {
+            if (set.Count > 600_000)
+            {
+                set.ExceptWith(remove);
+            }
+            else
+            {
+                set.RemoveWhere(u => remove.Contains(u));
+            }
+        }
+
+        internal static void Remove<T, V>(this HashSet<T> set, IDictionary<T, V> remove)
+        {
+            if (set.Count > 600_000)
+            {
+                set.ExceptWith(remove.Keys);
+            }
+            else
+            {
+                set.RemoveWhere(u => remove.ContainsKey(u));
+            }
+        }
+
         internal static string GetVersion(this Assembly assembly)
         {
             CustomAttributeData attribute = assembly.CustomAttributes.FirstOrDefault(p => p.AttributeType == typeof(AssemblyInformationalVersionAttribute));

neo/IO/Caching/FIFOSet.cs

@@ -1,16 +1,30 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Collections.Specialized;
-using System.Linq;
 
 namespace Neo.IO.Caching
 {
     internal class FIFOSet<T> : IEnumerable<T> where T : IEquatable<T>
     {
+        class Entry
+        {
+            public readonly T Value;
+            public Entry Next;
+
+            public Entry(T current)
+            {
+                Value = current;
+            }
+        }
+
         private readonly int maxCapacity;
         private readonly int removeCount;
-        private readonly OrderedDictionary dictionary;
+
+        private int _count = 0;
+        private Entry _firstEntry = null;
+        private Entry _lastEntry = null;
+
+        public int Count => _count;
 
         public FIFOSet(int maxCapacity, decimal batchSize = 0.1m)
         {
@@ -19,45 +33,113 @@ public FIFOSet(int maxCapacity, decimal batchSize = 0.1m)
 
             this.maxCapacity = maxCapacity;
             this.removeCount = Math.Max((int)(maxCapacity * batchSize), 1);
-            this.dictionary = new OrderedDictionary(maxCapacity);
         }
 
         public bool Add(T item)
         {
-            if (dictionary.Contains(item)) return false;
-            if (dictionary.Count >= maxCapacity)
+            if (Contains(item)) return false;
+            if (Count >= maxCapacity)
             {
                 if (removeCount == maxCapacity)
                 {
-                    dictionary.Clear();
+                    _lastEntry = _firstEntry = null;
+                    _count = 0;
                 }
                 else
                 {
                     for (int i = 0; i < removeCount; i++)
-                        dictionary.RemoveAt(0);
+                    {
+                        RemoveFirst();
+                    }
                 }
             }
-            dictionary.Add(item, null);
+
+            if (_lastEntry == null)
+            {
+                _firstEntry = _lastEntry = new Entry(item);
+            }
+            else
+            {
+                _lastEntry = _lastEntry.Next = new Entry(item);
+            }
+
+            _count++;
             return true;
         }
 
+        private void RemoveFirst()
+        {
+            if (_firstEntry != null)
+            {
+                _firstEntry = _firstEntry.Next;
+                _count--;
+            }
+        }
+
         public bool Contains(T item)
         {
-            return dictionary.Contains(item);
+            var current = _firstEntry;
+
+            while (current != null)
+            {
+                if (current.Value.Equals(item)) return true;
+                current = current.Next;
+            }
+
+            return false;
         }
 
-        public void ExceptWith(IEnumerable<UInt256> hashes)
+        private void Remove(T item)
         {
-            foreach (var hash in hashes)
+            var prev = _firstEntry;
+            var current = _firstEntry;
+
+            while (current != null)
             {
-                dictionary.Remove(hash);
+                if (current.Value.Equals(item))
+                {
+                    if (prev == null)
+                    {
+                        // First entry
+                        _firstEntry = current.Next;
+                    }
+                    else
+                    {
+                        if (current == _firstEntry)
+                        {
+                            _firstEntry = prev.Next;
+                        }
+                        else
+                        {
+                            prev.Next = current.Next;
+                        }
+                    }
+                    _count--;
+                    return;
+                }
+
+                prev = current;
+                current = current.Next;
+            }
+        }
+
+        public void ExceptWith(IEnumerable<T> entries)
+        {
+            foreach (var entry in entries)
+            {
+                Remove(entry);
             }
         }
 
         public IEnumerator<T> GetEnumerator()
         {
-            var entries = dictionary.Keys.Cast<T>().ToArray();
-            foreach (var entry in entries) yield return entry;
+            var current = _firstEntry;
+
+            while (current != null)
+            {
+                yield return current.Value;
+                current = current.Next;
+            }
         }
 
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

neo/Network/P2P/TaskManager.cs

@@ -58,11 +58,11 @@ private void OnNewTasks(InvPayload payload)
                 return;
             }
             HashSet<UInt256> hashes = new HashSet<UInt256>(payload.Hashes);
-            hashes.ExceptWith(knownHashes);
+            hashes.Remove(knownHashes);
             if (payload.Type == InventoryType.Block)
                 session.AvailableTasks.UnionWith(hashes.Where(p => globalTasks.ContainsKey(p)));
 
-            hashes.ExceptWith(globalTasks.Keys);
+            hashes.Remove(globalTasks);
             if (hashes.Count == 0)
             {
                 RequestTasks(session);
@@ -203,7 +203,7 @@ private void RequestTasks(TaskSession session)
             if (session.HasTask) return;
             if (session.AvailableTasks.Count > 0)
             {
-                session.AvailableTasks.ExceptWith(knownHashes);
+                session.AvailableTasks.Remove(knownHashes);
                 session.AvailableTasks.RemoveWhere(p => Blockchain.Singleton.ContainsBlock(p));
                 HashSet<UInt256> hashes = new HashSet<UInt256>(session.AvailableTasks);
                 if (hashes.Count > 0)
@@ -213,7 +213,7 @@ private void RequestTasks(TaskSession session)
                         if (!IncrementGlobalTask(hash))
                             hashes.Remove(hash);
                     }
-                    session.AvailableTasks.ExceptWith(hashes);
+                    session.AvailableTasks.Remove(hashes);
                     foreach (UInt256 hash in hashes)
                         session.Tasks[hash] = DateTime.UtcNow;
                     foreach (InvPayload group in InvPayload.CreateGroup(InventoryType.Block, hashes.ToArray()))

neo/UIntBase.cs

@@ -2,6 +2,7 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Runtime.CompilerServices;
 
 namespace Neo
 {
@@ -61,7 +62,12 @@ public bool Equals(UIntBase other)
                 return true;
             if (data_bytes.Length != other.data_bytes.Length)
                 return false;
-            return data_bytes.SequenceEqual(other.data_bytes);
+
+            for (int x = data_bytes.Length - 1; x >= 0; x--)
+            {
+                if (data_bytes[x] != other.data_bytes[x]) return false;
+            }
+            return true;
         }
 
         /// <summary>
@@ -110,6 +116,7 @@ void ISerializable.Serialize(BinaryWriter writer)
         /// <summary>
         /// Method ToArray() returns the byte array data_bytes, which stores the little-endian unsigned int
         /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public byte[] ToArray()
         {
             return data_bytes;