From 03a2ab3e95bdc7e4b90ca1846e73a3fc86c83e59 Mon Sep 17 00:00:00 2001 From: Yabin Cui Date: Tue, 25 Jul 2023 10:06:16 -0700 Subject: simpleperf: Disable failed tests when running with a 32-bit translator The CtsSimpleperfTestCases built for ARM may run with a 32-bit translator on a 64-bit only CPU. In this situation, tests about recording apps can fail because of the limiation of translation. So detect this situation and diable failed tests. Bug: 291717595 Test: run CtsSimpleperfTestCases Change-Id: Icd9f3736d5dd84c2c502e6b733a3688b0a3de2bb Merged-In: Icd9f3736d5dd84c2c502e6b733a3688b0a3de2bb --- simpleperf/cmd_record_test.cpp | 4 ++++ simpleperf/test_util.cpp | 39 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 42 insertions(+), 1 deletion(-) diff --git a/simpleperf/cmd_record_test.cpp b/simpleperf/cmd_record_test.cpp index b8300d7f..4ea71ad1 100644 --- a/simpleperf/cmd_record_test.cpp +++ b/simpleperf/cmd_record_test.cpp @@ -790,6 +790,7 @@ static void TestRecordingApps(const std::string& app_name, const std::string& ap } TEST(record_cmd, app_option_for_debuggable_app) { + OMIT_TEST_ON_NON_NATIVE_ABIS(); TEST_REQUIRE_APPS(); SetRunInAppToolForTesting(true, false); TestRecordingApps("com.android.simpleperf.debuggable", "debuggable"); @@ -798,6 +799,7 @@ TEST(record_cmd, app_option_for_debuggable_app) { } TEST(record_cmd, app_option_for_profileable_app) { + OMIT_TEST_ON_NON_NATIVE_ABIS(); TEST_REQUIRE_APPS(); SetRunInAppToolForTesting(false, true); TestRecordingApps("com.android.simpleperf.profileable", "profileable"); @@ -827,6 +829,7 @@ static void RecordJavaApp(RecordingAppHelper& helper) { TEST(record_cmd, record_java_app) { #if defined(__ANDROID__) + OMIT_TEST_ON_NON_NATIVE_ABIS(); RecordingAppHelper helper; RecordJavaApp(helper); @@ -892,6 +895,7 @@ TEST(record_cmd, record_native_app) { TEST(record_cmd, check_trampoline_after_art_jni_methods) { // Test if art jni methods are called by art_jni_trampoline. #if defined(__ANDROID__) + OMIT_TEST_ON_NON_NATIVE_ABIS(); RecordingAppHelper helper; RecordJavaApp(helper); diff --git a/simpleperf/test_util.cpp b/simpleperf/test_util.cpp index 60d8ea35..ad667e22 100644 --- a/simpleperf/test_util.cpp +++ b/simpleperf/test_util.cpp @@ -17,14 +17,45 @@ #include +#include + #include #include +#include "command.h" #include "event_attr.h" #include "event_fd.h" #include "event_type.h" +#include "record_file.h" #include "test_util.h" +#if defined(__linux__) + +static std::optional CanSampleRegsFor32BitABI() { + std::vector> workloads; + CreateProcesses(1, &workloads); + std::string pid = std::to_string(workloads[0]->GetPid()); + std::unique_ptr cmd = CreateCommandInstance("record"); + TemporaryFile tmpfile; + if (!cmd->Run({"-p", pid, "--call-graph", "dwarf,8", "--no-unwind", "-e", "cpu-clock:u", + "--duration", "3", "-o", tmpfile.path})) { + return std::nullopt; + } + auto reader = RecordFileReader::CreateInstance(tmpfile.path); + if (!reader) { + return std::nullopt; + } + for (const std::unique_ptr& record : reader->DataSection()) { + if (record->type() == PERF_RECORD_SAMPLE) { + auto sample = static_cast(record.get()); + if (sample->regs_user_data.abi == PERF_SAMPLE_REGS_ABI_32) { + return true; + } + } + } + return false; +} + bool IsInNativeAbi() { static int in_native_abi = -1; if (in_native_abi == -1) { @@ -43,6 +74,13 @@ bool IsInNativeAbi() { if (s.find("arm") == std::string::npos && s.find("aarch64") == std::string::npos) { in_native_abi = 0; } + if (GetTargetArch() == ARCH_ARM) { + // If we can't get ARM registers in samples, probably we are running with a 32-bit + // translator on 64-bit only CPUs. + if (CanSampleRegsFor32BitABI() != std::optional(true)) { + in_native_abi = 0; + } + } } else if (GetTargetArch() == ARCH_RISCV64) { if (s.find("riscv") == std::string::npos) { in_native_abi = 0; @@ -52,7 +90,6 @@ bool IsInNativeAbi() { return in_native_abi == 1; } -#if defined(__linux__) // Check if we can get a non-zero instruction event count by monitoring current thread. static bool HasNonZeroInstructionEventCount() { const simpleperf::EventType* type = simpleperf::FindEventTypeByName("instructions", false); -- cgit v1.2.3 From d85e633e1fd8c647de595a1a74dd07ce718acbb5 Mon Sep 17 00:00:00 2001 From: Yabin Cui Date: Wed, 26 Jul 2023 10:59:42 -0700 Subject: simpleperf: check errors in CanSampleRegsFor32BitABI() CanSampleRegsFor32BitABI() returns nullopt when having an error. Currently the caller ignores the error. But it's better to check. So this patch checks the error in OMIT_TEST_ON_NON_NATIVE_ABIS. Bug: 291717595 Test: run CtsSimpleperfTestCases Change-Id: I210fbb5ca2f426936cefd0ae717ff50f4549f2ae Merged-In: I210fbb5ca2f426936cefd0ae717ff50f4549f2ae --- simpleperf/test_util.cpp | 16 +++++++++++----- simpleperf/test_util.h | 7 +++++-- 2 files changed, 16 insertions(+), 7 deletions(-) diff --git a/simpleperf/test_util.cpp b/simpleperf/test_util.cpp index ad667e22..7e99b5d5 100644 --- a/simpleperf/test_util.cpp +++ b/simpleperf/test_util.cpp @@ -56,7 +56,7 @@ static std::optional CanSampleRegsFor32BitABI() { return false; } -bool IsInNativeAbi() { +std::optional IsInNativeAbi() { static int in_native_abi = -1; if (in_native_abi == -1) { FILE* fp = popen("uname -m", "re"); @@ -76,9 +76,11 @@ bool IsInNativeAbi() { } if (GetTargetArch() == ARCH_ARM) { // If we can't get ARM registers in samples, probably we are running with a 32-bit - // translator on 64-bit only CPUs. - if (CanSampleRegsFor32BitABI() != std::optional(true)) { - in_native_abi = 0; + // translator on 64-bit only CPUs. Then we should make in_native_abi = 0. + if (auto result = CanSampleRegsFor32BitABI(); result.has_value()) { + in_native_abi = result.value() ? 1 : 0; + } else { + in_native_abi = 2; } } } else if (GetTargetArch() == ARCH_RISCV64) { @@ -87,6 +89,9 @@ bool IsInNativeAbi() { } } } + if (in_native_abi == 2) { + return std::nullopt; + } return in_native_abi == 1; } @@ -121,8 +126,9 @@ bool HasHardwareCounter() { bool is_emulator = android::base::StartsWith(fingerprint, "google/sdk_gphone") || android::base::StartsWith(fingerprint, "google/sdk_gpc") || android::base::StartsWith(fingerprint, "generic/cf"); + bool in_native_abi = IsInNativeAbi() == std::optional(true); - if (arch == ARCH_X86_64 || arch == ARCH_X86_32 || !IsInNativeAbi() || is_emulator) { + if (arch == ARCH_X86_64 || arch == ARCH_X86_32 || !in_native_abi || is_emulator) { // On x86 and x86_64, or when we are not in native abi, it's likely to run on an emulator or // vm without hardware perf counters. It's hard to enumerate them all. So check the support // at runtime. diff --git a/simpleperf/test_util.h b/simpleperf/test_util.h index 21b89a5e..16483103 100644 --- a/simpleperf/test_util.h +++ b/simpleperf/test_util.h @@ -16,6 +16,7 @@ #include #include +#include #include #include @@ -68,11 +69,13 @@ void CheckElfFileSymbols(const std::map& symbols); #define TEST_REQUIRE_HOST_ROOT() TEST_REQUIRE_ROOT() #endif -bool IsInNativeAbi(); +std::optional IsInNativeAbi(); // Used to skip tests not supposed to run on non-native ABIs. #define OMIT_TEST_ON_NON_NATIVE_ABIS() \ do { \ - if (!IsInNativeAbi()) { \ + std::optional in_native_abi = IsInNativeAbi(); \ + ASSERT_TRUE(in_native_abi.has_value()); \ + if (!in_native_abi.value()) { \ GTEST_LOG_(INFO) << "Skip this test as it only runs on native ABIs."; \ return; \ } \ -- cgit v1.2.3