198 lines
7.5 KiB
C++
198 lines
7.5 KiB
C++
/*
|
|
* @author TPOC: contact@palisade-crypto.org
|
|
*
|
|
* @copyright Copyright (c) 2019, New Jersey Institute of Technology (NJIT)
|
|
* 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 code benchmarks functions of the math directory of the PALISADE lattice
|
|
encryption library.
|
|
*/
|
|
#define _USE_MATH_DEFINES
|
|
#include "benchmark/benchmark.h"
|
|
|
|
#include "palisade.h"
|
|
|
|
#include <iostream>
|
|
|
|
#include "vechelper.h"
|
|
|
|
#include "lattice/dcrtpoly.cpp"
|
|
#include "lattice/elemparamfactory.h"
|
|
#include "lattice/elemparams.cpp"
|
|
#include "lattice/ildcrtparams.cpp"
|
|
#include "lattice/ilparams.cpp"
|
|
#include "lattice/poly.cpp"
|
|
#include "math/discretegaussiangenerator.cpp"
|
|
#include "math/discreteuniformgenerator.cpp"
|
|
#include "math/nbtheory.cpp"
|
|
#include "math/transfrm.cpp"
|
|
|
|
using namespace std;
|
|
using namespace lbcrypto;
|
|
|
|
#define DO_NATIVEVECTOR_BENCHMARK(X) \
|
|
BENCHMARK_TEMPLATE(X, NativeVector) \
|
|
->Unit(benchmark::kMicrosecond) \
|
|
->ArgName("parm_16") \
|
|
->Arg(16); \
|
|
BENCHMARK_TEMPLATE(X, NativeVector) \
|
|
->Unit(benchmark::kMicrosecond) \
|
|
->ArgName("parm_1024") \
|
|
->Arg(1024); \
|
|
BENCHMARK_TEMPLATE(X, NativeVector) \
|
|
->Unit(benchmark::kMicrosecond) \
|
|
->ArgName("parm_2048") \
|
|
->Arg(2048);
|
|
|
|
#define DO_VECTOR_BENCHMARK_TEMPLATE(X, Y) \
|
|
BENCHMARK_TEMPLATE(X, Y) \
|
|
->Unit(benchmark::kMicrosecond) \
|
|
->ArgName("parm_16") \
|
|
->Arg(16); \
|
|
BENCHMARK_TEMPLATE(X, Y) \
|
|
->Unit(benchmark::kMicrosecond) \
|
|
->ArgName("parm_1024") \
|
|
->Arg(1024); \
|
|
BENCHMARK_TEMPLATE(X, Y) \
|
|
->Unit(benchmark::kMicrosecond) \
|
|
->ArgName("parm_2048") \
|
|
->Arg(2048); \
|
|
/*BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_4096")->Arg(4096);*/ \
|
|
BENCHMARK_TEMPLATE(X, Y) \
|
|
->Unit(benchmark::kMicrosecond) \
|
|
->ArgName("parm_8192") \
|
|
->Arg(8192); \
|
|
/*BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_16384")->Arg(16384);*/ \
|
|
BENCHMARK_TEMPLATE(X, Y) \
|
|
->Unit(benchmark::kMicrosecond) \
|
|
->ArgName("parm_32768") \
|
|
->Arg(32768);
|
|
|
|
// add
|
|
template <typename V>
|
|
static void add_BigVec(const V &a, const V &b) {
|
|
V c = a + b;
|
|
}
|
|
|
|
template <typename V>
|
|
static void BM_BigVec_Add(benchmark::State &state) { // benchmark
|
|
auto p = state.range(0);
|
|
size_t idx = ElemParamFactory::GetNearestIndex(p);
|
|
typename V::Integer q(ElemParamFactory::DefaultSet[idx].q);
|
|
V a = makeVector<V>(p, q);
|
|
V b = makeVector<V>(p, q);
|
|
|
|
while (state.KeepRunning()) {
|
|
add_BigVec<V>(a, b);
|
|
}
|
|
}
|
|
|
|
DO_NATIVEVECTOR_BENCHMARK(BM_BigVec_Add)
|
|
DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Add, M2Vector)
|
|
DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Add, M4Vector)
|
|
#ifdef WITH_NTL
|
|
DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Add, M6Vector)
|
|
#endif
|
|
|
|
// +=
|
|
template <typename V>
|
|
static void addeq_BigVec(V &a, const V &b) {
|
|
a += b;
|
|
}
|
|
|
|
template <typename V>
|
|
static void BM_BigVec_Addeq(benchmark::State &state) { // benchmark
|
|
auto p = state.range(0);
|
|
size_t idx = ElemParamFactory::GetNearestIndex(p);
|
|
typename V::Integer q(ElemParamFactory::DefaultSet[idx].q);
|
|
V b = makeVector<V>(p, q);
|
|
V a = makeVector<V>(p, q);
|
|
|
|
while (state.KeepRunning()) {
|
|
// V a = makeVector<V>(p, q);
|
|
addeq_BigVec<V>(a, b);
|
|
}
|
|
}
|
|
|
|
DO_NATIVEVECTOR_BENCHMARK(BM_BigVec_Addeq)
|
|
DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Addeq, M2Vector)
|
|
DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Addeq, M4Vector)
|
|
#ifdef WITH_NTL
|
|
DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Addeq, M6Vector)
|
|
#endif
|
|
|
|
// mult
|
|
template <typename V>
|
|
static void mult_BigVec(const V &a, const V &b) { // function
|
|
V c = a * b;
|
|
}
|
|
|
|
template <typename V>
|
|
static void BM_BigVec_Mult(benchmark::State &state) { // benchmark
|
|
auto p = state.range(0);
|
|
size_t idx = ElemParamFactory::GetNearestIndex(p);
|
|
typename V::Integer q(ElemParamFactory::DefaultSet[idx].q);
|
|
V a = makeVector<V>(p, q);
|
|
V b = makeVector<V>(p, q);
|
|
|
|
while (state.KeepRunning()) {
|
|
mult_BigVec<V>(a, b);
|
|
}
|
|
}
|
|
|
|
DO_NATIVEVECTOR_BENCHMARK(BM_BigVec_Mult)
|
|
DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Mult, M2Vector)
|
|
DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Mult, M4Vector)
|
|
#ifdef WITH_NTL
|
|
DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Mult, M6Vector)
|
|
#endif
|
|
|
|
// mult
|
|
template <typename V>
|
|
static void multeq_BigVec(V &a, const V &b) {
|
|
a *= b;
|
|
}
|
|
|
|
template <typename V>
|
|
static void BM_BigVec_Multeq(benchmark::State &state) { // benchmark
|
|
auto p = state.range(0);
|
|
size_t idx = ElemParamFactory::GetNearestIndex(p);
|
|
typename V::Integer q(ElemParamFactory::DefaultSet[idx].q);
|
|
V b = makeVector<V>(p, q);
|
|
V a = makeVector<V>(p, q);
|
|
|
|
while (state.KeepRunning()) {
|
|
// V a = makeVector<V>(p, q);
|
|
multeq_BigVec<V>(a, b);
|
|
}
|
|
}
|
|
|
|
DO_NATIVEVECTOR_BENCHMARK(BM_BigVec_Multeq)
|
|
DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Multeq, M2Vector)
|
|
DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Multeq, M4Vector)
|
|
#ifdef WITH_NTL
|
|
DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Multeq, M6Vector)
|
|
#endif
|
|
|
|
// execute the benchmarks
|
|
BENCHMARK_MAIN();
|