1package mapset 2 3import ( 4 "math/rand" 5 "testing" 6) 7 8func nrand(n int) []int { 9 i := make([]int, n) 10 for ind := range i { 11 i[ind] = rand.Int() 12 } 13 return i 14} 15 16func toInterfaces(i []int) []interface{} { 17 ifs := make([]interface{}, len(i)) 18 for ind, v := range i { 19 ifs[ind] = v 20 } 21 return ifs 22} 23 24func benchAdd(b *testing.B, s Set) { 25 nums := nrand(b.N) 26 b.ResetTimer() 27 for _, v := range nums { 28 s.Add(v) 29 } 30} 31 32func BenchmarkAddSafe(b *testing.B) { 33 benchAdd(b, NewSet()) 34} 35 36func BenchmarkAddUnsafe(b *testing.B) { 37 benchAdd(b, NewThreadUnsafeSet()) 38} 39 40func benchRemove(b *testing.B, s Set) { 41 nums := nrand(b.N) 42 for _, v := range nums { 43 s.Add(v) 44 } 45 46 b.ResetTimer() 47 for _, v := range nums { 48 s.Remove(v) 49 } 50} 51 52func BenchmarkRemoveSafe(b *testing.B) { 53 benchRemove(b, NewSet()) 54} 55 56func BenchmarkRemoveUnsafe(b *testing.B) { 57 benchRemove(b, NewThreadUnsafeSet()) 58} 59 60func benchCardinality(b *testing.B, s Set) { 61 for i := 0; i < b.N; i++ { 62 s.Cardinality() 63 } 64} 65 66func BenchmarkCardinalitySafe(b *testing.B) { 67 benchCardinality(b, NewSet()) 68} 69 70func BenchmarkCardinalityUnsafe(b *testing.B) { 71 benchCardinality(b, NewThreadUnsafeSet()) 72} 73 74func benchClear(b *testing.B, s Set) { 75 b.ResetTimer() 76 for i := 0; i < b.N; i++ { 77 s.Clear() 78 } 79} 80 81func BenchmarkClearSafe(b *testing.B) { 82 benchClear(b, NewSet()) 83} 84 85func BenchmarkClearUnsafe(b *testing.B) { 86 benchClear(b, NewThreadUnsafeSet()) 87} 88 89func benchClone(b *testing.B, n int, s Set) { 90 nums := toInterfaces(nrand(n)) 91 for _, v := range nums { 92 s.Add(v) 93 } 94 95 b.ResetTimer() 96 for i := 0; i < b.N; i++ { 97 s.Clone() 98 } 99} 100 101func BenchmarkClone1Safe(b *testing.B) { 102 benchClone(b, 1, NewSet()) 103} 104 105func BenchmarkClone1Unsafe(b *testing.B) { 106 benchClone(b, 1, NewThreadUnsafeSet()) 107} 108 109func BenchmarkClone10Safe(b *testing.B) { 110 benchClone(b, 10, NewSet()) 111} 112 113func BenchmarkClone10Unsafe(b *testing.B) { 114 benchClone(b, 10, NewThreadUnsafeSet()) 115} 116 117func BenchmarkClone100Safe(b *testing.B) { 118 benchClone(b, 100, NewSet()) 119} 120 121func BenchmarkClone100Unsafe(b *testing.B) { 122 benchClone(b, 100, NewThreadUnsafeSet()) 123} 124 125func benchContains(b *testing.B, n int, s Set) { 126 nums := toInterfaces(nrand(n)) 127 for _, v := range nums { 128 s.Add(v) 129 } 130 131 nums[n-1] = -1 // Definitely not in s 132 133 b.ResetTimer() 134 for i := 0; i < b.N; i++ { 135 s.Contains(nums...) 136 } 137} 138 139func BenchmarkContains1Safe(b *testing.B) { 140 benchContains(b, 1, NewSet()) 141} 142 143func BenchmarkContains1Unsafe(b *testing.B) { 144 benchContains(b, 1, NewThreadUnsafeSet()) 145} 146 147func BenchmarkContains10Safe(b *testing.B) { 148 benchContains(b, 10, NewSet()) 149} 150 151func BenchmarkContains10Unsafe(b *testing.B) { 152 benchContains(b, 10, NewThreadUnsafeSet()) 153} 154 155func BenchmarkContains100Safe(b *testing.B) { 156 benchContains(b, 100, NewSet()) 157} 158 159func BenchmarkContains100Unsafe(b *testing.B) { 160 benchContains(b, 100, NewThreadUnsafeSet()) 161} 162 163func benchEqual(b *testing.B, n int, s, t Set) { 164 nums := nrand(n) 165 for _, v := range nums { 166 s.Add(v) 167 t.Add(v) 168 } 169 170 b.ResetTimer() 171 for i := 0; i < b.N; i++ { 172 s.Equal(t) 173 } 174} 175 176func BenchmarkEqual1Safe(b *testing.B) { 177 benchEqual(b, 1, NewSet(), NewSet()) 178} 179 180func BenchmarkEqual1Unsafe(b *testing.B) { 181 benchEqual(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 182} 183 184func BenchmarkEqual10Safe(b *testing.B) { 185 benchEqual(b, 10, NewSet(), NewSet()) 186} 187 188func BenchmarkEqual10Unsafe(b *testing.B) { 189 benchEqual(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 190} 191 192func BenchmarkEqual100Safe(b *testing.B) { 193 benchEqual(b, 100, NewSet(), NewSet()) 194} 195 196func BenchmarkEqual100Unsafe(b *testing.B) { 197 benchEqual(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 198} 199 200func benchDifference(b *testing.B, n int, s, t Set) { 201 nums := nrand(n) 202 for _, v := range nums { 203 s.Add(v) 204 } 205 for _, v := range nums[:n/2] { 206 t.Add(v) 207 } 208 209 b.ResetTimer() 210 for i := 0; i < b.N; i++ { 211 s.Difference(t) 212 } 213} 214 215func benchIsSubset(b *testing.B, n int, s, t Set) { 216 nums := nrand(n) 217 for _, v := range nums { 218 s.Add(v) 219 t.Add(v) 220 } 221 222 b.ResetTimer() 223 for i := 0; i < b.N; i++ { 224 s.IsSubset(t) 225 } 226} 227 228func BenchmarkIsSubset1Safe(b *testing.B) { 229 benchIsSubset(b, 1, NewSet(), NewSet()) 230} 231 232func BenchmarkIsSubset1Unsafe(b *testing.B) { 233 benchIsSubset(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 234} 235 236func BenchmarkIsSubset10Safe(b *testing.B) { 237 benchIsSubset(b, 10, NewSet(), NewSet()) 238} 239 240func BenchmarkIsSubset10Unsafe(b *testing.B) { 241 benchIsSubset(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 242} 243 244func BenchmarkIsSubset100Safe(b *testing.B) { 245 benchIsSubset(b, 100, NewSet(), NewSet()) 246} 247 248func BenchmarkIsSubset100Unsafe(b *testing.B) { 249 benchIsSubset(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 250} 251 252func benchIsSuperset(b *testing.B, n int, s, t Set) { 253 nums := nrand(n) 254 for _, v := range nums { 255 s.Add(v) 256 t.Add(v) 257 } 258 259 b.ResetTimer() 260 for i := 0; i < b.N; i++ { 261 s.IsSuperset(t) 262 } 263} 264 265func BenchmarkIsSuperset1Safe(b *testing.B) { 266 benchIsSuperset(b, 1, NewSet(), NewSet()) 267} 268 269func BenchmarkIsSuperset1Unsafe(b *testing.B) { 270 benchIsSuperset(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 271} 272 273func BenchmarkIsSuperset10Safe(b *testing.B) { 274 benchIsSuperset(b, 10, NewSet(), NewSet()) 275} 276 277func BenchmarkIsSuperset10Unsafe(b *testing.B) { 278 benchIsSuperset(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 279} 280 281func BenchmarkIsSuperset100Safe(b *testing.B) { 282 benchIsSuperset(b, 100, NewSet(), NewSet()) 283} 284 285func BenchmarkIsSuperset100Unsafe(b *testing.B) { 286 benchIsSuperset(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 287} 288 289func benchIsProperSubset(b *testing.B, n int, s, t Set) { 290 nums := nrand(n) 291 for _, v := range nums { 292 s.Add(v) 293 t.Add(v) 294 } 295 296 b.ResetTimer() 297 for i := 0; i < b.N; i++ { 298 s.IsProperSubset(t) 299 } 300} 301 302func BenchmarkIsProperSubset1Safe(b *testing.B) { 303 benchIsProperSubset(b, 1, NewSet(), NewSet()) 304} 305 306func BenchmarkIsProperSubset1Unsafe(b *testing.B) { 307 benchIsProperSubset(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 308} 309 310func BenchmarkIsProperSubset10Safe(b *testing.B) { 311 benchIsProperSubset(b, 10, NewSet(), NewSet()) 312} 313 314func BenchmarkIsProperSubset10Unsafe(b *testing.B) { 315 benchIsProperSubset(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 316} 317 318func BenchmarkIsProperSubset100Safe(b *testing.B) { 319 benchIsProperSubset(b, 100, NewSet(), NewSet()) 320} 321 322func BenchmarkIsProperSubset100Unsafe(b *testing.B) { 323 benchIsProperSubset(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 324} 325 326func benchIsProperSuperset(b *testing.B, n int, s, t Set) { 327 nums := nrand(n) 328 for _, v := range nums { 329 s.Add(v) 330 t.Add(v) 331 } 332 333 b.ResetTimer() 334 for i := 0; i < b.N; i++ { 335 s.IsProperSuperset(t) 336 } 337} 338 339func BenchmarkIsProperSuperset1Safe(b *testing.B) { 340 benchIsProperSuperset(b, 1, NewSet(), NewSet()) 341} 342 343func BenchmarkIsProperSuperset1Unsafe(b *testing.B) { 344 benchIsProperSuperset(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 345} 346 347func BenchmarkIsProperSuperset10Safe(b *testing.B) { 348 benchIsProperSuperset(b, 10, NewSet(), NewSet()) 349} 350 351func BenchmarkIsProperSuperset10Unsafe(b *testing.B) { 352 benchIsProperSuperset(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 353} 354 355func BenchmarkIsProperSuperset100Safe(b *testing.B) { 356 benchIsProperSuperset(b, 100, NewSet(), NewSet()) 357} 358 359func BenchmarkIsProperSuperset100Unsafe(b *testing.B) { 360 benchIsProperSuperset(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 361} 362 363func BenchmarkDifference1Safe(b *testing.B) { 364 benchDifference(b, 1, NewSet(), NewSet()) 365} 366 367func BenchmarkDifference1Unsafe(b *testing.B) { 368 benchDifference(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 369} 370 371func BenchmarkDifference10Safe(b *testing.B) { 372 benchDifference(b, 10, NewSet(), NewSet()) 373} 374 375func BenchmarkDifference10Unsafe(b *testing.B) { 376 benchDifference(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 377} 378 379func BenchmarkDifference100Safe(b *testing.B) { 380 benchDifference(b, 100, NewSet(), NewSet()) 381} 382 383func BenchmarkDifference100Unsafe(b *testing.B) { 384 benchDifference(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 385} 386 387func benchIntersect(b *testing.B, n int, s, t Set) { 388 nums := nrand(int(float64(n) * float64(1.5))) 389 for _, v := range nums[:n] { 390 s.Add(v) 391 } 392 for _, v := range nums[n/2:] { 393 t.Add(v) 394 } 395 396 b.ResetTimer() 397 for i := 0; i < b.N; i++ { 398 s.Intersect(t) 399 } 400} 401 402func BenchmarkIntersect1Safe(b *testing.B) { 403 benchIntersect(b, 1, NewSet(), NewSet()) 404} 405 406func BenchmarkIntersect1Unsafe(b *testing.B) { 407 benchIntersect(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 408} 409 410func BenchmarkIntersect10Safe(b *testing.B) { 411 benchIntersect(b, 10, NewSet(), NewSet()) 412} 413 414func BenchmarkIntersect10Unsafe(b *testing.B) { 415 benchIntersect(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 416} 417 418func BenchmarkIntersect100Safe(b *testing.B) { 419 benchIntersect(b, 100, NewSet(), NewSet()) 420} 421 422func BenchmarkIntersect100Unsafe(b *testing.B) { 423 benchIntersect(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 424} 425 426func benchSymmetricDifference(b *testing.B, n int, s, t Set) { 427 nums := nrand(int(float64(n) * float64(1.5))) 428 for _, v := range nums[:n] { 429 s.Add(v) 430 } 431 for _, v := range nums[n/2:] { 432 t.Add(v) 433 } 434 435 b.ResetTimer() 436 for i := 0; i < b.N; i++ { 437 s.SymmetricDifference(t) 438 } 439} 440 441func BenchmarkSymmetricDifference1Safe(b *testing.B) { 442 benchSymmetricDifference(b, 1, NewSet(), NewSet()) 443} 444 445func BenchmarkSymmetricDifference1Unsafe(b *testing.B) { 446 benchSymmetricDifference(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 447} 448 449func BenchmarkSymmetricDifference10Safe(b *testing.B) { 450 benchSymmetricDifference(b, 10, NewSet(), NewSet()) 451} 452 453func BenchmarkSymmetricDifference10Unsafe(b *testing.B) { 454 benchSymmetricDifference(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 455} 456 457func BenchmarkSymmetricDifference100Safe(b *testing.B) { 458 benchSymmetricDifference(b, 100, NewSet(), NewSet()) 459} 460 461func BenchmarkSymmetricDifference100Unsafe(b *testing.B) { 462 benchSymmetricDifference(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 463} 464 465func benchUnion(b *testing.B, n int, s, t Set) { 466 nums := nrand(n) 467 for _, v := range nums[:n/2] { 468 s.Add(v) 469 } 470 for _, v := range nums[n/2:] { 471 t.Add(v) 472 } 473 474 b.ResetTimer() 475 for i := 0; i < b.N; i++ { 476 s.Union(t) 477 } 478} 479 480func BenchmarkUnion1Safe(b *testing.B) { 481 benchUnion(b, 1, NewSet(), NewSet()) 482} 483 484func BenchmarkUnion1Unsafe(b *testing.B) { 485 benchUnion(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 486} 487 488func BenchmarkUnion10Safe(b *testing.B) { 489 benchUnion(b, 10, NewSet(), NewSet()) 490} 491 492func BenchmarkUnion10Unsafe(b *testing.B) { 493 benchUnion(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 494} 495 496func BenchmarkUnion100Safe(b *testing.B) { 497 benchUnion(b, 100, NewSet(), NewSet()) 498} 499 500func BenchmarkUnion100Unsafe(b *testing.B) { 501 benchUnion(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet()) 502} 503 504func benchEach(b *testing.B, n int, s Set) { 505 nums := nrand(n) 506 for _, v := range nums { 507 s.Add(v) 508 } 509 510 b.ResetTimer() 511 for i := 0; i < b.N; i++ { 512 s.Each(func(elem interface{}) bool { 513 return false 514 }) 515 } 516} 517 518func BenchmarkEach1Safe(b *testing.B) { 519 benchEach(b, 1, NewSet()) 520} 521 522func BenchmarkEach1Unsafe(b *testing.B) { 523 benchEach(b, 1, NewThreadUnsafeSet()) 524} 525 526func BenchmarkEach10Safe(b *testing.B) { 527 benchEach(b, 10, NewSet()) 528} 529 530func BenchmarkEach10Unsafe(b *testing.B) { 531 benchEach(b, 10, NewThreadUnsafeSet()) 532} 533 534func BenchmarkEach100Safe(b *testing.B) { 535 benchEach(b, 100, NewSet()) 536} 537 538func BenchmarkEach100Unsafe(b *testing.B) { 539 benchEach(b, 100, NewThreadUnsafeSet()) 540} 541 542func benchIter(b *testing.B, n int, s Set) { 543 nums := nrand(n) 544 for _, v := range nums { 545 s.Add(v) 546 } 547 548 b.ResetTimer() 549 for i := 0; i < b.N; i++ { 550 c := s.Iter() 551 for range c { 552 553 } 554 } 555} 556 557func BenchmarkIter1Safe(b *testing.B) { 558 benchIter(b, 1, NewSet()) 559} 560 561func BenchmarkIter1Unsafe(b *testing.B) { 562 benchIter(b, 1, NewThreadUnsafeSet()) 563} 564 565func BenchmarkIter10Safe(b *testing.B) { 566 benchIter(b, 10, NewSet()) 567} 568 569func BenchmarkIter10Unsafe(b *testing.B) { 570 benchIter(b, 10, NewThreadUnsafeSet()) 571} 572 573func BenchmarkIter100Safe(b *testing.B) { 574 benchIter(b, 100, NewSet()) 575} 576 577func BenchmarkIter100Unsafe(b *testing.B) { 578 benchIter(b, 100, NewThreadUnsafeSet()) 579} 580 581func benchIterator(b *testing.B, n int, s Set) { 582 nums := nrand(n) 583 for _, v := range nums { 584 s.Add(v) 585 } 586 587 b.ResetTimer() 588 for i := 0; i < b.N; i++ { 589 c := s.Iterator().C 590 for range c { 591 592 } 593 } 594} 595 596func BenchmarkIterator1Safe(b *testing.B) { 597 benchIterator(b, 1, NewSet()) 598} 599 600func BenchmarkIterator1Unsafe(b *testing.B) { 601 benchIterator(b, 1, NewThreadUnsafeSet()) 602} 603 604func BenchmarkIterator10Safe(b *testing.B) { 605 benchIterator(b, 10, NewSet()) 606} 607 608func BenchmarkIterator10Unsafe(b *testing.B) { 609 benchIterator(b, 10, NewThreadUnsafeSet()) 610} 611 612func BenchmarkIterator100Safe(b *testing.B) { 613 benchIterator(b, 100, NewSet()) 614} 615 616func BenchmarkIterator100Unsafe(b *testing.B) { 617 benchIterator(b, 100, NewThreadUnsafeSet()) 618} 619 620func benchString(b *testing.B, n int, s Set) { 621 nums := nrand(n) 622 for _, v := range nums { 623 s.Add(v) 624 } 625 626 b.ResetTimer() 627 for i := 0; i < b.N; i++ { 628 _ = s.String() 629 } 630} 631 632func BenchmarkString1Safe(b *testing.B) { 633 benchString(b, 1, NewSet()) 634} 635 636func BenchmarkString1Unsafe(b *testing.B) { 637 benchString(b, 1, NewThreadUnsafeSet()) 638} 639 640func BenchmarkString10Safe(b *testing.B) { 641 benchString(b, 10, NewSet()) 642} 643 644func BenchmarkString10Unsafe(b *testing.B) { 645 benchString(b, 10, NewThreadUnsafeSet()) 646} 647 648func BenchmarkString100Safe(b *testing.B) { 649 benchString(b, 100, NewSet()) 650} 651 652func BenchmarkString100Unsafe(b *testing.B) { 653 benchString(b, 100, NewThreadUnsafeSet()) 654} 655 656func benchToSlice(b *testing.B, s Set) { 657 nums := nrand(b.N) 658 for _, v := range nums { 659 s.Add(v) 660 } 661 662 b.ResetTimer() 663 for i := 0; i < b.N; i++ { 664 s.ToSlice() 665 } 666} 667 668func BenchmarkToSliceSafe(b *testing.B) { 669 benchToSlice(b, NewSet()) 670} 671 672func BenchmarkToSliceUnsafe(b *testing.B) { 673 benchToSlice(b, NewThreadUnsafeSet()) 674} 675