replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[PGO] Add support for reading multiple versions of indexed profile format profile data 

Profile readers using incompatible on-disk hash table format can now share the same 
implementation and interfaces. 

Differential Revision: http://reviews.llvm.org/D15100

llvm-svn: 254458
This commit is contained in:
Xinliang David Li 2015-12-01 20:26:26 +00:00
parent edf811d68f
commit a28306db0c
3 changed files with 70 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
llvm/include/llvm/ProfileData/InstrProfReader.h
View File

@ -259,36 +259,50 @@ public:
}
};
class InstrProfReaderIndex {
private:
typedef OnDiskIterableChainedHashTable<InstrProfLookupTrait> IndexType;
struct InstrProfReaderIndexBase {
// Read all the profile records with the same key pointed to the current
// iterator.
virtual std::error_code getRecords(ArrayRef<InstrProfRecord> &Data) = 0;
// Read all the profile records with the key equal to FuncName
virtual std::error_code getRecords(StringRef FuncName,
ArrayRef<InstrProfRecord> &Data) = 0;
virtual void advanceToNextKey() = 0;
virtual bool atEnd() const = 0;
virtual void setValueProfDataEndianness(support::endianness Endianness) = 0;
virtual ~InstrProfReaderIndexBase() {}
};
std::unique_ptr<IndexType> Index;
IndexType::data_iterator RecordIterator;
typedef OnDiskIterableChainedHashTable<InstrProfLookupTrait>
OnDiskHashTableImplV3;
template <typename HashTableImpl>
class InstrProfReaderIndex : public InstrProfReaderIndexBase {
private:
std::unique_ptr<HashTableImpl> HashTable;
typename HashTableImpl::data_iterator RecordIterator;
uint64_t FormatVersion;
// String table for holding a unique copy of all the strings in the profile.
InstrProfStringTable StringTable;
public:
InstrProfReaderIndex() : Index(nullptr) {}
void Init(const unsigned char *Buckets, const unsigned char *const Payload,
const unsigned char *const Base, IndexedInstrProf::HashT HashType,
uint64_t Version);
public:
InstrProfReaderIndex(const unsigned char *Buckets,
const unsigned char *const Payload,
const unsigned char *const Base,
IndexedInstrProf::HashT HashType, uint64_t Version);
// Read all the pofile records with the same key pointed to the current
// iterator.
std::error_code getRecords(ArrayRef<InstrProfRecord> &Data);
// Read all the profile records with the key equal to FuncName
std::error_code getRecords(ArrayRef<InstrProfRecord> &Data) override;
std::error_code getRecords(StringRef FuncName,
ArrayRef<InstrProfRecord> &Data);
void advanceToNextKey() { RecordIterator++; }
bool atEnd() const { return RecordIterator == Index->data_end(); }
// Used for testing purpose only.
void setValueProfDataEndianness(support::endianness Endianness) {
Index->getInfoObj().setValueProfDataEndianness(Endianness);
ArrayRef<InstrProfRecord> &Data) override;
void advanceToNextKey() override { RecordIterator++; }
bool atEnd() const override {
return RecordIterator == HashTable->data_end();
}
void setValueProfDataEndianness(support::endianness Endianness) override {
HashTable->getInfoObj().setValueProfDataEndianness(Endianness);
}
~InstrProfReaderIndex() override {}
};
/// Reader for the indexed binary instrprof format.
@ -297,16 +311,16 @@ private:
/// The profile data file contents.
std::unique_ptr<MemoryBuffer> DataBuffer;
/// The index into the profile data.
InstrProfReaderIndex Index;
std::unique_ptr<InstrProfReaderIndexBase> Index;
/// The maximal execution count among all functions.
uint64_t MaxFunctionCount;
IndexedInstrProfReader(const IndexedInstrProfReader &) = delete;
IndexedInstrProfReader &operator=(const IndexedInstrProfReader &) = delete;
public:
public:
IndexedInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer)
: DataBuffer(std::move(DataBuffer)), Index() {}
: DataBuffer(std::move(DataBuffer)), Index(nullptr) {}
/// Return true if the given buffer is in an indexed instrprof format.
static bool hasFormat(const MemoryBuffer &DataBuffer);
@ -337,7 +351,7 @@ private:
// Used for testing purpose only.
void setValueProfDataEndianness(support::endianness Endianness) {
Index.setValueProfDataEndianness(Endianness);
Index->setValueProfDataEndianness(Endianness);
}
};

7
llvm/include/llvm/Support/OnDiskHashTable.h
View File

