Skip to content

Commit b2c3c71

Browse files
glessardglessard
authored
Merge pull request #46 from glessard/padded
added non-atomic pointer wrappers padded and aligned to cache lines
2 parents 18c0c44 + 017b05b commit b2c3c71

File tree

4 files changed

+115
-43
lines changed

4 files changed

+115
-43
lines changed

‎Sources/CAtomics/include/CAtomics.h‎

Lines changed: 29 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -100,8 +100,8 @@ SWIFT_ENUM(CASType, closed)
100100

101101
// atomic integer generation
102102

103-
#define CLANG_ATOMICS_STRUCT(swiftType, atomicType, alignment) \
104-
typedef struct { volatile atomicType a __attribute__ ((aligned(alignment))); } swiftType;
103+
#define CLANG_ATOMICS_STRUCT(swiftType, atomicType, atomName, alignment) \
104+
typedef struct { volatile atomicType atomName __attribute__ ((aligned(alignment))); } swiftType;
105105

106106
#define CLANG_ATOMICS_IS_LOCK_FREE(swiftType) \
107107
static __inline__ __attribute__((__always_inline__)) \
@@ -168,7 +168,7 @@ SWIFT_ENUM(CASType, closed)
168168
}
169169

170170
#define CLANG_ATOMICS_GENERATE(swiftType, atomicType, parameterType, alignment) \
171-
CLANG_ATOMICS_STRUCT(swiftType, atomicType, alignment) \
171+
CLANG_ATOMICS_STRUCT(swiftType, atomicType, a, alignment) \
172172
CLANG_ATOMICS_IS_LOCK_FREE(swiftType) \
173173
CLANG_ATOMICS_INITIALIZE(swiftType, parameterType) \
174174
CLANG_ATOMICS_CREATE(swiftType, parameterType) \
@@ -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(AtomicCacheLineAlignedInt, atomic_intptr_t, intptr_t, __CACHE_LINE_WIDTH)
217-
CLANG_ATOMICS_INT_GENERATE(AtomicCacheLineAlignedUInt, atomic_uintptr_t, uintptr_t, __CACHE_LINE_WIDTH)
218-
CLANG_ATOMICS_BOOL_GENERATE(AtomicCacheLineAlignedBool, atomic_bool, _Bool, __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)
219219
#endif
220220

221221
// pointer atomics
@@ -273,7 +273,7 @@ CLANG_ATOMICS_BOOL_GENERATE(AtomicCacheLineAlignedBool, atomic_bool, _Bool, __CA
273273
}
274274

275275
#define CLANG_ATOMICS_POINTER_GENERATE(swiftType, atomicType, parameterType, nullability, alignment) \
276-
CLANG_ATOMICS_STRUCT(swiftType, atomicType, alignment) \
276+
CLANG_ATOMICS_STRUCT(swiftType, atomicType, a, alignment) \
277277
CLANG_ATOMICS_IS_LOCK_FREE(swiftType) \
278278
CLANG_ATOMICS_POINTER_INITIALIZE(swiftType, parameterType, nullability) \
279279
CLANG_ATOMICS_POINTER_CREATE(swiftType, parameterType, nullability) \
@@ -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(AtomicCacheLineAlignedMutableRawPointer, atomic_uintptr_t, void*, _Nonnull, __CACHE_LINE_WIDTH)
294-
CLANG_ATOMICS_POINTER_GENERATE(AtomicCacheLineAlignedOptionalMutableRawPointer, atomic_uintptr_t, void*, _Nullable, __CACHE_LINE_WIDTH)
295-
CLANG_ATOMICS_POINTER_GENERATE(AtomicCacheLineAlignedRawPointer, atomic_uintptr_t, const void*, _Nonnull, __CACHE_LINE_WIDTH)
296-
CLANG_ATOMICS_POINTER_GENERATE(AtomicCacheLineAlignedOptionalRawPointer, atomic_uintptr_t, const void*, _Nullable, __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)
297297
#endif
298298

