libswift: Add the StackList data structure

StackList is a very efficient data structure for worklist type things.
This is a port of the C++ utility with the same name.

Compared to Array, it does not require any memory allocations.

Author: eeckstein

include/swift/SIL/SILBridging.h

@@ -34,6 +34,14 @@ enum {
   BridgedOperandSize = 4 * sizeof(uintptr_t)
 };
 
+typedef struct {
+  void * _Nullable data;
+} BridgedSlab;
+
+enum {
+  BridgedSlabCapacity = 64 * sizeof(uintptr_t)
+};
+
 enum ChangeNotificationKind {
   instructionsChanged,
   callsChanged,
@@ -121,6 +129,11 @@ void PassContext_notifyChanges(BridgedPassContext passContext,
                                enum ChangeNotificationKind changeKind);
 void PassContext_eraseInstruction(BridgedPassContext passContext,
                                   BridgedInstruction inst);
+BridgedSlab PassContext_getNextSlab(BridgedSlab slab);
+BridgedSlab PassContext_allocSlab(BridgedPassContext passContext,
+                                  BridgedSlab afterSlab);
+BridgedSlab PassContext_freeSlab(BridgedPassContext passContext,
+                                 BridgedSlab slab);
 
 BridgedStringRef SILFunction_getName(BridgedFunction function);
 BridgedStringRef SILFunction_debugDescription(BridgedFunction function);

include/swift/SIL/SILModule.h

@@ -57,10 +57,10 @@ class Output;
 
 namespace swift {
 
-/// A fixed size slab of memory, which can be allocated and freed by the
-/// SILModule at (basically) zero cost.
-class FixedSizeSlab : public llvm::ilist_node<FixedSizeSlab>,
-                       public SILAllocated<FixedSizeSlab> {
+/// The payload for the FixedSizeSlab.
+/// This is a super-class rather than a member of FixedSizeSlab to make bridging
+/// with libswift easier.
+class FixedSizeSlabPayload {
 public:
   /// The capacity of the payload.
   static constexpr size_t capacity = 64 * sizeof(uintptr_t);
@@ -78,7 +78,7 @@ class FixedSizeSlab : public llvm::ilist_node<FixedSizeSlab>,
   uintptr_t overflowGuard = magicNumber;
 
 public:
-  void operator=(const FixedSizeSlab &) = delete;
+  void operator=(const FixedSizeSlabPayload &) = delete;
   void operator delete(void *Ptr, size_t) = delete;
 
   /// Returns the payload pointing to \p T.
@@ -88,6 +88,17 @@ class FixedSizeSlab : public llvm::ilist_node<FixedSizeSlab>,
   template<typename T> const T *dataFor() const { return (const T *)(&data[0]); }
 };
 
+/// A fixed size slab of memory, which can be allocated and freed by the
+/// SILModule at (basically) zero cost.
+/// See SILModule::allocSlab().
+class FixedSizeSlab : public llvm::ilist_node<FixedSizeSlab>,
+                      public SILAllocated<FixedSizeSlab>,
+                      public FixedSizeSlabPayload {
+public:
+  void operator=(const FixedSizeSlab &) = delete;
+  void operator delete(void *Ptr, size_t) = delete;
+};
+
 class AnyFunctionType;
 class ASTContext;
 class FileUnit;

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -52,10 +52,17 @@ class LibswiftPassInvocation {
   /// Non-null if this is an instruction pass, invoked from SILCombine.
   SILCombiner *silCombiner;
 
+  /// All slabs, allocated by the pass.
+  SILModule::SlabList allocatedSlabs;
+
 public:
   LibswiftPassInvocation(SILPassManager *passManager, SILCombiner *silCombiner) :
     passManager(passManager), silCombiner(silCombiner) {}
 
+  FixedSizeSlab *allocSlab(FixedSizeSlab *afterSlab);
+
+  FixedSizeSlab *freeSlab(FixedSizeSlab *slab);
+
   /// The top-level API to erase an instruction, called from the Swift pass.
   void eraseInstruction(SILInstruction *inst);
 

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -1079,6 +1079,26 @@ void SILPassManager::viewCallGraph() {
 //                           LibswiftPassInvocation
 //===----------------------------------------------------------------------===//
 
+static_assert(BridgedSlabCapacity == FixedSizeSlab::capacity,
+              "wrong bridged slab capacity");
+
+FixedSizeSlab *LibswiftPassInvocation::allocSlab(FixedSizeSlab *afterSlab) {
+  FixedSizeSlab *slab = passManager->getModule()->allocSlab();
+  if (afterSlab) {
+    allocatedSlabs.insert(std::next(afterSlab->getIterator()), *slab);
+  } else {
+    allocatedSlabs.push_back(*slab);
+  }
+  return slab;
+}
+
+FixedSizeSlab *LibswiftPassInvocation::freeSlab(FixedSizeSlab *slab) {
+  FixedSizeSlab *prev = std::prev(&*slab->getIterator());
+  allocatedSlabs.remove(*slab);
+  passManager->getModule()->freeSlab(slab);
+  return prev;
+}
+
 void LibswiftPassInvocation::eraseInstruction(SILInstruction *inst) {
   if (silCombiner) {
     // TODO
@@ -1088,6 +1108,7 @@ void LibswiftPassInvocation::eraseInstruction(SILInstruction *inst) {
 }
 
 void LibswiftPassInvocation::finishedPassRun() {
+  assert(allocatedSlabs.empty() && "StackList is leaking slabs");
 }
 
 //===----------------------------------------------------------------------===//
@@ -1099,6 +1120,38 @@ inline LibswiftPassInvocation *castToPassInvocation(BridgedPassContext ctxt) {
     static_cast<const LibswiftPassInvocation *>(ctxt.opaqueCtxt));
 }
 
+inline FixedSizeSlab *castToSlab(BridgedSlab slab) {
+  if (slab.data)
+    return static_cast<FixedSizeSlab *>((FixedSizeSlabPayload *)slab.data);
+  return nullptr;
+}
+
+inline BridgedSlab toBridgedSlab(FixedSizeSlab *slab) {
+  if (slab) {
+    FixedSizeSlabPayload *payload = slab;
+    assert((void *)payload == slab->dataFor<void>());
+    return {payload};
+  }
+  return {nullptr};
+}
+
+
+BridgedSlab PassContext_getNextSlab(BridgedSlab slab) {
+  return toBridgedSlab(&*std::next(castToSlab(slab)->getIterator()));
+}
+
+BridgedSlab PassContext_allocSlab(BridgedPassContext passContext,
+                                  BridgedSlab afterSlab) {
+  auto *inv = castToPassInvocation(passContext);
+  return toBridgedSlab(inv->allocSlab(castToSlab(afterSlab)));
+}
+
+BridgedSlab PassContext_freeSlab(BridgedPassContext passContext,
+                                 BridgedSlab slab) {
+  auto *inv = castToPassInvocation(passContext);
+  return toBridgedSlab(inv->freeSlab(castToSlab(slab)));
+}
+
 void PassContext_notifyChanges(BridgedPassContext passContext,
                                enum ChangeNotificationKind changeKind) {
   LibswiftPassInvocation *inv = castToPassInvocation(passContext);

libswift/README.md

@@ -90,4 +90,6 @@ Some performance considerations:
 
 * Memory is managed on the C++ side. On the Swift side, SIL objects are treated as "immortal" objects, which avoids (most of) ARC overhead. ARC runtime functions are still being called, but no atomic reference counting operations are done. In future we could add a compiler feature to mark classes as immortal to avoid the runtime calls at all.
 
+* Minimizing memory allocations: _libswift_ provides data structures which are malloc-free. For example `StackList` can be used in optimizations to implement work lists without any memory allocations. (Not yet done: `BasicBlockSet`, `BasicBlockData`)
+
 But most importantly, if there are performance issues with the current compiler, the design of _libswift_ should make it possible to fix performance deficiencies with future compiler improvements.

libswift/Sources/Optimizer/PassManager/PassUtils.swift

@@ -49,6 +49,12 @@ struct FunctionPass {
   }
 }
 
+extension StackList {
+  init(_ context: FunctionPassContext) {
+    self.init(context: context.passContext)
+  }
+}
+
 extension Builder {
   init(at insPnt: Instruction, location: Location,
        _ context: FunctionPassContext) {

libswift/Sources/SIL/CMakeLists.txt

@@ -18,5 +18,6 @@ add_libswift_module(SIL
   Registration.swift
   Type.swift
   Utils.swift
+  StackList.swift
   Value.swift)
 

libswift/Sources/SIL/StackList.swift

@@ -0,0 +1,137 @@
+//===--- StackList.swift - defines the StackList data structure -----------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SILBridging
+
+/// A very efficient implementation of a stack, which can also be iterated over.
+///
+/// A StackList is the best choice for things like worklists, etc., if no random
+/// access is needed.
+/// Compared to Array, it does not require any memory allocations, because it
+/// uses the bump pointer allocator of the SILModule.
+/// All operations have (almost) zero cost.
+///
+/// Ideally this would be a move-only type. Until then, only pass StackLists as
+/// inout!
+/// Note: it is required to manually remove all elements - either by pop() or
+///       removeAll().
+public struct StackList<Element> : Sequence, CustomReflectable {
+
+  private let context: BridgedPassContext
+  private var firstSlab = BridgedSlab(data: nil)
+  private var lastSlab = BridgedSlab(data: nil)
+  private var endIndex: Int = slabCapacity
+
+  private static var slabCapacity: Int {
+    BridgedSlabCapacity / MemoryLayout<Element>.size
+  }
+
+  private static func bind(_ slab: BridgedSlab) -> UnsafeMutablePointer<Element> {
+    return slab.data!.bindMemory(to: Element.self, capacity: StackList.slabCapacity)
+  }
+
+  public struct Iterator : IteratorProtocol {
+    var slab: BridgedSlab
+    var index: Int
+    let lastSlab: BridgedSlab
+    let endIndex: Int
+    
+    public mutating func next() -> Element? {
+      let end = (slab.data == lastSlab.data ? endIndex : slabCapacity)
+      if index < end {
+        let elem = StackList.bind(slab)[index]
+        index += 1
+
+        if index >= end && slab.data != lastSlab.data {
+          slab = PassContext_getNextSlab(slab)
+          index = 0
+        }
+        return elem
+      }
+      return nil
+    }
+  }
+  
+  public init(context: BridgedPassContext) { self.context = context }
+
+  public func makeIterator() -> Iterator {
+    return Iterator(slab: firstSlab, index: 0, lastSlab: lastSlab, endIndex: endIndex)
+  }
+
+  public var first: Element? {
+    if isEmpty {
+      return nil
+    }
+    return StackList.bind(firstSlab)[0]
+  }
+
+  public var last: Element? {
+    if isEmpty {
+      return nil
+    }
+    return StackList.bind(lastSlab)[endIndex - 1]
+  }
+
+  public mutating func push(_ element: Element) {
+    if endIndex >= StackList.slabCapacity {
+      lastSlab = PassContext_allocSlab(context, lastSlab)
+      if firstSlab.data == nil {
+        firstSlab = lastSlab
+      }
+      endIndex = 0
+    }
+    (StackList.bind(lastSlab) + endIndex).initialize(to: element)
+    endIndex += 1
+  }
+  
+  public var isEmpty: Bool { return firstSlab.data == nil }
+  
+  public mutating func pop() -> Element? {
+    if isEmpty {
+      return nil
+    }
+    assert(endIndex > 0)
+    endIndex -= 1
+    let elem = (StackList.bind(lastSlab) + endIndex).move()
+    
+    if endIndex == 0 {
+      if lastSlab.data == firstSlab.data {
+        _ = PassContext_freeSlab(context, lastSlab)
+        firstSlab.data = nil
+        lastSlab.data = nil
+      } else {
+        lastSlab = PassContext_freeSlab(context, lastSlab)
+      }
+      endIndex = StackList.slabCapacity
+    }
+
+    return elem
+  }
+  
+  public mutating func removeAll() {
+    if isEmpty {
+      return
+    }
+    while lastSlab.data != firstSlab.data {
+      lastSlab = PassContext_freeSlab(context, lastSlab)
+    }
+    _ = PassContext_freeSlab(context, lastSlab)
+    firstSlab.data = nil
+    lastSlab.data = nil
+    endIndex = StackList.slabCapacity
+  }
+  
+  public var customMirror: Mirror {
+    let c: [Mirror.Child] = map { (label: nil, value: $0) }
+    return Mirror(self, children: c)
+  }
+}