microsoft
/
SEAL
зеркало из https://github.com/microsoft/SEAL.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Merge remote-tracking branch 'github/contrib' into 3.6.x

This commit is contained in:
Wei Dai 2021-04-05 14:09:31 -07:00
Родитель 0d2234f285 aa476c7e1a
Коммит aa45e41d1d
20 изменённых файлов: 366 добавлений и 31 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

68
CMakeLists.txt
Просмотреть файл

@ -62,6 +62,8 @@ message(STATUS "Microsoft SEAL debug mode: ${SEAL_DEBUG}")
# Use C++17, use C++14 otherwise.
set(SEAL_USE_CXX17_OPTION_STR "Use C++17")
option(SEAL_USE_CXX17 ${SEAL_USE_CXX17_OPTION_STR} ON)
message(STATUS "SEAL_USE_CXX17: ${SEAL_USE_CXX17}")
# Enable features from C++17 if available, disable features if set to OFF.
include(EnableCXX17)
@ -123,6 +125,7 @@ include(CleanArtifacts)
# Download and build missing dependencies, throw error if disabled.
set(SEAL_BUILD_DEPS_OPTION_STR "Automatically download and build unmet dependencies")
option(SEAL_BUILD_DEPS ${SEAL_BUILD_DEPS_OPTION_STR} ON)
message(STATUS "SEAL_BUILD_DEPS: ${SEAL_BUILD_DEPS}")
if(SEAL_BUILD_DEPS)
include(FetchContent)
@ -135,6 +138,8 @@ endif()
# [option] SEAL_USE_MSGSL (default: ON)
set(SEAL_USE_MSGSL_OPTION_STR "Use Microsoft GSL")
option(SEAL_USE_MSGSL ${SEAL_USE_MSGSL_OPTION_STR} ON)
message(STATUS "SEAL_USE_MSGSL: ${SEAL_USE_MSGSL}")
if(SEAL_USE_MSGSL)
if(SEAL_BUILD_DEPS)
message(STATUS "Microsoft GSL: download ...")
@ -152,6 +157,8 @@ endif()
# [option] SEAL_USE_ZLIB (default: ON)
set(SEAL_USE_ZLIB_OPTION_STR "Use ZLIB for compressed serialization")
option(SEAL_USE_ZLIB ${SEAL_USE_ZLIB_OPTION_STR} ON)
message(STATUS "SEAL_USE_ZLIB: ${SEAL_USE_ZLIB}")
if(SEAL_USE_ZLIB)
if(SEAL_BUILD_DEPS)
message(STATUS "ZLIB: download ...")
@ -171,6 +178,8 @@ endif()
# [option] SEAL_USE_ZSTD (default: ON)
set(SEAL_USE_ZSTD_OPTION_STR "Use Zstandard for compressed serialization")
option(SEAL_USE_ZSTD ${SEAL_USE_ZSTD_OPTION_STR} ON)
message(STATUS "SEAL_USE_ZSTD: ${SEAL_USE_ZSTD}")
if(SEAL_USE_ZSTD)
if(SEAL_BUILD_DEPS)
message(STATUS "Zstandard: download ...")
@ -200,6 +209,23 @@ if(SEAL_USE_ZSTD)
endif()
endif()
# [option] SEAL_USE_INTEL_HEXL (default: OFF)
set(SEAL_USE_INTEL_HEXL_OPTION_STR "Use Intel HEXL library")
option(SEAL_USE_INTEL_HEXL ${SEAL_USE_INTEL_HEXL_OPTION_STR} OFF)
message(STATUS "SEAL_USE_INTEL_HEXL: ${SEAL_USE_INTEL_HEXL}")
if(SEAL_USE_INTEL_HEXL)
if(SEAL_BUILD_DEPS)
message(STATUS "Intel HEXL: download ...")
seal_fetch_thirdparty_content(ExternalIntelHEXL)
else()
find_package(HEXL 1.0.1)
if (NOT TARGET HEXL::hexl)
FATAL_ERROR("Intel HEXL: not found")
endif()
endif()
endif()
####################
# SEAL C++ library #
####################
@ -208,6 +234,7 @@ endif()
# Build a shared library if set to ON. Build a static library regardlessly.
set(BUILD_SHARED_LIBS_STR "Build shared library")
option(BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS_STR} OFF)
message(STATUS "BUILD_SHARED_LIBS: ${BUILD_SHARED_LIBS}")
if(WIN32 AND BUILD_SHARED_LIBS)
message(FATAL_ERROR "On Windows only static build is supported; set `BUILD_SHARED_LIBS=OFF`")
endif()
@ -215,18 +242,21 @@ endif()
# [option] SEAL_THROW_ON_TRANSPARENT_CIPHERTEXT (default: ON)
set(SEAL_THROW_ON_TRANSPARENT_CIPHERTEXT_STR "Throw an exception when Evaluator outputs a transparent ciphertext")
option(SEAL_THROW_ON_TRANSPARENT_CIPHERTEXT ${SEAL_THROW_ON_TRANSPARENT_CIPHERTEXT_STR} ON)
message(STATUS "SEAL_THROW_ON_TRANSPARENT_CIPHERTEXT: ${SEAL_THROW_ON_TRANSPARENT_CIPHERTEXT}")
mark_as_advanced(FORCE SEAL_THROW_ON_TRANSPARENT_CIPHERTEXT)
# [option] SEAL_USE_GAUSSIAN_NOISE (default: OFF)
# Use Gaussian distribution for noise sampling if set to ON, use centered binomial otherwise.
set(SEAL_USE_GAUSSIAN_NOISE_STR "Use a rounded Gaussian distribution for noise sampling instead of a Centered Binomial Distribution")
option(SEAL_USE_GAUSSIAN_NOISE ${SEAL_USE_GAUSSIAN_NOISE_STR} OFF)
message(STATUS "SEAL_USE_GAUSSIAN_NOISE: ${SEAL_USE_GAUSSIAN_NOISE}")
mark_as_advanced(FORCE SEAL_USE_GAUSSIAN_NOISE)
# [option] SEAL_DEFAULT_PRNG (default: Blake2xb)
# Choose either Blake2xb or Shake256 to be the default PRNG.
set(SEAL_DEFAULT_PRNG_STR "Choose the default PRNG")
set(SEAL_DEFAULT_PRNG "Blake2xb" CACHE STRING ${SEAL_DEFAULT_PRNG_STR} FORCE)
message(STATUS "SEAL_DEFAULT_PRNG: ${SEAL_DEFAULT_PRNG}")
set_property(CACHE SEAL_DEFAULT_PRNG PROPERTY
STRINGS "Blake2xb" "Shake256")
mark_as_advanced(FORCE SEAL_DEFAULT_PRNG)
@ -239,6 +269,7 @@ include(CheckCXXIntrinsicsHeader)
if(NOT SEAL_INTRIN_HEADER_FOUND)
set(SEAL_USE_INTRIN OFF CACHE BOOL ${SEAL_USE_INTRIN_OPTION_STR} FORCE)
endif()
message(STATUS "SEAL_USE_INTRIN: ${SEAL_USE_INTRIN}")
# [option] SEAL_USE_${A_SPECIFIC_INTRIN} (default: ON, advanced)
# Not available if SEAL_USE_INTRIN is OFF.
@ -299,6 +330,7 @@ mark_as_advanced(FORCE SEAL_USE_MEMSET_S)
if(NOT SEAL_MEMSET_S_FOUND)
set(SEAL_USE_MEMSET_S OFF CACHE BOOL ${SEAL_USE_MEMSET_S_OPTION_STR} FORCE)
endif()
message(STATUS "SEAL_USE_MEMSET_S: ${SEAL_USE_MEMSET_S}")
set(SEAL_USE_EXPLICIT_BZERO_OPTION_STR "Use explicit_bzero")
option(SEAL_USE_EXPLICIT_BZERO ${SEAL_USE_EXPLICIT_BZERO_OPTION_STR} ON)
@ -306,6 +338,7 @@ mark_as_advanced(FORCE SEAL_USE_EXPLICIT_BZERO)
if(NOT SEAL_EXPLICIT_BZERO_FOUND)
set(SEAL_USE_EXPLICIT_BZERO OFF CACHE BOOL ${SEAL_USE_EXPLICIT_BZERO_OPTION_STR} FORCE)
endif()
message(STATUS "SEAL_USE_EXPLICIT_BZERO: ${SEAL_USE_EXPLICIT_BZERO}")
set(SEAL_USE_EXPLICIT_MEMSET_OPTION_STR "Use explicit_memset")
option(SEAL_USE_EXPLICIT_MEMSET ${SEAL_USE_EXPLICIT_MEMSET_OPTION_STR} ON)
@ -313,6 +346,7 @@ mark_as_advanced(FORCE SEAL_USE_EXPLICIT_MEMSET)
if(NOT SEAL_EXPLICIT_MEMSET_FOUND)
set(SEAL_USE_EXPLICIT_MEMSET OFF CACHE BOOL ${SEAL_USE_EXPLICIT_MEMSET_OPTION_STR} FORCE)
endif()
message(STATUS "SEAL_USE_EXPLICIT_MEMSET: ${SEAL_USE_EXPLICIT_MEMSET}")
# Add source files to library and header files to install
set(SEAL_SOURCE_FILES "")
@ -364,6 +398,21 @@ if(NOT BUILD_SHARED_LIBS)
endif()
endif()
if(SEAL_USE_INTEL_HEXL)
if(SEAL_BUILD_DEPS)
add_dependencies(seal HEXL::hexl)
target_include_directories(seal PUBLIC $<BUILD_INTERFACE:${hexl_SOURCE_DIR}/hexl/include>)
seal_combine_archives(seal HEXL::hexl)
else()
target_link_libraries(seal PRIVATE HEXL::hexl)
get_target_property(
HEXL_INCLUDE_DIR
HEXL::hexl
INTERFACE_INCLUDE_DIRECTORIES)
target_include_directories(seal PUBLIC ${HEXL_INCLUDE_DIR})
endif()
endif()
# Set secure compile options if SEAL_SECURE_COMPILE_OPTIONS is ON; only supported on MSVC
if(SEAL_SECURE_COMPILE_OPTIONS)
seal_set_secure_compile_options(seal PUBLIC)
@ -399,6 +448,11 @@ else()
target_include_directories(seal_shared PRIVATE $<BUILD_INTERFACE:${zstd_SOURCE_DIR}/lib/common>)
target_link_libraries(seal_shared PRIVATE ${zstd_static})
endif()
if(SEAL_USE_INTEL_HEXL)
target_include_directories(seal_shared PRIVATE $<BUILD_INTERFACE:${hexl_SOURCE_DIR}/hexl/include>)
target_link_libraries(seal_shared PRIVATE hexl)
endif()
endif()
# Add standard alias targets for SEAL::seal and SEAL::seal_shared
@ -416,6 +470,7 @@ endif()
# [option] SEAL_BUILD_SEAL_C (default: OFF)
set(SEAL_BUILD_SEAL_C_OPTION_STR "Build C export library for Microsoft SEAL")
option(SEAL_BUILD_SEAL_C ${SEAL_BUILD_SEAL_C_OPTION_STR} OFF)
message(STATUS "SEAL_BUILD_SEAL_C: ${SEAL_BUILD_SEAL_C}")
set(SEAL_BUILD_STATIC_SEAL_C_OPTION_STR "Build static C library for Microsoft SEAL")
cmake_dependent_option(SEAL_BUILD_STATIC_SEAL_C ${SEAL_BUILD_STATIC_SEAL_C_OPTION_STR} OFF "SEAL_BUILD_SEAL_C" OFF)
@ -459,6 +514,9 @@ if(SEAL_BUILD_SEAL_C)
endif()
seal_set_language(sealc)
seal_set_include_directories(sealc)
if (SEAL_USE_INTEL_HEXL)
target_include_directories(sealc PRIVATE $<BUILD_INTERFACE:${hexl_SOURCE_DIR}/hexl/include>)
endif()
target_link_libraries(sealc PUBLIC seal)
@ -513,6 +571,13 @@ if(SEAL_USE_MSGSL AND SEAL_BUILD_DEPS)
DESTINATION ${SEAL_INCLUDES_INSTALL_DIR})
endif()
# Install Intel HEXL header files if SEAL_BUILD_DEPS is ON
if(SEAL_USE_INTEL_HEXL AND SEAL_BUILD_DEPS)
install(
DIRECTORY ${hexl_SOURCE_DIR}/hexl/include/intel-hexl
DESTINATION ${SEAL_INCLUDES_INSTALL_DIR})
endif()
##############
# pkg-config #
##############
@ -571,6 +636,7 @@ endif()
# [option] SEAL_BUILD_EXAMPLES
set(SEAL_BUILD_EXAMPLES_OPTION_STR "Build C++ examples for Microsoft SEAL")
option(SEAL_BUILD_EXAMPLES ${SEAL_BUILD_EXAMPLES_OPTION_STR} OFF)
message(STATUS "SEAL_BUILD_EXAMPLES: ${SEAL_BUILD_EXAMPLES}")
if(SEAL_BUILD_EXAMPLES)
add_subdirectory(native/examples)
@ -583,6 +649,7 @@ endif()
# [option] SEAL_BUILD_TESTS
set(SEAL_BUILD_TESTS_OPTION_STR "Build C++ tests for Microsoft SEAL")
option(SEAL_BUILD_TESTS ${SEAL_BUILD_TESTS_OPTION_STR} OFF)
message(STATUS "SEAL_BUILD_TESTS: ${SEAL_BUILD_TESTS}")
if(SEAL_BUILD_TESTS)
add_subdirectory(native/tests)
@ -595,6 +662,7 @@ endif()
# [option] SEAL_BUILD_BENCH
set(SEAL_BUILD_BENCH_OPTION_STR "Build C++ benchmarks for Microsoft SEAL")
option(SEAL_BUILD_BENCH ${SEAL_BUILD_BENCH_OPTION_STR} OFF)
message(STATUS "SEAL_BUILD_BENCH: ${SEAL_BUILD_BENCH}")
if(SEAL_BUILD_BENCH)
add_subdirectory(native/bench)

