package atomic

Import Path
	internal/runtime/atomic (on go.dev)

Dependency Relation
	imports one package, and imported by 3 packages


Involved Source Files

	    atomic_amd64.go
	
		Package atomic provides atomic operations, independent of sync/atomic,
		to the runtime.
		
		On most platforms, the compiler is aware of the functions defined
		in this package, and they're replaced with platform-specific intrinsics.
		On other platforms, generic implementations are made available.
		
		Unless otherwise noted, operations defined in this package are sequentially
		consistent across threads with respect to the values they manipulate. More
		specifically, operations that happen in a specific order on one thread,
		will always be observed to happen in exactly that order by another thread.

	    stubs.go
	    types.go
	    types_64bit.go
	    unaligned.go
	    atomic_amd64.s


Package-Level Type Names (total 10)


	/* sort by:  |  */
	
		Bool is an atomically accessed bool value.
		
		A Bool must not be copied.

		
			
				Load accesses and returns the value atomically.

			
				Store updates the value atomically.



	
		Float64 is an atomically accessed float64 value.
		
		8-byte aligned on all platforms, unlike a regular float64.
		
		A Float64 must not be copied.

		
			
				Load accesses and returns the value atomically.

			
				Store updates the value atomically.



	
		Int32 is an atomically accessed int32 value.
		
		An Int32 must not be copied.

		
			
				Add adds delta to i atomically, returning
				the new updated value.
				
				This operation wraps around in the usual
				two's-complement way.

			
				CompareAndSwap atomically compares i's value with old,
				and if they're equal, swaps i's value with new.
				It reports whether the swap ran.

			
				Load accesses and returns the value atomically.

			
				Store updates the value atomically.

			
				Swap replaces i's value with new, returning
				i's value before the replacement.



	
		Int64 is an atomically accessed int64 value.
		
		8-byte aligned on all platforms, unlike a regular int64.
		
		An Int64 must not be copied.

		
			
				Add adds delta to i atomically, returning
				the new updated value.
				
				This operation wraps around in the usual
				two's-complement way.

			
				CompareAndSwap atomically compares i's value with old,
				and if they're equal, swaps i's value with new.
				It reports whether the swap ran.

			
				Load accesses and returns the value atomically.

			
				Store updates the value atomically.

			
				Swap replaces i's value with new, returning
				i's value before the replacement.



	

		Type Parameters:
			T: any

		Pointer is an atomic pointer of type *T.

		
			
				CompareAndSwap atomically (with respect to other methods)
				compares u's value with old, and if they're equal,
				swaps u's value with new.
				It reports whether the swap ran.

			
				CompareAndSwapNoWB atomically (with respect to other methods)
				compares u's value with old, and if they're equal,
				swaps u's value with new.
				It reports whether the swap ran.
				
				WARNING: As the name implies this operation does *not*
				perform a write barrier on value, and so this operation may
				hide pointers from the GC. Use with care and sparingly.
				It is safe to use with values not found in the Go heap.
				Prefer CompareAndSwap instead.

			
				Load accesses and returns the value atomically.

			
				Store updates the value atomically.

			
				StoreNoWB updates the value atomically.
				
				WARNING: As the name implies this operation does *not*
				perform a write barrier on value, and so this operation may
				hide pointers from the GC. Use with care and sparingly.
				It is safe to use with values not found in the Go heap.
				Prefer Store instead.



	
		Uint32 is an atomically accessed uint32 value.
		
		A Uint32 must not be copied.

		
			
				Add adds delta to u atomically, returning
				the new updated value.
				
				This operation wraps around in the usual
				two's-complement way.

			
				And takes value and performs a bit-wise
				"and" operation with the value of u, storing
				the result into u.
				
				The full process is performed atomically.

			
				CompareAndSwap atomically compares u's value with old,
				and if they're equal, swaps u's value with new.
				It reports whether the swap ran.

			
				CompareAndSwapRelease is a partially unsynchronized version
				of Cas that relaxes ordering constraints. Other threads
				may observe operations that occur after this operation to
				precede it, but no operation that precedes it
				on this thread can be observed to occur after it.
				It reports whether the swap ran.
				
				WARNING: Use sparingly and with great care.

			
				Load accesses and returns the value atomically.

			
				LoadAcquire is a partially unsynchronized version
				of Load that relaxes ordering constraints. Other threads
				may observe operations that precede this operation to
				occur after it, but no operation that occurs after it
				on this thread can be observed to occur before it.
				
				WARNING: Use sparingly and with great care.

			
				Or takes value and performs a bit-wise
				"or" operation with the value of u, storing
				the result into u.
				
				The full process is performed atomically.

			
				Store updates the value atomically.

			
				StoreRelease is a partially unsynchronized version
				of Store that relaxes ordering constraints. Other threads
				may observe operations that occur after this operation to
				precede it, but no operation that precedes it
				on this thread can be observed to occur after it.
				
				WARNING: Use sparingly and with great care.

			
				Swap replaces u's value with new, returning
				u's value before the replacement.



	
		Uint64 is an atomically accessed uint64 value.
		
		8-byte aligned on all platforms, unlike a regular uint64.
		
		A Uint64 must not be copied.

		
			
				Add adds delta to u atomically, returning
				the new updated value.
				
				This operation wraps around in the usual
				two's-complement way.

			
				CompareAndSwap atomically compares u's value with old,
				and if they're equal, swaps u's value with new.
				It reports whether the swap ran.

			
				Load accesses and returns the value atomically.

			
				LoadAcquire is a partially unsynchronized version
				of Load that relaxes ordering constraints. Other threads
				may observe operations that precede this operation to
				occur after it, but no operation that occurs after it
				on this thread can be observed to occur before it.
				
				WARNING: Use sparingly and with great care.

			
				Store updates the value atomically.

			
				StoreRelease is a partially unsynchronized version
				of Store that relaxes ordering constraints. Other threads
				may observe operations that occur after this operation to
				precede it, but no operation that precedes it
				on this thread can be observed to occur after it.
				
				WARNING: Use sparingly and with great care.

			
				Swap replaces u's value with new, returning
				u's value before the replacement.



	
		Uint8 is an atomically accessed uint8 value.
		
		A Uint8 must not be copied.

		
			
				And takes value and performs a bit-wise
				"and" operation with the value of u, storing
				the result into u.
				
				The full process is performed atomically.

			
				Load accesses and returns the value atomically.

			
				Or takes value and performs a bit-wise
				"or" operation with the value of u, storing
				the result into u.
				
				The full process is performed atomically.

			
				Store updates the value atomically.



	
		Uintptr is an atomically accessed uintptr value.
		
		A Uintptr must not be copied.

		
			
				Add adds delta to u atomically, returning
				the new updated value.
				
				This operation wraps around in the usual
				two's-complement way.

			
				CompareAndSwap atomically compares u's value with old,
				and if they're equal, swaps u's value with new.
				It reports whether the swap ran.

			
				Load accesses and returns the value atomically.

			
				LoadAcquire is a partially unsynchronized version
				of Load that relaxes ordering constraints. Other threads
				may observe operations that precede this operation to
				occur after it, but no operation that occurs after it
				on this thread can be observed to occur before it.
				
				WARNING: Use sparingly and with great care.

			
				Store updates the value atomically.

			
				StoreRelease is a partially unsynchronized version
				of Store that relaxes ordering constraints. Other threads
				may observe operations that occur after this operation to
				precede it, but no operation that precedes it
				on this thread can be observed to occur after it.
				
				WARNING: Use sparingly and with great care.

			
				Swap replaces u's value with new, returning
				u's value before the replacement.



	
		UnsafePointer is an atomically accessed unsafe.Pointer value.
		
		Note that because of the atomicity guarantees, stores to values
		of this type never trigger a write barrier, and the relevant
		methods are suffixed with "NoWB" to indicate that explicitly.
		As a result, this type should be used carefully, and sparingly,
		mostly with values that do not live in the Go heap anyway.
		
		An UnsafePointer must not be copied.

		
			
				CompareAndSwap atomically compares u's value with old,
				and if they're equal, swaps u's value with new.
				It reports whether the swap ran.

			
				CompareAndSwapNoWB atomically (with respect to other methods)
				compares u's value with old, and if they're equal,
				swaps u's value with new.
				It reports whether the swap ran.
				
				WARNING: As the name implies this operation does *not*
				perform a write barrier on value, and so this operation may
				hide pointers from the GC. Use with care and sparingly.
				It is safe to use with values not found in the Go heap.
				Prefer CompareAndSwap instead.

			
				Load accesses and returns the value atomically.

			
				Store updates the value atomically.

			
				StoreNoWB updates the value atomically.
				
				WARNING: As the name implies this operation does *not*
				perform a write barrier on value, and so this operation may
				hide pointers from the GC. Use with care and sparingly.
				It is safe to use with values not found in the Go heap.
				Prefer Store instead.





