Switch ats to use micro seconds for latency instead of nano

LiteRT-PiperOrigin-RevId: 826195550

Author: LukeBoyer

litert/ats/BUILD

@@ -380,7 +380,6 @@ litert_define_ats(
         # "^(?:(?!npu_ats_87).)*$$",
     ],
     extra_flags = [
-        "--f16_range_for_f32=true",
         "--data_seed=42",
     ],
     jit_suffix = "",

litert/ats/common.h

@@ -100,7 +100,7 @@ enum class CompilationStatus {
 // Timing related types.
 using Clock = std::chrono::steady_clock;
 using TimePoint = Clock::time_point;
-using Nanoseconds = uint64_t;
+using Microseconds = uint64_t;
 
 // Which backend to use as the "actual".
 enum class ExecutionBackend { kCpu, kGpu, kNpu };
@@ -177,7 +177,7 @@ void AbslStringify(Sink& sink, const CompilationStatus& status) {
 }
 
 template <typename Sink>
-void AbslStringify(Sink& sink, const Nanoseconds& ns) {
+void AbslStringify(Sink& sink, const Microseconds& ns) {
   absl::Format(&sink, "%e", ns);
 }
 

litert/ats/compile_capture.h

@@ -29,25 +29,25 @@
 namespace litert::testing {
 
 // Information about the time taken to compile the model.
-class CompilationTime : public Printable<Nanoseconds> {
+class CompilationTime : public Printable<Microseconds> {
  public:
   // Start timing.
   TimePoint Start() const { return Clock::now(); }
 
   // Stop timing and record the latency.
   void Stop(const TimePoint& start) {
-    std::chrono::duration<Nanoseconds, std::nano> nano = Clock::now() - start;
+    std::chrono::duration<Microseconds, std::nano> nano = Clock::now() - start;
     nanos_ = nano.count();
   }
 
-  Nanoseconds Nanos() const { return nanos_; }
+  Microseconds Nanos() const { return nanos_; }
 
   CompilationTime() : Printable("CompilationTime", "compile_time(ns)") {}
 
  private:
   Fields GetFields() const override { return Fields{nanos_}; }
 
-  Nanoseconds nanos_ = std::numeric_limits<Nanoseconds>::max();
+  Microseconds nanos_ = std::numeric_limits<Microseconds>::max();
 };
 
 // Type to hold all of the capturable information related compilation test

litert/ats/compile_capture_test.cc

@@ -33,7 +33,7 @@ TEST(AtsCompileCaptureTest, Basic) {
   e.model.name = "FOO";
 
   ASSERT_NE(e.compilation_time.Nanos(),
-            std::numeric_limits<Nanoseconds>::max());
+            std::numeric_limits<Microseconds>::max());
 
   std::ostringstream s;
   cap.Print(s);

litert/ats/configure.cc

@@ -196,7 +196,6 @@ Expected<AtsConf> AtsConf::ParseFlagsAndDoSetup() {
   std::regex pos_re(absl::GetFlag(FLAGS_do_register),
                     std::regex_constants::ECMAScript);
   auto extra_models = absl::GetFlag(FLAGS_extra_models);
-  auto f16_range_for_f32 = absl::GetFlag(FLAGS_f16_range_for_f32);
   auto data_seed = absl::GetFlag(FLAGS_data_seed);
   auto dispatch_dir = absl::GetFlag(FLAGS_dispatch_dir);
   auto plugin_dir = absl::GetFlag(FLAGS_plugin_dir);
@@ -223,12 +222,11 @@ Expected<AtsConf> AtsConf::ParseFlagsAndDoSetup() {
       ParsePlugin(plugin_dir, soc_manufacturer, compile_mode, target_options));
   AtsConf res(std::move(seeds), backend, quiet, dispatch_dir, plugin_dir,
               std::move(neg_re), std::move(pos_re), std::move(extra_models),
-              f16_range_for_f32, data_seed, iters_per_test,
-              std::move(max_ms_per_test_opt), fail_on_timeout, dump_report,
-              std::move(csv), compile_mode, std::move(models_out), limit,
-              std::move(plugin), std::move(soc_manufacturer),
-              std::move(soc_model), std::move(target_options),
-              std::move(reference_options));
+              data_seed, iters_per_test, std::move(max_ms_per_test_opt),
+              fail_on_timeout, dump_report, std::move(csv), compile_mode,
+              std::move(models_out), limit, std::move(plugin),
+              std::move(soc_manufacturer), std::move(soc_model),
+              std::move(target_options), std::move(reference_options));
   Setup(res);
   return res;
 }

litert/ats/configure.h

@@ -62,9 +62,6 @@ ABSL_DECLARE_FLAG(std::string, dont_register);
 // Regex for explicit inclusions.
 ABSL_DECLARE_FLAG(std::string, do_register);
 
-// Will generate values for f32 tensors in the range of f16 values.
-ABSL_DECLARE_FLAG(bool, f16_range_for_f32);
-
 // Optional list of directories, or model files to add to the test.
 ABSL_DECLARE_FLAG(std::vector<std::string>, extra_models);
 
@@ -251,8 +248,7 @@ class AtsConf {
                    bool quiet, std::string dispatch_dir, std::string plugin_dir,
                    std::regex&& neg_re, std::regex&& pos_re,
                    std::vector<std::string> extra_models,
-                   bool f16_range_for_f32, std::optional<int> data_seed,
-                   size_t iters_per_test,
+                   std::optional<int> data_seed, size_t iters_per_test,
                    std::chrono::milliseconds max_ms_per_test,
                    bool fail_on_timeout, bool dump_report, std::string csv,
                    bool compile_mode, std::string models_out, int32_t limit,
@@ -267,7 +263,7 @@ class AtsConf {
         neg_re_(std::move(neg_re)),
         pos_re_(std::move(pos_re)),
         extra_models_(std::move(extra_models)),
-        f16_range_for_f32_(f16_range_for_f32),
+
         data_seed_(data_seed),
         iters_per_test_(iters_per_test),
         max_ms_per_test_(std::move(max_ms_per_test)),
@@ -282,9 +278,9 @@ class AtsConf {
         soc_model_(std::move(soc_model)),
         target_options_(std::move(target_options)),
         reference_options_(std::move(reference_options)) {
-    if (f16_range_for_f32_) {
-      data_builder_.SetF16InF32();
-    }
+    // For now, we will provide default settings for data generation.
+    // More configurability may be introduced later.
+    data_builder_.SetSin();
   }
 
   SeedMap seeds_for_params_;
@@ -296,7 +292,6 @@ class AtsConf {
   std::regex neg_re_;
   std::regex pos_re_;
   std::vector<std::string> extra_models_;
-  bool f16_range_for_f32_;
   std::optional<int> data_seed_;
   size_t iters_per_test_;
   std::chrono::milliseconds max_ms_per_test_;

litert/ats/inference_capture.h

@@ -35,7 +35,7 @@ namespace litert::testing {
 
 // Information about the latency of the execution.
 class Latency
-    : public Printable<Nanoseconds, Nanoseconds, Nanoseconds, size_t> {
+    : public Printable<Microseconds, Microseconds, Microseconds, size_t> {
  public:
   using Ref = std::reference_wrapper<Latency>;
 
@@ -58,25 +58,26 @@ class Latency
 
   // Stop timing and record the latency.
   void Stop(const TimePoint& start) {
-    std::chrono::duration<Nanoseconds, std::nano> nano = Clock::now() - start;
-    latencies_.push_back(nano.count());
+    const auto micro = std::chrono::duration_cast<
+        std::chrono::duration<Microseconds, std::micro>>(Clock::now() - start);
+    latencies_.push_back(micro.count());
   }
 
   // Average latency.
-  Nanoseconds Avg() const {
+  Microseconds Avg() const {
     return ::litert::Avg(latencies_.cbegin(), latencies_.cend());
   }
 
   // Maximum latency.
-  Nanoseconds Max() const {
+  Microseconds Max() const {
     if (latencies_.empty()) {
       return 0;
     }
     return *std::max_element(latencies_.begin(), latencies_.end());
   }
 
   // Minimum latency.
-  Nanoseconds Min() const {
+  Microseconds Min() const {
     if (latencies_.empty()) {
       return 0;
     }
@@ -87,15 +88,15 @@ class Latency
   size_t NumSamples() const { return latencies_.size(); }
 
   Latency()
-      : Printable("Latency", "avg_latency(ns)", "max_latency(ns)",
-                  "min_latency(ns)", "num_samples") {}
+      : Printable("Latency", "avg_latency(us)", "max_latency(us)",
+                  "min_latency(us)", "num_samples") {}
 
  private:
   Fields GetFields() const override {
     return Fields{Avg(), Max(), Min(), NumSamples()};
   }
 
-  std::vector<Nanoseconds> latencies_;
+  std::vector<Microseconds> latencies_;
 };
 
 // Information about the numerics of the execution.

litert/ats/inference_fixture.h

@@ -15,6 +15,7 @@
 #ifndef THIRD_PARTY_ODML_LITERT_LITERT_ATS_INFERENCE_FIXTURE_H_
 #define THIRD_PARTY_ODML_LITERT_LITERT_ATS_INFERENCE_FIXTURE_H_
 
+#include <algorithm>
 #include <cstddef>
 #include <cstdint>
 #include <limits>
@@ -136,7 +137,24 @@ class AtsInferenceTest : public RngTest {
 
   template <typename Rng>
   Expected<VarBuffers> MakeInputs(Rng& device) const {
-    return graph_->MakeInputs(device, conf_.DataBuilder());
+    auto inputs = graph_->MakeInputs(device, conf_.DataBuilder());
+    if (!inputs.HasValue()) return inputs.Error();
+#ifndef NDEBUG
+    LITERT_LOG(LITERT_INFO, "First 5 elements of each input:");
+    for (size_t i = 0; i < inputs->size(); ++i) {
+      const auto& input = (*inputs)[i];
+      LITERT_LOG(LITERT_INFO, "  Input %zu:", i);
+      if (input.Type().ElementType() == ElementType::Float32) {
+        const auto& view = input.template AsView<float>();
+        for (int j = 0; j < std::min(5, view.data.size()); ++j) {
+          LITERT_LOG(LITERT_INFO, "    [%d]: %f", j, view.data[j]);
+        }
+      } else {
+        LITERT_LOG(LITERT_INFO, "    Unsupported element type for printing.");
+      }
+    }
+#endif
+    return inputs;
   }
 
   Expected<VarBuffers> Actual(const VarBuffers& inputs,
@@ -185,7 +203,15 @@ class AtsInferenceTest : public RngTest {
   template <typename T>
   void CheckOutputImpl(const BufferView<T>& actual, const BufferView<T>& ref) {
     double mse = std::numeric_limits<double>::max();
-    EXPECT_THAT(actual.data, MeanSquaredErrorLt(ref.data, 1e-5, &mse));
+#ifndef NDEBUG
+    LITERT_LOG(LITERT_INFO, "First 5 elements:");
+    for (int i = 0; i < std::min(5, actual.data.size()); ++i) {
+      LITERT_LOG(LITERT_INFO, "  actual[%d]: %f, ref[%d]: %f", i,
+                 static_cast<float>(actual.data[i]), i,
+                 static_cast<float>(ref.data[i]));
+    }
+#endif
+    EXPECT_THAT(actual.data, MeanSquaredErrorLt(ref.data, 1e-4, &mse));
     cap_.numerics.NewMse(mse);
   }
 

litert/cc/internal/litert_rng.h

@@ -260,6 +260,23 @@ class F16InF32Generator<float> final {
   }
 };
 
+template <typename D>
+class SinGenerator final : public DataGeneratorBase<D> {};
+
+// Generates sin values in the range [-1, 1].
+template <>
+class SinGenerator<float> final : public DataGeneratorBase<float> {
+ public:
+  SinGenerator() = default;
+
+  template <typename Rng>
+  float operator()(Rng& rng) {
+    return std::sin(rng() * 0.12345f);
+  }
+  float Max() const override { return 1.0f; }
+  float Min() const override { return -1.0f; }
+};
+
 // Dummy primitive generator that returns a monotonically increasing sequence.
 template <typename D>
 class DummyGenerator final : public DataGeneratorBase<D> {
@@ -536,6 +553,11 @@ class RandomTensorDataBuilder {
     return *this;
   }
 
+  RandomTensorDataBuilder& SetSin() {
+    float_config_ = Sin();
+    return *this;
+  }
+
   template <typename D>
   std::pair<double, double> Bounds() const {
     if constexpr (std::is_same_v<D, int32_t>) {
@@ -556,6 +578,8 @@ class RandomTensorDataBuilder {
                 std::numeric_limits<float>::max()};
       } else if (std::holds_alternative<F16InF32>(float_config_)) {
         return {std::numeric_limits<float>::lowest(), 65504.0};
+      } else if (std::holds_alternative<Sin>(float_config_)) {
+        return {-1.0f, 1.0f};
       } else {
         auto [min, max] = std::get<std::pair<float, float>>(float_config_);
         return {min, max};
@@ -589,6 +613,9 @@ class RandomTensorDataBuilder {
       } else if (std::holds_alternative<F16InF32>(float_config_)) {
         RandomTensorData<D, F16InF32Generator> data;
         return Functor()(data, std::forward<Args>(args)...);
+      } else if (std::holds_alternative<Sin>(float_config_)) {
+        RandomTensorData<D, SinGenerator> data;
+        return Functor()(data, std::forward<Args>(args)...);
       } else {
         auto [min, max] = std::get<std::pair<D, D>>(float_config_);
         RandomTensorData<D, DefaultRangedGenerator> data(min, max);
@@ -603,12 +630,13 @@ class RandomTensorDataBuilder {
   struct Dummy {};
   struct NullOpt {};
   struct F16InF32 {};
+  struct Sin {};
 
   template <typename D>
   using IntConfig = std::variant<std::pair<D, D>, Dummy, NullOpt>;
   template <typename D>
   using FloatConfig =
-      std::variant<std::pair<float, float>, Dummy, NullOpt, F16InF32>;
+      std::variant<std::pair<float, float>, Dummy, NullOpt, F16InF32, Sin>;
 
   IntConfig<int32_t> int_config_ = NullOpt();
   FloatConfig<float> float_config_ = NullOpt();