Method run

cli/command_benchmark_splitters.go:43–159

(ctx context.Context)

}

func (c *commandBenchmarkSplitters) run(ctx context.Context) error { //nolint:funlen
	type benchResult struct {
		splitter       string
		duration       time.Duration
		segmentCount   int
		min            int
		p10            int
		p25            int
		p50            int
		p75            int
		p90            int
		max            int
		bytesPerSecond int64
	}

	var results []benchResult

	var best benchResult

	best.duration = math.MaxInt64

	// generate data blocks
	var dataBlocks [][]byte

	rnd := rand.New(rand.NewSource(c.randSeed)) //nolint:gosec

	for range c.blockCount {
		b := make([]byte, c.blockSize)
		if _, err := rnd.Read(b); err != nil {
			return errors.Wrap(err, "error generating random data")
		}

		dataBlocks = append(dataBlocks, b)
	}

	log(ctx).Infof("splitting %v blocks of %v each, parallelism %v", c.blockCount, c.blockSize, c.parallel)

	for _, sp := range splitter.SupportedAlgorithms() {
		tt := timetrack.Start()

		segmentLengths := runInParallelNoInput(c.parallel, func() []int {
			fact := splitter.GetFactory(sp)

			var segmentLengths []int

			for _, d := range dataBlocks {
				s := fact()

				for len(d) > 0 {
					n := s.NextSplitPoint(d)
					if n < 0 {
						segmentLengths = append(segmentLengths, len(d))
						break
					}

					segmentLengths = append(segmentLengths, n)
					d = d[n:]
				}