SampleProfWriter.cpp | Explore in Territory

//===- SampleProfWriter.cpp - Write LLVM sample profile data --------------===//
//
// 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 implements the class that writes LLVM sample profiles. It
// supports two file formats: text and binary. The textual representation
// is useful for debugging and testing purposes. The binary representation
// is more compact, resulting in smaller file sizes. However, they can
// both be used interchangeably.
//
// See lib/ProfileData/SampleProfReader.cpp for documentation on each of the
// supported formats.
//
//===----------------------------------------------------------------------===//

#include "llvm/ProfileData/SampleProfWriter.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ProfileData/ProfileCommon.h"
#include "llvm/ProfileData/SampleProf.h"
#include "llvm/Support/Compression.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/EndianStream.h"
#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/LEB128.h"
#include "llvm/Support/MD5.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <memory>
#include <set>
#include <system_error>
#include <utility>
#include <vector>

#define DEBUG_TYPE …

usingnamespacellvm;
usingnamespacesampleprof;

namespace llvm {
namespace support {
namespace endian {
namespace {

// Adapter class to llvm::support::endian::Writer for pwrite().
struct SeekableWriter { … };

} // namespace
} // namespace endian
} // namespace support
} // namespace llvm

DefaultFunctionPruningStrategy::DefaultFunctionPruningStrategy(
    SampleProfileMap &ProfileMap, size_t OutputSizeLimit)
    : … { … }

void DefaultFunctionPruningStrategy::Erase(size_t CurrentOutputSize) { … }

std::error_code SampleProfileWriter::writeWithSizeLimitInternal(
    SampleProfileMap &ProfileMap, size_t OutputSizeLimit,
    FunctionPruningStrategy *Strategy) { … }

std::error_code
SampleProfileWriter::writeFuncProfiles(const SampleProfileMap &ProfileMap) { … }

std::error_code SampleProfileWriter::write(const SampleProfileMap &ProfileMap) { … }

/// Return the current position and prepare to use it as the start
/// position of a section given the section type \p Type and its position
/// \p LayoutIdx in SectionHdrLayout.
uint64_t
SampleProfileWriterExtBinaryBase::markSectionStart(SecType Type,
                                                   uint32_t LayoutIdx) { … }

std::error_code SampleProfileWriterExtBinaryBase::compressAndOutput() { … }

/// Add a new section into section header table given the section type
/// \p Type, its position \p LayoutIdx in SectionHdrLayout and the
/// location \p SectionStart where the section should be written to.
std::error_code SampleProfileWriterExtBinaryBase::addNewSection(
    SecType Type, uint32_t LayoutIdx, uint64_t SectionStart) { … }

std::error_code
SampleProfileWriterExtBinaryBase::write(const SampleProfileMap &ProfileMap) { … }

std::error_code SampleProfileWriterExtBinaryBase::writeContextIdx(
    const SampleContext &Context) { … }

std::error_code
SampleProfileWriterExtBinaryBase::writeCSNameIdx(const SampleContext &Context) { … }

std::error_code
SampleProfileWriterExtBinaryBase::writeSample(const FunctionSamples &S) { … }

std::error_code SampleProfileWriterExtBinaryBase::writeFuncOffsetTable() { … }

std::error_code SampleProfileWriterExtBinaryBase::writeFuncMetadata(
    const FunctionSamples &FunctionProfile) { … }

std::error_code SampleProfileWriterExtBinaryBase::writeFuncMetadata(
    const SampleProfileMap &Profiles) { … }

std::error_code SampleProfileWriterExtBinaryBase::writeNameTable() { … }

std::error_code SampleProfileWriterExtBinaryBase::writeNameTableSection(
    const SampleProfileMap &ProfileMap) { … }

std::error_code SampleProfileWriterExtBinaryBase::writeCSNameTableSection() { … }

std::error_code
SampleProfileWriterExtBinaryBase::writeProfileSymbolListSection() { … }

