/*
 * Copyright (c) Advanced Micro Devices, Inc. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include "frequencies_read.h"

#include <gtest/gtest.h>

#include <cstdint>
#include <iomanip>
#include <iostream>
#include <string>

#include "../test_common.h"
#include "amd_smi/amdsmi.h"

TestFrequenciesRead::TestFrequenciesRead() : TestBase() {
  set_title("AMDSMI Frequencies Read Test");
  set_description(
      "The Frequency Read tests verifies that the "
      "available and current frequency levels can be read properly.");
}

TestFrequenciesRead::~TestFrequenciesRead(void) {}

void TestFrequenciesRead::SetUp(void) {
  TestBase::SetUp();

  return;
}

void TestFrequenciesRead::DisplayTestInfo(void) { TestBase::DisplayTestInfo(); }

void TestFrequenciesRead::DisplayResults(void) const {
  TestBase::DisplayResults();
  return;
}

void TestFrequenciesRead::Close() {
  // This will close handles opened within rsmitst utility calls and call
  // amdsmi_shut_down(), so it should be done after other hsa cleanup
  TestBase::Close();
}

static void print_frequencies(amdsmi_frequencies_t* f, uint32_t* l = nullptr) {
  assert(f != nullptr);
  for (uint32_t clk_i = 0; clk_i < f->num_supported; ++clk_i) {
    std::string clk_i_str;
    if (f->has_deep_sleep) {
      clk_i_str = (clk_i == 0) ? "S" : std::to_string(clk_i - 1);
    } else {
      clk_i_str = std::to_string(clk_i);
    }
    std::cout << "\t**  " << std::setw(2) << std::right << clk_i_str << ": " << std::setw(11)
              << std::right << f->frequency[clk_i];
    if (l != nullptr) {
      std::cout << "T/s; x" << l[clk_i];
    } else {
      std::cout << "Hz";
    }

    if (clk_i == f->current) {
      std::cout << " *";
    }
    std::cout << std::endl;
  }
}

void TestFrequenciesRead::Run(void) {
  amdsmi_status_t err;
  amdsmi_frequencies_t f;
  amdsmi_pcie_bandwidth_t b;

  TestBase::Run();
  PRINT_VERBOSITY();
  if (setup_failed_) {
    std::cout << "** SetUp Failed for this test. Skipping.**" << std::endl;
    return;
  }

  for (uint32_t x = 0; x < num_iterations(); ++x) {
    for (uint32_t i = 0; i < num_monitor_devs(); ++i) {
      auto freq_output = [&](amdsmi_clk_type_t t, const char* name) {
        DISPLAY_AMDSMI_API("amdsmi_get_clk_freq", "gpu=" + std::to_string(i), VERB(STANDARD));
        err = amdsmi_get_clk_freq(processor_handles_[i], t, &f);
        DISPLAY_AMDSMI_STATUS(VERB(STANDARD), __FILE__, __LINE__, err, AMDSMI_STATUS_SUCCESS);
        if (err == AMDSMI_STATUS_NOT_SUPPORTED) {
          std::cout << "\t**Get " << name << ": Not supported on this machine" << std::endl;
          // Verify api support checking functionality is working
          DISPLAY_AMDSMI_API("amdsmi_get_clk_freq", "gpu=" + std::to_string(i), VERB(STANDARD));
          err = amdsmi_get_clk_freq(processor_handles_[i], t, nullptr);
          DISPLAY_AMDSMI_STATUS(VERB(STANDARD), __FILE__, __LINE__, err, AMDSMI_STATUS_INVAL);
          ASSERT_EQ(err, AMDSMI_STATUS_NOT_SUPPORTED);
          return;
        }

        if (err == AMDSMI_STATUS_NOT_YET_IMPLEMENTED) {
          return;
        }

        if (err == AMDSMI_STATUS_UNEXPECTED_DATA) {
          // special driver issue, shouldn't normally occur
          std::cerr << "WARN: Clock file [" << FreqEnumToStr(t) << "] exists on device [" << i
                    << "] but empty!" << std::endl;
          std::cerr << "      Likely a driver issue!" << std::endl;
          return;
        }

        CHK_ERR_ASRT(err)
        IF_VERB(STANDARD) {
          std::cout << "\t**Supported " << name << " clock frequencies: ";
          std::cout << f.num_supported << std::endl;
          print_frequencies(&f);
          // Verify api support checking functionality is working
          DISPLAY_AMDSMI_API("amdsmi_get_clk_freq", "gpu=" + std::to_string(i), VERB(STANDARD));
          err = amdsmi_get_clk_freq(processor_handles_[i], t, nullptr);
          DISPLAY_AMDSMI_STATUS(VERB(STANDARD), __FILE__, __LINE__, err, AMDSMI_STATUS_INVAL);
          ASSERT_EQ(err, AMDSMI_STATUS_INVAL);
        }
      };

      PrintDeviceHeader(processor_handles_[i]);

      freq_output(AMDSMI_CLK_TYPE_MEM, "GPU Memory Clock (mclk)");
      freq_output(AMDSMI_CLK_TYPE_SYS, "GPU Clock (sclk)");
      freq_output(AMDSMI_CLK_TYPE_DF, "Data Fabric Clock (fclk)");
      freq_output(AMDSMI_CLK_TYPE_DCEF, "Display Controller Engine Clock (dcefclk)");
      freq_output(AMDSMI_CLK_TYPE_SOC, "SOC Clock (socclk)");

      // Verify api support checking functionality is working
      DISPLAY_AMDSMI_API("amdsmi_get_gpu_pci_bandwidth(nullptr)", "gpu=" + std::to_string(i),
                         VERB(STANDARD));
      err = amdsmi_get_gpu_pci_bandwidth(processor_handles_[i], nullptr);
      DISPLAY_AMDSMI_STATUS(VERB(STANDARD), __FILE__, __LINE__, err, AMDSMI_STATUS_INVAL);
      ASSERT_EQ(err, AMDSMI_STATUS_INVAL);
      DISPLAY_AMDSMI_API("amdsmi_get_gpu_pci_bandwidth", "gpu=" + std::to_string(i),
                         VERB(STANDARD));
      err = amdsmi_get_gpu_pci_bandwidth(processor_handles_[i], &b);
      DISPLAY_AMDSMI_STATUS(VERB(STANDARD), __FILE__, __LINE__, err, AMDSMI_STATUS_SUCCESS);
      if (err == AMDSMI_STATUS_NOT_SUPPORTED) {
        ASSERT_EQ(err, AMDSMI_STATUS_NOT_SUPPORTED);
        IF_VERB(STANDARD) {
          std::cout << "\t**Get PCIE Bandwidth: Not supported on this machine" << std::endl;
        }
      } else if (err == AMDSMI_STATUS_NOT_YET_IMPLEMENTED) {
        ASSERT_EQ(err, AMDSMI_STATUS_NOT_YET_IMPLEMENTED);
        IF_VERB(STANDARD) {
          std::cout << "\t**Get PCIE Bandwidth: Not implemented on this machine" << std::endl;
        }
      } else {
        CHK_ERR_ASRT(err)
        IF_VERB(STANDARD) {
          std::cout << "\t**Supported PCIe bandwidths: ";
          std::cout << b.transfer_rate.num_supported << std::endl;
          print_frequencies(&b.transfer_rate, b.lanes);
        }
      }
    }
  }
}