@ -263,11 +263,12 @@ template <typename Info> class OnDiskChainedHashTable {
Info InfoObj;
public:
typedef Info InfoType;
typedef typename Info::internal_key_type internal_key_type;
typedef typename Info::external_key_type external_key_type;
typedef typename Info::data_type data_type;
typedef typename Info::hash_value_type hash_value_type;
typedef typename Info::offset_type offset_type;
typedef typename Info::data_type data_type;
typedef typename Info::hash_value_type hash_value_type;
typedef typename Info::offset_type offset_type;
OnDiskChainedHashTable(offset_type NumBuckets, offset_type NumEntries,
const unsigned char *Buckets,

49
llvm/lib/ProfileData/InstrProfReader.cpp
View File

@ -441,11 +441,11 @@ data_type InstrProfLookupTrait::ReadData(StringRef K, const unsigned char *D,
return DataBuffer;
}
std::error_code
InstrProfReaderIndex::getRecords(StringRef FuncName,
ArrayRef<InstrProfRecord> &Data) {
auto Iter = Index->find(FuncName);
if (Iter == Index->end())
template <typename HashTableImpl>
std::error_code InstrProfReaderIndex<HashTableImpl>::getRecords(
StringRef FuncName, ArrayRef<InstrProfRecord> &Data) {
auto Iter = HashTable->find(FuncName);
if (Iter == HashTable->end())
return instrprof_error::unknown_function;
Data = (*Iter);
@ -455,9 +455,11 @@ InstrProfReaderIndex::getRecords(StringRef FuncName,
return instrprof_error::success;
}
std::error_code InstrProfReaderIndex::getRecords(
template <typename HashTableImpl>
std::error_code InstrProfReaderIndex<HashTableImpl>::getRecords(
ArrayRef<InstrProfRecord> &Data) {
if (atEnd()) return instrprof_error::eof;
if (atEnd())
return instrprof_error::eof;
Data = *RecordIterator;
@ -466,25 +468,26 @@ std::error_code InstrProfReaderIndex::getRecords(
return instrprof_error::success;
}
void InstrProfReaderIndex::Init(const unsigned char *Buckets,
const unsigned char *const Payload,
const unsigned char *const Base,
IndexedInstrProf::HashT HashType,
uint64_t Version) {
template <typename HashTableImpl>
InstrProfReaderIndex<HashTableImpl>::InstrProfReaderIndex(
const unsigned char *Buckets, const unsigned char *const Payload,
const unsigned char *const Base, IndexedInstrProf::HashT HashType,
uint64_t Version) {
FormatVersion = Version;
Index.reset(IndexType::Create(Buckets, Payload, Base,
InstrProfLookupTrait(HashType, Version)));
HashTable.reset(HashTableImpl::Create(
Buckets, Payload, Base,
typename HashTableImpl::InfoType(HashType, Version)));
// Form the map of hash values to const char* keys in profiling data.
std::vector<std::pair<uint64_t, const char *>> HashKeys;
for (auto Key : Index->keys()) {
for (auto Key : HashTable->keys()) {
const char *KeyTableRef = StringTable.insertString(Key);
HashKeys.push_back(std::make_pair(ComputeHash(HashType, Key), KeyTableRef));
}
std::sort(HashKeys.begin(), HashKeys.end(), less_first());
HashKeys.erase(std::unique(HashKeys.begin(), HashKeys.end()), HashKeys.end());
// Set the hash key map for the InstrLookupTrait
Index->getInfoObj().setHashKeys(std::move(HashKeys));
RecordIterator = Index->data_begin();
HashTable->getInfoObj().setHashKeys(std::move(HashKeys));
RecordIterator = HashTable->data_begin();
}
bool IndexedInstrProfReader::hasFormat(const MemoryBuffer &DataBuffer) {
@ -532,8 +535,10 @@ std::error_code IndexedInstrProfReader::readHeader() {
uint64_t HashOffset = endian::byte_swap<uint64_t, little>(Header->HashOffset);
// The rest of the file is an on disk hash table.
Index.Init(Start + HashOffset, Cur, Start, HashType, FormatVersion);
InstrProfReaderIndexBase *IndexPtr = nullptr;
IndexPtr = new InstrProfReaderIndex<OnDiskHashTableImplV3>(
Start + HashOffset, Cur, Start, HashType, FormatVersion);
Index.reset(IndexPtr);
return success();
}
@ -541,7 +546,7 @@ ErrorOr<InstrProfRecord>
IndexedInstrProfReader::getInstrProfRecord(StringRef FuncName,
uint64_t FuncHash) {
ArrayRef<InstrProfRecord> Data;
std::error_code EC = Index.getRecords(FuncName, Data);
std::error_code EC = Index->getRecords(FuncName, Data);
if (EC != instrprof_error::success)
return EC;
// Found it. Look for counters with the right hash.
@ -571,13 +576,13 @@ std::error_code IndexedInstrProfReader::readNextRecord(
ArrayRef<InstrProfRecord> Data;
std::error_code EC = Index.getRecords(Data);
std::error_code EC = Index->getRecords(Data);
if (EC != instrprof_error::success)
return error(EC);
Record = Data[RecordIndex++];
if (RecordIndex >= Data.size()) {
Index.advanceToNextKey();
Index->advanceToNextKey();
RecordIndex = 0;
}
return success();