Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

atomix

package module

Go to main page

Versions in this module

v0

v0.1.2

Feb 16, 2026

v0.1.1

Jan 30, 2026

v0.1.0

Jan 8, 2026

Changes in this version

+ const CacheLineSize

+ func BarrierAcqRel()

+ func BarrierAcquire()

+ func BarrierRelease()

+ func CanPlaceAligned16(p []byte, off int) bool

+ func CanPlaceAligned4(p []byte, off int) bool

+ func CanPlaceAligned8(p []byte, off int) bool

+ func CanPlaceCacheAligned(p []byte, off, size int) bool

+ type Allocator struct

+ func NewAllocator(buf []byte) *Allocator

+ func (a *Allocator) Align(alignment int)

+ func (a *Allocator) Bool() *Bool

+ func (a *Allocator) CacheAlignedBool() *BoolPadded

+ func (a *Allocator) CacheAlignedInt128() *Int128Padded

+ func (a *Allocator) CacheAlignedInt32() *Int32Padded

+ func (a *Allocator) CacheAlignedInt64() *Int64Padded

+ func (a *Allocator) CacheAlignedUint128() *Uint128Padded

+ func (a *Allocator) CacheAlignedUint32() *Uint32Padded

+ func (a *Allocator) CacheAlignedUint64() *Uint64Padded

+ func (a *Allocator) CacheAlignedUintptr() *UintptrPadded

+ func (a *Allocator) Int128() *Int128

+ func (a *Allocator) Int32() *Int32

+ func (a *Allocator) Int64() *Int64

+ func (a *Allocator) Offset() int

+ func (a *Allocator) Remaining() int

+ func (a *Allocator) Reset()

+ func (a *Allocator) Skip(n int)

+ func (a *Allocator) Uint128() *Uint128

+ func (a *Allocator) Uint32() *Uint32

+ func (a *Allocator) Uint64() *Uint64

+ func (a *Allocator) Uintptr() *Uintptr

+ type Bool struct

+ func PlaceAlignedBool(p []byte, off int) (n int, a *Bool)

+ func (a *Bool) CompareAndSwap(old, new bool) bool

+ func (a *Bool) CompareAndSwapAcqRel(old, new bool) bool

+ func (a *Bool) CompareAndSwapAcquire(old, new bool) bool

+ func (a *Bool) CompareAndSwapRelaxed(old, new bool) bool

+ func (a *Bool) CompareAndSwapRelease(old, new bool) bool

+ func (a *Bool) Load() bool

+ func (a *Bool) LoadAcquire() bool

+ func (a *Bool) LoadRelaxed() bool

+ func (a *Bool) Store(val bool)

+ func (a *Bool) StoreRelaxed(val bool)

+ func (a *Bool) StoreRelease(val bool)

+ func (a *Bool) Swap(new bool) bool

+ func (a *Bool) SwapAcqRel(new bool) bool

+ func (a *Bool) SwapAcquire(new bool) bool

+ func (a *Bool) SwapRelaxed(new bool) bool

+ func (a *Bool) SwapRelease(new bool) bool

+ type BoolPadded struct

+ func PlaceCacheAlignedBool(p []byte, off int) (n int, a *BoolPadded)

+ type Int128 struct

+ func PlaceAlignedInt128(p []byte, off int) (n int, a *Int128)

+ func (a *Int128) Add(deltaLo, deltaHi int64) (lo, hi int64)

+ func (a *Int128) AddRelaxed(deltaLo, deltaHi int64) (lo, hi int64)

+ func (a *Int128) CompareAndSwap(oldLo, oldHi, newLo, newHi int64) bool

+ func (a *Int128) CompareAndSwapAcqRel(oldLo, oldHi, newLo, newHi int64) bool

+ func (a *Int128) CompareAndSwapAcquire(oldLo, oldHi, newLo, newHi int64) bool

+ func (a *Int128) CompareAndSwapRelaxed(oldLo, oldHi, newLo, newHi int64) bool

+ func (a *Int128) CompareAndSwapRelease(oldLo, oldHi, newLo, newHi int64) bool

+ func (a *Int128) CompareExchange(oldLo, oldHi, newLo, newHi int64) (lo, hi int64)

+ func (a *Int128) CompareExchangeAcqRel(oldLo, oldHi, newLo, newHi int64) (lo, hi int64)

+ func (a *Int128) CompareExchangeAcquire(oldLo, oldHi, newLo, newHi int64) (lo, hi int64)

+ func (a *Int128) CompareExchangeRelaxed(oldLo, oldHi, newLo, newHi int64) (lo, hi int64)

+ func (a *Int128) CompareExchangeRelease(oldLo, oldHi, newLo, newHi int64) (lo, hi int64)

+ func (a *Int128) Dec() (lo, hi int64)

+ func (a *Int128) DecRelaxed() (lo, hi int64)

