mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2025-01-23 01:20:03 +00:00
2946cd7010
to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
299 lines
11 KiB
C++
299 lines
11 KiB
C++
//===------ PerfMonitor.cpp - Generate a run-time performance monitor. -======//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "polly/CodeGen/PerfMonitor.h"
|
|
#include "polly/CodeGen/RuntimeDebugBuilder.h"
|
|
#include "polly/ScopInfo.h"
|
|
#include "llvm/ADT/Triple.h"
|
|
#include "llvm/IR/Intrinsics.h"
|
|
#include <sstream>
|
|
|
|
using namespace llvm;
|
|
using namespace polly;
|
|
|
|
Function *PerfMonitor::getAtExit() {
|
|
const char *Name = "atexit";
|
|
Function *F = M->getFunction(Name);
|
|
|
|
if (!F) {
|
|
GlobalValue::LinkageTypes Linkage = Function::ExternalLinkage;
|
|
FunctionType *Ty = FunctionType::get(Builder.getInt32Ty(),
|
|
{Builder.getInt8PtrTy()}, false);
|
|
F = Function::Create(Ty, Linkage, Name, M);
|
|
}
|
|
|
|
return F;
|
|
}
|
|
|
|
void PerfMonitor::addToGlobalConstructors(Function *Fn) {
|
|
const char *Name = "llvm.global_ctors";
|
|
GlobalVariable *GV = M->getGlobalVariable(Name);
|
|
std::vector<Constant *> V;
|
|
|
|
if (GV) {
|
|
Constant *Array = GV->getInitializer();
|
|
for (Value *X : Array->operand_values())
|
|
V.push_back(cast<Constant>(X));
|
|
GV->eraseFromParent();
|
|
}
|
|
|
|
StructType *ST = StructType::get(Builder.getInt32Ty(), Fn->getType(),
|
|
Builder.getInt8PtrTy());
|
|
|
|
V.push_back(
|
|
ConstantStruct::get(ST, Builder.getInt32(10), Fn,
|
|
ConstantPointerNull::get(Builder.getInt8PtrTy())));
|
|
ArrayType *Ty = ArrayType::get(ST, V.size());
|
|
|
|
GV = new GlobalVariable(*M, Ty, true, GlobalValue::AppendingLinkage,
|
|
ConstantArray::get(Ty, V), Name, nullptr,
|
|
GlobalVariable::NotThreadLocal);
|
|
}
|
|
|
|
Function *PerfMonitor::getRDTSCP() {
|
|
return Intrinsic::getDeclaration(M, Intrinsic::x86_rdtscp);
|
|
}
|
|
|
|
PerfMonitor::PerfMonitor(const Scop &S, Module *M)
|
|
: M(M), Builder(M->getContext()), S(S) {
|
|
if (Triple(M->getTargetTriple()).getArch() == llvm::Triple::x86_64)
|
|
Supported = true;
|
|
else
|
|
Supported = false;
|
|
}
|
|
|
|
static void TryRegisterGlobal(Module *M, const char *Name,
|
|
Constant *InitialValue, Value **Location) {
|
|
*Location = M->getGlobalVariable(Name);
|
|
|
|
if (!*Location)
|
|
*Location = new GlobalVariable(
|
|
*M, InitialValue->getType(), true, GlobalValue::WeakAnyLinkage,
|
|
InitialValue, Name, nullptr, GlobalVariable::InitialExecTLSModel);
|
|
}
|
|
|
|
// Generate a unique name that is usable as a LLVM name for a scop to name its
|
|
// performance counter.
|
|
static std::string GetScopUniqueVarname(const Scop &S) {
|
|
std::stringstream Name;
|
|
std::string EntryString, ExitString;
|
|
std::tie(EntryString, ExitString) = S.getEntryExitStr();
|
|
|
|
Name << "__polly_perf_in_" << std::string(S.getFunction().getName())
|
|
<< "_from__" << EntryString << "__to__" << ExitString;
|
|
return Name.str();
|
|
}
|
|
|
|
void PerfMonitor::addScopCounter() {
|
|
const std::string varname = GetScopUniqueVarname(S);
|
|
TryRegisterGlobal(M, (varname + "_cycles").c_str(), Builder.getInt64(0),
|
|
&CyclesInCurrentScopPtr);
|
|
|
|
TryRegisterGlobal(M, (varname + "_trip_count").c_str(), Builder.getInt64(0),
|
|
&TripCountForCurrentScopPtr);
|
|
}
|
|
|
|
void PerfMonitor::addGlobalVariables() {
|
|
TryRegisterGlobal(M, "__polly_perf_cycles_total_start", Builder.getInt64(0),
|
|
&CyclesTotalStartPtr);
|
|
|
|
TryRegisterGlobal(M, "__polly_perf_initialized", Builder.getInt1(0),
|
|
&AlreadyInitializedPtr);
|
|
|
|
TryRegisterGlobal(M, "__polly_perf_cycles_in_scops", Builder.getInt64(0),
|
|
&CyclesInScopsPtr);
|
|
|
|
TryRegisterGlobal(M, "__polly_perf_cycles_in_scop_start", Builder.getInt64(0),
|
|
&CyclesInScopStartPtr);
|
|
}
|
|
|
|
static const char *InitFunctionName = "__polly_perf_init";
|
|
static const char *FinalReportingFunctionName = "__polly_perf_final";
|
|
|
|
static BasicBlock *FinalStartBB = nullptr;
|
|
static ReturnInst *ReturnFromFinal = nullptr;
|
|
|
|
Function *PerfMonitor::insertFinalReporting() {
|
|
// Create new function.
|
|
GlobalValue::LinkageTypes Linkage = Function::WeakODRLinkage;
|
|
FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), {}, false);
|
|
Function *ExitFn =
|
|
Function::Create(Ty, Linkage, FinalReportingFunctionName, M);
|
|
FinalStartBB = BasicBlock::Create(M->getContext(), "start", ExitFn);
|
|
Builder.SetInsertPoint(FinalStartBB);
|
|
|
|
if (!Supported) {
|
|
RuntimeDebugBuilder::createCPUPrinter(
|
|
Builder, "Polly runtime information generation not supported\n");
|
|
Builder.CreateRetVoid();
|
|
return ExitFn;
|
|
}
|
|
|
|
// Measure current cycles and compute final timings.
|
|
Function *RDTSCPFn = getRDTSCP();
|
|
|
|
Value *CurrentCycles =
|
|
Builder.CreateExtractValue(Builder.CreateCall(RDTSCPFn), {0});
|
|
Value *CyclesStart = Builder.CreateLoad(CyclesTotalStartPtr, true);
|
|
Value *CyclesTotal = Builder.CreateSub(CurrentCycles, CyclesStart);
|
|
Value *CyclesInScops = Builder.CreateLoad(CyclesInScopsPtr, true);
|
|
|
|
// Print the runtime information.
|
|
RuntimeDebugBuilder::createCPUPrinter(Builder, "Polly runtime information\n");
|
|
RuntimeDebugBuilder::createCPUPrinter(Builder, "-------------------------\n");
|
|
RuntimeDebugBuilder::createCPUPrinter(Builder, "Total: ", CyclesTotal, "\n");
|
|
RuntimeDebugBuilder::createCPUPrinter(Builder, "Scops: ", CyclesInScops,
|
|
"\n");
|
|
|
|
// Print the preamble for per-scop information.
|
|
RuntimeDebugBuilder::createCPUPrinter(Builder, "\n");
|
|
RuntimeDebugBuilder::createCPUPrinter(Builder, "Per SCoP information\n");
|
|
RuntimeDebugBuilder::createCPUPrinter(Builder, "--------------------\n");
|
|
|
|
RuntimeDebugBuilder::createCPUPrinter(
|
|
Builder, "scop function, "
|
|
"entry block name, exit block name, total time, trip count\n");
|
|
ReturnFromFinal = Builder.CreateRetVoid();
|
|
return ExitFn;
|
|
}
|
|
|
|
void PerfMonitor::AppendScopReporting() {
|
|
if (!Supported)
|
|
return;
|
|
|
|
assert(FinalStartBB && "Expected FinalStartBB to be initialized by "
|
|
"PerfMonitor::insertFinalReporting.");
|
|
assert(ReturnFromFinal && "Expected ReturnFromFinal to be initialized by "
|
|
"PerfMonitor::insertFinalReporting.");
|
|
|
|
Builder.SetInsertPoint(FinalStartBB);
|
|
ReturnFromFinal->eraseFromParent();
|
|
|
|
Value *CyclesInCurrentScop =
|
|
Builder.CreateLoad(this->CyclesInCurrentScopPtr, true);
|
|
|
|
Value *TripCountForCurrentScop =
|
|
Builder.CreateLoad(this->TripCountForCurrentScopPtr, true);
|
|
|
|
std::string EntryName, ExitName;
|
|
std::tie(EntryName, ExitName) = S.getEntryExitStr();
|
|
|
|
// print in CSV for easy parsing with other tools.
|
|
RuntimeDebugBuilder::createCPUPrinter(
|
|
Builder, S.getFunction().getName(), ", ", EntryName, ", ", ExitName, ", ",
|
|
CyclesInCurrentScop, ", ", TripCountForCurrentScop, "\n");
|
|
|
|
ReturnFromFinal = Builder.CreateRetVoid();
|
|
}
|
|
|
|
static Function *FinalReporting = nullptr;
|
|
|
|
void PerfMonitor::initialize() {
|
|
addGlobalVariables();
|
|
addScopCounter();
|
|
|
|
// Ensure that we only add the final reporting function once.
|
|
// On later invocations, append to the reporting function.
|
|
if (!FinalReporting) {
|
|
FinalReporting = insertFinalReporting();
|
|
|
|
Function *InitFn = insertInitFunction(FinalReporting);
|
|
addToGlobalConstructors(InitFn);
|
|
}
|
|
|
|
AppendScopReporting();
|
|
}
|
|
|
|
Function *PerfMonitor::insertInitFunction(Function *FinalReporting) {
|
|
// Insert function definition and BBs.
|
|
GlobalValue::LinkageTypes Linkage = Function::WeakODRLinkage;
|
|
FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), {}, false);
|
|
Function *InitFn = Function::Create(Ty, Linkage, InitFunctionName, M);
|
|
BasicBlock *Start = BasicBlock::Create(M->getContext(), "start", InitFn);
|
|
BasicBlock *EarlyReturn =
|
|
BasicBlock::Create(M->getContext(), "earlyreturn", InitFn);
|
|
BasicBlock *InitBB = BasicBlock::Create(M->getContext(), "initbb", InitFn);
|
|
|
|
Builder.SetInsertPoint(Start);
|
|
|
|
// Check if this function was already run. If yes, return.
|
|
//
|
|
// In case profiling has been enabled in multiple translation units, the
|
|
// initializer function will be added to the global constructors list of
|
|
// each translation unit. When merging translation units, the global
|
|
// constructor lists are just appended, such that the initializer will appear
|
|
// multiple times. To avoid initializations being run multiple times (and
|
|
// especially to avoid that atExitFn is called more than once), we bail
|
|
// out if the initializer is run more than once.
|
|
Value *HasRunBefore = Builder.CreateLoad(AlreadyInitializedPtr);
|
|
Builder.CreateCondBr(HasRunBefore, EarlyReturn, InitBB);
|
|
Builder.SetInsertPoint(EarlyReturn);
|
|
Builder.CreateRetVoid();
|
|
|
|
// Keep track that this function has been run once.
|
|
Builder.SetInsertPoint(InitBB);
|
|
Value *True = Builder.getInt1(true);
|
|
Builder.CreateStore(True, AlreadyInitializedPtr);
|
|
|
|
// Register the final reporting function with atexit().
|
|
Value *FinalReportingPtr =
|
|
Builder.CreatePointerCast(FinalReporting, Builder.getInt8PtrTy());
|
|
Function *AtExitFn = getAtExit();
|
|
Builder.CreateCall(AtExitFn, {FinalReportingPtr});
|
|
|
|
if (Supported) {
|
|
// Read the currently cycle counter and store the result for later.
|
|
Function *RDTSCPFn = getRDTSCP();
|
|
Value *CurrentCycles =
|
|
Builder.CreateExtractValue(Builder.CreateCall(RDTSCPFn), {0});
|
|
Builder.CreateStore(CurrentCycles, CyclesTotalStartPtr, true);
|
|
}
|
|
Builder.CreateRetVoid();
|
|
|
|
return InitFn;
|
|
}
|
|
|
|
void PerfMonitor::insertRegionStart(Instruction *InsertBefore) {
|
|
if (!Supported)
|
|
return;
|
|
|
|
Builder.SetInsertPoint(InsertBefore);
|
|
Function *RDTSCPFn = getRDTSCP();
|
|
Value *CurrentCycles =
|
|
Builder.CreateExtractValue(Builder.CreateCall(RDTSCPFn), {0});
|
|
Builder.CreateStore(CurrentCycles, CyclesInScopStartPtr, true);
|
|
}
|
|
|
|
void PerfMonitor::insertRegionEnd(Instruction *InsertBefore) {
|
|
if (!Supported)
|
|
return;
|
|
|
|
Builder.SetInsertPoint(InsertBefore);
|
|
Function *RDTSCPFn = getRDTSCP();
|
|
LoadInst *CyclesStart = Builder.CreateLoad(CyclesInScopStartPtr, true);
|
|
Value *CurrentCycles =
|
|
Builder.CreateExtractValue(Builder.CreateCall(RDTSCPFn), {0});
|
|
Value *CyclesInScop = Builder.CreateSub(CurrentCycles, CyclesStart);
|
|
Value *CyclesInScops = Builder.CreateLoad(CyclesInScopsPtr, true);
|
|
CyclesInScops = Builder.CreateAdd(CyclesInScops, CyclesInScop);
|
|
Builder.CreateStore(CyclesInScops, CyclesInScopsPtr, true);
|
|
|
|
Value *CyclesInCurrentScop = Builder.CreateLoad(CyclesInCurrentScopPtr, true);
|
|
CyclesInCurrentScop = Builder.CreateAdd(CyclesInCurrentScop, CyclesInScop);
|
|
Builder.CreateStore(CyclesInCurrentScop, CyclesInCurrentScopPtr, true);
|
|
|
|
Value *TripCountForCurrentScop =
|
|
Builder.CreateLoad(TripCountForCurrentScopPtr, true);
|
|
TripCountForCurrentScop =
|
|
Builder.CreateAdd(TripCountForCurrentScop, Builder.getInt64(1));
|
|
Builder.CreateStore(TripCountForCurrentScop, TripCountForCurrentScopPtr,
|
|
true);
|
|
}
|