Using thread pool

.clang-format

@@ -5,3 +5,5 @@ BasedOnStyle: Google
 Language: Cpp
 DerivePointerAlignment: false
 PointerAlignment: Left
+# Let cpplint enforce header order
+SortIncludes: true

CMakeLists.txt

@@ -38,6 +38,8 @@ else()
   set(HEXL_DEBUG OFF)
 endif()
 
+
+
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
@@ -55,17 +57,35 @@ set(CMAKE_INSTALL_RPATH "\$ORIGIN")
 #------------------------------------------------------------------------------
 
 option(HEXL_BENCHMARK "Enable benchmarking" ON)
-option(HEXL_COVERAGE "Enables coverage for unit tests" OFF)
+option(HEXL_COVERAGE "Enable coverage for unit tests" OFF)
 option(HEXL_DOCS "Enable documentation building" OFF)
 option(HEXL_EXPERIMENTAL "Enable experimental features" OFF)
 option(HEXL_SHARED_LIB "Generate a shared library" OFF)
-option(HEXL_TESTING "Enables unit-tests" ON)
+option(HEXL_TESTING "Enable unit-tests" ON)
 option(HEXL_TREAT_WARNING_AS_ERROR "Treat all compile-time warnings as errors" OFF)
+option(HEXL_MULTI_THREADING "Enabling multithreading" ON)
 
 if (NOT HEXL_FPGA_COMPATIBILITY)
     set(HEXL_FPGA_COMPATIBILITY "0" CACHE INTERNAL "Set FPGA compatibility mask" FORCE)
 endif()
 
+
+if (HEXL_MULTI_THREADING STREQUAL "ON")
+  include(ProcessorCount)
+  ProcessorCount(N)
+  if(NOT N EQUAL 0)
+    if(N GREATER 2)  # Minimum for testing
+      message(STATUS "ProcessorCount: ${N}")
+    else()
+      message(WARNING "Small Processor Count.")
+      set(HEXL_MULTI_THREADING OFF)
+    endif()
+  else()
+    message(WARNING "Not able to get Processor Count.")
+    set(HEXL_MULTI_THREADING OFF)
+  endif()
+endif()
+
 message(STATUS "CMAKE_BUILD_TYPE:              ${CMAKE_BUILD_TYPE}")
 message(STATUS "CMAKE_C_COMPILER:              ${CMAKE_C_COMPILER}")
 message(STATUS "CMAKE_CXX_COMPILER:            ${CMAKE_CXX_COMPILER}")
@@ -78,6 +98,7 @@ message(STATUS "HEXL_SHARED_LIB:               ${HEXL_SHARED_LIB}")
 message(STATUS "HEXL_TESTING:                  ${HEXL_TESTING}")
 message(STATUS "HEXL_TREAT_WARNING_AS_ERROR:   ${HEXL_TREAT_WARNING_AS_ERROR}")
 message(STATUS "HEXL_FPGA_COMPATIBILITY:       ${HEXL_FPGA_COMPATIBILITY}")
+message(STATUS "HEXL_MULTI_THREADING:          ${HEXL_MULTI_THREADING}")
 
 hexl_check_compiler_version()
 hexl_add_compiler_definition()

README.md

@@ -127,6 +127,7 @@ For convenience, they are listed below:
 | HEXL_DOCS                     | ON / OFF | OFF     | Set to ON to enable building of documentation               |
 | HEXL_TESTING                  | ON / OFF | ON      | Set to ON to enable building of unit-tests                  |
 | HEXL_TREAT_WARNING_AS_ERROR   | ON / OFF | OFF     | Set to ON to treat all warnings as error                    |
+| HEXL_MULTI_THREADING          | ON / OFF | ON      | Set to ON to enable multithreading                          |
 
 ### Compiling Intel HE Acceleration Library
 To compile Intel HE Acceleration Library from source code, first clone the