+ func (a *Int128) Equal(lo, hi int64) bool

+ func (a *Int128) EqualRelaxed(lo, hi int64) bool

+ func (a *Int128) Greater(lo, hi int64) bool

+ func (a *Int128) GreaterOrEqual(lo, hi int64) bool

+ func (a *Int128) GreaterOrEqualRelaxed(lo, hi int64) bool

+ func (a *Int128) GreaterRelaxed(lo, hi int64) bool

+ func (a *Int128) Inc() (lo, hi int64)

+ func (a *Int128) IncRelaxed() (lo, hi int64)

+ func (a *Int128) Less(lo, hi int64) bool

+ func (a *Int128) LessOrEqual(lo, hi int64) bool

+ func (a *Int128) LessOrEqualRelaxed(lo, hi int64) bool

+ func (a *Int128) LessRelaxed(lo, hi int64) bool

+ func (a *Int128) Load() (lo, hi int64)

+ func (a *Int128) LoadAcquire() (lo, hi int64)

+ func (a *Int128) LoadRelaxed() (lo, hi int64)

+ func (a *Int128) Store(lo, hi int64)

+ func (a *Int128) StoreRelaxed(lo, hi int64)

+ func (a *Int128) StoreRelease(lo, hi int64)

+ func (a *Int128) Sub(deltaLo, deltaHi int64) (lo, hi int64)

+ func (a *Int128) SubRelaxed(deltaLo, deltaHi int64) (lo, hi int64)

+ func (a *Int128) Swap(newLo, newHi int64) (oldLo, oldHi int64)

+ func (a *Int128) SwapAcqRel(newLo, newHi int64) (oldLo, oldHi int64)

+ func (a *Int128) SwapAcquire(newLo, newHi int64) (oldLo, oldHi int64)

+ func (a *Int128) SwapRelaxed(newLo, newHi int64) (oldLo, oldHi int64)

+ func (a *Int128) SwapRelease(newLo, newHi int64) (oldLo, oldHi int64)

+ type Int128Padded struct

+ func PlaceCacheAlignedInt128(p []byte, off int) (n int, a *Int128Padded)

+ type Int32 struct

+ func PlaceAlignedInt32(p []byte, off int) (n int, a *Int32)

+ func (a *Int32) Add(delta int32) int32

+ func (a *Int32) AddAcqRel(delta int32) int32

+ func (a *Int32) AddAcquire(delta int32) int32

+ func (a *Int32) AddRelaxed(delta int32) int32

+ func (a *Int32) AddRelease(delta int32) int32

+ func (a *Int32) And(mask int32) int32

+ func (a *Int32) AndAcqRel(mask int32) int32

+ func (a *Int32) AndAcquire(mask int32) int32

+ func (a *Int32) AndRelaxed(mask int32) int32

+ func (a *Int32) AndRelease(mask int32) int32

+ func (a *Int32) CompareAndSwap(old, new int32) bool

+ func (a *Int32) CompareAndSwapAcqRel(old, new int32) bool

+ func (a *Int32) CompareAndSwapAcquire(old, new int32) bool

+ func (a *Int32) CompareAndSwapRelaxed(old, new int32) bool

+ func (a *Int32) CompareAndSwapRelease(old, new int32) bool

+ func (a *Int32) CompareExchange(old, new int32) int32

+ func (a *Int32) CompareExchangeAcqRel(old, new int32) int32

+ func (a *Int32) CompareExchangeAcquire(old, new int32) int32

+ func (a *Int32) CompareExchangeRelaxed(old, new int32) int32

+ func (a *Int32) CompareExchangeRelease(old, new int32) int32

+ func (a *Int32) Load() int32

+ func (a *Int32) LoadAcquire() int32

+ func (a *Int32) LoadRelaxed() int32

+ func (a *Int32) Max(val int32) int32

+ func (a *Int32) MaxRelaxed(val int32) int32

+ func (a *Int32) Min(val int32) int32

+ func (a *Int32) MinRelaxed(val int32) int32

+ func (a *Int32) Or(mask int32) int32

+ func (a *Int32) OrAcqRel(mask int32) int32

+ func (a *Int32) OrAcquire(mask int32) int32

+ func (a *Int32) OrRelaxed(mask int32) int32

+ func (a *Int32) OrRelease(mask int32) int32

+ func (a *Int32) Store(val int32)

+ func (a *Int32) StoreRelaxed(val int32)

+ func (a *Int32) StoreRelease(val int32)

+ func (a *Int32) Sub(delta int32) int32

+ func (a *Int32) SubAcqRel(delta int32) int32

+ func (a *Int32) SubAcquire(delta int32) int32

+ func (a *Int32) SubRelaxed(delta int32) int32

+ func (a *Int32) SubRelease(delta int32) int32

+ func (a *Int32) Swap(new int32) int32

+ func (a *Int32) SwapAcqRel(new int32) int32

