* [Buildroot] [PATCH v2] package/boost: fix math with no atomics
@ 2021-09-12 9:12 Michael Nosthoff via buildroot
2021-09-12 9:47 ` Yann E. MORIN
0 siblings, 1 reply; 5+ messages in thread
From: Michael Nosthoff via buildroot @ 2021-09-12 9:12 UTC (permalink / raw)
To: buildroot; +Cc: Michael Nosthoff
Boost 1.77.0 broke the build of the math component on architectures
without lockfree atomics. This was reported in [0].
This patch adds the relevant patches from the upstream patchset[1] which fix the build
and removes the dependency on BR2_TOOLCHAIN_SUPPORTS_ALWAYS_LOCKFREE_ATOMIC_INTS
[0] https://github.com/boostorg/math/issues/673
[1] https://github.com/boostorg/math/pull/684
Signed-off-by: Michael Nosthoff <buildroot@heine.tech>
---
V2:
- split patchset into multiple patches
- drop patches that only fix tests
---
...li-code-on-platforms-with-no-atomics.patch | 47 ++++++
...oft-failure-in-bernoulli_details_hpp.patch | 145 ++++++++++++++++++
package/boost/Config.in | 1 -
3 files changed, 192 insertions(+), 1 deletion(-)
create mode 100644 package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch
create mode 100644 package/boost/0003-math-make-no-atomics-a-soft-failure-in-bernoulli_details_hpp.patch
diff --git a/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch b/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch
new file mode 100644
index 0000000000..121355d71e
--- /dev/null
+++ b/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch
@@ -0,0 +1,47 @@
+From 32bd6197353f6ea8e5bef01f09e25c944141acfc Mon Sep 17 00:00:00 2001
+From: jzmaddock <john@johnmaddock.co.uk>
+Date: Wed, 1 Sep 2021 18:54:54 +0100
+Subject: [PATCH] Allow definition of BOOST_MATH_NO_ATOMIC_INT on the command
+ line. Allows us to test/emulate platforms with no atomic integers.
+
+---
+ boost/math/tools/atomic.hpp | 10 +++++-----
+ 1 file changed, 5 insertions(+), 5 deletions(-)
+
+diff --git a/boost/math/tools/atomic.hpp b/boost/math/tools/atomic.hpp
+index cc76ed269f..e3cbf5db89 100644
+--- a/boost/math/tools/atomic.hpp
++++ b/boost/math/tools/atomic.hpp
+@@ -16,27 +16,27 @@
+ namespace boost {
+ namespace math {
+ namespace detail {
+-#if ATOMIC_INT_LOCK_FREE == 2
++#if (ATOMIC_INT_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
+ typedef std::atomic<int> atomic_counter_type;
+ typedef std::atomic<unsigned> atomic_unsigned_type;
+ typedef int atomic_integer_type;
+ typedef unsigned atomic_unsigned_integer_type;
+-#elif ATOMIC_SHORT_LOCK_FREE == 2
++#elif (ATOMIC_SHORT_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
+ typedef std::atomic<short> atomic_counter_type;
+ typedef std::atomic<unsigned short> atomic_unsigned_type;
+ typedef short atomic_integer_type;
+ typedef unsigned short atomic_unsigned_type;
+-#elif ATOMIC_LONG_LOCK_FREE == 2
++#elif (ATOMIC_LONG_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
+ typedef std::atomic<long> atomic_unsigned_integer_type;
+ typedef std::atomic<unsigned long> atomic_unsigned_type;
+ typedef unsigned long atomic_unsigned_type;
+ typedef long atomic_integer_type;
+-#elif ATOMIC_LLONG_LOCK_FREE == 2
++#elif (ATOMIC_LLONG_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
+ typedef std::atomic<long long> atomic_unsigned_integer_type;
+ typedef std::atomic<unsigned long long> atomic_unsigned_type;
+ typedef long long atomic_integer_type;
+ typedef unsigned long long atomic_unsigned_integer_type;
+-#else
++#elif !defined(BOOST_MATH_NO_ATOMIC_INT)
+ # define BOOST_MATH_NO_ATOMIC_INT
+ #endif
+ } // Namespace detail
diff --git a/package/boost/0003-math-make-no-atomics-a-soft-failure-in-bernoulli_details_hpp.patch b/package/boost/0003-math-make-no-atomics-a-soft-failure-in-bernoulli_details_hpp.patch
new file mode 100644
index 0000000000..77f1217a3a
--- /dev/null
+++ b/package/boost/0003-math-make-no-atomics-a-soft-failure-in-bernoulli_details_hpp.patch
@@ -0,0 +1,145 @@
+From 7d482f6ebc356e6ec455ccb5f51a23971bf6ce5b Mon Sep 17 00:00:00 2001
+From: jzmaddock <john@johnmaddock.co.uk>
+Date: Wed, 1 Sep 2021 20:31:53 +0100
+Subject: [PATCH] Make no atomics a soft failure in bernoulli_details.hpp.
+ Include an "escape macro" so thread safety can be disabled if certain
+ bernoulli features are to be used in a no-atomics environment. Fixes
+ https://github.com/boostorg/math/issues/673.
+
+---
+ .../detail/bernoulli_details.hpp | 10 +++++++---
+ libs/math/test/Jamfile.v2 | 3 +++
+ test/compile_test/bernoulli_no_atomic_d.cpp | 14 ++++++++++++++
+ test/compile_test/bernoulli_no_atomic_fail.cpp | 15 +++++++++++++++
+ test/compile_test/bernoulli_no_atomic_mp.cpp | 16 ++++++++++++++++
+ 5 files changed, 55 insertions(+), 3 deletions(-)
+ create mode 100644 test/compile_test/bernoulli_no_atomic_d.cpp
+ create mode 100644 test/compile_test/bernoulli_no_atomic_fail.cpp
+ create mode 100644 test/compile_test/bernoulli_no_atomic_mp.cpp
+
+diff --git a/boost/math/special_functions/detail/bernoulli_details.hpp b/boost/math/special_functions/detail/bernoulli_details.hpp
+index cf35545264..8519b7c89c 100644
+--- a/boost/math/special_functions/detail/bernoulli_details.hpp
++++ b/boost/math/special_functions/detail/bernoulli_details.hpp
+@@ -360,7 +360,7 @@ class bernoulli_numbers_cache
+ return out;
+ }
+
+- #ifndef BOOST_HAS_THREADS
++ #if !defined(BOOST_HAS_THREADS) || defined(BOOST_MATH_BERNOULLI_UNTHREADED)
+ //
+ // Single threaded code, very simple:
+ //
+@@ -382,6 +382,8 @@ class bernoulli_numbers_cache
+ *out = (i >= m_overflow_limit) ? policies::raise_overflow_error<T>("boost::math::bernoulli_b2n<%1%>(std::size_t)", 0, T(i), pol) : bn[i];
+ ++out;
+ }
++ #elif defined(BOOST_MATH_NO_ATOMIC_INT)
++ static_assert(sizeof(T) == 1, "Unsupported configuration: your platform appears to have no atomic integers. If you are happy with thread-unsafe code, then you may define BOOST_MATH_BERNOULLI_UNTHREADED to suppress this error.");
+ #else
+ //
+ // Double-checked locking pattern, lets us access cached already cached values
+@@ -464,7 +466,7 @@ class bernoulli_numbers_cache
+ return out;
+ }
+
+- #ifndef BOOST_HAS_THREADS
++ #if !defined(BOOST_HAS_THREADS) || defined(BOOST_MATH_BERNOULLI_UNTHREADED)
+ //
+ // Single threaded code, very simple:
+ //
+@@ -494,6 +496,8 @@ class bernoulli_numbers_cache
+ }
+ ++out;
+ }
++ #elif defined(BOOST_MATH_NO_ATOMIC_INT)
++ static_assert(sizeof(T) == 1, "Unsupported configuration: your platform appears to have no atomic integers. If you are happy with thread-unsafe code, then you may define BOOST_MATH_BERNOULLI_UNTHREADED to suppress this error.");
+ #else
+ //
+ // Double-checked locking pattern, lets us access cached already cached values
+@@ -555,7 +559,7 @@ class bernoulli_numbers_cache
+ // The value at which we know overflow has already occurred for the Bn:
+ std::size_t m_overflow_limit;
+
+- #ifdef BOOST_HAS_THREADS
++ #if defined(BOOST_HAS_THREADS) && !defined(BOOST_MATH_NO_ATOMIC_INT)
+ std::mutex m_mutex;
+ atomic_counter_type m_counter, m_current_precision;
+ #else
+diff --git a/libs/math/test/Jamfile.v2 b/libs/math/test/Jamfile.v2
+index 52fb87f5e5..3ac63f9279 100644
+--- a/libs/math/test/Jamfile.v2
++++ b/libs/math/test/Jamfile.v2
+@@ -1137,6 +1137,9 @@ test-suite misc :
+
+ # [ run __temporary_test.cpp test_instances//test_instances : : : <test-info>always_show_run_output <pch>off ]
+ [ compile test_no_long_double_policy.cpp ]
++ [ compile compile_test/bernoulli_no_atomic_d.cpp ]
++ [ compile compile_test/bernoulli_no_atomic_mp.cpp ]
++ [ compile-fail compile_test/bernoulli_no_atomic_fail.cpp ]
+ ;
+
+ test-suite interpolators :
+diff --git a/test/compile_test/bernoulli_no_atomic_d.cpp b/test/compile_test/bernoulli_no_atomic_d.cpp
+new file mode 100644
+index 0000000000..61926f7e1f
+--- /dev/null
++++ b/test/compile_test/bernoulli_no_atomic_d.cpp
+@@ -0,0 +1,14 @@
++// (C) Copyright John Maddock 2021.
++// Use, modification and distribution are subject to the
++// Boost Software License, Version 1.0. (See accompanying file
++// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
++
++#define BOOST_MATH_NO_ATOMIC_INT
++
++#include <boost/math/special_functions/bernoulli.hpp>
++#include "test_compile_result.hpp"
++
++void compile_and_link_test()
++{
++ check_result<double>(boost::math::bernoulli_b2n<double>(4));
++}
+diff --git a/test/compile_test/bernoulli_no_atomic_fail.cpp b/test/compile_test/bernoulli_no_atomic_fail.cpp
+new file mode 100644
+index 0000000000..bbd7152412
+--- /dev/null
++++ b/test/compile_test/bernoulli_no_atomic_fail.cpp
+@@ -0,0 +1,15 @@
++// (C) Copyright John Maddock 2021.
++// Use, modification and distribution are subject to the
++// Boost Software License, Version 1.0. (See accompanying file
++// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
++
++#define BOOST_MATH_NO_ATOMIC_INT
++
++#include <boost/math/special_functions/bernoulli.hpp>
++#include <boost/multiprecision/cpp_bin_float.hpp>
++#include "test_compile_result.hpp"
++
++void compile_and_link_test()
++{
++ check_result<boost::multiprecision::cpp_bin_float_50>(boost::math::bernoulli_b2n<boost::multiprecision::cpp_bin_float_50>(4));
++}
+diff --git a/test/compile_test/bernoulli_no_atomic_mp.cpp b/test/compile_test/bernoulli_no_atomic_mp.cpp
+new file mode 100644
+index 0000000000..8d5a6e78e6
+--- /dev/null
++++ b/test/compile_test/bernoulli_no_atomic_mp.cpp
+@@ -0,0 +1,16 @@
++// (C) Copyright John Maddock 2021.
++// Use, modification and distribution are subject to the
++// Boost Software License, Version 1.0. (See accompanying file
++// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
++
++#define BOOST_MATH_NO_ATOMIC_INT
++#define BOOST_MATH_BERNOULLI_UNTHREADED
++
++#include <boost/math/special_functions/bernoulli.hpp>
++#include <boost/multiprecision/cpp_bin_float.hpp>
++#include "test_compile_result.hpp"
++
++void compile_and_link_test()
++{
++ check_result<boost::multiprecision::cpp_bin_float_50>(boost::math::bernoulli_b2n<boost::multiprecision::cpp_bin_float_50>(4));
++}
diff --git a/package/boost/Config.in b/package/boost/Config.in
index d9ce841a92..f6dea1eaf7 100644
--- a/package/boost/Config.in
+++ b/package/boost/Config.in
@@ -254,7 +254,6 @@ comment "boost-log needs a toolchain not affected by GCC bug 64735"
config BR2_PACKAGE_BOOST_MATH
bool "boost-math"
- depends on BR2_TOOLCHAIN_SUPPORTS_ALWAYS_LOCKFREE_ATOMIC_INTS
help
Boost.Math includes several contributions in the domain of
mathematics:
--
2.33.0
_______________________________________________
buildroot mailing list
buildroot@lists.buildroot.org
https://lists.buildroot.org/mailman/listinfo/buildroot
^ permalink raw reply related [flat|nested] 5+ messages in thread* Re: [Buildroot] [PATCH v2] package/boost: fix math with no atomics
2021-09-12 9:12 [Buildroot] [PATCH v2] package/boost: fix math with no atomics Michael Nosthoff via buildroot
@ 2021-09-12 9:47 ` Yann E. MORIN
2021-09-12 11:36 ` Yann E. MORIN
0 siblings, 1 reply; 5+ messages in thread
From: Yann E. MORIN @ 2021-09-12 9:47 UTC (permalink / raw)
To: Michael Nosthoff; +Cc: buildroot
Michael, All,
On 2021-09-12 11:12 +0200, Michael Nosthoff via buildroot spake thusly:
> Boost 1.77.0 broke the build of the math component on architectures
> without lockfree atomics. This was reported in [0].
>
> This patch adds the relevant patches from the upstream patchset[1] which fix the build
> and removes the dependency on BR2_TOOLCHAIN_SUPPORTS_ALWAYS_LOCKFREE_ATOMIC_INTS
>
> [0] https://github.com/boostorg/math/issues/673
> [1] https://github.com/boostorg/math/pull/684
>
> Signed-off-by: Michael Nosthoff <buildroot@heine.tech>
Applied to master, thanks.
Regards,
Yann E. MORIN.
> ---
>
> V2:
> - split patchset into multiple patches
> - drop patches that only fix tests
> ---
> ...li-code-on-platforms-with-no-atomics.patch | 47 ++++++
> ...oft-failure-in-bernoulli_details_hpp.patch | 145 ++++++++++++++++++
> package/boost/Config.in | 1 -
> 3 files changed, 192 insertions(+), 1 deletion(-)
> create mode 100644 package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch
> create mode 100644 package/boost/0003-math-make-no-atomics-a-soft-failure-in-bernoulli_details_hpp.patch
>
> diff --git a/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch b/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch
> new file mode 100644
> index 0000000000..121355d71e
> --- /dev/null
> +++ b/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch
> @@ -0,0 +1,47 @@
> +From 32bd6197353f6ea8e5bef01f09e25c944141acfc Mon Sep 17 00:00:00 2001
> +From: jzmaddock <john@johnmaddock.co.uk>
> +Date: Wed, 1 Sep 2021 18:54:54 +0100
> +Subject: [PATCH] Allow definition of BOOST_MATH_NO_ATOMIC_INT on the command
> + line. Allows us to test/emulate platforms with no atomic integers.
> +
> +---
> + boost/math/tools/atomic.hpp | 10 +++++-----
> + 1 file changed, 5 insertions(+), 5 deletions(-)
> +
> +diff --git a/boost/math/tools/atomic.hpp b/boost/math/tools/atomic.hpp
> +index cc76ed269f..e3cbf5db89 100644
> +--- a/boost/math/tools/atomic.hpp
> ++++ b/boost/math/tools/atomic.hpp
> +@@ -16,27 +16,27 @@
> + namespace boost {
> + namespace math {
> + namespace detail {
> +-#if ATOMIC_INT_LOCK_FREE == 2
> ++#if (ATOMIC_INT_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
> + typedef std::atomic<int> atomic_counter_type;
> + typedef std::atomic<unsigned> atomic_unsigned_type;
> + typedef int atomic_integer_type;
> + typedef unsigned atomic_unsigned_integer_type;
> +-#elif ATOMIC_SHORT_LOCK_FREE == 2
> ++#elif (ATOMIC_SHORT_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
> + typedef std::atomic<short> atomic_counter_type;
> + typedef std::atomic<unsigned short> atomic_unsigned_type;
> + typedef short atomic_integer_type;
> + typedef unsigned short atomic_unsigned_type;
> +-#elif ATOMIC_LONG_LOCK_FREE == 2
> ++#elif (ATOMIC_LONG_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
> + typedef std::atomic<long> atomic_unsigned_integer_type;
> + typedef std::atomic<unsigned long> atomic_unsigned_type;
> + typedef unsigned long atomic_unsigned_type;
> + typedef long atomic_integer_type;
> +-#elif ATOMIC_LLONG_LOCK_FREE == 2
> ++#elif (ATOMIC_LLONG_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
> + typedef std::atomic<long long> atomic_unsigned_integer_type;
> + typedef std::atomic<unsigned long long> atomic_unsigned_type;
> + typedef long long atomic_integer_type;
> + typedef unsigned long long atomic_unsigned_integer_type;
> +-#else
> ++#elif !defined(BOOST_MATH_NO_ATOMIC_INT)
> + # define BOOST_MATH_NO_ATOMIC_INT
> + #endif
> + } // Namespace detail
> diff --git a/package/boost/0003-math-make-no-atomics-a-soft-failure-in-bernoulli_details_hpp.patch b/package/boost/0003-math-make-no-atomics-a-soft-failure-in-bernoulli_details_hpp.patch
> new file mode 100644
> index 0000000000..77f1217a3a
> --- /dev/null
> +++ b/package/boost/0003-math-make-no-atomics-a-soft-failure-in-bernoulli_details_hpp.patch
> @@ -0,0 +1,145 @@
> +From 7d482f6ebc356e6ec455ccb5f51a23971bf6ce5b Mon Sep 17 00:00:00 2001
> +From: jzmaddock <john@johnmaddock.co.uk>
> +Date: Wed, 1 Sep 2021 20:31:53 +0100
> +Subject: [PATCH] Make no atomics a soft failure in bernoulli_details.hpp.
> + Include an "escape macro" so thread safety can be disabled if certain
> + bernoulli features are to be used in a no-atomics environment. Fixes
> + https://github.com/boostorg/math/issues/673.
> +
> +---
> + .../detail/bernoulli_details.hpp | 10 +++++++---
> + libs/math/test/Jamfile.v2 | 3 +++
> + test/compile_test/bernoulli_no_atomic_d.cpp | 14 ++++++++++++++
> + test/compile_test/bernoulli_no_atomic_fail.cpp | 15 +++++++++++++++
> + test/compile_test/bernoulli_no_atomic_mp.cpp | 16 ++++++++++++++++
> + 5 files changed, 55 insertions(+), 3 deletions(-)
> + create mode 100644 test/compile_test/bernoulli_no_atomic_d.cpp
> + create mode 100644 test/compile_test/bernoulli_no_atomic_fail.cpp
> + create mode 100644 test/compile_test/bernoulli_no_atomic_mp.cpp
> +
> +diff --git a/boost/math/special_functions/detail/bernoulli_details.hpp b/boost/math/special_functions/detail/bernoulli_details.hpp
> +index cf35545264..8519b7c89c 100644
> +--- a/boost/math/special_functions/detail/bernoulli_details.hpp
> ++++ b/boost/math/special_functions/detail/bernoulli_details.hpp
> +@@ -360,7 +360,7 @@ class bernoulli_numbers_cache
> + return out;
> + }
> +
> +- #ifndef BOOST_HAS_THREADS
> ++ #if !defined(BOOST_HAS_THREADS) || defined(BOOST_MATH_BERNOULLI_UNTHREADED)
> + //
> + // Single threaded code, very simple:
> + //
> +@@ -382,6 +382,8 @@ class bernoulli_numbers_cache
> + *out = (i >= m_overflow_limit) ? policies::raise_overflow_error<T>("boost::math::bernoulli_b2n<%1%>(std::size_t)", 0, T(i), pol) : bn[i];
> + ++out;
> + }
> ++ #elif defined(BOOST_MATH_NO_ATOMIC_INT)
> ++ static_assert(sizeof(T) == 1, "Unsupported configuration: your platform appears to have no atomic integers. If you are happy with thread-unsafe code, then you may define BOOST_MATH_BERNOULLI_UNTHREADED to suppress this error.");
> + #else
> + //
> + // Double-checked locking pattern, lets us access cached already cached values
> +@@ -464,7 +466,7 @@ class bernoulli_numbers_cache
> + return out;
> + }
> +
> +- #ifndef BOOST_HAS_THREADS
> ++ #if !defined(BOOST_HAS_THREADS) || defined(BOOST_MATH_BERNOULLI_UNTHREADED)
> + //
> + // Single threaded code, very simple:
> + //
> +@@ -494,6 +496,8 @@ class bernoulli_numbers_cache
> + }
> + ++out;
> + }
> ++ #elif defined(BOOST_MATH_NO_ATOMIC_INT)
> ++ static_assert(sizeof(T) == 1, "Unsupported configuration: your platform appears to have no atomic integers. If you are happy with thread-unsafe code, then you may define BOOST_MATH_BERNOULLI_UNTHREADED to suppress this error.");
> + #else
> + //
> + // Double-checked locking pattern, lets us access cached already cached values
> +@@ -555,7 +559,7 @@ class bernoulli_numbers_cache
> + // The value at which we know overflow has already occurred for the Bn:
> + std::size_t m_overflow_limit;
> +
> +- #ifdef BOOST_HAS_THREADS
> ++ #if defined(BOOST_HAS_THREADS) && !defined(BOOST_MATH_NO_ATOMIC_INT)
> + std::mutex m_mutex;
> + atomic_counter_type m_counter, m_current_precision;
> + #else
> +diff --git a/libs/math/test/Jamfile.v2 b/libs/math/test/Jamfile.v2
> +index 52fb87f5e5..3ac63f9279 100644
> +--- a/libs/math/test/Jamfile.v2
> ++++ b/libs/math/test/Jamfile.v2
> +@@ -1137,6 +1137,9 @@ test-suite misc :
> +
> + # [ run __temporary_test.cpp test_instances//test_instances : : : <test-info>always_show_run_output <pch>off ]
> + [ compile test_no_long_double_policy.cpp ]
> ++ [ compile compile_test/bernoulli_no_atomic_d.cpp ]
> ++ [ compile compile_test/bernoulli_no_atomic_mp.cpp ]
> ++ [ compile-fail compile_test/bernoulli_no_atomic_fail.cpp ]
> + ;
> +
> + test-suite interpolators :
> +diff --git a/test/compile_test/bernoulli_no_atomic_d.cpp b/test/compile_test/bernoulli_no_atomic_d.cpp
> +new file mode 100644
> +index 0000000000..61926f7e1f
> +--- /dev/null
> ++++ b/test/compile_test/bernoulli_no_atomic_d.cpp
> +@@ -0,0 +1,14 @@
> ++// (C) Copyright John Maddock 2021.
> ++// Use, modification and distribution are subject to the
> ++// Boost Software License, Version 1.0. (See accompanying file
> ++// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
> ++
> ++#define BOOST_MATH_NO_ATOMIC_INT
> ++
> ++#include <boost/math/special_functions/bernoulli.hpp>
> ++#include "test_compile_result.hpp"
> ++
> ++void compile_and_link_test()
> ++{
> ++ check_result<double>(boost::math::bernoulli_b2n<double>(4));
> ++}
> +diff --git a/test/compile_test/bernoulli_no_atomic_fail.cpp b/test/compile_test/bernoulli_no_atomic_fail.cpp
> +new file mode 100644
> +index 0000000000..bbd7152412
> +--- /dev/null
> ++++ b/test/compile_test/bernoulli_no_atomic_fail.cpp
> +@@ -0,0 +1,15 @@
> ++// (C) Copyright John Maddock 2021.
> ++// Use, modification and distribution are subject to the
> ++// Boost Software License, Version 1.0. (See accompanying file
> ++// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
> ++
> ++#define BOOST_MATH_NO_ATOMIC_INT
> ++
> ++#include <boost/math/special_functions/bernoulli.hpp>
> ++#include <boost/multiprecision/cpp_bin_float.hpp>
> ++#include "test_compile_result.hpp"
> ++
> ++void compile_and_link_test()
> ++{
> ++ check_result<boost::multiprecision::cpp_bin_float_50>(boost::math::bernoulli_b2n<boost::multiprecision::cpp_bin_float_50>(4));
> ++}
> +diff --git a/test/compile_test/bernoulli_no_atomic_mp.cpp b/test/compile_test/bernoulli_no_atomic_mp.cpp
> +new file mode 100644
> +index 0000000000..8d5a6e78e6
> +--- /dev/null
> ++++ b/test/compile_test/bernoulli_no_atomic_mp.cpp
> +@@ -0,0 +1,16 @@
> ++// (C) Copyright John Maddock 2021.
> ++// Use, modification and distribution are subject to the
> ++// Boost Software License, Version 1.0. (See accompanying file
> ++// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
> ++
> ++#define BOOST_MATH_NO_ATOMIC_INT
> ++#define BOOST_MATH_BERNOULLI_UNTHREADED
> ++
> ++#include <boost/math/special_functions/bernoulli.hpp>
> ++#include <boost/multiprecision/cpp_bin_float.hpp>
> ++#include "test_compile_result.hpp"
> ++
> ++void compile_and_link_test()
> ++{
> ++ check_result<boost::multiprecision::cpp_bin_float_50>(boost::math::bernoulli_b2n<boost::multiprecision::cpp_bin_float_50>(4));
> ++}
> diff --git a/package/boost/Config.in b/package/boost/Config.in
> index d9ce841a92..f6dea1eaf7 100644
> --- a/package/boost/Config.in
> +++ b/package/boost/Config.in
> @@ -254,7 +254,6 @@ comment "boost-log needs a toolchain not affected by GCC bug 64735"
>
> config BR2_PACKAGE_BOOST_MATH
> bool "boost-math"
> - depends on BR2_TOOLCHAIN_SUPPORTS_ALWAYS_LOCKFREE_ATOMIC_INTS
> help
> Boost.Math includes several contributions in the domain of
> mathematics:
> --
> 2.33.0
>
> _______________________________________________
> buildroot mailing list
> buildroot@lists.buildroot.org
> https://lists.buildroot.org/mailman/listinfo/buildroot
--
.-----------------.--------------------.------------------.--------------------.
| Yann E. MORIN | Real-Time Embedded | /"\ ASCII RIBBON | Erics' conspiracy: |
| +33 662 376 056 | Software Designer | \ / CAMPAIGN | ___ |
| +33 561 099 427 `------------.-------: X AGAINST | \e/ There is no |
| http://ymorin.is-a-geek.org/ | _/*\_ | / \ HTML MAIL | v conspiracy. |
'------------------------------^-------^------------------^--------------------'
_______________________________________________
buildroot mailing list
buildroot@lists.buildroot.org
https://lists.buildroot.org/mailman/listinfo/buildroot
^ permalink raw reply [flat|nested] 5+ messages in thread* Re: [Buildroot] [PATCH v2] package/boost: fix math with no atomics
2021-09-12 9:47 ` Yann E. MORIN
@ 2021-09-12 11:36 ` Yann E. MORIN
2021-09-12 15:00 ` Michael Nosthoff via buildroot
0 siblings, 1 reply; 5+ messages in thread
From: Yann E. MORIN @ 2021-09-12 11:36 UTC (permalink / raw)
To: Michael Nosthoff; +Cc: buildroot
On 2021-09-12 11:47 +0200, Yann E. MORIN spake thusly:
> Michael, All,
>
> On 2021-09-12 11:12 +0200, Michael Nosthoff via buildroot spake thusly:
> > Boost 1.77.0 broke the build of the math component on architectures
> > without lockfree atomics. This was reported in [0].
> >
> > This patch adds the relevant patches from the upstream patchset[1] which fix the build
> > and removes the dependency on BR2_TOOLCHAIN_SUPPORTS_ALWAYS_LOCKFREE_ATOMIC_INTS
> >
> > [0] https://github.com/boostorg/math/issues/673
> > [1] https://github.com/boostorg/math/pull/684
> >
> > Signed-off-by: Michael Nosthoff <buildroot@heine.tech>
> Applied to master, thanks.
[--SNIP--]
> > diff --git a/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch b/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch
> > new file mode 100644
> > index 0000000000..121355d71e
> > --- /dev/null
> > +++ b/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch
> > @@ -0,0 +1,47 @@
> > +From 32bd6197353f6ea8e5bef01f09e25c944141acfc Mon Sep 17 00:00:00 2001
> > +From: jzmaddock <john@johnmaddock.co.uk>
> > +Date: Wed, 1 Sep 2021 18:54:54 +0100
> > +Subject: [PATCH] Allow definition of BOOST_MATH_NO_ATOMIC_INT on the command
> > + line. Allows us to test/emulate platforms with no atomic integers.
> > +
Arg, I forgot a few details about the individual patches:
- you should add a small comment to explain the origin of the patch
- and add your own SoB line
Usually, I do something like:
[your@email: backport from upstream 32bd6197353f6ea8e5bef01f09e25c944141acfc]
Signed-off-by: Your NAME <your@email>
Can you send a fixup please?
Regards,
Yann E. MORIN.
> > +---
> > + boost/math/tools/atomic.hpp | 10 +++++-----
> > + 1 file changed, 5 insertions(+), 5 deletions(-)
> > +
> > +diff --git a/boost/math/tools/atomic.hpp b/boost/math/tools/atomic.hpp
> > +index cc76ed269f..e3cbf5db89 100644
> > +--- a/boost/math/tools/atomic.hpp
> > ++++ b/boost/math/tools/atomic.hpp
> > +@@ -16,27 +16,27 @@
> > + namespace boost {
> > + namespace math {
> > + namespace detail {
> > +-#if ATOMIC_INT_LOCK_FREE == 2
> > ++#if (ATOMIC_INT_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
> > + typedef std::atomic<int> atomic_counter_type;
> > + typedef std::atomic<unsigned> atomic_unsigned_type;
> > + typedef int atomic_integer_type;
> > + typedef unsigned atomic_unsigned_integer_type;
> > +-#elif ATOMIC_SHORT_LOCK_FREE == 2
> > ++#elif (ATOMIC_SHORT_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
> > + typedef std::atomic<short> atomic_counter_type;
> > + typedef std::atomic<unsigned short> atomic_unsigned_type;
> > + typedef short atomic_integer_type;
> > + typedef unsigned short atomic_unsigned_type;
> > +-#elif ATOMIC_LONG_LOCK_FREE == 2
> > ++#elif (ATOMIC_LONG_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
> > + typedef std::atomic<long> atomic_unsigned_integer_type;
> > + typedef std::atomic<unsigned long> atomic_unsigned_type;
> > + typedef unsigned long atomic_unsigned_type;
> > + typedef long atomic_integer_type;
> > +-#elif ATOMIC_LLONG_LOCK_FREE == 2
> > ++#elif (ATOMIC_LLONG_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
> > + typedef std::atomic<long long> atomic_unsigned_integer_type;
> > + typedef std::atomic<unsigned long long> atomic_unsigned_type;
> > + typedef long long atomic_integer_type;
> > + typedef unsigned long long atomic_unsigned_integer_type;
> > +-#else
> > ++#elif !defined(BOOST_MATH_NO_ATOMIC_INT)
> > + # define BOOST_MATH_NO_ATOMIC_INT
> > + #endif
> > + } // Namespace detail
> > diff --git a/package/boost/0003-math-make-no-atomics-a-soft-failure-in-bernoulli_details_hpp.patch b/package/boost/0003-math-make-no-atomics-a-soft-failure-in-bernoulli_details_hpp.patch
> > new file mode 100644
> > index 0000000000..77f1217a3a
> > --- /dev/null
> > +++ b/package/boost/0003-math-make-no-atomics-a-soft-failure-in-bernoulli_details_hpp.patch
> > @@ -0,0 +1,145 @@
> > +From 7d482f6ebc356e6ec455ccb5f51a23971bf6ce5b Mon Sep 17 00:00:00 2001
> > +From: jzmaddock <john@johnmaddock.co.uk>
> > +Date: Wed, 1 Sep 2021 20:31:53 +0100
> > +Subject: [PATCH] Make no atomics a soft failure in bernoulli_details.hpp.
> > + Include an "escape macro" so thread safety can be disabled if certain
> > + bernoulli features are to be used in a no-atomics environment. Fixes
> > + https://github.com/boostorg/math/issues/673.
> > +
> > +---
> > + .../detail/bernoulli_details.hpp | 10 +++++++---
> > + libs/math/test/Jamfile.v2 | 3 +++
> > + test/compile_test/bernoulli_no_atomic_d.cpp | 14 ++++++++++++++
> > + test/compile_test/bernoulli_no_atomic_fail.cpp | 15 +++++++++++++++
> > + test/compile_test/bernoulli_no_atomic_mp.cpp | 16 ++++++++++++++++
> > + 5 files changed, 55 insertions(+), 3 deletions(-)
> > + create mode 100644 test/compile_test/bernoulli_no_atomic_d.cpp
> > + create mode 100644 test/compile_test/bernoulli_no_atomic_fail.cpp
> > + create mode 100644 test/compile_test/bernoulli_no_atomic_mp.cpp
> > +
> > +diff --git a/boost/math/special_functions/detail/bernoulli_details.hpp b/boost/math/special_functions/detail/bernoulli_details.hpp
> > +index cf35545264..8519b7c89c 100644
> > +--- a/boost/math/special_functions/detail/bernoulli_details.hpp
> > ++++ b/boost/math/special_functions/detail/bernoulli_details.hpp
> > +@@ -360,7 +360,7 @@ class bernoulli_numbers_cache
> > + return out;
> > + }
> > +
> > +- #ifndef BOOST_HAS_THREADS
> > ++ #if !defined(BOOST_HAS_THREADS) || defined(BOOST_MATH_BERNOULLI_UNTHREADED)
> > + //
> > + // Single threaded code, very simple:
> > + //
> > +@@ -382,6 +382,8 @@ class bernoulli_numbers_cache
> > + *out = (i >= m_overflow_limit) ? policies::raise_overflow_error<T>("boost::math::bernoulli_b2n<%1%>(std::size_t)", 0, T(i), pol) : bn[i];
> > + ++out;
> > + }
> > ++ #elif defined(BOOST_MATH_NO_ATOMIC_INT)
> > ++ static_assert(sizeof(T) == 1, "Unsupported configuration: your platform appears to have no atomic integers. If you are happy with thread-unsafe code, then you may define BOOST_MATH_BERNOULLI_UNTHREADED to suppress this error.");
> > + #else
> > + //
> > + // Double-checked locking pattern, lets us access cached already cached values
> > +@@ -464,7 +466,7 @@ class bernoulli_numbers_cache
> > + return out;
> > + }
> > +
> > +- #ifndef BOOST_HAS_THREADS
> > ++ #if !defined(BOOST_HAS_THREADS) || defined(BOOST_MATH_BERNOULLI_UNTHREADED)
> > + //
> > + // Single threaded code, very simple:
> > + //
> > +@@ -494,6 +496,8 @@ class bernoulli_numbers_cache
> > + }
> > + ++out;
> > + }
> > ++ #elif defined(BOOST_MATH_NO_ATOMIC_INT)
> > ++ static_assert(sizeof(T) == 1, "Unsupported configuration: your platform appears to have no atomic integers. If you are happy with thread-unsafe code, then you may define BOOST_MATH_BERNOULLI_UNTHREADED to suppress this error.");
> > + #else
> > + //
> > + // Double-checked locking pattern, lets us access cached already cached values
> > +@@ -555,7 +559,7 @@ class bernoulli_numbers_cache
> > + // The value at which we know overflow has already occurred for the Bn:
> > + std::size_t m_overflow_limit;
> > +
> > +- #ifdef BOOST_HAS_THREADS
> > ++ #if defined(BOOST_HAS_THREADS) && !defined(BOOST_MATH_NO_ATOMIC_INT)
> > + std::mutex m_mutex;
> > + atomic_counter_type m_counter, m_current_precision;
> > + #else
> > +diff --git a/libs/math/test/Jamfile.v2 b/libs/math/test/Jamfile.v2
> > +index 52fb87f5e5..3ac63f9279 100644
> > +--- a/libs/math/test/Jamfile.v2
> > ++++ b/libs/math/test/Jamfile.v2
> > +@@ -1137,6 +1137,9 @@ test-suite misc :
> > +
> > + # [ run __temporary_test.cpp test_instances//test_instances : : : <test-info>always_show_run_output <pch>off ]
> > + [ compile test_no_long_double_policy.cpp ]
> > ++ [ compile compile_test/bernoulli_no_atomic_d.cpp ]
> > ++ [ compile compile_test/bernoulli_no_atomic_mp.cpp ]
> > ++ [ compile-fail compile_test/bernoulli_no_atomic_fail.cpp ]
> > + ;
> > +
> > + test-suite interpolators :
> > +diff --git a/test/compile_test/bernoulli_no_atomic_d.cpp b/test/compile_test/bernoulli_no_atomic_d.cpp
> > +new file mode 100644
> > +index 0000000000..61926f7e1f
> > +--- /dev/null
> > ++++ b/test/compile_test/bernoulli_no_atomic_d.cpp
> > +@@ -0,0 +1,14 @@
> > ++// (C) Copyright John Maddock 2021.
> > ++// Use, modification and distribution are subject to the
> > ++// Boost Software License, Version 1.0. (See accompanying file
> > ++// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
> > ++
> > ++#define BOOST_MATH_NO_ATOMIC_INT
> > ++
> > ++#include <boost/math/special_functions/bernoulli.hpp>
> > ++#include "test_compile_result.hpp"
> > ++
> > ++void compile_and_link_test()
> > ++{
> > ++ check_result<double>(boost::math::bernoulli_b2n<double>(4));
> > ++}
> > +diff --git a/test/compile_test/bernoulli_no_atomic_fail.cpp b/test/compile_test/bernoulli_no_atomic_fail.cpp
> > +new file mode 100644
> > +index 0000000000..bbd7152412
> > +--- /dev/null
> > ++++ b/test/compile_test/bernoulli_no_atomic_fail.cpp
> > +@@ -0,0 +1,15 @@
> > ++// (C) Copyright John Maddock 2021.
> > ++// Use, modification and distribution are subject to the
> > ++// Boost Software License, Version 1.0. (See accompanying file
> > ++// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
> > ++
> > ++#define BOOST_MATH_NO_ATOMIC_INT
> > ++
> > ++#include <boost/math/special_functions/bernoulli.hpp>
> > ++#include <boost/multiprecision/cpp_bin_float.hpp>
> > ++#include "test_compile_result.hpp"
> > ++
> > ++void compile_and_link_test()
> > ++{
> > ++ check_result<boost::multiprecision::cpp_bin_float_50>(boost::math::bernoulli_b2n<boost::multiprecision::cpp_bin_float_50>(4));
> > ++}
> > +diff --git a/test/compile_test/bernoulli_no_atomic_mp.cpp b/test/compile_test/bernoulli_no_atomic_mp.cpp
> > +new file mode 100644
> > +index 0000000000..8d5a6e78e6
> > +--- /dev/null
> > ++++ b/test/compile_test/bernoulli_no_atomic_mp.cpp
> > +@@ -0,0 +1,16 @@
> > ++// (C) Copyright John Maddock 2021.
> > ++// Use, modification and distribution are subject to the
> > ++// Boost Software License, Version 1.0. (See accompanying file
> > ++// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
> > ++
> > ++#define BOOST_MATH_NO_ATOMIC_INT
> > ++#define BOOST_MATH_BERNOULLI_UNTHREADED
> > ++
> > ++#include <boost/math/special_functions/bernoulli.hpp>
> > ++#include <boost/multiprecision/cpp_bin_float.hpp>
> > ++#include "test_compile_result.hpp"
> > ++
> > ++void compile_and_link_test()
> > ++{
> > ++ check_result<boost::multiprecision::cpp_bin_float_50>(boost::math::bernoulli_b2n<boost::multiprecision::cpp_bin_float_50>(4));
> > ++}
> > diff --git a/package/boost/Config.in b/package/boost/Config.in
> > index d9ce841a92..f6dea1eaf7 100644
> > --- a/package/boost/Config.in
> > +++ b/package/boost/Config.in
> > @@ -254,7 +254,6 @@ comment "boost-log needs a toolchain not affected by GCC bug 64735"
> >
> > config BR2_PACKAGE_BOOST_MATH
> > bool "boost-math"
> > - depends on BR2_TOOLCHAIN_SUPPORTS_ALWAYS_LOCKFREE_ATOMIC_INTS
> > help
> > Boost.Math includes several contributions in the domain of
> > mathematics:
> > --
> > 2.33.0
> >
> > _______________________________________________
> > buildroot mailing list
> > buildroot@lists.buildroot.org
> > https://lists.buildroot.org/mailman/listinfo/buildroot
>
> --
> .-----------------.--------------------.------------------.--------------------.
> | Yann E. MORIN | Real-Time Embedded | /"\ ASCII RIBBON | Erics' conspiracy: |
> | +33 662 376 056 | Software Designer | \ / CAMPAIGN | ___ |
> | +33 561 099 427 `------------.-------: X AGAINST | \e/ There is no |
> | http://ymorin.is-a-geek.org/ | _/*\_ | / \ HTML MAIL | v conspiracy. |
> '------------------------------^-------^------------------^--------------------'
> _______________________________________________
> buildroot mailing list
> buildroot@lists.buildroot.org
> https://lists.buildroot.org/mailman/listinfo/buildroot
--
.-----------------.--------------------.------------------.--------------------.
| Yann E. MORIN | Real-Time Embedded | /"\ ASCII RIBBON | Erics' conspiracy: |
| +33 662 376 056 | Software Designer | \ / CAMPAIGN | ___ |
| +33 561 099 427 `------------.-------: X AGAINST | \e/ There is no |
| http://ymorin.is-a-geek.org/ | _/*\_ | / \ HTML MAIL | v conspiracy. |
'------------------------------^-------^------------------^--------------------'
_______________________________________________
buildroot mailing list
buildroot@lists.buildroot.org
https://lists.buildroot.org/mailman/listinfo/buildroot
^ permalink raw reply [flat|nested] 5+ messages in thread* Re: [Buildroot] [PATCH v2] package/boost: fix math with no atomics
2021-09-12 11:36 ` Yann E. MORIN
@ 2021-09-12 15:00 ` Michael Nosthoff via buildroot
2021-09-12 15:25 ` Yann E. MORIN
0 siblings, 1 reply; 5+ messages in thread
From: Michael Nosthoff via buildroot @ 2021-09-12 15:00 UTC (permalink / raw)
To: Yann E. MORIN; +Cc: buildroot
Hi Yann,
On 12.09.21 13:36, Yann E. MORIN wrote:
> diff --git
> a/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch
> b/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch
>
>>> new file mode 100644
>>> index 0000000000..121355d71e
>>> --- /dev/null
>>> +++ b/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch
>>> @@ -0,0 +1,47 @@
>>> +From 32bd6197353f6ea8e5bef01f09e25c944141acfc Mon Sep 17 00:00:00 2001
>>> +From: jzmaddock <john@johnmaddock.co.uk>
>>> +Date: Wed, 1 Sep 2021 18:54:54 +0100
>>> +Subject: [PATCH] Allow definition of BOOST_MATH_NO_ATOMIC_INT on the command
>>> + line. Allows us to test/emulate platforms with no atomic integers.
>>> +
> Arg, I forgot a few details about the individual patches:
>
> - you should add a small comment to explain the origin of the patch
> - and add your own SoB line
>
> Usually, I do something like:
>
> [your@email: backport from upstream 32bd6197353f6ea8e5bef01f09e25c944141acfc]
> Signed-off-by: Your NAME <your@email>
>
> Can you send a fixup please?
Sure! just to be sure: what do you mean by fixup? should I commit using
--fixup and send as new patch?
Regards,
Michael
>
> Regards,
> Yann E. MORIN.
>
>>> +---
>>> + boost/math/tools/atomic.hpp | 10 +++++-----
>>> + 1 file changed, 5 insertions(+), 5 deletions(-)
>>> +
>>> +diff --git a/boost/math/tools/atomic.hpp b/boost/math/tools/atomic.hpp
>>> +index cc76ed269f..e3cbf5db89 100644
>>> +--- a/boost/math/tools/atomic.hpp
>>> ++++ b/boost/math/tools/atomic.hpp
>>> +@@ -16,27 +16,27 @@
>>> + namespace boost {
>>> + namespace math {
>>> + namespace detail {
>>> +-#if ATOMIC_INT_LOCK_FREE == 2
>>> ++#if (ATOMIC_INT_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
>>> + typedef std::atomic<int> atomic_counter_type;
>>> + typedef std::atomic<unsigned> atomic_unsigned_type;
>>> + typedef int atomic_integer_type;
>>> + typedef unsigned atomic_unsigned_integer_type;
>>> +-#elif ATOMIC_SHORT_LOCK_FREE == 2
>>> ++#elif (ATOMIC_SHORT_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
>>> + typedef std::atomic<short> atomic_counter_type;
>>> + typedef std::atomic<unsigned short> atomic_unsigned_type;
>>> + typedef short atomic_integer_type;
>>> + typedef unsigned short atomic_unsigned_type;
>>> +-#elif ATOMIC_LONG_LOCK_FREE == 2
>>> ++#elif (ATOMIC_LONG_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
>>> + typedef std::atomic<long> atomic_unsigned_integer_type;
>>> + typedef std::atomic<unsigned long> atomic_unsigned_type;
>>> + typedef unsigned long atomic_unsigned_type;
>>> + typedef long atomic_integer_type;
>>> +-#elif ATOMIC_LLONG_LOCK_FREE == 2
>>> ++#elif (ATOMIC_LLONG_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
>>> + typedef std::atomic<long long> atomic_unsigned_integer_type;
>>> + typedef std::atomic<unsigned long long> atomic_unsigned_type;
>>> + typedef long long atomic_integer_type;
>>> + typedef unsigned long long atomic_unsigned_integer_type;
>>> +-#else
>>> ++#elif !defined(BOOST_MATH_NO_ATOMIC_INT)
>>> + # define BOOST_MATH_NO_ATOMIC_INT
>>> + #endif
>>> + } // Namespace detail
>>> diff --git a/package/boost/0003-math-make-no-atomics-a-soft-failure-in-bernoulli_details_hpp.patch b/package/boost/0003-math-make-no-atomics-a-soft-failure-in-bernoulli_details_hpp.patch
>>> new file mode 100644
>>> index 0000000000..77f1217a3a
>>> --- /dev/null
>>> +++ b/package/boost/0003-math-make-no-atomics-a-soft-failure-in-bernoulli_details_hpp.patch
>>> @@ -0,0 +1,145 @@
>>> +From 7d482f6ebc356e6ec455ccb5f51a23971bf6ce5b Mon Sep 17 00:00:00 2001
>>> +From: jzmaddock <john@johnmaddock.co.uk>
>>> +Date: Wed, 1 Sep 2021 20:31:53 +0100
>>> +Subject: [PATCH] Make no atomics a soft failure in bernoulli_details.hpp.
>>> + Include an "escape macro" so thread safety can be disabled if certain
>>> + bernoulli features are to be used in a no-atomics environment. Fixes
>>> + https://github.com/boostorg/math/issues/673.
>>> +
>>> +---
>>> + .../detail/bernoulli_details.hpp | 10 +++++++---
>>> + libs/math/test/Jamfile.v2 | 3 +++
>>> + test/compile_test/bernoulli_no_atomic_d.cpp | 14 ++++++++++++++
>>> + test/compile_test/bernoulli_no_atomic_fail.cpp | 15 +++++++++++++++
>>> + test/compile_test/bernoulli_no_atomic_mp.cpp | 16 ++++++++++++++++
>>> + 5 files changed, 55 insertions(+), 3 deletions(-)
>>> + create mode 100644 test/compile_test/bernoulli_no_atomic_d.cpp
>>> + create mode 100644 test/compile_test/bernoulli_no_atomic_fail.cpp
>>> + create mode 100644 test/compile_test/bernoulli_no_atomic_mp.cpp
>>> +
>>> +diff --git a/boost/math/special_functions/detail/bernoulli_details.hpp b/boost/math/special_functions/detail/bernoulli_details.hpp
>>> +index cf35545264..8519b7c89c 100644
>>> +--- a/boost/math/special_functions/detail/bernoulli_details.hpp
>>> ++++ b/boost/math/special_functions/detail/bernoulli_details.hpp
>>> +@@ -360,7 +360,7 @@ class bernoulli_numbers_cache
>>> + return out;
>>> + }
>>> +
>>> +- #ifndef BOOST_HAS_THREADS
>>> ++ #if !defined(BOOST_HAS_THREADS) || defined(BOOST_MATH_BERNOULLI_UNTHREADED)
>>> + //
>>> + // Single threaded code, very simple:
>>> + //
>>> +@@ -382,6 +382,8 @@ class bernoulli_numbers_cache
>>> + *out = (i >= m_overflow_limit) ? policies::raise_overflow_error<T>("boost::math::bernoulli_b2n<%1%>(std::size_t)", 0, T(i), pol) : bn[i];
>>> + ++out;
>>> + }
>>> ++ #elif defined(BOOST_MATH_NO_ATOMIC_INT)
>>> ++ static_assert(sizeof(T) == 1, "Unsupported configuration: your platform appears to have no atomic integers. If you are happy with thread-unsafe code, then you may define BOOST_MATH_BERNOULLI_UNTHREADED to suppress this error.");
>>> + #else
>>> + //
>>> + // Double-checked locking pattern, lets us access cached already cached values
>>> +@@ -464,7 +466,7 @@ class bernoulli_numbers_cache
>>> + return out;
>>> + }
>>> +
>>> +- #ifndef BOOST_HAS_THREADS
>>> ++ #if !defined(BOOST_HAS_THREADS) || defined(BOOST_MATH_BERNOULLI_UNTHREADED)
>>> + //
>>> + // Single threaded code, very simple:
>>> + //
>>> +@@ -494,6 +496,8 @@ class bernoulli_numbers_cache
>>> + }
>>> + ++out;
>>> + }
>>> ++ #elif defined(BOOST_MATH_NO_ATOMIC_INT)
>>> ++ static_assert(sizeof(T) == 1, "Unsupported configuration: your platform appears to have no atomic integers. If you are happy with thread-unsafe code, then you may define BOOST_MATH_BERNOULLI_UNTHREADED to suppress this error.");
>>> + #else
>>> + //
>>> + // Double-checked locking pattern, lets us access cached already cached values
>>> +@@ -555,7 +559,7 @@ class bernoulli_numbers_cache
>>> + // The value at which we know overflow has already occurred for the Bn:
>>> + std::size_t m_overflow_limit;
>>> +
>>> +- #ifdef BOOST_HAS_THREADS
>>> ++ #if defined(BOOST_HAS_THREADS) && !defined(BOOST_MATH_NO_ATOMIC_INT)
>>> + std::mutex m_mutex;
>>> + atomic_counter_type m_counter, m_current_precision;
>>> + #else
>>> +diff --git a/libs/math/test/Jamfile.v2 b/libs/math/test/Jamfile.v2
>>> +index 52fb87f5e5..3ac63f9279 100644
>>> +--- a/libs/math/test/Jamfile.v2
>>> ++++ b/libs/math/test/Jamfile.v2
>>> +@@ -1137,6 +1137,9 @@ test-suite misc :
>>> +
>>> + # [ run __temporary_test.cpp test_instances//test_instances : : : <test-info>always_show_run_output <pch>off ]
>>> + [ compile test_no_long_double_policy.cpp ]
>>> ++ [ compile compile_test/bernoulli_no_atomic_d.cpp ]
>>> ++ [ compile compile_test/bernoulli_no_atomic_mp.cpp ]
>>> ++ [ compile-fail compile_test/bernoulli_no_atomic_fail.cpp ]
>>> + ;
>>> +
>>> + test-suite interpolators :
>>> +diff --git a/test/compile_test/bernoulli_no_atomic_d.cpp b/test/compile_test/bernoulli_no_atomic_d.cpp
>>> +new file mode 100644
>>> +index 0000000000..61926f7e1f
>>> +--- /dev/null
>>> ++++ b/test/compile_test/bernoulli_no_atomic_d.cpp
>>> +@@ -0,0 +1,14 @@
>>> ++// (C) Copyright John Maddock 2021.
>>> ++// Use, modification and distribution are subject to the
>>> ++// Boost Software License, Version 1.0. (See accompanying file
>>> ++// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
>>> ++
>>> ++#define BOOST_MATH_NO_ATOMIC_INT
>>> ++
>>> ++#include <boost/math/special_functions/bernoulli.hpp>
>>> ++#include "test_compile_result.hpp"
>>> ++
>>> ++void compile_and_link_test()
>>> ++{
>>> ++ check_result<double>(boost::math::bernoulli_b2n<double>(4));
>>> ++}
>>> +diff --git a/test/compile_test/bernoulli_no_atomic_fail.cpp b/test/compile_test/bernoulli_no_atomic_fail.cpp
>>> +new file mode 100644
>>> +index 0000000000..bbd7152412
>>> +--- /dev/null
>>> ++++ b/test/compile_test/bernoulli_no_atomic_fail.cpp
>>> +@@ -0,0 +1,15 @@
>>> ++// (C) Copyright John Maddock 2021.
>>> ++// Use, modification and distribution are subject to the
>>> ++// Boost Software License, Version 1.0. (See accompanying file
>>> ++// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
>>> ++
>>> ++#define BOOST_MATH_NO_ATOMIC_INT
>>> ++
>>> ++#include <boost/math/special_functions/bernoulli.hpp>
>>> ++#include <boost/multiprecision/cpp_bin_float.hpp>
>>> ++#include "test_compile_result.hpp"
>>> ++
>>> ++void compile_and_link_test()
>>> ++{
>>> ++ check_result<boost::multiprecision::cpp_bin_float_50>(boost::math::bernoulli_b2n<boost::multiprecision::cpp_bin_float_50>(4));
>>> ++}
>>> +diff --git a/test/compile_test/bernoulli_no_atomic_mp.cpp b/test/compile_test/bernoulli_no_atomic_mp.cpp
>>> +new file mode 100644
>>> +index 0000000000..8d5a6e78e6
>>> +--- /dev/null
>>> ++++ b/test/compile_test/bernoulli_no_atomic_mp.cpp
>>> +@@ -0,0 +1,16 @@
>>> ++// (C) Copyright John Maddock 2021.
>>> ++// Use, modification and distribution are subject to the
>>> ++// Boost Software License, Version 1.0. (See accompanying file
>>> ++// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
>>> ++
>>> ++#define BOOST_MATH_NO_ATOMIC_INT
>>> ++#define BOOST_MATH_BERNOULLI_UNTHREADED
>>> ++
>>> ++#include <boost/math/special_functions/bernoulli.hpp>
>>> ++#include <boost/multiprecision/cpp_bin_float.hpp>
>>> ++#include "test_compile_result.hpp"
>>> ++
>>> ++void compile_and_link_test()
>>> ++{
>>> ++ check_result<boost::multiprecision::cpp_bin_float_50>(boost::math::bernoulli_b2n<boost::multiprecision::cpp_bin_float_50>(4));
>>> ++}
>>> diff --git a/package/boost/Config.in b/package/boost/Config.in
>>> index d9ce841a92..f6dea1eaf7 100644
>>> --- a/package/boost/Config.in
>>> +++ b/package/boost/Config.in
>>> @@ -254,7 +254,6 @@ comment "boost-log needs a toolchain not affected by GCC bug 64735"
>>>
>>> config BR2_PACKAGE_BOOST_MATH
>>> bool "boost-math"
>>> - depends on BR2_TOOLCHAIN_SUPPORTS_ALWAYS_LOCKFREE_ATOMIC_INTS
>>> help
>>> Boost.Math includes several contributions in the domain of
>>> mathematics:
>>> --
>>> 2.33.0
>>>
>>> _______________________________________________
>>> buildroot mailing list
>>> buildroot@lists.buildroot.org
>>> https://lists.buildroot.org/mailman/listinfo/buildroot
>> --
>> .-----------------.--------------------.------------------.--------------------.
>> | Yann E. MORIN | Real-Time Embedded | /"\ ASCII RIBBON | Erics' conspiracy: |
>> | +33 662 376 056 | Software Designer | \ / CAMPAIGN | ___ |
>> | +33 561 099 427 `------------.-------: X AGAINST | \e/ There is no |
>> | http://ymorin.is-a-geek.org/ | _/*\_ | / \ HTML MAIL | v conspiracy. |
>> '------------------------------^-------^------------------^--------------------'
>> _______________________________________________
>> buildroot mailing list
>> buildroot@lists.buildroot.org
>> https://lists.buildroot.org/mailman/listinfo/buildroot
_______________________________________________
buildroot mailing list
buildroot@lists.buildroot.org
https://lists.buildroot.org/mailman/listinfo/buildroot
^ permalink raw reply [flat|nested] 5+ messages in thread* Re: [Buildroot] [PATCH v2] package/boost: fix math with no atomics
2021-09-12 15:00 ` Michael Nosthoff via buildroot
@ 2021-09-12 15:25 ` Yann E. MORIN
0 siblings, 0 replies; 5+ messages in thread
From: Yann E. MORIN @ 2021-09-12 15:25 UTC (permalink / raw)
To: Michael Nosthoff; +Cc: buildroot
Michael, All,
On 2021-09-12 17:00 +0200, Michael Nosthoff via buildroot spake thusly:
> On 12.09.21 13:36, Yann E. MORIN wrote:
> >diff --git a/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch b/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch
> >
> >>>new file mode 100644
> >>>index 0000000000..121355d71e
> >>>--- /dev/null
> >>>+++ b/package/boost/0002-math-provide-graceful-failure-for-bernoulli-code-on-platforms-with-no-atomics.patch
> >>>@@ -0,0 +1,47 @@
> >>>+From 32bd6197353f6ea8e5bef01f09e25c944141acfc Mon Sep 17 00:00:00 2001
> >>>+From: jzmaddock <john@johnmaddock.co.uk>
> >>>+Date: Wed, 1 Sep 2021 18:54:54 +0100
> >>>+Subject: [PATCH] Allow definition of BOOST_MATH_NO_ATOMIC_INT on the command
> >>>+ line. Allows us to test/emulate platforms with no atomic integers.
> >>>+
> >Arg, I forgot a few details about the individual patches:
> >
> > - you should add a small comment to explain the origin of the patch
> > - and add your own SoB line
> >
> >Usually, I do something like:
> >
> > [your@email: backport from upstream 32bd6197353f6ea8e5bef01f09e25c944141acfc]
> > Signed-off-by: Your NAME <your@email>
> >
> >Can you send a fixup please?
>
> Sure! just to be sure: what do you mean by fixup? should I commit using
> --fixup and send as new patch?
I've applied already, and pushed, so please send a new patch.
Thanks!
Regards,
Yann E. MORIN.
--
.-----------------.--------------------.------------------.--------------------.
| Yann E. MORIN | Real-Time Embedded | /"\ ASCII RIBBON | Erics' conspiracy: |
| +33 662 376 056 | Software Designer | \ / CAMPAIGN | ___ |
| +33 561 099 427 `------------.-------: X AGAINST | \e/ There is no |
| http://ymorin.is-a-geek.org/ | _/*\_ | / \ HTML MAIL | v conspiracy. |
'------------------------------^-------^------------------^--------------------'
_______________________________________________
buildroot mailing list
buildroot@lists.buildroot.org
https://lists.buildroot.org/mailman/listinfo/buildroot
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2021-09-12 15:26 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2021-09-12 9:12 [Buildroot] [PATCH v2] package/boost: fix math with no atomics Michael Nosthoff via buildroot
2021-09-12 9:47 ` Yann E. MORIN
2021-09-12 11:36 ` Yann E. MORIN
2021-09-12 15:00 ` Michael Nosthoff via buildroot
2021-09-12 15:25 ` Yann E. MORIN
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox