Method runBenchmark

cli/command_benchmark_encryption.go:63–108

(ctx context.Context)

}

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

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

	for _, ea := range encryption.SupportedAlgorithms(c.deprecatedAlgorithms) {
		enc, err := encryption.CreateEncryptor(&format.ContentFormat{
			Encryption: ea,
			Hash:       hashing.DefaultAlgorithm,
			MasterKey:  make([]byte, 32), //nolint:mnd
			HMACSecret: make([]byte, 32), //nolint:mnd
		})
		if err != nil {
			continue
		}

		log(ctx).Infof("Benchmarking encryption '%v'... (%v x %v bytes, parallelism %v)", 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()

				if encerr := enc.Encrypt(input, hashOutput[:32], &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: "-", encryption: ea, throughput: bytesPerSecond})
	}

	return results
}