Clean Code Tax, Measured

Expectation: per-object polymorphism should lose when a hot loop calls through a base pointer. The cost is not only the virtual call. It is also the heap object layout and the lost chance to run tight type-specific loops.

struct ShapeBase {
    virtual ~ShapeBase() = default;
    virtual std::uint64_t area() const = 0;
};

struct CircleShape final : ShapeBase {
    explicit CircleShape(std::uint64_t radius_value) : radius(radius_value) {}
    std::uint64_t area() const override { return radius * radius * 3ULL; }
    std::uint64_t radius;
};

struct SquareShape final : ShapeBase {
    explicit SquareShape(std::uint64_t side_value) : side(side_value) {}
    std::uint64_t area() const override { return side * side; }
    std::uint64_t side;
};

for (const auto& shape : *shapes) {
    sum += shape->area();
}

The SoA control buckets by type, then runs tight loops.

for (const std::uint64_t radius : *circles) {
    sum += radius * radius * 3ULL;
}
for (const std::uint64_t side : *squares) {
    sum += side * side;
}

Expectation: no-throw exception-shaped code may be fine, but throwing as a normal failure path should become very expensive as failure rate rises.

CACHEBENCH_CLEAN_NOINLINE std::uint64_t parse_or_throw(
    const std::uint64_t value,
    const std::size_t index,
    const std::size_t period) {
    if (period != 0U && index % period == 0U) {
        throw std::runtime_error("clean_tax");
    }
    return value + 11ULL;
}

TinyResult parse_result(const std::uint64_t value,
                        const std::size_t index,
                        const std::size_t period) {
    if (period != 0U && index % period == 0U) {
        return TinyResult{false, 0};
    }
    return TinyResult{true, value + 11ULL};
}

The benchmark sweeps no throw, 0.001 percent, 1 percent, and 50 percent failure rates.

if (mode.find("exception") == 0U) {
    try {
        sum += parse_or_throw(value, index, period);
    } catch (const std::exception&) {
        sum += 7ULL;
    }
} else {
    const TinyResult result = parse_result(value, index, period);
    sum += result.ok ? result.value : 7ULL;
}

Expectation: RAII is not the problem. Repeated hidden allocation is the problem. Creating a std::string or unique_ptr inside every iteration should lose to reused storage or stack storage.

if (mode == "string_per_iter") {
    std::string key = std::string("prefix_") + std::to_string(index + pass);
    sum += key.size();
}

else if (mode == "string_reuse") {
    reused.clear();
    reused.append("prefix_");
    reused.append(std::to_string(index + pass));
    sum += reused.size();
}

else if (mode == "unique_ptr_per_iter") {
    auto value = std::make_unique<std::uint64_t>(index + pass);
    escape_pointer(value.get());
    sum += *value;
}

else if (mode == "stack_object") {
    std::uint64_t value = index + pass;
    escape_pointer(&value);
    sum += value;
}

Expectation: fluent builders can be good API design, but they are not free when used at high construction rates.

Request request = RequestBuilder()
                      .url("https://svc/items/" + std::to_string(index))
                      .method("GET")
                      .header("Accept", "application/json")
                      .header("Trace", "on")
                      .timeout(30)
                      .build();

Aggregate initialization and reserved construction are the controls.

Request request{"https://svc/items/" + std::to_string(index),
                "GET",
                {{"Accept", "application/json"}, {"Trace", "on"}},
                30};

Request request;
request.headers.reserve(2);
request.url = "https://svc/items/";
request.url += std::to_string(index);
request.method = "GET";
request.headers.emplace_back("Accept", "application/json");
request.headers.emplace_back("Trace", "on");
request.timeout_ms = 30;

Expectation: logging is cheap only when formatting is avoided and I/O is not on the hot path. Tracing at boundaries is usually fine; tracing every helper can dominate small operations.

if (mode == "eager_disabled") {
    const std::string line = format_log_line(index, pass);
    if (debug_enabled) {
        sum += line.size();
    }
}

else if (mode == "lazy_guard_disabled") {
    if (debug_enabled) {
        sum += format_log_line(index, pass).size();
    }
}

if (mode == "boundary_span") {
    sum ^= span_marker(pass);
}

for (std::size_t index = 0; index < data->size(); ++index) {
    if (mode == "span_every_helper") {
        sum ^= span_marker(index);
    }
    sum += inline_transform((*data)[index]);
}

Expectation: splitting a direct call into staged work should add overhead. If serialization is included, the cost should be much larger.

if (mode == "direct") {
    sum += direct_service_call(value);
}

