cactus-react-native 1.5.0 → 1.7.0

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,59 +44,6 @@ 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;
-}
-
-__attribute__((target("i8mm")))
-inline int32x4_t accum_matmul(int32x4_t acc, int8x16_t a, int8x16_t b) {
-    return vmmlaq_s32(acc, a, b);
-}
-
-#else
-
-inline bool cactus_has_i8mm() {
-    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) {
     const float32x4_t log2e = vdupq_n_f32(1.4426950408889634f);
@@ -154,102 +102,6 @@ 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
-}
-
 namespace CactusThreading {
 
     class ThreadPool {
@@ -431,18 +283,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>(2));
         }
-        #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>(4));
         }
         #endif
     };

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_ffi.h

@@ -6,11 +6,11 @@
 #include <stdbool.h>
 
 #if __GNUC__ >= 4
-  #define CACTUS_FFI_EXPORT __attribute__ ((visibility ("default")))
-  #define CACTUS_FFI_LOCAL  __attribute__ ((visibility ("hidden")))
+    #define CACTUS_FFI_EXPORT __attribute__((visibility("default")))
+    #define CACTUS_FFI_LOCAL  __attribute__((visibility("hidden")))
 #else
-  #define CACTUS_FFI_EXPORT
-  #define CACTUS_FFI_LOCAL
+    #define CACTUS_FFI_EXPORT
+    #define CACTUS_FFI_LOCAL
 #endif
 
 #ifdef __cplusplus