+ func (a *Int32) SwapAcquire(new int32) int32

+ func (a *Int32) SwapRelaxed(new int32) int32

+ func (a *Int32) SwapRelease(new int32) int32

+ func (a *Int32) Xor(mask int32) int32

+ func (a *Int32) XorAcqRel(mask int32) int32

+ func (a *Int32) XorAcquire(mask int32) int32

+ func (a *Int32) XorRelaxed(mask int32) int32

+ func (a *Int32) XorRelease(mask int32) int32

+ type Int32Padded struct

+ func PlaceCacheAlignedInt32(p []byte, off int) (n int, a *Int32Padded)

+ type Int64 struct

+ func PlaceAlignedInt64(p []byte, off int) (n int, a *Int64)

+ func (a *Int64) Add(delta int64) int64

+ func (a *Int64) AddAcqRel(delta int64) int64

+ func (a *Int64) AddAcquire(delta int64) int64

+ func (a *Int64) AddRelaxed(delta int64) int64

+ func (a *Int64) AddRelease(delta int64) int64

+ func (a *Int64) And(mask int64) int64

+ func (a *Int64) AndAcqRel(mask int64) int64

+ func (a *Int64) AndAcquire(mask int64) int64

+ func (a *Int64) AndRelaxed(mask int64) int64

+ func (a *Int64) AndRelease(mask int64) int64

+ func (a *Int64) CompareAndSwap(old, new int64) bool

+ func (a *Int64) CompareAndSwapAcqRel(old, new int64) bool

+ func (a *Int64) CompareAndSwapAcquire(old, new int64) bool

+ func (a *Int64) CompareAndSwapRelaxed(old, new int64) bool

+ func (a *Int64) CompareAndSwapRelease(old, new int64) bool

+ func (a *Int64) CompareExchange(old, new int64) int64

+ func (a *Int64) CompareExchangeAcqRel(old, new int64) int64

+ func (a *Int64) CompareExchangeAcquire(old, new int64) int64

+ func (a *Int64) CompareExchangeRelaxed(old, new int64) int64

+ func (a *Int64) CompareExchangeRelease(old, new int64) int64

+ func (a *Int64) Load() int64

+ func (a *Int64) LoadAcquire() int64

+ func (a *Int64) LoadRelaxed() int64

+ func (a *Int64) Max(val int64) int64

+ func (a *Int64) MaxRelaxed(val int64) int64

+ func (a *Int64) Min(val int64) int64

+ func (a *Int64) MinRelaxed(val int64) int64

+ func (a *Int64) Or(mask int64) int64

+ func (a *Int64) OrAcqRel(mask int64) int64

+ func (a *Int64) OrAcquire(mask int64) int64

+ func (a *Int64) OrRelaxed(mask int64) int64

+ func (a *Int64) OrRelease(mask int64) int64

+ func (a *Int64) Store(val int64)

+ func (a *Int64) StoreRelaxed(val int64)

+ func (a *Int64) StoreRelease(val int64)

+ func (a *Int64) Sub(delta int64) int64

+ func (a *Int64) SubAcqRel(delta int64) int64

+ func (a *Int64) SubAcquire(delta int64) int64

+ func (a *Int64) SubRelaxed(delta int64) int64

+ func (a *Int64) SubRelease(delta int64) int64

+ func (a *Int64) Swap(new int64) int64

+ func (a *Int64) SwapAcqRel(new int64) int64

+ func (a *Int64) SwapAcquire(new int64) int64

+ func (a *Int64) SwapRelaxed(new int64) int64

+ func (a *Int64) SwapRelease(new int64) int64

+ func (a *Int64) Xor(mask int64) int64

+ func (a *Int64) XorAcqRel(mask int64) int64

+ func (a *Int64) XorAcquire(mask int64) int64

+ func (a *Int64) XorRelaxed(mask int64) int64

+ func (a *Int64) XorRelease(mask int64) int64

+ type Int64Padded struct

+ func PlaceCacheAlignedInt64(p []byte, off int) (n int, a *Int64Padded)

+ type MemoryOrder uint8

+ const AcqRel

+ const Acquire

+ const Relaxed

+ const Release

+ func (o MemoryOrder) AddInt128(addr *Int128, deltaLo, deltaHi int64) (oldLo, oldHi int64)

+ func (o MemoryOrder) AddInt32(addr *int32, delta int32) (new int32)

+ func (o MemoryOrder) AddInt64(addr *int64, delta int64) (new int64)

+ func (o MemoryOrder) AddUint128(addr *Uint128, deltaLo, deltaHi uint64) (oldLo, oldHi uint64)

+ func (o MemoryOrder) AddUint32(addr *uint32, delta uint32) (new uint32)

+ func (o MemoryOrder) AddUint64(addr *uint64, delta uint64) (new uint64)

+ func (o MemoryOrder) AddUintptr(addr *uintptr, delta uintptr) (new uintptr)