else if (mode == "queue_stage") {
    queue.push_back(value);
    const std::uint64_t staged = queue.front();
    queue.pop_front();
    sum += direct_service_call(staged);
}

else {
    const int written = std::snprintf(buffer.data(), buffer.size(), "%llu",
                                      static_cast<unsigned long long>(value));
    const std::uint64_t parsed =
        static_cast<std::uint64_t>(std::strtoull(buffer.data(), nullptr, 10));
    sum += direct_service_call(parsed) + static_cast<std::uint64_t>(std::max(written, 0));
}

Expectation: cache hits can beat recompute, but miss paths are still on the critical path. A cache should not be judged only by average hit rate.

if (mode == "direct_compute") {
    sum += expensive_compute(key);
}

else {
    const auto found = cache->find(key);
    if (found != cache->end()) {
        sum += found->second;
    } else {
        const std::uint64_t computed = expensive_compute(key);
        (*cache)[key] = computed;
        sum += computed;
    }
}

Expectation: the clean default container may not be the fastest. The winner depends on key count and access shape.

if (mode == "std_map") {
    sum += tree->find(key)->second;
} else if (mode == "unordered_map") {
    sum += hash->find(key)->second;
} else if (mode == "flat_vector") {
    const auto found = std::lower_bound(
        shared_items->begin(), shared_items->end(), key,
        [](const auto& item, const std::uint64_t query) { return item.first < query; });
    sum += found->second;
} else {
    for (const auto& item : *shared_items) {
        if (item.first == key) {
            sum += item.second;
            break;
        }
    }
}

Expectation: ostringstream is convenient, but it should be slower than simpler formatting for small repeated formatting tasks.

if (mode == "ostringstream") {
    std::ostringstream stream;
    stream << "id=" << index << ",value=" << (index + pass);
    sum += stream.str().size();
} else if (mode == "snprintf") {
    const int written =
        std::snprintf(buffer.data(), buffer.size(), "id=%zu,value=%zu", index, index + pass);
    sum += static_cast<std::uint64_t>(std::max(written, 0));
} else {
    std::string out;
    out.reserve(32);
    out.append("id=");
    out.append(std::to_string(index));
    out.append(",value=");
    out.append(std::to_string(index + pass));
    sum += out.size();
}

Expectation: DOM-like allocation should lose to streaming extraction when the schema is known.

std::uint64_t parse_streaming_digits(const std::string& text) {
    std::uint64_t sum = 0;
    std::uint64_t current = 0;
    bool in_number = false;
    for (const char ch : text) {
        if (ch >= '0' && ch <= '9') {
            current = current * 10ULL + static_cast<std::uint64_t>(ch - '0');
            in_number = true;
        } else if (in_number) {
            sum += current;
            current = 0;
            in_number = false;
        }
    }
    return in_number ? sum + current : sum;
}

if (mode == "dom_allocated") {
    std::vector<JsonPair> pairs;
    pairs.reserve(2);
    pairs.push_back(JsonPair{"id", parse_streaming_digits(doc)});
    pairs.push_back(JsonPair{"qty", doc.size()});
    for (const JsonPair& pair : pairs) {
        sum += pair.value + pair.key.size();
    }
} else {
    sum += parse_streaming_digits(doc);
}

Expectation: a global atomic per item should lose to local accumulation with one flush, especially with more threads and larger workloads.

if (mode == "global_atomic") {
    for (std::size_t index = begin; index < end; ++index) {
        counter.fetch_add(index + 1U, std::memory_order_relaxed);
    }
} else {
    std::uint64_t local = 0;
    for (std::size_t index = begin; index < end; ++index) {
        local += index + 1U;
    }
    counter.fetch_add(local, std::memory_order_relaxed);
}

Expectation: JSON text should lose to packed binary for repeated encode/decode work.

if (mode == "json_text") {
    const int written =
        std::snprintf(buffer.data(), buffer.size(), "{\"id\":%u,\"qty\":%u,\"price\":%llu}",
                      payload.id,
                      payload.qty,
                      static_cast<unsigned long long>(payload.price));
    sum += parse_streaming_digits(std::string(buffer.data(),
        static_cast<std::size_t>(std::max(written, 0))));
} else {
    std::array<unsigned char, sizeof(BinaryPayload)> bytes{};
    std::memcpy(bytes.data(), &payload, sizeof(payload));
    BinaryPayload decoded{};
    std::memcpy(&decoded, bytes.data(), sizeof(decoded));
    sum += decoded.id + decoded.qty + decoded.price;
}