Skip to content

Commit 7883159

Browse files
glessardglessard
authored
Merge pull request #48 from glessard/alternate-cachealigned
Fix import of cache-line-padded types for Swift 5 compiler
2 parents 612ab68 + d8151e9 commit 7883159

File tree

5 files changed

+74
-61
lines changed

5 files changed

+74
-61
lines changed

‎Sources/CAtomics/include/CAtomics.h‎

Lines changed: 23 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -101,7 +101,7 @@ SWIFT_ENUM(CASType, closed)
101101
// atomic integer generation
102102

103103
#define CLANG_ATOMICS_STRUCT(swiftType, atomicType, atomName, alignment) \
104-
typedef struct { volatile atomicType atomName __attribute__ ((aligned(alignment))); } swiftType;
104+
typedef struct { volatile atomicType atomName; atomic_uchar padding[alignment-sizeof(atomicType)]; } swiftType;
105105

106106
#define CLANG_ATOMICS_IS_LOCK_FREE(swiftType) \
107107
static __inline__ __attribute__((__always_inline__)) \
@@ -213,9 +213,9 @@ CLANG_ATOMICS_INT_GENERATE(AtomicUInt64, atomic_ullong, unsigned long long, _Ali
213213
CLANG_ATOMICS_BOOL_GENERATE(AtomicBool, atomic_bool, _Bool, _Alignof(atomic_bool))
214214

215215
#ifdef __CACHE_LINE_WIDTH
216-
CLANG_ATOMICS_INT_GENERATE(AtomicCacheAlignedInt, atomic_intptr_t, intptr_t, __CACHE_LINE_WIDTH)
217-
CLANG_ATOMICS_INT_GENERATE(AtomicCacheAlignedUInt, atomic_uintptr_t, uintptr_t, __CACHE_LINE_WIDTH)
218-
CLANG_ATOMICS_BOOL_GENERATE(AtomicCacheAlignedBool, atomic_bool, _Bool, __CACHE_LINE_WIDTH)
216+
CLANG_ATOMICS_INT_GENERATE(AtomicPaddedInt, atomic_intptr_t, intptr_t, __CACHE_LINE_WIDTH)
217+
CLANG_ATOMICS_INT_GENERATE(AtomicPaddedUInt, atomic_uintptr_t, uintptr_t, __CACHE_LINE_WIDTH)
218+
CLANG_ATOMICS_BOOL_GENERATE(AtomicPaddedBool, atomic_bool, _Bool, __CACHE_LINE_WIDTH)
219219
#endif
220220

221221
// pointer atomics
@@ -290,10 +290,10 @@ CLANG_ATOMICS_POINTER_GENERATE(AtomicNonNullRawPointer, atomic_uintptr_t, const
290290
CLANG_ATOMICS_POINTER_GENERATE(AtomicOptionalRawPointer, atomic_uintptr_t, const void*, _Nullable, _Alignof(atomic_uintptr_t))
291291

292292
#ifdef __CACHE_LINE_WIDTH
293-
CLANG_ATOMICS_POINTER_GENERATE(AtomicCacheAlignedMutableRawPointer, atomic_uintptr_t, void*, _Nonnull, __CACHE_LINE_WIDTH)
294-
CLANG_ATOMICS_POINTER_GENERATE(AtomicCacheAlignedOptionalMutableRawPointer, atomic_uintptr_t, void*, _Nullable, __CACHE_LINE_WIDTH)
295-
CLANG_ATOMICS_POINTER_GENERATE(AtomicCacheAlignedRawPointer, atomic_uintptr_t, const void*, _Nonnull, __CACHE_LINE_WIDTH)
296-
CLANG_ATOMICS_POINTER_GENERATE(AtomicCacheAlignedOptionalRawPointer, atomic_uintptr_t, const void*, _Nullable, __CACHE_LINE_WIDTH)
293+
CLANG_ATOMICS_POINTER_GENERATE(AtomicPaddedMutableRawPointer, atomic_uintptr_t, void*, _Nonnull, __CACHE_LINE_WIDTH)
294+
CLANG_ATOMICS_POINTER_GENERATE(AtomicPaddedOptionalMutableRawPointer, atomic_uintptr_t, void*, _Nullable, __CACHE_LINE_WIDTH)
295+
CLANG_ATOMICS_POINTER_GENERATE(AtomicPaddedRawPointer, atomic_uintptr_t, const void*, _Nonnull, __CACHE_LINE_WIDTH)
296+
CLANG_ATOMICS_POINTER_GENERATE(AtomicPaddedOptionalRawPointer, atomic_uintptr_t, const void*, _Nullable, __CACHE_LINE_WIDTH)
297297
#endif
298298

299299
struct opaque;
@@ -415,19 +415,26 @@ CLANG_ATOMICS_TAGGED_POINTER_GENERATE(TaggedOptionalMutableRawPointer, void*, _N
415415
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicTaggedOptionalMutableRawPointer, TaggedOptionalMutableRawPointer, _Alignof(_Atomic(__UNION_TYPE)))
416416

417417
#ifdef __CACHE_LINE_WIDTH
418-
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicCacheAlignedTaggedRawPointer, TaggedRawPointer, __CACHE_LINE_WIDTH)
419-
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicCacheAlignedTaggedOptionalRawPointer, TaggedOptionalRawPointer, __CACHE_LINE_WIDTH)
420-
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicCacheAlignedTaggedMutableRawPointer, TaggedMutableRawPointer, __CACHE_LINE_WIDTH)
421-
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicCacheAlignedTaggedOptionalMutableRawPointer, TaggedOptionalMutableRawPointer, __CACHE_LINE_WIDTH)
418+
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicPaddedTaggedRawPointer, TaggedRawPointer, __CACHE_LINE_WIDTH)
419+
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicPaddedTaggedOptionalRawPointer, TaggedOptionalRawPointer, __CACHE_LINE_WIDTH)
420+
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicPaddedTaggedMutableRawPointer, TaggedMutableRawPointer, __CACHE_LINE_WIDTH)
421+
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicPaddedTaggedOptionalMutableRawPointer, TaggedOptionalMutableRawPointer, __CACHE_LINE_WIDTH)
422422
#endif
423423