+ func (o MemoryOrder) AndInt32(addr *int32, mask int32) (old int32)

+ func (o MemoryOrder) AndInt64(addr *int64, mask int64) (old int64)

+ func (o MemoryOrder) AndUint32(addr *uint32, mask uint32) (old uint32)

+ func (o MemoryOrder) AndUint64(addr *uint64, mask uint64) (old uint64)

+ func (o MemoryOrder) AndUintptr(addr *uintptr, mask uintptr) (old uintptr)

+ func (o MemoryOrder) CompareAndSwapBool(addr *uint32, old, new bool) (swapped bool)

+ func (o MemoryOrder) CompareAndSwapInt128(addr *Int128, oldLo, oldHi, newLo, newHi int64) (swapped bool)

+ func (o MemoryOrder) CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)

+ func (o MemoryOrder) CompareAndSwapInt64(addr *int64, old, new int64) (swapped bool)

+ func (o MemoryOrder) CompareAndSwapPointer(addr *unsafe.Pointer, old, new unsafe.Pointer) (swapped bool)

+ func (o MemoryOrder) CompareAndSwapUint128(addr *Uint128, oldLo, oldHi, newLo, newHi uint64) (swapped bool)

+ func (o MemoryOrder) CompareAndSwapUint32(addr *uint32, old, new uint32) (swapped bool)

+ func (o MemoryOrder) CompareAndSwapUint64(addr *uint64, old, new uint64) (swapped bool)

+ func (o MemoryOrder) CompareAndSwapUintptr(addr *uintptr, old, new uintptr) (swapped bool)

+ func (o MemoryOrder) CompareExchangeInt128(addr *Int128, oldLo, oldHi, newLo, newHi int64) (prevLo, prevHi int64)

+ func (o MemoryOrder) CompareExchangeInt32(addr *int32, old, new int32) (prev int32)

+ func (o MemoryOrder) CompareExchangeInt64(addr *int64, old, new int64) (prev int64)

+ func (o MemoryOrder) CompareExchangePointer(addr *unsafe.Pointer, old, new unsafe.Pointer) (prev unsafe.Pointer)

+ func (o MemoryOrder) CompareExchangeUint128(addr *Uint128, oldLo, oldHi, newLo, newHi uint64) (prevLo, prevHi uint64)

+ func (o MemoryOrder) CompareExchangeUint32(addr *uint32, old, new uint32) (prev uint32)

+ func (o MemoryOrder) CompareExchangeUint64(addr *uint64, old, new uint64) (prev uint64)

+ func (o MemoryOrder) CompareExchangeUintptr(addr *uintptr, old, new uintptr) (prev uintptr)

+ func (o MemoryOrder) LoadBool(addr *uint32) bool

+ func (o MemoryOrder) LoadInt128(addr *Int128) (lo, hi int64)

+ func (o MemoryOrder) LoadInt32(addr *int32) int32

+ func (o MemoryOrder) LoadInt64(addr *int64) int64

+ func (o MemoryOrder) LoadPointer(addr *unsafe.Pointer) unsafe.Pointer

+ func (o MemoryOrder) LoadUint128(addr *Uint128) (lo, hi uint64)

+ func (o MemoryOrder) LoadUint32(addr *uint32) uint32

+ func (o MemoryOrder) LoadUint64(addr *uint64) uint64

+ func (o MemoryOrder) LoadUintptr(addr *uintptr) uintptr

+ func (o MemoryOrder) MaxInt32(addr *int32, val int32) (old int32)

+ func (o MemoryOrder) MaxInt64(addr *int64, val int64) (old int64)

+ func (o MemoryOrder) MaxUint32(addr *uint32, val uint32) (old uint32)

+ func (o MemoryOrder) MaxUint64(addr *uint64, val uint64) (old uint64)

+ func (o MemoryOrder) MaxUintptr(addr *uintptr, val uintptr) (old uintptr)

+ func (o MemoryOrder) MinInt32(addr *int32, val int32) (old int32)

+ func (o MemoryOrder) MinInt64(addr *int64, val int64) (old int64)

+ func (o MemoryOrder) MinUint32(addr *uint32, val uint32) (old uint32)

+ func (o MemoryOrder) MinUint64(addr *uint64, val uint64) (old uint64)

+ func (o MemoryOrder) MinUintptr(addr *uintptr, val uintptr) (old uintptr)

+ func (o MemoryOrder) OrInt32(addr *int32, mask int32) (old int32)

+ func (o MemoryOrder) OrInt64(addr *int64, mask int64) (old int64)

+ func (o MemoryOrder) OrUint32(addr *uint32, mask uint32) (old uint32)

+ func (o MemoryOrder) OrUint64(addr *uint64, mask uint64) (old uint64)

+ func (o MemoryOrder) OrUintptr(addr *uintptr, mask uintptr) (old uintptr)

