cactus-react-native 1.5.0 → 1.10.0

package/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/kernel.h

@@ -4,6 +4,8 @@
 #include <cstddef>
 #include <arm_neon.h>
 
+enum class Precision;
+
 enum class ScalarOpType {
     ADD,
     SUBTRACT,
@@ -12,15 +14,17 @@ enum class ScalarOpType {
     EXP,
     SQRT,
     COS,
-    SIN
+    SIN,
+    LOG
 };
 
-constexpr size_t KV_QUANT_GROUP_SIZE = 128;
+constexpr size_t KV_QUANT_GROUP_SIZE = 32;
 
 void cactus_add_f16(const __fp16* a, const __fp16* b, __fp16* output, size_t num_elements);
 void cactus_add_f16_clipped(const __fp16* a, const __fp16* b, __fp16* output, size_t num_elements);
 void cactus_subtract_f16(const __fp16* a, const __fp16* b, __fp16* output, size_t num_elements);
 void cactus_multiply_f16(const __fp16* a, const __fp16* b, __fp16* output, size_t num_elements);
+void cactus_add_scaled_f16(const __fp16* base, const __fp16* src, __fp16* output, size_t num_elements, float scale);
 void cactus_divide_f16(const __fp16* a, const __fp16* b, __fp16* output, size_t num_elements);
 
 void cactus_add_broadcast_f16(const __fp16* a, const __fp16* b, __fp16* output,
@@ -38,14 +42,35 @@ void cactus_divide_broadcast_f16(const __fp16* a, const __fp16* b, __fp16* outpu
 
 void cactus_scalar_op_f16(const __fp16* input, __fp16* output, size_t num_elements, float scalar_value, ScalarOpType op_type);
 
+void cactus_gemv_int8(const int8_t* A, float A_scale,
+                      const int8_t* B, const __fp16* B_scales,
+                      __fp16* C, size_t K, size_t N, size_t group_size);
+
+void cactus_gemm_int8(const int8_t* A, const float* A_scales,
+                      const int8_t* B, const __fp16* B_scales,
+                      __fp16* C, size_t M, size_t K, size_t N, size_t group_size);
+
 void cactus_matmul_int8(const int8_t* A, const float* A_scales,
                         const int8_t* B, const __fp16* B_scales,
                         __fp16* C, size_t M, size_t K, size_t N, size_t group_size);
 
+void cactus_gemv_int4(const int8_t* A, float A_scale,
+                      const int8_t* B_packed, const __fp16* B_scales,
+                      __fp16* C, size_t K, size_t N, size_t group_size);
+
+void cactus_gemm_int4(const int8_t* A, const float* A_scales,
+                      const int8_t* B_packed, const __fp16* B_scales,
+                      __fp16* C, size_t M, size_t K, size_t N, size_t group_size);
+
 void cactus_matmul_int4(const int8_t* A, const float* A_scales,
-                        const uint8_t* B_packed, const __fp16* B_scales,
+                        const int8_t* B_packed, const __fp16* B_scales,
                         __fp16* C, size_t M, size_t K, size_t N, size_t group_size);
 
+void cactus_matmul_integer(Precision precision,
+                            const int8_t* A, const float* A_scales,
+                            const int8_t* B, const __fp16* B_scales,
+                            __fp16* C, size_t M, size_t K, size_t N, size_t group_size);
+
 void cactus_matmul_f16(const __fp16* a, const __fp16* b_transposed, __fp16* c,
                        size_t M, size_t K, size_t N);
 
@@ -75,19 +100,70 @@ void cactus_rms_norm_f16(const __fp16* input, const __fp16* weight, __fp16* outp
 void cactus_rope_f16(const __fp16* input, __fp16* output, size_t batch_size, size_t seq_len,
                       size_t num_heads, size_t head_dim, size_t start_pos, float theta);
 
+void cactus_gpt_j_rope_f16(const __fp16* input, __fp16* output, size_t batch_size, size_t seq_len,
+                           size_t num_heads, size_t head_dim, size_t rot_dim, size_t start_pos, float theta);
+
 void cactus_softmax_f16(const __fp16* input, __fp16* output, size_t batch_size,
                          size_t seq_len, size_t vocab_size);
 
+void cactus_relu_f16(const __fp16* input, __fp16* output, size_t num_elements);
+
 void cactus_silu_f16(const __fp16* input, __fp16* output, size_t num_elements);
 
 void cactus_gelu_f16(const __fp16* input, __fp16* output, size_t num_elements);
 
 void cactus_gelu_f16_erf(const __fp16* input, __fp16* output, size_t num_elements);
 
+void cactus_sigmoid_f16(const __fp16* input, __fp16* output, size_t num_elements);
+
+void cactus_tanh_f16(const __fp16* input, __fp16* output, size_t num_elements);
+
+void cactus_glu_f16(
+    const __fp16* input,
+    __fp16* output,
+    size_t outer_size,
+    size_t split_size,
+    size_t inner_size
+);
+
+void cactus_glu_f32(
+    const float* input,
+    float* output,
+    size_t outer_size,
+    size_t split_size,
+    size_t inner_size
+);
+
+void cactus_batchnorm_f16(
+    const __fp16* input,
+    const float* weight,
+    const float* bias,
+    const float* running_mean,
+    const float* running_var,
+    __fp16* output,
+    size_t outer_size,
+    size_t channels,
+    size_t inner_size,
+    float epsilon
+);
+
+void cactus_batchnorm_f32(
+    const float* input,
+    const float* weight,
+    const float* bias,
+    const float* running_mean,
+    const float* running_var,
+    float* output,
+    size_t outer_size,
+    size_t channels,
+    size_t inner_size,
+    float epsilon
+);
+
 void cactus_attention_f16(const __fp16* queries, const __fp16* keys, const __fp16* values, __fp16* output,
                           size_t batch_size, size_t seq_len, size_t kv_seq_len, size_t num_q_heads, size_t num_kv_heads,
                           size_t head_dim, float scale, const __fp16* mask, size_t position_offset = 0, size_t window_size = 0,
-                          bool is_causal = true);
+                          bool is_causal = true, bool mask_is_additive = false, bool mask_per_head = false);
 
 void cactus_attention_hybrid_int8_fp16(
     const __fp16* queries,        
@@ -100,7 +176,7 @@ void cactus_attention_hybrid_int8_fp16(
     __fp16* output,
     size_t batch_size, size_t seq_len, size_t cache_len, size_t new_len,
     size_t num_q_heads, size_t num_kv_heads, size_t head_dim,
-    float scale, size_t position_offset = 0, bool is_causal = true,
+    float scale, size_t position_offset = 0, bool is_causal = true, size_t window_size = 0,
     size_t group_size = KV_QUANT_GROUP_SIZE);
 
 void cactus_conv1d_causal_depthwise_f16(
@@ -124,6 +200,96 @@ void cactus_conv1d_f16_k3(
     size_t stride
 );
 
+void cactus_conv1d_f16(
+    const __fp16* input,
+    const __fp16* weight,
+    const __fp16* bias,
+    __fp16* output,
+    size_t N,
+    size_t L,
+    size_t C_in,
+    size_t C_out,
+    size_t K,
+    size_t stride
+);
+
+void cactus_stft_f16(
+    const __fp16* input,
+    const __fp16* weight,
+    __fp16* output,
+    size_t N, size_t L,
+    size_t C_in, size_t C_out,
+    size_t K, size_t stride,
+    size_t num_fft_bins
+);
+
+void cactus_conv1d_f16_k7s3_oc8(
+    const __fp16* input,
+    const __fp16* Wpack,
+    const __fp16* bias,
+    __fp16* output,
+    size_t N,
+    size_t L,
+    size_t C_in,
+    size_t C_out
+);
+
+void cactus_conv1d_same_depthwise_f16_k9(
+    const __fp16* input,
+    const __fp16* weight,
+    const __fp16* bias,
+    __fp16* output,
+    size_t N,
+    size_t L,
+    size_t C
+);
+
+void cactus_conv2d_f16_k3s2p1_nchw(
+    const __fp16* input,
+    const __fp16* weight,
+    const __fp16* bias,
+    __fp16* output,
+    size_t N,
+    size_t C_in,
+    size_t H,
+    size_t W,
+    size_t C_out
+);
+
+void cactus_conv2d_depthwise_f16_k3s2p1_nchw(
+    const __fp16* input,
+    const __fp16* weight,
+    const __fp16* bias,
+    __fp16* output,
+    size_t N,
+    size_t C,
+    size_t H,
+    size_t W
+);
+
+void cactus_conv2d_pointwise_f16_1x1_nchw_gemm(
+    const __fp16* input,
+    const __fp16* weight,
+    const __fp16* bias,
+    __fp16* output,
+    size_t N,
+    size_t C_in,
+    size_t H,
+    size_t W,
+    size_t C_out
+);
+
+void cactus_conv1d_pointwise_f16_gemm(
+    const __fp16* input,
+    const __fp16* weight,
+    const __fp16* bias,
+    __fp16* output,
+    size_t N,
+    size_t L,
+    size_t C_in,
+    size_t C_out
+);
+
 void cactus_bilinear_interpolation_f16(const __fp16* input, __fp16* output, size_t src_height, size_t src_width, size_t embed_dim,
                                        size_t dst_height, size_t dst_width);
 
@@ -162,4 +328,19 @@ inline size_t kv_scales_count(size_t seq_len, size_t kv_heads, size_t head_dim,
 
 void cactus_unpack_int4_to_int8(const uint8_t* packed, int8_t* unpacked, size_t unpacked_count);
 
-#endif
+void cactus_lstm_cell_f16(
+    const __fp16* x_input,
+    const __fp16* h_prev,
+    const __fp16* c_prev,
+    const __fp16* weight_ih,
+    const __fp16* weight_hh,
+    const __fp16* bias_ih,
+    const __fp16* bias_hh,
+    __fp16* h_new,
+    __fp16* c_new,
+    size_t batch_size,
+    size_t input_size,
+    size_t hidden_size
+);
+
+#endif

package/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/kernel_utils.h

@@ -4,6 +4,7 @@
 #include <arm_neon.h>
 #if defined(__APPLE__)
 #include <TargetConditionals.h>
+#include <sys/sysctl.h>
 #endif
 #if defined(__ANDROID__)
 #include <sys/auxv.h>
@@ -43,58 +44,33 @@ inline void stream_store_f16x8(__fp16* dst, float16x8_t val) {
 #endif
 }
 
-#if defined(__ARM_FEATURE_DOTPROD)
-inline int32x4_t accum_dot(int32x4_t acc, int8x16_t a, int8x16_t b) {
-    return vdotq_s32(acc, a, b);
-}
-#else
-inline int32x4_t accum_dot(int32x4_t acc, int8x16_t a, int8x16_t b) {
-    int16x8_t prod_low = vmull_s8(vget_low_s8(a), vget_low_s8(b));
-    int32x4_t acc_high = vpaddlq_s16(vmull_s8(vget_high_s8(a), vget_high_s8(b)));
-    return vaddq_s32(vaddq_s32(acc, vpaddlq_s16(prod_low)), acc_high);
-}
-#endif
-
-// I8MM support: runtime detection on Android, compile-time on Apple
-#if defined(__ANDROID__) && defined(__aarch64__)
-
-inline bool cactus_has_i8mm() {
-    static int8_t supported = -1;
-    if (supported == -1) {
-        unsigned long hwcaps = getauxval(AT_HWCAP2);
-        supported = (hwcaps & HWCAP2_I8MM) ? 1 : 0;
-    }
-    return supported;
-}
-
-__attribute__((target("arch=armv8.2-a+i8mm")))
-inline int32x4_t accum_matmul(int32x4_t acc, int8x16_t a, int8x16_t b) {
-    return vmmlaq_s32(acc, a, b);
-}
-
-#elif defined(__APPLE__) && defined(__aarch64__)
-
-inline bool cactus_has_i8mm() {
-    return true;
-}
+inline bool cpu_has_sme2() {
+#if defined(__aarch64__)
+	static std::once_flag once;
+	static bool has = false;
+	
+	std::call_once(once, []() {
 
-__attribute__((target("i8mm")))
-inline int32x4_t accum_matmul(int32x4_t acc, int8x16_t a, int8x16_t b) {
-    return vmmlaq_s32(acc, a, b);
-}
+#if defined(__APPLE__)
+	int ret = 0;
+	size_t size = sizeof(ret);
+	if (sysctlbyname("hw.optional.arm.FEAT_SME2", &ret, &size, nullptr, 0) == 0) {
+		has = ret == 1;
+	}
+
+#elif defined(__ANDROID__)
+	unsigned long hwcap2 = getauxval(AT_HWCAP2);
+#ifdef HWCAP2_SME2
+	has = (hwcap2 & HWCAP2_SME2) != 0;
+#endif
 
+#endif
+	});
+	
+	return has;
 #else
-
-inline bool cactus_has_i8mm() {
-    return false;
-}
-
+	return false;
 #endif
-
-inline float16x8_t accum_f16_dot(float16x8_t acc, float16x8_t a_low, float16x8_t a_high,
-                                 float16x8_t b_low, float16x8_t b_high) {
-    acc = vfmaq_f16(acc, a_low, b_low);
-    return vfmaq_f16(acc, a_high, b_high);
 }
 
 inline float32x4_t fast_exp_f32x4(float32x4_t x) {
@@ -154,100 +130,10 @@ inline float32x4_t fast_tanh_f32x4(float32x4_t x) {
     return result;
 }
 
-inline int8x16_t unpack_int4_lo(uint8x16_t packed) {
-    uint8x16_t lo = vandq_u8(packed, vdupq_n_u8(0x0F));
-    uint8x16_t sign_mask = vcgtq_u8(lo, vdupq_n_u8(7));
-    uint8x16_t correction = vandq_u8(sign_mask, vdupq_n_u8(16));
-    return vreinterpretq_s8_u8(vsubq_u8(lo, correction));
-}
-
-inline int8x16_t unpack_int4_hi(uint8x16_t packed) {
-    uint8x16_t hi = vshrq_n_u8(packed, 4);
-    uint8x16_t sign_mask = vcgtq_u8(hi, vdupq_n_u8(7));
-    uint8x16_t correction = vandq_u8(sign_mask, vdupq_n_u8(16));
-    return vreinterpretq_s8_u8(vsubq_u8(hi, correction));
-}
-
-inline void unpack_int4_to_int8x32(uint8x16_t packed, int8x16_t& out_lo, int8x16_t& out_hi) {
-    int8x16_t lo_nibbles = unpack_int4_lo(packed);
-    int8x16_t hi_nibbles = unpack_int4_hi(packed);
-    int8x16x2_t interleaved = vzipq_s8(lo_nibbles, hi_nibbles);
-    out_lo = interleaved.val[0];
-    out_hi = interleaved.val[1];
-}
-
-inline int32x4_t int4_dot_asm(int32x4_t acc, uint8x16_t packed, int8x16_t a_lo, int8x16_t a_hi) {
-#if defined(__aarch64__)
-    int8x16_t b_lo, b_hi;
-
-    __asm__ __volatile__ (
-        "movi   v16.16b, #0x0F          \n"  // low nibble mask
-        "movi   v17.16b, #7             \n"  // sign threshold
-        "movi   v18.16b, #16            \n"  // sign correction
-
-        "and    %[b_lo].16b, %[packed].16b, v16.16b  \n"
-
-        "ushr   %[b_hi].16b, %[packed].16b, #4      \n"
-
-        "cmgt   v19.16b, %[b_lo].16b, v17.16b       \n"
-        "and    v19.16b, v19.16b, v18.16b           \n"
-        "sub    %[b_lo].16b, %[b_lo].16b, v19.16b   \n"
-
-        "cmgt   v20.16b, %[b_hi].16b, v17.16b       \n"
-        "and    v20.16b, v20.16b, v18.16b           \n"
-        "sub    %[b_hi].16b, %[b_hi].16b, v20.16b   \n"
-
-        "zip1   v21.16b, %[b_lo].16b, %[b_hi].16b   \n"
-        "zip2   v22.16b, %[b_lo].16b, %[b_hi].16b   \n"
-
-        ".arch armv8.2-a+dotprod                    \n"
-        "sdot   %[acc].4s, %[a_lo].16b, v21.16b     \n"
-        "sdot   %[acc].4s, %[a_hi].16b, v22.16b     \n"
-
-        : [acc] "+w"(acc), [b_lo] "=w"(b_lo), [b_hi] "=w"(b_hi)
-        : [packed] "w"(packed), [a_lo] "w"(a_lo), [a_hi] "w"(a_hi)
-        : "v16", "v17", "v18", "v19", "v20", "v21", "v22"
-    );
-
-    return acc;
-#else
-    int8x16_t b_lo, b_hi;
-    unpack_int4_to_int8x32(packed, b_lo, b_hi);
-    acc = accum_dot(acc, a_lo, b_lo);
-    acc = accum_dot(acc, a_hi, b_hi);
-    return acc;
-#endif
-}
-
-inline int32_t int4_dot_m1_asm(const int8_t* a_ptr, const uint8_t* b_packed, size_t group_size) {
-#if defined(__aarch64__)
-    int32x4_t acc = vdupq_n_s32(0);
-
-    for (size_t k = 0; k < group_size; k += 64) {
-        uint8x16_t p0 = vld1q_u8(b_packed + k/2);
-        uint8x16_t p1 = vld1q_u8(b_packed + k/2 + 16);
-
-        int8x16_t a0 = vld1q_s8(a_ptr + k);
-        int8x16_t a1 = vld1q_s8(a_ptr + k + 16);
-        int8x16_t a2 = vld1q_s8(a_ptr + k + 32);
-        int8x16_t a3 = vld1q_s8(a_ptr + k + 48);
-
-        acc = int4_dot_asm(acc, p0, a0, a1);
-        acc = int4_dot_asm(acc, p1, a2, a3);
-    }
-
-    return vaddvq_s32(acc);
-#else
-    int32x4_t acc = vdupq_n_s32(0);
-    for (size_t k = 0; k < group_size; k += 32) {
-        uint8x16_t packed = vld1q_u8(b_packed + k/2);
-        int8x16_t b_lo, b_hi;
-        unpack_int4_to_int8x32(packed, b_lo, b_hi);
-        acc = accum_dot(acc, vld1q_s8(a_ptr + k), b_lo);
-        acc = accum_dot(acc, vld1q_s8(a_ptr + k + 16), b_hi);
-    }
-    return vaddvq_s32(acc);
-#endif
+inline void unpack_int4_as_int8x16x2(const uint8_t* ptr, int8x16_t& high_decoded, int8x16_t& low_decoded) {
+    int8x16_t packed = vreinterpretq_s8_u8(vld1q_u8(ptr));
+    high_decoded = vshrq_n_s8(packed, 4);
+    low_decoded = vshrq_n_s8(vshlq_n_s8(packed, 4), 4);
 }
 
 namespace CactusThreading {
@@ -431,18 +317,32 @@ namespace CactusThreading {
     struct GemmThreading {
         #if defined(__ANDROID__)
         static size_t get_num_threads(size_t M, size_t pool_size) {
-            if (M <= 1) return 1; 
-            return pool_size; 
+            if (M <= 1) return 1;
+            return pool_size;
+        }
+        static size_t get_gemv_threads(size_t /*N_blocks*/, size_t /*pool_size*/) {
+            return 1; 
         }
         #elif defined(__APPLE__) && TARGET_OS_IPHONE
+        static constexpr size_t GEMV_MIN_N_BLOCKS = 512; 
         static size_t get_num_threads(size_t M, size_t pool_size) {
-            if (M <= 1) return std::min(pool_size, static_cast<size_t>(2)); 
-            return pool_size; 
+            if (M <= 1) return std::min(pool_size, static_cast<size_t>(2));
+            return pool_size;
+        }
+        static size_t get_gemv_threads(size_t N_blocks, size_t pool_size) {
+            if (N_blocks < GEMV_MIN_N_BLOCKS) return 1;
+            return std::min(pool_size, static_cast<size_t>(3));
         }
-        #else // Mac
+        #else 
+        static constexpr size_t GEMV_MIN_N_BLOCKS = 256;  
         static size_t get_num_threads(size_t M, size_t pool_size) {
             if (M <= 1) return std::min(pool_size, static_cast<size_t>(4));
-            return pool_size; 
+            return pool_size;
+        }
+        static size_t get_gemv_threads(size_t N_blocks, size_t pool_size) {
+            if (N_blocks < GEMV_MIN_N_BLOCKS) return 1;
+            if (N_blocks < 512) return std::min(pool_size, static_cast<size_t>(2));
+            return std::min(pool_size, static_cast<size_t>(5));
         }
         #endif
     };
@@ -599,4 +499,4 @@ namespace CactusThreading {
 }
 
 
-#endif // KERNEL_UTILS_H 
+#endif // KERNEL_UTILS_H 

package/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus.h

@@ -7,7 +7,6 @@
 #include "engine/engine.h"
 #include "models/model.h"
 #include "ffi/cactus_ffi.h"
-#include "ffi/cactus_telemetry.h"
 #include "npu/npu.h"
 
 #endif // CACTUS_H

package/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus_cloud.h

@@ -0,0 +1,48 @@
+#ifndef CACTUS_CLOUD_H
+#define CACTUS_CLOUD_H
+
+#include "cactus_utils.h"
+#include <string>
+#include <vector>
+
+namespace cactus {
+namespace ffi {
+
+struct CloudResponse {
+    std::string transcript;
+    std::string api_key_hash;
+    bool used_cloud = false;
+    std::string error;
+};
+
+struct CloudCompletionRequest {
+    std::vector<cactus::engine::ChatMessage> messages;
+    std::vector<ToolFunction> tools;
+    std::string local_output;
+    std::vector<std::string> local_function_calls;
+    bool has_images = false;
+    std::string cloud_key;
+};
+
+struct CloudCompletionResult {
+    bool ok = false;
+    bool used_cloud = false;
+    std::string response;
+    std::vector<std::string> function_calls;
+    std::string error;
+};
+
+std::string cloud_base64_encode(const uint8_t* data, size_t len);
+std::vector<uint8_t> cloud_build_wav(const uint8_t* pcm, size_t pcm_bytes);
+std::string resolve_cloud_api_key(const char* cloud_key_param);
+CloudResponse cloud_transcribe_request(const std::string& audio_b64,
+                                       const std::string& fallback_text,
+                                       long timeout_seconds = 15L,
+                                       const char* cloud_key = nullptr);
+CloudCompletionResult cloud_complete_request(const CloudCompletionRequest& request,
+                                             long timeout_ms);
+
+} // namespace ffi
+} // namespace cactus
+
+#endif // CACTUS_CLOUD_H