6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-20 10:24:12 +00:00
Code Issues Projects Releases Wiki Activity

InstrProf: When reading, copy the data instead of taking a reference. NFC

Browse Source 
This consolidates the logic to read instrprof records into the on disk
hash table's lookup trait and makes us copy the counter data instead
of taking references to it as we read. This will simplify further
changes to the format.

Patch by Betul Buyukkurt.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@240206 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Justin Bogner
2015-06-20 01:26:04 +00:00
parent cdc126d293
commit 9edccc8b40
3 changed files with 88 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
include/llvm/ProfileData/InstrProf.h
View File

@ -16,7 +16,9 @@
#ifndef LLVM_PROFILEDATA_INSTRPROF_H_
#define LLVM_PROFILEDATA_INSTRPROF_H_
#include "llvm/ADT/StringRef.h"
#include <system_error>
#include <vector>
namespace llvm {
const std::error_category &instrprof_category();
@ -41,6 +43,16 @@ inline std::error_code make_error_code(instrprof_error E) {
return std::error_code(static_cast<int>(E), instrprof_category());
}
/// Profiling information for a single function.
struct InstrProfRecord {
InstrProfRecord() {}
InstrProfRecord(StringRef Name, uint64_t Hash, std::vector<uint64_t> &Counts)
: Name(Name), Hash(Hash), Counts(std::move(Counts)) {}
StringRef Name;
uint64_t Hash;
std::vector<uint64_t> Counts;
};
} // end namespace llvm
namespace std {

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

@ -29,16 +29,6 @@ namespace llvm {
class InstrProfReader;
/// Profiling information for a single function.
struct InstrProfRecord {
InstrProfRecord() {}
InstrProfRecord(StringRef Name, uint64_t Hash, ArrayRef<uint64_t> Counts)
: Name(Name), Hash(Hash), Counts(Counts) {}
StringRef Name;
uint64_t Hash;
ArrayRef<uint64_t> Counts;
};
/// A file format agnostic iterator over profiling data.
class InstrProfIterator : public std::iterator<std::input_iterator_tag,
InstrProfRecord> {
@ -114,8 +104,6 @@ private:
std::unique_ptr<MemoryBuffer> DataBuffer;
/// Iterator over the profile data.
line_iterator Line;
/// The current set of counter values.
std::vector<uint64_t> Counts;
TextInstrProfReader(const TextInstrProfReader &) = delete;
TextInstrProfReader &operator=(const TextInstrProfReader &) = delete;
@ -141,8 +129,6 @@ class RawInstrProfReader : public InstrProfReader {
private:
/// The profile data file contents.
std::unique_ptr<MemoryBuffer> DataBuffer;
/// The current set of counter values.
std::vector<uint64_t> Counts;
struct ProfileData {
const uint32_t NameSize;
const uint32_t NumCounters;
@ -206,17 +192,16 @@ enum class HashT : uint32_t;
/// Trait for lookups into the on-disk hash table for the binary instrprof
/// format.
class InstrProfLookupTrait {
std::vector<uint64_t> DataBuffer;
std::vector<InstrProfRecord> DataBuffer;
IndexedInstrProf::HashT HashType;
public:
InstrProfLookupTrait(IndexedInstrProf::HashT HashType) : HashType(HashType) {}
unsigned FormatVersion;
public:
InstrProfLookupTrait(IndexedInstrProf::HashT HashType, unsigned FormatVersion)
: HashType(HashType), FormatVersion(FormatVersion) {}
typedef ArrayRef<InstrProfRecord> data_type;
struct data_type {
data_type(StringRef Name, ArrayRef<uint64_t> Data)
: Name(Name), Data(Data) {}
StringRef Name;
ArrayRef<uint64_t> Data;
};
typedef StringRef internal_key_type;
typedef StringRef external_key_type;
typedef uint64_t hash_value_type;
@ -239,22 +224,9 @@ public:
return StringRef((const char *)D, N);
}
data_type ReadData(StringRef K, const unsigned char *D, offset_type N) {
DataBuffer.clear();
if (N % sizeof(uint64_t))
// The data is corrupt, don't try to read it.
return data_type("", DataBuffer);
using namespace support;
// We just treat the data as opaque here. It's simpler to handle in
// IndexedInstrProfReader.
unsigned NumEntries = N / sizeof(uint64_t);
DataBuffer.reserve(NumEntries);
for (unsigned I = 0; I < NumEntries; ++I)
DataBuffer.push_back(endian::readNext<uint64_t, little, unaligned>(D));
return data_type(K, DataBuffer);
}
data_type ReadData(StringRef K, const unsigned char *D, offset_type N);
};
typedef OnDiskIterableChainedHashTable<InstrProfLookupTrait>
InstrProfReaderIndex;
@ -267,8 +239,6 @@ private:
std::unique_ptr<InstrProfReaderIndex> Index;
/// Iterator over the profile data.
InstrProfReaderIndex::data_iterator RecordIterator;
/// Offset into our current data set.
size_t CurrentOffset;
/// The file format version of the profile data.
uint64_t FormatVersion;
/// The maximal execution count among all functions.
@ -278,7 +248,7 @@ private:
IndexedInstrProfReader &operator=(const IndexedInstrProfReader &) = delete;
public:
IndexedInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer)
: DataBuffer(std::move(DataBuffer)), Index(nullptr), CurrentOffset(0) {}
: DataBuffer(std::move(DataBuffer)), Index(nullptr) {}
/// Return true if the given buffer is in an indexed instrprof format.
static bool hasFormat(const MemoryBuffer &DataBuffer);