react-native-executorch 0.5.2 → 0.5.4

package/android/CMakeLists.txt

@@ -14,4 +14,28 @@ set(COMMON_CPP_DIR "${CMAKE_SOURCE_DIR}/../common")
 set(LIBS_DIR "${CMAKE_SOURCE_DIR}/../third-party/android/libs")
 set(INCLUDE_DIR "${CMAKE_SOURCE_DIR}/../third-party/include")
 
+# FIXME: Below u can see miserable attempts of trying to link tokenizers-cpp 
+# directly into react-native-executorch instead of it being linked against ExecuTorch
+# and then transitively to our library. Please go back to this when we bump ET runtime to the next version.  
+# The problem with directly linking tokenizers-cpp using a submodule is that we get unresolved symbols for 
+# some android logging libraries, which are referenced by sentencepiece.
+
+# set(TOKENIZERS_CPP_DIR "${CMAKE_SOURCE_DIR}/../../../third-party/tokenizers-cpp")
+# add_subdirectory("${TOKENIZERS_CPP_DIR}" tokenizers-cpp)
+
+# # Link Android log library to sentencepiece targets
+# if(TARGET sentencepiece-static)
+#   target_link_libraries(sentencepiece-static INTERFACE log)
+# endif()
+# if(TARGET sentencepiece_train-static)
+#   target_link_libraries(sentencepiece_train-static INTERFACE log)
+# endif()
+
+# # Link log library to sentencepiece executables
+# foreach(exe spm_encode spm_decode spm_normalize spm_train spm_export_vocab)
+#   if(TARGET ${exe})
+#     target_link_libraries(${exe} log)
+#   endif()
+# endforeach()
+
 add_subdirectory("${ANDROID_CPP_DIR}")

package/android/build.gradle

@@ -168,5 +168,6 @@ dependencies {
   implementation 'com.facebook.fbjni:fbjni:0.6.0'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation files('libs/classes.jar')
+  implementation 'org.opencv:opencv:4.10.0'
   implementation("com.squareup.okhttp3:okhttp:4.9.2")
 }

package/android/src/main/cpp/CMakeLists.txt

@@ -33,6 +33,7 @@ set(RN_VERSION_LINK_LIBRARIES
 )
 
 # Dependencies:
+
 # ------- Executorch -------
 
 add_library(executorch SHARED IMPORTED)
@@ -40,6 +41,29 @@ add_library(executorch SHARED IMPORTED)
 set_target_properties(executorch PROPERTIES
                       IMPORTED_LOCATION "${LIBS_DIR}/executorch/${ANDROID_ABI}/libexecutorch.so")
 
+                      
+if(ANDROID_ABI STREQUAL "arm64-v8a")
+  target_compile_definitions(react-native-executorch PRIVATE ARCH_ARM64)
+
+  # ------- pthreadpool -------
+  add_library(pthreadpool SHARED IMPORTED)
+  
+  set_target_properties(pthreadpool PROPERTIES
+                        IMPORTED_LOCATION "${LIBS_DIR}/pthreadpool/${ANDROID_ABI}/libpthreadpool.so"
+                        INTERFACE_INCLUDE_DIRECTORIES "${LIBS_DIR}/../../include/pthreadpool/")
+  
+  # ------- cpuinfo -------
+  add_library(cpuinfo SHARED IMPORTED)
+  
+  set_target_properties(cpuinfo PROPERTIES
+                        IMPORTED_LOCATION "${LIBS_DIR}/cpuinfo/${ANDROID_ABI}/libcpuinfo.so"
+                        INTERFACE_INCLUDE_DIRECTORIES "${LIBS_DIR}/../../include/cpuinfo/")
+  set(EXECUTORCH_LIBS
+    "pthreadpool"
+    "cpuinfo"
+  )
+endif()
+
 # ------- OpenCV -------
 
 set(OPENCV_LIBS 
@@ -70,4 +94,6 @@ target_link_libraries(
   ${OPENCV_LIBS}
   ${OPENCV_THIRD_PARTY_LIBS}
   executorch
-)
+  ${EXECUTORCH_LIBS}
+  z
+)