299299
struct opaque;
@@ -394,7 +394,7 @@ CLANG_ATOMICS_POINTER_GENERATE(AtomicOptionalOpaquePointer, atomic_uintptr_t, st
394394
CLANG_ATOMICS_TAGGED_POINTER_INCREMENT(swiftType, pointerType, nullability)
395395

396396
#define CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(atomicType, structType, alignment) \
397-
CLANG_ATOMICS_STRUCT(atomicType, _Atomic(__UNION_TYPE), alignment) \
397+
CLANG_ATOMICS_STRUCT(atomicType, _Atomic(__UNION_TYPE), a, alignment) \
398398
CLANG_ATOMICS_IS_LOCK_FREE(atomicType) \
399399
CLANG_ATOMICS_TAGGED_POINTER_INITIALIZE(atomicType, structType) \
400400
CLANG_ATOMICS_TAGGED_POINTER_LOAD(atomicType, structType) \
@@ -404,19 +404,31 @@ CLANG_ATOMICS_POINTER_GENERATE(AtomicOptionalOpaquePointer, atomic_uintptr_t, st
404404

405405
CLANG_ATOMICS_TAGGED_POINTER_GENERATE(TaggedRawPointer, const void*, _Nonnull)
406406
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicTaggedRawPointer, TaggedRawPointer, _Alignof(_Atomic(__UNION_TYPE)))
407-
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicCacheLineAlignedTaggedRawPointer, TaggedRawPointer, __CACHE_LINE_WIDTH)
408407

409408
CLANG_ATOMICS_TAGGED_POINTER_GENERATE(TaggedOptionalRawPointer, const void*, _Nullable)
410409
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicTaggedOptionalRawPointer, TaggedOptionalRawPointer, _Alignof(_Atomic(__UNION_TYPE)))
411-
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicCacheLineAlignedTaggedOptionalRawPointer, TaggedOptionalRawPointer, __CACHE_LINE_WIDTH)
412410

413411
CLANG_ATOMICS_TAGGED_POINTER_GENERATE(TaggedMutableRawPointer, void*, _Nonnull)
414412
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicTaggedMutableRawPointer, TaggedMutableRawPointer, _Alignof(_Atomic(__UNION_TYPE)))
415-
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicCacheLineAlignedTaggedMutableRawPointer, TaggedMutableRawPointer, __CACHE_LINE_WIDTH)
416413

417414
CLANG_ATOMICS_TAGGED_POINTER_GENERATE(TaggedOptionalMutableRawPointer, void*, _Nullable)
418415
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicTaggedOptionalMutableRawPointer, TaggedOptionalMutableRawPointer, _Alignof(_Atomic(__UNION_TYPE)))
419-
CLANG_ATOMICS_ATOMIC_TAGGED_POINTER_GENERATE(AtomicCacheLineAlignedTaggedOptionalMutableRawPointer, TaggedOptionalMutableRawPointer, __CACHE_LINE_WIDTH)
416+
417+
#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)
422+
#endif
423+
424+
// non-atomic padded pointer wrappers
425+
426+
#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)
431+
#endif
420432

421433
// fence
422434

@@ -431,7 +443,7 @@ void CAtomicsThreadFence(enum MemoryOrder order)
431443
#define __OPAQUE_UNMANAGED_LOCKED (uintptr_t)0x7
432444
#define __OPAQUE_UNMANAGED_SPINMASK (char)0xc0
433445

434-
CLANG_ATOMICS_STRUCT(OpaqueUnmanagedHelper, atomic_uintptr_t, _Alignof(atomic_uintptr_t))
446+
CLANG_ATOMICS_STRUCT(OpaqueUnmanagedHelper, atomic_uintptr_t, a, _Alignof(atomic_uintptr_t))
435447
CLANG_ATOMICS_IS_LOCK_FREE(OpaqueUnmanagedHelper)
436448
CLANG_ATOMICS_POINTER_INITIALIZE(OpaqueUnmanagedHelper, const void*, _Nullable)
437449

