lib/xray/tests/unit/profile_collector_test.cpp - llvm-project/compiler-rt - Git at Google

 //===-- profile_collector_test.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of XRay, a function call tracing system.
 //
 //===----------------------------------------------------------------------===//
 #include "gtest/gtest.h"

 #include "xray_profile_collector.h"
 #include "xray_profiling_flags.h"
 #include <cstdint>
 #include <cstring>
 #include <memory>
 #include <thread>
 #include <utility>
 #include <vector>

 namespace __xray {
 namespace {

 static constexpr auto kHeaderSize = 16u;

 constexpr uptr ExpectedProfilingVersion = 0x20180424;

 struct ExpectedProfilingFileHeader {
   const u64 MagicBytes = 0x7872617970726f66; // Identifier for XRay profiling
                                              // files 'xrayprof' in hex.
   const u64 Version = ExpectedProfilingVersion;
   u64 Timestamp = 0;
   u64 PID = 0;
 };

 void ValidateFileHeaderBlock(XRayBuffer B) {
   ASSERT_NE(static_cast<const void *>(B.Data), nullptr);
   ASSERT_EQ(B.Size, sizeof(ExpectedProfilingFileHeader));
   typename std::aligned_storage<sizeof(ExpectedProfilingFileHeader)>::type
       FileHeaderStorage;
   ExpectedProfilingFileHeader ExpectedHeader;
   std::memcpy(&FileHeaderStorage, B.Data, B.Size);
   auto &FileHeader =
       *reinterpret_cast<ExpectedProfilingFileHeader *>(&FileHeaderStorage);
   ASSERT_EQ(ExpectedHeader.MagicBytes, FileHeader.MagicBytes);
   ASSERT_EQ(ExpectedHeader.Version, FileHeader.Version);
 }

 void ValidateBlock(XRayBuffer B) {
   profilingFlags()->setDefaults();
   ASSERT_NE(static_cast<const void *>(B.Data), nullptr);
   ASSERT_NE(B.Size, 0u);
   ASSERT_GE(B.Size, kHeaderSize);
   // We look at the block size, the block number, and the thread ID to ensure
   // that none of them are zero (or that the header data is laid out as we
   // expect).
   char LocalBuffer[kHeaderSize] = {};
   internal_memcpy(LocalBuffer, B.Data, kHeaderSize);
   u32 BlockSize = 0;
   u32 BlockNumber = 0;
   u64 ThreadId = 0;
   internal_memcpy(&BlockSize, LocalBuffer, sizeof(u32));
   internal_memcpy(&BlockNumber, LocalBuffer + sizeof(u32), sizeof(u32));
   internal_memcpy(&ThreadId, LocalBuffer + (2 * sizeof(u32)), sizeof(u64));
   ASSERT_NE(BlockSize, 0u);
   ASSERT_GE(BlockNumber, 0u);
   ASSERT_NE(ThreadId, 0u);
 }

 std::tuple<u32, u32, u64> ParseBlockHeader(XRayBuffer B) {
   char LocalBuffer[kHeaderSize] = {};
   internal_memcpy(LocalBuffer, B.Data, kHeaderSize);
   u32 BlockSize = 0;
   u32 BlockNumber = 0;
   u64 ThreadId = 0;
   internal_memcpy(&BlockSize, LocalBuffer, sizeof(u32));
   internal_memcpy(&BlockNumber, LocalBuffer + sizeof(u32), sizeof(u32));
   internal_memcpy(&ThreadId, LocalBuffer + (2 * sizeof(u32)), sizeof(u64));
   return std::make_tuple(BlockSize, BlockNumber, ThreadId);
 }

 struct Profile {
   int64_t CallCount;
   int64_t CumulativeLocalTime;
   std::vector<int32_t> Path;
 };

 std::tuple<Profile, const char *> ParseProfile(const char *P) {
   Profile Result;
   // Read the path first, until we find a sentinel 0.
   int32_t F;
   do {
     internal_memcpy(&F, P, sizeof(int32_t));
     P += sizeof(int32_t);
     Result.Path.push_back(F);
   } while (F != 0);

   // Then read the CallCount.
   internal_memcpy(&Result.CallCount, P, sizeof(int64_t));
   P += sizeof(int64_t);

   // Then read the CumulativeLocalTime.
   internal_memcpy(&Result.CumulativeLocalTime, P, sizeof(int64_t));
   P += sizeof(int64_t);
   return std::make_tuple(std::move(Result), P);
 }

 TEST(profileCollectorServiceTest, PostSerializeCollect) {
   profilingFlags()->setDefaults();
   bool Success = false;
   BufferQueue BQ(profilingFlags()->per_thread_allocator_max,
                  profilingFlags()->buffers_max, Success);
   ASSERT_EQ(Success, true);
   FunctionCallTrie::Allocators::Buffers Buffers;
   ASSERT_EQ(BQ.getBuffer(Buffers.NodeBuffer), BufferQueue::ErrorCode::Ok);
   ASSERT_EQ(BQ.getBuffer(Buffers.RootsBuffer), BufferQueue::ErrorCode::Ok);
   ASSERT_EQ(BQ.getBuffer(Buffers.ShadowStackBuffer),
             BufferQueue::ErrorCode::Ok);
   ASSERT_EQ(BQ.getBuffer(Buffers.NodeIdPairBuffer), BufferQueue::ErrorCode::Ok);
   auto Allocators = FunctionCallTrie::InitAllocatorsFromBuffers(Buffers);
   FunctionCallTrie T(Allocators);

   // Populate the trie with some data.
   T.enterFunction(1, 1, 0);
   T.enterFunction(2, 2, 0);
   T.exitFunction(2, 3, 0);
   T.exitFunction(1, 4, 0);

   // Reset the collector data structures.
   profileCollectorService::reset();

   // Then we post the data to the global profile collector service.
   profileCollectorService::post(&BQ, std::move(T), std::move(Allocators),
                                 std::move(Buffers), 1);

   // Then we serialize the data.
   profileCollectorService::serialize();

   // Then we go through two buffers to see whether we're getting the data we
   // expect. The first block must always be as large as a file header, which
   // will have a fixed size.
   auto B = profileCollectorService::nextBuffer({nullptr, 0});
   ValidateFileHeaderBlock(B);

   B = profileCollectorService::nextBuffer(B);
   ValidateBlock(B);
   u32 BlockSize;
   u32 BlockNum;
   u64 ThreadId;
   std::tie(BlockSize, BlockNum, ThreadId) = ParseBlockHeader(B);

   // We look at the serialized buffer to see whether the Trie we're expecting
   // to see is there.
   auto DStart = static_cast<const char *>(B.Data) + kHeaderSize;
   std::vector<char> D(DStart, DStart + BlockSize);
   B = profileCollectorService::nextBuffer(B);
   ASSERT_EQ(B.Data, nullptr);
   ASSERT_EQ(B.Size, 0u);

   Profile Profile1, Profile2;
   auto P = static_cast<const char *>(D.data());
   std::tie(Profile1, P) = ParseProfile(P);
   std::tie(Profile2, P) = ParseProfile(P);

   ASSERT_NE(Profile1.Path.size(), Profile2.Path.size());
   auto &P1 = Profile1.Path.size() < Profile2.Path.size() ? Profile2 : Profile1;
   auto &P2 = Profile1.Path.size() < Profile2.Path.size() ? Profile1 : Profile2;
   std::vector<int32_t> P1Expected = {2, 1, 0};
   std::vector<int32_t> P2Expected = {1, 0};
   ASSERT_EQ(P1.Path.size(), P1Expected.size());
   ASSERT_EQ(P2.Path.size(), P2Expected.size());
   ASSERT_EQ(P1.Path, P1Expected);
   ASSERT_EQ(P2.Path, P2Expected);
 }

 // We break out a function that will be run in multiple threads, one that will
 // use a thread local allocator, and will post the FunctionCallTrie to the
 // profileCollectorService. This simulates what the threads being profiled would
 // be doing anyway, but through the XRay logging implementation.
 void threadProcessing() {
   static bool Success = false;
   static BufferQueue BQ(profilingFlags()->per_thread_allocator_max,
                         profilingFlags()->buffers_max, Success);
   thread_local FunctionCallTrie::Allocators::Buffers Buffers = [] {
     FunctionCallTrie::Allocators::Buffers B;
     BQ.getBuffer(B.NodeBuffer);
     BQ.getBuffer(B.RootsBuffer);
     BQ.getBuffer(B.ShadowStackBuffer);
     BQ.getBuffer(B.NodeIdPairBuffer);
     return B;
   }();

   thread_local auto Allocators =
       FunctionCallTrie::InitAllocatorsFromBuffers(Buffers);

   FunctionCallTrie T(Allocators);

   T.enterFunction(1, 1, 0);
   T.enterFunction(2, 2, 0);
   T.exitFunction(2, 3, 0);
   T.exitFunction(1, 4, 0);

   profileCollectorService::post(&BQ, std::move(T), std::move(Allocators),
                                 std::move(Buffers), GetTid());
 }

 TEST(profileCollectorServiceTest, PostSerializeCollectMultipleThread) {
   profilingFlags()->setDefaults();

   profileCollectorService::reset();

   std::thread t1(threadProcessing);
   std::thread t2(threadProcessing);

   t1.join();
   t2.join();

   // At this point, t1 and t2 are already done with what they were doing.
   profileCollectorService::serialize();

   // Ensure that we see two buffers.
   auto B = profileCollectorService::nextBuffer({nullptr, 0});
   ValidateFileHeaderBlock(B);

   B = profileCollectorService::nextBuffer(B);
   ValidateBlock(B);

   B = profileCollectorService::nextBuffer(B);
   ValidateBlock(B);
 }

 } // namespace
 } // namespace __xray
	//===-- profile_collector_test.cpp ----------------------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	//
	// This file is a part of XRay, a function call tracing system.
	//
	//===----------------------------------------------------------------------===//
	#include "gtest/gtest.h"

	#include "xray_profile_collector.h"
	#include "xray_profiling_flags.h"
	#include <cstdint>
	#include <cstring>
	#include <memory>
	#include <thread>
	#include <utility>
	#include <vector>

	namespace __xray {
	namespace {

	static constexpr auto kHeaderSize = 16u;

	constexpr uptr ExpectedProfilingVersion = 0x20180424;

	struct ExpectedProfilingFileHeader {
	const u64 MagicBytes = 0x7872617970726f66; // Identifier for XRay profiling
	// files 'xrayprof' in hex.
	const u64 Version = ExpectedProfilingVersion;
	u64 Timestamp = 0;
	u64 PID = 0;
	};

	void ValidateFileHeaderBlock(XRayBuffer B) {
	ASSERT_NE(static_cast<const void *>(B.Data), nullptr);
	ASSERT_EQ(B.Size, sizeof(ExpectedProfilingFileHeader));
	typename std::aligned_storage<sizeof(ExpectedProfilingFileHeader)>::type
	FileHeaderStorage;
	ExpectedProfilingFileHeader ExpectedHeader;
	std::memcpy(&FileHeaderStorage, B.Data, B.Size);
	auto &FileHeader =
	reinterpret_cast<ExpectedProfilingFileHeader >(&FileHeaderStorage);
	ASSERT_EQ(ExpectedHeader.MagicBytes, FileHeader.MagicBytes);
	ASSERT_EQ(ExpectedHeader.Version, FileHeader.Version);
	}

	void ValidateBlock(XRayBuffer B) {
	profilingFlags()->setDefaults();
	ASSERT_NE(static_cast<const void *>(B.Data), nullptr);
	ASSERT_NE(B.Size, 0u);
	ASSERT_GE(B.Size, kHeaderSize);
	// We look at the block size, the block number, and the thread ID to ensure
	// that none of them are zero (or that the header data is laid out as we
	// expect).
	char LocalBuffer[kHeaderSize] = {};
	internal_memcpy(LocalBuffer, B.Data, kHeaderSize);
	u32 BlockSize = 0;
	u32 BlockNumber = 0;
	u64 ThreadId = 0;
	internal_memcpy(&BlockSize, LocalBuffer, sizeof(u32));
	internal_memcpy(&BlockNumber, LocalBuffer + sizeof(u32), sizeof(u32));
	internal_memcpy(&ThreadId, LocalBuffer + (2 * sizeof(u32)), sizeof(u64));
	ASSERT_NE(BlockSize, 0u);
	ASSERT_GE(BlockNumber, 0u);
	ASSERT_NE(ThreadId, 0u);
	}

	std::tuple<u32, u32, u64> ParseBlockHeader(XRayBuffer B) {
	char LocalBuffer[kHeaderSize] = {};
	internal_memcpy(LocalBuffer, B.Data, kHeaderSize);
	u32 BlockSize = 0;
	u32 BlockNumber = 0;
	u64 ThreadId = 0;
	internal_memcpy(&BlockSize, LocalBuffer, sizeof(u32));
	internal_memcpy(&BlockNumber, LocalBuffer + sizeof(u32), sizeof(u32));
	internal_memcpy(&ThreadId, LocalBuffer + (2 * sizeof(u32)), sizeof(u64));
	return std::make_tuple(BlockSize, BlockNumber, ThreadId);
	}

	struct Profile {
	int64_t CallCount;
	int64_t CumulativeLocalTime;
	std::vector<int32_t> Path;
	};

	std::tuple<Profile, const char > ParseProfile(const char P) {
	Profile Result;
	// Read the path first, until we find a sentinel 0.
	int32_t F;
	do {
	internal_memcpy(&F, P, sizeof(int32_t));
	P += sizeof(int32_t);
	Result.Path.push_back(F);
	} while (F != 0);

	// Then read the CallCount.
	internal_memcpy(&Result.CallCount, P, sizeof(int64_t));
	P += sizeof(int64_t);

	// Then read the CumulativeLocalTime.
	internal_memcpy(&Result.CumulativeLocalTime, P, sizeof(int64_t));
	P += sizeof(int64_t);
	return std::make_tuple(std::move(Result), P);
	}

	TEST(profileCollectorServiceTest, PostSerializeCollect) {
	profilingFlags()->setDefaults();
	bool Success = false;
	BufferQueue BQ(profilingFlags()->per_thread_allocator_max,
	profilingFlags()->buffers_max, Success);
	ASSERT_EQ(Success, true);
	FunctionCallTrie::Allocators::Buffers Buffers;
	ASSERT_EQ(BQ.getBuffer(Buffers.NodeBuffer), BufferQueue::ErrorCode::Ok);
	ASSERT_EQ(BQ.getBuffer(Buffers.RootsBuffer), BufferQueue::ErrorCode::Ok);
	ASSERT_EQ(BQ.getBuffer(Buffers.ShadowStackBuffer),
	BufferQueue::ErrorCode::Ok);
	ASSERT_EQ(BQ.getBuffer(Buffers.NodeIdPairBuffer), BufferQueue::ErrorCode::Ok);
	auto Allocators = FunctionCallTrie::InitAllocatorsFromBuffers(Buffers);
	FunctionCallTrie T(Allocators);

	// Populate the trie with some data.
	T.enterFunction(1, 1, 0);
	T.enterFunction(2, 2, 0);
	T.exitFunction(2, 3, 0);
	T.exitFunction(1, 4, 0);

	// Reset the collector data structures.
	profileCollectorService::reset();

	// Then we post the data to the global profile collector service.
	profileCollectorService::post(&BQ, std::move(T), std::move(Allocators),
	std::move(Buffers), 1);

	// Then we serialize the data.
	profileCollectorService::serialize();

	// Then we go through two buffers to see whether we're getting the data we
	// expect. The first block must always be as large as a file header, which
	// will have a fixed size.
	auto B = profileCollectorService::nextBuffer({nullptr, 0});
	ValidateFileHeaderBlock(B);

	B = profileCollectorService::nextBuffer(B);
	ValidateBlock(B);
	u32 BlockSize;
	u32 BlockNum;
	u64 ThreadId;
	std::tie(BlockSize, BlockNum, ThreadId) = ParseBlockHeader(B);

	// We look at the serialized buffer to see whether the Trie we're expecting
	// to see is there.
	auto DStart = static_cast<const char *>(B.Data) + kHeaderSize;
	std::vector<char> D(DStart, DStart + BlockSize);
	B = profileCollectorService::nextBuffer(B);
	ASSERT_EQ(B.Data, nullptr);
	ASSERT_EQ(B.Size, 0u);

	Profile Profile1, Profile2;
	auto P = static_cast<const char *>(D.data());
	std::tie(Profile1, P) = ParseProfile(P);
	std::tie(Profile2, P) = ParseProfile(P);

	ASSERT_NE(Profile1.Path.size(), Profile2.Path.size());
	auto &P1 = Profile1.Path.size() < Profile2.Path.size() ? Profile2 : Profile1;
	auto &P2 = Profile1.Path.size() < Profile2.Path.size() ? Profile1 : Profile2;
	std::vector<int32_t> P1Expected = {2, 1, 0};
	std::vector<int32_t> P2Expected = {1, 0};
	ASSERT_EQ(P1.Path.size(), P1Expected.size());
	ASSERT_EQ(P2.Path.size(), P2Expected.size());
	ASSERT_EQ(P1.Path, P1Expected);
	ASSERT_EQ(P2.Path, P2Expected);
	}

	// We break out a function that will be run in multiple threads, one that will
	// use a thread local allocator, and will post the FunctionCallTrie to the
	// profileCollectorService. This simulates what the threads being profiled would
	// be doing anyway, but through the XRay logging implementation.
	void threadProcessing() {
	static bool Success = false;
	static BufferQueue BQ(profilingFlags()->per_thread_allocator_max,
	profilingFlags()->buffers_max, Success);
	thread_local FunctionCallTrie::Allocators::Buffers Buffers = [] {
	FunctionCallTrie::Allocators::Buffers B;
	BQ.getBuffer(B.NodeBuffer);
	BQ.getBuffer(B.RootsBuffer);
	BQ.getBuffer(B.ShadowStackBuffer);
	BQ.getBuffer(B.NodeIdPairBuffer);
	return B;
	}();

	thread_local auto Allocators =
	FunctionCallTrie::InitAllocatorsFromBuffers(Buffers);

	FunctionCallTrie T(Allocators);

	T.enterFunction(1, 1, 0);
	T.enterFunction(2, 2, 0);
	T.exitFunction(2, 3, 0);
	T.exitFunction(1, 4, 0);

	profileCollectorService::post(&BQ, std::move(T), std::move(Allocators),
	std::move(Buffers), GetTid());
	}

	TEST(profileCollectorServiceTest, PostSerializeCollectMultipleThread) {
	profilingFlags()->setDefaults();

	profileCollectorService::reset();

	std::thread t1(threadProcessing);
	std::thread t2(threadProcessing);

	t1.join();
	t2.join();

	// At this point, t1 and t2 are already done with what they were doing.
	profileCollectorService::serialize();

	// Ensure that we see two buffers.
	auto B = profileCollectorService::nextBuffer({nullptr, 0});
	ValidateFileHeaderBlock(B);

	B = profileCollectorService::nextBuffer(B);
	ValidateBlock(B);

	B = profileCollectorService::nextBuffer(B);
	ValidateBlock(B);
	}

	} // namespace
	} // namespace __xray