extras/simpleperf/cmd_list.cpp

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <sched.h>
#include <stdio.h>

#include <atomic>
#include <map>
#include <string>
#include <thread>
#include <vector>

#include <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/strings.h>

#include "ETMRecorder.h"
#include "RegEx.h"
#include "command.h"
#include "environment.h"
#include "event_attr.h"
#include "event_fd.h"
#include "event_selection_set.h"
#include "event_type.h"

namespace simpleperf {

extern std::unordered_map<std::string, std::unordered_set<int>> cpu_supported_raw_events;

#if defined(__aarch64__) || defined(__arm__)
extern std::unordered_map<uint64_t, std::string> cpuid_to_name;
#endif  // defined(__aarch64__) || defined(__arm__)

#if defined(__riscv)
extern std::map<std::tuple<uint64_t, std::string, std::string>, std::string> cpuid_to_name;
#endif  // defined(__riscv)

namespace {

struct RawEventTestThreadArg {
  int cpu;
  std::atomic<pid_t> tid;
  std::atomic<bool> start;
};

static void RawEventTestThread(RawEventTestThreadArg* arg) {
  cpu_set_t mask;
  CPU_ZERO(&mask);
  CPU_SET(arg->cpu, &mask);
  int tid = gettid();
  sched_setaffinity(tid, sizeof(mask), &mask);
  arg->tid = tid;
  while (!arg->start) {
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
  }
  TemporaryFile tmpfile;
  FILE* fp = fopen(tmpfile.path, "w");
  if (fp == nullptr) {
    return;
  }
  for (int i = 0; i < 10; ++i) {
    fprintf(fp, "output some data\n");
  }
  fclose(fp);
}

struct RawEventSupportStatus {
  std::vector<int> supported_cpus;
  std::vector<int> may_supported_cpus;
};

#if defined(__riscv)
std::string to_hex_string(uint64_t value) {
  std::stringstream stream;
  stream << "0x" << std::hex << value;
  return stream.str();
}

auto find_cpu_name(
    const std::tuple<uint64_t, uint64_t, uint64_t>& cpu_id,
    const std::map<std::tuple<uint64_t, std::string, std::string>, std::string>& cpuid_to_name) {
  // cpu_id: mvendorid, marchid, mimpid
  // cpuid_to_name: mvendorid, marchid regex, mimpid regex

  std::string marchid_hex = to_hex_string(get<1>(cpu_id));
  std::string mimpid_hex = to_hex_string(get<2>(cpu_id));
  uint64_t mvendorid = std::get<0>(cpu_id);

  // Search the first entry that matches mvendorid
  auto it = cpuid_to_name.lower_bound({mvendorid, "", ""});

  // Search the iterator of correct regex for current CPU from entries with same mvendorid
  for (; it != cpuid_to_name.end() && std::get<0>(it->first) == mvendorid; ++it) {
    const auto& [_, marchid_regex, mimpid_regex] = it->first;
    if (RegEx::Create(marchid_regex)->Match(marchid_hex) &&
        RegEx::Create(mimpid_regex)->Match(mimpid_hex)) {
      break;
    }
  }

  return it;
}
#endif  // defined(__riscv)

class RawEventSupportChecker {
 public:
  bool Init() {
    cpu_models_ = GetCpuModels();
    if (cpu_models_.empty()) {
      LOG(ERROR) << "can't get device cpu info";
      return false;
    }
    for (const auto& model : cpu_models_) {
      cpu_model_names_.push_back(GetCpuModelName(model));
    }
    return true;
  }