@@ -262,7 +263,41 @@ documentation](https://github.com/amrayn/easyloggingpp#application-arguments)
 for more details.
 
 ## Threading
-Intel HE Acceleration Library is single-threaded and thread-safe.
+Intel HE Acceleration Library is multi-threaded and thread-safe.
+`-DHEXL_MULTI_THREADING=OFF` can be used to disable multithreading.
+
+**Note**, when using the Intel HE Acceleration Library from a multi-threaded
+application only one top level thread at the time will have access to the
+thread pool. For any other top level thread the use of the thread pool will
+be bypassed to be executed sequentially.
+
+By default, the thread pool will consist of 8 threads, but a different number
+of threads can be set by using the following environment variable.
+
+Example (in bash):
+```bash
+export HEXL_NUM_THREADS=<integer>
+```
+
+If the default value or `HEXL_NUM_THREADS` are bigger than C++'s
+`N = hardware_concurrency()` then the thread pool will consist of
+`N` threads only. In the case CMake's `ProcessorCount` is less than 3 then
+the thread pool will be automatically disabled.
+
+### NTT's recursive parallelization
+By default, the NTT will run two levels of parallel recursion. A different
+number of levels can be set by using the following environment variable.
+
+Example (in bash):
+```bash
+export HEXL_NTT_PARALLEL_DEPTH=<integer>
+```
+
+Independently of the parallel depth value the recursive parallelization
+will be limited by the total number of threads in the thread pool.
+
+**Note**, NTT's recursive parallelization is controlled separately of
+loop parallelization as the performance of both methods do not scale the same.
 
 # Community Adoption
 

benchmark/CMakeLists.txt

@@ -10,6 +10,7 @@ set(SRC main.cpp
     bench-eltwise-mult-mod.cpp
     bench-eltwise-sub-mod.cpp
     bench-eltwise-reduce-mod.cpp
+    bench-thread-pool.cpp
     )
 
 if (HEXL_EXPERIMENTAL)

benchmark/bench-eltwise-add-mod.cpp

@@ -36,7 +36,11 @@ BENCHMARK(BM_EltwiseVectorVectorAddModNative)
     ->Unit(benchmark::kMicrosecond)
     ->Args({1024})
     ->Args({4096})
-    ->Args({16384});
+    ->Args({16384})
+    ->Args({32768})
+    ->Args({65536})
+    ->Args({131072})
+    ->Args({262144});
 
 //=================================================================
 
@@ -61,7 +65,11 @@ BENCHMARK(BM_EltwiseVectorVectorAddModAVX512)
     ->Unit(benchmark::kMicrosecond)
     ->Args({1024})
     ->Args({4096})
-    ->Args({16384});
+    ->Args({16384})
+    ->Args({32768})
+    ->Args({65536})
+    ->Args({131072})
+    ->Args({262144});
 #endif
 
 //=================================================================
@@ -85,7 +93,11 @@ BENCHMARK(BM_EltwiseVectorScalarAddModNative)
     ->Unit(benchmark::kMicrosecond)
     ->Args({1024})
     ->Args({4096})
-    ->Args({16384});
+    ->Args({16384})
+    ->Args({32768})
+    ->Args({65536})
+    ->Args({131072})
+    ->Args({262144});
 
 //=================================================================
 
@@ -110,7 +122,11 @@ BENCHMARK(BM_EltwiseVectorScalarAddModAVX512)
     ->Unit(benchmark::kMicrosecond)
     ->Args({1024})
     ->Args({4096})
-    ->Args({16384});
+    ->Args({16384})
+    ->Args({32768})
+    ->Args({65536})
+    ->Args({131072})
+    ->Args({262144});
 #endif
 
 }  // namespace hexl

benchmark/bench-eltwise-cmp-add.cpp

@@ -37,7 +37,11 @@ BENCHMARK(BM_EltwiseCmpAddNative)
     ->Unit(benchmark::kMicrosecond)
     ->Args({1024})
     ->Args({4096})
-    ->Args({16384});
+    ->Args({16384})
+    ->Args({32768})
+    ->Args({65536})
+    ->Args({131072})
+    ->Args({262144});
 
 //=================================================================
 
@@ -61,7 +65,11 @@ BENCHMARK(BM_EltwiseCmpAddAVX512)
     ->Unit(benchmark::kMicrosecond)
     ->Args({1024})
     ->Args({4096})
-    ->Args({16384});
+    ->Args({16384})
+    ->Args({32768})
+    ->Args({65536})
+    ->Args({131072})
+    ->Args({262144});
 #endif
 
 }  // namespace hexl

benchmark/bench-eltwise-cmp-sub-mod.cpp

@@ -36,7 +36,11 @@ BENCHMARK(BM_EltwiseCmpSubModNative)
     ->Unit(benchmark::kMicrosecond)
     ->Args({1024})
     ->Args({4096})
-    ->Args({16384});
+    ->Args({16384})
+    ->Args({32768})
+    ->Args({65536})
+    ->Args({131072})
+    ->Args({262144});
 
 //=================================================================
 
@@ -59,7 +63,11 @@ BENCHMARK(BM_EltwiseCmpSubModAVX512_64)
     ->Unit(benchmark::kMicrosecond)
     ->Args({1024})
     ->Args({4096})
-    ->Args({16384});
+    ->Args({16384})
+    ->Args({32768})
+    ->Args({65536})
+    ->Args({131072})
+    ->Args({262144});
 #endif
 
 //=================================================================

benchmark/bench-eltwise-fma-mod.cpp

