Merge branch 'main' into jz/fix-preq-enums

Author: jackzhxng

.ci/scripts/benchmark_tooling/README.md

@@ -77,16 +77,16 @@ python3 .ci/scripts/benchmark_tooling/analyze_benchmark_stability.py \
 
 ##### Filtering Options:
 
-- `--device-pools`: Filter by private device pool names (e.g., "samsung-galaxy-s22-5g", "samsung-galaxy-s22plus-5g")
+- `--device-pools`: Filter by device pool names (e.g., "apple_iphone_15_private", "samsung_s22_private")
 - `--backends`: Filter by specific backend names (e.g.,"xnnpack_q8")
-- `--models`: Filter by specific model names (e.g., "mv3", "meta-llama-llama-3.2-1b-instruct-qlora-int4-eo8")
+- `--models`: Filter by specific model names (e.g., "mv3", "meta-llama/Llama-3.2-1B-Instruct-SpinQuant_INT4_EO8")
 
 #### Example Usage
 
 Filter by multiple private device pools and models:
 ```bash
 # This fetches all private table data for models 'llama-3.2-1B' and 'mv3'
-python3 get_benchmark_analysis_data.py \
+python3 .ci/scripts/benchmark_tooling/get_benchmark_analysis_data.py \
   --startTime "2025-06-01T00:00:00" \
   --endTime "2025-06-11T00:00:00" \
   --device-pools 'apple_iphone_15_private' 'samsung_s22_private' \
@@ -97,7 +97,7 @@ Filter by specific device pool and models:
 ```bash
 # This fetches all private iPhone table data for models 'llama-3.2-1B' and 'mv3',
 # and associated public iPhone data
-python3 get_benchmark_analysis_data.py \
+python3 .ci/scripts/benchmark_tooling/get_benchmark_analysis_data.py \
   --startTime "2025-06-01T00:00:00" \
   --endTime "2025-06-11T00:00:00" \
   --device-pools 'apple_iphone_15_private' \
@@ -140,22 +140,6 @@ fetcher.run(
     end_time="2025-06-17T18:00:00"
 )
 
