Skip to content

Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more

6.4 KB
Raw Blame
#include <algorithm>
#include <array>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <limits>
#include <vector>

#include <mach/mach.h>
#include <pthread/qos.h>

#include "fluid_aec3_bridge.h"

namespace {

using Frame = std::array<float, FV_AEC3_FRAME_SAMPLES>;

constexpr int kWarmupFrames = 6000;       // One simulated minute.
constexpr int kMeasurementFrames = 180000;  // Thirty simulated minutes.
constexpr int kEchoDelaySamples = 240;
constexpr uint64_t kMaximumGrowthBytes = 1024 * 1024;

uint64_t ResidentBytes() {
  mach_task_basic_info_data_t info{};
  mach_msg_type_number_t count = MACH_TASK_BASIC_INFO_COUNT;
  if (task_info(mach_task_self_, MACH_TASK_BASIC_INFO,
                reinterpret_cast<task_info_t>(&info), &count) != KERN_SUCCESS) {
    return 0;
  }
  return info.resident_size;
}

class DeterministicSignal {
 public:
  void Fill(Frame* render, Frame* capture) {
    for (int index = 0; index < FV_AEC3_FRAME_SAMPLES; ++index) {
      render_state_ = render_state_ * 1664525u + 1013904223u;
      const float white =
          static_cast<float>(static_cast<int32_t>(render_state_)) /
          2147483648.0f;
      filtered_render_ = 0.76f * filtered_render_ + 0.24f * white;
      const float render_sample = 0.2f * filtered_render_;
      (*render)[index] = render_sample;

      const float delayed = delay_[delay_index_];
      delay_[delay_index_] = render_sample;
      delay_index_ = (delay_index_ + 1) % delay_.size();

      near_state_ = near_state_ * 1103515245u + 12345u;
      const bool double_talk = ((sample_index_ / 48000) % 4) == 3;
      const float near_white =
          static_cast<float>(static_cast<int32_t>(near_state_)) /
          2147483648.0f;
      filtered_near_ = 0.81f * filtered_near_ + 0.19f * near_white;
      const float near_sample = double_talk ? 0.12f * filtered_near_ : 0.0f;
      (*capture)[index] = std::clamp(near_sample + 0.58f * delayed, -1.0f, 1.0f);
      ++sample_index_;
    }
  }

 private:
  uint32_t render_state_ = 0x12345678u;
  uint32_t near_state_ = 0x87654321u;
  float filtered_render_ = 0.0f;
  float filtered_near_ = 0.0f;
  std::array<float, kEchoDelaySamples> delay_{};
  size_t delay_index_ = 0;
  uint64_t sample_index_ = 0;
};

bool ProcessFrame(FVAEC3Engine* engine, DeterministicSignal* signal,
                  Frame* render, Frame* capture, Frame* output,
                  FVAEC3Stats* statistics) {
  signal->Fill(render, capture);
  if (fv_aec3_process_10ms(engine, render->data(), capture->data(),
                           output->data(), statistics) != FV_AEC3_OK) {
    return false;
  }
  return std::all_of(output->begin(), output->end(), [](float sample) {
    return std::isfinite(sample) && sample >= -1.0f && sample <= 1.0f;
  });
}

}  // namespace

int main() {
  pthread_set_qos_class_self_np(QOS_CLASS_USER_INTERACTIVE, 0);
  FVAEC3Engine* engine = fv_aec3_create_48k_mono();
  if (engine == nullptr) {
    std::cerr << "benchmark: engine creation failed\n";
    return 2;
  }

  DeterministicSignal signal;
  Frame render{};
  Frame capture{};
  Frame output{};
  FVAEC3Stats statistics{};
  for (int frame = 0; frame < kWarmupFrames; ++frame) {
    if (!ProcessFrame(engine, &signal, &render, &capture, &output, &statistics)) {
      std::cerr << "benchmark: warm-up processing failed at frame " << frame << '\n';
      fv_aec3_destroy(engine);
      return 3;
    }
  }

  // Fault benchmark-owned storage in before the RSS baseline so lazy vector page commitment is
  // not mistaken for growth inside AEC3.
  std::vector<double> durations_ms(kMeasurementFrames, 0.0);
  volatile double prefault_sink = 0.0;
  for (size_t index = 0; index < durations_ms.size(); ++index) {
    durations_ms[index] = static_cast<double>(index & 1);
    prefault_sink = prefault_sink + durations_ms[index];
  }
  std::vector<uint64_t> minute_rss(31, 0);
  size_t rss_count = 1;
  const uint64_t baseline_rss = ResidentBytes();
  minute_rss[0] = baseline_rss;
  volatile float output_sink = 0.0f;

  for (int frame = 0; frame < kMeasurementFrames; ++frame) {
    signal.Fill(&render, &capture);
    const auto start = std::chrono::steady_clock::now();
    const FVAEC3Status status = fv_aec3_process_10ms(
        engine, render.data(), capture.data(), output.data(), &statistics);
    const auto end = std::chrono::steady_clock::now();
    if (status != FV_AEC3_OK ||
        !std::all_of(output.begin(), output.end(), [](float sample) {
          return std::isfinite(sample) && sample >= -1.0f && sample <= 1.0f;
        })) {
      std::cerr << "benchmark: measured processing failed at frame " << frame << '\n';
      fv_aec3_destroy(engine);
      return 4;
    }
    output_sink = output_sink + output[frame % FV_AEC3_FRAME_SAMPLES];
    durations_ms[frame] =
        std::chrono::duration<double, std::milli>(end - start).count();
    if ((frame + 1) % 6000 == 0) minute_rss[rss_count++] = ResidentBytes();
  }

  fv_aec3_destroy(engine);
  std::sort(durations_ms.begin(), durations_ms.end());
  const size_t p99_index =
      static_cast<size_t>(std::ceil(0.99 * durations_ms.size())) - 1;
  const double p99_ms = durations_ms[p99_index];
  const double maximum_ms = durations_ms.back();
  const auto [minimum_rss_it, maximum_rss_it] =
      std::minmax_element(minute_rss.begin(), minute_rss.end());
  const uint64_t rss_range = *maximum_rss_it - *minimum_rss_it;
  const bool monotonic_growth =
      std::adjacent_find(minute_rss.begin(), minute_rss.end(),
                         std::greater_equal<uint64_t>()) == minute_rss.end() &&
      minute_rss.back() > minute_rss.front();

  std::cout << std::fixed << std::setprecision(4)
            << "aec3_realtime_benchmark frames=" << kMeasurementFrames
            << " simulated_minutes=30"
            << " p99_ms=" << p99_ms
            << " max_ms=" << maximum_ms
            << " rss_start_bytes=" << minute_rss.front()
            << " rss_end_bytes=" << minute_rss.back()
            << " rss_range_bytes=" << rss_range
            << " monotonic_growth=" << (monotonic_growth ? "true" : "false")
            << " sink=" << output_sink + static_cast<float>(prefault_sink * 0.0) << '\n';

  if (p99_ms >= 5.0) return 10;
  if (maximum_ms >= 10.0) return 11;
  if (monotonic_growth || rss_range > kMaximumGrowthBytes) return 12;
  if (statistics.render_frames != kWarmupFrames + kMeasurementFrames ||
      statistics.capture_frames != kWarmupFrames + kMeasurementFrames) {
    return 13;
  }
  return 0;
}