+ func (o MemoryOrder) StoreBool(addr *uint32, val bool)

+ func (o MemoryOrder) StoreInt128(addr *Int128, lo, hi int64)

+ func (o MemoryOrder) StoreInt32(addr *int32, val int32)

+ func (o MemoryOrder) StoreInt64(addr *int64, val int64)

+ func (o MemoryOrder) StorePointer(addr *unsafe.Pointer, val unsafe.Pointer)

+ func (o MemoryOrder) StoreUint128(addr *Uint128, lo, hi uint64)

+ func (o MemoryOrder) StoreUint32(addr *uint32, val uint32)

+ func (o MemoryOrder) StoreUint64(addr *uint64, val uint64)

+ func (o MemoryOrder) StoreUintptr(addr *uintptr, val uintptr)

+ func (o MemoryOrder) SwapBool(addr *uint32, new bool) (old bool)

+ func (o MemoryOrder) SwapInt128(addr *Int128, newLo, newHi int64) (oldLo, oldHi int64)

+ func (o MemoryOrder) SwapInt32(addr *int32, new int32) (old int32)

+ func (o MemoryOrder) SwapInt64(addr *int64, new int64) (old int64)

+ func (o MemoryOrder) SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)

+ func (o MemoryOrder) SwapUint128(addr *Uint128, newLo, newHi uint64) (oldLo, oldHi uint64)

+ func (o MemoryOrder) SwapUint32(addr *uint32, new uint32) (old uint32)

+ func (o MemoryOrder) SwapUint64(addr *uint64, new uint64) (old uint64)

+ func (o MemoryOrder) SwapUintptr(addr *uintptr, new uintptr) (old uintptr)

+ func (o MemoryOrder) XorInt32(addr *int32, mask int32) (old int32)

+ func (o MemoryOrder) XorInt64(addr *int64, mask int64) (old int64)

+ func (o MemoryOrder) XorUint32(addr *uint32, mask uint32) (old uint32)

+ func (o MemoryOrder) XorUint64(addr *uint64, mask uint64) (old uint64)

+ func (o MemoryOrder) XorUintptr(addr *uintptr, mask uintptr) (old uintptr)

+ type Pointer struct

+ func (a *Pointer[T]) CompareAndSwap(old, new *T) bool

+ func (a *Pointer[T]) CompareAndSwapAcqRel(old, new *T) bool

+ func (a *Pointer[T]) CompareAndSwapAcquire(old, new *T) bool

+ func (a *Pointer[T]) CompareAndSwapRelaxed(old, new *T) bool

+ func (a *Pointer[T]) CompareAndSwapRelease(old, new *T) bool

+ func (a *Pointer[T]) CompareExchange(old, new *T) *T

+ func (a *Pointer[T]) CompareExchangeAcqRel(old, new *T) *T

+ func (a *Pointer[T]) CompareExchangeAcquire(old, new *T) *T

+ func (a *Pointer[T]) CompareExchangeRelaxed(old, new *T) *T

+ func (a *Pointer[T]) CompareExchangeRelease(old, new *T) *T

+ func (a *Pointer[T]) Load() *T

+ func (a *Pointer[T]) LoadAcquire() *T

+ func (a *Pointer[T]) LoadRelaxed() *T

+ func (a *Pointer[T]) Store(val *T)

+ func (a *Pointer[T]) StoreRelaxed(val *T)

+ func (a *Pointer[T]) StoreRelease(val *T)

+ func (a *Pointer[T]) Swap(new *T) *T

+ func (a *Pointer[T]) SwapAcqRel(new *T) *T

+ func (a *Pointer[T]) SwapAcquire(new *T) *T

+ func (a *Pointer[T]) SwapRelaxed(new *T) *T

+ func (a *Pointer[T]) SwapRelease(new *T) *T

+ type Uint128 struct

+ func PlaceAlignedUint128(p []byte, off int) (n int, a *Uint128)

+ func (a *Uint128) Add(deltaLo, deltaHi uint64) (newLo, newHi uint64)

+ func (a *Uint128) AddRelaxed(deltaLo, deltaHi uint64) (newLo, newHi uint64)

+ func (a *Uint128) CompareAndSwap(oldLo, oldHi, newLo, newHi uint64) bool

+ func (a *Uint128) CompareAndSwapAcqRel(oldLo, oldHi, newLo, newHi uint64) bool

+ func (a *Uint128) CompareAndSwapAcquire(oldLo, oldHi, newLo, newHi uint64) bool

+ func (a *Uint128) CompareAndSwapRelaxed(oldLo, oldHi, newLo, newHi uint64) bool

+ func (a *Uint128) CompareAndSwapRelease(oldLo, oldHi, newLo, newHi uint64) bool

+ func (a *Uint128) CompareExchange(oldLo, oldHi, newLo, newHi uint64) (lo, hi uint64)

