Source file src/sync/atomic/atomic_test.go

Documentation: sync/atomic

		 1  // Copyright 2011 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package atomic_test
		 6  
		 7  import (
		 8  	"fmt"
		 9  	"runtime"
		10  	"strings"
		11  	. "sync/atomic"
		12  	"testing"
		13  	"unsafe"
		14  )
		15  
		16  // Tests of correct behavior, without contention.
		17  // (Does the function work as advertised?)
		18  //
		19  // Test that the Add functions add correctly.
		20  // Test that the CompareAndSwap functions actually
		21  // do the comparison and the swap correctly.
		22  //
		23  // The loop over power-of-two values is meant to
		24  // ensure that the operations apply to the full word size.
		25  // The struct fields x.before and x.after check that the
		26  // operations do not extend past the full word size.
		27  
		28  const (
		29  	magic32 = 0xdedbeef
		30  	magic64 = 0xdeddeadbeefbeef
		31  )
		32  
		33  // Do the 64-bit functions panic? If so, don't bother testing.
		34  var test64err = func() (err interface{}) {
		35  	defer func() {
		36  		err = recover()
		37  	}()
		38  	var x int64
		39  	AddInt64(&x, 1)
		40  	return nil
		41  }()
		42  
		43  func TestSwapInt32(t *testing.T) {
		44  	var x struct {
		45  		before int32
		46  		i			int32
		47  		after	int32
		48  	}
		49  	x.before = magic32
		50  	x.after = magic32
		51  	var j int32
		52  	for delta := int32(1); delta+delta > delta; delta += delta {
		53  		k := SwapInt32(&x.i, delta)
		54  		if x.i != delta || k != j {
		55  			t.Fatalf("delta=%d i=%d j=%d k=%d", delta, x.i, j, k)
		56  		}
		57  		j = delta
		58  	}
		59  	if x.before != magic32 || x.after != magic32 {
		60  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
		61  	}
		62  }
		63  
		64  func TestSwapUint32(t *testing.T) {
		65  	var x struct {
		66  		before uint32
		67  		i			uint32
		68  		after	uint32
		69  	}
		70  	x.before = magic32
		71  	x.after = magic32
		72  	var j uint32
		73  	for delta := uint32(1); delta+delta > delta; delta += delta {
		74  		k := SwapUint32(&x.i, delta)
		75  		if x.i != delta || k != j {
		76  			t.Fatalf("delta=%d i=%d j=%d k=%d", delta, x.i, j, k)
		77  		}
		78  		j = delta
		79  	}
		80  	if x.before != magic32 || x.after != magic32 {
		81  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
		82  	}
		83  }
		84  
		85  func TestSwapInt64(t *testing.T) {
		86  	if test64err != nil {
		87  		t.Skipf("Skipping 64-bit tests: %v", test64err)
		88  	}
		89  	var x struct {
		90  		before int64
		91  		i			int64
		92  		after	int64
		93  	}
		94  	x.before = magic64
		95  	x.after = magic64
		96  	var j int64
		97  	for delta := int64(1); delta+delta > delta; delta += delta {
		98  		k := SwapInt64(&x.i, delta)
		99  		if x.i != delta || k != j {
	 100  			t.Fatalf("delta=%d i=%d j=%d k=%d", delta, x.i, j, k)
	 101  		}
	 102  		j = delta
	 103  	}
	 104  	if x.before != magic64 || x.after != magic64 {
	 105  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, uint64(magic64), uint64(magic64))
	 106  	}
	 107  }
	 108  
	 109  func TestSwapUint64(t *testing.T) {
	 110  	if test64err != nil {
	 111  		t.Skipf("Skipping 64-bit tests: %v", test64err)
	 112  	}
	 113  	var x struct {
	 114  		before uint64
	 115  		i			uint64
	 116  		after	uint64
	 117  	}
	 118  	x.before = magic64
	 119  	x.after = magic64
	 120  	var j uint64
	 121  	for delta := uint64(1); delta+delta > delta; delta += delta {
	 122  		k := SwapUint64(&x.i, delta)
	 123  		if x.i != delta || k != j {
	 124  			t.Fatalf("delta=%d i=%d j=%d k=%d", delta, x.i, j, k)
	 125  		}
	 126  		j = delta
	 127  	}
	 128  	if x.before != magic64 || x.after != magic64 {
	 129  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, uint64(magic64), uint64(magic64))
	 130  	}
	 131  }
	 132  
	 133  func TestSwapUintptr(t *testing.T) {
	 134  	var x struct {
	 135  		before uintptr
	 136  		i			uintptr
	 137  		after	uintptr
	 138  	}
	 139  	var m uint64 = magic64
	 140  	magicptr := uintptr(m)
	 141  	x.before = magicptr
	 142  	x.after = magicptr
	 143  	var j uintptr
	 144  	for delta := uintptr(1); delta+delta > delta; delta += delta {
	 145  		k := SwapUintptr(&x.i, delta)
	 146  		if x.i != delta || k != j {
	 147  			t.Fatalf("delta=%d i=%d j=%d k=%d", delta, x.i, j, k)
	 148  		}
	 149  		j = delta
	 150  	}
	 151  	if x.before != magicptr || x.after != magicptr {
	 152  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magicptr, magicptr)
	 153  	}
	 154  }
	 155  
	 156  var global [1024]byte
	 157  
	 158  func testPointers() []unsafe.Pointer {
	 159  	var pointers []unsafe.Pointer
	 160  	// globals
	 161  	for i := 0; i < 10; i++ {
	 162  		pointers = append(pointers, unsafe.Pointer(&global[1<<i-1]))
	 163  	}
	 164  	// heap
	 165  	pointers = append(pointers, unsafe.Pointer(new(byte)))
	 166  	// nil
	 167  	pointers = append(pointers, nil)
	 168  	return pointers
	 169  }
	 170  
	 171  func TestSwapPointer(t *testing.T) {
	 172  	var x struct {
	 173  		before uintptr
	 174  		i			unsafe.Pointer
	 175  		after	uintptr
	 176  	}
	 177  	var m uint64 = magic64
	 178  	magicptr := uintptr(m)
	 179  	x.before = magicptr
	 180  	x.after = magicptr
	 181  	var j unsafe.Pointer
	 182  
	 183  	for _, p := range testPointers() {
	 184  		k := SwapPointer(&x.i, p)
	 185  		if x.i != p || k != j {
	 186  			t.Fatalf("p=%p i=%p j=%p k=%p", p, x.i, j, k)
	 187  		}
	 188  		j = p
	 189  	}
	 190  	if x.before != magicptr || x.after != magicptr {
	 191  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magicptr, magicptr)
	 192  	}
	 193  }
	 194  
	 195  func TestAddInt32(t *testing.T) {
	 196  	var x struct {
	 197  		before int32
	 198  		i			int32
	 199  		after	int32
	 200  	}
	 201  	x.before = magic32
	 202  	x.after = magic32
	 203  	var j int32
	 204  	for delta := int32(1); delta+delta > delta; delta += delta {
	 205  		k := AddInt32(&x.i, delta)
	 206  		j += delta
	 207  		if x.i != j || k != j {
	 208  			t.Fatalf("delta=%d i=%d j=%d k=%d", delta, x.i, j, k)
	 209  		}
	 210  	}
	 211  	if x.before != magic32 || x.after != magic32 {
	 212  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
	 213  	}
	 214  }
	 215  
	 216  func TestAddUint32(t *testing.T) {
	 217  	var x struct {
	 218  		before uint32
	 219  		i			uint32
	 220  		after	uint32
	 221  	}
	 222  	x.before = magic32
	 223  	x.after = magic32
	 224  	var j uint32
	 225  	for delta := uint32(1); delta+delta > delta; delta += delta {
	 226  		k := AddUint32(&x.i, delta)
	 227  		j += delta
	 228  		if x.i != j || k != j {
	 229  			t.Fatalf("delta=%d i=%d j=%d k=%d", delta, x.i, j, k)
	 230  		}
	 231  	}
	 232  	if x.before != magic32 || x.after != magic32 {
	 233  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
	 234  	}
	 235  }
	 236  
	 237  func TestAddInt64(t *testing.T) {
	 238  	if test64err != nil {
	 239  		t.Skipf("Skipping 64-bit tests: %v", test64err)
	 240  	}
	 241  	var x struct {
	 242  		before int64
	 243  		i			int64
	 244  		after	int64
	 245  	}
	 246  	x.before = magic64
	 247  	x.after = magic64
	 248  	var j int64
	 249  	for delta := int64(1); delta+delta > delta; delta += delta {
	 250  		k := AddInt64(&x.i, delta)
	 251  		j += delta
	 252  		if x.i != j || k != j {
	 253  			t.Fatalf("delta=%d i=%d j=%d k=%d", delta, x.i, j, k)
	 254  		}
	 255  	}
	 256  	if x.before != magic64 || x.after != magic64 {
	 257  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, int64(magic64), int64(magic64))
	 258  	}
	 259  }
	 260  
	 261  func TestAddUint64(t *testing.T) {
	 262  	if test64err != nil {
	 263  		t.Skipf("Skipping 64-bit tests: %v", test64err)
	 264  	}
	 265  	var x struct {
	 266  		before uint64
	 267  		i			uint64
	 268  		after	uint64
	 269  	}
	 270  	x.before = magic64
	 271  	x.after = magic64
	 272  	var j uint64
	 273  	for delta := uint64(1); delta+delta > delta; delta += delta {
	 274  		k := AddUint64(&x.i, delta)
	 275  		j += delta
	 276  		if x.i != j || k != j {
	 277  			t.Fatalf("delta=%d i=%d j=%d k=%d", delta, x.i, j, k)
	 278  		}
	 279  	}
	 280  	if x.before != magic64 || x.after != magic64 {
	 281  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, uint64(magic64), uint64(magic64))
	 282  	}
	 283  }
	 284  
	 285  func TestAddUintptr(t *testing.T) {
	 286  	var x struct {
	 287  		before uintptr
	 288  		i			uintptr
	 289  		after	uintptr
	 290  	}
	 291  	var m uint64 = magic64
	 292  	magicptr := uintptr(m)
	 293  	x.before = magicptr
	 294  	x.after = magicptr
	 295  	var j uintptr
	 296  	for delta := uintptr(1); delta+delta > delta; delta += delta {
	 297  		k := AddUintptr(&x.i, delta)
	 298  		j += delta
	 299  		if x.i != j || k != j {
	 300  			t.Fatalf("delta=%d i=%d j=%d k=%d", delta, x.i, j, k)
	 301  		}
	 302  	}
	 303  	if x.before != magicptr || x.after != magicptr {
	 304  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magicptr, magicptr)
	 305  	}
	 306  }
	 307  
	 308  func TestCompareAndSwapInt32(t *testing.T) {
	 309  	var x struct {
	 310  		before int32
	 311  		i			int32
	 312  		after	int32
	 313  	}
	 314  	x.before = magic32
	 315  	x.after = magic32
	 316  	for val := int32(1); val+val > val; val += val {
	 317  		x.i = val
	 318  		if !CompareAndSwapInt32(&x.i, val, val+1) {
	 319  			t.Fatalf("should have swapped %#x %#x", val, val+1)
	 320  		}
	 321  		if x.i != val+1 {
	 322  			t.Fatalf("wrong x.i after swap: x.i=%#x val+1=%#x", x.i, val+1)
	 323  		}
	 324  		x.i = val + 1
	 325  		if CompareAndSwapInt32(&x.i, val, val+2) {
	 326  			t.Fatalf("should not have swapped %#x %#x", val, val+2)
	 327  		}
	 328  		if x.i != val+1 {
	 329  			t.Fatalf("wrong x.i after swap: x.i=%#x val+1=%#x", x.i, val+1)
	 330  		}
	 331  	}
	 332  	if x.before != magic32 || x.after != magic32 {
	 333  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
	 334  	}
	 335  }
	 336  
	 337  func TestCompareAndSwapUint32(t *testing.T) {
	 338  	var x struct {
	 339  		before uint32
	 340  		i			uint32
	 341  		after	uint32
	 342  	}
	 343  	x.before = magic32
	 344  	x.after = magic32
	 345  	for val := uint32(1); val+val > val; val += val {
	 346  		x.i = val
	 347  		if !CompareAndSwapUint32(&x.i, val, val+1) {
	 348  			t.Fatalf("should have swapped %#x %#x", val, val+1)
	 349  		}
	 350  		if x.i != val+1 {
	 351  			t.Fatalf("wrong x.i after swap: x.i=%#x val+1=%#x", x.i, val+1)
	 352  		}
	 353  		x.i = val + 1
	 354  		if CompareAndSwapUint32(&x.i, val, val+2) {
	 355  			t.Fatalf("should not have swapped %#x %#x", val, val+2)
	 356  		}
	 357  		if x.i != val+1 {
	 358  			t.Fatalf("wrong x.i after swap: x.i=%#x val+1=%#x", x.i, val+1)
	 359  		}
	 360  	}
	 361  	if x.before != magic32 || x.after != magic32 {
	 362  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
	 363  	}
	 364  }
	 365  
	 366  func TestCompareAndSwapInt64(t *testing.T) {
	 367  	if test64err != nil {
	 368  		t.Skipf("Skipping 64-bit tests: %v", test64err)
	 369  	}
	 370  	var x struct {
	 371  		before int64
	 372  		i			int64
	 373  		after	int64
	 374  	}
	 375  	x.before = magic64
	 376  	x.after = magic64
	 377  	for val := int64(1); val+val > val; val += val {
	 378  		x.i = val
	 379  		if !CompareAndSwapInt64(&x.i, val, val+1) {
	 380  			t.Fatalf("should have swapped %#x %#x", val, val+1)
	 381  		}
	 382  		if x.i != val+1 {
	 383  			t.Fatalf("wrong x.i after swap: x.i=%#x val+1=%#x", x.i, val+1)
	 384  		}
	 385  		x.i = val + 1
	 386  		if CompareAndSwapInt64(&x.i, val, val+2) {
	 387  			t.Fatalf("should not have swapped %#x %#x", val, val+2)
	 388  		}
	 389  		if x.i != val+1 {
	 390  			t.Fatalf("wrong x.i after swap: x.i=%#x val+1=%#x", x.i, val+1)
	 391  		}
	 392  	}
	 393  	if x.before != magic64 || x.after != magic64 {
	 394  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, uint64(magic64), uint64(magic64))
	 395  	}
	 396  }
	 397  
	 398  func testCompareAndSwapUint64(t *testing.T, cas func(*uint64, uint64, uint64) bool) {
	 399  	if test64err != nil {
	 400  		t.Skipf("Skipping 64-bit tests: %v", test64err)
	 401  	}
	 402  	var x struct {
	 403  		before uint64
	 404  		i			uint64
	 405  		after	uint64
	 406  	}
	 407  	x.before = magic64
	 408  	x.after = magic64
	 409  	for val := uint64(1); val+val > val; val += val {
	 410  		x.i = val
	 411  		if !cas(&x.i, val, val+1) {
	 412  			t.Fatalf("should have swapped %#x %#x", val, val+1)
	 413  		}
	 414  		if x.i != val+1 {
	 415  			t.Fatalf("wrong x.i after swap: x.i=%#x val+1=%#x", x.i, val+1)
	 416  		}
	 417  		x.i = val + 1
	 418  		if cas(&x.i, val, val+2) {
	 419  			t.Fatalf("should not have swapped %#x %#x", val, val+2)
	 420  		}
	 421  		if x.i != val+1 {
	 422  			t.Fatalf("wrong x.i after swap: x.i=%#x val+1=%#x", x.i, val+1)
	 423  		}
	 424  	}
	 425  	if x.before != magic64 || x.after != magic64 {
	 426  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, uint64(magic64), uint64(magic64))
	 427  	}
	 428  }
	 429  
	 430  func TestCompareAndSwapUint64(t *testing.T) {
	 431  	testCompareAndSwapUint64(t, CompareAndSwapUint64)
	 432  }
	 433  
	 434  func TestCompareAndSwapUintptr(t *testing.T) {
	 435  	var x struct {
	 436  		before uintptr
	 437  		i			uintptr
	 438  		after	uintptr
	 439  	}
	 440  	var m uint64 = magic64
	 441  	magicptr := uintptr(m)
	 442  	x.before = magicptr
	 443  	x.after = magicptr
	 444  	for val := uintptr(1); val+val > val; val += val {
	 445  		x.i = val
	 446  		if !CompareAndSwapUintptr(&x.i, val, val+1) {
	 447  			t.Fatalf("should have swapped %#x %#x", val, val+1)
	 448  		}
	 449  		if x.i != val+1 {
	 450  			t.Fatalf("wrong x.i after swap: x.i=%#x val+1=%#x", x.i, val+1)
	 451  		}
	 452  		x.i = val + 1
	 453  		if CompareAndSwapUintptr(&x.i, val, val+2) {
	 454  			t.Fatalf("should not have swapped %#x %#x", val, val+2)
	 455  		}
	 456  		if x.i != val+1 {
	 457  			t.Fatalf("wrong x.i after swap: x.i=%#x val+1=%#x", x.i, val+1)
	 458  		}
	 459  	}
	 460  	if x.before != magicptr || x.after != magicptr {
	 461  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magicptr, magicptr)
	 462  	}
	 463  }
	 464  
	 465  func TestCompareAndSwapPointer(t *testing.T) {
	 466  	var x struct {
	 467  		before uintptr
	 468  		i			unsafe.Pointer
	 469  		after	uintptr
	 470  	}
	 471  	var m uint64 = magic64
	 472  	magicptr := uintptr(m)
	 473  	x.before = magicptr
	 474  	x.after = magicptr
	 475  	q := unsafe.Pointer(new(byte))
	 476  	for _, p := range testPointers() {
	 477  		x.i = p
	 478  		if !CompareAndSwapPointer(&x.i, p, q) {
	 479  			t.Fatalf("should have swapped %p %p", p, q)
	 480  		}
	 481  		if x.i != q {
	 482  			t.Fatalf("wrong x.i after swap: x.i=%p want %p", x.i, q)
	 483  		}
	 484  		if CompareAndSwapPointer(&x.i, p, nil) {
	 485  			t.Fatalf("should not have swapped %p nil", p)
	 486  		}
	 487  		if x.i != q {
	 488  			t.Fatalf("wrong x.i after swap: x.i=%p want %p", x.i, q)
	 489  		}
	 490  	}
	 491  	if x.before != magicptr || x.after != magicptr {
	 492  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magicptr, magicptr)
	 493  	}
	 494  }
	 495  
	 496  func TestLoadInt32(t *testing.T) {
	 497  	var x struct {
	 498  		before int32
	 499  		i			int32
	 500  		after	int32
	 501  	}
	 502  	x.before = magic32
	 503  	x.after = magic32
	 504  	for delta := int32(1); delta+delta > delta; delta += delta {
	 505  		k := LoadInt32(&x.i)
	 506  		if k != x.i {
	 507  			t.Fatalf("delta=%d i=%d k=%d", delta, x.i, k)
	 508  		}
	 509  		x.i += delta
	 510  	}
	 511  	if x.before != magic32 || x.after != magic32 {
	 512  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
	 513  	}
	 514  }
	 515  
	 516  func TestLoadUint32(t *testing.T) {
	 517  	var x struct {
	 518  		before uint32
	 519  		i			uint32
	 520  		after	uint32
	 521  	}
	 522  	x.before = magic32
	 523  	x.after = magic32
	 524  	for delta := uint32(1); delta+delta > delta; delta += delta {
	 525  		k := LoadUint32(&x.i)
	 526  		if k != x.i {
	 527  			t.Fatalf("delta=%d i=%d k=%d", delta, x.i, k)
	 528  		}
	 529  		x.i += delta
	 530  	}
	 531  	if x.before != magic32 || x.after != magic32 {
	 532  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
	 533  	}
	 534  }
	 535  
	 536  func TestLoadInt64(t *testing.T) {
	 537  	if test64err != nil {
	 538  		t.Skipf("Skipping 64-bit tests: %v", test64err)
	 539  	}
	 540  	var x struct {
	 541  		before int64
	 542  		i			int64
	 543  		after	int64
	 544  	}
	 545  	x.before = magic64
	 546  	x.after = magic64
	 547  	for delta := int64(1); delta+delta > delta; delta += delta {
	 548  		k := LoadInt64(&x.i)
	 549  		if k != x.i {
	 550  			t.Fatalf("delta=%d i=%d k=%d", delta, x.i, k)
	 551  		}
	 552  		x.i += delta
	 553  	}
	 554  	if x.before != magic64 || x.after != magic64 {
	 555  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, uint64(magic64), uint64(magic64))
	 556  	}
	 557  }
	 558  
	 559  func TestLoadUint64(t *testing.T) {
	 560  	if test64err != nil {
	 561  		t.Skipf("Skipping 64-bit tests: %v", test64err)
	 562  	}
	 563  	var x struct {
	 564  		before uint64
	 565  		i			uint64
	 566  		after	uint64
	 567  	}
	 568  	x.before = magic64
	 569  	x.after = magic64
	 570  	for delta := uint64(1); delta+delta > delta; delta += delta {
	 571  		k := LoadUint64(&x.i)
	 572  		if k != x.i {
	 573  			t.Fatalf("delta=%d i=%d k=%d", delta, x.i, k)
	 574  		}
	 575  		x.i += delta
	 576  	}
	 577  	if x.before != magic64 || x.after != magic64 {
	 578  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, uint64(magic64), uint64(magic64))
	 579  	}
	 580  }
	 581  
	 582  func TestLoadUintptr(t *testing.T) {
	 583  	var x struct {
	 584  		before uintptr
	 585  		i			uintptr
	 586  		after	uintptr
	 587  	}
	 588  	var m uint64 = magic64
	 589  	magicptr := uintptr(m)
	 590  	x.before = magicptr
	 591  	x.after = magicptr
	 592  	for delta := uintptr(1); delta+delta > delta; delta += delta {
	 593  		k := LoadUintptr(&x.i)
	 594  		if k != x.i {
	 595  			t.Fatalf("delta=%d i=%d k=%d", delta, x.i, k)
	 596  		}
	 597  		x.i += delta
	 598  	}
	 599  	if x.before != magicptr || x.after != magicptr {
	 600  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magicptr, magicptr)
	 601  	}
	 602  }
	 603  
	 604  func TestLoadPointer(t *testing.T) {
	 605  	var x struct {
	 606  		before uintptr
	 607  		i			unsafe.Pointer
	 608  		after	uintptr
	 609  	}
	 610  	var m uint64 = magic64
	 611  	magicptr := uintptr(m)
	 612  	x.before = magicptr
	 613  	x.after = magicptr
	 614  	for _, p := range testPointers() {
	 615  		x.i = p
	 616  		k := LoadPointer(&x.i)
	 617  		if k != p {
	 618  			t.Fatalf("p=%x k=%x", p, k)
	 619  		}
	 620  	}
	 621  	if x.before != magicptr || x.after != magicptr {
	 622  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magicptr, magicptr)
	 623  	}
	 624  }
	 625  
	 626  func TestStoreInt32(t *testing.T) {
	 627  	var x struct {
	 628  		before int32
	 629  		i			int32
	 630  		after	int32
	 631  	}
	 632  	x.before = magic32
	 633  	x.after = magic32
	 634  	v := int32(0)
	 635  	for delta := int32(1); delta+delta > delta; delta += delta {
	 636  		StoreInt32(&x.i, v)
	 637  		if x.i != v {
	 638  			t.Fatalf("delta=%d i=%d v=%d", delta, x.i, v)
	 639  		}
	 640  		v += delta
	 641  	}
	 642  	if x.before != magic32 || x.after != magic32 {
	 643  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
	 644  	}
	 645  }
	 646  
	 647  func TestStoreUint32(t *testing.T) {
	 648  	var x struct {
	 649  		before uint32
	 650  		i			uint32
	 651  		after	uint32
	 652  	}
	 653  	x.before = magic32
	 654  	x.after = magic32
	 655  	v := uint32(0)
	 656  	for delta := uint32(1); delta+delta > delta; delta += delta {
	 657  		StoreUint32(&x.i, v)
	 658  		if x.i != v {
	 659  			t.Fatalf("delta=%d i=%d v=%d", delta, x.i, v)
	 660  		}
	 661  		v += delta
	 662  	}
	 663  	if x.before != magic32 || x.after != magic32 {
	 664  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
	 665  	}
	 666  }
	 667  
	 668  func TestStoreInt64(t *testing.T) {
	 669  	if test64err != nil {
	 670  		t.Skipf("Skipping 64-bit tests: %v", test64err)
	 671  	}
	 672  	var x struct {
	 673  		before int64
	 674  		i			int64
	 675  		after	int64
	 676  	}
	 677  	x.before = magic64
	 678  	x.after = magic64
	 679  	v := int64(0)
	 680  	for delta := int64(1); delta+delta > delta; delta += delta {
	 681  		StoreInt64(&x.i, v)
	 682  		if x.i != v {
	 683  			t.Fatalf("delta=%d i=%d v=%d", delta, x.i, v)
	 684  		}
	 685  		v += delta
	 686  	}
	 687  	if x.before != magic64 || x.after != magic64 {
	 688  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, uint64(magic64), uint64(magic64))
	 689  	}
	 690  }
	 691  
	 692  func TestStoreUint64(t *testing.T) {
	 693  	if test64err != nil {
	 694  		t.Skipf("Skipping 64-bit tests: %v", test64err)
	 695  	}
	 696  	var x struct {
	 697  		before uint64
	 698  		i			uint64
	 699  		after	uint64
	 700  	}
	 701  	x.before = magic64
	 702  	x.after = magic64
	 703  	v := uint64(0)
	 704  	for delta := uint64(1); delta+delta > delta; delta += delta {
	 705  		StoreUint64(&x.i, v)
	 706  		if x.i != v {
	 707  			t.Fatalf("delta=%d i=%d v=%d", delta, x.i, v)
	 708  		}
	 709  		v += delta
	 710  	}
	 711  	if x.before != magic64 || x.after != magic64 {
	 712  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, uint64(magic64), uint64(magic64))
	 713  	}
	 714  }
	 715  
	 716  func TestStoreUintptr(t *testing.T) {
	 717  	var x struct {
	 718  		before uintptr
	 719  		i			uintptr
	 720  		after	uintptr
	 721  	}
	 722  	var m uint64 = magic64
	 723  	magicptr := uintptr(m)
	 724  	x.before = magicptr
	 725  	x.after = magicptr
	 726  	v := uintptr(0)
	 727  	for delta := uintptr(1); delta+delta > delta; delta += delta {
	 728  		StoreUintptr(&x.i, v)
	 729  		if x.i != v {
	 730  			t.Fatalf("delta=%d i=%d v=%d", delta, x.i, v)
	 731  		}
	 732  		v += delta
	 733  	}
	 734  	if x.before != magicptr || x.after != magicptr {
	 735  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magicptr, magicptr)
	 736  	}
	 737  }
	 738  
	 739  func TestStorePointer(t *testing.T) {
	 740  	var x struct {
	 741  		before uintptr
	 742  		i			unsafe.Pointer
	 743  		after	uintptr
	 744  	}
	 745  	var m uint64 = magic64
	 746  	magicptr := uintptr(m)
	 747  	x.before = magicptr
	 748  	x.after = magicptr
	 749  	for _, p := range testPointers() {
	 750  		StorePointer(&x.i, p)
	 751  		if x.i != p {
	 752  			t.Fatalf("x.i=%p p=%p", x.i, p)
	 753  		}
	 754  	}
	 755  	if x.before != magicptr || x.after != magicptr {
	 756  		t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magicptr, magicptr)
	 757  	}
	 758  }
	 759  
	 760  // Tests of correct behavior, with contention.
	 761  // (Is the function atomic?)
	 762  //
	 763  // For each function, we write a "hammer" function that repeatedly
	 764  // uses the atomic operation to add 1 to a value. After running
	 765  // multiple hammers in parallel, check that we end with the correct
	 766  // total.
	 767  // Swap can't add 1, so it uses a different scheme.
	 768  // The functions repeatedly generate a pseudo-random number such that
	 769  // low bits are equal to high bits, swap, check that the old value
	 770  // has low and high bits equal.
	 771  
	 772  var hammer32 = map[string]func(*uint32, int){
	 773  	"SwapInt32":						 hammerSwapInt32,
	 774  	"SwapUint32":						hammerSwapUint32,
	 775  	"SwapUintptr":					 hammerSwapUintptr32,
	 776  	"AddInt32":							hammerAddInt32,
	 777  	"AddUint32":						 hammerAddUint32,
	 778  	"AddUintptr":						hammerAddUintptr32,
	 779  	"CompareAndSwapInt32":	 hammerCompareAndSwapInt32,
	 780  	"CompareAndSwapUint32":	hammerCompareAndSwapUint32,
	 781  	"CompareAndSwapUintptr": hammerCompareAndSwapUintptr32,
	 782  }
	 783  
	 784  func init() {
	 785  	var v uint64 = 1 << 50
	 786  	if uintptr(v) != 0 {
	 787  		// 64-bit system; clear uintptr tests
	 788  		delete(hammer32, "SwapUintptr")
	 789  		delete(hammer32, "AddUintptr")
	 790  		delete(hammer32, "CompareAndSwapUintptr")
	 791  	}
	 792  }
	 793  
	 794  func hammerSwapInt32(uaddr *uint32, count int) {
	 795  	addr := (*int32)(unsafe.Pointer(uaddr))
	 796  	seed := int(uintptr(unsafe.Pointer(&count)))
	 797  	for i := 0; i < count; i++ {
	 798  		new := uint32(seed+i)<<16 | uint32(seed+i)<<16>>16
	 799  		old := uint32(SwapInt32(addr, int32(new)))
	 800  		if old>>16 != old<<16>>16 {
	 801  			panic(fmt.Sprintf("SwapInt32 is not atomic: %v", old))
	 802  		}
	 803  	}
	 804  }
	 805  
	 806  func hammerSwapUint32(addr *uint32, count int) {
	 807  	seed := int(uintptr(unsafe.Pointer(&count)))
	 808  	for i := 0; i < count; i++ {
	 809  		new := uint32(seed+i)<<16 | uint32(seed+i)<<16>>16
	 810  		old := SwapUint32(addr, new)
	 811  		if old>>16 != old<<16>>16 {
	 812  			panic(fmt.Sprintf("SwapUint32 is not atomic: %v", old))
	 813  		}
	 814  	}
	 815  }
	 816  
	 817  func hammerSwapUintptr32(uaddr *uint32, count int) {
	 818  	// only safe when uintptr is 32-bit.
	 819  	// not called on 64-bit systems.
	 820  	addr := (*uintptr)(unsafe.Pointer(uaddr))
	 821  	seed := int(uintptr(unsafe.Pointer(&count)))
	 822  	for i := 0; i < count; i++ {
	 823  		new := uintptr(seed+i)<<16 | uintptr(seed+i)<<16>>16
	 824  		old := SwapUintptr(addr, new)
	 825  		if old>>16 != old<<16>>16 {
	 826  			panic(fmt.Sprintf("SwapUintptr is not atomic: %#08x", old))
	 827  		}
	 828  	}
	 829  }
	 830  
	 831  func hammerAddInt32(uaddr *uint32, count int) {
	 832  	addr := (*int32)(unsafe.Pointer(uaddr))
	 833  	for i := 0; i < count; i++ {
	 834  		AddInt32(addr, 1)
	 835  	}
	 836  }
	 837  
	 838  func hammerAddUint32(addr *uint32, count int) {
	 839  	for i := 0; i < count; i++ {
	 840  		AddUint32(addr, 1)
	 841  	}
	 842  }
	 843  
	 844  func hammerAddUintptr32(uaddr *uint32, count int) {
	 845  	// only safe when uintptr is 32-bit.
	 846  	// not called on 64-bit systems.
	 847  	addr := (*uintptr)(unsafe.Pointer(uaddr))
	 848  	for i := 0; i < count; i++ {
	 849  		AddUintptr(addr, 1)
	 850  	}
	 851  }
	 852  
	 853  func hammerCompareAndSwapInt32(uaddr *uint32, count int) {
	 854  	addr := (*int32)(unsafe.Pointer(uaddr))
	 855  	for i := 0; i < count; i++ {
	 856  		for {
	 857  			v := LoadInt32(addr)
	 858  			if CompareAndSwapInt32(addr, v, v+1) {
	 859  				break
	 860  			}
	 861  		}
	 862  	}
	 863  }
	 864  
	 865  func hammerCompareAndSwapUint32(addr *uint32, count int) {
	 866  	for i := 0; i < count; i++ {
	 867  		for {
	 868  			v := LoadUint32(addr)
	 869  			if CompareAndSwapUint32(addr, v, v+1) {
	 870  				break
	 871  			}
	 872  		}
	 873  	}
	 874  }
	 875  
	 876  func hammerCompareAndSwapUintptr32(uaddr *uint32, count int) {
	 877  	// only safe when uintptr is 32-bit.
	 878  	// not called on 64-bit systems.
	 879  	addr := (*uintptr)(unsafe.Pointer(uaddr))
	 880  	for i := 0; i < count; i++ {
	 881  		for {
	 882  			v := LoadUintptr(addr)
	 883  			if CompareAndSwapUintptr(addr, v, v+1) {
	 884  				break
	 885  			}
	 886  		}
	 887  	}
	 888  }
	 889  
	 890  func TestHammer32(t *testing.T) {
	 891  	const p = 4
	 892  	n := 100000
	 893  	if testing.Short() {
	 894  		n = 1000
	 895  	}
	 896  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(p))
	 897  
	 898  	for name, testf := range hammer32 {
	 899  		c := make(chan int)
	 900  		var val uint32
	 901  		for i := 0; i < p; i++ {
	 902  			go func() {
	 903  				defer func() {
	 904  					if err := recover(); err != nil {
	 905  						t.Error(err.(string))
	 906  					}
	 907  					c <- 1
	 908  				}()
	 909  				testf(&val, n)
	 910  			}()
	 911  		}
	 912  		for i := 0; i < p; i++ {
	 913  			<-c
	 914  		}
	 915  		if !strings.HasPrefix(name, "Swap") && val != uint32(n)*p {
	 916  			t.Fatalf("%s: val=%d want %d", name, val, n*p)
	 917  		}
	 918  	}
	 919  }
	 920  
	 921  var hammer64 = map[string]func(*uint64, int){
	 922  	"SwapInt64":						 hammerSwapInt64,
	 923  	"SwapUint64":						hammerSwapUint64,
	 924  	"SwapUintptr":					 hammerSwapUintptr64,
	 925  	"AddInt64":							hammerAddInt64,
	 926  	"AddUint64":						 hammerAddUint64,
	 927  	"AddUintptr":						hammerAddUintptr64,
	 928  	"CompareAndSwapInt64":	 hammerCompareAndSwapInt64,
	 929  	"CompareAndSwapUint64":	hammerCompareAndSwapUint64,
	 930  	"CompareAndSwapUintptr": hammerCompareAndSwapUintptr64,
	 931  }
	 932  
	 933  func init() {
	 934  	var v uint64 = 1 << 50
	 935  	if uintptr(v) == 0 {
	 936  		// 32-bit system; clear uintptr tests
	 937  		delete(hammer64, "SwapUintptr")
	 938  		delete(hammer64, "AddUintptr")
	 939  		delete(hammer64, "CompareAndSwapUintptr")
	 940  	}
	 941  }
	 942  
	 943  func hammerSwapInt64(uaddr *uint64, count int) {
	 944  	addr := (*int64)(unsafe.Pointer(uaddr))
	 945  	seed := int(uintptr(unsafe.Pointer(&count)))
	 946  	for i := 0; i < count; i++ {
	 947  		new := uint64(seed+i)<<32 | uint64(seed+i)<<32>>32
	 948  		old := uint64(SwapInt64(addr, int64(new)))
	 949  		if old>>32 != old<<32>>32 {
	 950  			panic(fmt.Sprintf("SwapInt64 is not atomic: %v", old))
	 951  		}
	 952  	}
	 953  }
	 954  
	 955  func hammerSwapUint64(addr *uint64, count int) {
	 956  	seed := int(uintptr(unsafe.Pointer(&count)))
	 957  	for i := 0; i < count; i++ {
	 958  		new := uint64(seed+i)<<32 | uint64(seed+i)<<32>>32
	 959  		old := SwapUint64(addr, new)
	 960  		if old>>32 != old<<32>>32 {
	 961  			panic(fmt.Sprintf("SwapUint64 is not atomic: %v", old))
	 962  		}
	 963  	}
	 964  }
	 965  
	 966  const arch32 = unsafe.Sizeof(uintptr(0)) == 4
	 967  
	 968  func hammerSwapUintptr64(uaddr *uint64, count int) {
	 969  	// only safe when uintptr is 64-bit.
	 970  	// not called on 32-bit systems.
	 971  	if !arch32 {
	 972  		addr := (*uintptr)(unsafe.Pointer(uaddr))
	 973  		seed := int(uintptr(unsafe.Pointer(&count)))
	 974  		for i := 0; i < count; i++ {
	 975  			new := uintptr(seed+i)<<32 | uintptr(seed+i)<<32>>32
	 976  			old := SwapUintptr(addr, new)
	 977  			if old>>32 != old<<32>>32 {
	 978  				panic(fmt.Sprintf("SwapUintptr is not atomic: %v", old))
	 979  			}
	 980  		}
	 981  	}
	 982  }
	 983  
	 984  func hammerAddInt64(uaddr *uint64, count int) {
	 985  	addr := (*int64)(unsafe.Pointer(uaddr))
	 986  	for i := 0; i < count; i++ {
	 987  		AddInt64(addr, 1)
	 988  	}
	 989  }
	 990  
	 991  func hammerAddUint64(addr *uint64, count int) {
	 992  	for i := 0; i < count; i++ {
	 993  		AddUint64(addr, 1)
	 994  	}
	 995  }
	 996  
	 997  func hammerAddUintptr64(uaddr *uint64, count int) {
	 998  	// only safe when uintptr is 64-bit.
	 999  	// not called on 32-bit systems.
	1000  	addr := (*uintptr)(unsafe.Pointer(uaddr))
	1001  	for i := 0; i < count; i++ {
	1002  		AddUintptr(addr, 1)
	1003  	}
	1004  }
	1005  
	1006  func hammerCompareAndSwapInt64(uaddr *uint64, count int) {
	1007  	addr := (*int64)(unsafe.Pointer(uaddr))
	1008  	for i := 0; i < count; i++ {
	1009  		for {
	1010  			v := LoadInt64(addr)
	1011  			if CompareAndSwapInt64(addr, v, v+1) {
	1012  				break
	1013  			}
	1014  		}
	1015  	}
	1016  }
	1017  
	1018  func hammerCompareAndSwapUint64(addr *uint64, count int) {
	1019  	for i := 0; i < count; i++ {
	1020  		for {
	1021  			v := LoadUint64(addr)
	1022  			if CompareAndSwapUint64(addr, v, v+1) {
	1023  				break
	1024  			}
	1025  		}
	1026  	}
	1027  }
	1028  
	1029  func hammerCompareAndSwapUintptr64(uaddr *uint64, count int) {
	1030  	// only safe when uintptr is 64-bit.
	1031  	// not called on 32-bit systems.
	1032  	addr := (*uintptr)(unsafe.Pointer(uaddr))
	1033  	for i := 0; i < count; i++ {
	1034  		for {
	1035  			v := LoadUintptr(addr)
	1036  			if CompareAndSwapUintptr(addr, v, v+1) {
	1037  				break
	1038  			}
	1039  		}
	1040  	}
	1041  }
	1042  
	1043  func TestHammer64(t *testing.T) {
	1044  	if test64err != nil {
	1045  		t.Skipf("Skipping 64-bit tests: %v", test64err)
	1046  	}
	1047  	const p = 4
	1048  	n := 100000
	1049  	if testing.Short() {
	1050  		n = 1000
	1051  	}
	1052  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(p))
	1053  
	1054  	for name, testf := range hammer64 {
	1055  		c := make(chan int)
	1056  		var val uint64
	1057  		for i := 0; i < p; i++ {
	1058  			go func() {
	1059  				defer func() {
	1060  					if err := recover(); err != nil {
	1061  						t.Error(err.(string))
	1062  					}
	1063  					c <- 1
	1064  				}()
	1065  				testf(&val, n)
	1066  			}()
	1067  		}
	1068  		for i := 0; i < p; i++ {
	1069  			<-c
	1070  		}
	1071  		if !strings.HasPrefix(name, "Swap") && val != uint64(n)*p {
	1072  			t.Fatalf("%s: val=%d want %d", name, val, n*p)
	1073  		}
	1074  	}
	1075  }
	1076  
	1077  func hammerStoreLoadInt32(t *testing.T, paddr unsafe.Pointer) {
	1078  	addr := (*int32)(paddr)
	1079  	v := LoadInt32(addr)
	1080  	vlo := v & ((1 << 16) - 1)
	1081  	vhi := v >> 16
	1082  	if vlo != vhi {
	1083  		t.Fatalf("Int32: %#x != %#x", vlo, vhi)
	1084  	}
	1085  	new := v + 1 + 1<<16
	1086  	if vlo == 1e4 {
	1087  		new = 0
	1088  	}
	1089  	StoreInt32(addr, new)
	1090  }
	1091  
	1092  func hammerStoreLoadUint32(t *testing.T, paddr unsafe.Pointer) {
	1093  	addr := (*uint32)(paddr)
	1094  	v := LoadUint32(addr)
	1095  	vlo := v & ((1 << 16) - 1)
	1096  	vhi := v >> 16
	1097  	if vlo != vhi {
	1098  		t.Fatalf("Uint32: %#x != %#x", vlo, vhi)
	1099  	}
	1100  	new := v + 1 + 1<<16
	1101  	if vlo == 1e4 {
	1102  		new = 0
	1103  	}
	1104  	StoreUint32(addr, new)
	1105  }
	1106  
	1107  func hammerStoreLoadInt64(t *testing.T, paddr unsafe.Pointer) {
	1108  	addr := (*int64)(paddr)
	1109  	v := LoadInt64(addr)
	1110  	vlo := v & ((1 << 32) - 1)
	1111  	vhi := v >> 32
	1112  	if vlo != vhi {
	1113  		t.Fatalf("Int64: %#x != %#x", vlo, vhi)
	1114  	}
	1115  	new := v + 1 + 1<<32
	1116  	StoreInt64(addr, new)
	1117  }
	1118  
	1119  func hammerStoreLoadUint64(t *testing.T, paddr unsafe.Pointer) {
	1120  	addr := (*uint64)(paddr)
	1121  	v := LoadUint64(addr)
	1122  	vlo := v & ((1 << 32) - 1)
	1123  	vhi := v >> 32
	1124  	if vlo != vhi {
	1125  		t.Fatalf("Uint64: %#x != %#x", vlo, vhi)
	1126  	}
	1127  	new := v + 1 + 1<<32
	1128  	StoreUint64(addr, new)
	1129  }
	1130  
	1131  func hammerStoreLoadUintptr(t *testing.T, paddr unsafe.Pointer) {
	1132  	addr := (*uintptr)(paddr)
	1133  	v := LoadUintptr(addr)
	1134  	new := v
	1135  	if arch32 {
	1136  		vlo := v & ((1 << 16) - 1)
	1137  		vhi := v >> 16
	1138  		if vlo != vhi {
	1139  			t.Fatalf("Uintptr: %#x != %#x", vlo, vhi)
	1140  		}
	1141  		new = v + 1 + 1<<16
	1142  		if vlo == 1e4 {
	1143  			new = 0
	1144  		}
	1145  	} else {
	1146  		vlo := v & ((1 << 32) - 1)
	1147  		vhi := v >> 32
	1148  		if vlo != vhi {
	1149  			t.Fatalf("Uintptr: %#x != %#x", vlo, vhi)
	1150  		}
	1151  		inc := uint64(1 + 1<<32)
	1152  		new = v + uintptr(inc)
	1153  	}
	1154  	StoreUintptr(addr, new)
	1155  }
	1156  
	1157  //go:nocheckptr
	1158  // This code is just testing that LoadPointer/StorePointer operate
	1159  // atomically; it's not actually calculating pointers.
	1160  func hammerStoreLoadPointer(t *testing.T, paddr unsafe.Pointer) {
	1161  	addr := (*unsafe.Pointer)(paddr)
	1162  	v := uintptr(LoadPointer(addr))
	1163  	new := v
	1164  	if arch32 {
	1165  		vlo := v & ((1 << 16) - 1)
	1166  		vhi := v >> 16
	1167  		if vlo != vhi {
	1168  			t.Fatalf("Pointer: %#x != %#x", vlo, vhi)
	1169  		}
	1170  		new = v + 1 + 1<<16
	1171  		if vlo == 1e4 {
	1172  			new = 0
	1173  		}
	1174  	} else {
	1175  		vlo := v & ((1 << 32) - 1)
	1176  		vhi := v >> 32
	1177  		if vlo != vhi {
	1178  			t.Fatalf("Pointer: %#x != %#x", vlo, vhi)
	1179  		}
	1180  		inc := uint64(1 + 1<<32)
	1181  		new = v + uintptr(inc)
	1182  	}
	1183  	StorePointer(addr, unsafe.Pointer(new))
	1184  }
	1185  
	1186  func TestHammerStoreLoad(t *testing.T) {
	1187  	var tests []func(*testing.T, unsafe.Pointer)
	1188  	tests = append(tests, hammerStoreLoadInt32, hammerStoreLoadUint32,
	1189  		hammerStoreLoadUintptr, hammerStoreLoadPointer)
	1190  	if test64err == nil {
	1191  		tests = append(tests, hammerStoreLoadInt64, hammerStoreLoadUint64)
	1192  	}
	1193  	n := int(1e6)
	1194  	if testing.Short() {
	1195  		n = int(1e4)
	1196  	}
	1197  	const procs = 8
	1198  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(procs))
	1199  	for _, tt := range tests {
	1200  		c := make(chan int)
	1201  		var val uint64
	1202  		for p := 0; p < procs; p++ {
	1203  			go func() {
	1204  				for i := 0; i < n; i++ {
	1205  					tt(t, unsafe.Pointer(&val))
	1206  				}
	1207  				c <- 1
	1208  			}()
	1209  		}
	1210  		for p := 0; p < procs; p++ {
	1211  			<-c
	1212  		}
	1213  	}
	1214  }
	1215  
	1216  func TestStoreLoadSeqCst32(t *testing.T) {
	1217  	if runtime.NumCPU() == 1 {
	1218  		t.Skipf("Skipping test on %v processor machine", runtime.NumCPU())
	1219  	}
	1220  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
	1221  	N := int32(1e3)
	1222  	if testing.Short() {
	1223  		N = int32(1e2)
	1224  	}
	1225  	c := make(chan bool, 2)
	1226  	X := [2]int32{}
	1227  	ack := [2][3]int32{{-1, -1, -1}, {-1, -1, -1}}
	1228  	for p := 0; p < 2; p++ {
	1229  		go func(me int) {
	1230  			he := 1 - me
	1231  			for i := int32(1); i < N; i++ {
	1232  				StoreInt32(&X[me], i)
	1233  				my := LoadInt32(&X[he])
	1234  				StoreInt32(&ack[me][i%3], my)
	1235  				for w := 1; LoadInt32(&ack[he][i%3]) == -1; w++ {
	1236  					if w%1000 == 0 {
	1237  						runtime.Gosched()
	1238  					}
	1239  				}
	1240  				his := LoadInt32(&ack[he][i%3])
	1241  				if (my != i && my != i-1) || (his != i && his != i-1) {
	1242  					t.Errorf("invalid values: %d/%d (%d)", my, his, i)
	1243  					break
	1244  				}
	1245  				if my != i && his != i {
	1246  					t.Errorf("store/load are not sequentially consistent: %d/%d (%d)", my, his, i)
	1247  					break
	1248  				}
	1249  				StoreInt32(&ack[me][(i-1)%3], -1)
	1250  			}
	1251  			c <- true
	1252  		}(p)
	1253  	}
	1254  	<-c
	1255  	<-c
	1256  }
	1257  
	1258  func TestStoreLoadSeqCst64(t *testing.T) {
	1259  	if runtime.NumCPU() == 1 {
	1260  		t.Skipf("Skipping test on %v processor machine", runtime.NumCPU())
	1261  	}
	1262  	if test64err != nil {
	1263  		t.Skipf("Skipping 64-bit tests: %v", test64err)
	1264  	}
	1265  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
	1266  	N := int64(1e3)
	1267  	if testing.Short() {
	1268  		N = int64(1e2)
	1269  	}
	1270  	c := make(chan bool, 2)
	1271  	X := [2]int64{}
	1272  	ack := [2][3]int64{{-1, -1, -1}, {-1, -1, -1}}
	1273  	for p := 0; p < 2; p++ {
	1274  		go func(me int) {
	1275  			he := 1 - me
	1276  			for i := int64(1); i < N; i++ {
	1277  				StoreInt64(&X[me], i)
	1278  				my := LoadInt64(&X[he])
	1279  				StoreInt64(&ack[me][i%3], my)
	1280  				for w := 1; LoadInt64(&ack[he][i%3]) == -1; w++ {
	1281  					if w%1000 == 0 {
	1282  						runtime.Gosched()
	1283  					}
	1284  				}
	1285  				his := LoadInt64(&ack[he][i%3])
	1286  				if (my != i && my != i-1) || (his != i && his != i-1) {
	1287  					t.Errorf("invalid values: %d/%d (%d)", my, his, i)
	1288  					break
	1289  				}
	1290  				if my != i && his != i {
	1291  					t.Errorf("store/load are not sequentially consistent: %d/%d (%d)", my, his, i)
	1292  					break
	1293  				}
	1294  				StoreInt64(&ack[me][(i-1)%3], -1)
	1295  			}
	1296  			c <- true
	1297  		}(p)
	1298  	}
	1299  	<-c
	1300  	<-c
	1301  }
	1302  
	1303  func TestStoreLoadRelAcq32(t *testing.T) {
	1304  	if runtime.NumCPU() == 1 {
	1305  		t.Skipf("Skipping test on %v processor machine", runtime.NumCPU())
	1306  	}
	1307  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
	1308  	N := int32(1e3)
	1309  	if testing.Short() {
	1310  		N = int32(1e2)
	1311  	}
	1312  	c := make(chan bool, 2)
	1313  	type Data struct {
	1314  		signal int32
	1315  		pad1	 [128]int8
	1316  		data1	int32
	1317  		pad2	 [128]int8
	1318  		data2	float32
	1319  	}
	1320  	var X Data
	1321  	for p := int32(0); p < 2; p++ {
	1322  		go func(p int32) {
	1323  			for i := int32(1); i < N; i++ {
	1324  				if (i+p)%2 == 0 {
	1325  					X.data1 = i
	1326  					X.data2 = float32(i)
	1327  					StoreInt32(&X.signal, i)
	1328  				} else {
	1329  					for w := 1; LoadInt32(&X.signal) != i; w++ {
	1330  						if w%1000 == 0 {
	1331  							runtime.Gosched()
	1332  						}
	1333  					}
	1334  					d1 := X.data1
	1335  					d2 := X.data2
	1336  					if d1 != i || d2 != float32(i) {
	1337  						t.Errorf("incorrect data: %d/%g (%d)", d1, d2, i)
	1338  						break
	1339  					}
	1340  				}
	1341  			}
	1342  			c <- true
	1343  		}(p)
	1344  	}
	1345  	<-c
	1346  	<-c
	1347  }
	1348  
	1349  func TestStoreLoadRelAcq64(t *testing.T) {
	1350  	if runtime.NumCPU() == 1 {
	1351  		t.Skipf("Skipping test on %v processor machine", runtime.NumCPU())
	1352  	}
	1353  	if test64err != nil {
	1354  		t.Skipf("Skipping 64-bit tests: %v", test64err)
	1355  	}
	1356  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
	1357  	N := int64(1e3)
	1358  	if testing.Short() {
	1359  		N = int64(1e2)
	1360  	}
	1361  	c := make(chan bool, 2)
	1362  	type Data struct {
	1363  		signal int64
	1364  		pad1	 [128]int8
	1365  		data1	int64
	1366  		pad2	 [128]int8
	1367  		data2	float64
	1368  	}
	1369  	var X Data
	1370  	for p := int64(0); p < 2; p++ {
	1371  		go func(p int64) {
	1372  			for i := int64(1); i < N; i++ {
	1373  				if (i+p)%2 == 0 {
	1374  					X.data1 = i
	1375  					X.data2 = float64(i)
	1376  					StoreInt64(&X.signal, i)
	1377  				} else {
	1378  					for w := 1; LoadInt64(&X.signal) != i; w++ {
	1379  						if w%1000 == 0 {
	1380  							runtime.Gosched()
	1381  						}
	1382  					}
	1383  					d1 := X.data1
	1384  					d2 := X.data2
	1385  					if d1 != i || d2 != float64(i) {
	1386  						t.Errorf("incorrect data: %d/%g (%d)", d1, d2, i)
	1387  						break
	1388  					}
	1389  				}
	1390  			}
	1391  			c <- true
	1392  		}(p)
	1393  	}
	1394  	<-c
	1395  	<-c
	1396  }
	1397  
	1398  func shouldPanic(t *testing.T, name string, f func()) {
	1399  	defer func() {
	1400  		// Check that all GC maps are sane.
	1401  		runtime.GC()
	1402  
	1403  		err := recover()
	1404  		want := "unaligned 64-bit atomic operation"
	1405  		if err == nil {
	1406  			t.Errorf("%s did not panic", name)
	1407  		} else if s, _ := err.(string); s != want {
	1408  			t.Errorf("%s: wanted panic %q, got %q", name, want, err)
	1409  		}
	1410  	}()
	1411  	f()
	1412  }
	1413  
	1414  func TestUnaligned64(t *testing.T) {
	1415  	// Unaligned 64-bit atomics on 32-bit systems are
	1416  	// a continual source of pain. Test that on 32-bit systems they crash
	1417  	// instead of failing silently.
	1418  	if !arch32 {
	1419  		t.Skip("test only runs on 32-bit systems")
	1420  	}
	1421  
	1422  	x := make([]uint32, 4)
	1423  	p := (*uint64)(unsafe.Pointer(&x[1])) // misaligned
	1424  
	1425  	shouldPanic(t, "LoadUint64", func() { LoadUint64(p) })
	1426  	shouldPanic(t, "StoreUint64", func() { StoreUint64(p, 1) })
	1427  	shouldPanic(t, "CompareAndSwapUint64", func() { CompareAndSwapUint64(p, 1, 2) })
	1428  	shouldPanic(t, "AddUint64", func() { AddUint64(p, 3) })
	1429  }
	1430  
	1431  func TestNilDeref(t *testing.T) {
	1432  	funcs := [...]func(){
	1433  		func() { CompareAndSwapInt32(nil, 0, 0) },
	1434  		func() { CompareAndSwapInt64(nil, 0, 0) },
	1435  		func() { CompareAndSwapUint32(nil, 0, 0) },
	1436  		func() { CompareAndSwapUint64(nil, 0, 0) },
	1437  		func() { CompareAndSwapUintptr(nil, 0, 0) },
	1438  		func() { CompareAndSwapPointer(nil, nil, nil) },
	1439  		func() { SwapInt32(nil, 0) },
	1440  		func() { SwapUint32(nil, 0) },
	1441  		func() { SwapInt64(nil, 0) },
	1442  		func() { SwapUint64(nil, 0) },
	1443  		func() { SwapUintptr(nil, 0) },
	1444  		func() { SwapPointer(nil, nil) },
	1445  		func() { AddInt32(nil, 0) },
	1446  		func() { AddUint32(nil, 0) },
	1447  		func() { AddInt64(nil, 0) },
	1448  		func() { AddUint64(nil, 0) },
	1449  		func() { AddUintptr(nil, 0) },
	1450  		func() { LoadInt32(nil) },
	1451  		func() { LoadInt64(nil) },
	1452  		func() { LoadUint32(nil) },
	1453  		func() { LoadUint64(nil) },
	1454  		func() { LoadUintptr(nil) },
	1455  		func() { LoadPointer(nil) },
	1456  		func() { StoreInt32(nil, 0) },
	1457  		func() { StoreInt64(nil, 0) },
	1458  		func() { StoreUint32(nil, 0) },
	1459  		func() { StoreUint64(nil, 0) },
	1460  		func() { StoreUintptr(nil, 0) },
	1461  		func() { StorePointer(nil, nil) },
	1462  	}
	1463  	for _, f := range funcs {
	1464  		func() {
	1465  			defer func() {
	1466  				runtime.GC()
	1467  				recover()
	1468  			}()
	1469  			f()
	1470  		}()
	1471  	}
	1472  }
	1473  

View as plain text