@@ -18,20 +18,30 @@ extern "C" {
 #endif
 
 typedef void* cactus_model_t;
+typedef void* cactus_index_t;
+typedef void* cactus_stream_transcribe_t;
 
 typedef void (*cactus_token_callback)(const char* token, uint32_t token_id, void* user_data);
 
-CACTUS_FFI_EXPORT cactus_model_t cactus_init(const char* model_path, size_t context_size, const char* corpus_dir);
+CACTUS_FFI_EXPORT cactus_model_t cactus_init(
+    const char* model_path,
+    const char* corpus_dir,                 // optional: NULL if no RAG corpus
+    bool cache_index                        // false = always rebuild index, true = load cached if available
+);
+
+CACTUS_FFI_EXPORT void cactus_destroy(cactus_model_t model);
+CACTUS_FFI_EXPORT void cactus_reset(cactus_model_t model);
+CACTUS_FFI_EXPORT void cactus_stop(cactus_model_t model);
 
 CACTUS_FFI_EXPORT int cactus_complete(
     cactus_model_t model,
     const char* messages_json,
     char* response_buffer,
     size_t buffer_size,
-    const char* options_json,
-    const char* tools_json,
-    cactus_token_callback callback,
-    void* user_data
+    const char* options_json,               // optional
+    const char* tools_json,                 // optional
+    cactus_token_callback callback,         // optional
+    void* user_data                         // optional
 );
 
 CACTUS_FFI_EXPORT int cactus_tokenize(
@@ -53,45 +63,38 @@ CACTUS_FFI_EXPORT int cactus_score_window(
     size_t buffer_size
 );
 
-
 CACTUS_FFI_EXPORT int cactus_transcribe(
     cactus_model_t model,
-    const char* audio_file_path,
+    const char* audio_file_path,            // NULL if using pcm_buffer
     const char* prompt,
     char* response_buffer,
     size_t buffer_size,
-    const char* options_json,
-    cactus_token_callback callback,
-    void* user_data,
-    const uint8_t* pcm_buffer,
+    const char* options_json,               // optional
+    cactus_token_callback callback,         // optional
+    void* user_data,                        // optional
+    const uint8_t* pcm_buffer,              // NULL if using audio_file_path
     size_t pcm_buffer_size
 );
 
-typedef void* cactus_stream_transcribe_t;
-
-CACTUS_FFI_EXPORT cactus_stream_transcribe_t cactus_stream_transcribe_init(cactus_model_t model);
-
-CACTUS_FFI_EXPORT int cactus_stream_transcribe_insert(
-    cactus_stream_transcribe_t stream,
-    const uint8_t* pcm_buffer,
-    size_t pcm_buffer_size
+CACTUS_FFI_EXPORT cactus_stream_transcribe_t cactus_stream_transcribe_start(
+    cactus_model_t model,
+    const char* options_json                // optional
 );
 
 CACTUS_FFI_EXPORT int cactus_stream_transcribe_process(
     cactus_stream_transcribe_t stream,
+    const uint8_t* pcm_buffer,
+    size_t pcm_buffer_size,
     char* response_buffer,
-    size_t buffer_size,
-    const char* options_json
+    size_t buffer_size
 );
 
-CACTUS_FFI_EXPORT int cactus_stream_transcribe_finalize(
+CACTUS_FFI_EXPORT int cactus_stream_transcribe_stop(
     cactus_stream_transcribe_t stream,
     char* response_buffer,
     size_t buffer_size
 );
 
-CACTUS_FFI_EXPORT void cactus_stream_transcribe_destroy(cactus_stream_transcribe_t stream);
-
 CACTUS_FFI_EXPORT int cactus_embed(
     cactus_model_t model,
     const char* text,
@@ -117,19 +120,24 @@ CACTUS_FFI_EXPORT int cactus_audio_embed(
     size_t* embedding_dim
 );
 
-CACTUS_FFI_EXPORT void cactus_reset(cactus_model_t model);
-
-CACTUS_FFI_EXPORT void cactus_stop(cactus_model_t model);
-
-CACTUS_FFI_EXPORT void cactus_destroy(cactus_model_t model);
-
-CACTUS_FFI_EXPORT const char* cactus_get_last_error(void);
-
-CACTUS_FFI_EXPORT void cactus_set_telemetry_token(const char* token);
+CACTUS_FFI_EXPORT int cactus_vad(
+    cactus_model_t model,
+    const char* audio_file_path,
+    char* response_buffer,
+    size_t buffer_size,
+    const char* options_json,
+    const uint8_t* pcm_buffer,
+    size_t pcm_buffer_size
+);
 
-CACTUS_FFI_EXPORT void cactus_set_pro_key(const char* pro_key);
+CACTUS_FFI_EXPORT int cactus_rag_query(
+    cactus_model_t model,
+    const char* query,
+    char* response_buffer,
+    size_t buffer_size,
+    size_t top_k
+);
 
-typedef void* cactus_index_t;
 
 CACTUS_FFI_EXPORT cactus_index_t cactus_index_init(
     const char* index_dir,
@@ -140,7 +148,7 @@ CACTUS_FFI_EXPORT int cactus_index_add(
     cactus_index_t index,
     const int* ids,
     const char** documents,
-    const char** metadatas,
+    const char** metadatas,                 // optional: can be NULL
     const float** embeddings,
     size_t count,
     size_t embedding_dim
@@ -169,7 +177,7 @@ CACTUS_FFI_EXPORT int cactus_index_query(
     const float** embeddings,
     size_t embeddings_count,
     size_t embedding_dim,
-    const char* options_json,
+    const char* options_json,               // optional
     int** id_buffers,
     size_t* id_buffer_sizes,
     float** score_buffers,
@@ -177,11 +185,14 @@ CACTUS_FFI_EXPORT int cactus_index_query(
 );
 
 CACTUS_FFI_EXPORT int cactus_index_compact(cactus_index_t index);
-
 CACTUS_FFI_EXPORT void cactus_index_destroy(cactus_index_t index);
 
+CACTUS_FFI_EXPORT const char* cactus_get_last_error(void);
+
+CACTUS_FFI_EXPORT void cactus_set_telemetry_environment(const char* framework, const char* cache_location);
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif 
+#endif // CACTUS_FFI_H