deepinsight · a15355447898a · Oct 31, 2025
diff --git a/cpp-package/inspireface/cpp/inspireface/c_api/inspireface.cc b/cpp-package/inspireface/cpp/inspireface/c_api/inspireface.cc
@@ -591,6 +591,62 @@ HResult HFGetCudaDeviceId(HPInt32 device_id) {
     return HSUCCEED;
 }
 
+HResult HFSetRockchipDefaultNpuCoreMask(HInt32 core_mask) {
+#if defined(ISF_ENABLE_RKNN) || defined(ISF_ENABLE_RKNN2)
+    INSPIREFACE_CONTEXT->SetRockchipDefaultNpuCoreMask(core_mask);
+    return HSUCCEED;
+#else
+    INSPIRE_LOGW("RKNN runtime is not enabled during compilation; default core mask configuration skipped.");
+    return HERR_EXTENSION_ERROR;
+#endif
+}
+
+HResult HFSetRockchipNpuCoreMask(HInt32 core_mask) {
+#if defined(ISF_ENABLE_RKNN) || defined(ISF_ENABLE_RKNN2)
+    if (core_mask < 0) {
+        INSPIREFACE_CONTEXT->ClearRockchipThreadNpuCoreMask();
+    } else {
+        INSPIREFACE_CONTEXT->SetRockchipThreadNpuCoreMask(core_mask);
+    }
+    return HSUCCEED;
+#else
+    INSPIRE_LOGW("RKNN runtime is not enabled during compilation; thread core mask configuration skipped.");
+    return HERR_EXTENSION_ERROR;
+#endif
+}
+
+HResult HFClearRockchipNpuCoreMask(void) {
+#if defined(ISF_ENABLE_RKNN) || defined(ISF_ENABLE_RKNN2)
+    INSPIREFACE_CONTEXT->ClearRockchipThreadNpuCoreMask();
+    return HSUCCEED;
+#else
+    INSPIRE_LOGW("RKNN runtime is not enabled during compilation; clear core mask skipped.");
+    return HERR_EXTENSION_ERROR;
+#endif
+}
+
+HResult HFGetRockchipNpuCoreMask(HPInt32 core_mask) {
+#if defined(ISF_ENABLE_RKNN) || defined(ISF_ENABLE_RKNN2)
+    *core_mask = INSPIREFACE_CONTEXT->GetRockchipNpuCoreMask();
+    return HSUCCEED;
+#else
+    INSPIRE_LOGW("RKNN runtime is not enabled during compilation; returning default auto core mask.");
+    *core_mask = 0;
+    return HERR_EXTENSION_ERROR;
+#endif
+}
+
+HResult HFGetRockchipDefaultNpuCoreMask(HPInt32 core_mask) {
+#if defined(ISF_ENABLE_RKNN) || defined(ISF_ENABLE_RKNN2)
+    *core_mask = INSPIREFACE_CONTEXT->GetRockchipDefaultNpuCoreMask();
+    return HSUCCEED;
+#else
+    INSPIRE_LOGW("RKNN runtime is not enabled during compilation; returning default auto core mask.");
+    *core_mask = 0;
+    return HERR_EXTENSION_ERROR;
+#endif
+}
+
 HResult HFPrintCudaDeviceInfo() {
 #if defined(ISF_ENABLE_TENSORRT)
     return inspire::PrintCudaDeviceInfo();

diff --git a/cpp-package/inspireface/cpp/inspireface/c_api/inspireface.h b/cpp-package/inspireface/cpp/inspireface/c_api/inspireface.h
@@ -435,6 +435,40 @@ HYPER_CAPI_EXPORT extern HResult HFSetCudaDeviceId(HInt32 device_id);
  * */
 HYPER_CAPI_EXPORT extern HResult HFGetCudaDeviceId(HPInt32 device_id);
 
+/**
+ * @brief Set the default Rockchip NPU core mask. This value is used when the current thread does not override the mask.
+ * @param core_mask The default core mask to be set.
+ * @return HResult indicating the success or failure of the operation.
+ * */
+HYPER_CAPI_EXPORT extern HResult HFSetRockchipDefaultNpuCoreMask(HInt32 core_mask);
+
+/**
+ * @brief Set the Rockchip NPU core mask for the current thread. Call with -1 to fall back to the default mask.
+ * @param core_mask The core mask to be applied to the current thread.
+ * @return HResult indicating the success or failure of the operation.
+ * */
+HYPER_CAPI_EXPORT extern HResult HFSetRockchipNpuCoreMask(HInt32 core_mask);
+
+/**
+ * @brief Clear the Rockchip NPU core mask override for the current thread.
+ * @return HResult indicating the success or failure of the operation.
+ * */
+HYPER_CAPI_EXPORT extern HResult HFClearRockchipNpuCoreMask(void);
+
+/**
+ * @brief Get the Rockchip NPU core mask that will be used for the current thread.
+ * @param core_mask Pointer to the core mask to be returned.
+ * @return HResult indicating the success or failure of the operation.
+ * */
+HYPER_CAPI_EXPORT extern HResult HFGetRockchipNpuCoreMask(HPInt32 core_mask);
+
+/**
+ * @brief Get the default Rockchip NPU core mask value.
+ * @param core_mask Pointer to the default core mask to be returned.
+ * @return HResult indicating the success or failure of the operation.
+ * */
+HYPER_CAPI_EXPORT extern HResult HFGetRockchipDefaultNpuCoreMask(HPInt32 core_mask);
+
 /**
  * @brief Print the CUDA device information.
  * @return HResult indicating the success or failure of the operation.

diff --git a/cpp-package/inspireface/cpp/inspireface/include/inspireface/launch.h b/cpp-package/inspireface/cpp/inspireface/include/inspireface/launch.h
@@ -75,6 +75,21 @@ class INSPIRE_API_EXPORT Launch {
     // Get the rockchip dma heap path
     std::string GetRockchipDmaHeapPath() const;
 
+    // Configure default Rockchip NPU core mask
+    void SetRockchipDefaultNpuCoreMask(int32_t core_mask);
+
+    // Configure the Rockchip NPU core mask for the current thread
+    void SetRockchipThreadNpuCoreMask(int32_t core_mask);
+
+    // Clear the Rockchip NPU core mask override for the current thread
+    void ClearRockchipThreadNpuCoreMask();
+
+    // Query the Rockchip NPU core mask for the current thread (fallback to default)
+    int32_t GetRockchipNpuCoreMask() const;
+
+    // Query the default Rockchip NPU core mask
+    int32_t GetRockchipDefaultNpuCoreMask() const;
+
     // Set the extension path
     void ConfigurationExtensionPath(const std::string& path);
 
@@ -134,4 +149,4 @@ class INSPIRE_API_EXPORT Launch {
 
 }  // namespace inspire
 
-#endif  // INSPIREFACE_LAUNCH_H
+#endif  // INSPIREFACE_LAUNCH_H
diff --git a/cpp-package/inspireface/cpp/inspireface/middleware/any_net_adapter.h b/cpp-package/inspireface/cpp/inspireface/middleware/any_net_adapter.h
@@ -82,6 +82,10 @@ class INSPIRE_API AnyNetAdapter {
 
         if (m_infer_type_ == InferenceWrapper::INFER_TENSORRT) {
             m_nn_inference_->SetDevice(INSPIREFACE_CONTEXT->GetCudaDeviceId());
+        } else if (m_infer_type_ == InferenceWrapper::INFER_RKNN) {
+#if defined(ISF_ENABLE_RKNN) || defined(ISF_ENABLE_RKNN2)
+            m_nn_inference_->SetDevice(INSPIREFACE_CONTEXT->GetRockchipNpuCoreMask());
+#endif
         }
 
 #if defined(ISF_GLOBAL_INFERENCE_BACKEND_USE_MNN_CUDA) && !defined(ISF_ENABLE_RKNN)

diff --git a/...ackage/inspireface/cpp/inspireface/middleware/inference_wrapper/customized/rknn_adapter.h b/...ackage/inspireface/cpp/inspireface/middleware/inference_wrapper/customized/rknn_adapter.h
@@ -11,6 +11,10 @@
 #include "data_type.h"
 #include "log.h"
 
+#if defined(RKNN_NPU_CORE_UNDEFINED)
+#define INSPIREFACE_HAS_RKNN_CORE_MASK 1
+#endif
+
 /**
  * @brief Function to get RKNN data type string.
  * @param type Data type
@@ -167,7 +171,14 @@ class RKNNAdapter {
         }
         run_ = true;
 
-        return init_();
+        ret = init_();
+        if (ret != RKNN_SUCC) {
+            return ret;
+        }
+        if (core_mask_overridden_) {
+            ret = apply_core_mask_();
+        }
+        return ret;
     }
 
     /**
@@ -188,7 +199,14 @@ class RKNNAdapter {
         }
         run_ = true;
 
-        return init_();
+        ret = init_();
+        if (ret != RKNN_SUCC) {
+            return ret;
+        }
+        if (core_mask_overridden_) {
+            ret = apply_core_mask_();
+        }
+        return ret;
     }
 
     /**
@@ -385,6 +403,33 @@ class RKNNAdapter {
         outputs_want_float_ = outputsWantFloat;
     }
 
+    /**
+     * @brief Configure the target NPU core mask.
+     * @param core_mask Rockchip NPU core mask value.
+     * @return 0 on success, negative on failure.
+     */
+    int SetCoreMask(int32_t core_mask) {
+        core_mask_ = core_mask;
+        core_mask_overridden_ = true;
+        if (run_) {
+            return apply_core_mask_();
+        }
+        return 0;
+    }
+
+    /**
+     * @brief Reset NPU core mask to auto scheduling.
+     * @return 0 on success, negative on failure.
+     */
+    int ResetCoreMask() {
+        core_mask_ = 0;
+        core_mask_overridden_ = false;
+        if (run_) {
+            return apply_core_mask_();
+        }
+        return 0;
+    }
+
 private:
     /**
      * initial
@@ -474,6 +519,23 @@ class RKNNAdapter {
         return ret;
     }
 
+    int apply_core_mask_() {
+        if (!run_) {
+            return 0;
+        }
+#if defined(INSPIREFACE_HAS_RKNN_CORE_MASK)
+        // rknn_set_core_mask 需要 rknn_core_mask 类型，这里做显式转换
+        int ret = rknn_set_core_mask(rk_ctx_, static_cast<rknn_core_mask>(core_mask_));
+        if (ret != RKNN_SUCC) {
+            INSPIRE_LOGE("rknn_set_core_mask fail! ret=%d", ret);
+        }
+        return ret;
+#else
+        INSPIRE_LOGW("Current RKNN runtime does not support core mask configuration, skip.");
+        return RKNN_SUCC;
+#endif
+    }
+
 private:
     rknn_context rk_ctx_;              ///< The context manager for RKNN.
     rknn_input_output_num rk_io_num_;  ///< The number of input and output streams in RKNN.
@@ -493,6 +555,8 @@ class RKNNAdapter {
     unsigned char *model_data;  ///< Pointer to the model's data stream.
     bool load_;
     bool run_;
+    int32_t core_mask_{0};
+    bool core_mask_overridden_{false};
 };
 
 #endif  // INSPIREFACE_RKNN_ADAPTER_RKNPU1_H
diff --git a/...e/inspireface/cpp/inspireface/middleware/inference_wrapper/customized/rknn_adapter_nano.h b/...e/inspireface/cpp/inspireface/middleware/inference_wrapper/customized/rknn_adapter_nano.h
@@ -19,6 +19,9 @@
 #include <vector>
 #include "log.h"
 
+#if defined(RKNN_NPU_CORE_UNDEFINED)
+#define INSPIREFACE_HAS_RKNN_CORE_MASK 1
+#endif
 inline std::vector<float> softmax(const std::vector<float> &input) {
     std::vector<float> output;
     output.reserve(input.size());
@@ -80,6 +83,24 @@ class RKNNAdapterNano {
     RKNNAdapterNano &operator=(const RKNNAdapterNano &) = delete;
     RKNNAdapterNano() = default;
 
+    int32_t SetCoreMask(int32_t core_mask) {
+        core_mask_ = core_mask;
+        core_mask_overridden_ = true;
+        if (run_) {
+            return apply_core_mask_();
+        }
+        return 0;
+    }
+
+    int32_t ResetCoreMask() {
+        core_mask_ = 0;
+        core_mask_overridden_ = false;
+        if (run_) {
+            return apply_core_mask_();
+        }
+        return 0;
+    }
+
     int32_t Initialize(void *model_data, unsigned int model_size) {
         int ret = rknn_init(&m_rk_ctx_, model_data, model_size, 0, NULL);
         if (ret < 0) {
@@ -168,6 +189,12 @@ class RKNNAdapterNano {
         }
 
         run_ = true;
+        if (core_mask_overridden_) {
+            ret = apply_core_mask_();
+            if (ret != RKNN_SUCC) {
+                return ret;
+            }
+        }
         return 0;
     }
 
@@ -254,6 +281,23 @@ class RKNNAdapterNano {
         return 0;
     }
 
+    int apply_core_mask_() {
+        if (!run_) {
+            return 0;
+        }
+#if defined(INSPIREFACE_HAS_RKNN_CORE_MASK)
+        // rknn_set_core_mask 期望的是枚举类型 rknn_core_mask，这里做显式转换
+        int ret = rknn_set_core_mask(m_rk_ctx_, static_cast<rknn_core_mask>(core_mask_));
+        if (ret != RKNN_SUCC) {
+            INSPIRE_LOGE("rknn_set_core_mask fail! ret=%d", ret);
+        }
+        return ret;
+#else
+        INSPIRE_LOGW("Current RKNN runtime does not support core mask configuration, skip.");
+        return RKNN_SUCC;
+#endif
+    }
+
     std::vector<float> &GetOutputData(size_t index) {
         return m_output_nchw_[index];
     }
@@ -307,6 +351,8 @@ class RKNNAdapterNano {
 
     std::vector<std::vector<float>> m_output_nchw_;
     bool run_;
+    int32_t core_mask_{0};
+    bool core_mask_overridden_{false};
 };
 
 #endif  // SLEEPMONITORING_RKNN_ADAPTER_NANO_H
diff --git a/...spireface/cpp/inspireface/middleware/inference_wrapper/inference_wrapper_rknn_adapter.cpp b/...spireface/cpp/inspireface/middleware/inference_wrapper/inference_wrapper_rknn_adapter.cpp
@@ -36,6 +36,19 @@ int32_t InferenceWrapperRKNNAdapter::SetNumThreads(const int32_t num_threads) {
     return WrapperOk;
 }
 
+int32_t InferenceWrapperRKNNAdapter::SetDevice(int32_t device_id) {
+    core_mask_ = device_id;
+    core_mask_overridden_ = true;
+    if (net_) {
+        auto ret = net_->SetCoreMask(core_mask_);
+        if (ret != 0) {
+            INSPIRE_LOGE("Failed to apply RKNN core mask(%d), ret=%d", core_mask_, ret);
+            return WrapperError;
+        }
+    }
+    return WrapperOk;
+}
+
 int32_t InferenceWrapperRKNNAdapter::ParameterInitialization(std::vector<InputTensorInfo> &input_tensor_info_list,
                                                              std::vector<OutputTensorInfo> &output_tensor_info_list) {
     return WrapperOk;
@@ -116,6 +129,13 @@ int32_t InferenceWrapperRKNNAdapter::Initialize(char *model_buffer, int model_si
         INSPIRE_LOGE("Rknn init error.");
         return WrapperError;
     }
+    if (core_mask_overridden_) {
+        auto mask_ret = net_->SetCoreMask(core_mask_);
+        if (mask_ret != 0) {
+            INSPIRE_LOGE("Failed to apply RKNN core mask(%d), ret=%d", core_mask_, mask_ret);
+            return WrapperError;
+        }
+    }
     return ParameterInitialization(input_tensor_info_list, output_tensor_info_list);
 }
 
@@ -135,4 +155,4 @@ int32_t InferenceWrapperRKNNAdapter::ResizeInput(const std::vector<InputTensorIn
     return 0;
 }
 
-#endif  // INFERENCE_WRAPPER_ENABLE_RKNN
+#endif  // INFERENCE_WRAPPER_ENABLE_RKNN
diff --git a/...inspireface/cpp/inspireface/middleware/inference_wrapper/inference_wrapper_rknn_adapter.h b/...inspireface/cpp/inspireface/middleware/inference_wrapper/inference_wrapper_rknn_adapter.h
@@ -22,6 +22,7 @@ class InferenceWrapperRKNNAdapter : public InferenceWrapper {
     InferenceWrapperRKNNAdapter();
     ~InferenceWrapperRKNNAdapter() override;
     int32_t SetNumThreads(const int32_t num_threads) override;
+    int32_t SetDevice(int32_t device_id) override;
     int32_t Initialize(const std::string& model_filename, std::vector<InputTensorInfo>& input_tensor_info_list,
                        std::vector<OutputTensorInfo>& output_tensor_info_list) override;
     int32_t Initialize(char* model_buffer, int model_size, std::vector<InputTensorInfo>& input_tensor_info_list,
@@ -38,6 +39,8 @@ class InferenceWrapperRKNNAdapter : public InferenceWrapper {
 private:
     std::shared_ptr<RKNNAdapter> net_;
     int32_t num_threads_;
+    int32_t core_mask_{0};
+    bool core_mask_overridden_{false};
 };
 
 #endif  // INFERENCE_WRAPPER_ENABLE_RKNN