‎Tests/CAtomicsTests/CAtomicsTests.swift‎

Lines changed: 52 additions & 16 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 testAtomicCacheLineAlignedMutableRawPointer()
792+
public func testAtomicCacheAlignedMutableRawPointer()
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 = AtomicCacheLineAlignedMutableRawPointer(r3)
799+
var p = AtomicCacheAlignedMutableRawPointer(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 testAtomicCacheLineAlignedOptionalMutableRawPointer()
825+
public func testAtomicCacheAlignedOptionalMutableRawPointer()
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 = AtomicCacheLineAlignedOptionalMutableRawPointer(r3)
832+
var p = AtomicCacheAlignedOptionalMutableRawPointer(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 testAtomicCacheLineAlignedRawPointer()
858+
public func testAtomicCacheAlignedRawPointer()
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 = AtomicCacheLineAlignedRawPointer(r3)
865+
var p = AtomicCacheAlignedRawPointer(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 testAtomicCacheLineAlignedOptionalRawPointer()
891+
public func testAtomicCacheAlignedOptionalRawPointer()
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 = AtomicCacheLineAlignedOptionalRawPointer(r3)
898+
var p = AtomicCacheAlignedOptionalRawPointer(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 testAtomicCacheLineAlignedTaggedRawPointer()
1098+
public func testAtomicCacheAlignedTaggedRawPointer()
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 = AtomicCacheLineAlignedTaggedRawPointer(r3)
1105+
var p = AtomicCacheAlignedTaggedRawPointer(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 testAtomicCacheLineAlignedTaggedMutableRawPointer()
1195+
public func testAtomicCacheAlignedTaggedMutableRawPointer()
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 = AtomicCacheLineAlignedTaggedMutableRawPointer(r3)
1202+
var p = AtomicCacheAlignedTaggedMutableRawPointer(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 testAtomicCacheLineAlignedTaggedOptionalRawPointer()
1292+
public func testAtomicCacheAlignedTaggedOptionalRawPointer()
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 = AtomicCacheLineAlignedTaggedOptionalRawPointer(r3)
1299+
var p = AtomicCacheAlignedTaggedOptionalRawPointer(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 testAtomicCacheLineAlignedTaggedOptionalMutableRawPointer()
1389+
public func testAtomicCacheAlignedTaggedOptionalMutableRawPointer()
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 = AtomicCacheLineAlignedTaggedOptionalMutableRawPointer(r3)
1396+
var p = AtomicCacheAlignedTaggedOptionalMutableRawPointer(r3)
13971397
XCTAssertEqual(r3, p.load(.relaxed))
13981398
XCTAssert(p.isLockFree())
13991399

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

1422+
public func testCacheAlignedPointers()
1423+
{
1424+
var p: UnsafeMutableRawPointer?
1425+
1426+
p = UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())
1427+
let c1 = CacheAlignedOptionalRawPointer(pointer: p)
1428+
XCTAssert(MemoryLayout.size(ofValue: c1) > MemoryLayout.size(ofValue: c1.pointer))
1429+
XCTAssert(MemoryLayout.alignment(ofValue: c1) > MemoryLayout.alignment(ofValue: c1.pointer))
1430+
XCTAssert(MemoryLayout.stride(ofValue: c1) > MemoryLayout.stride(ofValue: c1.pointer))
1431+
if let p1 = c1.pointer
1432+
{
1433+
let c2 = CacheAlignedRawPointer(pointer: p1)
1434+
XCTAssert(MemoryLayout.size(ofValue: c2) > MemoryLayout.size(ofValue: c2.pointer))
1435+
XCTAssert(MemoryLayout.alignment(ofValue: c2) > MemoryLayout.alignment(ofValue: c2.pointer))
1436+
XCTAssert(MemoryLayout.stride(ofValue: c2) > MemoryLayout.stride(ofValue: c2.pointer))
1437+
let p2 = c2.pointer
1438+
XCTAssert(p1 == p2)
1439+
XCTAssert(Int(bitPattern: p2) == Int(bitPattern: p))
1440+
}
1441+
1442+
p = UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())
1443+
let m1 = CacheAlignedOptionalMutableRawPointer(pointer: p)
1444+
XCTAssert(MemoryLayout.size(ofValue: m1) > MemoryLayout.size(ofValue: m1.pointer))
1445+
XCTAssert(MemoryLayout.alignment(ofValue: m1) > MemoryLayout.alignment(ofValue: m1.pointer))
1446+
XCTAssert(MemoryLayout.stride(ofValue: m1) > MemoryLayout.stride(ofValue: m1.pointer))
1447+
if let p1 = m1.pointer
1448+
{
1449+
let m2 = CacheAlignedMutableRawPointer(pointer: p1)
1450+
XCTAssert(MemoryLayout.size(ofValue: m2) > MemoryLayout.size(ofValue: m2.pointer))
1451+
XCTAssert(MemoryLayout.alignment(ofValue: m2) > MemoryLayout.alignment(ofValue: m2.pointer))
1452+
XCTAssert(MemoryLayout.stride(ofValue: m2) > MemoryLayout.stride(ofValue: m2.pointer))
1453+
let p2 = m2.pointer
1454+
XCTAssert(p1 == p2)
1455+
XCTAssert(Int(bitPattern: p2) == Int(bitPattern: p))
1456+
}
1457+
}
14221458
}

‎Tests/CAtomicsTests/CAtomicsTests.swift.gyb‎

Lines changed: 25 additions & 2 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', 'AtomicCacheLineAlignedMutableRawPointer', 'AtomicCacheLineAlignedOptionalMutableRawPointer', 'AtomicCacheLineAlignedRawPointer', 'AtomicCacheLineAlignedOptionalRawPointer', 'AtomicNonNullOpaquePointer', 'AtomicOptionalOpaquePointer']
131+
% pointers = ['AtomicOptionalRawPointer', 'AtomicNonNullRawPointer', 'AtomicNonNullMutableRawPointer', 'AtomicOptionalMutableRawPointer', 'AtomicCacheAlignedMutableRawPointer', 'AtomicCacheAlignedOptionalMutableRawPointer', 'AtomicCacheAlignedRawPointer', 'AtomicCacheAlignedOptionalRawPointer', '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 ['', 'CacheLineAligned']:
248+
% for aligned in ['', 'CacheAligned']:
249249
% atomicType = 'Atomic' + aligned + taggedType
250250
public func test${atomicType}()
251251
{
@@ -284,4 +284,27 @@ extension CAtomicsBasicTests
284284
% end
285285
% end
286286
% end
287+
public func testCacheAlignedPointers()
288+
{
289+
var p: UnsafeMutableRawPointer?
290+
% for mutable in ['', 'Mutable']:
291+
% variable = 'm' if mutable is 'Mutable' else 'c'
292+
293+
p = UnsafeMutableRawPointer(bitPattern: UInt.randomPositive())
294+
let ${variable}1 = CacheAlignedOptional${mutable}RawPointer(pointer: p)
295+
XCTAssert(MemoryLayout.size(ofValue: ${variable}1) > MemoryLayout.size(ofValue: ${variable}1.pointer))
296+
XCTAssert(MemoryLayout.alignment(ofValue: ${variable}1) > MemoryLayout.alignment(ofValue: ${variable}1.pointer))
297+
XCTAssert(MemoryLayout.stride(ofValue: ${variable}1) > MemoryLayout.stride(ofValue: ${variable}1.pointer))
298+
if let p1 = ${variable}1.pointer
299+
{
300+
let ${variable}2 = CacheAligned${mutable}RawPointer(pointer: p1)
301+
XCTAssert(MemoryLayout.size(ofValue: ${variable}2) > MemoryLayout.size(ofValue: ${variable}2.pointer))
302+
XCTAssert(MemoryLayout.alignment(ofValue: ${variable}2) > MemoryLayout.alignment(ofValue: ${variable}2.pointer))
303+
XCTAssert(MemoryLayout.stride(ofValue: ${variable}2) > MemoryLayout.stride(ofValue: ${variable}2.pointer))
304+
let p2 = ${variable}2.pointer
305+
XCTAssert(p1 == p2)
306+
XCTAssert(Int(bitPattern: p2) == Int(bitPattern: p))
307+
}
308+
% end
309+
}
287310
}

‎Tests/CAtomicsTests/XCTestManifests.swift‎

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

33
extension CAtomicsBasicTests {
44
static let __allTests = [
5-
("testAtomicCacheLineAlignedMutableRawPointer", testAtomicCacheLineAlignedMutableRawPointer),
6-
("testAtomicCacheLineAlignedOptionalMutableRawPointer", testAtomicCacheLineAlignedOptionalMutableRawPointer),
7-
("testAtomicCacheLineAlignedOptionalRawPointer", testAtomicCacheLineAlignedOptionalRawPointer),
8-
("testAtomicCacheLineAlignedRawPointer", testAtomicCacheLineAlignedRawPointer),
9-
("testAtomicCacheLineAlignedTaggedMutableRawPointer", testAtomicCacheLineAlignedTaggedMutableRawPointer),
10-
("testAtomicCacheLineAlignedTaggedOptionalMutableRawPointer", testAtomicCacheLineAlignedTaggedOptionalMutableRawPointer),
11-
("testAtomicCacheLineAlignedTaggedOptionalRawPointer", testAtomicCacheLineAlignedTaggedOptionalRawPointer),
12-
("testAtomicCacheLineAlignedTaggedRawPointer", testAtomicCacheLineAlignedTaggedRawPointer),
5+
("testAtomicCacheAlignedMutableRawPointer", testAtomicCacheAlignedMutableRawPointer),
6+
("testAtomicCacheAlignedOptionalMutableRawPointer", testAtomicCacheAlignedOptionalMutableRawPointer),
7+
("testAtomicCacheAlignedOptionalRawPointer", testAtomicCacheAlignedOptionalRawPointer),
8+
("testAtomicCacheAlignedRawPointer", testAtomicCacheAlignedRawPointer),
9+
("testAtomicCacheAlignedTaggedMutableRawPointer", testAtomicCacheAlignedTaggedMutableRawPointer),
10+
("testAtomicCacheAlignedTaggedOptionalMutableRawPointer", testAtomicCacheAlignedTaggedOptionalMutableRawPointer),
11+
("testAtomicCacheAlignedTaggedOptionalRawPointer", testAtomicCacheAlignedTaggedOptionalRawPointer),
12+
("testAtomicCacheAlignedTaggedRawPointer", testAtomicCacheAlignedTaggedRawPointer),
1313
("testAtomicNonNullMutableRawPointer", testAtomicNonNullMutableRawPointer),
1414
("testAtomicNonNullOpaquePointer", testAtomicNonNullOpaquePointer),
1515
("testAtomicNonNullRawPointer", testAtomicNonNullRawPointer),
@@ -21,6 +21,7 @@ extension CAtomicsBasicTests {
2121
("testAtomicTaggedOptionalRawPointer", testAtomicTaggedOptionalRawPointer),
2222
("testAtomicTaggedRawPointer", testAtomicTaggedRawPointer),
2323
("testBool", testBool),
24+
("testCacheAlignedPointers", testCacheAlignedPointers),
2425
("testFence", testFence),
2526
("testInt", testInt),
2627
("testInt16", testInt16),

0 commit comments

Comments
 (0)