+ func (a *Uint128) CompareExchangeAcqRel(oldLo, oldHi, newLo, newHi uint64) (lo, hi uint64)

+ func (a *Uint128) CompareExchangeAcquire(oldLo, oldHi, newLo, newHi uint64) (lo, hi uint64)

+ func (a *Uint128) CompareExchangeRelaxed(oldLo, oldHi, newLo, newHi uint64) (lo, hi uint64)

+ func (a *Uint128) CompareExchangeRelease(oldLo, oldHi, newLo, newHi uint64) (lo, hi uint64)

+ func (a *Uint128) Dec() (newLo, newHi uint64)

+ func (a *Uint128) DecRelaxed() (newLo, newHi uint64)

+ func (a *Uint128) Equal(lo, hi uint64) bool

+ func (a *Uint128) EqualRelaxed(lo, hi uint64) bool

+ func (a *Uint128) Greater(lo, hi uint64) bool

+ func (a *Uint128) GreaterOrEqual(lo, hi uint64) bool

+ func (a *Uint128) GreaterOrEqualRelaxed(lo, hi uint64) bool

+ func (a *Uint128) GreaterRelaxed(lo, hi uint64) bool

+ func (a *Uint128) Inc() (newLo, newHi uint64)

+ func (a *Uint128) IncRelaxed() (newLo, newHi uint64)

+ func (a *Uint128) Less(lo, hi uint64) bool

+ func (a *Uint128) LessOrEqual(lo, hi uint64) bool

+ func (a *Uint128) LessOrEqualRelaxed(lo, hi uint64) bool

+ func (a *Uint128) LessRelaxed(lo, hi uint64) bool

+ func (a *Uint128) Load() (lo, hi uint64)

+ func (a *Uint128) LoadAcquire() (lo, hi uint64)

+ func (a *Uint128) LoadRelaxed() (lo, hi uint64)

+ func (a *Uint128) Store(lo, hi uint64)

+ func (a *Uint128) StoreRelaxed(lo, hi uint64)

+ func (a *Uint128) StoreRelease(lo, hi uint64)

+ func (a *Uint128) Sub(deltaLo, deltaHi uint64) (newLo, newHi uint64)

+ func (a *Uint128) SubRelaxed(deltaLo, deltaHi uint64) (newLo, newHi uint64)

+ func (a *Uint128) Swap(newLo, newHi uint64) (oldLo, oldHi uint64)

+ func (a *Uint128) SwapAcqRel(newLo, newHi uint64) (oldLo, oldHi uint64)

+ func (a *Uint128) SwapAcquire(newLo, newHi uint64) (oldLo, oldHi uint64)

+ func (a *Uint128) SwapRelaxed(newLo, newHi uint64) (oldLo, oldHi uint64)

+ func (a *Uint128) SwapRelease(newLo, newHi uint64) (oldLo, oldHi uint64)

+ type Uint128Padded struct

+ func PlaceCacheAlignedUint128(p []byte, off int) (n int, a *Uint128Padded)

+ type Uint32 struct

+ func PlaceAlignedUint32(p []byte, off int) (n int, a *Uint32)

+ func (a *Uint32) Add(delta uint32) uint32

+ func (a *Uint32) AddAcqRel(delta uint32) uint32

+ func (a *Uint32) AddAcquire(delta uint32) uint32

+ func (a *Uint32) AddRelaxed(delta uint32) uint32

+ func (a *Uint32) AddRelease(delta uint32) uint32

+ func (a *Uint32) And(mask uint32) uint32

+ func (a *Uint32) AndAcqRel(mask uint32) uint32

+ func (a *Uint32) AndAcquire(mask uint32) uint32

+ func (a *Uint32) AndRelaxed(mask uint32) uint32

+ func (a *Uint32) AndRelease(mask uint32) uint32

+ func (a *Uint32) CompareAndSwap(old, new uint32) bool

+ func (a *Uint32) CompareAndSwapAcqRel(old, new uint32) bool

+ func (a *Uint32) CompareAndSwapAcquire(old, new uint32) bool

+ func (a *Uint32) CompareAndSwapRelaxed(old, new uint32) bool

+ func (a *Uint32) CompareAndSwapRelease(old, new uint32) bool

+ func (a *Uint32) CompareExchange(old, new uint32) uint32

+ func (a *Uint32) CompareExchangeAcqRel(old, new uint32) uint32

+ func (a *Uint32) CompareExchangeAcquire(old, new uint32) uint32

+ func (a *Uint32) CompareExchangeRelaxed(old, new uint32) uint32

+ func (a *Uint32) CompareExchangeRelease(old, new uint32) uint32

+ func (a *Uint32) Load() uint32

+ func (a *Uint32) LoadAcquire() uint32

+ func (a *Uint32) LoadRelaxed() uint32

+ func (a *Uint32) Max(val uint32) uint32

