Merge branch 'main' into wip-distributed-actors-prime-main

Author: ktoso

.mailmap

@@ -1,7 +1,7 @@
 Adrian-Constantin Popescu <[email protected]> <[email protected]>
 Alex Blewitt <[email protected]> <[email protected]>
-Alex Hoppen <[email protected]> <[email protected]>
-Alex Hoppen <[email protected]> <[email protected]>
+Alex Hoppen <[email protected]> <[email protected]>
+Alex Hoppen <[email protected]> <[email protected]>
 Alexis Beingessner <[email protected]> <[email protected]>
 Alper Çugun <[email protected]> <[email protected]>
 Amr Aboelela <[email protected]> <[email protected]>

CHANGELOG.md

@@ -6,6 +6,7 @@ CHANGELOG
 
 | Version                | Released   | Toolchain   |
 | :--------------------- | :--------- | :---------- |
+| [Swift 5.5](#swift-55) |            |             |
 | [Swift 5.4](#swift-54) |            |             |
 | [Swift 5.3](#swift-53) | 2020-09-16 | Xcode 12.0  |
 | [Swift 5.2](#swift-52) | 2020-03-24 | Xcode 11.4  |
@@ -25,8 +26,28 @@ CHANGELOG
 
 </details>
 
-Swift Next
-----------
+Swift 5.5
+---------
+
+* [SE-0299][]:
+
+  It is now possible to use leading-dot syntax in generic contexts to access static members of protocol extensions where `Self` is constrained to a fully concrete type:
+
+  ```swift
+  public protocol ToggleStyle { ... }
+
+  public struct DefaultToggleStyle: ToggleStyle { ... }
+
+  extension ToggleStyle where Self == DefaultToggleStyle {
+    public static var `default`: Self { .init() }
+  }
+
+  struct Toggle {
+    func applyToggle<T: ToggleStyle>(_ style: T) { ... }
+  }
+
+  Toggle(...).applyToggle(.default)
+  ```
 
 * Whenever a reference to `Self` does not impede the usage of a protocol as a value type, or a protocol member on a value of protocol type, the same is now true for references to `[Self]` and `[Key : Self]`:
 
@@ -8363,6 +8384,7 @@ Swift 1.0
 [SE-0296]: <https://github.com/apple/swift-evolution/blob/main/proposals/0296-async-await.md>
 [SE-0297]: <https://github.com/apple/swift-evolution/blob/main/proposals/0297-concurrency-objc.md>
 [SE-0298]: <https://github.com/apple/swift-evolution/blob/main/proposals/0298-asyncsequence.md>
+[SE-0299]: <https://github.com/apple/swift-evolution/blob/main/proposals/0299-extend-generic-static-member-lookup.md>
 
 [SR-75]: <https://bugs.swift.org/browse/SR-75>
 [SR-106]: <https://bugs.swift.org/browse/SR-106>

CMakeLists.txt

@@ -148,7 +148,7 @@ set(SWIFT_ANALYZE_CODE_COVERAGE FALSE CACHE STRING
 # SWIFT_VERSION is deliberately /not/ cached so that an existing build directory
 # can be reused when a new version of Swift comes out (assuming the user hasn't
 # manually set it as part of their own CMake configuration).
-set(SWIFT_VERSION "5.4")
+set(SWIFT_VERSION "5.5")
 
 set(SWIFT_VENDOR "" CACHE STRING
     "The vendor name of the Swift compiler")
@@ -196,13 +196,6 @@ if(SWIFT_PROFDATA_FILE AND EXISTS ${SWIFT_PROFDATA_FILE})
   add_definitions("-fprofile-instr-use=${SWIFT_PROFDATA_FILE}")
 endif()
 
-option(USE_SWIFT_ASYNC_LOWERING
-       "Indicates if Swiftc should use async-specific lowering for async
-        functions if it is supported for the target. The runtime also checks
-        this setting before using async-specific attributes. This only applies
-        to the async calling convention and not to the async context attribute."
-	TRUE)
-
 #
 # User-configurable Swift Standard Library specific options.
 #

benchmark/CMakeLists.txt

@@ -158,6 +158,7 @@ set(SWIFT_BENCH_MODULES
     single-source/RemoveWhere
     single-source/ReversedCollections
     single-source/RomanNumbers
+    single-source/SIMDReduceInteger
     single-source/SequenceAlgos
     single-source/SetTests
     single-source/SevenBoom
@@ -179,6 +180,7 @@ set(SWIFT_BENCH_MODULES
     single-source/StringMatch
     single-source/StringRemoveDupes
     single-source/StringReplaceSubrange
+    single-source/StringSplitting
     single-source/StringSwitch
     single-source/StringTests
     single-source/StringWalk

benchmark/single-source/SIMDReduceInteger.swift

@@ -0,0 +1,247 @@
+//===--- SIMDReduceInteger.swift ------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 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 TestsUtils
+
+public let SIMDReduceInteger = [
+  BenchmarkInfo(
+    name: "SIMDReduce.Int32",
+    runFunction: run_SIMDReduceInt32x1,
+    tags: [.validation, .SIMD],
+    setUpFunction: { blackHole(int32Data) }
+  ),
+  BenchmarkInfo(
+    name: "SIMDReduce.Int32x4.Initializer",
+    runFunction: run_SIMDReduceInt32x4_init,
+    tags: [.validation, .SIMD],
+    setUpFunction: { blackHole(int32Data) }
+  ),
+  BenchmarkInfo(
+    name: "SIMDReduce.Int32x4.Cast",
+    runFunction: run_SIMDReduceInt32x4_cast,
+    tags: [.validation, .SIMD],
+    setUpFunction: { blackHole(int32Data) }
+  ), 
+  BenchmarkInfo(
+    name: "SIMDReduce.Int32x16.Initializer",
+    runFunction: run_SIMDReduceInt32x16_init,
+    tags: [.validation, .SIMD],
+    setUpFunction: { blackHole(int32Data) }
+  ),
+  BenchmarkInfo(
+    name: "SIMDReduce.Int32x16.Cast",
+    runFunction: run_SIMDReduceInt32x16_cast,
+    tags: [.validation, .SIMD],
+    setUpFunction: { blackHole(int32Data) }
+  ),
+  BenchmarkInfo(
+    name: "SIMDReduce.Int8",
+    runFunction: run_SIMDReduceInt8x1,
+    tags: [.validation, .SIMD],
+    setUpFunction: { blackHole(int8Data) }
+  ),
+  BenchmarkInfo(
+    name: "SIMDReduce.Int8x16.Initializer",
+    runFunction: run_SIMDReduceInt8x16_init,
+    tags: [.validation, .SIMD],
+    setUpFunction: { blackHole(int8Data) }
+  ),
+  BenchmarkInfo(
+    name: "SIMDReduce.Int8x16.Cast",
+    runFunction: run_SIMDReduceInt8x16_cast,
+    tags: [.validation, .SIMD],
+    setUpFunction: { blackHole(int8Data) }
+  ),
+  BenchmarkInfo(
+    name: "SIMDReduce.Int8x64.Initializer",
+    runFunction: run_SIMDReduceInt8x64_init,
+    tags: [.validation, .SIMD],
+    setUpFunction: { blackHole(int8Data) }
+  ),
+  BenchmarkInfo(
+    name: "SIMDReduce.Int8x64.Cast",
+    runFunction: run_SIMDReduceInt8x64_cast,
+    tags: [.validation, .SIMD],
+    setUpFunction: { blackHole(int8Data) }
+  )
+]
+
+// TODO: use 100 for Onone?
+let scale = 1000
+
+let int32Data: UnsafeBufferPointer<Int32> = {
+  let count = 256
+  // Allocate memory for `count` Int32s with alignment suitable for all
+  // SIMD vector types.
+  let untyped = UnsafeMutableRawBufferPointer.allocate(
+    byteCount: MemoryLayout<Int32>.size * count, alignment: 16
+  )
+  // Intialize the memory as Int32 and fill with random values.
+  let typed = untyped.initializeMemory(as: Int32.self, repeating: 0)
+  var g = SplitMix64(seed: 0)
+  for i in 0 ..< typed.count {
+    typed[i] = .random(in: .min ... .max, using: &g)
+  }
+  return UnsafeBufferPointer(typed)
+}()
+
+@inline(never)
+public func run_SIMDReduceInt32x1(_ N: Int) {
+  for _ in 0 ..< scale*N {
+    var accum: Int32 = 0
+    for v in int32Data {
+      accum &+= v &* v
+    }
+    blackHole(accum)
+  }
+}
+
+@inline(never)
+public func run_SIMDReduceInt32x4_init(_ N: Int) {
+  for _ in 0 ..< scale*N {
+    var accum = SIMD4<Int32>()
+    for i in stride(from: 0, to: int32Data.count, by: 4) {
+      let v = SIMD4(int32Data[i ..< i+4])
+      accum &+= v &* v
+    }
+    blackHole(accum.wrappedSum())
+  }
+}
+
+@inline(never)
+public func run_SIMDReduceInt32x4_cast(_ N: Int) {
+  // Morally it seems like we "should" be able to use withMemoryRebound
+  // to SIMD4<Int32>, but that function requries that the sizes match in
+  // debug builds, so this is pretty ugly. The following "works" for now,
+  // but is probably in violation of the formal model (the exact rules
+  // for "assumingMemoryBound" are not clearly documented). We need a
+  // better solution.
+  let vecs = UnsafeBufferPointer<SIMD4<Int32>>(
+    start: UnsafeRawPointer(int32Data.baseAddress!).assumingMemoryBound(to: SIMD4<Int32>.self),
+    count: int32Data.count / 4
+  )
+  for _ in 0 ..< scale*N {
+    var accum = SIMD4<Int32>()
+    for v in vecs {
+      accum &+= v &* v
+    }
+    blackHole(accum.wrappedSum())
+  }
+}
+
+@inline(never)
+public func run_SIMDReduceInt32x16_init(_ N: Int) {
+  for _ in 0 ..< scale*N {
+    var accum = SIMD16<Int32>()
+    for i in stride(from: 0, to: int32Data.count, by: 16) {
+      let v = SIMD16(int32Data[i ..< i+16])
+      accum &+= v &* v
+    }
+    blackHole(accum.wrappedSum())
+  }
+}
+
+@inline(never)
+public func run_SIMDReduceInt32x16_cast(_ N: Int) {
+  let vecs = UnsafeBufferPointer<SIMD16<Int32>>(
+    start: UnsafeRawPointer(int32Data.baseAddress!).assumingMemoryBound(to: SIMD16<Int32>.self),
+    count: int32Data.count / 16
+  )
+  for _ in 0 ..< scale*N {
+    var accum = SIMD16<Int32>()
+    for v in vecs {
+      accum &+= v &* v
+    }
+    blackHole(accum.wrappedSum())
+  }
+}
+
+let int8Data: UnsafeBufferPointer<Int8> = {
+  let count = 1024
+  // Allocate memory for `count` Int8s with alignment suitable for all
+  // SIMD vector types.
+  let untyped = UnsafeMutableRawBufferPointer.allocate(
+    byteCount: MemoryLayout<Int8>.size * count, alignment: 16
+  )
+  // Intialize the memory as Int8 and fill with random values.
+  let typed = untyped.initializeMemory(as: Int8.self, repeating: 0)
+  var g = SplitMix64(seed: 0)
+  for i in 0 ..< typed.count {
+    typed[i] = .random(in: .min ... .max, using: &g)
+  }
+  return UnsafeBufferPointer(typed)
+}()
+
+@inline(never)
+public func run_SIMDReduceInt8x1(_ N: Int) {
+  for _ in 0 ..< scale*N {
+    var accum: Int8 = 0
+    for v in int8Data {
+      accum &+= v &* v
+    }
+    blackHole(accum)
+  }
+}
+
+@inline(never)
+public func run_SIMDReduceInt8x16_init(_ N: Int) {
+  for _ in 0 ..< scale*N {
+    var accum = SIMD16<Int8>()
+    for i in stride(from: 0, to: int8Data.count, by: 16) {
+      let v = SIMD16(int8Data[i ..< i+16])
+      accum &+= v &* v
+    }
+    blackHole(accum.wrappedSum())
+  }
+}
+
+@inline(never)
+public func run_SIMDReduceInt8x16_cast(_ N: Int) {
+  let vecs = UnsafeBufferPointer<SIMD16<Int8>>(
+    start: UnsafeRawPointer(int8Data.baseAddress!).assumingMemoryBound(to: SIMD16<Int8>.self),
+    count: int8Data.count / 16
+  )
+  for _ in 0 ..< scale*N {
+    var accum = SIMD16<Int8>()
+    for v in vecs {
+      accum &+= v &* v
+    }
+    blackHole(accum.wrappedSum())
+  }
+}
+
+@inline(never)
+public func run_SIMDReduceInt8x64_init(_ N: Int) {
+  for _ in 0 ..< scale*N {
+    var accum = SIMD64<Int8>()
+    for i in stride(from: 0, to: int8Data.count, by: 64) {
+      let v = SIMD64(int8Data[i ..< i+64])
+      accum &+= v &* v
+    }
+    blackHole(accum.wrappedSum())
+  }
+}
+
+@inline(never)
+public func run_SIMDReduceInt8x64_cast(_ N: Int) {
+  let vecs = UnsafeBufferPointer<SIMD64<Int8>>(
+    start: UnsafeRawPointer(int8Data.baseAddress!).assumingMemoryBound(to: SIMD64<Int8>.self),
+    count: int8Data.count / 64
+  )
+  for _ in 0 ..< scale*N {
+    var accum = SIMD64<Int8>()
+    for v in vecs {
+      accum &+= v &* v
+    }
+    blackHole(accum.wrappedSum())
+  }
+}