Source file src/runtime/slice_test.go

Documentation: runtime

		 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 runtime_test
		 6  
		 7  import (
		 8  	"fmt"
		 9  	"testing"
		10  )
		11  
		12  const N = 20
		13  
		14  func BenchmarkMakeSliceCopy(b *testing.B) {
		15  	const length = 32
		16  	var bytes = make([]byte, 8*length)
		17  	var ints = make([]int, length)
		18  	var ptrs = make([]*byte, length)
		19  	b.Run("mallocmove", func(b *testing.B) {
		20  		b.Run("Byte", func(b *testing.B) {
		21  			var x []byte
		22  			for i := 0; i < b.N; i++ {
		23  				x = make([]byte, len(bytes))
		24  				copy(x, bytes)
		25  			}
		26  		})
		27  		b.Run("Int", func(b *testing.B) {
		28  			var x []int
		29  			for i := 0; i < b.N; i++ {
		30  				x = make([]int, len(ints))
		31  				copy(x, ints)
		32  			}
		33  		})
		34  		b.Run("Ptr", func(b *testing.B) {
		35  			var x []*byte
		36  			for i := 0; i < b.N; i++ {
		37  				x = make([]*byte, len(ptrs))
		38  				copy(x, ptrs)
		39  			}
		40  
		41  		})
		42  	})
		43  	b.Run("makecopy", func(b *testing.B) {
		44  		b.Run("Byte", func(b *testing.B) {
		45  			var x []byte
		46  			for i := 0; i < b.N; i++ {
		47  				x = make([]byte, 8*length)
		48  				copy(x, bytes)
		49  			}
		50  		})
		51  		b.Run("Int", func(b *testing.B) {
		52  			var x []int
		53  			for i := 0; i < b.N; i++ {
		54  				x = make([]int, length)
		55  				copy(x, ints)
		56  			}
		57  		})
		58  		b.Run("Ptr", func(b *testing.B) {
		59  			var x []*byte
		60  			for i := 0; i < b.N; i++ {
		61  				x = make([]*byte, length)
		62  				copy(x, ptrs)
		63  			}
		64  
		65  		})
		66  	})
		67  	b.Run("nilappend", func(b *testing.B) {
		68  		b.Run("Byte", func(b *testing.B) {
		69  			var x []byte
		70  			for i := 0; i < b.N; i++ {
		71  				x = append([]byte(nil), bytes...)
		72  				_ = x
		73  			}
		74  		})
		75  		b.Run("Int", func(b *testing.B) {
		76  			var x []int
		77  			for i := 0; i < b.N; i++ {
		78  				x = append([]int(nil), ints...)
		79  				_ = x
		80  			}
		81  		})
		82  		b.Run("Ptr", func(b *testing.B) {
		83  			var x []*byte
		84  			for i := 0; i < b.N; i++ {
		85  				x = append([]*byte(nil), ptrs...)
		86  				_ = x
		87  			}
		88  		})
		89  	})
		90  }
		91  
		92  type (
		93  	struct24 struct{ a, b, c int64 }
		94  	struct32 struct{ a, b, c, d int64 }
		95  	struct40 struct{ a, b, c, d, e int64 }
		96  )
		97  
		98  func BenchmarkMakeSlice(b *testing.B) {
		99  	const length = 2
	 100  	b.Run("Byte", func(b *testing.B) {
	 101  		var x []byte
	 102  		for i := 0; i < b.N; i++ {
	 103  			x = make([]byte, length, 2*length)
	 104  			_ = x
	 105  		}
	 106  	})
	 107  	b.Run("Int16", func(b *testing.B) {
	 108  		var x []int16
	 109  		for i := 0; i < b.N; i++ {
	 110  			x = make([]int16, length, 2*length)
	 111  			_ = x
	 112  		}
	 113  	})
	 114  	b.Run("Int", func(b *testing.B) {
	 115  		var x []int
	 116  		for i := 0; i < b.N; i++ {
	 117  			x = make([]int, length, 2*length)
	 118  			_ = x
	 119  		}
	 120  	})
	 121  	b.Run("Ptr", func(b *testing.B) {
	 122  		var x []*byte
	 123  		for i := 0; i < b.N; i++ {
	 124  			x = make([]*byte, length, 2*length)
	 125  			_ = x
	 126  		}
	 127  	})
	 128  	b.Run("Struct", func(b *testing.B) {
	 129  		b.Run("24", func(b *testing.B) {
	 130  			var x []struct24
	 131  			for i := 0; i < b.N; i++ {
	 132  				x = make([]struct24, length, 2*length)
	 133  				_ = x
	 134  			}
	 135  		})
	 136  		b.Run("32", func(b *testing.B) {
	 137  			var x []struct32
	 138  			for i := 0; i < b.N; i++ {
	 139  				x = make([]struct32, length, 2*length)
	 140  				_ = x
	 141  			}
	 142  		})
	 143  		b.Run("40", func(b *testing.B) {
	 144  			var x []struct40
	 145  			for i := 0; i < b.N; i++ {
	 146  				x = make([]struct40, length, 2*length)
	 147  				_ = x
	 148  			}
	 149  		})
	 150  
	 151  	})
	 152  }
	 153  
	 154  func BenchmarkGrowSlice(b *testing.B) {
	 155  	b.Run("Byte", func(b *testing.B) {
	 156  		x := make([]byte, 9)
	 157  		for i := 0; i < b.N; i++ {
	 158  			_ = append([]byte(nil), x...)
	 159  		}
	 160  	})
	 161  	b.Run("Int16", func(b *testing.B) {
	 162  		x := make([]int16, 9)
	 163  		for i := 0; i < b.N; i++ {
	 164  			_ = append([]int16(nil), x...)
	 165  		}
	 166  	})
	 167  	b.Run("Int", func(b *testing.B) {
	 168  		x := make([]int, 9)
	 169  		for i := 0; i < b.N; i++ {
	 170  			_ = append([]int(nil), x...)
	 171  		}
	 172  	})
	 173  	b.Run("Ptr", func(b *testing.B) {
	 174  		x := make([]*byte, 9)
	 175  		for i := 0; i < b.N; i++ {
	 176  			_ = append([]*byte(nil), x...)
	 177  		}
	 178  	})
	 179  	b.Run("Struct", func(b *testing.B) {
	 180  		b.Run("24", func(b *testing.B) {
	 181  			x := make([]struct24, 9)
	 182  			for i := 0; i < b.N; i++ {
	 183  				_ = append([]struct24(nil), x...)
	 184  			}
	 185  		})
	 186  		b.Run("32", func(b *testing.B) {
	 187  			x := make([]struct32, 9)
	 188  			for i := 0; i < b.N; i++ {
	 189  				_ = append([]struct32(nil), x...)
	 190  			}
	 191  		})
	 192  		b.Run("40", func(b *testing.B) {
	 193  			x := make([]struct40, 9)
	 194  			for i := 0; i < b.N; i++ {
	 195  				_ = append([]struct40(nil), x...)
	 196  			}
	 197  		})
	 198  
	 199  	})
	 200  }
	 201  
	 202  var (
	 203  	SinkIntSlice				[]int
	 204  	SinkIntPointerSlice []*int
	 205  )
	 206  
	 207  func BenchmarkExtendSlice(b *testing.B) {
	 208  	var length = 4 // Use a variable to prevent stack allocation of slices.
	 209  	b.Run("IntSlice", func(b *testing.B) {
	 210  		s := make([]int, 0, length)
	 211  		for i := 0; i < b.N; i++ {
	 212  			s = append(s[:0:length/2], make([]int, length)...)
	 213  		}
	 214  		SinkIntSlice = s
	 215  	})
	 216  	b.Run("PointerSlice", func(b *testing.B) {
	 217  		s := make([]*int, 0, length)
	 218  		for i := 0; i < b.N; i++ {
	 219  			s = append(s[:0:length/2], make([]*int, length)...)
	 220  		}
	 221  		SinkIntPointerSlice = s
	 222  	})
	 223  	b.Run("NoGrow", func(b *testing.B) {
	 224  		s := make([]int, 0, length)
	 225  		for i := 0; i < b.N; i++ {
	 226  			s = append(s[:0:length], make([]int, length)...)
	 227  		}
	 228  		SinkIntSlice = s
	 229  	})
	 230  }
	 231  
	 232  func BenchmarkAppend(b *testing.B) {
	 233  	b.StopTimer()
	 234  	x := make([]int, 0, N)
	 235  	b.StartTimer()
	 236  	for i := 0; i < b.N; i++ {
	 237  		x = x[0:0]
	 238  		for j := 0; j < N; j++ {
	 239  			x = append(x, j)
	 240  		}
	 241  	}
	 242  }
	 243  
	 244  func BenchmarkAppendGrowByte(b *testing.B) {
	 245  	for i := 0; i < b.N; i++ {
	 246  		var x []byte
	 247  		for j := 0; j < 1<<20; j++ {
	 248  			x = append(x, byte(j))
	 249  		}
	 250  	}
	 251  }
	 252  
	 253  func BenchmarkAppendGrowString(b *testing.B) {
	 254  	var s string
	 255  	for i := 0; i < b.N; i++ {
	 256  		var x []string
	 257  		for j := 0; j < 1<<20; j++ {
	 258  			x = append(x, s)
	 259  		}
	 260  	}
	 261  }
	 262  
	 263  func BenchmarkAppendSlice(b *testing.B) {
	 264  	for _, length := range []int{1, 4, 7, 8, 15, 16, 32} {
	 265  		b.Run(fmt.Sprint(length, "Bytes"), func(b *testing.B) {
	 266  			x := make([]byte, 0, N)
	 267  			y := make([]byte, length)
	 268  			for i := 0; i < b.N; i++ {
	 269  				x = x[0:0]
	 270  				x = append(x, y...)
	 271  			}
	 272  		})
	 273  	}
	 274  }
	 275  
	 276  var (
	 277  	blackhole []byte
	 278  )
	 279  
	 280  func BenchmarkAppendSliceLarge(b *testing.B) {
	 281  	for _, length := range []int{1 << 10, 4 << 10, 16 << 10, 64 << 10, 256 << 10, 1024 << 10} {
	 282  		y := make([]byte, length)
	 283  		b.Run(fmt.Sprint(length, "Bytes"), func(b *testing.B) {
	 284  			for i := 0; i < b.N; i++ {
	 285  				blackhole = nil
	 286  				blackhole = append(blackhole, y...)
	 287  			}
	 288  		})
	 289  	}
	 290  }
	 291  
	 292  func BenchmarkAppendStr(b *testing.B) {
	 293  	for _, str := range []string{
	 294  		"1",
	 295  		"1234",
	 296  		"12345678",
	 297  		"1234567890123456",
	 298  		"12345678901234567890123456789012",
	 299  	} {
	 300  		b.Run(fmt.Sprint(len(str), "Bytes"), func(b *testing.B) {
	 301  			x := make([]byte, 0, N)
	 302  			for i := 0; i < b.N; i++ {
	 303  				x = x[0:0]
	 304  				x = append(x, str...)
	 305  			}
	 306  		})
	 307  	}
	 308  }
	 309  
	 310  func BenchmarkAppendSpecialCase(b *testing.B) {
	 311  	b.StopTimer()
	 312  	x := make([]int, 0, N)
	 313  	b.StartTimer()
	 314  	for i := 0; i < b.N; i++ {
	 315  		x = x[0:0]
	 316  		for j := 0; j < N; j++ {
	 317  			if len(x) < cap(x) {
	 318  				x = x[:len(x)+1]
	 319  				x[len(x)-1] = j
	 320  			} else {
	 321  				x = append(x, j)
	 322  			}
	 323  		}
	 324  	}
	 325  }
	 326  
	 327  var x []int
	 328  
	 329  func f() int {
	 330  	x[:1][0] = 3
	 331  	return 2
	 332  }
	 333  
	 334  func TestSideEffectOrder(t *testing.T) {
	 335  	x = make([]int, 0, 10)
	 336  	x = append(x, 1, f())
	 337  	if x[0] != 1 || x[1] != 2 {
	 338  		t.Error("append failed: ", x[0], x[1])
	 339  	}
	 340  }
	 341  
	 342  func TestAppendOverlap(t *testing.T) {
	 343  	x := []byte("1234")
	 344  	x = append(x[1:], x...) // p > q in runtime·appendslice.
	 345  	got := string(x)
	 346  	want := "2341234"
	 347  	if got != want {
	 348  		t.Errorf("overlap failed: got %q want %q", got, want)
	 349  	}
	 350  }
	 351  
	 352  func BenchmarkCopy(b *testing.B) {
	 353  	for _, l := range []int{1, 2, 4, 8, 12, 16, 32, 128, 1024} {
	 354  		buf := make([]byte, 4096)
	 355  		b.Run(fmt.Sprint(l, "Byte"), func(b *testing.B) {
	 356  			s := make([]byte, l)
	 357  			var n int
	 358  			for i := 0; i < b.N; i++ {
	 359  				n = copy(buf, s)
	 360  			}
	 361  			b.SetBytes(int64(n))
	 362  		})
	 363  		b.Run(fmt.Sprint(l, "String"), func(b *testing.B) {
	 364  			s := string(make([]byte, l))
	 365  			var n int
	 366  			for i := 0; i < b.N; i++ {
	 367  				n = copy(buf, s)
	 368  			}
	 369  			b.SetBytes(int64(n))
	 370  		})
	 371  	}
	 372  }
	 373  
	 374  var (
	 375  	sByte []byte
	 376  	s1Ptr []uintptr
	 377  	s2Ptr [][2]uintptr
	 378  	s3Ptr [][3]uintptr
	 379  	s4Ptr [][4]uintptr
	 380  )
	 381  
	 382  // BenchmarkAppendInPlace tests the performance of append
	 383  // when the result is being written back to the same slice.
	 384  // In order for the in-place optimization to occur,
	 385  // the slice must be referred to by address;
	 386  // using a global is an easy way to trigger that.
	 387  // We test the "grow" and "no grow" paths separately,
	 388  // but not the "normal" (occasionally grow) path,
	 389  // because it is a blend of the other two.
	 390  // We use small numbers and small sizes in an attempt
	 391  // to avoid benchmarking memory allocation and copying.
	 392  // We use scalars instead of pointers in an attempt
	 393  // to avoid benchmarking the write barriers.
	 394  // We benchmark four common sizes (byte, pointer, string/interface, slice),
	 395  // and one larger size.
	 396  func BenchmarkAppendInPlace(b *testing.B) {
	 397  	b.Run("NoGrow", func(b *testing.B) {
	 398  		const C = 128
	 399  
	 400  		b.Run("Byte", func(b *testing.B) {
	 401  			for i := 0; i < b.N; i++ {
	 402  				sByte = make([]byte, C)
	 403  				for j := 0; j < C; j++ {
	 404  					sByte = append(sByte, 0x77)
	 405  				}
	 406  			}
	 407  		})
	 408  
	 409  		b.Run("1Ptr", func(b *testing.B) {
	 410  			for i := 0; i < b.N; i++ {
	 411  				s1Ptr = make([]uintptr, C)
	 412  				for j := 0; j < C; j++ {
	 413  					s1Ptr = append(s1Ptr, 0x77)
	 414  				}
	 415  			}
	 416  		})
	 417  
	 418  		b.Run("2Ptr", func(b *testing.B) {
	 419  			for i := 0; i < b.N; i++ {
	 420  				s2Ptr = make([][2]uintptr, C)
	 421  				for j := 0; j < C; j++ {
	 422  					s2Ptr = append(s2Ptr, [2]uintptr{0x77, 0x88})
	 423  				}
	 424  			}
	 425  		})
	 426  
	 427  		b.Run("3Ptr", func(b *testing.B) {
	 428  			for i := 0; i < b.N; i++ {
	 429  				s3Ptr = make([][3]uintptr, C)
	 430  				for j := 0; j < C; j++ {
	 431  					s3Ptr = append(s3Ptr, [3]uintptr{0x77, 0x88, 0x99})
	 432  				}
	 433  			}
	 434  		})
	 435  
	 436  		b.Run("4Ptr", func(b *testing.B) {
	 437  			for i := 0; i < b.N; i++ {
	 438  				s4Ptr = make([][4]uintptr, C)
	 439  				for j := 0; j < C; j++ {
	 440  					s4Ptr = append(s4Ptr, [4]uintptr{0x77, 0x88, 0x99, 0xAA})
	 441  				}
	 442  			}
	 443  		})
	 444  
	 445  	})
	 446  
	 447  	b.Run("Grow", func(b *testing.B) {
	 448  		const C = 5
	 449  
	 450  		b.Run("Byte", func(b *testing.B) {
	 451  			for i := 0; i < b.N; i++ {
	 452  				sByte = make([]byte, 0)
	 453  				for j := 0; j < C; j++ {
	 454  					sByte = append(sByte, 0x77)
	 455  					sByte = sByte[:cap(sByte)]
	 456  				}
	 457  			}
	 458  		})
	 459  
	 460  		b.Run("1Ptr", func(b *testing.B) {
	 461  			for i := 0; i < b.N; i++ {
	 462  				s1Ptr = make([]uintptr, 0)
	 463  				for j := 0; j < C; j++ {
	 464  					s1Ptr = append(s1Ptr, 0x77)
	 465  					s1Ptr = s1Ptr[:cap(s1Ptr)]
	 466  				}
	 467  			}
	 468  		})
	 469  
	 470  		b.Run("2Ptr", func(b *testing.B) {
	 471  			for i := 0; i < b.N; i++ {
	 472  				s2Ptr = make([][2]uintptr, 0)
	 473  				for j := 0; j < C; j++ {
	 474  					s2Ptr = append(s2Ptr, [2]uintptr{0x77, 0x88})
	 475  					s2Ptr = s2Ptr[:cap(s2Ptr)]
	 476  				}
	 477  			}
	 478  		})
	 479  
	 480  		b.Run("3Ptr", func(b *testing.B) {
	 481  			for i := 0; i < b.N; i++ {
	 482  				s3Ptr = make([][3]uintptr, 0)
	 483  				for j := 0; j < C; j++ {
	 484  					s3Ptr = append(s3Ptr, [3]uintptr{0x77, 0x88, 0x99})
	 485  					s3Ptr = s3Ptr[:cap(s3Ptr)]
	 486  				}
	 487  			}
	 488  		})
	 489  
	 490  		b.Run("4Ptr", func(b *testing.B) {
	 491  			for i := 0; i < b.N; i++ {
	 492  				s4Ptr = make([][4]uintptr, 0)
	 493  				for j := 0; j < C; j++ {
	 494  					s4Ptr = append(s4Ptr, [4]uintptr{0x77, 0x88, 0x99, 0xAA})
	 495  					s4Ptr = s4Ptr[:cap(s4Ptr)]
	 496  				}
	 497  			}
	 498  		})
	 499  
	 500  	})
	 501  }
	 502  

View as plain text