+ func (a *Uint32) MaxRelaxed(val uint32) uint32

+ func (a *Uint32) Min(val uint32) uint32

+ func (a *Uint32) MinRelaxed(val uint32) uint32

+ func (a *Uint32) Or(mask uint32) uint32

+ func (a *Uint32) OrAcqRel(mask uint32) uint32

+ func (a *Uint32) OrAcquire(mask uint32) uint32

+ func (a *Uint32) OrRelaxed(mask uint32) uint32

+ func (a *Uint32) OrRelease(mask uint32) uint32

+ func (a *Uint32) Store(val uint32)

+ func (a *Uint32) StoreRelaxed(val uint32)

+ func (a *Uint32) StoreRelease(val uint32)

+ func (a *Uint32) Sub(delta uint32) uint32

+ func (a *Uint32) SubAcqRel(delta uint32) uint32

+ func (a *Uint32) SubAcquire(delta uint32) uint32

+ func (a *Uint32) SubRelaxed(delta uint32) uint32

+ func (a *Uint32) SubRelease(delta uint32) uint32

+ func (a *Uint32) Swap(new uint32) uint32

+ func (a *Uint32) SwapAcqRel(new uint32) uint32

+ func (a *Uint32) SwapAcquire(new uint32) uint32

+ func (a *Uint32) SwapRelaxed(new uint32) uint32

+ func (a *Uint32) SwapRelease(new uint32) uint32

+ func (a *Uint32) Xor(mask uint32) uint32

+ func (a *Uint32) XorAcqRel(mask uint32) uint32

+ func (a *Uint32) XorAcquire(mask uint32) uint32

+ func (a *Uint32) XorRelaxed(mask uint32) uint32

+ func (a *Uint32) XorRelease(mask uint32) uint32

+ type Uint32Padded struct

+ func PlaceCacheAlignedUint32(p []byte, off int) (n int, a *Uint32Padded)

+ type Uint64 struct

+ func PlaceAlignedUint64(p []byte, off int) (n int, a *Uint64)

+ func (a *Uint64) Add(delta uint64) uint64

+ func (a *Uint64) AddAcqRel(delta uint64) uint64

+ func (a *Uint64) AddAcquire(delta uint64) uint64

+ func (a *Uint64) AddRelaxed(delta uint64) uint64

+ func (a *Uint64) AddRelease(delta uint64) uint64

+ func (a *Uint64) And(mask uint64) uint64

+ func (a *Uint64) AndAcqRel(mask uint64) uint64

+ func (a *Uint64) AndAcquire(mask uint64) uint64

+ func (a *Uint64) AndRelaxed(mask uint64) uint64

+ func (a *Uint64) AndRelease(mask uint64) uint64

+ func (a *Uint64) CompareAndSwap(old, new uint64) bool

+ func (a *Uint64) CompareAndSwapAcqRel(old, new uint64) bool

+ func (a *Uint64) CompareAndSwapAcquire(old, new uint64) bool

+ func (a *Uint64) CompareAndSwapRelaxed(old, new uint64) bool

+ func (a *Uint64) CompareAndSwapRelease(old, new uint64) bool

+ func (a *Uint64) CompareExchange(old, new uint64) uint64

+ func (a *Uint64) CompareExchangeAcqRel(old, new uint64) uint64

+ func (a *Uint64) CompareExchangeAcquire(old, new uint64) uint64

+ func (a *Uint64) CompareExchangeRelaxed(old, new uint64) uint64

+ func (a *Uint64) CompareExchangeRelease(old, new uint64) uint64

+ func (a *Uint64) Load() uint64

+ func (a *Uint64) LoadAcquire() uint64

+ func (a *Uint64) LoadRelaxed() uint64

+ func (a *Uint64) Max(val uint64) uint64

+ func (a *Uint64) MaxRelaxed(val uint64) uint64

+ func (a *Uint64) Min(val uint64) uint64

+ func (a *Uint64) MinRelaxed(val uint64) uint64

+ func (a *Uint64) Or(mask uint64) uint64

+ func (a *Uint64) OrAcqRel(mask uint64) uint64

+ func (a *Uint64) OrAcquire(mask uint64) uint64

+ func (a *Uint64) OrRelaxed(mask uint64) uint64

+ func (a *Uint64) OrRelease(mask uint64) uint64

+ func (a *Uint64) Store(val uint64)

+ func (a *Uint64) StoreRelaxed(val uint64)

+ func (a *Uint64) StoreRelease(val uint64)

+ func (a *Uint64) Sub(delta uint64) uint64

+ func (a *Uint64) SubAcqRel(delta uint64) uint64

+ func (a *Uint64) SubAcquire(delta uint64) uint64

+ func (a *Uint64) SubRelaxed(delta uint64) uint64

+ func (a *Uint64) SubRelease(delta uint64) uint64

+ func (a *Uint64) Swap(new uint64) uint64

