add minor improvements to unit-tests build script for macOS ARM support

Author: Jeffrey Hurchalla

benchmark/benchmark.cpp

@@ -5,12 +5,14 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
+#include "hurchalla/util/compiler_macros.h"
 #include "hurchalla/util/traits/extensible_make_unsigned.h"
 #include "hurchalla/util/traits/ut_numeric_limits.h"
 #include "hurchalla/factoring/factorize.h"
 #include <iostream>
 #include <chrono>
-#if defined(__GNUC__)
+#if defined(__GNUC__) && (defined(HURCHALLA_TARGET_ISA_X86_64) \
+                         || defined(HURCHALLA_TARGET_ISA_X86_32))
 #  include <cpuid.h>
 #  include <string>
 #  include <cstring>
@@ -25,7 +27,8 @@
 #define STRINGIFYMACRO(y) STRINGIFY(y)
 
 
-#if defined(__GNUC__)
+#if defined(__GNUC__) && (defined(HURCHALLA_TARGET_ISA_X86_64) \
+                         || defined(HURCHALLA_TARGET_ISA_X86_32))
 std::string displayCPU()
 {
     // this code is copied from https://stackoverflow.com/a/50021699
@@ -109,7 +112,8 @@ void print_int_type()
 
 int main()
 {
-#if defined(__GNUC__)
+#if defined(__GNUC__) && (defined(HURCHALLA_TARGET_ISA_X86_64) \
+                         || defined(HURCHALLA_TARGET_ISA_X86_32))
    std::cout << displayCPU() << "\n";
 #endif
 

build_tests.sh

@@ -1,18 +1,23 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
-# Copyright (c) 2020-2022 Jeffrey Hurchalla.
+# Copyright (c) 2020-2024 Jeffrey Hurchalla.
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
+#TODO
+# test_factoring with gcc in debug  5:46 to compile.  Using the standard MontgomeryForm
 
 # Description of this script -----------
 # This is a working convenience script for invoking the testing builds and then
 # running the tests.
 # The syntax is 
-# ./build_tests [-c<compiler_name>] [-r] [-a] [-u] [-t] [-m<Release|Debug|Profile>] [-l<standard_library_name>]
+# ./build_tests [-c<compiler_name>] [-j<num_jobs>] [-r] [-a] [-u] [-t] [-m<Release|Debug|Profile>] [-l<standard_library_name>]
 #
 # -c allows you to select the compiler, rather than using the default.
+# -j specifies the number of jobs (typically threads) that you want the compiler
+#    to use when building.  If you omit this option, the compiler's default
+#    number of jobs will be used.
 # -r specifies to run all tests after the build.  Without -r, no tests will run.
 # -a specifies you want to compile the code using typically helpful (how much it
 #    helps depends on your compiler) inline asm optimizations, which makes for
@@ -167,18 +172,26 @@
 #   update-alternatives for both icc and icpc. ]
 
 
+if [ "${BASH_VERSINFO:-0}" -lt 4 ]; then
+   >&2 echo "This script requires some verion of bash >= 4.0.  Bash 3.2.57 is known to fail, but the minimum required version is unknown"
+   exit 1
+fi
+
 
-while getopts ":m:l:c:h-:raut" opt; do
+while getopts ":m:l:c:j:h-:raut" opt; do
   case $opt in
     h)
       ;&
     -)
-      echo "Usage: build_tests [-c<compiler_name>] [-r] [-a] [-u] [-t] [-m<Release|Debug|Profile>] [-l<standard_library_name>]" >&2
+      echo "Usage: build_tests [-c<compiler_name>] [-j<num_jobs>] [-r] [-a] [-u] [-t] [-m<Release|Debug|Profile>] [-l<standard_library_name>]" >&2
       exit 1
       ;;
     c)
       compiler=$OPTARG
       ;;
+    j)
+      num_jobs="-j$OPTARG"
+      ;;
     m)
       mode=$OPTARG
       ;;
@@ -395,9 +408,18 @@ fi
 # "[The] UndefinedBehaviorSanitizer ... test suite is integrated into the CMake
 # build and can be run with check-ubsan command."
 if [ "$compiler_name" = "gcc" ]; then