36
README.md
Просмотреть файл

@ -19,6 +19,7 @@ The [EVA compiler for CKKS](https://arxiv.org/abs/1912.11951) is available at [G
- [Microsoft SEAL](#microsoft-seal-1)
- [Getting Started](#getting-started)
- [Optional Dependencies](#optional-dependencies)
- [Intel HEXL](#intel-hexl)
- [Microsoft GSL](#microsoft-gsl)
- [ZLIB and Zstandard](#zlib-and-zstandard)
- [Installing from NuGet Package](#installing-from-nuget-package-windows-linux-macos-android-ios)
@ -115,12 +116,17 @@ The optional dependencies and their tested versions (other versions may work as
| Optional dependency | Tested version | Use |
| ------------------------------------------------------ | -------------- | ------------------------------------------------ |
| [Intel HEXL](https://github.com/intel/hexl) | 1.0.1 | Acceleration of low-level kernels |
| [Microsoft GSL](https://github.com/microsoft/GSL) | 3.1.0 | API extensions |
| [ZLIB](https://github.com/madler/zlib) | 1.2.11 | Compressed serialization |
| [Zstandard](https://github.com/facebook/zstd) | 1.4.5 | Compressed serialization (much faster than ZLIB) |
| [GoogleTest](https://github.com/google/googletest) | 1.10.0 | For running tests |
| [GoogleBenchmark](https://github.com/google/benchmark) | 1.5.2 | For running benchmarks |
#### Intel HEXL
Intel HEXL is a library providing efficient implementations of cryptographic primitives common in homomorphic encryption. The acceleration is particularly evident on Intel processors with the Intel AVX512-IMA52 instruction set.
#### Microsoft GSL
Microsoft GSL (Guidelines Support Library) is a header-only library that implements `gsl::span`: a *view type* that provides safe (bounds-checked) array access to memory.
@ -377,20 +383,21 @@ The build flag `--bind` expects the bindings to be specified using the [embind](
The following options can be used with CMake to configure the build. The default value for each option is denoted with boldface in the **Values** column.
| CMake option | Values | Information |
| ------------------- | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| CMAKE_BUILD_TYPE | **Release**</br>Debug</br>RelWithDebInfo</br>MinSizeRel</br> | `Debug` and `MinSizeRel` have worse run-time performance. `Debug` inserts additional assertion code. Set to `Release` unless you are developing Microsoft SEAL itself or debugging some complex issue. |
| SEAL_BUILD_EXAMPLES | ON / **OFF** | Build the C++ examples in [native/examples](native/examples). |
| SEAL_BUILD_TESTS | ON / **OFF** | Build the tests to check that Microsoft SEAL works correctly. |
| SEAL_BUILD_BENCH | ON / **OFF** | Build the performance benchmarks. |
| SEAL_BUILD_DEPS | **ON** / OFF | Set to `ON` to automatically download and build [optional dependencies](#optional-dependencies); otherwise CMake will attempt to locate pre-installed dependencies. |
| SEAL_USE_MSGSL | **ON** / OFF | Build with Microsoft GSL support. |
| SEAL_USE_ZLIB | **ON** / OFF | Build with ZLIB support. |
| SEAL_USE_ZSTD | **ON** / OFF | Build with Zstandard support. |
| BUILD_SHARED_LIBS | ON / **OFF** | Set to `ON` to build a shared library instead of a static library. Not supported in Windows. |
| SEAL_BUILD_SEAL_C | ON / **OFF** | Build the C wrapper library SEAL_C. This is used by the C# wrapper and most users should have no reason to build it. |
| SEAL_USE_CXX17 | **ON** / OFF | Set to `ON` to build Microsoft SEAL as C++17 for a positive performance impact. |
| SEAL_USE_INTRIN | **ON** / OFF | Set to `ON` to use compiler intrinsics for improved performance. CMake will automatically detect which intrinsics are available and enable them accordingly. |
| CMake option | Values | Information |
| ---------------------- | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| CMAKE_BUILD_TYPE | **Release**</br>Debug</br>RelWithDebInfo</br>MinSizeRel</br> | `Debug` and `MinSizeRel` have worse run-time performance. `Debug` inserts additional assertion code. Set to `Release` unless you are developing Microsoft SEAL itself or debugging some complex issue. |
| SEAL_BUILD_EXAMPLES | ON / **OFF** | Build the C++ examples in [native/examples](native/examples). |
| SEAL_BUILD_TESTS | ON / **OFF** | Build the tests to check that Microsoft SEAL works correctly. |
| SEAL_BUILD_BENCH | ON / **OFF** | Build the performance benchmark. |
| SEAL_BUILD_DEPS | **ON** / OFF | Set to `ON` to automatically download and build [optional dependencies](#optional-dependencies); otherwise CMake will attempt to locate pre-installed dependencies. |
| SEAL_USE_INTEL_HEXL | ON / **OFF** | Set to `ON` to use Intel HEXL for low-level kernels. |
| SEAL_USE_MSGSL | **ON** / OFF | Build with Microsoft GSL support. |
| SEAL_USE_ZLIB | **ON** / OFF | Build with ZLIB support. |
| SEAL_USE_ZSTD | **ON** / OFF | Build with Zstandard support. |
| BUILD_SHARED_LIBS | ON / **OFF** | Set to `ON` to build a shared library instead of a static library. Not supported in Windows. |
| SEAL_BUILD_SEAL_C | ON / **OFF** | Build the C wrapper library SEAL_C. This is used by the C# wrapper and most users should have no reason to build it. |
| SEAL_USE_CXX17 | **ON** / OFF | Set to `ON` to build Microsoft SEAL as C++17 for a positive performance impact. |
| SEAL_USE_INTRIN | **ON** / OFF | Set to `ON` to use compiler intrinsics for improved performance. CMake will automatically detect which intrinsics are available and enable them accordingly. |
As usual, these options can be passed to CMake with the `-D` flag.
For example, one could run
@ -412,6 +419,7 @@ The following options can be used with CMake to further configure the build. Mos
| SEAL_DEFAULT_PRNG | **Blake2xb**</br>Shake256 | Microsoft SEAL supports both Blake2xb and Shake256 XOFs for generating random bytes. Blake2xb is much faster, but it is not standardized, whereas Shake256 is a FIPS standard. |
| SEAL_USE_GAUSSIAN_NOISE | ON / **OFF** | Set to `ON` to use a non-constant time rounded continuous Gaussian for the error distribution; otherwise a centered binomial distribution &ndash; with slightly larger standard deviation &ndash; is used. |
| SEAL_SECURE_COMPILE_OPTIONS | ON / **OFF** | Set to `ON` to compile/link with Control-Flow Guard (`/guard:cf`) and Spectre mitigations (`/Qspectre`). This has an effect only when compiling with MSVC. |
| SEAL_USE_ALIGN_64 | **ON** / OFF | Set to `ON` to use 64-byte aligned memory allocations. This can improve performance of AVX512 primitives when Intel HEXL is enabled. |
#### Linking with Microsoft SEAL through CMake

4
cmake/CheckCXXIntrinsicsHeader.cmake
Просмотреть файл

@ -20,11 +20,11 @@ if(SEAL_USE_INTRIN)
if(SEAL_ARM64)
set(SEAL_INTRIN_HEADER "arm_neon.h")
elseif(EMSCRIPTEN)
set(SEAL_INTRIN_HEADER "wasm_simd128.h")
set(SEAL_INTRIN_HEADER "wasm_simd128.h")
else()
set(SEAL_INTRIN_HEADER "x86intrin.h")
endif()
endif()
check_include_file_cxx(${SEAL_INTRIN_HEADER} SEAL_INTRIN_HEADER_FOUND)
endif()
endif()

4
cmake/EnableCXX17.cmake
Просмотреть файл

@ -1,6 +1,7 @@
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT license.
set(SEAL_USE_ALIGN_64 OFF)
set(SEAL_USE_STD_BYTE OFF)
set(SEAL_USE_SHARED_MUTEX OFF)
set(SEAL_USE_IF_CONSTEXPR OFF)
@ -9,6 +10,7 @@ set(SEAL_USE_NODISCARD OFF)
set(SEAL_USE_STD_FOR_EACH_N OFF)
set(SEAL_LANG_FLAG "-std=c++14")
if(SEAL_USE_CXX17)
set(SEAL_USE_ALIGN_64 ON)
set(SEAL_USE_STD_BYTE ON)
set(SEAL_USE_SHARED_MUTEX ON)
set(SEAL_USE_IF_CONSTEXPR ON)
@ -41,4 +43,4 @@ if(SEAL_USE_STD_FOR_EACH_N)
endif()
cmake_pop_check_state()
endif()
endif()

36
cmake/ExternalIntelHEXL.cmake Normal file
Просмотреть файл

@ -0,0 +1,36 @@
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT license.
FetchContent_Declare(
hexl
PREFIX hexl
GIT_REPOSITORY https://github.com/intel/hexl.git
GIT_TAG v1.0.1
)
FetchContent_GetProperties(hexl)
if(NOT hexl_POPULATED)
FetchContent_Populate(hexl)
set(HEXL_DEBUG OFF) # Set to ON/OFF to toggle debugging
set(CMAKE_C_COMPILER ${CMAKE_C_COMPILER} CACHE STRING "" FORCE)
set(CMAKE_CXX_COMPILER ${CMAKE_CXX_COMPILER} CACHE STRING "" FORCE)
set(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX} CACHE STRING "" FORCE)
set(HEXL_DEBUG ${HEXL_DEBUG} CACHE BOOL "" FORCE)
set(HEXL_BENCHMARK OFF CACHE BOOL "" FORCE)
set(HEXL_EXPORT OFF CACHE BOOL "" FORCE)
set(HEXL_COVERAGE OFF CACHE BOOL "" FORCE)
set(HEXL_TESTING OFF CACHE BOOL "" FORCE)
set(HEXL_SHARED_LIB OFF CACHE BOOL "" FORCE)
set(EXCLUDE_FROM_ALL TRUE)
mark_as_advanced(BUILD_HEXL)
mark_as_advanced(INSTALL_HEXL)
mark_as_advanced(FETCHCONTENT_SOURCE_DIR_HEXL)
mark_as_advanced(FETCHCONTENT_UPDATES_DISCONNECTED_HEXL)
add_subdirectory(
${hexl_SOURCE_DIR}
EXCLUDE_FROM_ALL
)
endif()

6
cmake/SEALConfig.cmake.in
Просмотреть файл

@ -15,8 +15,9 @@
# SEAL_DEBUG : Set to non-zero value if library is compiled with extra debugging code (very slow!)
# SEAL_BUILD_TYPE : The build type (e.g., "Release" or "Debug")
# SEAL_USE_CXX17 : Set to non-zero value if library is compiled as C++17 instead of C++14
# SEAL_THROW_ON_TRANSPARENT_CIPHERTEXT : Set to non-zero value if library is compiled with
# SEAL_THROW_ON_TRANSPARENT_CIPHERTEXT enabled
# SEAL_ENFORCE_HE_STD_SECURITY : Set to non-zero value if library is compiled to enforce at least
# a 128-bit security level based on HomomorphicEncryption.org security estimates
# SEAL_USE_INTEL_HEXL: Set to non-zero value if library is compiled with Intel HEXL support
# SEAL_USE_MSGSL : Set to non-zero value if library is compiled with Microsoft GSL support
# SEAL_USE_ZLIB : Set to non-zero value if library is compiled with ZLIB support
# SEAL_USE_ZSTD : Set to non-zero value if library is compiled with Zstandard support
@ -51,6 +52,7 @@ set(SEAL_DEBUG @SEAL_DEBUG@)
set(SEAL_USE_CXX17 @SEAL_USE_CXX17@)
set(SEAL_THROW_ON_TRANSPARENT_CIPHERTEXT @SEAL_THROW_ON_TRANSPARENT_CIPHERTEXT@)
set(SEAL_USE_INTEL_HEXL @SEAL_USE_INTEL_HEXL@)
set(SEAL_USE_MSGSL @SEAL_USE_MSGSL@)
set(SEAL_USE_ZLIB @SEAL_USE_ZLIB@)
set(SEAL_USE_ZSTD @SEAL_USE_ZSTD@)

2
cmake/SEALMacros.cmake
Просмотреть файл

@ -110,4 +110,4 @@ macro(seal_set_secure_compile_options target scope)
target_link_options(${target} ${scope} /guard:cf)
target_link_options(${target} ${scope} /DYNAMICBASE)
endif()
endmacro()
endmacro()

2
native/src/seal/CMakeLists.txt
Просмотреть файл

@ -54,4 +54,4 @@ install(
)
add_subdirectory(util)
set(SEAL_SOURCE_FILES ${SEAL_SOURCE_FILES} PARENT_SCOPE)
set(SEAL_SOURCE_FILES ${SEAL_SOURCE_FILES} PARENT_SCOPE)

3
native/src/seal/util/CMakeLists.txt
Просмотреть файл

@ -45,6 +45,7 @@ install(
${CMAKE_CURRENT_LIST_DIR}/globals.h
${CMAKE_CURRENT_LIST_DIR}/hash.h
${CMAKE_CURRENT_LIST_DIR}/hestdparms.h
${CMAKE_CURRENT_LIST_DIR}/intel_seal_ext.h
${CMAKE_CURRENT_LIST_DIR}/iterator.h
${CMAKE_CURRENT_LIST_DIR}/locks.h
${CMAKE_CURRENT_LIST_DIR}/mempool.h
@ -67,4 +68,4 @@ install(
${SEAL_INCLUDES_INSTALL_DIR}/seal/util
)
set(SEAL_SOURCE_FILES ${SEAL_SOURCE_FILES} PARENT_SCOPE)
set(SEAL_SOURCE_FILES ${SEAL_SOURCE_FILES} PARENT_SCOPE)

7
native/src/seal/util/clang.h
Просмотреть файл

@ -13,6 +13,13 @@
// Read in config.h
#include "seal/util/config.h"
#ifdef SEAL_USE_ALIGN_64
#include <cstdlib>
#define SEAL_ALIGNED_ALLOC(alignment, size) \
((size) % (alignment) == 0) ? aligned_alloc((alignment), (size)) : malloc((size))
#define SEAL_ALIGNED_FREE(ptr) free(ptr)
#endif
// Are intrinsics enabled?
#ifdef SEAL_USE_INTRIN
#if defined(__aarch64__)

2
native/src/seal/util/config.h.in
Просмотреть файл

@ -13,6 +13,7 @@
// C++17 features
#cmakedefine SEAL_USE_STD_BYTE
#cmakedefine SEAL_USE_ALIGN_64
#cmakedefine SEAL_USE_SHARED_MUTEX
#cmakedefine SEAL_USE_IF_CONSTEXPR
#cmakedefine SEAL_USE_MAYBE_UNUSED
@ -42,3 +43,4 @@
#cmakedefine SEAL_USE_MSGSL
#cmakedefine SEAL_USE_ZLIB
#cmakedefine SEAL_USE_ZSTD
#cmakedefine SEAL_USE_INTEL_HEXL

2
native/src/seal/util/defines.h
Просмотреть файл

@ -268,4 +268,4 @@ namespace seal
// Conditionally select the former if true and the latter if false
// This is a temporary solution that generates constant-time code with all compilers on all platforms.
#define SEAL_COND_SELECT(cond, if_true, if_false) (cond ? if_true : if_false)
#define SEAL_COND_SELECT(cond, if_true, if_false) (cond ? if_true : if_false)

7
native/src/seal/util/gcc.h
Просмотреть файл

@ -19,6 +19,13 @@
#define SEAL_FORCE_INLINE inline __attribute__((always_inline))
#ifdef SEAL_USE_ALIGN_64
#include <cstdlib>
#define SEAL_ALIGNED_ALLOC(alignment, size) \
((size) % (alignment) == 0) ? std::aligned_alloc((alignment), (size)) : malloc((size))
#define SEAL_ALIGNED_FREE(ptr) free(ptr)
#endif
// Are intrinsics enabled?
#ifdef SEAL_USE_INTRIN
#if defined(__aarch64__)

105
native/src/seal/util/intel_seal_ext.h Normal file
Просмотреть файл

@ -0,0 +1,105 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license.
#pragma once
#ifdef SEAL_USE_INTEL_HEXL
#include "seal/util/locks.h"
#include <unordered_map>
#include "hexl/hexl.hpp"
namespace intel
{
namespace seal_ext
{
struct HashPair
{
template <class T1, class T2>
size_t operator()(const std::pair<T1, T2> &p) const
{
auto hash1 = std::hash<T1>{}(std::get<0>(p));
auto hash2 = std::hash<T2>{}(std::get<1>(p));
return hash_combine(hash1, hash2);
}
static size_t hash_combine(size_t lhs, size_t rhs)
{
lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
return lhs;
}
};
static std::unordered_map<std::pair<uint64_t, uint64_t>, intel::hexl::NTT, HashPair> ntt_cache_;
static seal::util::ReaderWriterLocker ntt_cache_locker_;
/**
Returns a HEXL NTT object corresponding to the given parameters.
@param[in] N The polynomial modulus degree
@param[in] modulus The modulus
@param[in] root The root of unity
*/
static intel::hexl::NTT get_ntt(size_t N, uint64_t modulus, uint64_t root)
{
std::pair<uint64_t, uint64_t> key{ N, modulus };
// Enable shared access of NTT already present
{
seal::util::ReaderLock reader_lock(ntt_cache_locker_.acquire_read());
auto ntt_it = ntt_cache_.find(key);
if (ntt_it != ntt_cache_.end())
{
return ntt_it->second;
}
}
// Deal with NTT not yet present
seal::util::WriterLock write_lock(ntt_cache_locker_.acquire_write());
// Check ntt_cache for value (maybe added by another thread)
auto ntt_it = ntt_cache_.find(key);
if (ntt_it == ntt_cache_.end())
{
ntt_it = ntt_cache_.emplace(std::move(key), intel::hexl::NTT(N, modulus, root)).first;
}
return ntt_it->second;
}
/**
Computes for forward negacyclic NTT from the given parameters.
@param[in,out] operand The data on which to compute the NTT.
@param[in] N The polynomial modulus degree
@param[in] modulus The modulus
@param[in] root The root of unity
@param[in] input_mod_factor Bounds the input data to the range [0, input_mod_factor * modulus)
@param[in] output_mod_factor Bounds the output data to the range [0, output_mod_factor * modulus)
*/
static void compute_forward_ntt(
seal::util::CoeffIter operand, size_t N, uint64_t modulus, uint64_t root, uint64_t input_mod_factor,
uint64_t output_mod_factor)
{
get_ntt(N, modulus, root).ComputeForward(operand, operand, input_mod_factor, output_mod_factor);
}
/**
Computes for inverse negacyclic NTT from the given parameters.
@param[in,out] operand The data on which to compute the NTT.
@param[in] N The polynomial modulus degree
@param[in] modulus The modulus
@param[in] root The root of unity
@param[in] input_mod_factor Bounds the input data to the range [0, input_mod_factor * modulus)
@param[in] output_mod_factor Bounds the output data to the range [0, output_mod_factor * modulus)
*/
static void compute_inverse_ntt(
seal::util::CoeffIter operand, size_t N, uint64_t modulus, uint64_t root, uint64_t input_mod_factor,
uint64_t output_mod_factor)
{
get_ntt(N, modulus, root).ComputeInverse(operand, operand, input_mod_factor, output_mod_factor);
}
} // namespace seal_ext
} // namespace intel
#endif

34
native/src/seal/util/mempool.cpp
Просмотреть файл

@ -40,7 +40,12 @@ namespace seal
allocation new_alloc;
try
{
#ifdef SEAL_USE_ALIGN_64
new_alloc.data_ptr = static_cast<seal_byte *>(
SEAL_ALIGNED_ALLOC(64, mul_safe(MemoryPool::first_alloc_count, item_byte_count_)));
#else
new_alloc.data_ptr = new seal_byte[mul_safe(MemoryPool::first_alloc_count, item_byte_count_)];
#endif
}
catch (const bad_alloc &)
{
@ -83,7 +88,11 @@ namespace seal
seal_memzero(alloc.data_ptr, curr_alloc_byte_count);
// Delete this allocation
#ifdef SEAL_USE_ALIGN_64
SEAL_ALIGNED_FREE(alloc.data_ptr);
#else
delete[] alloc.data_ptr;
#endif
}
}
else
@ -92,7 +101,11 @@ namespace seal
for (auto &alloc : allocs_)
{
// Delete this allocation
#ifdef SEAL_USE_ALIGN_64
SEAL_ALIGNED_FREE(alloc.data_ptr);
#else
delete[] alloc.data_ptr;
#endif
}
}
@ -137,7 +150,11 @@ namespace seal
try
{
#ifdef SEAL_USE_ALIGN_64
new_alloc.data_ptr = static_cast<seal_byte *>(SEAL_ALIGNED_ALLOC(64, new_alloc_byte_count));
#else
new_alloc.data_ptr = new seal_byte[new_alloc_byte_count];
#endif
}
catch (const bad_alloc &)
{
@ -178,7 +195,12 @@ namespace seal
allocation new_alloc;
try
{
#ifdef SEAL_USE_ALIGN_64
new_alloc.data_ptr = static_cast<seal_byte *>(
SEAL_ALIGNED_ALLOC(64, mul_safe(MemoryPool::first_alloc_count, item_byte_count_)));
#else
new_alloc.data_ptr = new seal_byte[mul_safe(MemoryPool::first_alloc_count, item_byte_count_)];
#endif
}
catch (const bad_alloc &)
{
@ -215,7 +237,11 @@ namespace seal
seal_memzero(alloc.data_ptr, curr_alloc_byte_count);
// Delete this allocation
#ifdef SEAL_USE_ALIGN_64
SEAL_ALIGNED_FREE(alloc.data_ptr);
#else
delete[] alloc.data_ptr;
#endif
}
}
else
@ -224,7 +250,11 @@ namespace seal
for (auto &alloc : allocs_)
{
// Delete this allocation
#ifdef SEAL_USE_ALIGN_64
SEAL_ALIGNED_FREE(alloc.data_ptr);
#else
delete[] alloc.data_ptr;
#endif
}
}
@ -264,7 +294,11 @@ namespace seal
try
{
#ifdef SEAL_USE_ALIGN_64
new_alloc.data_ptr = static_cast<seal_byte *>(SEAL_ALIGNED_ALLOC(64, new_alloc_byte_count));
#else
new_alloc.data_ptr = new seal_byte[new_alloc_byte_count];
#endif
}
catch (const bad_alloc &)
{

16
native/src/seal/util/msvc.h
Просмотреть файл

@ -34,23 +34,27 @@
#else
#ifdef SEAL_USE_IF_CONSTEXPR
#pragma message("Disabling `if constexpr` based on _MSVC_LANG value \
" SEAL_STRINGIZE(_MSVC_LANG) ": undefining SEAL_USE_IF_CONSTEXPR")
#pragma message("Disabling `if constexpr` based on _MSVC_LANG value " SEAL_STRINGIZE( \
_MSVC_LANG) ": undefining SEAL_USE_IF_CONSTEXPR")
#undef SEAL_USE_IF_CONSTEXPR
#endif
#ifdef SEAL_USE_MAYBE_UNUSED
#pragma message("Disabling `[[maybe_unused]]` based on _MSVC_LANG value \
" SEAL_STRINGIZE(_MSVC_LANG) ": undefining SEAL_USE_MAYBE_UNUSED")
#pragma message("Disabling `[[maybe_unused]]` based on _MSVC_LANG value " SEAL_STRINGIZE( \
_MSVC_LANG) ": undefining SEAL_USE_MAYBE_UNUSED")
#undef SEAL_USE_MAYBE_UNUSED
#endif
#ifdef SEAL_USE_NODISCARD
#pragma message("Disabling `[[nodiscard]]` based on _MSVC_LANG value " \
SEAL_STRINGIZE(_MSVC_LANG) ": undefining SEAL_USE_NODISCARD")
#pragma message("Disabling `[[nodiscard]]` based on _MSVC_LANG value " SEAL_STRINGIZE( \
_MSVC_LANG) ": undefining SEAL_USE_NODISCARD")
#undef SEAL_USE_NODISCARD
#endif
#endif
#ifdef SEAL_USE_ALIGN_64
#define SEAL_ALIGNED_ALLOC(alignment, size) _aligned_malloc((size), (alignment))
#define SEAL_ALIGNED_FREE(ptr) _aligned_free(ptr)
#endif
// X64

19
native/src/seal/util/ntt.cpp
Просмотреть файл

@ -6,6 +6,10 @@
#include "seal/util/uintarithsmallmod.h"
#include <algorithm>
#ifdef SEAL_USE_INTEL_HEXL
#include "hexl/hexl.hpp"
#endif
using namespace std;
namespace seal
@ -173,15 +177,30 @@ namespace seal
void ntt_negacyclic_harvey_lazy(CoeffIter operand, const NTTTables &tables)
{
#ifdef SEAL_USE_INTEL_HEXL
size_t N = size_t(1) << tables.coeff_count_power();
uint64_t p = tables.modulus().value();
uint64_t root = tables.get_root();
intel::seal_ext::compute_forward_ntt(operand, N, p, root, 4, 4);
#else
tables.ntt_handler().transform_to_rev(
operand.ptr(), tables.coeff_count_power(), tables.get_from_root_powers());
#endif
}
void inverse_ntt_negacyclic_harvey_lazy(CoeffIter operand, const NTTTables &tables)
{
#ifdef SEAL_USE_INTEL_HEXL
size_t N = size_t(1) << tables.coeff_count_power();
uint64_t p = tables.modulus().value();
uint64_t root = tables.get_root();
intel::seal_ext::compute_inverse_ntt(operand, N, p, root, 2, 2);
#else
MultiplyUIntModOperand inv_degree_modulo = tables.inv_degree_modulo();
tables.ntt_handler().transform_from_rev(
operand.ptr(), tables.coeff_count_power(), tables.get_from_inv_root_powers(), &inv_degree_modulo);
#endif
}
} // namespace util
} // namespace seal

21
native/src/seal/util/ntt.h
Просмотреть файл

@ -13,6 +13,10 @@
#include "seal/util/uintcore.h"
#include <stdexcept>
#ifdef SEAL_USE_INTEL_HEXL
#include "seal/util/intel_seal_ext.h"
#endif
namespace seal
{
namespace util
@ -230,8 +234,14 @@ namespace seal
inline void ntt_negacyclic_harvey(CoeffIter operand, const NTTTables &tables)
{
ntt_negacyclic_harvey_lazy(operand, tables);
#ifdef SEAL_USE_INTEL_HEXL
size_t N = size_t(1) << tables.coeff_count_power();
uint64_t p = tables.modulus().value();
uint64_t root = tables.get_root();
intel::seal_ext::compute_forward_ntt(operand, N, p, root, 4, 1);
#else
ntt_negacyclic_harvey_lazy(operand, tables);
// Finally maybe we need to reduce every coefficient modulo q, but we
// know that they are in the range [0, 4q).
// Since word size is controlled this is fast.
@ -250,6 +260,7 @@ namespace seal
I -= modulus;
}
});
#endif
}
inline void ntt_negacyclic_harvey(RNSIter operand, std::size_t coeff_modulus_size, ConstNTTTablesIter tables)
@ -324,8 +335,13 @@ namespace seal
inline void inverse_ntt_negacyclic_harvey(CoeffIter operand, const NTTTables &tables)
{
#ifdef SEAL_USE_INTEL_HEXL
size_t N = size_t(1) << tables.coeff_count_power();
uint64_t p = tables.modulus().value();
uint64_t root = tables.get_root();
intel::seal_ext::compute_inverse_ntt(operand, N, p, root, 2, 1);
#else
inverse_ntt_negacyclic_harvey_lazy(operand, tables);
std::uint64_t modulus = tables.modulus().value();
std::size_t n = std::size_t(1) << tables.coeff_count_power();
@ -338,6 +354,7 @@ namespace seal
I -= modulus;
}
});
#endif
}
inline void inverse_ntt_negacyclic_harvey(

13
native/src/seal/util/polyarithsmallmod.cpp
Просмотреть файл

@ -5,6 +5,10 @@
#include "seal/util/uintarith.h"
#include "seal/util/uintcore.h"
#ifdef SEAL_USE_INTEL_HEXL
#include "hexl/hexl.hpp"
#endif
using namespace std;
namespace seal
@ -85,10 +89,15 @@ namespace seal
throw invalid_argument("modulus");
}
#endif
#ifdef SEAL_USE_INTEL_HEXL
intel::hexl::EltwiseFMAMod(&result[0], &poly[0], scalar.operand, nullptr, coeff_count, modulus.value(), 8);
#else
SEAL_ITERATE(iter(poly, result), coeff_count, [&](auto I) {
const uint64_t x = get<0>(I);
get<1>(I) = multiply_uint_mod(x, scalar, modulus);
});
#endif
}
void dyadic_product_coeffmod(
@ -117,6 +126,9 @@ namespace seal
throw invalid_argument("modulus");
}
#endif
#ifdef SEAL_USE_INTEL_HEXL
intel::hexl::EltwiseMultMod(&result[0], &operand1[0], &operand2[0], coeff_count, modulus.value(), 4);
#else
const uint64_t modulus_value = modulus.value();
const uint64_t const_ratio_0 = modulus.const_ratio()[0];
const uint64_t const_ratio_1 = modulus.const_ratio()[1];
@ -145,6 +157,7 @@ namespace seal
// Claim: One more subtraction is enough
get<2>(I) = SEAL_COND_SELECT(tmp3 >= modulus_value, tmp3 - modulus_value, tmp3);
});
#endif
}
uint64_t poly_infty_norm_coeffmod(ConstCoeffIter operand, size_t coeff_count, const Modulus &modulus)

10
native/src/seal/util/polyarithsmallmod.h
Просмотреть файл

@ -14,6 +14,10 @@
#include <cstdint>
#include <stdexcept>
#ifdef SEAL_USE_INTEL_HEXL
#include "hexl/hexl.hpp"
#endif
namespace seal
{
namespace util
@ -201,6 +205,11 @@ namespace seal
}
#endif
const uint64_t modulus_value = modulus.value();
#ifdef SEAL_USE_INTEL_HEXL
intel::hexl::EltwiseAddMod(&result[0], &operand1[0], &operand2[0], coeff_count, modulus_value);
#else
SEAL_ITERATE(iter(operand1, operand2, result), coeff_count, [&](auto I) {
#ifdef SEAL_DEBUG
if (get<0>(I) >= modulus_value)
@ -215,6 +224,7 @@ namespace seal
std::uint64_t sum = get<0>(I) + get<1>(I);
get<2>(I) = SEAL_COND_SELECT(sum >= modulus_value, sum - modulus_value, sum);
});
#endif
}
inline void add_poly_coeffmod(