package/android/src/main/java/com/swmansion/rnexecutorch/RnExecutorchPackage.kt

@@ -14,9 +14,7 @@ class RnExecutorchPackage : TurboReactPackage() {
     name: String,
     reactContext: ReactApplicationContext,
   ): NativeModule? =
-    if (name == LLM.NAME) {
-      LLM(reactContext)
-    } else if (name == ETInstaller.NAME) {
+    if (name == ETInstaller.NAME) {
       ETInstaller(reactContext)
     } else {
       null
@@ -25,16 +23,6 @@ class RnExecutorchPackage : TurboReactPackage() {
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
     ReactModuleInfoProvider {
       val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
-      moduleInfos[LLM.NAME] =
-        ReactModuleInfo(
-          LLM.NAME,
-          LLM.NAME,
-          false, // canOverrideExistingModule
-          false, // needsEagerInit
-          true, // hasConstants
-          false, // isCxxModule
-          true,
-        )
       moduleInfos[ETInstaller.NAME] =
         ReactModuleInfo(
           ETInstaller.NAME,

package/common/rnexecutorch/RnExecutorchInstaller.cpp

@@ -6,12 +6,19 @@
 #include <rnexecutorch/models/embeddings/image/ImageEmbeddings.h>
 #include <rnexecutorch/models/embeddings/text/TextEmbeddings.h>
 #include <rnexecutorch/models/image_segmentation/ImageSegmentation.h>
+#include <rnexecutorch/models/llm/LLM.h>
 #include <rnexecutorch/models/object_detection/ObjectDetection.h>
 #include <rnexecutorch/models/ocr/OCR.h>
 #include <rnexecutorch/models/speech_to_text/SpeechToText.h>
 #include <rnexecutorch/models/style_transfer/StyleTransfer.h>
 #include <rnexecutorch/models/vertical_ocr/VerticalOCR.h>
 
+#if defined(__ANDROID__) && defined(__aarch64__)
+#include <executorch/extension/threadpool/cpuinfo_utils.h>
+#include <executorch/extension/threadpool/threadpool.h>
+#include <rnexecutorch/Log.h>
+#endif
+
 namespace rnexecutorch {
 
 // This function fetches data from a url address. It is implemented in
@@ -26,28 +33,30 @@ void RnExecutorchInstaller::injectJSIBindings(
 
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadStyleTransfer",
-      RnExecutorchInstaller::loadModel<StyleTransfer>(jsiRuntime, jsCallInvoker,
-                                                      "loadStyleTransfer"));
+      RnExecutorchInstaller::loadModel<models::style_transfer::StyleTransfer>(
+          jsiRuntime, jsCallInvoker, "loadStyleTransfer"));
 
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadImageSegmentation",
-      RnExecutorchInstaller::loadModel<ImageSegmentation>(
+      RnExecutorchInstaller::loadModel<
+          models::image_segmentation::ImageSegmentation>(
           jsiRuntime, jsCallInvoker, "loadImageSegmentation"));
 
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadClassification",
-      RnExecutorchInstaller::loadModel<Classification>(
+      RnExecutorchInstaller::loadModel<models::classification::Classification>(
           jsiRuntime, jsCallInvoker, "loadClassification"));
 
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadObjectDetection",
-      RnExecutorchInstaller::loadModel<ObjectDetection>(
-          jsiRuntime, jsCallInvoker, "loadObjectDetection"));
+      RnExecutorchInstaller::loadModel<
+          models::object_detection::ObjectDetection>(jsiRuntime, jsCallInvoker,
+                                                     "loadObjectDetection"));
 
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadExecutorchModule",
-      RnExecutorchInstaller::loadModel<BaseModel>(jsiRuntime, jsCallInvoker,
-                                                  "loadExecutorchModule"));
+      RnExecutorchInstaller::loadModel<models::BaseModel>(
+          jsiRuntime, jsCallInvoker, "loadExecutorchModule"));
 
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadTokenizerModule",
@@ -56,23 +65,48 @@ void RnExecutorchInstaller::injectJSIBindings(
 
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadImageEmbeddings",
-      RnExecutorchInstaller::loadModel<ImageEmbeddings>(
+      RnExecutorchInstaller::loadModel<models::embeddings::ImageEmbeddings>(
           jsiRuntime, jsCallInvoker, "loadImageEmbeddings"));
+
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadTextEmbeddings",
-      RnExecutorchInstaller::loadModel<TextEmbeddings>(
+      RnExecutorchInstaller::loadModel<models::embeddings::TextEmbeddings>(
           jsiRuntime, jsCallInvoker, "loadTextEmbeddings"));
+
   jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadSpeechToText",
-      RnExecutorchInstaller::loadModel<SpeechToText>(jsiRuntime, jsCallInvoker,
-                                                     "loadSpeechToText"));
+      *jsiRuntime, "loadLLM",
+      RnExecutorchInstaller::loadModel<models::llm::LLM>(
+          jsiRuntime, jsCallInvoker, "loadLLM"));
 