+ func (a *Uint64) SwapAcqRel(new uint64) uint64

+ func (a *Uint64) SwapAcquire(new uint64) uint64

+ func (a *Uint64) SwapRelaxed(new uint64) uint64

+ func (a *Uint64) SwapRelease(new uint64) uint64

+ func (a *Uint64) Xor(mask uint64) uint64

+ func (a *Uint64) XorAcqRel(mask uint64) uint64

+ func (a *Uint64) XorAcquire(mask uint64) uint64

+ func (a *Uint64) XorRelaxed(mask uint64) uint64

+ func (a *Uint64) XorRelease(mask uint64) uint64

+ type Uint64Padded struct

+ func PlaceCacheAlignedUint64(p []byte, off int) (n int, a *Uint64Padded)

+ type Uintptr struct

+ func PlaceAlignedUintptr(p []byte, off int) (n int, a *Uintptr)

+ func (a *Uintptr) Add(delta uintptr) uintptr

+ func (a *Uintptr) AddAcqRel(delta uintptr) uintptr

+ func (a *Uintptr) AddAcquire(delta uintptr) uintptr

+ func (a *Uintptr) AddRelaxed(delta uintptr) uintptr

+ func (a *Uintptr) AddRelease(delta uintptr) uintptr

+ func (a *Uintptr) And(mask uintptr) uintptr

+ func (a *Uintptr) AndAcqRel(mask uintptr) uintptr

+ func (a *Uintptr) AndAcquire(mask uintptr) uintptr

+ func (a *Uintptr) AndRelaxed(mask uintptr) uintptr

+ func (a *Uintptr) AndRelease(mask uintptr) uintptr

+ func (a *Uintptr) CompareAndSwap(old, new uintptr) bool

+ func (a *Uintptr) CompareAndSwapAcqRel(old, new uintptr) bool

+ func (a *Uintptr) CompareAndSwapAcquire(old, new uintptr) bool

+ func (a *Uintptr) CompareAndSwapRelaxed(old, new uintptr) bool

+ func (a *Uintptr) CompareAndSwapRelease(old, new uintptr) bool

+ func (a *Uintptr) CompareExchange(old, new uintptr) uintptr

+ func (a *Uintptr) CompareExchangeAcqRel(old, new uintptr) uintptr

+ func (a *Uintptr) CompareExchangeAcquire(old, new uintptr) uintptr

+ func (a *Uintptr) CompareExchangeRelaxed(old, new uintptr) uintptr

+ func (a *Uintptr) CompareExchangeRelease(old, new uintptr) uintptr

+ func (a *Uintptr) Load() uintptr

+ func (a *Uintptr) LoadAcquire() uintptr

+ func (a *Uintptr) LoadRelaxed() uintptr

+ func (a *Uintptr) Max(val uintptr) uintptr

+ func (a *Uintptr) MaxRelaxed(val uintptr) uintptr

+ func (a *Uintptr) Min(val uintptr) uintptr

+ func (a *Uintptr) MinRelaxed(val uintptr) uintptr

+ func (a *Uintptr) Or(mask uintptr) uintptr

+ func (a *Uintptr) OrAcqRel(mask uintptr) uintptr

+ func (a *Uintptr) OrAcquire(mask uintptr) uintptr

+ func (a *Uintptr) OrRelaxed(mask uintptr) uintptr

+ func (a *Uintptr) OrRelease(mask uintptr) uintptr

+ func (a *Uintptr) Store(val uintptr)

+ func (a *Uintptr) StoreRelaxed(val uintptr)

+ func (a *Uintptr) StoreRelease(val uintptr)

+ func (a *Uintptr) Sub(delta uintptr) uintptr

+ func (a *Uintptr) SubAcqRel(delta uintptr) uintptr

+ func (a *Uintptr) SubAcquire(delta uintptr) uintptr

+ func (a *Uintptr) SubRelaxed(delta uintptr) uintptr

+ func (a *Uintptr) SubRelease(delta uintptr) uintptr

+ func (a *Uintptr) Swap(new uintptr) uintptr

+ func (a *Uintptr) SwapAcqRel(new uintptr) uintptr

+ func (a *Uintptr) SwapAcquire(new uintptr) uintptr

+ func (a *Uintptr) SwapRelaxed(new uintptr) uintptr

+ func (a *Uintptr) SwapRelease(new uintptr) uintptr

+ func (a *Uintptr) Xor(mask uintptr) uintptr

+ func (a *Uintptr) XorAcqRel(mask uintptr) uintptr

+ func (a *Uintptr) XorAcquire(mask uintptr) uintptr

+ func (a *Uintptr) XorRelaxed(mask uintptr) uintptr

+ func (a *Uintptr) XorRelease(mask uintptr) uintptr

+ type UintptrPadded struct

+ func PlaceCacheAlignedUintptr(p []byte, off int) (n int, a *UintptrPadded)