  RawEventSupportStatus GetCpusSupportingEvent(const EventType& event_type) {
    RawEventSupportStatus status;
    std::string required_cpu_model;
    // For cpu model specific events, the limited_arch is like "arm64:Cortex-A520".
    if (auto pos = event_type.limited_arch.find(':'); pos != std::string::npos) {
      required_cpu_model = event_type.limited_arch.substr(pos + 1);
    }

    for (size_t i = 0; i < cpu_models_.size(); ++i) {
      const CpuModel& model = cpu_models_[i];
      const std::string& model_name = cpu_model_names_[i];
      bool got_status = false;
      bool supported = false;
      bool may_supported = false;

      if (model.arch == "arm") {
        if (!required_cpu_model.empty()) {
          // This is a cpu model specific event, only supported on required_cpu_model.
          supported = model_name == required_cpu_model;
          got_status = true;
        } else if (!model_name.empty()) {
          // We know events supported on this cpu model.
          auto it = cpu_supported_raw_events.find(model_name);
          CHECK(it != cpu_supported_raw_events.end())
              << "no events configuration for " << model_name;
          supported = it->second.count(event_type.config) > 0;
          got_status = true;
        }
      } else if (model.arch == "x86") {
        std::string limited_arch = event_type.limited_arch;
        if (auto pos = limited_arch.find(':'); pos != std::string::npos) {
          limited_arch = limited_arch.substr(0, pos);
        }
        if (limited_arch != model_name) {
          supported = false;
          got_status = true;
        }
      }

      if (!got_status) {
        // We need to test the event support status.
        TestEventSupportOnCpu(event_type, model.cpus[0], supported, may_supported);
      }

      if (supported) {
        status.supported_cpus.insert(status.supported_cpus.end(), model.cpus.begin(),
                                     model.cpus.end());
      } else if (may_supported) {
        status.may_supported_cpus.insert(status.may_supported_cpus.end(), model.cpus.begin(),
                                         model.cpus.end());
      }
    }
    return status;
  }

 private:
  std::string GetCpuModelName(const CpuModel& model) {
#if defined(__aarch64__) || defined(__arm__)
    uint64_t cpu_id =
        (static_cast<uint64_t>(model.arm_data.implementer) << 32) | model.arm_data.partnum;
    auto it = cpuid_to_name.find(cpu_id);
    if (it != cpuid_to_name.end()) {
      return it->second;
    }
#elif defined(__riscv)
    std::tuple<uint64_t, uint64_t, uint64_t> cpu_id = {
        model.riscv_data.mvendorid, model.riscv_data.marchid, model.riscv_data.mimpid};
    auto it = find_cpu_name(cpu_id, cpuid_to_name);
    if (it != cpuid_to_name.end()) {
      return it->second;
    }
#elif defined(__i386__) || defined(__x86_64__)
    if (android::base::StartsWith(model.x86_data.vendor_id, "GenuineIntel")) {
      return "x86-intel";
    }
    if (android::base::StartsWith(model.x86_data.vendor_id, "AuthenticAMD")) {
      return "x86-amd";
    }
#endif  // defined(__i386__) || defined(__x86_64__)
    return "";
  }

