207 lines
6.3 KiB
C++
207 lines
6.3 KiB
C++
/*
|
|
* @file binfhe : library benchmark routines for FHEW-AP
|
|
* @author TPOC: contact@palisade-crypto.org
|
|
*
|
|
* @copyright Copyright (c) 2019, Duality Technologies Inc.
|
|
* All rights reserved.
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution. THIS SOFTWARE IS
|
|
* PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
|
* EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
|
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* This file benchmarks FHEW-AP gate evaluation operations
|
|
*/
|
|
|
|
#define PROFILE
|
|
#include "benchmark/benchmark.h"
|
|
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <iterator>
|
|
#include <limits>
|
|
#include <random>
|
|
|
|
#include "binfhecontext.h"
|
|
|
|
#include "utils/debug.h"
|
|
|
|
using namespace std;
|
|
using namespace lbcrypto;
|
|
|
|
/*
|
|
* Context setup utility methods
|
|
*/
|
|
|
|
BinFHEContext GenerateFHEWContext(BINFHEPARAMSET set) {
|
|
auto cc = BinFHEContext();
|
|
cc.GenerateBinFHEContext(set, AP);
|
|
return cc;
|
|
}
|
|
|
|
/*
|
|
* FHEW benchmarks
|
|
*/
|
|
|
|
template <class ParamSet>
|
|
void FHEW_NOT(benchmark::State &state, ParamSet param_set) {
|
|
BINFHEPARAMSET param(param_set);
|
|
BinFHEContext cc = GenerateFHEWContext(param);
|
|
|
|
LWEPrivateKey sk = cc.KeyGen();
|
|
|
|
LWECiphertext ct1 = cc.Encrypt(sk, 1, FRESH);
|
|
|
|
for (auto _ : state) {
|
|
LWECiphertext ct11 = cc.EvalNOT(ct1);
|
|
}
|
|
}
|
|
|
|
BENCHMARK_CAPTURE(FHEW_NOT, MEDIUM, MEDIUM)->Unit(benchmark::kMicrosecond);
|
|
BENCHMARK_CAPTURE(FHEW_NOT, STD128, STD128)->Unit(benchmark::kMicrosecond);
|
|
BENCHMARK_CAPTURE(FHEW_NOT, STD128_AP, STD128_AP)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
// benchmark for binary gates, such as AND, OR, NAND, NOR
|
|
template <class ParamSet, class BinGate>
|
|
void FHEW_BINGATE(benchmark::State &state, ParamSet param_set,
|
|
BinGate bin_gate) {
|
|
BINGATE gate(bin_gate);
|
|
BINFHEPARAMSET param(param_set);
|
|
|
|
BinFHEContext cc = GenerateFHEWContext(param);
|
|
|
|
LWEPrivateKey sk = cc.KeyGen();
|
|
|
|
cc.BTKeyGen(sk);
|
|
|
|
LWECiphertext ct1 = cc.Encrypt(sk, 1);
|
|
LWECiphertext ct2 = cc.Encrypt(sk, 1);
|
|
|
|
for (auto _ : state) {
|
|
LWECiphertext ct11 = cc.EvalBinGate(gate, ct1, ct2);
|
|
}
|
|
}
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, MEDIUM_OR, MEDIUM, OR)
|
|
->Unit(benchmark::kMicrosecond)
|
|
->MinTime(10.0);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, MEDIUM_AND, MEDIUM, AND)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, MEDIUM_NOR, MEDIUM, NOR)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, MEDIUM_NAND, MEDIUM, NAND)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, MEDIUM_XOR, MEDIUM, XOR)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, MEDIUM_XNOR, MEDIUM, XNOR)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, MEDIUM_XOR_FAST, MEDIUM, XOR_FAST)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, MEDIUM_XNOR_FAST, MEDIUM, XNOR_FAST)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_OR, STD128, OR)
|
|
->Unit(benchmark::kMicrosecond)
|
|
->MinTime(10.0);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_AND, STD128, AND)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_NOR, STD128, NOR)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_NAND, STD128, NAND)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_XOR, STD128, XOR)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_XNOR, STD128, XNOR)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_XOR_FAST, STD128, XOR_FAST)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_XNOR_FAST, STD128, XNOR_FAST)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_AP_OR, STD128_AP, OR)
|
|
->Unit(benchmark::kMicrosecond)
|
|
->MinTime(10.0);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_AP_AND, STD128_AP, AND)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_AP_NOR, STD128_AP, NOR)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_AP_NAND, STD128_AP, NAND)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_AP_XOR, STD128_AP, XOR)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_AP_XNOR, STD128_AP, XNOR)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_AP_XOR_FAST, STD128_AP, XOR_FAST)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_BINGATE, STD128_AP_XNOR_FAST, STD128_AP, XNOR_FAST)
|
|
->Unit(benchmark::kMicrosecond);
|
|
|
|
// benchmark for key switching
|
|
template <class ParamSet>
|
|
void FHEW_KEYSWITCH(benchmark::State &state, ParamSet param_set) {
|
|
BINFHEPARAMSET param(param_set);
|
|
BinFHEContext cc = GenerateFHEWContext(param);
|
|
|
|
LWEPrivateKey sk = cc.KeyGen();
|
|
LWEPrivateKey skN = cc.KeyGenN();
|
|
|
|
auto ctQN1 = cc.Encrypt(skN, 1, FRESH);
|
|
auto keySwitchHint = cc.KeySwitchGen(sk, skN);
|
|
|
|
for (auto _ : state) {
|
|
std::shared_ptr<LWECiphertextImpl> eQ1 = cc.GetLWEScheme()->KeySwitch(
|
|
cc.GetParams()->GetLWEParams(), keySwitchHint, ctQN1);
|
|
}
|
|
}
|
|
|
|
BENCHMARK_CAPTURE(FHEW_KEYSWITCH, MEDIUM, MEDIUM)
|
|
->Unit(benchmark::kMicrosecond)
|
|
->MinTime(1.0);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_KEYSWITCH, STD128, STD128)
|
|
->Unit(benchmark::kMicrosecond)
|
|
->MinTime(1.0);
|
|
|
|
BENCHMARK_CAPTURE(FHEW_KEYSWITCH, STD128_AP, STD128_AP)
|
|
->Unit(benchmark::kMicrosecond)
|
|
->MinTime(1.0);
|
|
|
|
BENCHMARK_MAIN();
|