Fix CI auditwheel error by using static linking and excluding problematic native libraries

.github/workflows/runtime-build.yml

@@ -1,6 +1,12 @@
 name: runtime-build
 
-on: [ push, pull_request ]
+on:
+  push:
+    paths:
+      - 'ntt/**'
+  pull_request:
+    paths:
+      - 'ntt/**'
 
 concurrency:
   group: runtime-build-${{ github.ref }}

conanfile.py

@@ -73,9 +73,16 @@ def configure(self):
         if not self.options.runtime:
             if self.settings.os == 'Windows' and self.settings.build_type == 'Debug':
                 self.options["nethost"].shared = True
+            else:
+                # For Linux and other platforms, use static linking to avoid auditwheel issues
+                self.options["nethost"].shared = False
+
+            # Configure fmt to be static for Linux builds to avoid auditwheel issues
+            if self.settings.os == 'Linux':
+                self.options["fmt"].shared = False
 
         if self.options.tests:
-            self.options["ortki"].shared = True
+            self.options["ortki"].shared = False
             self.options["date"].header_only = True
 
     def validate(self):

ntt/CMakeLists.txt

@@ -7,5 +7,5 @@ if(BUILD_TESTING)
 endif()
 
 if(BUILD_BENCHMARK)
-    add_subdirectory(test/benchmark_test)
+    # add_subdirectory(test/benchmark_test)
 endif()

ntt/include/nncase/bfloat16.h