424424
// non-atomic padded pointer wrappers
425425

426426
#ifdef __CACHE_LINE_WIDTH
427-
CLANG_ATOMICS_STRUCT(CacheAlignedRawPointer, const void *_Nonnull, pointer, __CACHE_LINE_WIDTH)
428-
CLANG_ATOMICS_STRUCT(CacheAlignedOptionalRawPointer, const void *_Nullable, pointer, __CACHE_LINE_WIDTH)
429-
CLANG_ATOMICS_STRUCT(CacheAlignedMutableRawPointer, void *_Nonnull, pointer, __CACHE_LINE_WIDTH)
430-
CLANG_ATOMICS_STRUCT(CacheAlignedOptionalMutableRawPointer, void *_Nullable, pointer, __CACHE_LINE_WIDTH)
427+
#define CLANG_ATOMICS_ALIGNED_POINTER_CREATE(swiftType, pointerType, nullability) \
428+
CLANG_ATOMICS_STRUCT(swiftType, pointerType nullability, pointer, __CACHE_LINE_WIDTH) \
429+
static __inline__ __attribute__((__always_inline__)) \
430+
SWIFT_NAME(swiftType.init(_:)) \
431+
swiftType swiftType##Create(pointerType nullability p) \
432+
{ swiftType s; s.pointer = p; return s; }
433+
434+
CLANG_ATOMICS_ALIGNED_POINTER_CREATE(PaddedRawPointer, const void*, _Nonnull)
435+
CLANG_ATOMICS_ALIGNED_POINTER_CREATE(PaddedOptionalRawPointer, const void*, _Nullable)
436+
CLANG_ATOMICS_ALIGNED_POINTER_CREATE(PaddedMutableRawPointer, void *, _Nonnull)
437+
CLANG_ATOMICS_ALIGNED_POINTER_CREATE(PaddedOptionalMutableRawPointer, void *, _Nullable)
431438
#endif
432439

