github.com/miolini/go@v0.0.0-20160405192216-fca68c8cb408/src/runtime/memmove_test.go (about) 1 // Copyright 2013 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 . "runtime" 9 "testing" 10 ) 11 12 func TestMemmove(t *testing.T) { 13 size := 256 14 if testing.Short() { 15 size = 128 + 16 16 } 17 src := make([]byte, size) 18 dst := make([]byte, size) 19 for i := 0; i < size; i++ { 20 src[i] = byte(128 + (i & 127)) 21 } 22 for i := 0; i < size; i++ { 23 dst[i] = byte(i & 127) 24 } 25 for n := 0; n <= size; n++ { 26 for x := 0; x <= size-n; x++ { // offset in src 27 for y := 0; y <= size-n; y++ { // offset in dst 28 copy(dst[y:y+n], src[x:x+n]) 29 for i := 0; i < y; i++ { 30 if dst[i] != byte(i&127) { 31 t.Fatalf("prefix dst[%d] = %d", i, dst[i]) 32 } 33 } 34 for i := y; i < y+n; i++ { 35 if dst[i] != byte(128+((i-y+x)&127)) { 36 t.Fatalf("copied dst[%d] = %d", i, dst[i]) 37 } 38 dst[i] = byte(i & 127) // reset dst 39 } 40 for i := y + n; i < size; i++ { 41 if dst[i] != byte(i&127) { 42 t.Fatalf("suffix dst[%d] = %d", i, dst[i]) 43 } 44 } 45 } 46 } 47 } 48 } 49 50 func TestMemmoveAlias(t *testing.T) { 51 size := 256 52 if testing.Short() { 53 size = 128 + 16 54 } 55 buf := make([]byte, size) 56 for i := 0; i < size; i++ { 57 buf[i] = byte(i) 58 } 59 for n := 0; n <= size; n++ { 60 for x := 0; x <= size-n; x++ { // src offset 61 for y := 0; y <= size-n; y++ { // dst offset 62 copy(buf[y:y+n], buf[x:x+n]) 63 for i := 0; i < y; i++ { 64 if buf[i] != byte(i) { 65 t.Fatalf("prefix buf[%d] = %d", i, buf[i]) 66 } 67 } 68 for i := y; i < y+n; i++ { 69 if buf[i] != byte(i-y+x) { 70 t.Fatalf("copied buf[%d] = %d", i, buf[i]) 71 } 72 buf[i] = byte(i) // reset buf 73 } 74 for i := y + n; i < size; i++ { 75 if buf[i] != byte(i) { 76 t.Fatalf("suffix buf[%d] = %d", i, buf[i]) 77 } 78 } 79 } 80 } 81 } 82 } 83 84 func bmMemmove(b *testing.B, n int) { 85 x := make([]byte, n) 86 y := make([]byte, n) 87 b.SetBytes(int64(n)) 88 for i := 0; i < b.N; i++ { 89 copy(x, y) 90 } 91 } 92 93 func BenchmarkMemmove0(b *testing.B) { bmMemmove(b, 0) } 94 func BenchmarkMemmove1(b *testing.B) { bmMemmove(b, 1) } 95 func BenchmarkMemmove2(b *testing.B) { bmMemmove(b, 2) } 96 func BenchmarkMemmove3(b *testing.B) { bmMemmove(b, 3) } 97 func BenchmarkMemmove4(b *testing.B) { bmMemmove(b, 4) } 98 func BenchmarkMemmove5(b *testing.B) { bmMemmove(b, 5) } 99 func BenchmarkMemmove6(b *testing.B) { bmMemmove(b, 6) } 100 func BenchmarkMemmove7(b *testing.B) { bmMemmove(b, 7) } 101 func BenchmarkMemmove8(b *testing.B) { bmMemmove(b, 8) } 102 func BenchmarkMemmove9(b *testing.B) { bmMemmove(b, 9) } 103 func BenchmarkMemmove10(b *testing.B) { bmMemmove(b, 10) } 104 func BenchmarkMemmove11(b *testing.B) { bmMemmove(b, 11) } 105 func BenchmarkMemmove12(b *testing.B) { bmMemmove(b, 12) } 106 func BenchmarkMemmove13(b *testing.B) { bmMemmove(b, 13) } 107 func BenchmarkMemmove14(b *testing.B) { bmMemmove(b, 14) } 108 func BenchmarkMemmove15(b *testing.B) { bmMemmove(b, 15) } 109 func BenchmarkMemmove16(b *testing.B) { bmMemmove(b, 16) } 110 func BenchmarkMemmove32(b *testing.B) { bmMemmove(b, 32) } 111 func BenchmarkMemmove64(b *testing.B) { bmMemmove(b, 64) } 112 func BenchmarkMemmove128(b *testing.B) { bmMemmove(b, 128) } 113 func BenchmarkMemmove256(b *testing.B) { bmMemmove(b, 256) } 114 func BenchmarkMemmove512(b *testing.B) { bmMemmove(b, 512) } 115 func BenchmarkMemmove1024(b *testing.B) { bmMemmove(b, 1024) } 116 func BenchmarkMemmove2048(b *testing.B) { bmMemmove(b, 2048) } 117 func BenchmarkMemmove4096(b *testing.B) { bmMemmove(b, 4096) } 118 119 func bmMemmoveUnalignedDst(b *testing.B, n int) { 120 x := make([]byte, n+1) 121 y := make([]byte, n) 122 b.SetBytes(int64(n)) 123 for i := 0; i < b.N; i++ { 124 copy(x[1:], y) 125 } 126 } 127 128 func BenchmarkMemmoveUnalignedDst0(b *testing.B) { bmMemmoveUnalignedDst(b, 0) } 129 func BenchmarkMemmoveUnalignedDst1(b *testing.B) { bmMemmoveUnalignedDst(b, 1) } 130 func BenchmarkMemmoveUnalignedDst2(b *testing.B) { bmMemmoveUnalignedDst(b, 2) } 131 func BenchmarkMemmoveUnalignedDst3(b *testing.B) { bmMemmoveUnalignedDst(b, 3) } 132 func BenchmarkMemmoveUnalignedDst4(b *testing.B) { bmMemmoveUnalignedDst(b, 4) } 133 func BenchmarkMemmoveUnalignedDst5(b *testing.B) { bmMemmoveUnalignedDst(b, 5) } 134 func BenchmarkMemmoveUnalignedDst6(b *testing.B) { bmMemmoveUnalignedDst(b, 6) } 135 func BenchmarkMemmoveUnalignedDst7(b *testing.B) { bmMemmoveUnalignedDst(b, 7) } 136 func BenchmarkMemmoveUnalignedDst8(b *testing.B) { bmMemmoveUnalignedDst(b, 8) } 137 func BenchmarkMemmoveUnalignedDst9(b *testing.B) { bmMemmoveUnalignedDst(b, 9) } 138 func BenchmarkMemmoveUnalignedDst10(b *testing.B) { bmMemmoveUnalignedDst(b, 10) } 139 func BenchmarkMemmoveUnalignedDst11(b *testing.B) { bmMemmoveUnalignedDst(b, 11) } 140 func BenchmarkMemmoveUnalignedDst12(b *testing.B) { bmMemmoveUnalignedDst(b, 12) } 141 func BenchmarkMemmoveUnalignedDst13(b *testing.B) { bmMemmoveUnalignedDst(b, 13) } 142 func BenchmarkMemmoveUnalignedDst14(b *testing.B) { bmMemmoveUnalignedDst(b, 14) } 143 func BenchmarkMemmoveUnalignedDst15(b *testing.B) { bmMemmoveUnalignedDst(b, 15) } 144 func BenchmarkMemmoveUnalignedDst16(b *testing.B) { bmMemmoveUnalignedDst(b, 16) } 145 func BenchmarkMemmoveUnalignedDst32(b *testing.B) { bmMemmoveUnalignedDst(b, 32) } 146 func BenchmarkMemmoveUnalignedDst64(b *testing.B) { bmMemmoveUnalignedDst(b, 64) } 147 func BenchmarkMemmoveUnalignedDst128(b *testing.B) { bmMemmoveUnalignedDst(b, 128) } 148 func BenchmarkMemmoveUnalignedDst256(b *testing.B) { bmMemmoveUnalignedDst(b, 256) } 149 func BenchmarkMemmoveUnalignedDst512(b *testing.B) { bmMemmoveUnalignedDst(b, 512) } 150 func BenchmarkMemmoveUnalignedDst1024(b *testing.B) { bmMemmoveUnalignedDst(b, 1024) } 151 func BenchmarkMemmoveUnalignedDst2048(b *testing.B) { bmMemmoveUnalignedDst(b, 2048) } 152 func BenchmarkMemmoveUnalignedDst4096(b *testing.B) { bmMemmoveUnalignedDst(b, 4096) } 153 154 func bmMemmoveUnalignedSrc(b *testing.B, n int) { 155 x := make([]byte, n) 156 y := make([]byte, n+1) 157 b.SetBytes(int64(n)) 158 for i := 0; i < b.N; i++ { 159 copy(x, y[1:]) 160 } 161 } 162 163 func BenchmarkMemmoveUnalignedSrc0(b *testing.B) { bmMemmoveUnalignedSrc(b, 0) } 164 func BenchmarkMemmoveUnalignedSrc1(b *testing.B) { bmMemmoveUnalignedSrc(b, 1) } 165 func BenchmarkMemmoveUnalignedSrc2(b *testing.B) { bmMemmoveUnalignedSrc(b, 2) } 166 func BenchmarkMemmoveUnalignedSrc3(b *testing.B) { bmMemmoveUnalignedSrc(b, 3) } 167 func BenchmarkMemmoveUnalignedSrc4(b *testing.B) { bmMemmoveUnalignedSrc(b, 4) } 168 func BenchmarkMemmoveUnalignedSrc5(b *testing.B) { bmMemmoveUnalignedSrc(b, 5) } 169 func BenchmarkMemmoveUnalignedSrc6(b *testing.B) { bmMemmoveUnalignedSrc(b, 6) } 170 func BenchmarkMemmoveUnalignedSrc7(b *testing.B) { bmMemmoveUnalignedSrc(b, 7) } 171 func BenchmarkMemmoveUnalignedSrc8(b *testing.B) { bmMemmoveUnalignedSrc(b, 8) } 172 func BenchmarkMemmoveUnalignedSrc9(b *testing.B) { bmMemmoveUnalignedSrc(b, 9) } 173 func BenchmarkMemmoveUnalignedSrc10(b *testing.B) { bmMemmoveUnalignedSrc(b, 10) } 174 func BenchmarkMemmoveUnalignedSrc11(b *testing.B) { bmMemmoveUnalignedSrc(b, 11) } 175 func BenchmarkMemmoveUnalignedSrc12(b *testing.B) { bmMemmoveUnalignedSrc(b, 12) } 176 func BenchmarkMemmoveUnalignedSrc13(b *testing.B) { bmMemmoveUnalignedSrc(b, 13) } 177 func BenchmarkMemmoveUnalignedSrc14(b *testing.B) { bmMemmoveUnalignedSrc(b, 14) } 178 func BenchmarkMemmoveUnalignedSrc15(b *testing.B) { bmMemmoveUnalignedSrc(b, 15) } 179 func BenchmarkMemmoveUnalignedSrc16(b *testing.B) { bmMemmoveUnalignedSrc(b, 16) } 180 func BenchmarkMemmoveUnalignedSrc32(b *testing.B) { bmMemmoveUnalignedSrc(b, 32) } 181 func BenchmarkMemmoveUnalignedSrc64(b *testing.B) { bmMemmoveUnalignedSrc(b, 64) } 182 func BenchmarkMemmoveUnalignedSrc128(b *testing.B) { bmMemmoveUnalignedSrc(b, 128) } 183 func BenchmarkMemmoveUnalignedSrc256(b *testing.B) { bmMemmoveUnalignedSrc(b, 256) } 184 func BenchmarkMemmoveUnalignedSrc512(b *testing.B) { bmMemmoveUnalignedSrc(b, 512) } 185 func BenchmarkMemmoveUnalignedSrc1024(b *testing.B) { bmMemmoveUnalignedSrc(b, 1024) } 186 func BenchmarkMemmoveUnalignedSrc2048(b *testing.B) { bmMemmoveUnalignedSrc(b, 2048) } 187 func BenchmarkMemmoveUnalignedSrc4096(b *testing.B) { bmMemmoveUnalignedSrc(b, 4096) } 188 189 func TestMemclr(t *testing.T) { 190 size := 512 191 if testing.Short() { 192 size = 128 + 16 193 } 194 mem := make([]byte, size) 195 for i := 0; i < size; i++ { 196 mem[i] = 0xee 197 } 198 for n := 0; n < size; n++ { 199 for x := 0; x <= size-n; x++ { // offset in mem 200 MemclrBytes(mem[x : x+n]) 201 for i := 0; i < x; i++ { 202 if mem[i] != 0xee { 203 t.Fatalf("overwrite prefix mem[%d] = %d", i, mem[i]) 204 } 205 } 206 for i := x; i < x+n; i++ { 207 if mem[i] != 0 { 208 t.Fatalf("failed clear mem[%d] = %d", i, mem[i]) 209 } 210 mem[i] = 0xee 211 } 212 for i := x + n; i < size; i++ { 213 if mem[i] != 0xee { 214 t.Fatalf("overwrite suffix mem[%d] = %d", i, mem[i]) 215 } 216 } 217 } 218 } 219 } 220 221 func bmMemclr(b *testing.B, n int) { 222 x := make([]byte, n) 223 b.SetBytes(int64(n)) 224 for i := 0; i < b.N; i++ { 225 MemclrBytes(x) 226 } 227 } 228 func BenchmarkMemclr5(b *testing.B) { bmMemclr(b, 5) } 229 func BenchmarkMemclr16(b *testing.B) { bmMemclr(b, 16) } 230 func BenchmarkMemclr64(b *testing.B) { bmMemclr(b, 64) } 231 func BenchmarkMemclr256(b *testing.B) { bmMemclr(b, 256) } 232 func BenchmarkMemclr4096(b *testing.B) { bmMemclr(b, 4096) } 233 func BenchmarkMemclr65536(b *testing.B) { bmMemclr(b, 65536) } 234 func BenchmarkMemclr1M(b *testing.B) { bmMemclr(b, 1<<20) } 235 func BenchmarkMemclr4M(b *testing.B) { bmMemclr(b, 4<<20) } 236 func BenchmarkMemclr8M(b *testing.B) { bmMemclr(b, 8<<20) } 237 func BenchmarkMemclr16M(b *testing.B) { bmMemclr(b, 16<<20) } 238 func BenchmarkMemclr64M(b *testing.B) { bmMemclr(b, 64<<20) } 239 240 func bmGoMemclr(b *testing.B, n int) { 241 x := make([]byte, n) 242 b.SetBytes(int64(n)) 243 for i := 0; i < b.N; i++ { 244 for j := range x { 245 x[j] = 0 246 } 247 } 248 } 249 func BenchmarkGoMemclr5(b *testing.B) { bmGoMemclr(b, 5) } 250 func BenchmarkGoMemclr16(b *testing.B) { bmGoMemclr(b, 16) } 251 func BenchmarkGoMemclr64(b *testing.B) { bmGoMemclr(b, 64) } 252 func BenchmarkGoMemclr256(b *testing.B) { bmGoMemclr(b, 256) } 253 254 func BenchmarkClearFat8(b *testing.B) { 255 for i := 0; i < b.N; i++ { 256 var x [8 / 4]uint32 257 _ = x 258 } 259 } 260 func BenchmarkClearFat12(b *testing.B) { 261 for i := 0; i < b.N; i++ { 262 var x [12 / 4]uint32 263 _ = x 264 } 265 } 266 func BenchmarkClearFat16(b *testing.B) { 267 for i := 0; i < b.N; i++ { 268 var x [16 / 4]uint32 269 _ = x 270 } 271 } 272 func BenchmarkClearFat24(b *testing.B) { 273 for i := 0; i < b.N; i++ { 274 var x [24 / 4]uint32 275 _ = x 276 } 277 } 278 func BenchmarkClearFat32(b *testing.B) { 279 for i := 0; i < b.N; i++ { 280 var x [32 / 4]uint32 281 _ = x 282 } 283 } 284 func BenchmarkClearFat40(b *testing.B) { 285 for i := 0; i < b.N; i++ { 286 var x [40 / 4]uint32 287 _ = x 288 } 289 } 290 func BenchmarkClearFat48(b *testing.B) { 291 for i := 0; i < b.N; i++ { 292 var x [48 / 4]uint32 293 _ = x 294 } 295 } 296 func BenchmarkClearFat56(b *testing.B) { 297 for i := 0; i < b.N; i++ { 298 var x [56 / 4]uint32 299 _ = x 300 } 301 } 302 func BenchmarkClearFat64(b *testing.B) { 303 for i := 0; i < b.N; i++ { 304 var x [64 / 4]uint32 305 _ = x 306 } 307 } 308 func BenchmarkClearFat128(b *testing.B) { 309 for i := 0; i < b.N; i++ { 310 var x [128 / 4]uint32 311 _ = x 312 } 313 } 314 func BenchmarkClearFat256(b *testing.B) { 315 for i := 0; i < b.N; i++ { 316 var x [256 / 4]uint32 317 _ = x 318 } 319 } 320 func BenchmarkClearFat512(b *testing.B) { 321 for i := 0; i < b.N; i++ { 322 var x [512 / 4]uint32 323 _ = x 324 } 325 } 326 func BenchmarkClearFat1024(b *testing.B) { 327 for i := 0; i < b.N; i++ { 328 var x [1024 / 4]uint32 329 _ = x 330 } 331 } 332 333 func BenchmarkCopyFat8(b *testing.B) { 334 var x [8 / 4]uint32 335 for i := 0; i < b.N; i++ { 336 y := x 337 _ = y 338 } 339 } 340 func BenchmarkCopyFat12(b *testing.B) { 341 var x [12 / 4]uint32 342 for i := 0; i < b.N; i++ { 343 y := x 344 _ = y 345 } 346 } 347 func BenchmarkCopyFat16(b *testing.B) { 348 var x [16 / 4]uint32 349 for i := 0; i < b.N; i++ { 350 y := x 351 _ = y 352 } 353 } 354 func BenchmarkCopyFat24(b *testing.B) { 355 var x [24 / 4]uint32 356 for i := 0; i < b.N; i++ { 357 y := x 358 _ = y 359 } 360 } 361 func BenchmarkCopyFat32(b *testing.B) { 362 var x [32 / 4]uint32 363 for i := 0; i < b.N; i++ { 364 y := x 365 _ = y 366 } 367 } 368 func BenchmarkCopyFat64(b *testing.B) { 369 var x [64 / 4]uint32 370 for i := 0; i < b.N; i++ { 371 y := x 372 _ = y 373 } 374 } 375 func BenchmarkCopyFat128(b *testing.B) { 376 var x [128 / 4]uint32 377 for i := 0; i < b.N; i++ { 378 y := x 379 _ = y 380 } 381 } 382 func BenchmarkCopyFat256(b *testing.B) { 383 var x [256 / 4]uint32 384 for i := 0; i < b.N; i++ { 385 y := x 386 _ = y 387 } 388 } 389 func BenchmarkCopyFat512(b *testing.B) { 390 var x [512 / 4]uint32 391 for i := 0; i < b.N; i++ { 392 y := x 393 _ = y 394 } 395 } 396 func BenchmarkCopyFat1024(b *testing.B) { 397 var x [1024 / 4]uint32 398 for i := 0; i < b.N; i++ { 399 y := x 400 _ = y 401 } 402 }