From: Michael McLoughlin <mmcloughlin@gmail.com>
Date: Mon, 24 Sep 2018 03:29:33 +0000 (-0700)
Subject: crypto/cipher: 8K benchmarks for AES stream modes
X-Git-Tag: go1.12beta1~1006
X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=4a0dad211c2158e8763c6fd230fbdc1c7d566cb9;p=gostls13.git

crypto/cipher: 8K benchmarks for AES stream modes

Some parallelizable cipher modes may achieve peak performance for larger
block sizes. For this reason the AES-GCM mode already has an 8K
benchmark alongside the 1K version. This change introduces 8K benchmarks
for additional AES stream cipher modes.

Updates #20967

Change-Id: If97c6fbf31222602dcc200f8f418d95908ec1202
Reviewed-on: https://go-review.googlesource.com/136897
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
---

diff --git a/src/crypto/cipher/benchmark_test.go b/src/crypto/cipher/benchmark_test.go
index 1a3f1bdfac..90d0cd7138 100644
--- a/src/crypto/cipher/benchmark_test.go
+++ b/src/crypto/cipher/benchmark_test.go
@@ -81,70 +81,49 @@ func BenchmarkAESGCMOpen8K(b *testing.B) {
 	benchmarkAESGCMOpen(b, make([]byte, 8*1024))
 }
 
-// If we test exactly 1K blocks, we would generate exact multiples of
-// the cipher's block size, and the cipher stream fragments would
-// always be wordsize aligned, whereas non-aligned is a more typical
-// use-case.
-const almost1K = 1024 - 5
-
-func BenchmarkAESCFBEncrypt1K(b *testing.B) {
-	buf := make([]byte, almost1K)
+func benchmarkAESStream(b *testing.B, mode func(cipher.Block, []byte) cipher.Stream, buf []byte) {
 	b.SetBytes(int64(len(buf)))
 
 	var key [16]byte
 	var iv [16]byte
 	aes, _ := aes.NewCipher(key[:])
-	ctr := cipher.NewCFBEncrypter(aes, iv[:])
+	stream := mode(aes, iv[:])
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		ctr.XORKeyStream(buf, buf)
+		stream.XORKeyStream(buf, buf)
 	}
 }
 
-func BenchmarkAESCFBDecrypt1K(b *testing.B) {
-	buf := make([]byte, almost1K)
-	b.SetBytes(int64(len(buf)))
-
-	var key [16]byte
-	var iv [16]byte
-	aes, _ := aes.NewCipher(key[:])
-	ctr := cipher.NewCFBDecrypter(aes, iv[:])
+// If we test exactly 1K blocks, we would generate exact multiples of
+// the cipher's block size, and the cipher stream fragments would
+// always be wordsize aligned, whereas non-aligned is a more typical
+// use-case.
+const almost1K = 1024 - 5
+const almost8K = 8*1024 - 5
 
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		ctr.XORKeyStream(buf, buf)
-	}
+func BenchmarkAESCFBEncrypt1K(b *testing.B) {
+	benchmarkAESStream(b, cipher.NewCFBEncrypter, make([]byte, almost1K))
 }
 
-func BenchmarkAESOFB1K(b *testing.B) {
-	buf := make([]byte, almost1K)
-	b.SetBytes(int64(len(buf)))
+func BenchmarkAESCFBDecrypt1K(b *testing.B) {
+	benchmarkAESStream(b, cipher.NewCFBDecrypter, make([]byte, almost1K))
+}
 
-	var key [16]byte
-	var iv [16]byte
-	aes, _ := aes.NewCipher(key[:])
-	ctr := cipher.NewOFB(aes, iv[:])
+func BenchmarkAESCFBDecrypt8K(b *testing.B) {
+	benchmarkAESStream(b, cipher.NewCFBDecrypter, make([]byte, almost8K))
+}
 
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		ctr.XORKeyStream(buf, buf)
-	}
+func BenchmarkAESOFB1K(b *testing.B) {
+	benchmarkAESStream(b, cipher.NewOFB, make([]byte, almost1K))
 }
 
 func BenchmarkAESCTR1K(b *testing.B) {
-	buf := make([]byte, almost1K)
-	b.SetBytes(int64(len(buf)))
-
-	var key [16]byte
-	var iv [16]byte
-	aes, _ := aes.NewCipher(key[:])
-	ctr := cipher.NewCTR(aes, iv[:])
+	benchmarkAESStream(b, cipher.NewCTR, make([]byte, almost1K))
+}
 
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		ctr.XORKeyStream(buf, buf)
-	}
+func BenchmarkAESCTR8K(b *testing.B) {
+	benchmarkAESStream(b, cipher.NewCTR, make([]byte, almost8K))
 }
 
 func BenchmarkAESCBCEncrypt1K(b *testing.B) {