| //===- unittest/ProfileData/InstrProfTest.cpp -------------------------------=// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "llvm/ProfileData/InstrProfReader.h" |
| #include "llvm/ProfileData/InstrProfWriter.h" |
| #include "gtest/gtest.h" |
| |
| #include <cstdarg> |
| |
| using namespace llvm; |
| |
| static ::testing::AssertionResult NoError(std::error_code EC) { |
| if (!EC) |
| return ::testing::AssertionSuccess(); |
| return ::testing::AssertionFailure() << "error " << EC.value() |
| << ": " << EC.message(); |
| } |
| |
| static ::testing::AssertionResult ErrorEquals(std::error_code Expected, |
| std::error_code Found) { |
| if (Expected == Found) |
| return ::testing::AssertionSuccess(); |
| return ::testing::AssertionFailure() << "error " << Found.value() |
| << ": " << Found.message(); |
| } |
| |
| namespace { |
| |
| struct InstrProfTest : ::testing::Test { |
| InstrProfWriter Writer; |
| std::unique_ptr<IndexedInstrProfReader> Reader; |
| |
| void readProfile(std::unique_ptr<MemoryBuffer> Profile) { |
| auto ReaderOrErr = IndexedInstrProfReader::create(std::move(Profile)); |
| ASSERT_TRUE(NoError(ReaderOrErr.getError())); |
| Reader = std::move(ReaderOrErr.get()); |
| } |
| }; |
| |
| TEST_F(InstrProfTest, write_and_read_empty_profile) { |
| auto Profile = Writer.writeBuffer(); |
| readProfile(std::move(Profile)); |
| ASSERT_TRUE(Reader->begin() == Reader->end()); |
| } |
| |
| TEST_F(InstrProfTest, write_and_read_one_function) { |
| Writer.addFunctionCounts("foo", 0x1234, {1, 2, 3, 4}); |
| auto Profile = Writer.writeBuffer(); |
| readProfile(std::move(Profile)); |
| |
| auto I = Reader->begin(), E = Reader->end(); |
| ASSERT_TRUE(I != E); |
| ASSERT_EQ(StringRef("foo"), I->Name); |
| ASSERT_EQ(0x1234U, I->Hash); |
| ASSERT_EQ(4U, I->Counts.size()); |
| ASSERT_EQ(1U, I->Counts[0]); |
| ASSERT_EQ(2U, I->Counts[1]); |
| ASSERT_EQ(3U, I->Counts[2]); |
| ASSERT_EQ(4U, I->Counts[3]); |
| ASSERT_TRUE(++I == E); |
| } |
| |
| TEST_F(InstrProfTest, get_function_counts) { |
| Writer.addFunctionCounts("foo", 0x1234, {1, 2}); |
| Writer.addFunctionCounts("foo", 0x1235, {3, 4}); |
| auto Profile = Writer.writeBuffer(); |
| readProfile(std::move(Profile)); |
| |
| std::vector<uint64_t> Counts; |
| ASSERT_TRUE(NoError(Reader->getFunctionCounts("foo", 0x1234, Counts))); |
| ASSERT_EQ(2U, Counts.size()); |
| ASSERT_EQ(1U, Counts[0]); |
| ASSERT_EQ(2U, Counts[1]); |
| |
| ASSERT_TRUE(NoError(Reader->getFunctionCounts("foo", 0x1235, Counts))); |
| ASSERT_EQ(2U, Counts.size()); |
| ASSERT_EQ(3U, Counts[0]); |
| ASSERT_EQ(4U, Counts[1]); |
| |
| std::error_code EC; |
| EC = Reader->getFunctionCounts("foo", 0x5678, Counts); |
| ASSERT_TRUE(ErrorEquals(instrprof_error::hash_mismatch, EC)); |
| |
| EC = Reader->getFunctionCounts("bar", 0x1234, Counts); |
| ASSERT_TRUE(ErrorEquals(instrprof_error::unknown_function, EC)); |
| } |
| |
| TEST_F(InstrProfTest, get_max_function_count) { |
| Writer.addFunctionCounts("foo", 0x1234, {1ULL << 31, 2}); |
| Writer.addFunctionCounts("bar", 0, {1ULL << 63}); |
| Writer.addFunctionCounts("baz", 0x5678, {0, 0, 0, 0}); |
| auto Profile = Writer.writeBuffer(); |
| readProfile(std::move(Profile)); |
| |
| ASSERT_EQ(1ULL << 63, Reader->getMaximumFunctionCount()); |
| } |
| |
| } // end anonymous namespace |