Fix threading issue with timers (homenc#350)

Co-Authored-By: Jack L Crawford <[email protected]>
Co-Authored-By: Enrico Steffinlongo <[email protected]>

Author: 3 people

OLD_INSTALL.txt

@@ -112,15 +112,12 @@ library, currently these are:
      this may take a significant amount of memory.
 
 
-   -DFHE_THREADS  tells HElib to enable generic multithreading capabilities;
-                  must be used with a thread-enabled NTL and the -pthread
-                  flag should be passed to gcc
+   -DHELIB_THREADS  tells HElib to enable generic multithreading capabilities;
+                    must be used with a thread-enabled NTL and the -pthread
+                    flag should be passed to gcc
 
-   -DFHE_DCRT_THREADS  tells HElib to use a multithreading strategy at the
-                       DoubleCRT level; requires -DFHE_THREADS (see above)
-
-   -DFHE_BOOT_THREADS  tells HElib to use a multithreading strategy for
-                       bootstrapping; requires -DFHE_THREADS (see above)
+   -DHELIB_BOOT_THREADS  tells HElib to use a multithreading strategy for
+                         bootstrapping; requires -DHELIB_THREADS (see above) 
 
 
   -DDEBUG_PRINTOUT

include/helib/ArgMap.h

@@ -537,18 +537,15 @@ ArgMap& ArgMap::arg(const std::string& name, T& value, const std::string& doc)
 
 template <typename T>
 ArgMap& ArgMap::arg(const std::string& name,
-            T& value,
-            const std::string& doc,
-            const char* info)
+                    T& value,
+                    const std::string& doc,
+                    const char* info)
 {
   arg(name, value);
 
   docVec.push_back({name, doc, required_mode});
   if (info != nullptr && info[0] != '\0')
-    std::get<1>(docVec.back())
-        .append(" [ default=")
-        .append(info)
-        .append(" ]");
+    std::get<1>(docVec.back()).append(" [ default=").append(info).append(" ]");
 
   return *this;
 }

include/helib/CModulus.h

@@ -77,7 +77,7 @@ class Cmodulus
   void privateInit(const PAlgebra&, long rt);
 
 public:
-#ifdef FHE_OPENCL
+#ifdef HELIB_OPENCL
   SmartPtr<AltFFTPrimeInfo> altFFTInfo;
   // We need to allow copying...the underlying object
   // is immutable

include/helib/EncryptedArray.h

@@ -33,7 +33,8 @@ typedef std::complex<double> cx_double;
 
 // DIRT: we're using undocumented NTL interfaces here
 //   also...this probably should be defined in NTL, anyway....
-#define FHE_MORE_UNWRAPARGS(n) NTL_SEPARATOR_##n NTL_REPEATER_##n(NTL_UNWRAPARG)
+#define HELIB_MORE_UNWRAPARGS(n)                                               \
+  NTL_SEPARATOR_##n NTL_REPEATER_##n(NTL_UNWRAPARG)
 
 // these are used to implement PlaintextArray stuff routines
 

include/helib/fhe_stats.h

@@ -10,8 +10,8 @@
  * limitations under the License. See accompanying LICENSE file.
  */
 
-#ifndef FHE_STATS_H
-#define FHE_STATS_H
+#ifndef HELIB_STATS_H
+#define HELIB_STATS_H
 
 #include <vector>
 #include <iostream>
@@ -35,15 +35,15 @@ struct fhe_stats_record
   void save(double val);
 };
 
-#define FHE_STATS_UPDATE(name, val)                                            \
+#define HELIB_STATS_UPDATE(name, val)                                          \
   do {                                                                         \
     if (fhe_stats) {                                                           \
       static fhe_stats_record _local_stats_record(name);                       \
       _local_stats_record.update(val);                                         \
     }                                                                          \
   } while (0)
 
