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.3

Feb 27, 2026

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)