Page MenuHomePhabricator
Differential D9226 Diff 27698 src/bench/chacha_poly_aead.cpp

Changeset View

Standalone View

View Options

src/bench/chacha_poly_aead.cpp

Show All 16 Lines
static constexpr uint64_t BUFFER_SIZE_SMALL = 256; static constexpr uint64_t BUFFER_SIZE_SMALL = 256;
static constexpr uint64_t BUFFER_SIZE_LARGE = 1024 * 1024; static constexpr uint64_t BUFFER_SIZE_LARGE = 1024 * 1024;
static const uint8_t k1[32] = {0}; static const uint8_t k1[32] = {0};
static const uint8_t k2[32] = {0}; static const uint8_t k2[32] = {0};
static ChaCha20Poly1305AEAD aead(k1, 32, k2, 32); static ChaCha20Poly1305AEAD aead(k1, 32, k2, 32);
static void CHACHA20_POLY1305_AEAD(benchmark::State &state, size_t buffersize, static void CHACHA20_POLY1305_AEAD(benchmark::Bench &bench, size_t buffersize,
bool include_decryption) { bool include_decryption) {
std::vector<uint8_t> in( std::vector<uint8_t> in(
buffersize + CHACHA20_POLY1305_AEAD_AAD_LEN + POLY1305_TAGLEN, 0); buffersize + CHACHA20_POLY1305_AEAD_AAD_LEN + POLY1305_TAGLEN, 0);
std::vector<uint8_t> out( std::vector<uint8_t> out(
buffersize + CHACHA20_POLY1305_AEAD_AAD_LEN + POLY1305_TAGLEN, 0); buffersize + CHACHA20_POLY1305_AEAD_AAD_LEN + POLY1305_TAGLEN, 0);
uint64_t seqnr_payload = 0; uint64_t seqnr_payload = 0;
uint64_t seqnr_aad = 0; uint64_t seqnr_aad = 0;
int aad_pos = 0; int aad_pos = 0;
uint32_t len = 0; uint32_t len = 0;
while (state.KeepRunning()) { bench.batch(buffersize).unit("byte").run([&] {
// encrypt or decrypt the buffer with a static key // encrypt or decrypt the buffer with a static key
assert(aead.Crypt(seqnr_payload, seqnr_aad, aad_pos, out.data(), assert(aead.Crypt(seqnr_payload, seqnr_aad, aad_pos, out.data(),
out.size(), in.data(), buffersize, true)); out.size(), in.data(), buffersize, true));
if (include_decryption) { if (include_decryption) {
// if we decrypt, include the GetLength // if we decrypt, include the GetLength
assert(aead.GetLength(&len, seqnr_aad, aad_pos, in.data())); assert(aead.GetLength(&len, seqnr_aad, aad_pos, in.data()));
assert(aead.Crypt(seqnr_payload, seqnr_aad, aad_pos, out.data(), assert(aead.Crypt(seqnr_payload, seqnr_aad, aad_pos, out.data(),
Show All 9 Lines bench.batch(buffersize).unit("byte").run([&] {
seqnr_aad++; seqnr_aad++;
} }
if (seqnr_payload + 1 == std::numeric_limits<uint64_t>::max()) { if (seqnr_payload + 1 == std::numeric_limits<uint64_t>::max()) {
// reuse of nonce+key is okay while benchmarking. // reuse of nonce+key is okay while benchmarking.
seqnr_payload = 0; seqnr_payload = 0;
seqnr_aad = 0; seqnr_aad = 0;
aad_pos = 0; aad_pos = 0;
} }
} });
} }
static void static void
CHACHA20_POLY1305_AEAD_64BYTES_ONLY_ENCRYPT(benchmark::State &state) { CHACHA20_POLY1305_AEAD_64BYTES_ONLY_ENCRYPT(benchmark::Bench &bench) {
CHACHA20_POLY1305_AEAD(state, BUFFER_SIZE_TINY, false); CHACHA20_POLY1305_AEAD(bench, BUFFER_SIZE_TINY, false);
} }
static void static void
CHACHA20_POLY1305_AEAD_256BYTES_ONLY_ENCRYPT(benchmark::State &state) { CHACHA20_POLY1305_AEAD_256BYTES_ONLY_ENCRYPT(benchmark::Bench &bench) {
CHACHA20_POLY1305_AEAD(state, BUFFER_SIZE_SMALL, false); CHACHA20_POLY1305_AEAD(bench, BUFFER_SIZE_SMALL, false);
} }
static void CHACHA20_POLY1305_AEAD_1MB_ONLY_ENCRYPT(benchmark::State &state) { static void CHACHA20_POLY1305_AEAD_1MB_ONLY_ENCRYPT(benchmark::Bench &bench) {
CHACHA20_POLY1305_AEAD(state, BUFFER_SIZE_LARGE, false); CHACHA20_POLY1305_AEAD(bench, BUFFER_SIZE_LARGE, false);
} }
static void static void
CHACHA20_POLY1305_AEAD_64BYTES_ENCRYPT_DECRYPT(benchmark::State &state) { CHACHA20_POLY1305_AEAD_64BYTES_ENCRYPT_DECRYPT(benchmark::Bench &bench) {
CHACHA20_POLY1305_AEAD(state, BUFFER_SIZE_TINY, true); CHACHA20_POLY1305_AEAD(bench, BUFFER_SIZE_TINY, true);
} }
static void static void
CHACHA20_POLY1305_AEAD_256BYTES_ENCRYPT_DECRYPT(benchmark::State &state) { CHACHA20_POLY1305_AEAD_256BYTES_ENCRYPT_DECRYPT(benchmark::Bench &bench) {
CHACHA20_POLY1305_AEAD(state, BUFFER_SIZE_SMALL, true); CHACHA20_POLY1305_AEAD(bench, BUFFER_SIZE_SMALL, true);
} }
static void static void
CHACHA20_POLY1305_AEAD_1MB_ENCRYPT_DECRYPT(benchmark::State &state) { CHACHA20_POLY1305_AEAD_1MB_ENCRYPT_DECRYPT(benchmark::Bench &bench) {
CHACHA20_POLY1305_AEAD(state, BUFFER_SIZE_LARGE, true); CHACHA20_POLY1305_AEAD(bench, BUFFER_SIZE_LARGE, true);
} }
// Add Hash() (dbl-sha256) bench for comparison // Add Hash() (dbl-sha256) bench for comparison
static void HASH(benchmark::State &state, size_t buffersize) { static void HASH(benchmark::Bench &bench, size_t buffersize) {
uint8_t hash[CHash256::OUTPUT_SIZE]; uint8_t hash[CHash256::OUTPUT_SIZE];
std::vector<uint8_t> in(buffersize, 0); std::vector<uint8_t> in(buffersize, 0);
while (state.KeepRunning()) { bench.batch(in.size()).unit("byte").run(
CHash256().Write(in).Finalize(hash); [&] { CHash256().Write(in).Finalize(hash); });
}
} }
static void HASH_64BYTES(benchmark::State &state) { static void HASH_64BYTES(benchmark::Bench &bench) {
HASH(state, BUFFER_SIZE_TINY); HASH(bench, BUFFER_SIZE_TINY);
} }
static void HASH_256BYTES(benchmark::State &state) { static void HASH_256BYTES(benchmark::Bench &bench) {
HASH(state, BUFFER_SIZE_SMALL); HASH(bench, BUFFER_SIZE_SMALL);
} }
static void HASH_1MB(benchmark::State &state) { static void HASH_1MB(benchmark::Bench &bench) {
HASH(state, BUFFER_SIZE_LARGE); HASH(bench, BUFFER_SIZE_LARGE);
} }
BENCHMARK(CHACHA20_POLY1305_AEAD_64BYTES_ONLY_ENCRYPT, 500000); BENCHMARK(CHACHA20_POLY1305_AEAD_64BYTES_ONLY_ENCRYPT);
BENCHMARK(CHACHA20_POLY1305_AEAD_256BYTES_ONLY_ENCRYPT, 250000); BENCHMARK(CHACHA20_POLY1305_AEAD_256BYTES_ONLY_ENCRYPT);
BENCHMARK(CHACHA20_POLY1305_AEAD_1MB_ONLY_ENCRYPT, 340); BENCHMARK(CHACHA20_POLY1305_AEAD_1MB_ONLY_ENCRYPT);
BENCHMARK(CHACHA20_POLY1305_AEAD_64BYTES_ENCRYPT_DECRYPT, 500000); BENCHMARK(CHACHA20_POLY1305_AEAD_64BYTES_ENCRYPT_DECRYPT);
BENCHMARK(CHACHA20_POLY1305_AEAD_256BYTES_ENCRYPT_DECRYPT, 250000); BENCHMARK(CHACHA20_POLY1305_AEAD_256BYTES_ENCRYPT_DECRYPT);
BENCHMARK(CHACHA20_POLY1305_AEAD_1MB_ENCRYPT_DECRYPT, 340); BENCHMARK(CHACHA20_POLY1305_AEAD_1MB_ENCRYPT_DECRYPT);
BENCHMARK(HASH_64BYTES, 500000); BENCHMARK(HASH_64BYTES);
BENCHMARK(HASH_256BYTES, 250000); BENCHMARK(HASH_256BYTES);
BENCHMARK(HASH_1MB, 340); BENCHMARK(HASH_1MB);