Function benchmark_crypto_ops

tests/crypto/benchmarks.cpp:284–349

}

void benchmark_crypto_ops(size_t count, std::ostream &out) {
	std::vector<Scalar> scalars(count);
	std::vector<PublicKey> public_keys(count);
	std::vector<KeyDerivation> derivations(count);
	std::vector<Point> points(count);
	std::vector<ge_dsmp> precomp(count);
	std::vector<crypto::EllipticCurvePoint> bytes(count);
	std::vector<std::pair<Scalar, Point>> merged_sp(count);
	auto merged_double_points =
	    std::make_unique<std::tuple<Scalar, Scalar, Point, Point>[]>(count);  // Also ok in C++14

	// initialize random values for tests
	for (size_t i = 0; i < count; ++i) {
		KeyPair k      = random_keypair();
		bytes[i]       = k.public_key;
		auto s         = k.secret_key;
		auto p         = crypto::P3(k.public_key).p3;
		scalars[i]     = s;
		points[i]      = p;
		public_keys[i] = to_bytes(p);
		memcpy(derivations[i].data, public_keys[i].data, sizeof(EllipticCurvePoint));
		merged_sp[i] = std::make_pair(s, p);

		k                             = random_keypair();
		auto s2                       = k.secret_key;
		auto p2                       = crypto::P3(k.public_key).p3;
		merged_double_points.get()[i] = std::make_tuple(s, s2, p, p2);

		ge_dsm_precomp(&precomp[i], &p);
	}

	std::map<std::string, BenchmarkResult> benchmark_results;

	// run the benchmarks
	benchmark_results["frombytes"]        = benchmark(count * 10, test_frombytes, bytes);
	benchmark_results["fromfe_frombytes"] = benchmark(count * 10, test_fromfe_frombytes, bytes);
	benchmark_results["check_subgroup"]   = benchmark(count, test_check_subgroup, points);
	benchmark_results["derive_output_secret_key"] =
	    benchmark(count * 10, test_derive_output_secret_key, mk_vec(derivations, scalars));
	benchmark_results["double_scalarmult_base"] =
	    benchmark(count, test_double_scalarmult_base, mk_vec(scalars, points));
	benchmark_results["double_scalarmult_badprecomp"] =
	    benchmark(count, test_double_scalarmult_badprecomp, mk_vec(scalars, points));
	benchmark_results["double_scalarmult_simple"] =
	    benchmark(count, test_double_scalarmult_simple, mk_vec(scalars, points));
	benchmark_results["double_scalarmult_simple_opt"] =
	    benchmark(count, test_double_scalarmult_simple_opt, mk_vec(scalars, points));
	benchmark_results["double_scalarmult_simple_aligned"] =
	    benchmark(count, test_double_scalarmult_simple_aligned, mk_vec(scalars, scalars, points, points));
	benchmark_results["generate_key_derivation"] =
	    benchmark(count, test_generate_key_derivation, mk_vec(scalars, public_keys));
	benchmark_results["generate_signature"] = benchmark(count, test_generate_signature, mk_vec(public_keys, scalars));
	benchmark_results["scalarmult_base"]    = benchmark(count, test_scalarmult_base, scalars);
	benchmark_results["scalarmult"]         = benchmark(count, test_scalarmult, mk_vec(scalars, points));
	benchmark_results["scalarmult_via_phantom_point"] =
	    benchmark(count, test_scalarmult_via_phantom_point, mk_vec(scalars, points));
	benchmark_results["double_scalarmult"] = benchmark(count, test_double_scalarmult, mk_vec(scalars, points));
	benchmark_results["sc_mul"]            = benchmark(count * 1000, test_sc_mul, mk_vec(scalars, scalars));