Example #1
0
func BenchmarkOutMessageGrowShrink(b *testing.B) {
	// A single buffer, which should fit in some level of CPU cache.
	b.Run("Single buffer", func(b *testing.B) {
		var om OutMessage
		for i := 0; i < b.N; i++ {
			om.Grow(MaxReadSize)
			om.ShrinkTo(OutMessageHeaderSize)
		}

		b.SetBytes(int64(MaxReadSize))
	})

	// Many megabytes worth of buffers, which should defeat the CPU cache.
	b.Run("Many buffers", func(b *testing.B) {
		// The number of messages; intentionally a power of two.
		const numMessages = 128

		var oms [numMessages]OutMessage
		if s := unsafe.Sizeof(oms); s < 128<<20 {
			panic(fmt.Sprintf("Array is too small; total size: %d", s))
		}

		for i := 0; i < b.N; i++ {
			oms[i%numMessages].Grow(MaxReadSize)
			oms[i%numMessages].ShrinkTo(OutMessageHeaderSize)
		}

		b.SetBytes(int64(MaxReadSize))
	})
}
Example #2
0
func BenchmarkScan(b *testing.B) {
	const x = 10
	for _, base := range []int{2, 8, 10, 16} {
		for _, y := range []Word{10, 100, 1000, 10000, 100000} {
			if isRaceBuilder && y > 1000 {
				continue
			}
			b.Run(fmt.Sprintf("%d/Base%d", y, base), func(b *testing.B) {
				b.StopTimer()
				var z nat
				z = z.expWW(x, y)

				s := z.utoa(base)
				if t := itoa(z, base); !bytes.Equal(s, t) {
					b.Fatalf("scanning: got %s; want %s", s, t)
				}
				b.StartTimer()

				for i := 0; i < b.N; i++ {
					z.scan(bytes.NewReader(s), base, false)
				}
			})
		}
	}
}
Example #3
0
func BenchmarkWrite(b *testing.B) {
	for _, p := range hashPairs {
		b.Run(p.label, func(b *testing.B) {
			MultiWrite(*benchn, *benchq, p.newFunc, b)
		})
	}
}
Example #4
0
func BenchmarkXCryptoSum(b *testing.B) {
	for _, size := range sizes {
		b.Run(size.name, func(b *testing.B) {
			benchmarkSum(b, ref.Sum, size.l)
		})
	}
}
Example #5
0
func BenchmarkResize(b *testing.B) {
	testCheckAvailable(b)
	hdr := &Handler{
		Executable: testExecutable,
	}
	params := imageserver.Params{
		param: imageserver.Params{
			"width": 100,
		},
	}
	for _, tc := range []struct {
		name string
		im   *imageserver.Image
	}{
		{"Small", testdata.Small},
		{"Medium", testdata.Medium},
		{"Large", testdata.Large},
		{"Huge", testdata.Huge},
	} {
		b.Run(tc.name, func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				_, err := hdr.Handle(tc.im, params)
				if err != nil {
					b.Fatal(err)
				}
			}
		})
	}
}
Example #6
0
func BenchmarkErrors(b *testing.B) {
	var toperr error
	type run struct {
		stack int
		std   bool
	}
	runs := []run{
		{10, false},
		{10, true},
		{100, false},
		{100, true},
		{1000, false},
		{1000, true},
	}
	for _, r := range runs {
		part := "pkg/errors"
		if r.std {
			part = "errors"
		}
		name := fmt.Sprintf("%s-stack-%d", part, r.stack)
		b.Run(name, func(b *testing.B) {
			var err error
			f := yesErrors
			if r.std {
				f = noErrors
			}
			b.ReportAllocs()
			for i := 0; i < b.N; i++ {
				err = f(0, r.stack)
			}
			b.StopTimer()
			toperr = err
		})
	}
}
Example #7
0
// BenchmarkVarint64ArrayMixed shows the performance of lots of small messages, each
// containing a small number of large (3, 4, and 5 byte) repeated int64s.
func BenchmarkVarint64ArrayMixed(b *testing.B) {
	for i := uint(1); i <= 1<<5; i <<= 1 {
		dist := genUint64Dist([11]int{0, 0, 0, 4, 6, 4, 0, 0, 0, 0, 0}, int(i))
		// number of sub fields
		for k := uint(1); k <= 1<<10; k <<= 2 {
			msg := &tpb.Message{}
			for m := uint(0); m < k; m++ {
				msg.Children = append(msg.Children, &tpb.Message{
					Key: dist,
				})
			}
			raw, err := proto.Marshal(msg)
			if err != nil {
				b.Error("wrong encode", err)
			}
			b.Run(fmt.Sprintf("Fields%vLen%v", k, i), func(b *testing.B) {
				scratchBuf := proto.NewBuffer(nil)
				b.ResetTimer()
				for k := 0; k < b.N; k++ {
					scratchBuf.SetBuf(raw)
					msgBlackhole.Reset()
					if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
						b.Error("wrong decode", err)
					}
				}
			})
		}
	}
}
Example #8
0
func BenchmarkClusterRestore(b *testing.B) {
	defer tracing.Disable()()

	// TODO(dan): count=10000 has some issues replicating. Investigate.
	for _, numAccounts := range []int{10, 100, 1000} {
		b.Run(strconv.Itoa(numAccounts), func(b *testing.B) {
			ctx, dir, tc, kvDB, _, cleanupFn := backupRestoreTestSetup(b, numAccounts)
			defer cleanupFn()

			// TODO(dan): Once mjibson's sql -> kv function is committed, use it
			// here on the output of bankDataInsert to generate the backup data
			// instead of this call.
			desc, err := sql.Backup(ctx, *kvDB, dir, tc.Server(0).Clock().Now())
			if err != nil {
				b.Fatal(err)
			}
			b.SetBytes(desc.DataSize)

			rebalanceLeases(b, tc)

			b.ResetTimer()
			table := parser.TableName{DatabaseName: "bench", TableName: "bank"}
			for i := 0; i < b.N; i++ {
				if _, err := sql.Restore(ctx, *kvDB, dir, table); err != nil {
					b.Fatal(err)
				}
			}
		})
	}
}
Example #9
0
func BenchmarkEncoder(b *testing.B) {
	buf, err := ioutil.ReadFile("../testdata/e.txt")
	if err != nil {
		b.Fatal(err)
	}
	if len(buf) == 0 {
		b.Fatalf("test file has no data")
	}

	for e := 4; e <= 6; e++ {
		n := int(math.Pow10(e))
		buf0 := buf
		buf1 := make([]byte, n)
		for i := 0; i < n; i += len(buf0) {
			if len(buf0) > n-i {
				buf0 = buf0[:n-i]
			}
			copy(buf1[i:], buf0)
		}
		buf0 = nil
		runtime.GC()
		b.Run(fmt.Sprint("1e", e), func(b *testing.B) {
			b.SetBytes(int64(n))
			for i := 0; i < b.N; i++ {
				w := NewWriter(ioutil.Discard, LSB, 8)
				w.Write(buf1)
				w.Close()
			}
		})
	}
}
Example #10
0
func BenchmarkByteBuffer(b *testing.B) {
	input := []byte("test writing this sentence to a buffer")

	b.Run("byteBuffer", func(b *testing.B) {
		buf := NewByteBuffer(1024)
		b.ResetTimer()

		for i := 0; i < b.N; i++ {
			buf.Write(input)
			buf.Bytes()
			buf.Reset()
		}
	})

	b.Run("bytes.Buffer", func(b *testing.B) {
		buf := bytes.NewBuffer(make([]byte, 0, 1024))
		b.ResetTimer()

		for i := 0; i < b.N; i++ {
			buf.Write(input)
			buf.Bytes()
			buf.Reset()
		}
	})
}
func BenchmarkSubnetLookup(b *testing.B) {

	var subnetLookup SubnetLookup

	b.Run("load routes file", func(b *testing.B) {

		routesData, err := ioutil.ReadFile("test_routes.dat")
		if err != nil {
			b.Skipf("can't load test routes file: %s", err)
		}

		for n := 0; n < b.N; n++ {
			subnetLookup, err = NewSubnetLookupFromRoutes(routesData)
			if err != nil {
				b.Fatalf("NewSubnetLookup failed: %s", err)
			}
		}
	})

	if subnetLookup == nil {
		b.Skipf("no test routes file")
	}

	b.Run("lookup random IP address", func(b *testing.B) {
		for n := 0; n < b.N; n++ {
			ip := make([]byte, 4)
			binary.BigEndian.PutUint32(ip, rand.Uint32())
			_ = subnetLookup.ContainsIPAddress(net.IP(ip))
		}
	})
}
Example #12
0
func BenchmarkDecoder(b *testing.B) {
	buf, err := ioutil.ReadFile("../testdata/e.txt")
	if err != nil {
		b.Fatal(err)
	}
	if len(buf) == 0 {
		b.Fatalf("test file has no data")
	}

	for e := 4; e <= 6; e++ {
		n := int(math.Pow10(e))
		b.Run(fmt.Sprint("1e", e), func(b *testing.B) {
			b.StopTimer()
			b.SetBytes(int64(n))
			buf0 := buf
			compressed := new(bytes.Buffer)
			w := NewWriter(compressed, LSB, 8)
			for i := 0; i < n; i += len(buf0) {
				if len(buf0) > n-i {
					buf0 = buf0[:n-i]
				}
				w.Write(buf0)
			}
			w.Close()
			buf1 := compressed.Bytes()
			buf0, compressed, w = nil, nil, nil
			runtime.GC()
			b.StartTimer()
			for i := 0; i < b.N; i++ {
				io.Copy(ioutil.Discard, NewReader(bytes.NewReader(buf1), LSB, 8))
			}
		})
	}
}
func BenchmarkServerGet(b *testing.B) {
	srv := &Server{
		Root: testdata.Dir,
	}
	for _, tc := range []struct {
		name     string
		filename string
	}{
		{"Small", testdata.SmallFileName},
		{"Medium", testdata.MediumFileName},
		{"Large", testdata.LargeFileName},
		{"Huge", testdata.HugeFileName},
	} {
		b.Run(tc.name, func(b *testing.B) {
			params := imageserver.Params{
				imageserver_source.Param: tc.filename,
			}
			var bs int
			b.ResetTimer()
			for i := 0; i < b.N; i++ {
				im, err := srv.Get(params)
				if err != nil {
					b.Fatal(err)
				}
				bs = len(im.Data)
			}
			b.SetBytes(int64(bs))
		})
	}
}
Example #14
0
func benchmarkSizes(b *testing.B, sizes []int, fn func(b *testing.B, n int)) {
	for _, n := range sizes {
		b.Run(fmt.Sprint(n), func(b *testing.B) {
			b.SetBytes(int64(n))
			fn(b, n)
		})
	}
}
Example #15
0
func runGCD(b *testing.B, aSize, bSize uint) {
	b.Run("WithoutXY", func(b *testing.B) {
		runGCDExt(b, aSize, bSize, false)
	})
	b.Run("WithXY", func(b *testing.B) {
		runGCDExt(b, aSize, bSize, true)
	})
}
Example #16
0
func BenchmarkNewTensor(b *testing.B) {
	var (
		// Some sample sizes from the Inception image labeling model.
		// Where input tensors correspond to a 224x224 RGB image
		// flattened into a vector.
		vector [224 * 224 * 3]int32
	)
	b.Run("[150528]", func(b *testing.B) { benchmarkNewTensor(b, vector) })
}
Example #17
0
func BenchmarkLeafSize(b *testing.B) {
	for n := 0; n <= 16; n++ {
		b.Run(fmt.Sprint(n), func(b *testing.B) { LeafSizeHelper(b, 10, n) })
	}
	// Try some large lengths
	for _, n := range []int{32, 64} {
		b.Run(fmt.Sprint(n), func(b *testing.B) { LeafSizeHelper(b, 10, n) })
	}
}
Example #18
0
func BenchmarkFormatFloat(b *testing.B) {
	for _, c := range ftoaBenches {
		b.Run(c.name, func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				FormatFloat(c.float, c.fmt, c.prec, c.bitSize)
			}
		})
	}
}
Example #19
0
func benchmarkGet(b *testing.B, name string, image *imageserver.Image, parallelism int) {
	b.Run(name, func(b *testing.B) {
		cch := newTestCache(b)
		defer func() {
			_ = cch.Pool.Close()
		}()
		cachetest.BenchmarkGet(b, cch, parallelism, image)
	})
}
Example #20
0
func doBench(b *testing.B, f func(b *testing.B, p *Profile, s string)) {
	for _, bp := range benchProfiles {
		for _, d := range benchData {
			b.Run(bp.name+"/"+d.name, func(b *testing.B) {
				f(b, bp.p, d.str)
			})
		}
	}
}
Example #21
0
func benchmarkReadWrite(b *testing.B, fracRead float64) {
	numReadGoRoutines := int(fracRead * float64(*benchq))
	for _, p := range hashPairs {
		b.Run(p.label, func(b *testing.B) {
			ReadWrite(*benchn, numReadGoRoutines, *benchq-numReadGoRoutines,
				p.newFunc, b)
		})
	}
}
Example #22
0
func BenchmarkLatency(b *testing.B) {
	for _, mode := range []string{"Max", "Dynamic"} {
		for _, kbps := range []int{200, 500, 1000, 2000, 5000} {
			name := fmt.Sprintf("%sPacket/%dkbps", mode, kbps)
			b.Run(name, func(b *testing.B) {
				latency(b, kbps*1000, mode == "Max")
			})
		}
	}
}
Example #23
0
func BenchmarkThroughput(b *testing.B) {
	for _, mode := range []string{"Max", "Dynamic"} {
		for size := 1; size <= 64; size <<= 1 {
			name := fmt.Sprintf("%sPacket/%dMB", mode, size)
			b.Run(name, func(b *testing.B) {
				throughput(b, int64(size<<20), mode == "Max")
			})
		}
	}
}
Example #24
0
func BenchmarkProbablyPrime(b *testing.B) {
	p, _ := new(Int).SetString("203956878356401977405765866929034577280193993314348263094772646453283062722701277632936616063144088173312372882677123879538709400158306567338328279154499698366071906766440037074217117805690872792848149112022286332144876183376326512083574821647933992961249917319836219304274280243803104015000563790123", 10)
	for _, rep := range []int{1, 5, 10, 20} {
		b.Run(fmt.Sprintf("Rep=%d", rep), func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				p.ProbablyPrime(rep)
			}
		})
	}
}
Example #25
0
func BenchmarkAppendFloat(b *testing.B) {
	dst := make([]byte, 30)
	for _, c := range ftoaBenches {
		b.Run(c.name, func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				AppendFloat(dst[:0], c.float, c.fmt, c.prec, c.bitSize)
			}
		})
	}
}
Example #26
0
func benchmarkHMAC(b *testing.B, fn func() hash.Hash) {
	for _, size := range sizes {
		b.Run(size.name, func(b *testing.B) {
			var key [KeySize]byte
			h := hmac.New(fn, key[:])

			benchmarkHash(b, h, size.l)
		})
	}
}
Example #27
0
func BenchmarkToAndFrom(b *testing.B) {
	benchmarks := []struct {
		k int
	}{
		{10},
		{100},
		{1000},
		{10000},
		{100000},
		{1000000},
		{10000000},
	}

	for _, bm := range benchmarks {
		for which := 0; which < 3; which++ {
			var name string
			if which == 0 {
				fmt.Println()
				name = "Flatb"
			} else if which == 1 {
				name = "Fixed"
			} else if which == 2 {
				name = "Proto"
			}

			b.Run(fmt.Sprintf("%s-%d", name, bm.k), func(b *testing.B) {
				uids := make([]uint64, bm.k)
				for i := 0; i < bm.k; i++ {
					uids[i] = uint64(rand.Int63())
				}

				var max, sz int
				b.ResetTimer()
				for i := 0; i < b.N; i++ {
					var err error
					if which == 0 {
						err, sz = ToAndFromFlat(uids)
					} else if which == 1 {
						err, sz = ToAndFromProtoAlt(uids)
					} else if which == 2 {
						err, sz = ToAndFromProto(uids)
					}
					if err != nil {
						b.Error(err)
						b.Fail()
					}
					if max < sz {
						max = sz
					}
					// runtime.GC() -- Actually makes FB looks worse.
				}
			})
		}
	}
}
Example #28
0
func benchBytes(b *testing.B, sizes []int, f func(b *testing.B, n int)) {
	for _, n := range sizes {
		b.Run(valName(n), func(b *testing.B) {
			if len(bmbuf) < n {
				bmbuf = make([]byte, n)
			}
			b.SetBytes(int64(n))
			f(b, n)
		})
	}
}
Example #29
0
func runGCD(b *testing.B, aSize, bSize uint) {
	if isRaceBuilder && (aSize > 1000 || bSize > 1000) {
		b.Skip("skipping on race builder")
	}
	b.Run("WithoutXY", func(b *testing.B) {
		runGCDExt(b, aSize, bSize, false)
	})
	b.Run("WithXY", func(b *testing.B) {
		runGCDExt(b, aSize, bSize, true)
	})
}
Example #30
0
func BenchmarkAppendSliceLarge(b *testing.B) {
	for _, length := range []int{1 << 10, 4 << 10, 16 << 10, 64 << 10, 256 << 10, 1024 << 10} {
		y := make([]byte, length)
		b.Run(fmt.Sprint(length, "Bytes"), func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				blackhole = nil
				blackhole = append(blackhole, y...)
			}
		})
	}
}