...
1
2
3
4
5 package atomic
6
7 import "unsafe"
8
9
10
11 type Bool struct {
12 _ noCopy
13 v uint32
14 }
15
16
17 func (x *Bool) Load() bool { return LoadUint32(&x.v) != 0 }
18
19
20 func (x *Bool) Store(val bool) { StoreUint32(&x.v, b32(val)) }
21
22
23 func (x *Bool) Swap(new bool) (old bool) { return SwapUint32(&x.v, b32(new)) != 0 }
24
25
26 func (x *Bool) CompareAndSwap(old, new bool) (swapped bool) {
27 return CompareAndSwapUint32(&x.v, b32(old), b32(new))
28 }
29
30
31 func b32(b bool) uint32 {
32 if b {
33 return 1
34 }
35 return 0
36 }
37
38
39 type Pointer[T any] struct {
40
41
42 _ [0]T
43
44 _ noCopy
45 v unsafe.Pointer
46 }
47
48
49 func (x *Pointer[T]) Load() *T { return (*T)(LoadPointer(&x.v)) }
50
51
52 func (x *Pointer[T]) Store(val *T) { StorePointer(&x.v, unsafe.Pointer(val)) }
53
54
55 func (x *Pointer[T]) Swap(new *T) (old *T) { return (*T)(SwapPointer(&x.v, unsafe.Pointer(new))) }
56
57
58 func (x *Pointer[T]) CompareAndSwap(old, new *T) (swapped bool) {
59 return CompareAndSwapPointer(&x.v, unsafe.Pointer(old), unsafe.Pointer(new))
60 }
61
62
63 type Int32 struct {
64 _ noCopy
65 v int32
66 }
67
68
69 func (x *Int32) Load() int32 { return LoadInt32(&x.v) }
70
71
72 func (x *Int32) Store(val int32) { StoreInt32(&x.v, val) }
73
74
75 func (x *Int32) Swap(new int32) (old int32) { return SwapInt32(&x.v, new) }
76
77
78 func (x *Int32) CompareAndSwap(old, new int32) (swapped bool) {
79 return CompareAndSwapInt32(&x.v, old, new)
80 }
81
82
83 func (x *Int32) Add(delta int32) (new int32) { return AddInt32(&x.v, delta) }
84
85
86 type Int64 struct {
87 _ noCopy
88 _ align64
89 v int64
90 }
91
92
93 func (x *Int64) Load() int64 { return LoadInt64(&x.v) }
94
95
96 func (x *Int64) Store(val int64) { StoreInt64(&x.v, val) }
97
98
99 func (x *Int64) Swap(new int64) (old int64) { return SwapInt64(&x.v, new) }
100
101
102 func (x *Int64) CompareAndSwap(old, new int64) (swapped bool) {
103 return CompareAndSwapInt64(&x.v, old, new)
104 }
105
106
107 func (x *Int64) Add(delta int64) (new int64) { return AddInt64(&x.v, delta) }
108
109
110 type Uint32 struct {
111 _ noCopy
112 v uint32
113 }
114
115
116 func (x *Uint32) Load() uint32 { return LoadUint32(&x.v) }
117
118
119 func (x *Uint32) Store(val uint32) { StoreUint32(&x.v, val) }
120
121
122 func (x *Uint32) Swap(new uint32) (old uint32) { return SwapUint32(&x.v, new) }
123
124
125 func (x *Uint32) CompareAndSwap(old, new uint32) (swapped bool) {
126 return CompareAndSwapUint32(&x.v, old, new)
127 }
128
129
130 func (x *Uint32) Add(delta uint32) (new uint32) { return AddUint32(&x.v, delta) }
131
132
133 type Uint64 struct {
134 _ noCopy
135 _ align64
136 v uint64
137 }
138
139
140 func (x *Uint64) Load() uint64 { return LoadUint64(&x.v) }
141
142
143 func (x *Uint64) Store(val uint64) { StoreUint64(&x.v, val) }
144
145
146 func (x *Uint64) Swap(new uint64) (old uint64) { return SwapUint64(&x.v, new) }
147
148
149 func (x *Uint64) CompareAndSwap(old, new uint64) (swapped bool) {
150 return CompareAndSwapUint64(&x.v, old, new)
151 }
152
153
154 func (x *Uint64) Add(delta uint64) (new uint64) { return AddUint64(&x.v, delta) }
155
156
157 type Uintptr struct {
158 _ noCopy
159 v uintptr
160 }
161
162
163 func (x *Uintptr) Load() uintptr { return LoadUintptr(&x.v) }
164
165
166 func (x *Uintptr) Store(val uintptr) { StoreUintptr(&x.v, val) }
167
168
169 func (x *Uintptr) Swap(new uintptr) (old uintptr) { return SwapUintptr(&x.v, new) }
170
171
172 func (x *Uintptr) CompareAndSwap(old, new uintptr) (swapped bool) {
173 return CompareAndSwapUintptr(&x.v, old, new)
174 }
175
176
177 func (x *Uintptr) Add(delta uintptr) (new uintptr) { return AddUintptr(&x.v, delta) }
178
179
180
181
182
183
184
185
186 type noCopy struct{}
187
188
189 func (*noCopy) Lock() {}
190 func (*noCopy) Unlock() {}
191
192
193
194
195 type align64 struct{}
196
View as plain text