-#define FHE_STATS_SAVE(name, val)                                              \
+#define HELIB_STATS_SAVE(name, val)                                            \
   do {                                                                         \
     if (fhe_stats) {                                                           \
       static fhe_stats_record _local_stats_record(name);                       \

include/helib/keySwitching.h

@@ -134,12 +134,12 @@ std::ostream& operator<<(std::ostream& str, const KeySwitch& matrix);
 
 //! @brief Constant defining threshold above which a baby-set/giant-step
 //! strategy is used
-#define FHE_KEYSWITCH_THRESH (50)
+#define HELIB_KEYSWITCH_THRESH (50)
 
 //! @brief Constant defining threshold above which a single
-//! giant step matrix is added even in FHE_KSS_MIN mode.
+//! giant step matrix is added even in HELIB_KSS_MIN mode.
 //! This helps in the matmul routines.
-#define FHE_KEYSWITCH_MIN_THRESH (8)
+#define HELIB_KEYSWITCH_MIN_THRESH (8)
 
 //! @brief Function that returns number of baby steps.  Used to keep
 //! this and matmul routines "in sync".
@@ -157,7 +157,7 @@ void addFewMatrices(SecKey& sKey, long keyID = 0);
 //! For a generator g whose order is larger than bound, generate only enough
 //! matrices for the giant-step/baby-step procedures (2*sqrt(ord(g))of them).
 void addSome1DMatrices(SecKey& sKey,
-                       long bound = FHE_KEYSWITCH_THRESH,
+                       long bound = HELIB_KEYSWITCH_THRESH,
                        long keyID = 0);
 
 //! @brief Generate all matrices s(X^{g^i})->s(X) for generators g of
@@ -169,7 +169,7 @@ void addBSGS1DMatrices(SecKey& sKey, long keyID = 0);
 
 //! Generate all/some Frobenius matrices of the form s(X^{p^i})->s(X)
 void addSomeFrbMatrices(SecKey& sKey,
-                        long bound = FHE_KEYSWITCH_THRESH,
+                        long bound = HELIB_KEYSWITCH_THRESH,
                         long keyID = 0);
 
 void addFrbMatrices(SecKey& sKey, long keyID = 0);

include/helib/keys.h

@@ -24,16 +24,16 @@
 
 namespace helib {
 
-#define FHE_KSS_UNKNOWN (0)
+#define HELIB_KSS_UNKNOWN (0)
 // unknown KS strategy
 
-#define FHE_KSS_FULL (1)
+#define HELIB_KSS_FULL (1)
 // all KS matrices
 
-#define FHE_KSS_BSGS (2)
+#define HELIB_KSS_BSGS (2)
 // baby step/giant step strategy
 
-#define FHE_KSS_MIN (3)
+#define HELIB_KSS_MIN (3)
 // minimal strategy (for g_i, and for g_i^{-ord_i} for bad dims)
 
 void writePubKeyBinary(std::ostream& str, const PubKey& pk);

include/helib/multicore.h

@@ -17,30 +17,33 @@
 #ifndef HELIB_MULTICORE_H
 #define HELIB_MULTICORE_H
 
-#ifdef FHE_THREADS
+#ifdef HELIB_THREADS
 
 #include <atomic>
 #include <mutex>
 
 namespace helib {
 
-#define FHE_atomic_long std::atomic_long
-#define FHE_atomic_ulong std::atomic_ulong
+#define HELIB_atomic_long std::atomic_long
+#define HELIB_atomic_ulong std::atomic_ulong
 
-#define FHE_MUTEX_TYPE std::mutex
-#define FHE_MUTEX_GUARD(mx) std::lock_guard<std::mutex> _lock##__LINE__(mx)
+#define HELIB_MUTEX_TYPE std::mutex
+#define HELIB_MUTEX_GUARD(mx) std::lock_guard<std::mutex> _lock##__LINE__(mx)
+
+} // namespace helib
 
 #else
 
 namespace helib {
 
-#define FHE_atomic_long long
-#define FHE_atomic_ulong unsigned long
+#define HELIB_atomic_long long
+#define HELIB_atomic_ulong unsigned long
+
+#define HELIB_MUTEX_TYPE int
+#define HELIB_MUTEX_GUARD(mx) ((void)mx)
 
-#define FHE_MUTEX_TYPE int
-#define FHE_MUTEX_GUARD(mx) ((void)mx)
+} // namespace helib
 
-#endif
-}
+#endif // ifdef HELIB_THREADS
 
 #endif // ifndef HELIB_MULTICORE_H

include/helib/recryption.h

@@ -134,7 +134,7 @@ class ThinRecryptData : public RecryptData
             bool minimal = false);
 };
 
