Merge remote-tracking branch 'origin/main' into katei/merge-main-2022-09-24

Author: kateinoigakukun

SwiftCompilerSources/Sources/Optimizer/DataStructures/FunctionUses.swift

@@ -134,15 +134,15 @@ struct FunctionUses {
 
     for witnessTable in context.witnessTables {
       for entry in witnessTable.entries {
-        if entry.kind == .Method, let f = entry.methodFunction {
+        if entry.kind == .method, let f = entry.methodFunction {
           markUnknown(f)
         }
       }
     }
 
     for witnessTable in context.defaultWitnessTables {
       for entry in witnessTable.entries {
-        if entry.kind == .Method, let f = entry.methodFunction {
+        if entry.kind == .method, let f = entry.methodFunction {
           markUnknown(f)
         }
       }

SwiftCompilerSources/Sources/Optimizer/ModulePasses/StackProtection.swift

@@ -124,7 +124,7 @@ private struct StackProtectionOptimization {
                                 mustFixStackNesting: inout Bool, _ context: PassContext) {
 
     // `withUnsafeTemporaryAllocation(of:capacity:_:)` is compiled to a `builtin "stackAlloc"`.
-    if let bi = instruction as? BuiltinInst, bi.id == .StackAlloc {
+    if let bi = instruction as? BuiltinInst, bi.id == .stackAlloc {
       function.setNeedsStackProtection(context)
       return
     }
@@ -332,7 +332,7 @@ private struct StackProtectionOptimization {
   /// Moves the value of a `beginAccess` to a temporary stack location, if possible.
   private func moveToTemporary(scope beginAccess: BeginAccessInst, mustFixStackNesting: inout Bool,
                                _ context: PassContext) {
-    if beginAccess.accessKind != .Modify {
+    if beginAccess.accessKind != .modify {
       // We can only move from a `modify` access.
       // Also, read-only accesses shouldn't be subject to buffer overflows (because
       // no one should ever write to such a storage).

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -422,7 +422,7 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
       return walkDownUses(ofAddress: pta, path: path.with(knownType: nil))
     case let bi as BuiltinInst:
       switch bi.id {
-      case .DestroyArray:
+      case .destroyArray:
         // If it's not the array base pointer operand -> bail. Though, that shouldn't happen
         // because the other operands (metatype, count) shouldn't be visited anyway.
         if operand.index != 1 { return isEscaping }

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -319,10 +319,19 @@ final public class LoadUnownedInst : SingleValueInstruction, UnaryInstruction {}
 final public class LoadBorrowInst : SingleValueInstruction, UnaryInstruction {}
 
 final public class BuiltinInst : SingleValueInstruction {
-  public typealias ID = swift.BuiltinValueKind
+  // TODO: find a way to directly reuse the BuiltinValueKind enum
+  public enum ID  {
+    case none
+    case destroyArray
+    case stackAlloc
+  }
 
   public var id: ID {
-    return BuiltinInst_getID(bridged)
+    switch BuiltinInst_getID(bridged) {
+      case DestroyArrayBuiltin: return .destroyArray
+      case StackAllocBuiltin: return .stackAlloc
+      default: return .none
+    }
   }
 }
 
@@ -533,12 +542,34 @@ final public class BridgeObjectToRefInst : SingleValueInstruction,
 final public class BridgeObjectToWordInst : SingleValueInstruction,
                                            UnaryInstruction {}
 
-public typealias AccessKind = swift.SILAccessKind
+public enum AccessKind {
+  case initialize
+  case read
+  case modify
+  case deinitialize
+}
+
+extension BridgedAccessKind {
+  var kind: AccessKind {
+    switch self {
+    case AccessKind_Init:
+      return .initialize
+    case AccessKind_Read:
+      return .read
+    case AccessKind_Modify:
+      return .modify
+    case AccessKind_Deinit:
+      return .deinitialize
+    default:
+      fatalError("unsupported access kind")
+    }
+  }
+}
 
 
 // TODO: add support for begin_unpaired_access
 final public class BeginAccessInst : SingleValueInstruction, UnaryInstruction {
-  public var accessKind: AccessKind { BeginAccessInst_getAccessKind(bridged) }
+  public var accessKind: AccessKind { BeginAccessInst_getAccessKind(bridged).kind }
 }
 
 public protocol ScopedInstruction {

SwiftCompilerSources/Sources/SIL/WitnessTable.swift

@@ -20,14 +20,28 @@ public struct WitnessTable : CustomStringConvertible, CustomReflectable {
   public struct Entry : CustomStringConvertible, CustomReflectable {
     fileprivate let bridged: BridgedWitnessTableEntry
 
-    public typealias Kind = swift.SILWitnessTable.WitnessKind
+    public enum Kind {
+      case invalid
+      case method
+      case associatedType
+      case associatedTypeProtocol
+      case baseProtocol
+    }
 
     public var kind: Kind {
-      return SILWitnessTableEntry_getKind(bridged)
+      switch SILWitnessTableEntry_getKind(bridged) {
+        case SILWitnessTableEntry_Invalid:                return .invalid
+        case SILWitnessTableEntry_Method:                 return .method
+        case SILWitnessTableEntry_AssociatedType:         return .associatedType
+        case SILWitnessTableEntry_AssociatedTypeProtocol: return .associatedTypeProtocol
+        case SILWitnessTableEntry_BaseProtocol:           return .baseProtocol
+        default:
+          fatalError("unknown witness table kind")
+      }
     }
 
     public var methodFunction: Function? {
-      assert(kind == .Method)
+      assert(kind == .method)
       return SILWitnessTableEntry_getMethodFunction(bridged).function
     }
 

benchmark/CMakeLists.txt

@@ -162,6 +162,7 @@ set(SWIFT_BENCH_MODULES
     single-source/RomanNumbers
     single-source/SIMDRandomMask
     single-source/SIMDReduceInteger
+    single-source/SimpleArraySpecialization
     single-source/SequenceAlgos
     single-source/SetTests
     single-source/SevenBoom
@@ -215,6 +216,7 @@ endif()
 
 set(BENCH_LIBRARY_MODULES
     utils/TestsUtils
+    utils/SimpleArray
 )
 
 set(BENCH_DRIVER_LIBRARY_MODULES

benchmark/Package.swift

@@ -78,6 +78,7 @@ var multiSourceLibraries: [(parentSubDir: String, name: String)] = multiSourceLi
 
 var products: [Product] = []
 products.append(.library(name: "TestsUtils", type: .static, targets: ["TestsUtils"]))
+products.append(.library(name: "SimpleArray", type: .static, targets: ["SimpleArray"]))
 products.append(.library(name: "DriverUtils", type: .static, targets: ["DriverUtils"]))
 #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
 products.append(.library(name: "ObjectiveCTests", type: .static, targets: ["ObjectiveCTests"]))
@@ -96,6 +97,12 @@ products += multiSourceLibraries.map {
 
 var targets: [Target] = []
 targets.append(.target(name: "TestsUtils", path: "utils", sources: ["TestsUtils.swift"]))
+targets.append(.target(
+  name: "SimpleArray",
+  path: "utils",
+  sources: ["SimpleArray.swift"],
+  swiftSettings: [.unsafeFlags(["-Xfrontend",
+                                "-enable-experimental-layout-prespecialization"])]))
 targets.append(.systemLibrary(name: "LibProc", path: "utils/LibProc"))
 targets.append(
   .target(name: "DriverUtils",
@@ -129,7 +136,7 @@ targets.append(
     publicHeadersPath: "."))
 #endif
 
-var singleSourceDeps: [Target.Dependency] = [.target(name: "TestsUtils")]
+var singleSourceDeps: [Target.Dependency] = [.target(name: "TestsUtils"), .target(name: "SimpleArray")]
 #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
 singleSourceDeps.append(.target(name: "ObjectiveCTests"))
 #endif
@@ -147,7 +154,9 @@ targets += singleSourceLibraries.map { name in
   return .target(name: name,
       dependencies: singleSourceDeps,
       path: "single-source",
-      sources: ["\(name).swift"])
+      sources: ["\(name).swift"],
+      swiftSettings: [.unsafeFlags(["-Xfrontend",
+                                    "-enable-experimental-layout-prespecialization"])])
 }
 
 targets += cxxSingleSourceLibraries.map { name in

benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake

@@ -354,7 +354,8 @@ function (swift_benchmark_compile_archopts)
   set(common_options
       "-c"
       "-target" "${target}"
-      "-${BENCH_COMPILE_ARCHOPTS_OPT}" ${PAGE_ALIGNMENT_OPTION})
+      "-${BENCH_COMPILE_ARCHOPTS_OPT}" ${PAGE_ALIGNMENT_OPTION}
+      "-Xfrontend" "-enable-experimental-layout-prespecialization")
 
   if(SWIFT_BENCHMARK_GENERATE_DEBUG_INFO)
     list(APPEND common_options "-g")

benchmark/single-source/SimpleArraySpecialization.swift

@@ -0,0 +1,120 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 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
+//
+//===----------------------------------------------------------------------===//
+
+// This benchmark tests prespecialization of a simplified array type
+
+import TestsUtils
+import SimpleArray
+
+public let benchmarks = [
+  BenchmarkInfo(
+    name: "SimpleArraySpecialization",
+    runFunction: run_SimpleArraySpecializationBenchmarks,
+    tags: [.abstraction, .runtime, .cpubench]
+  ),
+  BenchmarkInfo(
+    name: "SimpleArraySpecialization2",
+    runFunction: run_SimpleArraySpecializationBenchmarks2,
+    tags: [.abstraction, .runtime, .cpubench]
+  ),
+  BenchmarkInfo(
+    name: "SimpleArraySpecialization3",
+    runFunction: run_SimpleArraySpecializationBenchmarks3,
+    tags: [.abstraction, .runtime, .cpubench]
+  ),
+  BenchmarkInfo(
+    name: "SimpleArraySpecialization4",
+    runFunction: run_SimpleArraySpecializationBenchmarks4,
+    tags: [.abstraction, .runtime, .cpubench]
+  ),
+]
+
+let xs = SimpleArray<MyClass>(capacity: 100_000)
+
+@_silgen_name("_swift_stdlib_immortalize")
+func _stdlib_immortalize(_ obj: AnyObject)
+
+import Foundation
+
+
+public final class MyClass {
+  public var x: Int = 23
+}
+
+
+@inline(never)
+public func run_SimpleArraySpecializationBenchmarks(_ n: Int) {
+  let myObject = MyClass()
+
+  // prevent refcount overflow
+  _stdlib_immortalize(myObject)
+  
+  for _ in 0..<n {
+    for i in 0..<100_000 {
+      xs.append(myObject)
+    }
+    xs.clear()
+  }
+
+  blackHole(xs)
+}
+
+@inline(never)
+public func run_SimpleArraySpecializationBenchmarks2(_ n: Int) {
+  let myObject = MyClass()
+  
+  // prevent refcount overflow
+  _stdlib_immortalize(myObject)
+
+  for _ in 0..<n {
+    for i in 0..<100_000 {
+      xs.append2(myObject)
+    }
+    xs.clear()
+  }
+
+  blackHole(xs)
+}
+
+@inline(never)
+public func run_SimpleArraySpecializationBenchmarks3(_ n: Int) {
+  let myObject = MyClass()
+  
+  // prevent refcount overflow
+  _stdlib_immortalize(myObject)
+
+  for _ in 0..<n {
+    for i in 0..<100_000 {
+      xs.append3(myObject)
+    }
+    xs.clear()
+  }
+
+  blackHole(xs)
+}
+
+@inline(never)
+public func run_SimpleArraySpecializationBenchmarks4(_ n: Int) {
+  let myObject = MyClass()
+  
+  // prevent refcount overflow
+  _stdlib_immortalize(myObject)
+
+  for _ in 0..<n {
+    for i in 0..<100_000 {
+      xs.append4(myObject)
+    }
+    xs.clear()
+  }
+
+  blackHole(xs)
+}

benchmark/utils/DriverUtils.swift

@@ -665,8 +665,7 @@ final class TestRunner {
           (c.logMemory ? [r.meta?.maxRSS].compactMap { $0 } : []) +
           (c.logMeta ? r.meta.map {
             [$0.pages, $0.ics, $0.yields] } ?? [] : [])
-        return values.map {
-          (c.delta && $0 == 0) ? "" : String($0) } // drop 0s in deltas
+        return values.map { String($0) }
       }
       let benchmarkStats = (
         [index, t.name] + (results.map(values) ?? ["Unsupported"])