Optimize LSRA (#2563)

* Optimize `TryAllocateRegWithtoutSpill` a bit

* Add a fast path for when all registers are live.
* Do not query `GetOverlapPosition` if the register is already in use
  (i.e: free position is 0).

* Do not allocate child split list if not parent

* Turn `LiveRange` into a reference struct

`LiveRange` is now a reference wrapping struct like `Operand` and
`Operation`.

It has also been changed into a singly linked-list. In micro-benchmarks
traversing the linked-list was faster than binary search on `List<T>`.
Even for quite large input sizes (e.g: 1,000,000), surprisingly.

Could be because the code gen for traversing the linked-list is much
much cleaner and there is no virtual dispatch happening when checking if
intervals overlaps.

* Turn `LiveInterval` into an iterator

The LSRA allocates in forward order and never inspect previous
`LiveInterval` once they are expired. Something similar can be done for
the `LiveRange`s within the `LiveInterval`s themselves.

The `LiveInterval` is turned into a iterator which expires `LiveRange`
within it. The iterator is moved forward along with interval walking
code, i.e: AllocateInterval(context, interval, cIndex).

* Remove `LinearScanAllocator.Sources`

Local methods are less susceptible to do allocations than lambdas.

* Optimize `GetOverlapPosition(interval)` a bit

Time complexity should be in O(n+m) instead of O(nm) now.

* Optimize `NumberLocals` a bit

Use the same idea as in `HybridAllocator` to store the visited state
in the MSB of the Operand's value instead of using a `HashSet<T>`.

* Optimize `InsertSplitCopies` a bit

Avoid allocating a redundant `CopyResolver`.

* Optimize `InsertSplitCopiesAtEdges` a bit

Avoid redundant allocations of `CopyResolver`.

* Use stack allocation for `freePositions`

Avoid redundant computations.

* Add `UseList`

Replace `SortedIntegerList` with an even more specialized data
structure. It allocates memory on the arena allocators and does not
require copying use positions when splitting it.

* Turn `LiveInterval` into a reference struct

`LiveInterval` is now a reference wrapping struct like `Operand` and
`Operation`.

The rationale behind turning this in a reference wrapping struct is
because a `LiveInterval` is associated with each local variable, and
these intervals may themselves be split further. I've seen translations
having up to 8000 local variables.

To make the `LiveInterval` unmanaged, a new data structure called
`LiveIntervalList` was added to store child splits. This differs from
`SortedList<,>` because it can contain intervals with the same start
position.

Really wished we got some more of C++ template in C#. :^(

* Optimize `GetChildSplit` a bit

No need to inspect the remaining ranges if we've reached a range which
starts after position, since the split list is ordered.

* Optimize `CopyResolver` a bit

Lazily allocate the fill, spill and parallel copy structures since most
of the time only one of them is needed.

* Optimize `BitMap.Enumerator` a bit

Marking `MoveNext` as `AggressiveInlining` allows RyuJIT to promote the
`Enumerator` struct into registers completely, reducing load/store code
a lot since it does not have to store the struct on the stack for ABI
purposes.

* Use stack allocation for `use/blockedPositions`

* Optimize `AllocateWithSpill` a bit

* Address feedback

* Make `LiveInterval.AddRange(,)` more conservative

Produces no diff against master, but just for good measure.

1 files changed, 55 insertions, 12 deletions

diff --git a/ARMeilleure/CodeGen/RegisterAllocators/LiveRange.cs b/ARMeilleure/CodeGen/RegisterAllocators/LiveRange.cs
index b5faeffd..e38b5190 100644
--- a/ARMeilleure/CodeGen/RegisterAllocators/LiveRange.cs
+++ b/ARMeilleure/CodeGen/RegisterAllocators/LiveRange.cs
@@ -2,30 +2,73 @@ using System;
 
 namespace ARMeilleure.CodeGen.RegisterAllocators
 {
-    struct LiveRange : IComparable<LiveRange>
+    unsafe readonly struct LiveRange : IEquatable<LiveRange>
     {
-        public int Start { get; }
-        public int End   { get; }
+        private struct Data
+        {
+            public int Start;
+            public int End;
+            public LiveRange Next;
+        }
+
+        private readonly Data* _data;
+
+        public ref int Start => ref _data->Start;
+        public ref int End => ref _data->End;
+        public ref LiveRange Next => ref _data->Next;
 
-        public LiveRange(int start, int end)
+        public LiveRange(int start, int end, LiveRange next = default)
         {
+            _data = Allocators.LiveRanges.Allocate<Data>();
+
             Start = start;
-            End   = end;
+            End = end;
+            Next = next;
         }
 
-        public int CompareTo(LiveRange other)
+        public bool Overlaps(int start, int end)
         {
-            if (Start < other.End && other.Start < End)
-            {
-                return 0;
-            }
+            return Start < end && start < End;
+        }
 
-            return Start.CompareTo(other.Start);
+        public bool Overlaps(LiveRange range)
+        {
+            return Start < range.End && range.Start < End;
+        }
+
+        public bool Overlaps(int position)
+        {
+            return position >= Start && position < End;
+        }
+
+        public bool Equals(LiveRange range)
+        {
+            return range._data == _data;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is LiveRange range && Equals(range);
+        }
+
+        public static bool operator ==(LiveRange a, LiveRange b)
+        {
+            return a.Equals(b);
+        }
+
+        public static bool operator !=(LiveRange a, LiveRange b)
+        {
+            return !a.Equals(b);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine((IntPtr)_data);
         }
 
         public override string ToString()
         {
-            return $"[{Start}, {End}[";
+            return $"[{Start}, {End})";
         }
     }
 }
\ No newline at end of file