433440
// fence

‎Tests/CAtomicsTests/CAtomicsTests.swift‎

Lines changed: 29 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -789,14 +789,14 @@ extension CAtomicsBasicTests
789789
XCTAssertEqual(r3, p.load(.relaxed))
790790
}
791791

792-
public func testAtomicCacheAlignedMutableRawPointer()
792+
public func testAtomicPaddedMutableRawPointer()
793793
{
794794
let r0 = UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())!
795795
let r1 = UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())!
796796
let r2 = UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())!
797797
let r3 = UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())!
798798

799-
var p = AtomicCacheAlignedMutableRawPointer(r3)
799+
var p = AtomicPaddedMutableRawPointer(r3)
800800
XCTAssertEqual(r3, p.load(.relaxed))
801801
XCTAssert(p.isLockFree())
802802

@@ -822,14 +822,14 @@ extension CAtomicsBasicTests
822822
XCTAssertEqual(r3, p.load(.relaxed))
823823
}
824824

825-
public func testAtomicCacheAlignedOptionalMutableRawPointer()
825+
public func testAtomicPaddedOptionalMutableRawPointer()
826826
{
827827
let r0 = UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())
828828
let r1 = UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())
829829
let r2 = UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())
830830
let r3 = UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())
831831

832-
var p = AtomicCacheAlignedOptionalMutableRawPointer(r3)
832+
var p = AtomicPaddedOptionalMutableRawPointer(r3)
833833
XCTAssertEqual(r3, p.load(.relaxed))
834834
XCTAssert(p.isLockFree())
835835

@@ -855,14 +855,14 @@ extension CAtomicsBasicTests
855855
XCTAssertEqual(r3, p.load(.relaxed))
856856
}
857857

858-
public func testAtomicCacheAlignedRawPointer()
858+
public func testAtomicPaddedRawPointer()
859859
{
860860
let r0 = UnsafeRawPointer(bitPattern: UInt.randomPositive())!
861861
let r1 = UnsafeRawPointer(bitPattern: UInt.randomPositive())!
862862
let r2 = UnsafeRawPointer(bitPattern: UInt.randomPositive())!
863863
let r3 = UnsafeRawPointer(bitPattern: UInt.randomPositive())!
864864

865-
var p = AtomicCacheAlignedRawPointer(r3)
865+
var p = AtomicPaddedRawPointer(r3)
866866
XCTAssertEqual(r3, p.load(.relaxed))
867867
XCTAssert(p.isLockFree())
868868

@@ -888,14 +888,14 @@ extension CAtomicsBasicTests
888888
XCTAssertEqual(r3, p.load(.relaxed))
889889
}
890890

891-
public func testAtomicCacheAlignedOptionalRawPointer()
891+
public func testAtomicPaddedOptionalRawPointer()
892892
{
893893
let r0 = UnsafeRawPointer(bitPattern: UInt.randomPositive())
894894
let r1 = UnsafeRawPointer(bitPattern: UInt.randomPositive())
895895
let r2 = UnsafeRawPointer(bitPattern: UInt.randomPositive())
896896
let r3 = UnsafeRawPointer(bitPattern: UInt.randomPositive())
897897

898-
var p = AtomicCacheAlignedOptionalRawPointer(r3)
898+
var p = AtomicPaddedOptionalRawPointer(r3)
899899
XCTAssertEqual(r3, p.load(.relaxed))
900900
XCTAssert(p.isLockFree())
901901

@@ -1095,14 +1095,14 @@ extension CAtomicsBasicTests
10951095
XCTAssertEqual(r3, p.load(.relaxed))
10961096
}
10971097

