[WIP] Use UnsafeMutablePointer for storage of CacheLookupTable

Author: rintaro

Sources/SwiftSyntax/CacheLookupTable.swift

@@ -35,24 +35,29 @@ private struct WeakReference<T: AnyObject>: ExpressibleByNilLiteral {
 /// References are stored in a hash table with simple open adressing. Because
 /// of weak reference, unlike normal open addressing, erased bucket are simply
 /// turned into 'nil'.
-struct CacheLookupTable<T: Identifiable & AnyObject> {
-
-  private typealias Buffer = Array<WeakReference<T>>
+class CacheLookupTable<T: Identifiable & AnyObject> {
 
   /// Storage for the hash table.
-  private var buckets: Buffer
+  private var buckets: UnsafeMutablePointer<WeakReference<T>>
+  private var bucketCount: Int
 
   /// Estimated count of inserted values. This is greater than or equal to
   /// the number of actually occupied buckets.
   /// i.e. estimatedCount >= _countOccupiedBuckets()
   private var estimatedCount: Int
 
   init(capacity: Int = 0) {
-    buckets = .init(repeating: nil,
-                    count: CacheLookupTable<T>._bucketCount(for: capacity))
+    bucketCount = CacheLookupTable<T>._bucketCount(for: capacity)
+    buckets = .allocate(capacity: bucketCount)
+    buckets.initialize(repeating: nil, count: bucketCount)
     estimatedCount = 0
   }
 
+  deinit {
+    buckets.deinitialize(count: bucketCount)
+    buckets.deallocate()
+  }
+
   /// Constant max load factor for hash table.
   private static var maxLoadFactor: Double {
     @inline(__always) get {
@@ -88,7 +93,7 @@ struct CacheLookupTable<T: Identifiable & AnyObject> {
 
   private var _bucketMask: Int {
     @inline(__always) get {
-      return buckets.count &- 1
+      return bucketCount &- 1
     }
   }
 
@@ -117,43 +122,51 @@ struct CacheLookupTable<T: Identifiable & AnyObject> {
 
   /// Reserves enough space to store the specified number of elements. Returns
   /// true if resizing happened.
-  mutating func reserveCapacity(_ requiredCapacity: Int) -> Bool {
-    let bucketCount = CacheLookupTable<T>._bucketCount(for: requiredCapacity,
-                                                       from: buckets.count)
-    if (buckets.count >= bucketCount) {
+  func reserveCapacity(_ requiredCapacity: Int) -> Bool {
+    let requiredBucketCount =
+      CacheLookupTable<T>._bucketCount(for: requiredCapacity, from: bucketCount)
+    if (bucketCount >= requiredBucketCount) {
       return false
     }
 
     // Slow path. Resizing.
-    var oldBuckets = buckets
-    buckets = .init(repeating: nil, count: bucketCount)
+    let oldBuckets = buckets
+    let oldBucketRange = buckets ..< buckets.advanced(by: bucketCount)
+
+    bucketCount = requiredBucketCount
+    buckets = .allocate(capacity: requiredBucketCount)
+    buckets.initialize(repeating: nil, count: requiredBucketCount)
 
     // Move all nodes from the old buffer.
-    // TODO: move(), when available.
-    for i in 0..<oldBuckets.count {
-      if let oldValue = oldBuckets[i].value {
-        let pos = _findHole(oldValue.id).pos
-        Swift.swap(&buckets[pos], &oldBuckets[i])
+    for oldBucket in oldBucketRange {
+      if let id = oldBucket.pointee.value?.id {
+        let newBucket = buckets.advanced(by: _findHole(id).pos)
+        newBucket.moveAssign(from: oldBucket, count: 1)
+      } else {
+        oldBucket.deinitialize(count: 1)
       }
     }
+
+    oldBuckets.deallocate()
+
     return true
   }
 
   /// Count the actual number of occupied buckets.
   @inline(__always)
   private func _countOccupiedBuckets() -> Int {
     var count = 0
-    for i in 0 ..< buckets.count where buckets[i].value != nil {
+    for i in 0 ..< bucketCount where buckets[i].value != nil {
       count &+= 1
     }
     return count
   }
 
   /// Reserves enough space to store a single new object. Returns true if
   /// resizing happened.
-  mutating private func _ensurePlusOneCapacity() -> Bool {
-    if buckets.count >= CacheLookupTable<T>
-                          ._minimalBucketCount(for: estimatedCount &+ 1) {
+  private func _ensurePlusOneCapacity() -> Bool {
+    if bucketCount >= CacheLookupTable<T>
+                        ._minimalBucketCount(for: estimatedCount &+ 1) {
       return false
     }
 
@@ -164,7 +177,7 @@ struct CacheLookupTable<T: Identifiable & AnyObject> {
 
   /// Inserts the given object into the table.
   @discardableResult
-  mutating func insert(_ obj: T) -> Bool {
+  func insert(_ obj: T) -> Bool {
     var (pos, found) = _findHole(obj.id)
     if found {
       return false