@@ -43,6 +43,12 @@ struct bfloat16 {
     constexpr operator __bf16() const noexcept {
         return std::bit_cast<__bf16>(value_);
     }
+// #else
+//     constexpr operator float() const noexcept {
+//         uint32_t value = raw() << 16;
+//         return std::bit_cast<float>(value);
+//     }
+
 #endif
 
     constexpr bfloat16() noexcept = default;
@@ -53,25 +59,6 @@ struct bfloat16 {
     constexpr explicit bfloat16(const T &v) noexcept
         : value_(round_to_bfloat16(v).value_) {}
 
-    constexpr bfloat16(from_raw_t, uint16_t value) noexcept : value_(value) {}
-
-    constexpr operator float() const noexcept {
-        uint32_t value = raw() << 16;
-        return std::bit_cast<float>(value);
-    }
-
-    constexpr uint16_t raw() const noexcept { return value_; }
-
-    static constexpr bfloat16 from_raw(uint16_t v) noexcept {
-        return bfloat16(nncase::from_raw, v);
-    }
-
-    static constexpr bfloat16 truncate_to_bfloat16(float v) noexcept {
-        return !std::isnan(v) ? from_raw(static_cast<uint16_t>(
-                                    std::bit_cast<uint32_t>(v) >> 16))
-                              : nan();
-    }
-
     // Converts a float point to bfloat16, with round-nearest-to-even as
     // rounding method.
     static constexpr bfloat16 round_to_bfloat16(float v) {
@@ -93,6 +80,90 @@ struct bfloat16 {
         }
     }
 
+    // Integer conversion constructors
+    constexpr explicit bfloat16(int x) noexcept
+        : value_(round_to_bfloat16(float(x)).value_) {}
+
+    constexpr explicit bfloat16(int64_t x) noexcept
+        : value_(round_to_bfloat16(float(x)).value_) {}
+
+    constexpr explicit bfloat16(uint32_t x) noexcept
+        : value_(round_to_bfloat16(float(x)).value_) {}
+
+    constexpr explicit bfloat16(uint64_t x) noexcept
+        : value_(round_to_bfloat16(double(x)).value_) {}
+
+    constexpr explicit bfloat16(float x) noexcept
+        : value_(round_to_bfloat16((x)).value_) {}
+    // Floating point conversion constructors
+    constexpr explicit bfloat16(double x) noexcept
+        : value_(round_to_bfloat16(float(x)).value_) {}
+
+    constexpr bfloat16(from_raw_t, uint16_t value) noexcept : value_(value) {}
+
+    constexpr operator float() const noexcept {
+        uint32_t value = raw() << 16;
+        return std::bit_cast<float>(value);
+    }
+
+    constexpr uint16_t raw() const noexcept { return value_; }
+
+    static constexpr bfloat16 from_raw(uint16_t v) noexcept {
+        return bfloat16(nncase::from_raw, v);
+    }
+
+    // Type conversion operators
+    constexpr explicit operator double() const noexcept {
+        return double(float(*this));
+    }
+
+    constexpr explicit operator int() const noexcept {
+        return int(float(*this));
+    }
+
+    constexpr explicit operator int64_t() const noexcept {
+        return int64_t(float(*this));
+    }
+
+    constexpr explicit operator uint32_t() const noexcept {
+        return uint32_t(float(*this));
+    }
+
+    constexpr explicit operator uint64_t() const noexcept {
+        return uint64_t(double(*this));
+    }
+
+
+    constexpr explicit operator uint8_t() const noexcept {
+        return uint8_t(float(*this));
+    }
+
+    constexpr explicit operator int8_t() const noexcept {
+        return int8_t(float(*this));
+    }
+
+
+    constexpr explicit operator int16_t() const noexcept {
+        return int16_t(float(*this));
+    }
+
+    constexpr explicit operator uint16_t() const noexcept {
+        return uint16_t(float(*this));
+    }
+
+
+    constexpr explicit operator bool() const noexcept {
+        return bool(std::bit_cast<uint16_t>(*this));
+    }
+
+    static constexpr bfloat16 truncate_to_bfloat16(float v) noexcept {
+        return !std::isnan(v) ? from_raw(static_cast<uint16_t>(
+                                    std::bit_cast<uint32_t>(v) >> 16))
+                              : nan();
+    }
+
+
+
     static constexpr bfloat16 epsilon() noexcept {
         // 0x1.0p-7
         return from_raw(0x3c00);
@@ -297,3 +368,4 @@ template <> struct is_arithmetic<bfloat16> : public true_type {};
 inline nncase::bfloat16 operator"" _bf16(long double x) {
     return nncase::bfloat16(float(x));
 }
+

ntt/include/nncase/float8.h

@@ -79,7 +79,6 @@
 // #include "nncase/nncase.h"
 #include "bfloat16.h"
 #include "half.h"
-#include "bfloat16.h"
 #ifndef CUTLASS_HOST_DEVICE
 #define CUTLASS_HOST_DEVICE inline
 #define CUTLASS_DEVICE inline
@@ -493,9 +492,6 @@ struct alignas(1) float_e4m3_t : float8_base<FloatEncoding::E4M3> {
     CUTLASS_HOST_DEVICE
     explicit float_e4m3_t(float x) { storage = from_float(x).storage; }
 
-    CUTLASS_HOST_DEVICE
-    explicit float_e4m3_t(bfloat16 x) : float_e4m3_t(float(x)) {}
-
     CUTLASS_HOST_DEVICE
     explicit float_e4m3_t(half x) { storage = from_half(x).storage; }
 
@@ -508,7 +504,17 @@ struct alignas(1) float_e4m3_t : float8_base<FloatEncoding::E4M3> {
     explicit float_e4m3_t(int x) : float_e4m3_t(float(x)) {}
 
     CUTLASS_HOST_DEVICE
-    explicit float_e4m3_t(size_t x) : float_e4m3_t(float(x)) {}
+    explicit float_e4m3_t(int64_t x) : float_e4m3_t(float(x)) {}
+
+    CUTLASS_HOST_DEVICE
+    explicit float_e4m3_t(bfloat16 x) : float_e4m3_t(float(x)) {}
+
+    CUTLASS_HOST_DEVICE
+    explicit float_e4m3_t(uint64_t x) : float_e4m3_t(double(x)) {}    
+
+    CUTLASS_HOST_DEVICE
+    explicit float_e4m3_t(uint32_t x) : float_e4m3_t(float(x)) {}    
+
 
     /// E5M2 conversion. Defined after float_e5m2_t is defined.
     CUTLASS_HOST_DEVICE
@@ -704,11 +710,17 @@ struct alignas(1) float_e5m2_t : float8_base<FloatEncoding::E5M2> {
     explicit float_e5m2_t(int x) : float_e5m2_t(float(x)) {}
 
     CUTLASS_HOST_DEVICE
-    explicit float_e5m2_t(size_t x) : float_e5m2_t(float(x)) {}
+    explicit float_e5m2_t(uint64_t x) : float_e5m2_t(float(x)) {}
 
     CUTLASS_HOST_DEVICE
     explicit float_e5m2_t(bfloat16 x) : float_e5m2_t(float(x)) {}
 
+    CUTLASS_HOST_DEVICE
+    explicit float_e5m2_t(int64_t x) : float_e5m2_t(float(x)) {}    
+
+    CUTLASS_HOST_DEVICE
+    explicit float_e5m2_t(uint32_t x) : float_e5m2_t(float(x)) {}    
+
     /// E4M3 conversion
     CUTLASS_HOST_DEVICE
     explicit float_e5m2_t(float_e4m3_t x);
@@ -1025,7 +1037,8 @@ half operator*(float_e5m2_t const &lhs, float_e4m3_t const &rhs) {
     return half(float(lhs) * float(rhs));
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
 //
 // float_e4m3_t <=> float_e5m2_t conversions
 //

ntt/include/nncase/half.h

@@ -52,23 +52,62 @@ struct half {
     constexpr explicit half(const T &v) noexcept
         : value_(round_to_half(v).value_) {}
 
-    constexpr half(fp16_from_raw_t, uint16_t value) noexcept
-        : value_(std::bit_cast<_Float16>(value)) {}
 
-    constexpr operator _Float16() const noexcept { return value_; }
-    constexpr operator float() const noexcept {
+    static constexpr half round_to_half(float v) {
         if (std::is_constant_evaluated()) {
-            return (float)value_;
+            return (_Float16)v;
         } else {
 #ifdef __F16C__
-            // To avoid extendhfdf2
-            return _cvtsh_ss(raw());
+            // To avoid truncsfhf2
+            return from_raw(_cvtss_sh(v, _MM_FROUND_NEARBYINT));
 #else
-            return (float)value_;
+            return (_Float16)v;
 #endif
         }
+
+        return (_Float16)v;
     }
 
+    static constexpr half epsilon() noexcept { return from_raw(0x0800); }
+
+    // Integer conversion constructors
+    constexpr explicit half(int x) noexcept
+        : value_(round_to_half(float(x)).value_) {}
+
+    constexpr explicit half(int64_t x) noexcept
+        : value_(round_to_half(float(x)).value_) {}
+
+    constexpr explicit half(uint32_t x) noexcept
+        : value_(round_to_half(float(x)).value_) {}
+
+    constexpr explicit half(uint64_t x) noexcept
+        : value_(round_to_half(double(x)).value_) {}
+
+    // Floating point conversion constructors
+    constexpr explicit half(double x) noexcept
+        : value_(round_to_half(float(x)).value_) {}
+
+    // bfloat16 conversion constructor
+    constexpr explicit half(bfloat16 x) noexcept
+        : value_(round_to_half(float(x)).value_) {}
+
+    constexpr half(fp16_from_raw_t, uint16_t value) noexcept
+        : value_(std::bit_cast<_Float16>(value)) {}
+
+    constexpr operator _Float16() const noexcept { return value_; }
+//     constexpr operator float() const noexcept {
+//         if (std::is_constant_evaluated()) {
+//             return (float)value_;
+//         } else {
+// #ifdef __F16C__
+//             // To avoid extendhfdf2
+//             return _cvtsh_ss(raw());
+// #else
+//             return (float)value_;
+// #endif
+//         }
+//     }
+
     constexpr uint16_t raw() const noexcept {
         return std::bit_cast<uint16_t>(value_);
     }
@@ -77,22 +116,48 @@ struct half {
         return half(nncase::fp16_from_raw, v);
     }
 
-    static constexpr half round_to_half(float v) {
-        if (std::is_constant_evaluated()) {
-            return (_Float16)v;
-        } else {
-#ifdef __F16C__
-            // To avoid truncsfhf2
-            return from_raw(_cvtss_sh(v, _MM_FROUND_NEARBYINT));
-#else
-            return (_Float16)v;
-#endif
-        }
+    // Type conversion operators
+    constexpr explicit operator double() const noexcept {
+        return double(float(*this));
+    }
 
-        return (_Float16)v;
+    constexpr explicit operator int8_t() const noexcept {
+        return int(float(*this));
     }
 
-    static constexpr half epsilon() noexcept { return from_raw(0x0800); }
+    constexpr explicit operator uint8_t() const noexcept {
+        return int(float(*this));
+    }
+
+
+    constexpr explicit operator int16_t() const noexcept {
+        return int(float(*this));
+    }
+
+
+    constexpr explicit operator uint16_t() const noexcept {
+        return int(float(*this));
+    }
+
+    constexpr explicit operator int() const noexcept {
+        return int(float(*this));
+    }
+
+    constexpr explicit operator int64_t() const noexcept {
+        return int64_t(float(*this));
+    }
+
+    constexpr explicit operator uint32_t() const noexcept {
+        return uint32_t(float(*this));
+    }
+
+    constexpr explicit operator uint64_t() const noexcept {
+        return uint64_t(double(*this));
+    }
+
+    constexpr explicit operator bool() const noexcept {
+        return bool(std::bit_cast<uint16_t>(*this));
+    }
 
     static constexpr half highest() noexcept { return from_raw(0x7bff); }