1098-
public func testAtomicCacheAlignedTaggedRawPointer()
1098+
public func testAtomicPaddedTaggedRawPointer()
10991099
{
11001100
let r0 = TaggedRawPointer(UnsafeRawPointer(bitPattern: UInt.randomPositive())!, tag: 0)
11011101
let r1 = TaggedRawPointer(UnsafeRawPointer(bitPattern: UInt.randomPositive())!, tag: 1)
11021102
let r2 = TaggedRawPointer(UnsafeRawPointer(bitPattern: UInt.randomPositive())!, tag: 2)
11031103
let r3 = r2.incremented()
11041104

1105-
var p = AtomicCacheAlignedTaggedRawPointer(r3)
1105+
var p = AtomicPaddedTaggedRawPointer(r3)
11061106
XCTAssertEqual(r3, p.load(.relaxed))
11071107
XCTAssert(p.isLockFree())
11081108

@@ -1192,14 +1192,14 @@ extension CAtomicsBasicTests
11921192
XCTAssertEqual(r3, p.load(.relaxed))
11931193
}
11941194

1195-
public func testAtomicCacheAlignedTaggedMutableRawPointer()
1195+
public func testAtomicPaddedTaggedMutableRawPointer()
11961196
{
11971197
let r0 = TaggedMutableRawPointer(UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())!, tag: 0)
11981198
let r1 = TaggedMutableRawPointer(UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())!, tag: 1)
11991199
let r2 = TaggedMutableRawPointer(UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())!, tag: 2)
12001200
let r3 = r2.incremented()
12011201

1202-
var p = AtomicCacheAlignedTaggedMutableRawPointer(r3)
1202+
var p = AtomicPaddedTaggedMutableRawPointer(r3)
12031203
XCTAssertEqual(r3, p.load(.relaxed))
12041204
XCTAssert(p.isLockFree())
12051205

@@ -1289,14 +1289,14 @@ extension CAtomicsBasicTests
12891289
XCTAssertEqual(r3, p.load(.relaxed))
12901290
}
12911291

1292-
public func testAtomicCacheAlignedTaggedOptionalRawPointer()
1292+
public func testAtomicPaddedTaggedOptionalRawPointer()
12931293
{
12941294
let r0 = TaggedOptionalRawPointer(UnsafeRawPointer(bitPattern: UInt.randomPositive()), tag: 0)
12951295
let r1 = TaggedOptionalRawPointer(UnsafeRawPointer(bitPattern: UInt.randomPositive()), tag: 1)
12961296
let r2 = TaggedOptionalRawPointer(UnsafeRawPointer(bitPattern: UInt.randomPositive()), tag: 2)
12971297
let r3 = r2.incremented()
12981298

1299-
var p = AtomicCacheAlignedTaggedOptionalRawPointer(r3)
1299+
var p = AtomicPaddedTaggedOptionalRawPointer(r3)
13001300
XCTAssertEqual(r3, p.load(.relaxed))
13011301
XCTAssert(p.isLockFree())
13021302

@@ -1386,14 +1386,14 @@ extension CAtomicsBasicTests
13861386
XCTAssertEqual(r3, p.load(.relaxed))
13871387
}
13881388

1389-
public func testAtomicCacheAlignedTaggedOptionalMutableRawPointer()
1389+
public func testAtomicPaddedTaggedOptionalMutableRawPointer()
13901390
{
13911391
let r0 = TaggedOptionalMutableRawPointer(UnsafeMutableRawPointer(bitPattern: UInt.randomPositive()), tag: 0)
13921392
let r1 = TaggedOptionalMutableRawPointer(UnsafeMutableRawPointer(bitPattern: UInt.randomPositive()), tag: 1)
13931393
let r2 = TaggedOptionalMutableRawPointer(UnsafeMutableRawPointer(bitPattern: UInt.randomPositive()), tag: 2)
13941394
let r3 = r2.incremented()
13951395

1396-
var p = AtomicCacheAlignedTaggedOptionalMutableRawPointer(r3)
1396+
var p = AtomicPaddedTaggedOptionalMutableRawPointer(r3)
13971397
XCTAssertEqual(r3, p.load(.relaxed))
13981398
XCTAssert(p.isLockFree())
13991399

@@ -1419,37 +1419,41 @@ extension CAtomicsBasicTests
14191419
XCTAssertEqual(r3, p.load(.relaxed))
14201420
}
14211421

