mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-11-21 14:56:53 +00:00
Reverts carbon-language/carbon-lang#8001 This depended on 3 unmerged PRs.
411 lines
18 KiB
C++
411 lines
18 KiB
C++
// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
|
|
// Exceptions. See /LICENSE for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
|
#ifndef CARBON_TOOLCHAIN_BENCHMARKING_SOURCE_GEN_H_
|
|
#define CARBON_TOOLCHAIN_BENCHMARKING_SOURCE_GEN_H_
|
|
|
|
#include <string>
|
|
|
|
#include "absl/random/random.h"
|
|
#include "common/map.h"
|
|
#include "common/set.h"
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/Support/Allocator.h"
|
|
|
|
namespace Carbon::Testing {
|
|
|
|
// Provides source code generation facilities.
|
|
//
|
|
// This class works to generate valid but random & meaningless source code in
|
|
// interesting patterns for benchmarking. It is very incomplete. A high level
|
|
// set of long-term goals:
|
|
//
|
|
// - Generate interesting patterns and structures of code that have emerged as
|
|
// toolchain performance bottlenecks in practice in C++ codebases.
|
|
// - Generate code that includes most Carbon language features (and whatever
|
|
// reasonable C++ analogs could be used for comparative purposes):
|
|
// - Functions
|
|
// - Classes with class functions, methods, and fields
|
|
// - Interfaces
|
|
// - Checked generics and templates
|
|
// - Nested and unnested impls
|
|
// - Nested classes
|
|
// - Inline and out-of-line function and method definitions
|
|
// - Imports and exports
|
|
// - API files and impl files.
|
|
// - Be random but deterministic. The goal is benchmarking and so while this
|
|
// code should strive for not producing trivially predictable patterns, it
|
|
// should also strive to be consistent and suitable for benchmarking. Wherever
|
|
// possible, it should permute the order and content without randomizing the
|
|
// total count, size, or complexity.
|
|
//
|
|
// Note that the default and primary generation target is interesting Carbon
|
|
// source code. We have a best-effort to alternatively generate comparable C++
|
|
// constructs to the Carbon ones for comparative benchmarking, but there is no
|
|
// goal to cover all the interesting C++ patterns we might want to benchmark,
|
|
// and we don't aim for perfectly synthesizing C++ analogs. We can always drop
|
|
// fidelity for the C++ code path if needed for simplicity.
|
|
//
|
|
// TODO: There are numerous places where we hard code a fixed quantity. Instead,
|
|
// we should build a rich but general system to easily encode a discrete
|
|
// distribution that is sampled. We have a specialized version of this for
|
|
// identifiers that should be generalized.
|
|
class SourceGen {
|
|
public:
|
|
enum class Language : uint8_t {
|
|
Carbon,
|
|
Cpp,
|
|
};
|
|
|
|
struct FunctionDeclParams {
|
|
// TODD: Arbitrary default, should switch to a distribution from data.
|
|
int max_params = 4;
|
|
};
|
|
|
|
struct MethodDeclParams {
|
|
// TODD: Arbitrary default, should switch to a distribution from data.
|
|
int max_params = 4;
|
|
};
|
|
|
|
// Parameters used to generate a class in a generated file.
|
|
//
|
|
// Currently, this uses a fixed number of each kind of declaration, with
|
|
// arbitrary defaults chosen. The defaults currently skew towards large
|
|
// classes with lots of nested declarations.
|
|
// TODO: Switch these to distributions based on data.
|
|
//
|
|
// TODO: Add heuristic for how many functions have return types.
|
|
struct ClassParams {
|
|
int public_function_decls = 4;
|
|
FunctionDeclParams public_function_decl_params = {.max_params = 8};
|
|
|
|
int public_method_decls = 10;
|
|
MethodDeclParams public_method_decl_params;
|
|
|
|
int private_function_decls = 2;
|
|
FunctionDeclParams private_function_decl_params = {.max_params = 6};
|
|
|
|
int private_method_decls = 8;
|
|
MethodDeclParams private_method_decl_params = {.max_params = 6};
|
|
|
|
int private_field_decls = 6;
|
|
|
|
// The number of public class functions to define inline, with a body that
|
|
// computes over its parameters.
|
|
int inline_function_defs = 0;
|
|
FunctionDeclParams inline_function_decl_params = {.max_params = 4};
|
|
|
|
// The maximum number of local variables in each computation. The counts are
|
|
// evenly distributed over `[0, max_body_locals]`.
|
|
int max_body_locals = 4;
|
|
|
|
// The number of public methods to define inline that return a field. Each
|
|
// one returns a field of its own, in addition to `private_field_decls`.
|
|
int inline_getters = 0;
|
|
|
|
// The number of public methods to define inline that test a field with the
|
|
// field type's predicate template. Each one tests a field of its own.
|
|
int inline_predicates = 0;
|
|
|
|
// The number of public methods to define inline that pass their parameters
|
|
// on to a private method declaration with the same signature.
|
|
int inline_forwarders = 0;
|
|
MethodDeclParams inline_forwarder_params = {.max_params = 4};
|
|
};
|
|
|
|
// Parameters used to select type _uses_, as opposed to definitions.
|
|
//
|
|
// These govern what distribution of types are used for function parameters,
|
|
// returns, and fields.
|
|
//
|
|
// Mainly these provide a coarse histogram of weights to shape the
|
|
// distribution of different type options, and try to fit that as closely as
|
|
// possible.
|
|
//
|
|
// The default weights in the histogram were arbitrarily selected based on
|
|
// intuition about importance for benchmarking and not based on any
|
|
// measurement. We arrange for them to sum to 100 so that the weights can be
|
|
// view as %s of the type uses.
|
|
//
|
|
// The specific builtin type options used in the weights were also selected
|
|
// arbitrarily.
|
|
//
|
|
// TODO: Improve the set of builtin types and the weighting if real world code
|
|
// ends up sharply different.
|
|
//
|
|
// TODO: Add a heuristic to make some % of type references via pointers (or
|
|
// other compound types).
|
|
struct TypeUseParams {
|
|
// The weights in the histogram start with a sequence fixed types described
|
|
// with a Carbon and C++ string, and their associated weight.
|
|
//
|
|
// Each type also has a value expression, which a body uses to produce a
|
|
// value of the type, such as a return value. Types without one, like
|
|
// pointers, are only used where no value is produced.
|
|
//
|
|
// Each type also has consumer templates, which a body uses to read a
|
|
// parameter of the type so that no parameter is unused. A template is an
|
|
// `i32` expression (`int` in C++) with a `{0}` placeholder for the
|
|
// parameter name. Every type needs at least one.
|
|
//
|
|
// A type can also have a predicate template, a `bool` expression with a
|
|
// `{0}` placeholder for a value of the type. Only types with a predicate
|
|
// template and a value expression are used for the fields that predicates
|
|
// test.
|
|
struct FixedTypeWeight {
|
|
llvm::StringRef carbon_spelling;
|
|
llvm::StringRef cpp_spelling;
|
|
int weight;
|
|
llvm::StringRef carbon_value;
|
|
llvm::StringRef cpp_value;
|
|
llvm::SmallVector<llvm::StringRef> carbon_consumers;
|
|
llvm::SmallVector<llvm::StringRef> cpp_consumers;
|
|
llvm::StringRef carbon_predicate;
|
|
llvm::StringRef cpp_predicate;
|
|
};
|
|
|
|
llvm::SmallVector<FixedTypeWeight> fixed_type_weights = {
|
|
// Combined weight of 65 for a core set of builtin types.
|
|
{.carbon_spelling = "bool",
|
|
.cpp_spelling = "bool",
|
|
.weight = 25,
|
|
.carbon_value = "true",
|
|
.cpp_value = "true",
|
|
.carbon_consumers = {"(if {0} then 1 else 0)",
|
|
"(if {0} then 2 else 3)"},
|
|
.cpp_consumers = {"({0} ? 1 : 0)", "({0} ? 2 : 3)"},
|
|
.carbon_predicate = "not {0}",
|
|
.cpp_predicate = "!{0}"},
|
|
{.carbon_spelling = "i32",
|
|
.cpp_spelling = "int",
|
|
.weight = 20,
|
|
.carbon_value = "0",
|
|
.cpp_value = "0",
|
|
.carbon_consumers = {"{0} + 1", "{0} * 2", "({0} % 7) + 1"},
|
|
.cpp_consumers = {"{0} + 1", "{0} * 2", "({0} % 7) + 1"},
|
|
.carbon_predicate = "{0} == 0",
|
|
.cpp_predicate = "{0} == 0"},
|
|
{.carbon_spelling = "i64",
|
|
.cpp_spelling = "std::int64_t",
|
|
.weight = 10,
|
|
.carbon_value = "0",
|
|
.cpp_value = "0",
|
|
.carbon_consumers = {"({0} as i32) - 2", "(({0} + 1) as i32)"},
|
|
.cpp_consumers = {"static_cast<int>({0}) - 2",
|
|
"static_cast<int>({0} + 1)"},
|
|
.carbon_predicate = "{0} > 0",
|
|
.cpp_predicate = "{0} > 0"},
|
|
{.carbon_spelling = "i32*",
|
|
.cpp_spelling = "int*",
|
|
.weight = 5,
|
|
.carbon_consumers = {"*{0} + 1", "*{0} * 2"},
|
|
.cpp_consumers = {"*{0} + 1", "*{0} * 2"}},
|
|
{.carbon_spelling = "i64*",
|
|
.cpp_spelling = "std::int64_t*",
|
|
.weight = 5,
|
|
.carbon_consumers = {"(*{0} as i32) - 2", "((*{0} * 2) as i32)"},
|
|
.cpp_consumers = {"static_cast<int>(*{0}) - 2",
|
|
"static_cast<int>(*{0} * 2)"}},
|
|
|
|
// A weight of 5 distributed across tuple structures
|
|
{.carbon_spelling = "(bool, i64)",
|
|
.cpp_spelling = "std::pair<bool, std::int64_t>",
|
|
.weight = 2,
|
|
.carbon_value = "(true, 0)",
|
|
.cpp_value = "{true, 0}",
|
|
.carbon_consumers = {"(if {0}.0 then 1 else 0)", "({0}.1 as i32) + 1"},
|
|
.cpp_consumers = {"({0}.first ? 1 : 0)",
|
|
"static_cast<int>({0}.second) + 1"},
|
|
.carbon_predicate = "{0}.1 > 0",
|
|
.cpp_predicate = "{0}.second > 0"},
|
|
{.carbon_spelling = "(i32, i64*)",
|
|
.cpp_spelling = "std::pair<int, std::int64_t*>",
|
|
.weight = 3,
|
|
.carbon_consumers = {"{0}.0 + 1", "{0}.0 * 2", "(*{0}.1 as i32) - 1"},
|
|
.cpp_consumers = {"{0}.first + 1", "{0}.first * 2",
|
|
"static_cast<int>(*{0}.second) - 1"}},
|
|
};
|
|
|
|
// Consumer templates for class types, in both languages. These call the
|
|
// generated `Checksum` method, which is the same in every class.
|
|
llvm::SmallVector<llvm::StringRef> class_consumers = {
|
|
"{0}.Checksum()", "{0}.Checksum() + 1", "{0}.Checksum() * 2"};
|
|
|
|
// The weight for using types declared in the file. These will be randomly
|
|
// shuffled references, and when there are more type references than
|
|
// declared, include repeated references.
|
|
int declared_types_weight = 30;
|
|
};
|
|
|
|
// Parameters used to generate a file with dense declarations.
|
|
struct DenseDeclParams {
|
|
// TODO: Add more parameters to control generating top-level constructs
|
|
// other than class definitions.
|
|
|
|
// Parameters used when generating class definitions.
|
|
ClassParams class_params = {};
|
|
|
|
// Parameters used to guide the selection of types for use in declarations.
|
|
TypeUseParams type_use_params = {};
|
|
};
|
|
|
|
// Access a global instance of this type to generate Carbon code for
|
|
// benchmarks, tests, or other places where sharing a common instance is
|
|
// useful. Note that there is nothing thread safe about this instance or type.
|
|
static auto Global() -> SourceGen&;
|
|
|
|
// Construct a source generator for the provided language, by default Carbon.
|
|
explicit SourceGen(Language language = Language::Carbon);
|
|
|
|
// Generate an API file with dense classes containing function forward
|
|
// declarations.
|
|
//
|
|
// Accepts a number of `target_lines` for the resulting source code. This is a
|
|
// rough approximation used to scale all the other constructs up and down
|
|
// accordingly. For C++ source generation, we work to generate the same number
|
|
// of constructs as Carbon would for the given line count over keeping the
|
|
// actual line count close to the target.
|
|
//
|
|
// TODO: Currently, the formatting and line breaks of generating code are
|
|
// extremely rough still, and those are a large factor in adherence to
|
|
// `target_lines`. Long term, the goal is to get as close as we can to any
|
|
// automatically formatted code while still keeping the stability of
|
|
// benchmarking.
|
|
auto GenApiFileDenseDecls(int target_lines, const DenseDeclParams& params)
|
|
-> std::string;
|
|
|
|
// Get some number of randomly shuffled identifiers.
|
|
//
|
|
// The identifiers start with a character [A-Za-z], other characters may also
|
|
// include [0-9_]. Both Carbon and C++ keywords are excluded along with any
|
|
// other non-identifier syntaxes that overlap to ensure all of these can be
|
|
// used as identifiers.
|
|
//
|
|
// The order will be different for each call to this function, but the
|
|
// specific identifiers may remain the same in order to reduce the cost of
|
|
// repeated calls. However, the sum of the identifier sizes returned is
|
|
// guaranteed to be the same for every call with the same number of
|
|
// identifiers so that benchmarking all of these identifiers has predictable
|
|
// and stable cost.
|
|
//
|
|
// Optionally, callers can request a minimum and maximum length. By default,
|
|
// the length distribution used across the identifiers will mirror the
|
|
// observed distribution of identifiers in C++ source code and our expectation
|
|
// of them in Carbon source code. The maximum length in this default
|
|
// distribution cannot be more than 64.
|
|
//
|
|
// Callers can request a uniform distribution across [min_length, max_length],
|
|
// and when it is requested there is no limit on `max_length`.
|
|
auto GetShuffledIdentifiers(int number, int min_length = 1,
|
|
int max_length = 64, bool uniform = false)
|
|
-> llvm::SmallVector<llvm::StringRef>;
|
|
|
|
// Same as `GetShuffledIdentifiers`, but ensures there are no collisions.
|
|
auto GetShuffledUniqueIdentifiers(int number, int min_length = 4,
|
|
int max_length = 64, bool uniform = false)
|
|
-> llvm::SmallVector<llvm::StringRef>;
|
|
|
|
// Returns a collection of un-shuffled identifiers, otherwise the same as
|
|
// `GetShuffledIdentifiers`.
|
|
//
|
|
// Usually, benchmarks should use the shuffled version. However, this is
|
|
// useful when deterministic access to the identifiers is needed to avoid
|
|
// introducing noise, or if there is already a post-processing step to shuffle
|
|
// things, since shuffling is very expensive in debug builds.
|
|
auto GetIdentifiers(int number, int min_length = 1, int max_length = 64,
|
|
bool uniform = false)
|
|
-> llvm::SmallVector<llvm::StringRef>;
|
|
|
|
// Returns a collection of un-shuffled unique identifiers, otherwise the same
|
|
// as `GetShuffledUniqueIdentifiers`.
|
|
//
|
|
// Usually, benchmarks should use the shuffled version. However, this is
|
|
// useful when deterministic access to the identifiers is needed to avoid
|
|
// introducing noise, or if there is already a post-processing step to shuffle
|
|
// things, since shuffling is very expensive in debug builds.
|
|
auto GetUniqueIdentifiers(int number, int min_length = 1, int max_length = 64,
|
|
bool uniform = false)
|
|
-> llvm::SmallVector<llvm::StringRef>;
|
|
|
|
// Returns a shared collection of random identifiers of a specific length.
|
|
//
|
|
// For a single, exact length, we have an even cheaper routine to return
|
|
// access to a shared collection of identifiers. The order of these is a
|
|
// single fixed random order for a given execution. The returned array
|
|
// reference is only valid until the next call any method on this generator.
|
|
auto GetSingleLengthIdentifiers(int length, int number)
|
|
-> llvm::ArrayRef<llvm::StringRef>;
|
|
|
|
private:
|
|
class ClassGenState;
|
|
friend ClassGenState;
|
|
|
|
class UniqueIdentifierPopper;
|
|
friend UniqueIdentifierPopper;
|
|
|
|
using AppendFn = auto(int length, int number,
|
|
llvm::SmallVectorImpl<llvm::StringRef>& dest) -> void;
|
|
|
|
auto IsCpp() -> bool { return language_ == Language::Cpp; }
|
|
|
|
auto GenerateRandomIdentifier(llvm::MutableArrayRef<char> dest_storage)
|
|
-> void;
|
|
auto AppendUniqueIdentifiers(int length, int number,
|
|
llvm::SmallVectorImpl<llvm::StringRef>& dest)
|
|
-> void;
|
|
auto GetIdentifiersImpl(int number, int min_length, int max_length,
|
|
bool uniform, llvm::function_ref<AppendFn> append)
|
|
-> llvm::SmallVector<llvm::StringRef>;
|
|
|
|
auto GetShuffledInts(int number, int min, int max) -> llvm::SmallVector<int>;
|
|
|
|
// A parameter or a field: its name, and the spelling of its type.
|
|
struct TypedName {
|
|
llvm::StringRef name;
|
|
llvm::StringRef type;
|
|
};
|
|
|
|
auto EmitParams(bool is_method, llvm::ArrayRef<TypedName> params,
|
|
llvm::StringRef indent, llvm::raw_ostream& os) -> void;
|
|
auto EmitFunctionDecl(llvm::StringRef name, bool is_private, bool is_method,
|
|
llvm::ArrayRef<TypedName> params,
|
|
llvm::StringRef return_type, llvm::StringRef indent,
|
|
llvm::raw_ostream& os) -> void;
|
|
auto GenerateFunctionDecl(ClassGenState& state, llvm::StringRef name,
|
|
bool is_private, bool is_method, int param_count,
|
|
llvm::StringRef indent, llvm::raw_ostream& os)
|
|
-> void;
|
|
auto GenerateInlineFunctionDef(ClassGenState& state, llvm::StringRef name,
|
|
int param_count, int local_count,
|
|
llvm::StringRef indent, llvm::raw_ostream& os)
|
|
-> void;
|
|
auto GenerateGetter(llvm::StringRef name, TypedName field,
|
|
llvm::raw_ostream& os) -> void;
|
|
auto GeneratePredicate(llvm::StringRef name, TypedName field,
|
|
llvm::StringRef predicate, llvm::raw_ostream& os)
|
|
-> void;
|
|
auto GenerateForwarder(llvm::StringRef name, llvm::ArrayRef<TypedName> params,
|
|
llvm::StringRef return_type, llvm::raw_ostream& os)
|
|
-> void;
|
|
auto GenerateMakeFunction(ClassGenState& state, llvm::StringRef class_name,
|
|
llvm::ArrayRef<TypedName> fields,
|
|
llvm::raw_ostream& os) -> void;
|
|
auto GenerateChecksumFunction(llvm::raw_ostream& os) -> void;
|
|
auto GenerateClassDef(const ClassParams& params, ClassGenState& state,
|
|
llvm::raw_ostream& os) -> void;
|
|
|
|
absl::BitGen rng_;
|
|
llvm::BumpPtrAllocator storage_;
|
|
|
|
Map<int, llvm::SmallVector<llvm::StringRef>> identifiers_by_length_;
|
|
Map<int, std::pair<int, Set<llvm::StringRef>>> unique_identifiers_by_length_;
|
|
|
|
Language language_;
|
|
};
|
|
|
|
} // namespace Carbon::Testing
|
|
|
|
#endif // CARBON_TOOLCHAIN_BENCHMARKING_SOURCE_GEN_H_
|