src/media/lib/codec_impl/codec_diagnostics.cc

// Copyright 2022 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <lib/async/default.h>
#include <lib/media/codec_impl/codec_diagnostics.h>
#include <lib/media/codec_impl/log.h>
#include <lib/vfs/cpp/pseudo_dir.h>
#include <lib/vfs/cpp/service.h>

ComponentCodecDiagnostics::ComponentCodecDiagnostics(CodecDiagnostics& driver_diagnostics,
                                                     inspect::Node root)
    : driver_diagnostics_(driver_diagnostics),
      root_(std::move(root)),
      creation_time_(
          root_.CreateUint(kCreationTime, static_cast<uint64_t>(zx_clock_get_monotonic()))) {}

ComponentCodecDiagnostics::~ComponentCodecDiagnostics() { driver_diagnostics_.get().RemoveCodec(); }

std::atomic<trace_counter_id_t> DriverCodecDiagnostics::CurrentTraceCounter = 0;

DriverCodecDiagnostics::DriverCodecDiagnostics(CodecDiagnostics& driver_diagnostics,
                                               inspect::Node root)
    : driver_diagnostics_(driver_diagnostics),
      root_(std::move(root)),
      creation_time_(
          root_.CreateUint(kCreationTime, static_cast<uint64_t>(zx_clock_get_monotonic()))),
      utilizing_hardware_(root_.CreateUint(kCurrentlyUtilizingHardware, 0)),
      allocation_(root_.CreateDouble(kAllocation, 0.0)),
      total_allocated_time_(root_.CreateUint(kTotalAllocatedTime, 0)) {}

DriverCodecDiagnostics::~DriverCodecDiagnostics() {
  // Inform the driver diagnostics that the codec implementation is being destroyed
  if (currently_utilizing_hardware_) {
    driver_diagnostics_.get().DecrementCurrentlyDecoding();
  }

  driver_diagnostics_.get().RemoveCodec();
}

// Update the hardware utilization status. This function should be called whenever a variable that
// could effect value of VideoDecoder::IsUtilizingHardware() changes even if the value of
// VideoDecoder::IsUtilizingHardware() has not changed from the previous call to this function. The
// reason is so that this function can take into account the passage of time and update durations
// stored by this class accordingly. This will also effect the allocation which is calculated and
// published by this function.
void DriverCodecDiagnostics::UpdateHardwareUtilizationStatus(zx::time now,
                                                             bool is_utilizing_hardware) {
  // Get the total time from the last time we checked
  zx::duration total_time = now - last_checked_time_;

  // If we are allocated then add the time our allocation
  if (is_utilizing_hardware) {
    total_allocated_time_.Add(total_time.to_nsecs());
  }

  zx::duration active_time = is_utilizing_hardware ? total_time : zx::nsec(0);

  bool coalesced = false;
  if (!time_periods_.empty()) {
    auto& last_time_period = time_periods_.back();
    auto start_time = time_periods_.back().end_time - time_periods_.back().total_time;
    if (now - start_time < kBucketDuration) {
      coalesced = true;
      last_time_period.end_time = now;
      last_time_period.total_time += total_time;
      last_time_period.active_time += active_time;
    }
  }

  if (!coalesced) {
    time_periods_.emplace_back(now, total_time, active_time);
  }

  while (!time_periods_.empty() && (now - time_periods_.front().end_time > kMemoryDuration)) {
    time_periods_.pop_front();
  }

  zx::duration total_time_accumulate(0);
  zx::duration active_time_accumulate(0);
  for (const auto& current_period : time_periods_) {
    active_time_accumulate += current_period.active_time;
    total_time_accumulate += current_period.total_time;
  }

  double utilization = 0.0;
  if (total_time_accumulate != zx::nsec(0)) {
    utilization = 100.0 * (static_cast<double>(active_time_accumulate.to_nsecs()) /
                           static_cast<double>(total_time_accumulate.to_nsecs()));
  }

  allocation_.Set(utilization);
  utilizing_hardware_.Set(is_utilizing_hardware);

  TRACE_COUNTER("media", "Decoder Utilization", trace_counter_id_, "utilization", utilization);

  // See if there was a change in value of currently_utilizing_hardware_ and if so
  // let the DriverDiagnostics class know that our hardware status has changed.
  if (!currently_utilizing_hardware_ && is_utilizing_hardware) {
    driver_diagnostics_.get().IncrementCurrentlyDecoding();
  } else if (currently_utilizing_hardware_ && !is_utilizing_hardware) {
    driver_diagnostics_.get().DecrementCurrentlyDecoding();
  }

  last_checked_time_ = now;
  currently_utilizing_hardware_ = is_utilizing_hardware;
}

CodecDiagnostics::CodecDiagnostics(std::string_view driver_name, async_dispatcher_t* dispatcher)
    : inspector_(dispatcher, {}),
      root_(inspector_.root().CreateChild(driver_name)),
      bind_time_(root_.CreateUint(kBindTime, 0)),
      num_of_active_codecs_(root_.CreateUint(kNumOfActiveCodecs, 0)),
      currently_decoding_(root_.CreateBool(kCurrentlyDecoding, false)) {}

zx::vmo CodecDiagnostics::DuplicateVmo() const { return inspector_.inspector().DuplicateVmo(); }

void CodecDiagnostics::SetBindTime() {
  zx_time_t current_time = zx_clock_get_monotonic();
  bind_time_.Set(static_cast<int64_t>(current_time));
}

void CodecDiagnostics::IncrementCurrentlyDecoding() {
  num_of_currently_decoding_ += 1;
  currently_decoding_.Set(true);
}

void CodecDiagnostics::DecrementCurrentlyDecoding() {
  if (num_of_currently_decoding_ > 0) {
    num_of_currently_decoding_ -= 1;
  }

  currently_decoding_.Set(num_of_currently_decoding_ != 0);
}

DriverCodecDiagnostics CodecDiagnostics::CreateDriverCodec(std::string_view codec_name) {
  const std::string& codec_prefix = std::string(codec_name) + "-";
  inspect::Node new_decoder_node = root_.CreateChild(root_.UniqueName(codec_prefix));

  num_of_active_codecs_.Add(1);

  return DriverCodecDiagnostics(*this, std::move(new_decoder_node));
}

ComponentCodecDiagnostics CodecDiagnostics::CreateComponentCodec(std::string_view codec_name) {
  inspect::Node new_decoder_node = root_.CreateChild(codec_name);

  num_of_active_codecs_.Add(1);

  return ComponentCodecDiagnostics(*this, std::move(new_decoder_node));
}

void CodecDiagnostics::RemoveCodec() { num_of_active_codecs_.Subtract(1); }