Method runBenchmark

cli/command_benchmark_crypto.go:63–119

(ctx context.Context)

}

func (c *commandBenchmarkCrypto) runBenchmark(ctx context.Context) []cryptoBenchResult {
	var results []cryptoBenchResult

	data := make([]byte, c.blockSize)

	for _, ha := range hashing.SupportedAlgorithms() {
		for _, ea := range encryption.SupportedAlgorithms(c.deprecatedAlgorithms) {
			fo := &format.ContentFormat{
				Encryption: ea,
				Hash:       ha,
				MasterKey:  make([]byte, 32), //nolint:mnd
				HMACSecret: make([]byte, 32), //nolint:mnd
			}

			hf, err := hashing.CreateHashFunc(fo)
			if err != nil {
				continue
			}

			enc, err := encryption.CreateEncryptor(fo)
			if err != nil {
				continue
			}

			log(ctx).Infof("Benchmarking hash '%v' and encryption '%v'... (%v x %v bytes, parallelism %v)", ha, ea, c.repeat, len(data), c.parallel)

			input := gather.FromSlice(data)
			tt := timetrack.Start()

			hashCount := c.repeat

			runInParallelNoInputNoResult(c.parallel, func() {
				var hashOutput [hashing.MaxHashSize]byte

				var encryptOutput gather.WriteBuffer
				defer encryptOutput.Close()

				for range hashCount {
					encryptOutput.Reset()

					contentID := hf(hashOutput[:0], input)

					if encerr := enc.Encrypt(input, contentID, &encryptOutput); encerr != nil {
						log(ctx).Errorf("encryption failed: %v", encerr)
						break
					}
				}
			})

			_, bytesPerSecond := tt.Completed(float64(c.parallel) * float64(len(data)) * float64(hashCount))

			results = append(results, cryptoBenchResult{hash: ha, encryption: ea, throughput: bytesPerSecond})
		}
	}

	return results
}