1422-
public func testCacheAlignedPointers()
1422+
public func testPaddedPointers()
14231423
{
14241424
var p: UnsafeMutableRawPointer?
14251425

14261426
p = UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())
1427-
let c1 = CacheAlignedOptionalRawPointer(pointer: p)
1427+
let c1 = PaddedOptionalRawPointer(p)
14281428
XCTAssertGreaterThan(MemoryLayout.size(ofValue: c1), MemoryLayout.size(ofValue: c1.pointer))
1429-
XCTAssertGreaterThan(MemoryLayout.alignment(ofValue: c1), MemoryLayout.alignment(ofValue: c1.pointer))
1429+
XCTAssertEqual(MemoryLayout.alignment(ofValue: c1), MemoryLayout.alignment(ofValue: c1.pointer))
14301430
XCTAssertGreaterThan(MemoryLayout.stride(ofValue: c1), MemoryLayout.stride(ofValue: c1.pointer))
1431+
XCTAssertEqual(MemoryLayout.stride(ofValue: c1), 64)
14311432
if let p1 = c1.pointer
14321433
{
1433-
let c2 = CacheAlignedRawPointer(pointer: p1)
1434+
let c2 = PaddedRawPointer(p1)
14341435
XCTAssertGreaterThan(MemoryLayout.size(ofValue: c2), MemoryLayout.size(ofValue: c2.pointer))
1435-
XCTAssertGreaterThan(MemoryLayout.alignment(ofValue: c2), MemoryLayout.alignment(ofValue: c2.pointer))
1436+
XCTAssertEqual(MemoryLayout.alignment(ofValue: c2), MemoryLayout.alignment(ofValue: c2.pointer))
14361437
XCTAssertGreaterThan(MemoryLayout.stride(ofValue: c2), MemoryLayout.stride(ofValue: c2.pointer))
1438+
XCTAssertEqual(MemoryLayout.stride(ofValue: c2), 64)
14371439
let p2 = c2.pointer
14381440
XCTAssert(p1 == p2)
14391441
XCTAssert(Int(bitPattern: p2) == Int(bitPattern: p))
14401442
}
14411443

14421444
p = UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())
1443-
let m1 = CacheAlignedOptionalMutableRawPointer(pointer: p)
1445+
let m1 = PaddedOptionalMutableRawPointer(p)
14441446
XCTAssertGreaterThan(MemoryLayout.size(ofValue: m1), MemoryLayout.size(ofValue: m1.pointer))
1445-
XCTAssertGreaterThan(MemoryLayout.alignment(ofValue: m1), MemoryLayout.alignment(ofValue: m1.pointer))
1447+
XCTAssertEqual(MemoryLayout.alignment(ofValue: m1), MemoryLayout.alignment(ofValue: m1.pointer))
14461448
XCTAssertGreaterThan(MemoryLayout.stride(ofValue: m1), MemoryLayout.stride(ofValue: m1.pointer))
1449+
XCTAssertEqual(MemoryLayout.stride(ofValue: m1), 64)
14471450
if let p1 = m1.pointer
14481451
{
1449-
let m2 = CacheAlignedMutableRawPointer(pointer: p1)
1452+
let m2 = PaddedMutableRawPointer(p1)
14501453
XCTAssertGreaterThan(MemoryLayout.size(ofValue: m2), MemoryLayout.size(ofValue: m2.pointer))
1451-
XCTAssertGreaterThan(MemoryLayout.alignment(ofValue: m2), MemoryLayout.alignment(ofValue: m2.pointer))
1454+
XCTAssertEqual(MemoryLayout.alignment(ofValue: m2), MemoryLayout.alignment(ofValue: m2.pointer))
14521455
XCTAssertGreaterThan(MemoryLayout.stride(ofValue: m2), MemoryLayout.stride(ofValue: m2.pointer))
1456+
XCTAssertEqual(MemoryLayout.stride(ofValue: m2), 64)
14531457
let p2 = m2.pointer
14541458
XCTAssert(p1 == p2)
14551459
XCTAssert(Int(bitPattern: p2) == Int(bitPattern: p))

‎Tests/CAtomicsTests/CAtomicsTests.swift.gyb‎

Lines changed: 9 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -128,7 +128,7 @@ public class CAtomicsBasicTests: XCTestCase
128128
}
129129
}
130130

