Saving current progress.

CMakeLists.txt

@@ -9,10 +9,10 @@ elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
 endif ()
 
 if(DEFINED CMAKE_BUILD_TYPE)
-  if(${CMAKE_BUILD_TYPE} STREQUAL "Debug")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -ggdb")
-    set(BOOST_FORCEINLINE "OFF") # improves debugging traces
-  endif()
+  #if(${CMAKE_BUILD_TYPE} STREQUAL "Debug")
+    #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -ggdb")
+    #set(BOOST_FORCEINLINE "OFF") # improves debugging traces
+  #endif()
 endif()
 
 option(SANITIZE "Build sanitizers" FALSE)

crypto3/libs/math/include/nil/crypto3/math/domains/basic_radix2_domain.hpp

@@ -86,10 +86,10 @@ namespace nil {
                         }
                     }
 
-                    /*if (!fft_cache) {
+                    if (!fft_cache) {
                         create_fft_cache();
-                    }*/
-                    detail::basic_radix2_fft_cached<FieldType>(a, omega);
+                    }
+                    detail::basic_radix2_fft_cached<FieldType>(a, fft_cache->first);
                 }
 
                 void inverse_fft(std::vector<value_type> &a) override {
@@ -101,10 +101,10 @@ namespace nil {
                         }
                     }
 
-                    /*if (!fft_cache) {
+                    if (!fft_cache) {
                         create_fft_cache();
-                    }*/
-                    detail::basic_radix2_fft_cached<FieldType>(a, omega.inversed());
+                    }
+                    detail::basic_radix2_fft_cached<FieldType>(a, fft_cache->second);
 
                     const field_value_type sconst = field_value_type(a.size()).inversed();
                     for (std::size_t i = 0; i < a.size(); ++i) {

crypto3/libs/multiprecision/include/nil/crypto3/multiprecision/detail/big_uint/big_uint_impl.hpp

@@ -111,7 +111,7 @@ namespace nil::crypto3::multiprecision {
         // Assignment
 
         template<typename T,
-                 std::enable_if_t<std::is_integral_v<T> && std::is_unsigned_v<T>, int> = 0>
+                 std::enable_if_t<std::is_integral_v<T> && std::is_unsigned_v<T> || std::is_same_v<T, unsigned __int128>, int> = 0>
         constexpr void do_assign_integral(const T& a) noexcept {
             if constexpr (sizeof(T) <= sizeof(limb_type)) {
                 this->limbs()[0] = a;
@@ -209,7 +209,7 @@ namespace nil::crypto3::multiprecision {
         }
 
         template<typename T,
-                 std::enable_if_t<std::is_integral_v<T> && std::is_unsigned_v<T>, int> = 0>
+                 std::enable_if_t<std::is_integral_v<T> && std::is_unsigned_v<T> || std::is_same_v<T, unsigned __int128>, int> = 0>
         constexpr big_uint& operator=(T val) noexcept {
             do_assign_integral(val);
             return *this;

crypto3/libs/multiprecision/include/nil/crypto3/multiprecision/detail/int128.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
-#if defined(__SIZEOF_INT128__)
-#define NIL_CO3_MP_HAS_INT128
-#endif
+//#if defined(__SIZEOF_INT128__)
+//#define NIL_CO3_MP_HAS_INT128
+//#endif
 
 // same again for __int128:
 #if defined(NIL_CO3_MP_HAS_INT128) && defined(__cplusplus)

crypto3/libs/multiprecision/include/nil/crypto3/multiprecision/detail/intel_intrinsics.hpp

@@ -5,7 +5,7 @@
 #include "nil/crypto3/multiprecision/detail/helper_macros.hpp"
 #include "nil/crypto3/multiprecision/detail/int128.hpp"
 
-#if __has_include(<immintrin.h>)
+/*#if __has_include(<immintrin.h>)
 
 #define NIL_CO3_MP_HAS_IMMINTRIN_H
 
@@ -53,4 +53,4 @@ namespace nil::crypto3::multiprecision::detail {
 
 #endif
 
-#endif
+#endif*/

gpu_gpustat_monitor.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+while true; do
+    gpustat --json >> gpu_utilization_gpustat_log.json
+done

parallel-crypto3/libs/parallel-math/include/nil/crypto3/math/algorithms/make_evaluation_domain.hpp

@@ -106,18 +106,17 @@ namespace nil {
              The function get_evaluation_domain is chosen from different supported domains,
              depending on MinSize.
             */
-            template<typename FieldType, typename ValueType = typename FieldType::value_type,
-                     typename Allocator = std::allocator<ValueType>>
-            std::shared_ptr<evaluation_domain<FieldType, ValueType, Allocator>> make_evaluation_domain(std::size_t m) {
+            template<typename FieldType, typename ValueType = typename FieldType::value_type>
+            std::shared_ptr<evaluation_domain<FieldType, ValueType>> make_evaluation_domain(std::size_t m) {
 
-                typedef std::shared_ptr<evaluation_domain<FieldType, ValueType, Allocator>> result_type;
+                typedef std::shared_ptr<evaluation_domain<FieldType, ValueType>> result_type;
 
                 const std::size_t big = 1ul << (std::size_t(std::ceil(std::log2(m))) - 1);
                 const std::size_t rounded_small = (1ul << std::size_t(std::ceil(std::log2(m - big))));
 
                 if (detail::is_basic_radix2_domain<FieldType>(m)) {
                     result_type result;
-                    result.reset(new basic_radix2_domain<FieldType, ValueType, Allocator>(m));
+                    result.reset(new basic_radix2_domain<FieldType, ValueType>(m));
                     return result;
                 }
 
@@ -135,7 +134,7 @@ namespace nil {
 
                 if (detail::is_basic_radix2_domain<FieldType>(big + rounded_small)) {
                     result_type result;
-                    result.reset(new basic_radix2_domain<FieldType, ValueType, Allocator>(big + rounded_small));
+                    result.reset(new basic_radix2_domain<FieldType, ValueType>(big + rounded_small));
                     return result;
                 }
 

parallel-crypto3/libs/parallel-math/include/nil/crypto3/math/domains/arithmetic_sequence_domain.hpp

@@ -46,12 +46,11 @@ namespace nil {
 
             using namespace nil::crypto3::algebra;
 
-            template<typename FieldType, typename ValueType, typename Allocator>
+            template<typename FieldType, typename ValueType>
             class evaluation_domain;
 
-            template<typename FieldType, typename ValueType = typename FieldType::value_type,
-                     typename Allocator = std::allocator<ValueType>>
-            class arithmetic_sequence_domain : public evaluation_domain<FieldType, ValueType, Allocator> {
+            template<typename FieldType, typename ValueType = typename FieldType::value_type>
+            class arithmetic_sequence_domain : public evaluation_domain<FieldType, ValueType> {
                 typedef typename FieldType::value_type field_value_type;
                 typedef ValueType value_type;