@@ -37,7 +37,8 @@ static void BM_EltwiseFMAModAddNative(benchmark::State& state) {  //  NOLINT
 
 BENCHMARK(BM_EltwiseFMAModAddNative)
     ->Unit(benchmark::kMicrosecond)
-    ->ArgsProduct({{1024, 4096, 16384}, {false, true}});
+    ->ArgsProduct({{1024, 4096, 16384, 32768, 65536, 131072, 262144},
+                   {false, true}});
 
 //=================================================================
 
@@ -62,7 +63,8 @@ static void BM_EltwiseFMAModAVX512DQ(benchmark::State& state) {  //  NOLINT
 
 BENCHMARK(BM_EltwiseFMAModAVX512DQ)
     ->Unit(benchmark::kMicrosecond)
-    ->ArgsProduct({{1024, 4096, 16384}, {false, true}});
+    ->ArgsProduct({{1024, 4096, 16384, 32768, 65536, 131072, 262144},
+                   {false, true}});
 #endif
 
 //=================================================================
@@ -87,7 +89,8 @@ static void BM_EltwiseFMAModAVX512IFMA(benchmark::State& state) {  //  NOLINT
 
 BENCHMARK(BM_EltwiseFMAModAVX512IFMA)
     ->Unit(benchmark::kMicrosecond)
-    ->ArgsProduct({{1024, 4096, 16384}, {false, true}});
+    ->ArgsProduct({{1024, 4096, 16384, 32768, 65536, 131072, 262144},
+                   {false, true}});
 
 #endif
 

benchmark/bench-eltwise-mult-mod.cpp

@@ -38,7 +38,9 @@ static void BM_EltwiseMultMod(benchmark::State& state) {  //  NOLINT
 
 BENCHMARK(BM_EltwiseMultMod)
     ->Unit(benchmark::kMicrosecond)
-    ->ArgsProduct({{1024, 4096, 16384}, {48, 60}, {1, 2, 4}});
+    ->ArgsProduct({{1024, 4096, 16384, 32768, 65536, 131072, 262144},
+                   {48, 60},
+                   {1, 2, 4}});
 
 //=================================================================
 
@@ -61,7 +63,11 @@ BENCHMARK(BM_EltwiseMultModNative)
     ->Unit(benchmark::kMicrosecond)
     ->Args({1024})
     ->Args({4096})
-    ->Args({16384});
+    ->Args({16384})
+    ->Args({32768})
+    ->Args({65536})
+    ->Args({131072})
+    ->Args({262144});
 
 //=================================================================
 
@@ -97,7 +103,8 @@ static void BM_EltwiseMultModAVX512Float(benchmark::State& state) {  //  NOLINT
 
 BENCHMARK(BM_EltwiseMultModAVX512Float)
     ->Unit(benchmark::kMicrosecond)
-    ->ArgsProduct({{1024, 4096, 16384}, {1, 2, 4}});
+    ->ArgsProduct({{1024, 4096, 16384, 32768, 65536, 131072, 262144},
+                   {1, 2, 4}});
 #endif
 
 //=================================================================
@@ -134,7 +141,8 @@ static void BM_EltwiseMultModAVX512DQInt(benchmark::State& state) {  //  NOLINT
 
 BENCHMARK(BM_EltwiseMultModAVX512DQInt)
     ->Unit(benchmark::kMicrosecond)
-    ->ArgsProduct({{1024, 4096, 16384}, {1, 2, 4}});
+    ->ArgsProduct({{1024, 4096, 16384, 32768, 65536, 131072, 262144},
+                   {1, 2, 4}});
 #endif
 
 #ifdef HEXL_HAS_AVX512IFMA
@@ -172,7 +180,8 @@ static void BM_EltwiseMultModAVX512IFMAInt(
 
 BENCHMARK(BM_EltwiseMultModAVX512IFMAInt)
     ->Unit(benchmark::kMicrosecond)
-    ->ArgsProduct({{1024, 4096, 16384}, {1, 2, 4}});
+    ->ArgsProduct({{1024, 4096, 16384, 32768, 65536, 131072, 262144},
+                   {1, 2, 4}});
 #endif
 
 //=================================================================
@@ -216,7 +225,8 @@ static void BM_EltwiseMultModMontAVX512IFMAIntEConv(
 
 BENCHMARK(BM_EltwiseMultModMontAVX512IFMAIntEConv)
     ->Unit(benchmark::kMicrosecond)
-    ->ArgsProduct({{1024, 4096, 16384}, {1, 2, 4}});
+    ->ArgsProduct({{1024, 4096, 16384, 32768, 65536, 131072, 262144},
+                   {1, 2, 4}});
 
 #endif