Merge pull request #5319 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -98,14 +98,14 @@ struct AliasAnalysis {
       },
 
       // isAddrVisibleFromObj
-      { (bridgedCtxt: BridgedPassContext, bridgedAddr: BridgedValue, bridgedObj: BridgedValue) -> Bool in
+      { (bridgedCtxt: BridgedPassContext, bridgedAddr: BridgedValue, bridgedObj: BridgedValue, complexityBudget: Int) -> Bool in
         let context = FunctionPassContext(_bridged: bridgedCtxt)
         let addr = bridgedAddr.value.at(AliasAnalysis.getPtrOrAddressPath(for: bridgedAddr.value))
 
         // This is similar to `canReferenceSameFieldFn`, except that all addresses of all objects are
         // considered which are transitively visible from `bridgedObj`.
         let anythingReachableFromObj = bridgedObj.value.at(SmallProjectionPath(.anything))
-        return addr.canAddressAlias(with: anythingReachableFromObj, context)
+        return addr.canAddressAlias(with: anythingReachableFromObj, complexityBudget: complexityBudget, context)
       },
 
       // canReferenceSameFieldFn

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -75,8 +75,9 @@ extension ProjectedValue {
   /// the walk. See `EscapeVisitor` for details.
   ///
   func isEscaping(using visitor: some EscapeVisitor = DefaultVisitor(),
+                  complexityBudget: Int = Int.max,
                   _ context: some Context) -> Bool {
-    var walker = EscapeWalker(visitor: visitor, context)
+    var walker = EscapeWalker(visitor: visitor, complexityBudget: complexityBudget, context)
     return walker.walkUp(addressOrValue: value, path: path.escapePath) == .abortWalk
   }
 
@@ -287,9 +288,10 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
                                                     AddressUseDefWalker {
   typealias Path = EscapeUtilityTypes.EscapePath
 
-  init(visitor: V, _ context: some Context) {
+  init(visitor: V, complexityBudget: Int = Int.max, _ context: some Context) {
     self.calleeAnalysis = context.calleeAnalysis
     self.visitor = visitor
+    self.complexityBudget = complexityBudget
   }
 
   //===--------------------------------------------------------------------===//
@@ -313,6 +315,9 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
   }
 
   mutating func walkDown(value: Operand, path: Path) -> WalkResult {
+    if complexityBudgetExceeded(value.value) {
+      return .abortWalk
+    }
     if hasRelevantType(value.value, at: path.projectionPath) {
       switch visitor.visitUse(operand: value, path: path) {
       case .continueWalk:
@@ -409,6 +414,9 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
   }
 
   mutating func walkDown(address: Operand, path: Path) -> WalkResult {
+    if complexityBudgetExceeded(address.value) {
+      return .abortWalk
+    }
     if hasRelevantType(address.value, at: path.projectionPath) {
       switch visitor.visitUse(operand: address, path: path) {
       case .continueWalk:
@@ -508,7 +516,7 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
       return .continueWalk
     }
     if !visitor.followLoads && p.matches(pattern: SmallProjectionPath(.anyValueFields).push(.anyClassField)) {
-      // Any address of a class property of the object to destroy cannot esacpe the destructor.
+      // Any address of a class property of the object to destroy cannot escape the destructor.
       // (Whereas a value stored in such a property could escape.)
       return .continueWalk
     }
@@ -644,6 +652,9 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
   }
 
   mutating func walkUp(value: Value, path: Path) -> WalkResult {
+    if complexityBudgetExceeded(value) {
+      return .abortWalk
+    }
     if hasRelevantType(value, at: path.projectionPath) {
       switch visitor.visitDef(def: value, path: path) {
       case .continueWalkUp:
@@ -697,6 +708,9 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
   }
 
   mutating func walkUp(address: Value, path: Path) -> WalkResult {
+    if complexityBudgetExceeded(address) {
+      return .abortWalk
+    }
     if hasRelevantType(address, at: path.projectionPath) {
       switch visitor.visitDef(def: address, path: path) {
       case .continueWalkUp:
@@ -785,6 +799,10 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
   var walkDownCache = WalkerCache<Path>()
   var walkUpCache = WalkerCache<Path>()
 
+  // Only this number of up/and down walks are done until the walk aborts.
+  // Used to avoid quadratic complexity in some scenarios.
+  var complexityBudget: Int
+
   private let calleeAnalysis: CalleeAnalysis
 
   //===--------------------------------------------------------------------===//
@@ -825,6 +843,14 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
     return path.popLastClassAndValuesFromTail()
   }
 
+  private mutating func complexityBudgetExceeded(_ v: Value) -> Bool {
+    if complexityBudget <= 0 {
+      return true
+    }
+    complexityBudget = complexityBudget &- 1
+    return false
+  }
+
   // Set a breakpoint here to debug when a value is escaping.
   private var isEscaping: WalkResult { .abortWalk }
 }

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -221,15 +221,15 @@ extension ProjectedValue {
   /// `%s`.canAddressAlias(with: `%2`) -> true
   /// `%1`.canAddressAlias(with: `%2`) -> false
   ///
-  func canAddressAlias(with rhs: ProjectedValue, _ context: some Context) -> Bool {
+  func canAddressAlias(with rhs: ProjectedValue, complexityBudget: Int = Int.max, _ context: some Context) -> Bool {
     // self -> rhs will succeed (= return false) if self is a non-escaping "local" object,
     // but not necessarily rhs.
-    if !isEscaping(using: EscapesToValueVisitor(target: rhs), context) {
+    if !isEscaping(using: EscapesToValueVisitor(target: rhs), complexityBudget: complexityBudget, context) {
       return false
     }
     // The other way round: rhs -> self will succeed if rhs is a non-escaping "local" object,
     // but not necessarily self.
-    if !rhs.isEscaping(using: EscapesToValueVisitor(target: self), context) {
+    if !rhs.isEscaping(using: EscapesToValueVisitor(target: self), complexityBudget: complexityBudget, context) {
       return false
     }
     return true

benchmark/CMakeLists.txt

@@ -198,6 +198,7 @@ set(SWIFT_BENCH_MODULES
     single-source/TwoSum
     single-source/TypeFlood
     single-source/UTF8Decode
+    single-source/UTF16Decode
     single-source/Walsh
     single-source/WordCount
     single-source/XorLoop

benchmark/single-source/UTF16Decode.swift

@@ -0,0 +1,223 @@
+//===--- UTF16Decode.swift -------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 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 TestsUtils
+import Foundation
+
+public let benchmarks = [
+    BenchmarkInfo(
+      name: "UTF16Decode",
+      runFunction: run_UTF16Decode,
+      tags: [.validation, .api, .String],
+      setUpFunction: setUp),
+    BenchmarkInfo(
+      name: "UTF16Decode.initFromCustom.cont",
+      runFunction: run_UTF16Decode_InitFromCustom_contiguous,
+      tags: [.validation, .api, .String],
+      setUpFunction: setUp),
+    BenchmarkInfo(
+      name: "UTF16Decode.initFromCustom.cont.ascii",
+      runFunction: run_UTF16Decode_InitFromCustom_contiguous_ascii,
+      tags: [.validation, .api, .String, .skip],
+      setUpFunction: setUp),
+    BenchmarkInfo(
+      name: "UTF16Decode.initFromCustom.noncont",
+      runFunction: run_UTF16Decode_InitFromCustom_noncontiguous,
+      tags: [.validation, .api, .String],
+      setUpFunction: setUp),
+    BenchmarkInfo(
+      name: "UTF16Decode.initFromCustom.noncont.ascii",
+      runFunction: run_UTF16Decode_InitFromCustom_noncontiguous_ascii,
+      tags: [.validation, .api, .String, .skip],
+      setUpFunction: setUp),
+    BenchmarkInfo(
+      name: "UTF16Decode.initFromData",
+      runFunction: run_UTF16Decode_InitFromData,
+      tags: [.validation, .api, .String],
+      setUpFunction: setUp),
+    BenchmarkInfo(
+      name: "UTF16Decode.initDecoding",
+      runFunction: run_UTF16Decode_InitDecoding,
+      tags: [.validation, .api, .String],
+      setUpFunction: setUp),
+    BenchmarkInfo(
+      name: "UTF16Decode.initFromData.ascii",
+      runFunction: run_UTF16Decode_InitFromData_ascii,
+      tags: [.validation, .api, .String, .skip],
+      setUpFunction: setUp),
+    BenchmarkInfo(
+      name: "UTF16Decode.initDecoding.ascii",
+      runFunction: run_UTF16Decode_InitDecoding_ascii,
+      tags: [.validation, .api, .String, .skip],
+      setUpFunction: setUp),
+    BenchmarkInfo(
+      name: "UTF16Decode.initFromData.asciiAsAscii",
+      runFunction: run_UTF16Decode_InitFromData_ascii_as_ascii,
+      tags: [.validation, .api, .String, .skip],
+      setUpFunction: setUp),
+]
+
+typealias CodeUnit = UInt16
+
+// 1-byte sequences
+// This test case is the longest as it's the most performance sensitive.
+let ascii = "Swift is a multi-paradigm, compiled programming language created for iOS, OS X, watchOS, tvOS and Linux development by Apple Inc. Swift is designed to work with Apple's Cocoa and Cocoa Touch frameworks and the large body of existing Objective-C code written for Apple products. Swift is intended to be more resilient to erroneous code (\"safer\") than Objective-C and also more concise. It is built with the LLVM compiler framework included in Xcode 6 and later and uses the Objective-C runtime, which allows C, Objective-C, C++ and Swift code to run within a single program."
+let asciiCodeUnits: [CodeUnit] = Array(ascii.utf16)
+let asciiData: Data = asciiCodeUnits.withUnsafeBytes { Data($0) }
+
+// 2-byte sequences
+let russian = "Ру́сский язы́к один из восточнославянских языков, национальный язык русского народа."
+// 3-byte sequences
+let japanese = "日本語（にほんご、にっぽんご）は、主に日本国内や日本人同士の間で使われている言語である。"
+// 4-byte sequences
+// Most commonly emoji, which are usually mixed with other text.
+let emoji = "Panda 🐼, Dog 🐶, Cat 🐱, Mouse 🐭."
+
+let allStrings: [[CodeUnit]] = [ascii, russian, japanese, emoji].map { Array($0.utf16) }
+let allStringsCodeUnits: [CodeUnit] = Array(allStrings.joined())
+let allStringsData: Data = allStringsCodeUnits.withUnsafeBytes { Data($0) }
+
+func setUp() {
+    blackHole(asciiCodeUnits)
+    blackHole(asciiData)
+    blackHole(allStrings)
+    blackHole(allStringsCodeUnits)
+    blackHole(allStringsData)
+    blackHole(allStringsCustomContiguous)
+    blackHole(asciiCustomContiguous)
+    blackHole(allStringsCustomNoncontiguous)
+    blackHole(asciiCustomNoncontiguous)
+}
+
+@inline(never)
+public func run_UTF16Decode(_ N: Int) {
+  func isEmpty(_ result: UnicodeDecodingResult) -> Bool {
+    switch result {
+    case .emptyInput:
+      return true
+    default:
+      return false
+    }
+  }
+
+  for _ in 1...200*N {
+    for string in allStrings {
+      var it = string.makeIterator()
+      var utf16 = UTF16()
+      while !isEmpty(utf16.decode(&it)) { }
+    }
+  }
+}
+
+@inline(never)
+public func run_UTF16Decode_InitFromData(_ N: Int) {
+  for _ in 0..<200*N {
+    blackHole(String(data: allStringsData, encoding: .utf16))
+  }
+}
+
+@inline(never)
+public func run_UTF16Decode_InitDecoding(_ N: Int) {
+  for _ in 0..<2*N {
+    blackHole(String(decoding: allStringsCodeUnits, as: UTF16.self))
+  }
+}
+
+@inline(never)
+public func run_UTF16Decode_InitFromData_ascii(_ N: Int) {
+  for _ in 0..<100*N {
+    blackHole(String(data: asciiData, encoding: .utf16))
+  }
+}
+
+@inline(never)
+public func run_UTF16Decode_InitDecoding_ascii(_ N: Int) {
+  for _ in 0..<N {
+    blackHole(String(decoding: asciiCodeUnits, as: UTF16.self))
+  }
+}
+
+@inline(never)
+public func run_UTF16Decode_InitFromData_ascii_as_ascii(_ N: Int) {
+  for _ in 0..<1_000*N {
+    blackHole(String(data: asciiData, encoding: .ascii))
+  }
+}
+
+struct CustomContiguousCollection: Collection {
+  let storage: [CodeUnit]
+  typealias Index = Int
+  typealias Element = CodeUnit
+
+  init(_ codeUnits: [CodeUnit]) { self.storage = codeUnits }
+  subscript(position: Int) -> Element { self.storage[position] }
+  var startIndex: Index { 0 }
+  var endIndex: Index { storage.count }
+  func index(after i: Index) -> Index { i+1 }
+
+  @inline(never)
+  func withContiguousStorageIfAvailable<R>(
+    _ body: (UnsafeBufferPointer<CodeUnit>) throws -> R
+  ) rethrows -> R? {
+    try storage.withContiguousStorageIfAvailable(body)
+  }
+}
+struct CustomNoncontiguousCollection: Collection {
+  let storage: [CodeUnit]
+  typealias Index = Int
+  typealias Element = CodeUnit
+
+  init(_ codeUnits: [CodeUnit]) { self.storage = codeUnits }
+  subscript(position: Int) -> Element { self.storage[position] }
+  var startIndex: Index { 0 }
+  var endIndex: Index { storage.count }
+  func index(after i: Index) -> Index { i+1 }
+
+  @inline(never)
+  func withContiguousStorageIfAvailable<R>(
+    _ body: (UnsafeBufferPointer<UInt8>) throws -> R
+  ) rethrows -> R? {
+    nil
+  }
+}
+let allStringsCustomContiguous = CustomContiguousCollection(allStringsCodeUnits)
+let asciiCustomContiguous = CustomContiguousCollection(Array(ascii.utf16))
+let allStringsCustomNoncontiguous = CustomNoncontiguousCollection(allStringsCodeUnits)
+let asciiCustomNoncontiguous = CustomNoncontiguousCollection(Array(ascii.utf16))
+
+@inline(never)
+public func run_UTF16Decode_InitFromCustom_contiguous(_ N: Int) {
+  for _ in 0..<20*N {
+    blackHole(String(decoding: allStringsCustomContiguous, as: UTF16.self))
+  }
+}
+
+@inline(never)
+public func run_UTF16Decode_InitFromCustom_contiguous_ascii(_ N: Int) {
+  for _ in 0..<10*N {
+    blackHole(String(decoding: asciiCustomContiguous, as: UTF16.self))
+  }
+}
+
+@inline(never)
+public func run_UTF16Decode_InitFromCustom_noncontiguous(_ N: Int) {
+  for _ in 0..<20*N {
+    blackHole(String(decoding: allStringsCustomNoncontiguous, as: UTF16.self))
+  }
+}
+
+@inline(never)
+public func run_UTF16Decode_InitFromCustom_noncontiguous_ascii(_ N: Int) {
+  for _ in 0..<10*N {
+    blackHole(String(decoding: asciiCustomNoncontiguous, as: UTF16.self))
+  }
+}

benchmark/utils/main.swift

@@ -199,6 +199,7 @@ import SuperChars
 import TwoSum
 import TypeFlood
 import UTF8Decode
+import UTF16Decode
 import Walsh
 import WordCount
 import XorLoop
@@ -393,6 +394,7 @@ register(SuperChars.benchmarks)
 register(TwoSum.benchmarks)
 register(TypeFlood.benchmarks)
 register(UTF8Decode.benchmarks)
+register(UTF16Decode.benchmarks)
 register(Walsh.benchmarks)
 register(WordCount.benchmarks)
 register(XorLoop.benchmarks)