  void TestEventSupportOnCpu(const EventType& event_type, int cpu, bool& supported,
                             bool& may_supported) {
    // Because the kernel may not check whether the raw event is supported by the cpu pmu.
    // We can't decide whether the raw event is supported by calling perf_event_open().
    // Instead, we can check if it can collect some real number.
    RawEventTestThreadArg test_thread_arg;
    test_thread_arg.cpu = cpu;
    test_thread_arg.tid = 0;
    test_thread_arg.start = false;
    std::thread test_thread(RawEventTestThread, &test_thread_arg);
    while (test_thread_arg.tid == 0) {
      std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
    perf_event_attr attr = CreateDefaultPerfEventAttr(event_type);
    attr.exclude_kernel = 1;
#if defined(__i386__) || defined(__x86_64__)
    std::set<int> atom_cpus = GetX86IntelAtomCpus();
    if (atom_cpus.count(cpu) > 0) {
      attr.config = event_type.GetIntelAtomCpuConfig();
    }
#endif  // defined(__i386__) || defined(__x86_64__)
    std::unique_ptr<EventFd> event_fd = EventFd::OpenEventFile(
        attr, test_thread_arg.tid, test_thread_arg.cpu, nullptr, event_type.name, false);
    test_thread_arg.start = true;
    test_thread.join();
    if (event_fd == nullptr) {
      supported = may_supported = false;
      return;
    }
    PerfCounter counter;
    if (!event_fd->ReadCounter(&counter)) {
      supported = may_supported = false;
      return;
    }
    if (counter.value != 0) {
      supported = true;
      may_supported = false;
    } else {
      supported = false;
      may_supported = true;
    }
  }

  std::vector<CpuModel> cpu_models_;

  std::vector<std::string> cpu_model_names_;
};

static std::string ToCpuString(const std::vector<int>& cpus) {
  std::string s;
  if (cpus.empty()) {
    return s;
  }
  s += std::to_string(cpus[0]);
  int last_cpu = cpus[0];
  bool added = true;
  for (size_t i = 1; i < cpus.size(); ++i) {
    if (cpus[i] == last_cpu + 1) {
      last_cpu = cpus[i];
      added = false;
    } else {
      s += "-" + std::to_string(last_cpu) + "," + std::to_string(cpus[i]);
      last_cpu = cpus[i];
      added = true;
    }
  }
  if (!added) {
    s += "-" + std::to_string(last_cpu);
  }
  return s;
}

static void PrintRawEventTypes(const std::string& type_desc) {
  printf("List of %s:\n", type_desc.c_str());
#if defined(__aarch64__) || defined(__arm__)
  printf(
      // clang-format off
"  # Please refer to \"PMU common architectural and microarchitectural event numbers\"\n"
"  # and \"ARM recommendations for IMPLEMENTATION DEFINED event numbers\" listed in\n"
"  # ARMv9 manual for details.\n"
"  # A possible link is https://developer.arm.com/documentation/ddi0487.\n"
      // clang-format on
  );
#endif  // defined(__aarch64__) || defined(__arm__)
  RawEventSupportChecker support_checker;
  if (!support_checker.Init()) {
    return;
  }
  auto callback = [&](const EventType& event_type) {
    if (event_type.type != PERF_TYPE_RAW) {
      return true;
    }
    RawEventSupportStatus status = support_checker.GetCpusSupportingEvent(event_type);
    if (status.supported_cpus.empty() && status.may_supported_cpus.empty()) {
      return true;
    }
    std::string text = "  " + event_type.name + " (";
    if (!status.supported_cpus.empty()) {
      text += "supported on cpu " + ToCpuString(status.supported_cpus);
      if (!status.may_supported_cpus.empty()) {
        text += ", ";
      }
    }
    if (!status.may_supported_cpus.empty()) {
      text += "may supported on cpu " + ToCpuString(status.may_supported_cpus);
    }
    text += ")";
    printf("%s", text.c_str());
    if (!event_type.description.empty()) {
      printf("\t\t# %s", event_type.description.c_str());
    }
    printf("\n");
    return true;
  };
  EventTypeManager::Instance().ForEachType(callback);
  printf("\n");
}

static bool IsEventTypeSupported(const EventType& event_type) {
  // PMU and tracepoint events are provided by kernel. So we assume they're supported.
  if (event_type.IsPmuEvent() || event_type.IsTracepointEvent()) {
    return true;
  }
  perf_event_attr attr = CreateDefaultPerfEventAttr(event_type);
  // Exclude kernel to list supported events even when kernel recording isn't allowed.
  attr.exclude_kernel = 1;
  return IsEventAttrSupported(attr, event_type.name);
}

static void PrintEventTypesOfType(const std::string& type_name, const std::string& type_desc,
                                  const std::function<bool(const EventType&)>& is_type_fn) {
  if (type_name == "raw") {
    return PrintRawEventTypes(type_desc);
  }
  printf("List of %s:\n", type_desc.c_str());
  if (GetTargetArch() == ARCH_ARM || GetTargetArch() == ARCH_ARM64) {
    if (type_name == "cache") {
      printf("  # More cache events are available in `simpleperf list raw`.\n");
    }
  }
  auto callback = [&](const EventType& event_type) {
    if (is_type_fn(event_type)) {
      if (!IsEventTypeSupported(event_type)) {
        return true;
      }
      printf("  %s", event_type.name.c_str());
      if (!event_type.description.empty()) {
        printf("\t\t# %s", event_type.description.c_str());
      }
      printf("\n");
    }
    return true;
  };
  EventTypeManager::Instance().ForEachType(callback);
  printf("\n");
}

class ListCommand : public Command {
 public:
  ListCommand()
      : Command("list", "list available event types",
                // clang-format off
"Usage: simpleperf list [options] [hw|sw|cache|raw|tracepoint|pmu]\n"
"       List all available event types.\n"
"       Filters can be used to show only event types belong to selected types:\n"
"         hw          hardware events\n"
"         sw          software events\n"
"         cache       hardware cache events\n"
"         raw         raw cpu pmu events\n"
"         tracepoint  tracepoint events\n"
"         cs-etm      coresight etm instruction tracing events\n"
"         pmu         system-specific pmu events\n"
"Options:\n"
"--show-features    Show features supported on the device, including:\n"
"                     dwarf-based-call-graph\n"
"                     trace-offcpu\n"
                // clang-format on
        ) {}