-#define FHE_MIN_CAP_FRAC (2.0 / 3.0)
+#define HELIB_MIN_CAP_FRAC (2.0 / 3.0)
 // Used in calculation of "min capacity".
 // This could be set to 1.0, but just to be on the safe side,
 // it is set to 2/3.  If we did set it to 1, the min capacity

include/helib/timing.h

@@ -15,8 +15,8 @@
  *
  * This module contains some utility functions for measuring the time that
  * various methods take to execute. To use it, we insert the macro
- * FHE_TIMER_START at the beginning of the method(s) that we want to time and
- * FHE_TIMER_STOP at the end, then the main program needs to call the function
+ * HELIB_TIMER_START at the beginning of the method(s) that we want to time and
+ * HELIB_TIMER_STOP at the end, then the main program needs to call the function
  * setTimersOn() to activate the timers and setTimersOff() to pause them.
  * To obtain the value of a given timer (in seconds), the application can
  * use the function getTime4func(const char *fncName), and the function
@@ -48,8 +48,8 @@ class FHEtimer
   const char* loc;
 
   // THREADS: these need to be atomic
-  FHE_atomic_ulong counter;
-  FHE_atomic_long numCalls;
+  HELIB_atomic_ulong counter;
+  HELIB_atomic_long numCalls;
 
   FHEtimer(const char* _name, const char* _loc) :
       name(_name), loc(_loc), counter(0), numCalls(0)
@@ -108,24 +108,24 @@ class auto_timer
 // NOTE: the STOP functions below are not really needed,
 // but are provided for backward compatibility
 
-#define FHE_STRINGIFY(x) #x
-#define FHE_TOSTRING(x) FHE_STRINGIFY(x)
-#define FHE_AT __FILE__ ":" FHE_TOSTRING(__LINE__)
+#define HELIB_STRINGIFY(x) #x
+#define HELIB_TOSTRING(x) HELIB_STRINGIFY(x)
+#define HELIB_AT __FILE__ ":" HELIB_TOSTRING(__LINE__)
 
-#define FHE_stringify_aux(s) #s
-#define FHE_stringify(s) FHE_stringify_aux(s)
+#define HELIB_stringify_aux(s) #s
+#define HELIB_stringify(s) HELIB_stringify_aux(s)
 
-#define FHE_TIMER_START                                                        \
-  static helib::FHEtimer _local_timer(__func__, FHE_AT);                       \
+#define HELIB_TIMER_START                                                      \
+  static helib::FHEtimer _local_timer(__func__, HELIB_AT);                     \
   helib::auto_timer _local_auto_timer(&_local_timer)
 
-#define FHE_TIMER_STOP _local_auto_timer.stop()
+#define HELIB_TIMER_STOP _local_auto_timer.stop()
 
-#define FHE_NTIMER_START(n)                                                    \
-  static helib::FHEtimer _named_local_timer##n(#n, FHE_AT);                    \
+#define HELIB_NTIMER_START(n)                                                  \
+  static helib::FHEtimer _named_local_timer##n(#n, HELIB_AT);                  \
   helib::auto_timer _named_local_auto_timer##n(&_named_local_timer##n)
 
-#define FHE_NTIMER_STOP(n) _named_local_auto_timer##n.stop();
+#define HELIB_NTIMER_STOP(n) _named_local_auto_timer##n.stop();
 
 } // namespace helib