std::error_code SampleProfileWriterExtBinaryBase::writeOneSection(
    SecType Type, uint32_t LayoutIdx, const SampleProfileMap &ProfileMap) { … }

std::error_code SampleProfileWriterExtBinary::writeDefaultLayout(
    const SampleProfileMap &ProfileMap) { … }

static void splitProfileMapToTwo(const SampleProfileMap &ProfileMap,
                                 SampleProfileMap &ContextProfileMap,
                                 SampleProfileMap &NoContextProfileMap) { … }

std::error_code SampleProfileWriterExtBinary::writeCtxSplitLayout(
    const SampleProfileMap &ProfileMap) { … }

std::error_code SampleProfileWriterExtBinary::writeSections(
    const SampleProfileMap &ProfileMap) { … }

/// Write samples to a text file.
///
/// Note: it may be tempting to implement this in terms of
/// FunctionSamples::print().  Please don't.  The dump functionality is intended
/// for debugging and has no specified form.
///
/// The format used here is more structured and deliberate because
/// it needs to be parsed by the SampleProfileReaderText class.
std::error_code SampleProfileWriterText::writeSample(const FunctionSamples &S) { … }

std::error_code
SampleProfileWriterBinary::writeContextIdx(const SampleContext &Context) { … }

std::error_code SampleProfileWriterBinary::writeNameIdx(FunctionId FName) { … }

void SampleProfileWriterBinary::addName(FunctionId FName) { … }

void SampleProfileWriterBinary::addContext(const SampleContext &Context) { … }

void SampleProfileWriterBinary::addNames(const FunctionSamples &S) { … }

void SampleProfileWriterExtBinaryBase::addContext(
    const SampleContext &Context) { … }

void SampleProfileWriterBinary::stablizeNameTable(
    MapVector<FunctionId, uint32_t> &NameTable, std::set<FunctionId> &V) { … }

std::error_code SampleProfileWriterBinary::writeNameTable() { … }

std::error_code
SampleProfileWriterBinary::writeMagicIdent(SampleProfileFormat Format) { … }

std::error_code
SampleProfileWriterBinary::writeHeader(const SampleProfileMap &ProfileMap) { … }

void SampleProfileWriterExtBinaryBase::setToCompressAllSections() { … }

void SampleProfileWriterExtBinaryBase::setToCompressSection(SecType Type) { … }

void SampleProfileWriterExtBinaryBase::allocSecHdrTable() { … }

std::error_code SampleProfileWriterExtBinaryBase::writeSecHdrTable() { … }

std::error_code SampleProfileWriterExtBinaryBase::writeHeader(
    const SampleProfileMap &ProfileMap) { … }

std::error_code SampleProfileWriterBinary::writeSummary() { … }
std::error_code SampleProfileWriterBinary::writeBody(const FunctionSamples &S) { … }

/// Write samples of a top-level function to a binary file.
///
/// \returns true if the samples were written successfully, false otherwise.
std::error_code
SampleProfileWriterBinary::writeSample(const FunctionSamples &S) { … }

/// Create a sample profile file writer based on the specified format.
///
/// \param Filename The file to create.
///
/// \param Format Encoding format for the profile file.
///
/// \returns an error code indicating the status of the created writer.
ErrorOr<std::unique_ptr<SampleProfileWriter>>
SampleProfileWriter::create(StringRef Filename, SampleProfileFormat Format) { … }

/// Create a sample profile stream writer based on the specified format.
///
/// \param OS The output stream to store the profile data to.
///
/// \param Format Encoding format for the profile file.
///
/// \returns an error code indicating the status of the created writer.
ErrorOr<std::unique_ptr<SampleProfileWriter>>
SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS,
                            SampleProfileFormat Format) { … }

void SampleProfileWriter::computeSummary(const SampleProfileMap &ProfileMap) { … }
llvm/llvm/lib/ProfileData/SampleProfWriter.cpp