131-
% pointers = ['AtomicOptionalRawPointer', 'AtomicNonNullRawPointer', 'AtomicNonNullMutableRawPointer', 'AtomicOptionalMutableRawPointer', 'AtomicCacheAlignedMutableRawPointer', 'AtomicCacheAlignedOptionalMutableRawPointer', 'AtomicCacheAlignedRawPointer', 'AtomicCacheAlignedOptionalRawPointer', 'AtomicNonNullOpaquePointer', 'AtomicOptionalOpaquePointer']
131+
% pointers = ['AtomicOptionalRawPointer', 'AtomicNonNullRawPointer', 'AtomicNonNullMutableRawPointer', 'AtomicOptionalMutableRawPointer', 'AtomicPaddedMutableRawPointer', 'AtomicPaddedOptionalMutableRawPointer', 'AtomicPaddedRawPointer', 'AtomicPaddedOptionalRawPointer', 'AtomicNonNullOpaquePointer', 'AtomicOptionalOpaquePointer']
132132
extension CAtomicsBasicTests
133133
{
134134
% for type in pointers:
@@ -245,7 +245,7 @@ extension CAtomicsBasicTests
245245
XCTAssertEqual(r3, r4)
246246
}
247247

248-
% for aligned in ['', 'CacheAligned']:
248+
% for aligned in ['', 'Padded']:
249249
% atomicType = 'Atomic' + aligned + taggedType
250250
public func test${atomicType}()
251251
{
@@ -284,23 +284,25 @@ extension CAtomicsBasicTests
284284
% end
285285
% end
286286
% end
287-
public func testCacheAlignedPointers()
287+
public func testPaddedPointers()
288288
{
289289
var p: UnsafeMutableRawPointer?
290290
% for mutable in ['', 'Mutable']:
291291
% variable = 'm' if mutable is 'Mutable' else 'c'
292292

293293
p = UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())
294-
let ${variable}1 = CacheAlignedOptional${mutable}RawPointer(pointer: p)
294+
let ${variable}1 = PaddedOptional${mutable}RawPointer(p)
295295
XCTAssertGreaterThan(MemoryLayout.size(ofValue: ${variable}1), MemoryLayout.size(ofValue: ${variable}1.pointer))
296-
XCTAssertGreaterThan(MemoryLayout.alignment(ofValue: ${variable}1), MemoryLayout.alignment(ofValue: ${variable}1.pointer))
296+
XCTAssertEqual(MemoryLayout.alignment(ofValue: ${variable}1), MemoryLayout.alignment(ofValue: ${variable}1.pointer))
297297
XCTAssertGreaterThan(MemoryLayout.stride(ofValue: ${variable}1), MemoryLayout.stride(ofValue: ${variable}1.pointer))
298+
XCTAssertEqual(MemoryLayout.stride(ofValue: ${variable}1), 64)
298299
if let p1 = ${variable}1.pointer
299300
{
300-
let ${variable}2 = CacheAligned${mutable}RawPointer(pointer: p1)
301+
let ${variable}2 = Padded${mutable}RawPointer(p1)
301302
XCTAssertGreaterThan(MemoryLayout.size(ofValue: ${variable}2), MemoryLayout.size(ofValue: ${variable}2.pointer))
302-
XCTAssertGreaterThan(MemoryLayout.alignment(ofValue: ${variable}2), MemoryLayout.alignment(ofValue: ${variable}2.pointer))
303+
XCTAssertEqual(MemoryLayout.alignment(ofValue: ${variable}2), MemoryLayout.alignment(ofValue: ${variable}2.pointer))
303304
XCTAssertGreaterThan(MemoryLayout.stride(ofValue: ${variable}2), MemoryLayout.stride(ofValue: ${variable}2.pointer))
305+
XCTAssertEqual(MemoryLayout.stride(ofValue: ${variable}2), 64)
304306
let p2 = ${variable}2.pointer
305307
XCTAssert(p1 == p2)
306308
XCTAssert(Int(bitPattern: p2) == Int(bitPattern: p))

‎Tests/CAtomicsTests/XCTestManifests.swift‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -2,32 +2,32 @@ import XCTest
22

33
extension CAtomicsBasicTests {
44
static let __allTests = [
5-
("testAtomicCacheAlignedMutableRawPointer", testAtomicCacheAlignedMutableRawPointer),
6-
("testAtomicCacheAlignedOptionalMutableRawPointer", testAtomicCacheAlignedOptionalMutableRawPointer),
7-
("testAtomicCacheAlignedOptionalRawPointer", testAtomicCacheAlignedOptionalRawPointer),
8-
("testAtomicCacheAlignedRawPointer", testAtomicCacheAlignedRawPointer),
9-
("testAtomicCacheAlignedTaggedMutableRawPointer", testAtomicCacheAlignedTaggedMutableRawPointer),
10-
("testAtomicCacheAlignedTaggedOptionalMutableRawPointer", testAtomicCacheAlignedTaggedOptionalMutableRawPointer),
11-
("testAtomicCacheAlignedTaggedOptionalRawPointer", testAtomicCacheAlignedTaggedOptionalRawPointer),
12-
("testAtomicCacheAlignedTaggedRawPointer", testAtomicCacheAlignedTaggedRawPointer),
135
("testAtomicNonNullMutableRawPointer", testAtomicNonNullMutableRawPointer),
146
("testAtomicNonNullOpaquePointer", testAtomicNonNullOpaquePointer),
157
("testAtomicNonNullRawPointer", testAtomicNonNullRawPointer),
168
("testAtomicOptionalMutableRawPointer", testAtomicOptionalMutableRawPointer),
179
("testAtomicOptionalOpaquePointer", testAtomicOptionalOpaquePointer),
1810
("testAtomicOptionalRawPointer", testAtomicOptionalRawPointer),
11+
("testAtomicPaddedMutableRawPointer", testAtomicPaddedMutableRawPointer),
12+
("testAtomicPaddedOptionalMutableRawPointer", testAtomicPaddedOptionalMutableRawPointer),
13+
("testAtomicPaddedOptionalRawPointer", testAtomicPaddedOptionalRawPointer),
14+
("testAtomicPaddedRawPointer", testAtomicPaddedRawPointer),
15+
("testAtomicPaddedTaggedMutableRawPointer", testAtomicPaddedTaggedMutableRawPointer),
16+
("testAtomicPaddedTaggedOptionalMutableRawPointer", testAtomicPaddedTaggedOptionalMutableRawPointer),
17+
("testAtomicPaddedTaggedOptionalRawPointer", testAtomicPaddedTaggedOptionalRawPointer),
18+
("testAtomicPaddedTaggedRawPointer", testAtomicPaddedTaggedRawPointer),
1919
("testAtomicTaggedMutableRawPointer", testAtomicTaggedMutableRawPointer),
2020
("testAtomicTaggedOptionalMutableRawPointer", testAtomicTaggedOptionalMutableRawPointer),
2121
("testAtomicTaggedOptionalRawPointer", testAtomicTaggedOptionalRawPointer),
2222
("testAtomicTaggedRawPointer", testAtomicTaggedRawPointer),
2323
("testBool", testBool),
24-
("testCacheAlignedPointers", testCacheAlignedPointers),
2524
("testFence", testFence),
2625
("testInt", testInt),
2726
("testInt16", testInt16),
2827
("testInt32", testInt32),
2928
("testInt64", testInt64),
3029
("testInt8", testInt8),
30+
("testPaddedPointers", testPaddedPointers),
3131
("testTaggedMutableRawPointer", testTaggedMutableRawPointer),
3232
("testTaggedOptionalMutableRawPointer", testTaggedOptionalMutableRawPointer),
3333
("testTaggedOptionalRawPointer", testTaggedOptionalRawPointer),

0 commit comments

Comments
 (0)