-# Get results in different formats
-# As DataFrames
-df_results = fetcher.to_df()
-
-# Export to Excel
-fetcher.to_excel(output_dir="./results")
-
-# Export to CSV
-fetcher.to_csv(output_dir="./results")
-
-# Export to JSON
-json_path = fetcher.to_json(output_dir="./results")
-
-# Get raw dictionary results
-dict_results = fetcher.to_dict()
-
 # Use the output_data method for flexible output
 results = fetcher.output_data(output_type="excel", output_dir="./results")
 ```

examples/models/llama/config/llm_config.py

@@ -227,9 +227,9 @@ class ExportConfig:
     export_only: bool = False
 
     def __post_init__(self):
-        if self.max_context_length > self.max_seq_length:
+        if self.max_context_length < self.max_seq_length:
             raise ValueError(
-                f"max_context_length of {self.max_context_length} cannot be greater than max_seq_length of {self.max_seq_length}"
+                f"max_context_length of {self.max_context_length} cannot be shorter than max_seq_length of {self.max_seq_length}"
             )
 
 

extension/data_loader/mmap_data_loader.cpp

@@ -150,10 +150,10 @@ void MunmapSegment(void* context, void* data, size_t size) {
 }
 } // namespace
 
-Result<FreeableBuffer> MmapDataLoader::load(
-    size_t offset,
-    size_t size,
-    ET_UNUSED const DataLoader::SegmentInfo& segment_info) const {
+/**
+ * Validates that file read range is within bounds.
+ */
+Error MmapDataLoader::validate_input(size_t offset, size_t size) const {
   ET_CHECK_OR_RETURN_ERROR(
       // Probably had its value moved to another instance.
       fd_ >= 0,
@@ -173,6 +173,18 @@ Result<FreeableBuffer> MmapDataLoader::load(
       InvalidArgument,
       "Offset %zu too large for off_t",
       offset);
+  return Error::Ok;
+}
+
+Result<FreeableBuffer> MmapDataLoader::load(
+    size_t offset,
+    size_t size,
+    ET_UNUSED const DataLoader::SegmentInfo& segment_info) const {
+  // Ensure read range is valid.
+  auto validation_err = validate_input(offset, size);
+  if (validation_err != Error::Ok) {
+    return validation_err;
+  }
 
   // mmap() will fail if the size is zero.
   if (size == 0) {
@@ -267,5 +279,69 @@ Result<size_t> MmapDataLoader::size() const {
   return file_size_;
 }
 
+Error MmapDataLoader::load_into(
+    size_t offset,
+    size_t size,
+    ET_UNUSED const SegmentInfo& segment_info,
+    void* buffer) const {
+  ET_CHECK_OR_RETURN_ERROR(
+      buffer != nullptr, InvalidArgument, "Buffer is null");
+
+  // Ensure read range is valid.
+  auto err = validate_input(offset, size);
+  if (err != Error::Ok) {
+    return err;
+  }
+
+  // Nothing to copy.
+  if (size == 0) {
+    return Error::Ok;
+  }
+
+  // Find the range of pages that covers the requested region.
+  Range range =
+      get_overlapping_pages(static_cast<uintptr_t>(offset), size, page_size_);
+
+  size_t map_size = range.size;
+  if (range.start + map_size > file_size_) {
+    // Clamp to the end of the file.
+    //
+    // The Windows implementation of mmap uses CreateFileMapping which returns
+    // error STATUS_SECTION_TOO_BIG (0xc0000040) if we try to map past the end
+    // of the last page of a file mapped in as read-only.
+    map_size = file_size_ - range.start;
+  }
+
+  // Map the pages read-only. MAP_PRIVATE vs. MAP_SHARED doesn't matter since
+  // the data is read-only, but use PRIVATE just to further avoid accidentally
+  // modifying the file.
+  void* pages = ::mmap(
+      nullptr,
+      map_size,
+      PROT_READ,
+      MAP_PRIVATE,
+      fd_,
+      static_cast<off_t>(range.start));
+  ET_CHECK_OR_RETURN_ERROR(
+      pages != MAP_FAILED,
+      AccessFailed,
+      "Failed to map %s: mmap(..., size=%zd, ..., fd=%d, offset=0x%zx)",
+      file_name_,
+      range.size,
+      fd_,
+      range.start);
+
+  // Offset into mapped region.
+  const size_t map_delta = offset - range.start;
+
+  // Copy data into caller's buffer.
+  std::memcpy(buffer, static_cast<uint8_t*>(pages) + map_delta, size);
+
+  // Unmap mapped region.
+  ::munmap(pages, map_size);
+
+  return Error::Ok;
+}
+
 } // namespace extension
 } // namespace executorch

extension/data_loader/mmap_data_loader.h

@@ -95,6 +95,13 @@ class MmapDataLoader final : public executorch::runtime::DataLoader {
 
   ET_NODISCARD executorch::runtime::Result<size_t> size() const override;
 
+  ET_NODISCARD
+  executorch::runtime::Error load_into(
+      size_t offset,
+      size_t size,
+      ET_UNUSED const SegmentInfo& segment_info,
+      void* buffer) const override;
+
  private:
   MmapDataLoader(
       int fd,
@@ -113,6 +120,10 @@ class MmapDataLoader final : public executorch::runtime::DataLoader {
   MmapDataLoader& operator=(const MmapDataLoader&) = delete;
   MmapDataLoader& operator=(MmapDataLoader&&) = delete;
 
+  ET_NODISCARD executorch::runtime::Error validate_input(
+      size_t offset,
+      size_t size) const;
+
   const char* const file_name_; // String data is owned by the instance.
   const size_t file_size_;
   const size_t page_size_;

extension/data_loader/test/mmap_data_loader_test.cpp

@@ -376,3 +376,56 @@ TEST_F(MmapDataLoaderTest, DEPRECATEDFrom) {
   ASSERT_EQ(total_size.error(), Error::Ok);
   EXPECT_EQ(*total_size, contents_size);
 }
+
+// Tests that load_into copies bytes correctly.
+TEST_F(MmapDataLoaderTest, LoadIntoCopiesCorrectly) {
+  // Create a test string.
+  const char* test_text = "FILE_CONTENTS";
+  const size_t text_size = std::strlen(test_text);
+  TempFile tf(test_text);
+
+  // Wrap it in a loader.
+  Result<MmapDataLoader> mdl = MmapDataLoader::from(tf.path().c_str());
+  ASSERT_EQ(mdl.error(), Error::Ok);
+
+  // Destination buffer.
+  std::vector<uint8_t> dst(text_size);
+
+  // Call load_into()
+  Error err = mdl->load_into(
+      /*offset=*/0,
+      /*size=*/text_size,
+      DataLoader::SegmentInfo(DataLoader::SegmentInfo::Type::Program),
+      dst.data());
+  ASSERT_EQ(err, Error::Ok);
+
+  // Verify memory copied correctly.
+  EXPECT_EQ(0, std::memcmp(dst.data(), test_text, text_size));
+}
+
+// Tests that load_into copies offset slice correctly.
+TEST_F(MmapDataLoaderTest, LoadIntoCopiesOffsetCorrectly) {
+  // Create a test string.
+  const char* contents = "ABCDEFGH";
+  TempFile tf(contents);
+
+  // Wrap it in a loader.
+  Result<MmapDataLoader> mdl = MmapDataLoader::from(tf.path().c_str());
+  ASSERT_EQ(mdl.error(), Error::Ok);
+
+  // Copying 3 bytes starting at offset 2 = "CDE"
+  const size_t offset = 2;
+  const size_t size = 3;
+  uint8_t dst[size];
+
+  // Call load_into()
+  Error err = mdl->load_into(
+      offset,
+      size,
+      DataLoader::SegmentInfo(DataLoader::SegmentInfo::Type::Program),
+      dst);
+  ASSERT_EQ(err, Error::Ok);
+
+  // Verify memory copied correctly.
+  EXPECT_EQ(0, std::memcmp(dst, contents + offset, size));
+}

runtime/backend/interface.cpp

@@ -66,5 +66,42 @@ Result<const char*> get_backend_name(size_t index) {
   return registered_backends[index].name;
 }
 
+Error set_option(
+    const char* backend_name,
+    const executorch::runtime::Span<executorch::runtime::BackendOption>
+        backend_options) {
+  auto backend_class = get_backend_class(backend_name);
+  if (!backend_class) {
+    return Error::NotFound;
+  }
+
+  BackendOptionContext backend_option_context;
+  Error result =
+      backend_class->set_option(backend_option_context, backend_options);
+  if (result != Error::Ok) {
+    return result;
+  }
+  return Error::Ok;
+}
+
+Error get_option(
+    const char* backend_name,
+    executorch::runtime::Span<executorch::runtime::BackendOption>
+        backend_options) {
+  auto backend_class = get_backend_class(backend_name);
+  if (!backend_class) {
+    return Error::NotFound;
+  }
+  BackendOptionContext backend_option_context;
+  executorch::runtime::Span<BackendOption> backend_options_ref(
+      backend_options.data(), backend_options.size());
+  auto result =
+      backend_class->get_option(backend_option_context, backend_options_ref);
+  if (result != Error::Ok) {
+    return result;
+  }
+  return Error::Ok;
+}
+
 } // namespace ET_RUNTIME_NAMESPACE
 } // namespace executorch

runtime/backend/interface.h

@@ -183,6 +183,34 @@ size_t get_num_registered_backends();
  */
 Result<const char*> get_backend_name(size_t index);
 
+/**
+ * Sets backend options for a specific backend.
+ *
+ * @param backend_name The name of the backend to set options for
+ * @param backend_options The backend option list containing the options
+ * to set
+ * @return Error::Ok on success, Error::NotFound if backend is not found, or
+ * other error codes on failure
+ */
+Error set_option(
+    const char* backend_name,
+    const executorch::runtime::Span<executorch::runtime::BackendOption>
+        backend_options);
+
+/**
+ * Retrieves backend options for a specific backend.
+ *
+ * @param backend_name The name of the backend to get options from
+ * @param backend_options The backend option objects that will be filled with
+ * the populated values from the backend
+ * @return Error::Ok on success, Error::NotFound if backend is not found, or
+ * other error codes on failure
+ */
+Error get_option(
+    const char* backend_name,
+    executorch::runtime::Span<executorch::runtime::BackendOption>
+        backend_options);
+
 } // namespace ET_RUNTIME_NAMESPACE
 } // namespace executorch