mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 21:50:14 +01:00
Jon Ross-PerkinsandChandler Carruth
613a139bef
This implements the leads decision made in #6821, proposal #6910. The proposal is pending, but I figured it's relatively safe to just do given the decision. Assisted-by: Google Antigravity with Gemini --------- Co-authored-by: Chandler Carruth <chandlerc@gmail.com>
123 lines
3.8 KiB
C++
123 lines
3.8 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
|
|
|
|
#include <benchmark/benchmark.h>
|
|
|
|
#include <string>
|
|
|
|
#include "common/check.h"
|
|
#include "toolchain/diagnostics/null_diagnostics.h"
|
|
#include "toolchain/lex/numeric_literal.h"
|
|
|
|
namespace Carbon::Lex {
|
|
namespace {
|
|
|
|
// Returns an integer literal string with `prefix` followed by `num_digits`
|
|
// entries from `digits` (repeating `digits` as necessary).
|
|
static auto MakeIntString(llvm::StringLiteral prefix, int radix, int num_digits)
|
|
-> std::string {
|
|
// Digits are reversed so that we can take `radix` digits from the end, and
|
|
// never have 0 be the first digit.
|
|
static constexpr llvm::StringLiteral Digits = "FEDCBA9876543210";
|
|
|
|
std::string s;
|
|
s.reserve(prefix.size() + num_digits);
|
|
s.append(prefix);
|
|
for (int i = 0; i < num_digits; i += radix) {
|
|
s.append(Digits.take_back(std::min(radix, num_digits - i)));
|
|
}
|
|
return s;
|
|
}
|
|
|
|
static void BM_Lex_Float(benchmark::State& state) {
|
|
for (auto _ : state) {
|
|
CARBON_CHECK(NumericLiteral::Lex("0.000001", true));
|
|
}
|
|
}
|
|
|
|
static void BM_Lex_Int(benchmark::State& state) {
|
|
for (auto _ : state) {
|
|
CARBON_CHECK(NumericLiteral::Lex("1_234_567_890", true));
|
|
}
|
|
}
|
|
|
|
static void BM_Lex_IntDecimalN(benchmark::State& state) {
|
|
std::string s = MakeIntString("", 10, state.range(0));
|
|
for (auto _ : state) {
|
|
CARBON_CHECK(NumericLiteral::Lex(s, true));
|
|
}
|
|
}
|
|
|
|
static void BM_ComputeValue_Float(benchmark::State& state) {
|
|
auto val = NumericLiteral::Lex("0.000001", true);
|
|
CARBON_CHECK(val);
|
|
auto& emitter = Diagnostics::NullEmitter<const char*>();
|
|
for (auto _ : state) {
|
|
val->ComputeValue(emitter);
|
|
}
|
|
}
|
|
|
|
static void BM_ComputeValue_Int(benchmark::State& state) {
|
|
auto val = NumericLiteral::Lex("1_234_567_890", true);
|
|
auto& emitter = Diagnostics::NullEmitter<const char*>();
|
|
CARBON_CHECK(val);
|
|
for (auto _ : state) {
|
|
val->ComputeValue(emitter);
|
|
}
|
|
}
|
|
|
|
static void BM_ComputeValue_IntDecimalN(benchmark::State& state) {
|
|
std::string s = MakeIntString("", 10, state.range(0));
|
|
auto val = NumericLiteral::Lex(s, true);
|
|
auto& emitter = Diagnostics::NullEmitter<const char*>();
|
|
CARBON_CHECK(val);
|
|
for (auto _ : state) {
|
|
val->ComputeValue(emitter);
|
|
}
|
|
}
|
|
|
|
static void BM_ComputeValue_IntBinaryN(benchmark::State& state) {
|
|
std::string s = MakeIntString("0b", 2, state.range(0));
|
|
auto val = NumericLiteral::Lex(s, true);
|
|
auto& emitter = Diagnostics::NullEmitter<const char*>();
|
|
CARBON_CHECK(val);
|
|
for (auto _ : state) {
|
|
val->ComputeValue(emitter);
|
|
}
|
|
}
|
|
|
|
static void BM_ComputeValue_IntOctalN(benchmark::State& state) {
|
|
std::string s = MakeIntString("0o", 8, state.range(0));
|
|
auto val = NumericLiteral::Lex(s, true);
|
|
auto& emitter = Diagnostics::NullEmitter<const char*>();
|
|
CARBON_CHECK(val);
|
|
for (auto _ : state) {
|
|
val->ComputeValue(emitter);
|
|
}
|
|
}
|
|
|
|
static void BM_ComputeValue_IntHexN(benchmark::State& state) {
|
|
// 0 is in the middle so that it isn't truncated in parse.
|
|
std::string s = MakeIntString("0x", 16, state.range(0));
|
|
auto val = NumericLiteral::Lex(s, true);
|
|
auto& emitter = Diagnostics::NullEmitter<const char*>();
|
|
CARBON_CHECK(val);
|
|
for (auto _ : state) {
|
|
val->ComputeValue(emitter);
|
|
}
|
|
}
|
|
|
|
BENCHMARK(BM_Lex_Float);
|
|
BENCHMARK(BM_Lex_Int);
|
|
BENCHMARK(BM_Lex_IntDecimalN)->RangeMultiplier(10)->Range(1, 10000);
|
|
BENCHMARK(BM_ComputeValue_Float);
|
|
BENCHMARK(BM_ComputeValue_Int);
|
|
BENCHMARK(BM_ComputeValue_IntDecimalN)->RangeMultiplier(10)->Range(1, 10000);
|
|
BENCHMARK(BM_ComputeValue_IntBinaryN)->RangeMultiplier(10)->Range(1, 10000);
|
|
BENCHMARK(BM_ComputeValue_IntOctalN)->RangeMultiplier(10)->Range(1, 10000);
|
|
BENCHMARK(BM_ComputeValue_IntHexN)->RangeMultiplier(10)->Range(1, 10000);
|
|
|
|
} // namespace
|
|
} // namespace Carbon::Lex
|