[SE-0101] MemoryLayout: Migrate testsuite and benchmarks

Author: rintaro

benchmark/single-source/BitCount.swift

@@ -17,7 +17,7 @@ import Foundation
 import TestsUtils
 
 func countBitSet(_ num: Int) -> Int {
-  let bits = sizeof(Int.self) * 8
+  let bits = MemoryLayout<Int>.size * 8
   var cnt: Int = 0
   var mask: Int = 1
   for _ in 0...bits {

test/1_stdlib/Character.swift

@@ -136,13 +136,13 @@ CharacterTests.test("literal") {
 
 CharacterTests.test("sizeof") {
   // FIXME: should be 8.
-  // <rdar://problem/16754935> sizeof(Character.self) is 9, should be 8
+  // <rdar://problem/16754935> MemoryLayout<Character>.size is 9, should be 8
 
-  let size1 = sizeof(Character.self)
+  let size1 = MemoryLayout<Character>.size
   expectTrue(size1 == 8 || size1 == 9)
 
   var a: Character = "a"
-  let size2 = sizeofValue(a)
+  let size2 = MemoryLayout._ofInstance(a).size
   expectTrue(size2 == 8 || size2 == 9)
 
   expectEqual(size1, size2)

test/1_stdlib/Runtime.swift.gyb

@@ -1483,9 +1483,9 @@ func computeCountLeadingZeroes(_ x: Int64) -> Int64 {
 
 BitTwiddlingTestSuite.test("_pointerSize") {
 #if arch(i386) || arch(arm)
-  expectEqual(4, sizeof(Optional<AnyObject>.self))
+  expectEqual(4, MemoryLayout<Optional<AnyObject>>.size)
 #elseif arch(x86_64) || arch(arm64) || arch(powerpc64) || arch(powerpc64le)
-  expectEqual(8, sizeof(Optional<AnyObject>.self))
+  expectEqual(8, MemoryLayout<Optional<AnyObject>>.size)
 #else
   fatalError("implement")
 #endif

test/1_stdlib/TestData.swift

@@ -458,19 +458,19 @@ class TestData : TestDataSuper {
 
     func testCopyBytes() {
         let c = 10
-        let underlyingBuffer = malloc(c * strideof(UInt16.self))!
+        let underlyingBuffer = malloc(c * MemoryLayout<UInt16>.stride)!
         let u16Ptr = underlyingBuffer.bindMemory(to: UInt16.self, capacity: c)
         let buffer = UnsafeMutableBufferPointer<UInt16>(start: u16Ptr, count: c)
 
         buffer[0] = 0
         buffer[1] = 0
 
-        var data = Data(capacity: c * strideof(UInt16.self))
-        data.resetBytes(in: 0..<c * strideof(UInt16.self))
+        var data = Data(capacity: c * MemoryLayout<UInt16>.stride)
+        data.resetBytes(in: 0..<c * MemoryLayout<UInt16>.stride)
         data[0] = 0xFF
         data[1] = 0xFF
         let copiedCount = data.copyBytes(to: buffer)
-        expectEqual(copiedCount, c * strideof(UInt16.self))
+        expectEqual(copiedCount, c * MemoryLayout<UInt16>.stride)
 
         expectEqual(buffer[0], 0xFFFF)
         free(underlyingBuffer)
@@ -481,7 +481,7 @@ class TestData : TestDataSuper {
         var data = a.withUnsafeBufferPointer {
             return Data(buffer: $0)
         }
-        let expectedSize = strideof(UInt8.self) * a.count
+        let expectedSize = MemoryLayout<UInt8>.stride * a.count
         expectEqual(expectedSize, data.count)
 
         let underlyingBuffer = unsafeBitCast(malloc(expectedSize - 1)!, to: UnsafeMutablePointer<UInt8>.self)
@@ -505,7 +505,7 @@ class TestData : TestDataSuper {
         var data = a.withUnsafeBufferPointer {
             return Data(buffer: $0)
         }
-        let expectedSize = strideof(Int32.self) * a.count
+        let expectedSize = MemoryLayout<Int32>.stride * a.count
         expectEqual(expectedSize, data.count)
 
         let underlyingBuffer = unsafeBitCast(malloc(expectedSize + 1)!, to: UnsafeMutablePointer<UInt8>.self)
@@ -700,14 +700,14 @@ class TestData : TestDataSuper {
             return Data(buffer: $0)
         }
 
-        var expectedSize = strideof(Int32.self) * a.count
+        var expectedSize = MemoryLayout<Int32>.stride * a.count
         expectEqual(expectedSize, data.count)
 
         [false, true].withUnsafeBufferPointer {
             data.append($0)
         }
 
-        expectedSize += strideof(Bool.self) * 2
+        expectedSize += MemoryLayout<Bool>.stride * 2
         expectEqual(expectedSize, data.count)
 
         let underlyingBuffer = unsafeBitCast(malloc(expectedSize)!, to: UnsafeMutablePointer<UInt8>.self)
@@ -810,51 +810,51 @@ class TestData : TestDataSuper {
             return Data(buffer: $0)
         }
 
-        expectEqual(data.count, strideof(MyStruct.self) * 3)
+        expectEqual(data.count, MemoryLayout<MyStruct>.stride * 3)
 
 
         // append
         stuff.withUnsafeBufferPointer {
             data.append($0)
         }
 
-        expectEqual(data.count, strideof(MyStruct.self) * 6)
+        expectEqual(data.count, MemoryLayout<MyStruct>.stride * 6)
 
         // copyBytes
         do {
             // equal size
-            let underlyingBuffer = malloc(6 * strideof(MyStruct.self))!
+            let underlyingBuffer = malloc(6 * MemoryLayout<MyStruct>.stride)!
             defer { free(underlyingBuffer) }
 
             let ptr = underlyingBuffer.bindMemory(to: MyStruct.self, capacity: 6)
             let buffer = UnsafeMutableBufferPointer<MyStruct>(start: ptr, count: 6)
 
             let byteCount = data.copyBytes(to: buffer)
-            expectEqual(6 * strideof(MyStruct.self), byteCount)
+            expectEqual(6 * MemoryLayout<MyStruct>.stride, byteCount)
         }
 
         do {
             // undersized
-            let underlyingBuffer = malloc(3 * strideof(MyStruct.self))!
+            let underlyingBuffer = malloc(3 * MemoryLayout<MyStruct>.stride)!
             defer { free(underlyingBuffer) }
 
             let ptr = underlyingBuffer.bindMemory(to: MyStruct.self, capacity: 3)
             let buffer = UnsafeMutableBufferPointer<MyStruct>(start: ptr, count: 3)
 
             let byteCount = data.copyBytes(to: buffer)
-            expectEqual(3 * strideof(MyStruct.self), byteCount)
+            expectEqual(3 * MemoryLayout<MyStruct>.stride, byteCount)
         }
 
         do {
             // oversized
-            let underlyingBuffer = malloc(12 * strideof(MyStruct.self))!
+            let underlyingBuffer = malloc(12 * MemoryLayout<MyStruct>.stride)!
             defer { free(underlyingBuffer) }
 
             let ptr = underlyingBuffer.bindMemory(to: MyStruct.self, capacity: 6)
             let buffer = UnsafeMutableBufferPointer<MyStruct>(start: ptr, count: 6)
 
             let byteCount = data.copyBytes(to: buffer)
-            expectEqual(6 * strideof(MyStruct.self), byteCount)
+            expectEqual(6 * MemoryLayout<MyStruct>.stride, byteCount)
         }
     }
 

test/1_stdlib/UnsafeRawPointer.swift

@@ -16,11 +16,11 @@ class Missile {
 UnsafeMutableRawPointerExtraTestSuite.test("initializeMemory") {
   Missile.missilesLaunched = 0
   do {
-    let sizeInBytes = 3 * strideof(Missile.self)
+    let sizeInBytes = 3 * MemoryLayout<Missile>.stride
     var p1 = UnsafeMutableRawPointer.allocate(
-      bytes: sizeInBytes, alignedTo: alignof(Missile.self))
+      bytes: sizeInBytes, alignedTo: MemoryLayout<Missile>.alignment)
     defer {
-      p1.deallocate(bytes: sizeInBytes, alignedTo: alignof(Missile.self))
+      p1.deallocate(bytes: sizeInBytes, alignedTo: MemoryLayout<Missile>.alignment)
     }
     var ptrM = p1.initializeMemory(as: Missile.self, to: Missile(1))
     p1.initializeMemory(as: Missile.self, at: 1, count: 2, to: Missile(2))
@@ -29,9 +29,9 @@ UnsafeMutableRawPointerExtraTestSuite.test("initializeMemory") {
     expectEqual(2, ptrM[2].number)
 
     var p2 = UnsafeMutableRawPointer.allocate(
-      bytes: sizeInBytes, alignedTo: alignof(Missile.self))
+      bytes: sizeInBytes, alignedTo: MemoryLayout<Missile>.alignment)
     defer {
-      p2.deallocate(bytes: sizeInBytes, alignedTo: alignof(Missile.self))
+      p2.deallocate(bytes: sizeInBytes, alignedTo: MemoryLayout<Missile>.alignment)
     }
     let ptrM2 = p2.moveInitializeMemory(as: Missile.self, from: ptrM, count: 3)
     defer {
@@ -55,11 +55,11 @@ UnsafeMutableRawPointerExtraTestSuite.test("initializeMemory") {
 }
 
 UnsafeMutableRawPointerExtraTestSuite.test("bindMemory") {
-  let sizeInBytes = 3 * strideof(Int.self)
+  let sizeInBytes = 3 * MemoryLayout<Int>.stride
   var p1 = UnsafeMutableRawPointer.allocate(
-    bytes: sizeInBytes, alignedTo: alignof(Int.self))
+    bytes: sizeInBytes, alignedTo: MemoryLayout<Int>.alignment)
   defer {
-    p1.deallocate(bytes: sizeInBytes, alignedTo: alignof(Int.self))
+    p1.deallocate(bytes: sizeInBytes, alignedTo: MemoryLayout<Int>.alignment)
   }
   let ptrI = p1.bindMemory(to: Int.self, capacity: 3)
   ptrI.initialize(from: 1...3)
@@ -72,33 +72,33 @@ UnsafeMutableRawPointerExtraTestSuite.test("bindMemory") {
 }
 
 UnsafeMutableRawPointerExtraTestSuite.test("load/store") {
-  let sizeInBytes = 3 * strideof(Int.self)
+  let sizeInBytes = 3 * MemoryLayout<Int>.stride
   var p1 = UnsafeMutableRawPointer.allocate(
-    bytes: sizeInBytes, alignedTo: alignof(Int.self))
+    bytes: sizeInBytes, alignedTo: MemoryLayout<Int>.alignment)
   defer {
-    p1.deallocate(bytes: sizeInBytes, alignedTo: alignof(Int.self))
+    p1.deallocate(bytes: sizeInBytes, alignedTo: MemoryLayout<Int>.alignment)
   }
   let ptrI = p1.initializeMemory(as: Int.self, from: 1...3)
   defer {
     ptrI.deinitialize(count: 3)
   }
   expectEqual(1, p1.load(as: Int.self))
-  expectEqual(2, p1.load(fromByteOffset: strideof(Int.self), as: Int.self))
-  expectEqual(3, p1.load(fromByteOffset: 2*strideof(Int.self), as: Int.self))
+  expectEqual(2, p1.load(fromByteOffset: MemoryLayout<Int>.stride, as: Int.self))
+  expectEqual(3, p1.load(fromByteOffset: 2*MemoryLayout<Int>.stride, as: Int.self))
   p1.storeBytes(of: 4, as: Int.self)
-  p1.storeBytes(of: 5, toByteOffset: strideof(Int.self), as: Int.self)
-  p1.storeBytes(of: 6, toByteOffset: 2 * strideof(Int.self), as: Int.self)
+  p1.storeBytes(of: 5, toByteOffset: MemoryLayout<Int>.stride, as: Int.self)
+  p1.storeBytes(of: 6, toByteOffset: 2 * MemoryLayout<Int>.stride, as: Int.self)
   expectEqual(4, p1.load(as: Int.self))
-  expectEqual(5, p1.load(fromByteOffset: strideof(Int.self), as: Int.self))
-  expectEqual(6, p1.load(fromByteOffset: 2 * strideof(Int.self), as: Int.self))
+  expectEqual(5, p1.load(fromByteOffset: MemoryLayout<Int>.stride, as: Int.self))
+  expectEqual(6, p1.load(fromByteOffset: 2 * MemoryLayout<Int>.stride, as: Int.self))
 }
 
 UnsafeMutableRawPointerExtraTestSuite.test("copyBytes") {
-  let sizeInBytes = 4 * strideof(Int.self)
+  let sizeInBytes = 4 * MemoryLayout<Int>.stride
   var rawPtr = UnsafeMutableRawPointer.allocate(
-    bytes: sizeInBytes, alignedTo: alignof(Int.self))
+    bytes: sizeInBytes, alignedTo: MemoryLayout<Int>.alignment)
   defer {
-    rawPtr.deallocate(bytes: sizeInBytes, alignedTo: alignof(Int.self))
+    rawPtr.deallocate(bytes: sizeInBytes, alignedTo: MemoryLayout<Int>.alignment)
   }
   let ptrI = rawPtr.initializeMemory(as: Int.self, count: 4, to: 42)
   defer {
@@ -108,32 +108,32 @@ UnsafeMutableRawPointerExtraTestSuite.test("copyBytes") {
   // Right overlap
   ptrI[0] = 1
   ptrI[1] = 2
-  (rawPtr + strideof(Int.self)).copyBytes(
-    from: roPtr, count: 2 * strideof(Int.self))
+  (rawPtr + MemoryLayout<Int>.stride).copyBytes(
+    from: roPtr, count: 2 * MemoryLayout<Int>.stride)
   expectEqual(1, ptrI[1])
   expectEqual(2, ptrI[2])
 
   // Left overlap
   ptrI[1] = 2
   ptrI[2] = 3
   rawPtr.copyBytes(
-    from: roPtr + strideof(Int.self), count: 2 * strideof(Int.self))
+    from: roPtr + MemoryLayout<Int>.stride, count: 2 * MemoryLayout<Int>.stride)
   expectEqual(2, ptrI[0])
   expectEqual(3, ptrI[1])
 
   // Disjoint:
   ptrI[2] = 2
   ptrI[3] = 3
   rawPtr.copyBytes(
-    from: roPtr + 2 * strideof(Int.self), count: 2 * strideof(Int.self))
+    from: roPtr + 2 * MemoryLayout<Int>.stride, count: 2 * MemoryLayout<Int>.stride)
   expectEqual(2, ptrI[0])
   expectEqual(3, ptrI[1])
 
   // Backwards
   ptrI[0] = 0
   ptrI[1] = 1
-  (rawPtr + 2 * strideof(Int.self)).copyBytes(
-    from: roPtr, count: 2 * strideof(Int.self))
+  (rawPtr + 2 * MemoryLayout<Int>.stride).copyBytes(
+    from: roPtr, count: 2 * MemoryLayout<Int>.stride)
   expectEqual(0, ptrI[2])
   expectEqual(1, ptrI[3])
 }

test/1_stdlib/simd.swift.gyb

@@ -59,35 +59,35 @@ var simdTestSuite = TestSuite("simd")
 
 simdTestSuite.test("sizes") {
 //  C interop requires that vector be the right size.
-  expectEqual(8, sizeof(float2.self))
-  expectEqual(16, sizeof(float3.self))
-  expectEqual(16, sizeof(float4.self))
-  expectEqual(8, sizeof(int2.self))
-  expectEqual(16, sizeof(int3.self))
-  expectEqual(16, sizeof(int4.self))
-  expectEqual(16, sizeof(double2.self))
-  expectEqual(32, sizeof(double3.self))
-  expectEqual(32, sizeof(double4.self))
-
-  expectEqual(16, sizeof(float2x2.self))
-  expectEqual(32, sizeof(float2x3.self))
-  expectEqual(32, sizeof(float2x4.self))
-  expectEqual(24, sizeof(float3x2.self))
-  expectEqual(48, sizeof(float3x3.self))
-  expectEqual(48, sizeof(float3x4.self))
-  expectEqual(32, sizeof(float4x2.self))
-  expectEqual(64, sizeof(float4x3.self))
-  expectEqual(64, sizeof(float4x4.self))
-
-  expectEqual(32, sizeof(double2x2.self))
-  expectEqual(64, sizeof(double2x3.self))
-  expectEqual(64, sizeof(double2x4.self))
-  expectEqual(48, sizeof(double3x2.self))
-  expectEqual(96, sizeof(double3x3.self))
-  expectEqual(96, sizeof(double3x4.self))
-  expectEqual(64, sizeof(double4x2.self))
-  expectEqual(128, sizeof(double4x3.self))
-  expectEqual(128, sizeof(double4x4.self))
+  expectEqual(8, MemoryLayout<float2>.size)
+  expectEqual(16, MemoryLayout<float3>.size)
+  expectEqual(16, MemoryLayout<float4>.size)
+  expectEqual(8, MemoryLayout<int2>.size)
+  expectEqual(16, MemoryLayout<int3>.size)
+  expectEqual(16, MemoryLayout<int4>.size)
+  expectEqual(16, MemoryLayout<double2>.size)
+  expectEqual(32, MemoryLayout<double3>.size)
+  expectEqual(32, MemoryLayout<double4>.size)
+
+  expectEqual(16, MemoryLayout<float2x2>.size)
+  expectEqual(32, MemoryLayout<float2x3>.size)
+  expectEqual(32, MemoryLayout<float2x4>.size)
+  expectEqual(24, MemoryLayout<float3x2>.size)
+  expectEqual(48, MemoryLayout<float3x3>.size)
+  expectEqual(48, MemoryLayout<float3x4>.size)
+  expectEqual(32, MemoryLayout<float4x2>.size)
+  expectEqual(64, MemoryLayout<float4x3>.size)
+  expectEqual(64, MemoryLayout<float4x4>.size)
+
+  expectEqual(32, MemoryLayout<double2x2>.size)
+  expectEqual(64, MemoryLayout<double2x3>.size)
+  expectEqual(64, MemoryLayout<double2x4>.size)
+  expectEqual(48, MemoryLayout<double3x2>.size)
+  expectEqual(96, MemoryLayout<double3x3>.size)
+  expectEqual(96, MemoryLayout<double3x4>.size)
+  expectEqual(64, MemoryLayout<double4x2>.size)
+  expectEqual(128, MemoryLayout<double4x3>.size)
+  expectEqual(128, MemoryLayout<double4x4>.size)
 }
 
 simdTestSuite.test("vector init") {

test/Constraints/diagnostics.swift

@@ -834,7 +834,7 @@ func read2(_ p: UnsafeMutableRawPointer, maxLength: Int) {}
 func read<T : Integer>() -> T? {
   var buffer : T 
   let n = withUnsafePointer(to: &buffer) { (p) in
-    read2(UnsafePointer(p), maxLength: sizeof(T)) // expected-error {{cannot convert value of type 'UnsafePointer<_>' to expected argument type 'UnsafeMutableRawPointer'}}
+    read2(UnsafePointer(p), maxLength: MemoryLayout<T>.size) // expected-error {{cannot convert value of type 'UnsafePointer<_>' to expected argument type 'UnsafeMutableRawPointer'}}
   }
 }
 

test/Interpreter/SDK/Accelerate.swift

@@ -10,7 +10,7 @@ extension vU1024: ExpressibleByIntegerLiteral, CustomStringConvertible, Equatabl
   public init(integerLiteral: Int) {
     var integerLiteral = integerLiteral
     self.init()
-    memcpy(&self, &integerLiteral, sizeof(Int.self))
+    memcpy(&self, &integerLiteral, MemoryLayout<Int>.size)
   }
 
   init(_ int: Int) {
@@ -37,7 +37,7 @@ extension Int {
     var u1024 = u1024
     // NB: Doesn't overflow check
     self.init()
-    memcpy(&self, &u1024, sizeof(Int.self))
+    memcpy(&self, &u1024, MemoryLayout<Int>.size)
   }
 }
 
@@ -61,7 +61,7 @@ func quorem(_ x: vU1024, _ y: vU1024) -> (vU1024, vU1024) {
 public func ==(x: vU1024, y: vU1024) -> Bool {
   var x = x
   var y = y
-  return memcmp(&x, &y, sizeof(vU1024.self)) == 0
+  return memcmp(&x, &y, MemoryLayout<vU1024>.size) == 0
 }
 
 func factorial(_ x: Int) -> vU1024 {