  bool Run(const std::vector<std::string>& args) override;

 private:
  void ShowFeatures();
};

bool ListCommand::Run(const std::vector<std::string>& args) {
  if (!CheckPerfEventLimit()) {
    return false;
  }

  static std::map<std::string, std::pair<std::string, std::function<bool(const EventType&)>>>
      type_map = {
          {"hw",
           {"hardware events", [](const EventType& e) { return e.type == PERF_TYPE_HARDWARE; }}},
          {"sw",
           {"software events", [](const EventType& e) { return e.type == PERF_TYPE_SOFTWARE; }}},
          {"cache",
           {"hw-cache events", [](const EventType& e) { return e.type == PERF_TYPE_HW_CACHE; }}},
          {"raw",
           {"raw events provided by cpu pmu",
            [](const EventType& e) { return e.type == PERF_TYPE_RAW; }}},
          {"tracepoint",
           {"tracepoint events",
            [](const EventType& e) { return e.type == PERF_TYPE_TRACEPOINT; }}},
#if defined(__arm__) || defined(__aarch64__)
          {"cs-etm",
           {"coresight etm events",
            [](const EventType& e) {
              return e.type == ETMRecorder::GetInstance().GetEtmEventType();
            }}},
#endif
          {"pmu", {"pmu events", [](const EventType& e) { return e.IsPmuEvent(); }}},
      };

  std::vector<std::string> names;
  if (args.empty()) {
    for (auto& item : type_map) {
      names.push_back(item.first);
    }
  } else {
    for (auto& arg : args) {
      if (type_map.find(arg) != type_map.end()) {
        names.push_back(arg);
      } else if (arg == "--show-features") {
        ShowFeatures();
        return true;
      } else {
        LOG(ERROR) << "unknown event type category: " << arg << ", try using \"help list\"";
        return false;
      }
    }
  }

  for (auto& name : names) {
    auto it = type_map.find(name);
    PrintEventTypesOfType(name, it->second.first, it->second.second);
  }
  return true;
}

void ListCommand::ShowFeatures() {
  if (IsDwarfCallChainSamplingSupported()) {
    printf("dwarf-based-call-graph\n");
  }
  if (IsDumpingRegsForTracepointEventsSupported()) {
    printf("trace-offcpu\n");
  }
  if (IsSettingClockIdSupported()) {
    printf("set-clockid\n");
  }
}

}  // namespace

void RegisterListCommand() {
  RegisterCommand("list", [] { return std::unique_ptr<Command>(new ListCommand); });
}

}  // namespace simpleperf