Package-Level Functions (total 48)


	 func And(ptr *uint32, val uint32)
	 func And32(ptr *uint32, val uint32) uint32
	 func And64(ptr *uint64, val uint64) uint64
	 func And8(ptr *uint8, val uint8)
	 func Cas(ptr *uint32, old, new uint32) bool
	 func Cas64(ptr *uint64, old, new uint64) bool
	 func Casint32(ptr *int32, old, new int32) bool
	 func Casint64(ptr *int64, old, new int64) bool
	
		NO go:noescape annotation; see atomic_pointer.go.


	 func CasRel(ptr *uint32, old, new uint32) bool
	 func Casuintptr(ptr *uintptr, old, new uintptr) bool
	 func Load(ptr *uint32) uint32
	 func Load64(ptr *uint64) uint64
	 func Load8(ptr *uint8) uint8
	 func LoadAcq(ptr *uint32) uint32
	 func LoadAcq64(ptr *uint64) uint64
	 func Loadint32(ptr *int32) int32
	 func Loadint64(ptr *int64) int64
	 func Loaduint(ptr *uint) uint
	 func Or(ptr *uint32, val uint32)
	 func Or32(ptr *uint32, val uint32) uint32
	 func Or64(ptr *uint64, val uint64) uint64
	 func Or8(ptr *uint8, val uint8)
	 func Oruintptr(ptr *uintptr, val uintptr) uintptr
	 func Store(ptr *uint32, val uint32)
	 func Store64(ptr *uint64, val uint64)
	 func Store8(ptr *uint8, val uint8)
	 func Storeint32(ptr *int32, new int32)
	 func Storeint64(ptr *int64, new int64)
	
		StorepNoWB performs *ptr = val atomically and without a write
		barrier.
		
		NO go:noescape annotation; see atomic_pointer.go.


	 func StoreRel(ptr *uint32, val uint32)
	 func StoreRel64(ptr *uint64, val uint64)
	 func Storeuintptr(ptr *uintptr, new uintptr)
	 func Xadd(ptr *uint32, delta int32) uint32
	 func Xadd64(ptr *uint64, delta int64) uint64
	 func Xaddint32(ptr *int32, delta int32) int32
	 func Xaddint64(ptr *int64, delta int64) int64
	 func Xadduintptr(ptr *uintptr, delta uintptr) uintptr
	 func Xchg(ptr *uint32, new uint32) uint32
	 func Xchg64(ptr *uint64, new uint64) uint64
	 func Xchgint32(ptr *int32, new int32) int32
	 func Xchgint64(ptr *int64, new int64) int64