-  gcc_ubsan="-fsanitize=undefined -fno-sanitize-recover \
-           -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow"
-
+  if [[ $(uname -m) == 'arm64' ]]; then
+    # At the time of this writing, gcc does not seem to have implemented sanitizers
+    # (at least not ubsan) for Silicon MacOS.  I get link errors if compiling
+    # with them on mac.  See  https://github.com/orgs/Homebrew/discussions/3384
+    # https://github.com/orgs/Homebrew/discussions/3260
+    # https://stackoverflow.com/questions/65259300/detect-apple-silicon-from-command-line
+
+    : # do nothing, at least for now
+  else
+    gcc_ubsan="-fsanitize=undefined -fno-sanitize-recover \
+             -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow"
+  fi
 elif [ "$compiler_name" = "clang" ] && [[ $compiler_version -ge 6 ]]; then
   # clang6 doesn't support -fsanitize=implicit-conversion.  Clang10 does support
   # it.  I don't know if clang7,8,9 support it.

include/hurchalla/factoring/detail/is_prime_miller_rabin.h

@@ -201,7 +201,7 @@ struct IPMR_internal {
 
   template <std::size_t TRIAL_SIZE, std::size_t TOTAL_BASES,
             typename B, typename MontType>
-  static HURCHALLA_FORCE_INLINE bool miller_rabin_trials(const MontType& mf,
+  static bool miller_rabin_trials(const MontType& mf,
                                          const std::array<B,TOTAL_BASES>& bases)
   {
     using T = typename MontType::IntegerType;
@@ -244,7 +244,7 @@ struct IPMR_internal {
 
   template <std::size_t TRIAL_SIZE, std::size_t TOTAL_BASES,
             typename B, typename MontType>
-  static HURCHALLA_FORCE_INLINE bool miller_rabin_trials128(const MontType& mf,
+  static bool miller_rabin_trials128(const MontType& mf,
                                          const std::array<B,TOTAL_BASES>& bases)
   {
     using T = typename MontType::IntegerType;

include/hurchalla/factoring/factorize.h

@@ -44,9 +44,9 @@ namespace hurchalla {
 // disivion stage.  It then uses either ECM or Pollard-Rho to find all remaining
 // factors, depending on the size of the number.  Prior to trying to extract
 // any factor with ECM or Pollard-Rho, it tests for primality by using the
-// deterministic Miller-Rabin algorithm - we usually speed up this algorithm by
-// using one of the very small hash tables (~100 bytes for example) in
-// factoring/include/hurchalla/factoring/detail/miller_rabin_bases/
+// deterministic Miller-Rabin algorithm - internally this algorithm is usually
+// sped up by using one of the very small hash tables (~100 bytes for example)
+// in factoring/include/hurchalla/factoring/detail/miller_rabin_bases/
 //
 // For numbers below ~40 bits, factorize() uses the Pollard-Rho factorization
 // algorithm, with Brent's improvements (see https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm)
@@ -59,8 +59,8 @@ namespace hurchalla {
 // ------------------------------------
 // Performance:
 // ------------------------------------
-// For 64 bit numbers, the resulting factorization functions below are likely
-// the fastest you will currently be able to find, both for factoring arbitrary
+// For 64 bit numbers, the factorization functions above are likely the fastest
+// available anywhere at the time of this writing, both for factoring arbitrary
 // values and for factoring semiprimes with two large factors.
 //
 // For 128 bit numbers, this code needs to be performance tested against other
@@ -70,8 +70,8 @@ namespace hurchalla {
 //
 // For 32 bit numbers, a very well-optimized implementation of Hart's One Line
 // Factoring algorithm and/or Lehman's method might potentially be faster than
-// the functions here.  The functions here should nonetheless be fairly close to
-// the fastest currently available at 32 bits.
+// the functions in this file.  Nevertheless the functions here should be fairly
+// close to the fastest currently available at 32 bits.
 //
 // For 256 bit or larger numbers - which this library does not support - you may
 // wish to seek out ECM for smaller bit depths, and then Quadratic Sieve and

include/hurchalla/factoring/resource_intensive_api/FactorByTable32.h

@@ -47,10 +47,11 @@ class FactorByTable
     // table in memory from scratch.
     FactorByTable() : impl() {}
 
-    // If you call this next constructor with an argument of false for
-    // createTableIfCantOpen, then the constructor will throw if it is unable
-    // to open table_filepath.  Otherwise (and by default), it will create the
-    // table, which will very likely take a few minutes to complete.
+    // If the constructor is unable to open table_filepath, and you specify
+    // false for createTableIfCantOpen then the constructor will throw.  If the
+    // constructor is unable to open table_filepath, and you specify true for
+    // createTableIfCantOpen, then the constructor will create the table
+    // from scratch which will likely take a few minutes to complete.
     //
     // Can throw from a file open failure, a read failure, or mismatch in
     // file values read vs values expected.