More fixes and enablement

GregoryComer · GregoryComer · commit 43355dea3d1a · 2025-09-09T21:10:23.000-07:00
diff --git a/.ci/scripts/unittest-windows.ps1 b/.ci/scripts/unittest-windows.ps1
@@ -29,7 +29,7 @@ if ($LASTEXITCODE -ne 0) {
     exit $LASTEXITCODE
 }
 
-ctest -j8
+ctest -j8 . --config $buildMode --output-on-failure
 if ($LASTEXITCODE -ne 0) {
     Write-Host "CTest run was unsuccessful. Exit code: $LASTEXITCODE."
     exit $LASTEXITCODE
diff --git a/extension/evalue_util/test/print_evalue_test.cpp b/extension/evalue_util/test/print_evalue_test.cpp
@@ -267,7 +267,7 @@ TEST(PrintEvalueTest, UnelidedBoolLists) {
   // case; the other scalar types use the same underlying code, so they don't
   // need to test this again.
   {
-    EValue value(ArrayRef<bool>(list.data(), 0ul));
+    EValue value(ArrayRef<bool>(list.data(), (size_t)0ul));
     expect_output(value, "(len=0)[]");
   }
   {
@@ -419,7 +419,7 @@ TEST(PrintEvalueTest, UnelidedDoubleLists) {
   std::array<double, 6> list = {-2.2, -1, 0, INFINITY, NAN, 3.3};
 
   {
-    EValue value(ArrayRef<double>(list.data(), 0ul));
+    EValue value(ArrayRef<double>(list.data(), (size_t)0ul));
     expect_output(value, "(len=0)[]");
   }
   {
diff --git a/extension/flat_tensor/test/CMakeLists.txt b/extension/flat_tensor/test/CMakeLists.txt
@@ -23,7 +23,7 @@ add_custom_command(
          "${CMAKE_CURRENT_BINARY_DIR}/ModuleAddMulProgram.ptd"
   COMMAND
     ${PYTHON_EXECUTABLE} -m test.models.export_program --modules "ModuleAddMul"
-    --external-constants --outdir "${CMAKE_CURRENT_BINARY_DIR}" 2> /dev/null
+    --external-constants --outdir "${CMAKE_CURRENT_BINARY_DIR}"
   WORKING_DIRECTORY ${EXECUTORCH_ROOT}
 )
 
diff --git a/extension/module/test/CMakeLists.txt b/extension/module/test/CMakeLists.txt
@@ -24,10 +24,10 @@ add_custom_command(
          "${CMAKE_CURRENT_BINARY_DIR}/ModuleAddMulProgram.pte"
          "${CMAKE_CURRENT_BINARY_DIR}/ModuleAddMulProgram.ptd"
   COMMAND ${PYTHON_EXECUTABLE} -m test.models.export_program --modules
-          "ModuleAdd" --outdir "${CMAKE_CURRENT_BINARY_DIR}" 2> /dev/null
+          "ModuleAdd" --outdir "${CMAKE_CURRENT_BINARY_DIR}"
   COMMAND
     ${PYTHON_EXECUTABLE} -m test.models.export_program --modules "ModuleAddMul"
-    --external-constants --outdir "${CMAKE_CURRENT_BINARY_DIR}" 2> /dev/null
+    --external-constants --outdir "${CMAKE_CURRENT_BINARY_DIR}"
   WORKING_DIRECTORY ${EXECUTORCH_ROOT}
 )
 
diff --git a/extension/runner_util/test/CMakeLists.txt b/extension/runner_util/test/CMakeLists.txt
@@ -20,7 +20,7 @@ include(${EXECUTORCH_ROOT}/tools/cmake/Test.cmake)
 add_custom_command(
   OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/ModuleAdd.pte"
   COMMAND ${PYTHON_EXECUTABLE} -m test.models.export_program --modules
-          "ModuleAdd" --outdir "${CMAKE_CURRENT_BINARY_DIR}" 2> /dev/null
+          "ModuleAdd" --outdir "${CMAKE_CURRENT_BINARY_DIR}"
   WORKING_DIRECTORY ${EXECUTORCH_ROOT}
 )
 
diff --git a/extension/testing_util/temp_file.h b/extension/testing_util/temp_file.h
@@ -9,13 +9,11 @@
 #pragma once
 
 #include <array>
+#include <fstream>
 #include <memory>
 #include <string>
 
 #include <fcntl.h> // open()
-#include <stdio.h> // tmpnam(), remove()
-#include <unistd.h> // write(), close()
-
 #include <gtest/gtest.h>
 
 namespace executorch {
@@ -72,19 +70,13 @@ class TempFile {
     }
 
     // Write the contents to the file.
-    int fd = open(
-        path.c_str(),
-        // O_EXCL ensures that we are the ones creating this file, to help
-        // protect against race conditions.
-        O_CREAT | O_EXCL | O_RDWR,
-        // User can read and write, group can read.
-        S_IRUSR | S_IWUSR | S_IRGRP);
-    ASSERT_GE(fd, 0) << "open(" << path << ") failed: " << strerror(errno);
-
-    ssize_t nwrite = write(fd, data, size);
-    ASSERT_EQ(nwrite, size) << "Failed to write " << size << " bytes (wrote "
-                            << nwrite << "): " << strerror(errno);
-    close(fd);
+    std::ofstream file(path, std::ios::out | std::ios::binary);
+    ASSERT_TRUE(file.is_open())
+        << "open(" << path << ") failed: " << strerror(errno);
+
+    file.write((const char*)data, size);
+    ASSERT_TRUE(file.good())
+        << "Failed to write " << size << " bytes: " << strerror(errno);
 
     *out_path = path;
   }
diff --git a/kernels/portable/cpu/op_argmax.cpp b/kernels/portable/cpu/op_argmax.cpp
@@ -49,21 +49,21 @@ Tensor& argmax_out(
   static constexpr const char op_name[] = "argmax.out";
 
   ET_SWITCH_REALHBF16_TYPES(in.scalar_type(), ctx, op_name, CTYPE, [&] {
-    long* out_data = out.mutable_data_ptr<long>();
+    int64_t* out_data = out.mutable_data_ptr<int64_t>();
 
     const bool success = parallel_for_each_reduce_over_dim_output_index(
         in, dim, out, [&](const auto begin, const auto end) {
           for (const auto out_ix : c10::irange(begin, end)) {
-            std::tuple<CTYPE, long> acc = reduce_over_dim<CTYPE>(
-                [](CTYPE v, long ix, CTYPE acc_val, long acc_ix) {
+            std::tuple<CTYPE, int64_t> acc = reduce_over_dim<CTYPE>(
+                [](CTYPE v, int64_t ix, CTYPE acc_val, int64_t acc_ix) {
                   // the below condition as written is equivalent to
                   // !isnan(accval) && (isnan(v) || v > acc_val). See
                   // argument in op_argmin.cpp.
                   if (!utils::isnan_override(acc_val) && !(v <= acc_val)) {
                     acc_val = v;
                     acc_ix = ix;
                   }
-                  return std::tuple<CTYPE, long>{acc_val, acc_ix};
+                  return std::tuple<CTYPE, int64_t>{acc_val, acc_ix};
                 },
                 in,
                 dim,
diff --git a/kernels/portable/cpu/op_argmin.cpp b/kernels/portable/cpu/op_argmin.cpp
@@ -49,13 +49,13 @@ Tensor& argmin_out(
   static constexpr const char op_name[] = "argmin.out";
 
   ET_SWITCH_REALHBF16_TYPES(in.scalar_type(), ctx, op_name, CTYPE, [&] {
-    long* out_data = out.mutable_data_ptr<long>();
+    int64_t* out_data = out.mutable_data_ptr<int64_t>();
 
     const bool success = parallel_for_each_reduce_over_dim_output_index(
         in, dim, out, [&](const auto begin, const auto end) {
           for (const auto out_ix : c10::irange(begin, end)) {
-            std::tuple<CTYPE, long> acc = reduce_over_dim<CTYPE>(
-                [](CTYPE v, long ix, CTYPE acc_val, long acc_ix) {
+            std::tuple<CTYPE, int64_t> acc = reduce_over_dim<CTYPE>(
+                [](CTYPE v, int64_t ix, CTYPE acc_val, int64_t acc_ix) {
                   // the below condition as written is equivalent to
                   // !isnan(accval) && (isnan(v) || v < acc_val). cases:
                   // - if neither acc_val nor v is NaN, !(v >= acc_val) is
@@ -70,7 +70,7 @@ Tensor& argmin_out(
                     acc_val = v;
                     acc_ix = ix;
                   }
-                  return std::tuple<CTYPE, long>{acc_val, acc_ix};
+                  return std::tuple<CTYPE, int64_t>{acc_val, acc_ix};
                 },
                 in,
                 dim,
diff --git a/kernels/portable/cpu/op_clamp.cpp b/kernels/portable/cpu/op_clamp.cpp
@@ -45,9 +45,9 @@ ET_NODISCARD bool check_bounds(
   static constexpr const char op_name[] = "clamp.out";
 
   if (isIntegralType(out_type, /*includeBool=*/false)) {
-    const long val_long = utils::scalar_to<long>(val_scalar);
+    const int64_t val_long = utils::scalar_to<int64_t>(val_scalar);
     ET_SWITCH_INT_TYPES(out_type, ctx, op_name, CTYPE_OUT, [&]() {
-      if (is_out_of_bounds<CTYPE_OUT, long>(val_long)) {
+      if (is_out_of_bounds<CTYPE_OUT, int64_t>(val_long)) {
         ET_LOG(Error, "%s value out of bounds", val_name);
         is_valid = false;
       }
diff --git a/kernels/portable/cpu/op_gather.cpp b/kernels/portable/cpu/op_gather.cpp
@@ -30,7 +30,7 @@ void gather_helper(
     Tensor& out,
     int64_t dim) {
   const CTYPE* in_data = in.const_data_ptr<CTYPE>();
-  const long* index_data = index.const_data_ptr<long>();
+  const int64_t* index_data = index.const_data_ptr<int64_t>();
   CTYPE* out_data = out.mutable_data_ptr<CTYPE>();
 
   if (index.dim() == 0) {
diff --git a/kernels/portable/cpu/op_min.cpp b/kernels/portable/cpu/op_min.cpp
@@ -82,19 +82,19 @@ std::tuple<Tensor&, Tensor&> min_out(
   ET_SWITCH_REALHBBF16_TYPES(
       in.scalar_type(), ctx, "min.dim_min", CTYPE, [&]() {
         CTYPE* min_data = min.mutable_data_ptr<CTYPE>();
-        long* min_indices_data = min_indices.mutable_data_ptr<long>();
+        int64_t* min_indices_data = min_indices.mutable_data_ptr<int64_t>();
 
         const bool success = parallel_for_each_reduce_over_dim_output_index(
             in, dim, min, [&](const auto begin, const auto end) {
               for (const auto out_ix : c10::irange(begin, end)) {
-                std::tuple<CTYPE, long> acc = reduce_over_dim<CTYPE>(
-                    [](CTYPE v, long ix, CTYPE acc_val, long acc_ix) {
+                std::tuple<CTYPE, int64_t> acc = reduce_over_dim<CTYPE>(
+                    [](CTYPE v, int64_t ix, CTYPE acc_val, int64_t acc_ix) {
                       if (!utils::isnan_override(acc_val) &&
                           (utils::isnan_override(v) || v < acc_val)) {
                         acc_val = v;
                         acc_ix = ix;
                       }
-                      return std::tuple<CTYPE, long>{acc_val, acc_ix};
+                      return std::tuple<CTYPE, int64_t>{acc_val, acc_ix};
                     },
                     in,
                     dim,
diff --git a/kernels/portable/cpu/op_scatter.cpp b/kernels/portable/cpu/op_scatter.cpp
@@ -32,7 +32,7 @@ void scatter_src_helper(
     const Tensor& src,
     Tensor& out) {
   const CTYPE* in_data = in.const_data_ptr<CTYPE>();
-  const long* index_data = index.const_data_ptr<long>();
+  const int64_t* index_data = index.const_data_ptr<int64_t>();
   const CTYPE* src_data = src.const_data_ptr<CTYPE>();
   CTYPE* out_data = out.mutable_data_ptr<CTYPE>();
 
@@ -72,7 +72,7 @@ void scatter_value_helper(
     CTYPE_VAL val,
     Tensor& out) {
   const CTYPE* in_data = in.const_data_ptr<CTYPE>();
-  const long* index_data = index.const_data_ptr<long>();
+  const int64_t* index_data = index.const_data_ptr<int64_t>();
   CTYPE* out_data = out.mutable_data_ptr<CTYPE>();
 
   memcpy(out_data, in_data, in.nbytes());
diff --git a/kernels/portable/cpu/op_scatter_add.cpp b/kernels/portable/cpu/op_scatter_add.cpp
@@ -23,7 +23,7 @@ namespace {
 template <typename CTYPE>
 void scatter_add_helper(
     const CTYPE* src_data,
-    const long* index_data,
+    const int64_t* index_data,
     CTYPE* out_data,
     const Tensor& src,
     const Tensor& index,
@@ -81,7 +81,7 @@ Tensor& scatter_add_out(
 
   ET_SWITCH_REALHBBF16_TYPES(self_type, ctx, "scatter_add.out", CTYPE, [&]() {
     const CTYPE* self_data = self.const_data_ptr<CTYPE>();
-    const long* index_data = index.const_data_ptr<long>();
+    const int64_t* index_data = index.const_data_ptr<int64_t>();
     const CTYPE* src_data = src.const_data_ptr<CTYPE>();
     CTYPE* out_data = out.mutable_data_ptr<CTYPE>();
 
diff --git a/kernels/portable/cpu/op_topk.cpp b/kernels/portable/cpu/op_topk.cpp
@@ -79,7 +79,7 @@ void perform_topk(
     elem_t* queue) {
   const CTYPE* const in_data = in.const_data_ptr<CTYPE>();
   CTYPE* values_data = values.mutable_data_ptr<CTYPE>();
-  long* indices_data = indices.mutable_data_ptr<long>();
+  int64_t* indices_data = indices.mutable_data_ptr<int64_t>();
 
   if (in.dim() == 0) {
     values_data[0] = in_data[0];
diff --git a/kernels/test/CMakeLists.txt b/kernels/test/CMakeLists.txt
@@ -26,8 +26,8 @@ foreach(kernel ${_kernels})
   set(_functions_include "#include <executorch/kernels/${kernel}/Functions.h>")
   add_custom_command(
     OUTPUT "${_wrapper_path}"
-    COMMAND mkdir -p ${_wrapper_dir}
-    COMMAND echo ${_functions_include} > "${_wrapper_path}"
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${_wrapper_dir}
+    COMMAND ${CMAKE_COMMAND} -E echo ${_functions_include} > "${_wrapper_path}"
     DEPENDS
       "${CMAKE_CURRENT_BINARY_DIR}/include/${kernel}/executorch/kernels/${kernel}/Functions.h"
       "${CMAKE_CURRENT_BINARY_DIR}/include/${kernel}/executorch/kernels/${kernel}/NativeFunctions.h"
@@ -44,7 +44,7 @@ foreach(kernel ${_kernels})
   add_custom_command(
     OUTPUT "${_wrapper_dir}/supported_features.cpp"
            "${_wrapper_dir}/supported_features.h"
-    COMMAND mkdir -p ${_wrapper_dir}
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${_wrapper_dir}
     COMMAND
       ${PYTHON_EXECUTABLE} kernels/test/gen_supported_features.py
       kernels/${_supported_features_kernel}/test/supported_features_def.yaml >
@@ -73,17 +73,35 @@ foreach(kernel ${_kernels})
         "${CMAKE_CURRENT_BINARY_DIR}/../../kernels/${kernel}/${kernel}_ops_lib"
     )
   endif()
+
+  # Copy with glob needs to be handle in a platform-specific manner.
+  if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+    # The quoting here is complicated, because there are three levels of
+    # interpretation: CMake -> Batch -> Powershell. The invoked (batch) command
+    # should look like `powershell -Command "Copy-Item ... -Path \"...\" ...".
+    # Powershell sees `Copy-Item -Path "..." ...`.
+    set(_copy_headers_cmd
+        powershell
+        -Command
+        "Copy-Item -Path \\\"${_kernel_ops_lib_path}/*.h\\\" -Destination \\\"${CMAKE_CURRENT_BINARY_DIR}/include/${kernel}/executorch/kernels/${kernel}/\\\""
+    )
+  else()
+    set(_copy_headers_cmd
+        cp
+        "${_kernel_ops_lib_path}/*.h"
+        "${CMAKE_CURRENT_BINARY_DIR}/include/${kernel}/executorch/kernels/${kernel}/"
+    )
+  endif()
+
   add_custom_command(
     OUTPUT
       "${CMAKE_CURRENT_BINARY_DIR}/include/${kernel}/executorch/kernels/${kernel}/Functions.h"
       "${CMAKE_CURRENT_BINARY_DIR}/include/${kernel}/executorch/kernels/${kernel}/NativeFunctions.h"
       "${CMAKE_CURRENT_BINARY_DIR}/include/${kernel}/executorch/kernels/${kernel}/RegisterKernels.h"
     COMMAND
-      mkdir -p
-      "${CMAKE_CURRENT_BINARY_DIR}/include/${kernel}/executorch/kernels/${kernel}/"
-    COMMAND
-      cp "${_kernel_ops_lib_path}/*.h"
+      ${CMAKE_COMMAND} -E make_directory
       "${CMAKE_CURRENT_BINARY_DIR}/include/${kernel}/executorch/kernels/${kernel}/"
+    COMMAND ${_copy_headers_cmd}
     DEPENDS ${_kernel_ops_lib}
   )
 endforeach()
diff --git a/runtime/core/exec_aten/testing_util/tensor_util.cpp b/runtime/core/exec_aten/testing_util/tensor_util.cpp
@@ -52,25 +52,52 @@ bool data_is_close(
     return true;
   }
   for (const auto i : c10::irange(numel)) {
-    const auto ai = a[i];
-    const auto bi = b[i];
-
-    if (std::isnan(ai) && std::isnan(bi)) {
-      // NaN == NaN
-    } else if (
-        !std::isfinite(ai) && !std::isfinite(bi) && ((ai > 0) == (bi > 0))) {
-      // -Inf == -Inf
-      // +Inf == +Inf
-    } else if (rtol == 0 && atol == 0) {
-      // Exact comparison; avoid unnecessary math.
-      if (ai != bi) {
-        return false;
+    if constexpr (is_reduced_floating_point_v<T>) {
+      // MSVC complains about ambiguous overload resolution for c10::Half and
+      // c10::BFloat16, so explictly cast to a float.
+      const auto ai = static_cast<float>(a[i]);
+      const auto bi = static_cast<float>(b[i]);
+
+      if (std::isnan(ai) && std::isnan(bi)) {
+        // NaN == NaN
+      } else if (
+          !std::isfinite(ai) && !std::isfinite(bi) && ((ai > 0) == (bi > 0))) {
+        // -Inf == -Inf
+        // +Inf == +Inf
+      } else if (rtol == 0 && atol == 0) {
+        // Exact comparison; avoid unnecessary math.
+        if (ai != bi) {
+          return false;
+        }
+      } else {
+        auto allowed_error = atol + std::abs(rtol * bi);
+        auto actual_error = std::abs(ai - bi);
+        if (!std::isfinite(actual_error) || actual_error > allowed_error) {
+          return false;
+        }
       }
+
     } else {
-      auto allowed_error = atol + std::abs(rtol * bi);
-      auto actual_error = std::abs(ai - bi);
-      if (!std::isfinite(actual_error) || actual_error > allowed_error) {
-        return false;
+      const auto ai = a[i];
+      const auto bi = b[i];
+
+      if (std::isnan(ai) && std::isnan(bi)) {
+        // NaN == NaN
+      } else if (
+          !std::isfinite(ai) && !std::isfinite(bi) && ((ai > 0) == (bi > 0))) {
+        // -Inf == -Inf
+        // +Inf == +Inf
+      } else if (rtol == 0 && atol == 0) {
+        // Exact comparison; avoid unnecessary math.
+        if (ai != bi) {
+          return false;
+        }
+      } else {
+        auto allowed_error = atol + std::abs(rtol * bi);
+        auto actual_error = std::abs(ai - bi);
+        if (!std::isfinite(actual_error) || actual_error > allowed_error) {
+          return false;
+        }
       }
     }
   }
diff --git a/runtime/executor/test/CMakeLists.txt b/runtime/executor/test/CMakeLists.txt
diff --git a/runtime/kernel/test/CMakeLists.txt b/runtime/kernel/test/CMakeLists.txt

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ if ($LASTEXITCODE -ne 0) {`
`29`	`29`	`exit $LASTEXITCODE`
`30`	`30`	`}`
`31`	`31`
`32`		`-ctest -j8`
	`32`	`+ctest -j8 . --config $buildMode --output-on-failure`
`33`	`33`	`if ($LASTEXITCODE -ne 0) {`
`34`	`34`	`Write-Host "CTest run was unsuccessful. Exit code: $LASTEXITCODE."`
`35`	`35`	`exit $LASTEXITCODE`
Original file line number	Diff line number	Diff line change
`@@ -267,7 +267,7 @@ TEST(PrintEvalueTest, UnelidedBoolLists) {`
`267`	`267`	`// case; the other scalar types use the same underlying code, so they don't`
`268`	`268`	`// need to test this again.`
`269`	`269`	`{`
`270`		`- EValue value(ArrayRef<bool>(list.data(), 0ul));`
	`270`	`+ EValue value(ArrayRef<bool>(list.data(), (size_t)0ul));`
`271`	`271`	`expect_output(value, "(len=0)[]");`
`272`	`272`	`}`
`273`	`273`	`{`
`@@ -419,7 +419,7 @@ TEST(PrintEvalueTest, UnelidedDoubleLists) {`
`419`	`419`	`std::array<double, 6> list = {-2.2, -1, 0, INFINITY, NAN, 3.3};`
`420`	`420`
`421`	`421`	`{`
`422`		`- EValue value(ArrayRef<double>(list.data(), 0ul));`
	`422`	`+ EValue value(ArrayRef<double>(list.data(), (size_t)0ul));`
`423`	`423`	`expect_output(value, "(len=0)[]");`
`424`	`424`	`}`
`425`	`425`	`{`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ add_custom_command(`
`23`	`23`	`"${CMAKE_CURRENT_BINARY_DIR}/ModuleAddMulProgram.ptd"`
`24`	`24`	`COMMAND`
`25`	`25`	`${PYTHON_EXECUTABLE} -m test.models.export_program --modules "ModuleAddMul"`
`26`		`- --external-constants --outdir "${CMAKE_CURRENT_BINARY_DIR}" 2> /dev/null`
	`26`	`+ --external-constants --outdir "${CMAKE_CURRENT_BINARY_DIR}"`
`27`	`27`	`WORKING_DIRECTORY ${EXECUTORCH_ROOT}`
`28`	`28`	`)`
`29`	`29`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ include(${EXECUTORCH_ROOT}/tools/cmake/Test.cmake)`
`20`	`20`	`add_custom_command(`
`21`	`21`	`OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/ModuleAdd.pte"`
`22`	`22`	`COMMAND ${PYTHON_EXECUTABLE} -m test.models.export_program --modules`
`23`		`- "ModuleAdd" --outdir "${CMAKE_CURRENT_BINARY_DIR}" 2> /dev/null`
	`23`	`+ "ModuleAdd" --outdir "${CMAKE_CURRENT_BINARY_DIR}"`
`24`	`24`	`WORKING_DIRECTORY ${EXECUTORCH_ROOT}`
`25`	`25`	`)`
`26`	`26`