-  jsiRuntime->global().setProperty(*jsiRuntime, "loadOCR",
-                                   RnExecutorchInstaller::loadModel<OCR>(
-                                       jsiRuntime, jsCallInvoker, "loadOCR"));
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadOCR",
+      RnExecutorchInstaller::loadModel<models::ocr::OCR>(
+          jsiRuntime, jsCallInvoker, "loadOCR"));
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadVerticalOCR",
-      RnExecutorchInstaller::loadModel<VerticalOCR>(jsiRuntime, jsCallInvoker,
-                                                    "loadVerticalOCR"));
+      RnExecutorchInstaller::loadModel<models::ocr::VerticalOCR>(
+          jsiRuntime, jsCallInvoker, "loadVerticalOCR"));
+
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadSpeechToText",
+      RnExecutorchInstaller::loadModel<models::speech_to_text::SpeechToText>(
+          jsiRuntime, jsCallInvoker, "loadSpeechToText"));
+
+#if defined(__ANDROID__) && defined(__aarch64__)
+  auto num_of_perf_cores =
+      ::executorch::extension::cpuinfo::get_num_performant_cores();
+  log(LOG_LEVEL::Info, "Detected ", num_of_perf_cores, " performant cores");
+  // setting num_of_cores to floor(num_of_perf_cores / 2) + 1) because depending
+  // on cpu arch as when possible we want to leave at least 2 performant cores
+  // for other tasks (setting more actually results in drop of performance). For
+  // older devices (i.e. samsung s22) resolves to 3 cores, and for newer ones
+  // (like OnePlus 12) resolves to 4, which when benchamrked gives highest
+  // throughput.
+  auto num_of_cores = static_cast<uint32_t>(num_of_perf_cores / 2) + 1;
+  ::executorch::extension::threadpool::get_threadpool()
+      ->_unsafe_reset_threadpool(num_of_cores);
+  log(LOG_LEVEL::Info, "Configuring xnnpack for ", num_of_cores, " threads");
+#endif
 }
+
 } // namespace rnexecutorch

package/common/rnexecutorch/RnExecutorchInstaller.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <memory>
-#include <rnexecutorch/models/speech_to_text/SpeechToText.h>
 #include <string>
 
 #include <ReactCommon/CallInvoker.h>
@@ -17,30 +16,6 @@ namespace rnexecutorch {
 
 using FetchUrlFunc_t = std::function<std::vector<std::byte>(std::string)>;
 extern FetchUrlFunc_t fetchUrlFunc;
-
-REGISTER_CONSTRUCTOR(StyleTransfer, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(ImageSegmentation, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(Classification, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(ObjectDetection, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(BaseModel, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(TokenizerModule, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(ImageEmbeddings, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(TextEmbeddings, std::string, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(SpeechToText, std::string, std::string, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(OCR, std::string, std::string, std::string, std::string,
-                     std::string, std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(VerticalOCR, std::string, std::string, std::string,
-                     std::string, bool, std::shared_ptr<react::CallInvoker>);
-
 using namespace facebook;
 
 class RnExecutorchInstaller {

package/common/rnexecutorch/TokenizerModule.cpp

@@ -10,7 +10,7 @@ TokenizerModule::TokenizerModule(
     std::string source, std::shared_ptr<react::CallInvoker> callInvoker)
     : memorySizeLowerBound(std::filesystem::file_size(source)),
       tokenizer(tokenizers::Tokenizer::FromBlobJSON(
-          fileutils::loadBytesFromFile(source))) {}
+          file_utils::loadBytesFromFile(source))) {}
 
 void TokenizerModule::ensureTokenizerLoaded(
     const std::string &methodName) const {

package/common/rnexecutorch/TokenizerModule.h

@@ -1,9 +1,9 @@
 #pragma once
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <ReactCommon/CallInvoker.h>
 #include <string>
 #include <tokenizers-cpp/tokenizers_cpp.h>
-
 namespace rnexecutorch {
 using namespace facebook;
 
@@ -23,4 +23,7 @@ private:
   std::unique_ptr<tokenizers::Tokenizer> tokenizer;
   const std::size_t memorySizeLowerBound{0};
 };
+
+REGISTER_CONSTRUCTOR(TokenizerModule, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/common/rnexecutorch/data_processing/FileUtils.h

@@ -5,7 +5,7 @@
 #include <fstream>
 #include <string>
 
-namespace rnexecutorch::fileutils {
+namespace rnexecutorch::file_utils {
 
 inline std::string getTimeID() {
   return std::to_string(std::chrono::duration_cast<std::chrono::milliseconds>(
@@ -27,4 +27,4 @@ inline std::string loadBytesFromFile(const std::string &path) {
   return data;
 };
 
-} // namespace rnexecutorch::fileutils
+} // namespace rnexecutorch::file_utils

package/common/rnexecutorch/data_processing/ImageProcessing.cpp

@@ -14,7 +14,7 @@ namespace rnexecutorch {
 // to this variable. It's done to not handle SSL intricacies manually, as it is
 // done automagically in ObjC++/Kotlin.
 extern FetchUrlFunc_t fetchUrlFunc;
-namespace imageprocessing {
+namespace image_processing {
 std::vector<float> colorMatToVector(const cv::Mat &mat) {
   return colorMatToVector(mat, cv::Scalar(0.0, 0.0, 0.0),
                           cv::Scalar(1.0, 1.0, 1.0));
@@ -62,7 +62,7 @@ cv::Mat bufferToColorMat(const std::span<const float> &buffer,
 }
 
 std::string saveToTempFile(const cv::Mat &image) {
-  std::string filename = "rn_executorch_" + fileutils::getTimeID() + ".png";
+  std::string filename = "rn_executorch_" + file_utils::getTimeID() + ".png";
 
   std::filesystem::path tempDir = std::filesystem::temp_directory_path();
   std::filesystem::path filePath = tempDir / filename;
@@ -212,7 +212,7 @@ std::pair<TensorPtr, cv::Size>
 readImageToTensor(const std::string &path,
                   const std::vector<int32_t> &tensorDims,
                   bool maintainAspectRatio) {
-  cv::Mat input = imageprocessing::readImage(path);
+  cv::Mat input = image_processing::readImage(path);
   cv::Size imageSize = input.size();
 
   if (tensorDims.size() < 2) {
@@ -234,7 +234,7 @@ readImageToTensor(const std::string &path,
 
   cv::cvtColor(input, input, cv::COLOR_BGR2RGB);
 
-  return {imageprocessing::getTensorFromMatrix(tensorDims, input), imageSize};
+  return {image_processing::getTensorFromMatrix(tensorDims, input), imageSize};
 }
-} // namespace imageprocessing
+} // namespace image_processing
 } // namespace rnexecutorch

package/common/rnexecutorch/data_processing/ImageProcessing.h

@@ -8,7 +8,7 @@
 #include <string>
 #include <vector>
 
-namespace rnexecutorch::imageprocessing {
+namespace rnexecutorch::image_processing {
 using executorch::aten::Tensor;
 using executorch::extension::TensorPtr;
 
@@ -52,4 +52,4 @@ std::pair<TensorPtr, cv::Size>
 readImageToTensor(const std::string &path,
                   const std::vector<int32_t> &tensorDims,
                   bool maintainAspectRatio = false);
-} // namespace rnexecutorch::imageprocessing
+} // namespace rnexecutorch::image_processing

package/common/rnexecutorch/data_processing/Numerical.cpp

@@ -2,11 +2,14 @@
 
 #include <algorithm>
 #include <cmath>
+#include <limits>
 #include <numeric>
 #include <span>
+#include <sstream>
+#include <string>
 
 namespace rnexecutorch::numerical {
-void softmax(std::vector<float> &v) {
+void softmax(std::span<float> v) {
   float max = *std::max_element(v.begin(), v.end());
 
   float sum = 0.0f;
@@ -19,37 +22,55 @@ void softmax(std::vector<float> &v) {
   }
 }
 
-void normalize(std::span<float> span) {
-  auto sum = 0.0f;
-  for (const auto &val : span) {
-    sum += val * val;
+void softmaxWithTemperature(std::span<float> input, float temperature) {
+  if (input.empty()) {
+    return;
   }
 
-  if (isClose(sum, 0.0f)) {
-    return;
+  if (temperature <= 0.0F) {
+    throw std::invalid_argument(
+        "Temperature must be greater than 0 for softmax with temperature.");
   }
 
-  float norm = std::sqrt(sum);
-  for (auto &val : span) {
-    val /= norm;
+  const auto maxElement = *std::ranges::max_element(input);
+
+  for (auto &value : input) {
+    value = std::exp((value - maxElement) / temperature);
   }
-}
 
-void normalize(std::vector<float> &v) {
-  float sum = 0.0f;
-  for (float &x : v) {
-    sum += x * x;
+  const auto sum = std::reduce(input.begin(), input.end());
+
+  // sum is at least 1 since exp(max - max) == exp(0) == 1
+  for (auto &value : input) {
+    value /= sum;
   }
+}
 
-  float norm =
-      std::max(std::sqrt(sum), 1e-9f); // Solely for preventing division by 0
-  for (float &x : v) {
-    x /= norm;
+void normalize(std::span<float> input) {
+  const auto sumOfSquares =
+      std::inner_product(input.begin(), input.end(), input.begin(), 0.0F);
+
+  constexpr auto kEpsilon = 1.0e-15F;
+
+  const auto norm = std::sqrt(sumOfSquares) + kEpsilon;
+
+  for (auto &value : input) {
+    value /= norm;
   }
 }
 
 std::vector<float> meanPooling(std::span<const float> modelOutput,
                                std::span<const int64_t> attnMask) {
+  if (attnMask.empty() || modelOutput.size() % attnMask.size() != 0) {
+    std::stringstream ss;
+    ss << "Invalid dimensions for mean pooling, expected model output size to "
+          "be divisible "
+       << "by the size of attention mask but got size: " << modelOutput.size()
+       << " for model output and size: " << attnMask.size()
+       << " for attention mask";
+    throw std::invalid_argument(ss.str());
+  }
+
   auto attnMaskLength = attnMask.size();
   auto embeddingDim = modelOutput.size() / attnMaskLength;
 

package/common/rnexecutorch/data_processing/Numerical.h

@@ -4,10 +4,59 @@
 #include <vector>
 
 namespace rnexecutorch::numerical {
-void softmax(std::vector<float> &v);
-void normalize(std::span<float> span);
-void normalize(std::vector<float> &v);
-void normalize(std::span<float> span);
+
+/**
+ * @brief Applies the softmax function in-place to a sequence of numbers.
+ *
+ * @param input A mutable span of floating-point numbers. After the function
+ * returns, `input` contains the softmax probabilities.
+ */
+void softmax(std::span<float> input);
+
+/**
+ * @brief Applies the softmax function with temperature scaling in-place to a
+ * sequence of numbers.
+ *
+ * The temperature parameter controls the "sharpness" of the resulting
+ * probability distribution. A temperature of 1.0 means no scaling, while lower
+ * values make the distribution sharper (more peaked), and higher values make it
+ * softer (more uniform).
+ *
+ * @param input A mutable span of floating-point numbers. After the function
+ * returns, `input` contains the softmax probabilities.
+ * @param temperature A positive float value used to scale the logits before
+ * applying softmax. Must be greater than 0.
+ */
+void softmaxWithTemperature(std::span<float> input, float temperature);
+
+/**
+ * @brief Normalizes the elements of the given float span in-place using the
+ * L2 norm method.
+ *
+ * This function scales the input vector such that its L2 norm (Euclidean norm)
+ * becomes 1. If the norm is zero, the result is a zero vector with the same
+ * size as the input.
+ *
+ * @param input A mutable span of floating-point values representing the data to
+ * be normalized.
+ */
+void normalize(std::span<float> input);
+
+/**
+ * @brief Computes mean pooling across the modelOutput adjusted by an attention
+ * mask.
+ *
+ * This function aggregates the `modelOutput` span by sections defined by
+ * `attnMask`, computing the mean of sections influenced by the mask. The result
+ * is a vector where each element is the mean of a segment from the original
+ * data.
+ *
+ * @param modelOutput A span of floating-point numbers representing the model
+ * output.
+ * @param attnMask A span of integers where each integer is a weight
+ * corresponding to the elements in `modelOutput`.
+ * @return A std::vector<float> containing the computed mean values of segments.
+ */
 std::vector<float> meanPooling(std::span<const float> modelOutput,
                                std::span<const int64_t> attnMask);
 /**

package/common/rnexecutorch/data_processing/dsp.cpp

@@ -18,7 +18,7 @@ std::vector<float> hannWindow(size_t size) {
   return window;
 }
 
-std::vector<float> stftFromWaveform(std::span<float> waveform,
+std::vector<float> stftFromWaveform(std::span<const float> waveform,
                                     size_t fftWindowSize, size_t hopSize) {
   // Initialize FFT
   FFT fft(fftWindowSize);

package/common/rnexecutorch/data_processing/dsp.h

@@ -6,7 +6,7 @@
 namespace rnexecutorch::dsp {
 
 std::vector<float> hannWindow(size_t size);
-std::vector<float> stftFromWaveform(std::span<float> waveform,
+std::vector<float> stftFromWaveform(std::span<const float> waveform,
                                     size_t fftWindowSize, size_t hopSize);
 
 } // namespace rnexecutorch::dsp

package/common/rnexecutorch/data_processing/gzip.cpp

@@ -0,0 +1,47 @@
+#include <vector>
+#include <zlib.h>
+
+#include "gzip.h"
+
+namespace rnexecutorch::gzip {
+
+namespace {
+constexpr int32_t kGzipWrapper = 16;     // gzip header/trailer
+constexpr int32_t kMemLevel = 8;         // memory level
+constexpr size_t kChunkSize = 16 * 1024; // 16 KiB stream buffer
+} // namespace
+
+size_t deflateSize(const std::string &input) {
+  z_stream strm{};
+  if (::deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
+                     MAX_WBITS + kGzipWrapper, kMemLevel,
+                     Z_DEFAULT_STRATEGY) != Z_OK) {
+    throw std::runtime_error("deflateInit2 failed");
+  }
+
+  size_t outSize = 0;
+
+  strm.next_in = reinterpret_cast<z_const Bytef *>(
+      const_cast<z_const char *>(input.data()));
+  strm.avail_in = static_cast<uInt>(input.size());
+
+  std::vector<unsigned char> buf(kChunkSize);
+  int ret;
+  do {
+    strm.next_out = buf.data();
+    strm.avail_out = static_cast<uInt>(buf.size());
+
+    ret = ::deflate(&strm, strm.avail_in ? Z_NO_FLUSH : Z_FINISH);
+    if (ret == Z_STREAM_ERROR) {
+      ::deflateEnd(&strm);
+      throw std::runtime_error("deflate stream error");
+    }
+
+    outSize += buf.size() - strm.avail_out;
+  } while (ret != Z_STREAM_END);
+
+  ::deflateEnd(&strm);
+  return outSize;
+}
+
+} // namespace rnexecutorch::gzip

package/common/rnexecutorch/data_processing/gzip.h

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace rnexecutorch::gzip {
+
+size_t deflateSize(const std::string &input);
+
+} // namespace rnexecutorch::gzip