github/esphome
2
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2026-09-12 15:57:33 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
46c3a897fe79e307fb71efd12a557723a540e0b8
esphome/tests/benchmarks/proto_encode_benchmark.cpp
T

796 lines
29 KiB
C++
Raw Blame History

/**
* Benchmark: ProtoWriteBuffer encoding performance
*
* Compares the old push_back()-based encoding against the new pre-sized
* pointer-write approach introduced in PR #14018.
*
* Build (from repo root):
* g++ -std=gnu++20 -O2 \
* tests/benchmarks/proto_encode_benchmark.cpp \
* -o tests/benchmarks/proto_encode_benchmark
*
* For ESP-like size-optimized builds (-Os):
* g++ -std=gnu++20 -Os \
* tests/benchmarks/proto_encode_benchmark.cpp \
* -o tests/benchmarks/proto_encode_benchmark
*
* Run:
* ./tests/benchmarks/proto_encode_benchmark
*/
#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <numeric>
#include <string>
#include <vector>
// ============================================================================
// Minimal stubs to avoid pulling in the full ESPHome framework
// ============================================================================
namespace esphome {
class StringRef {
public:
constexpr StringRef() : base_(""), len_(0) {}
explicit StringRef(const char *s) : base_(s), len_(strlen(s)) {}
constexpr StringRef(const char *s, size_t n) : base_(s), len_(n) {}
explicit StringRef(const std::string &s) : base_(s.c_str()), len_(s.size()) {}
const char *c_str() const { return base_; }
size_t size() const { return len_; }
bool empty() const { return len_ == 0; }
private:
const char *base_;
size_t len_;
};
} // namespace esphome
// ============================================================================
// Old-style ProtoWriteBuffer (push_back based) - from dev branch
// ============================================================================
class OldProtoWriteBuffer {
public:
explicit OldProtoWriteBuffer(std::vector<uint8_t> *buffer) : buffer_(buffer) {}
void encode_varint_raw(uint32_t value) {
while (value > 0x7F) {
this->buffer_->push_back(static_cast<uint8_t>(value | 0x80));
value >>= 7;
}
this->buffer_->push_back(static_cast<uint8_t>(value));
}
void encode_varint_raw_64(uint64_t value) {
while (value > 0x7F) {
this->buffer_->push_back(static_cast<uint8_t>(value | 0x80));
value >>= 7;
}
this->buffer_->push_back(static_cast<uint8_t>(value));
}
void encode_field_raw(uint32_t field_id, uint32_t type) { this->encode_varint_raw((field_id << 3) | type); }
void encode_string(uint32_t field_id, const char *string, size_t len, bool force = false) {
if (len == 0 && !force)
return;
this->encode_field_raw(field_id, 2);
this->encode_varint_raw(len);
size_t old_size = this->buffer_->size();
this->buffer_->resize(old_size + len);
std::memcpy(this->buffer_->data() + old_size, string, len);
}
void encode_string(uint32_t field_id, const esphome::StringRef &ref, bool force = false) {
this->encode_string(field_id, ref.c_str(), ref.size(), force);
}
void encode_uint32(uint32_t field_id, uint32_t value, bool force = false) {
if (value == 0 && !force)
return;
this->encode_field_raw(field_id, 0);
this->encode_varint_raw(value);
}
void encode_bool(uint32_t field_id, bool value, bool force = false) {
if (!value && !force)
return;
this->encode_field_raw(field_id, 0);
this->buffer_->push_back(value ? 0x01 : 0x00);
}
void encode_fixed32(uint32_t field_id, uint32_t value, bool force = false) {
if (value == 0 && !force)
return;
this->encode_field_raw(field_id, 5);
this->buffer_->push_back((value >> 0) & 0xFF);
this->buffer_->push_back((value >> 8) & 0xFF);
this->buffer_->push_back((value >> 16) & 0xFF);
this->buffer_->push_back((value >> 24) & 0xFF);
}
void encode_float(uint32_t field_id, float value, bool force = false) {
if (value == 0.0f && !force)
return;
union {
float value;
uint32_t raw;
} val{};
val.value = value;
this->encode_fixed32(field_id, val.raw);
}
void encode_bytes(uint32_t field_id, const uint8_t *data, size_t len, bool force = false) {
this->encode_string(field_id, reinterpret_cast<const char *>(data), len, force);
}
std::vector<uint8_t> *get_buffer() const { return buffer_; }
protected:
std::vector<uint8_t> *buffer_;
};
// ============================================================================
// New-style ProtoWriteBuffer (pointer-write based) - from this PR
// ============================================================================
class NewProtoWriteBuffer {
public:
NewProtoWriteBuffer(std::vector<uint8_t> *buffer, size_t write_pos)
: buffer_(buffer), pos_(buffer->data() + write_pos) {}
void encode_varint_raw(uint32_t value) {
while (value > 0x7F) {
*this->pos_++ = static_cast<uint8_t>(value | 0x80);
value >>= 7;
}
*this->pos_++ = static_cast<uint8_t>(value);
}
void encode_varint_raw_64(uint64_t value) {
while (value > 0x7F) {
*this->pos_++ = static_cast<uint8_t>(value | 0x80);
value >>= 7;
}
*this->pos_++ = static_cast<uint8_t>(value);
}
void encode_field_raw(uint32_t field_id, uint32_t type) { this->encode_varint_raw((field_id << 3) | type); }
void encode_string(uint32_t field_id, const char *string, size_t len, bool force = false) {
if (len == 0 && !force)
return;
this->encode_field_raw(field_id, 2);
this->encode_varint_raw(len);
std::memcpy(this->pos_, string, len);
this->pos_ += len;
}
void encode_string(uint32_t field_id, const esphome::StringRef &ref, bool force = false) {
this->encode_string(field_id, ref.c_str(), ref.size(), force);
}
void encode_uint32(uint32_t field_id, uint32_t value, bool force = false) {
if (value == 0 && !force)
return;
this->encode_field_raw(field_id, 0);
this->encode_varint_raw(value);
}
void encode_bool(uint32_t field_id, bool value, bool force = false) {
if (!value && !force)
return;
this->encode_field_raw(field_id, 0);
*this->pos_++ = value ? 0x01 : 0x00;
}
void encode_fixed32(uint32_t field_id, uint32_t value, bool force = false) {
if (value == 0 && !force)
return;
this->encode_field_raw(field_id, 5);
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
std::memcpy(this->pos_, &value, 4);
this->pos_ += 4;
#else
*this->pos_++ = (value >> 0) & 0xFF;
*this->pos_++ = (value >> 8) & 0xFF;
*this->pos_++ = (value >> 16) & 0xFF;
*this->pos_++ = (value >> 24) & 0xFF;
#endif
}
void encode_float(uint32_t field_id, float value, bool force = false) {
if (value == 0.0f && !force)
return;
union {
float value;
uint32_t raw;
} val{};
val.value = value;
this->encode_fixed32(field_id, val.raw);
}
void encode_bytes(uint32_t field_id, const uint8_t *data, size_t len, bool force = false) {
this->encode_string(field_id, reinterpret_cast<const char *>(data), len, force);
}
uint8_t *pos() const { return pos_; }
std::vector<uint8_t> *get_buffer() const { return buffer_; }
protected:
std::vector<uint8_t> *buffer_;
uint8_t *pos_;
};
// ============================================================================
// ProtoSize - calculate exact encoded size (shared by both approaches)
// ============================================================================
class ProtoSize {
public:
static constexpr uint32_t varint(uint32_t value) {
if (value < 128)
return 1;
if (value < 16384)
return 2;
if (value < 2097152)
return 3;
if (value < 268435456)
return 4;
return 5;
}
static constexpr uint32_t field(uint32_t field_id, uint32_t type) { return varint((field_id << 3) | (type & 0x7)); }
static constexpr uint32_t calc_uint32(uint32_t field_id_size, uint32_t value) {
return value ? field_id_size + varint(value) : 0;
}
static constexpr uint32_t calc_bool(uint32_t field_id_size, bool value) { return value ? field_id_size + 1 : 0; }
static constexpr uint32_t calc_float(uint32_t field_id_size, float value) {
return value != 0.0f ? field_id_size + 4 : 0;
}
static constexpr uint32_t calc_fixed32(uint32_t field_id_size, uint32_t value) {
return value ? field_id_size + 4 : 0;
}
static constexpr uint32_t calc_length(uint32_t field_id_size, size_t len) {
return len ? field_id_size + varint(static_cast<uint32_t>(len)) + static_cast<uint32_t>(len) : 0;
}
};
// ============================================================================
// Benchmark infrastructure
// ============================================================================
struct BenchResult {
const char *name;
double ns_per_op;
double ops_per_sec;
size_t iterations;
size_t bytes_per_op;
};
// Prevent compiler from optimizing away the result
template<typename T> __attribute__((noinline)) void do_not_optimize(T &value) {
asm volatile("" : "+r,m"(value) : : "memory");
}
__attribute__((noinline)) void clobber_memory() { asm volatile("" : : : "memory"); }
template<typename Func> BenchResult benchmark(const char *name, size_t bytes_per_op, Func func) {
// Warmup
for (int i = 0; i < 1000; i++) {
func();
}
// Determine iteration count (target ~100ms)
size_t iterations = 1000;
auto start = std::chrono::high_resolution_clock::now();
for (size_t i = 0; i < iterations; i++) {
func();
}
auto end = std::chrono::high_resolution_clock::now();
double elapsed_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
double ns_per_op = elapsed_ns / iterations;
// Scale iterations to target ~200ms
iterations = std::max<size_t>(10000, static_cast<size_t>(200'000'000.0 / ns_per_op));
// Actual benchmark run
start = std::chrono::high_resolution_clock::now();
for (size_t i = 0; i < iterations; i++) {
func();
clobber_memory();
}
end = std::chrono::high_resolution_clock::now();
elapsed_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
ns_per_op = elapsed_ns / iterations;
return BenchResult{name, ns_per_op, 1'000'000'000.0 / ns_per_op, iterations, bytes_per_op};
}
void print_results(const std::vector<BenchResult> &results) {
printf("%-50s %12s %12s %12s %10s\n", "Benchmark", "ns/op", "ops/sec", "iters", "bytes/op");
printf("%-50s %12s %12s %12s %10s\n", std::string(50, '-').c_str(), "--------", "--------", "--------", "--------");
for (const auto &r : results) {
printf("%-50s %12.1f %12.0f %12zu %10zu\n", r.name, r.ns_per_op, r.ops_per_sec, r.iterations, r.bytes_per_op);
}
}
void print_comparison(const char *label, const BenchResult &old_result, const BenchResult &new_result) {
double speedup = old_result.ns_per_op / new_result.ns_per_op;
printf(" %-46s %.1fx %s\n", label, speedup, speedup > 1.0 ? "faster" : "slower");
}
// ============================================================================
// Benchmark: Varint encoding
// ============================================================================
static void bench_varint_old(std::vector<uint8_t> &buf) {
buf.clear();
OldProtoWriteBuffer writer(&buf);
// Encode a mix of varint sizes (1-5 bytes)
writer.encode_varint_raw(0x01); // 1 byte
writer.encode_varint_raw(0x80); // 2 bytes
writer.encode_varint_raw(0x4000); // 3 bytes
writer.encode_varint_raw(0x200000); // 4 bytes
writer.encode_varint_raw(0x10000000); // 5 bytes
}
static void bench_varint_new(std::vector<uint8_t> &buf, size_t size) {
buf.resize(size);
NewProtoWriteBuffer writer(&buf, 0);
writer.encode_varint_raw(0x01);
writer.encode_varint_raw(0x80);
writer.encode_varint_raw(0x4000);
writer.encode_varint_raw(0x200000);
writer.encode_varint_raw(0x10000000);
}
// ============================================================================
// Benchmark: String encoding (simulates entity names, object_ids, etc.)
// ============================================================================
static const char SHORT_STR[] = "sensor_1"; // 8 bytes
static const char MEDIUM_STR[] = "living_room_temperature_sensor"; // 30 bytes
static const char LONG_STR[] =
"esphome_very_long_device_name_with_many_characters_for_testing_purposes_abcdef"; // 78 bytes
static void bench_strings_old(std::vector<uint8_t> &buf) {
buf.clear();
OldProtoWriteBuffer writer(&buf);
writer.encode_string(1, SHORT_STR, strlen(SHORT_STR));
writer.encode_string(2, MEDIUM_STR, strlen(MEDIUM_STR));
writer.encode_string(3, LONG_STR, strlen(LONG_STR));
}
static size_t calc_strings_size() {
uint32_t size = 0;
size += ProtoSize::calc_length(1, strlen(SHORT_STR));
size += ProtoSize::calc_length(1, strlen(MEDIUM_STR));
size += ProtoSize::calc_length(1, strlen(LONG_STR));
return size;
}
static void bench_strings_new(std::vector<uint8_t> &buf, size_t size) {
buf.resize(size);
NewProtoWriteBuffer writer(&buf, 0);
writer.encode_string(1, SHORT_STR, strlen(SHORT_STR));
writer.encode_string(2, MEDIUM_STR, strlen(MEDIUM_STR));
writer.encode_string(3, LONG_STR, strlen(LONG_STR));
}
// ============================================================================
// Benchmark: Fixed32 encoding (simulates key fields in state responses)
// ============================================================================
static void bench_fixed32_old(std::vector<uint8_t> &buf) {
buf.clear();
OldProtoWriteBuffer writer(&buf);
for (uint32_t i = 1; i <= 10; i++) {
writer.encode_fixed32(i, 0xDEADBEEF);
}
}
static size_t calc_fixed32_size() {
uint32_t size = 0;
for (uint32_t i = 1; i <= 10; i++) {
size += ProtoSize::calc_fixed32(1, 0xDEADBEEF);
}
return size;
}
static void bench_fixed32_new(std::vector<uint8_t> &buf, size_t size) {
buf.resize(size);
NewProtoWriteBuffer writer(&buf, 0);
for (uint32_t i = 1; i <= 10; i++) {
writer.encode_fixed32(i, 0xDEADBEEF);
}
}
// ============================================================================
// Benchmark: Simulate SensorStateResponse encoding
// SensorStateResponse has: fixed32 key, float state, bool missing_state
// This is the most frequent message type during normal operation.
// ============================================================================
static void bench_sensor_state_old(std::vector<uint8_t> &buf) {
buf.clear();
OldProtoWriteBuffer writer(&buf);
writer.encode_fixed32(1, 0x12345678); // key
writer.encode_float(2, 23.5f); // state
writer.encode_bool(3, false); // missing_state (default, skipped)
}
static size_t calc_sensor_state_size() {
uint32_t size = 0;
size += ProtoSize::calc_fixed32(1, 0x12345678);
size += ProtoSize::calc_float(1, 23.5f);
size += ProtoSize::calc_bool(1, false);
return size;
}
static void bench_sensor_state_new(std::vector<uint8_t> &buf, size_t size) {
buf.resize(size);
NewProtoWriteBuffer writer(&buf, 0);
writer.encode_fixed32(1, 0x12345678);
writer.encode_float(2, 23.5f);
writer.encode_bool(3, false);
}
// ============================================================================
// Benchmark: Simulate ListEntitiesSensorResponse encoding
// This is a larger message sent during entity listing.
// Fields: object_id, key, name, unique_id, icon, unit_of_measurement,
// accuracy_decimals, force_update, device_class, state_class
// ============================================================================
static const char OBJ_ID[] = "living_room_temp";
static const char NAME[] = "Living Room Temperature";
static const char UNIQUE_ID[] = "esp32_01-sensor-living_room_temp";
static const char ICON[] = "mdi:thermometer";
static const char UNIT[] = "\xc2\xb0"
"C"; // UTF-8 degree C
static const char DEVICE_CLASS[] = "temperature";
static void bench_list_entities_old(std::vector<uint8_t> &buf) {
buf.clear();
OldProtoWriteBuffer writer(&buf);
writer.encode_string(1, OBJ_ID, strlen(OBJ_ID)); // object_id
writer.encode_fixed32(2, 0xABCD1234); // key
writer.encode_string(3, NAME, strlen(NAME)); // name
writer.encode_string(4, UNIQUE_ID, strlen(UNIQUE_ID)); // unique_id
writer.encode_string(5, ICON, strlen(ICON)); // icon
writer.encode_string(6, UNIT, strlen(UNIT)); // unit_of_measurement
writer.encode_uint32(7, 1); // accuracy_decimals
writer.encode_bool(8, false); // force_update
writer.encode_string(9, DEVICE_CLASS, strlen(DEVICE_CLASS)); // device_class
writer.encode_uint32(10, 1); // state_class
}
static size_t calc_list_entities_size() {
uint32_t size = 0;
size += ProtoSize::calc_length(1, strlen(OBJ_ID));
size += ProtoSize::calc_fixed32(1, 0xABCD1234);
size += ProtoSize::calc_length(1, strlen(NAME));
size += ProtoSize::calc_length(1, strlen(UNIQUE_ID));
size += ProtoSize::calc_length(1, strlen(ICON));
size += ProtoSize::calc_length(1, strlen(UNIT));
size += ProtoSize::calc_uint32(1, 1);
size += ProtoSize::calc_bool(1, false);
size += ProtoSize::calc_length(1, strlen(DEVICE_CLASS));
size += ProtoSize::calc_uint32(1, 1);
return size;
}
static void bench_list_entities_new(std::vector<uint8_t> &buf, size_t size) {
buf.resize(size);
NewProtoWriteBuffer writer(&buf, 0);
writer.encode_string(1, OBJ_ID, strlen(OBJ_ID));
writer.encode_fixed32(2, 0xABCD1234);
writer.encode_string(3, NAME, strlen(NAME));
writer.encode_string(4, UNIQUE_ID, strlen(UNIQUE_ID));
writer.encode_string(5, ICON, strlen(ICON));
writer.encode_string(6, UNIT, strlen(UNIT));
writer.encode_uint32(7, 1);
writer.encode_bool(8, false);
writer.encode_string(9, DEVICE_CLASS, strlen(DEVICE_CLASS));
writer.encode_uint32(10, 1);
}
// ============================================================================
// Benchmark: Simulate BLE advertisement batch encoding
// BluetoothLERawAdvertisementsResponse with multiple advertisements.
// Each advert has: uint64 address, sint32 rssi, uint32 address_type, bytes data
// This is a high-frequency message that benefits most from optimization.
// ============================================================================
static const uint8_t FAKE_BLE_DATA[31] = {0x02, 0x01, 0x06, 0x11, 0x07, 0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00,
0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0x15, 0x12, 0x00, 0x00, 0x03,
0x09, 0x54, 0x65, 0x73, 0x74, 0x00, 0x00, 0x00, 0x00};
static void bench_ble_batch_old(std::vector<uint8_t> &buf) {
buf.clear();
OldProtoWriteBuffer writer(&buf);
// Simulate encoding 8 BLE advertisements
for (int i = 0; i < 8; i++) {
// Each advertisement fields (flattened, no nested message for simplicity)
writer.encode_uint32(1, static_cast<uint32_t>(0xAABBCCDD + i)); // address (lower 32)
writer.encode_uint32(2, static_cast<uint32_t>(-70 + i)); // rssi
writer.encode_uint32(3, 0); // address_type (public)
writer.encode_bytes(4, FAKE_BLE_DATA, sizeof(FAKE_BLE_DATA)); // data
}
}
static size_t calc_ble_batch_size() {
uint32_t size = 0;
for (int i = 0; i < 8; i++) {
size += ProtoSize::calc_uint32(1, static_cast<uint32_t>(0xAABBCCDD + i));
size += ProtoSize::calc_uint32(1, static_cast<uint32_t>(-70 + i));
size += ProtoSize::calc_uint32(1, 0);
size += ProtoSize::calc_length(1, sizeof(FAKE_BLE_DATA));
}
return size;
}
static void bench_ble_batch_new(std::vector<uint8_t> &buf, size_t size) {
buf.resize(size);
NewProtoWriteBuffer writer(&buf, 0);
for (int i = 0; i < 8; i++) {
writer.encode_uint32(1, static_cast<uint32_t>(0xAABBCCDD + i));
writer.encode_uint32(2, static_cast<uint32_t>(-70 + i));
writer.encode_uint32(3, 0);
writer.encode_bytes(4, FAKE_BLE_DATA, sizeof(FAKE_BLE_DATA));
}
}
// ============================================================================
// Benchmark: Simulate SubscribeLogsResponse encoding
// This is a frequent message: level (enum/uint32) + message (bytes)
// Message sizes vary from short to long log lines.
// ============================================================================
static const char LOG_SHORT[] = "[sensor:042]: 'Temperature': Sending state 23.50 °C";
static const char LOG_LONG[] = "[wifi:042]: Connecting to 'MyNetwork'... [wifi:042]: Connected! "
"IP=192.168.1.100, SSID=MyNetwork, BSSID=AA:BB:CC:DD:EE:FF, Channel=6, RSSI=-42 dB";
static void bench_log_msg_old(std::vector<uint8_t> &buf) {
buf.clear();
OldProtoWriteBuffer writer(&buf);
writer.encode_uint32(1, 3); // level = DEBUG
writer.encode_bytes(3, reinterpret_cast<const uint8_t *>(LOG_SHORT), strlen(LOG_SHORT));
}
static size_t calc_log_msg_size() {
uint32_t size = 0;
size += ProtoSize::calc_uint32(1, 3);
size += ProtoSize::calc_length(1, strlen(LOG_SHORT));
return size;
}
static void bench_log_msg_new(std::vector<uint8_t> &buf, size_t size) {
buf.resize(size);
NewProtoWriteBuffer writer(&buf, 0);
writer.encode_uint32(1, 3);
writer.encode_bytes(3, reinterpret_cast<const uint8_t *>(LOG_SHORT), strlen(LOG_SHORT));
}
static void bench_log_long_old(std::vector<uint8_t> &buf) {
buf.clear();
OldProtoWriteBuffer writer(&buf);
writer.encode_uint32(1, 3);
writer.encode_bytes(3, reinterpret_cast<const uint8_t *>(LOG_LONG), strlen(LOG_LONG));
}
static size_t calc_log_long_size() {
uint32_t size = 0;
size += ProtoSize::calc_uint32(1, 3);
size += ProtoSize::calc_length(1, strlen(LOG_LONG));
return size;
}
static void bench_log_long_new(std::vector<uint8_t> &buf, size_t size) {
buf.resize(size);
NewProtoWriteBuffer writer(&buf, 0);
writer.encode_uint32(1, 3);
writer.encode_bytes(3, reinterpret_cast<const uint8_t *>(LOG_LONG), strlen(LOG_LONG));
}
// ============================================================================
// Benchmark: Full encode cycle including calculate_size + resize + encode
// This measures the realistic overhead of the pre-sizing approach.
// ============================================================================
static void bench_full_cycle_sensor_old(std::vector<uint8_t> &buf) {
// Old approach: just encode directly (vector grows as needed)
buf.clear();
buf.reserve(32); // Typical small reserve
OldProtoWriteBuffer writer(&buf);
writer.encode_fixed32(1, 0x12345678);
writer.encode_float(2, 23.5f);
writer.encode_bool(3, false);
}
static void bench_full_cycle_sensor_new(std::vector<uint8_t> &buf) {
// New approach: calculate size, resize, then encode
uint32_t size = 0;
size += ProtoSize::calc_fixed32(1, 0x12345678);
size += ProtoSize::calc_float(1, 23.5f);
size += ProtoSize::calc_bool(1, false);
buf.clear();
buf.resize(size);
NewProtoWriteBuffer writer(&buf, 0);
writer.encode_fixed32(1, 0x12345678);
writer.encode_float(2, 23.5f);
writer.encode_bool(3, false);
}
// ============================================================================
// Correctness verification
// ============================================================================
static bool verify_encoding_match() {
std::vector<uint8_t> old_buf, new_buf;
bool all_pass = true;
auto check = [&](const char *name) {
if (old_buf.size() != new_buf.size() || memcmp(old_buf.data(), new_buf.data(), old_buf.size()) != 0) {
printf("FAIL: %s - output mismatch (old=%zu bytes, new=%zu bytes)\n", name, old_buf.size(), new_buf.size());
all_pass = false;
}
};
// Varint
bench_varint_old(old_buf);
bench_varint_new(new_buf, old_buf.size());
check("varint");
// Strings
bench_strings_old(old_buf);
bench_strings_new(new_buf, calc_strings_size());
check("strings");
// Fixed32
bench_fixed32_old(old_buf);
bench_fixed32_new(new_buf, calc_fixed32_size());
check("fixed32");
// SensorStateResponse
bench_sensor_state_old(old_buf);
bench_sensor_state_new(new_buf, calc_sensor_state_size());
check("sensor_state");
// ListEntitiesSensorResponse
bench_list_entities_old(old_buf);
bench_list_entities_new(new_buf, calc_list_entities_size());
check("list_entities");
// BLE batch
bench_ble_batch_old(old_buf);
bench_ble_batch_new(new_buf, calc_ble_batch_size());
check("ble_batch");
// Log message
bench_log_msg_old(old_buf);
bench_log_msg_new(new_buf, calc_log_msg_size());
check("log_short");
// Long log message
bench_log_long_old(old_buf);
bench_log_long_new(new_buf, calc_log_long_size());
check("log_long");
return all_pass;
}
// ============================================================================
// Main
// ============================================================================
int main() {
printf("=== ProtoWriteBuffer Encoding Benchmark ===\n");
printf("Comparing push_back() vs pre-sized pointer writes\n\n");
// Verify correctness first
printf("--- Correctness Verification ---\n");
if (!verify_encoding_match()) {
printf("CORRECTNESS CHECK FAILED - encoding output differs!\n");
return 1;
}
printf("All encoding outputs match between old and new implementations.\n\n");
// Calculate sizes for pre-allocation
size_t varint_size = 1 + 2 + 3 + 4 + 5; // 15 bytes
size_t strings_size = calc_strings_size();
size_t fixed32_size = calc_fixed32_size();
size_t sensor_state_size = calc_sensor_state_size();
size_t list_entities_size = calc_list_entities_size();
size_t ble_batch_size = calc_ble_batch_size();
size_t log_msg_size = calc_log_msg_size();
size_t log_long_size = calc_log_long_size();
std::vector<uint8_t> buf;
buf.reserve(1024); // Pre-allocate to avoid measuring allocation
std::vector<BenchResult> results;
// --- Varint encoding ---
printf("--- Running Benchmarks ---\n\n");
results.push_back(benchmark("varint_mix (old/push_back)", varint_size, [&] { bench_varint_old(buf); }));
results.push_back(benchmark("varint_mix (new/pointer)", varint_size, [&] { bench_varint_new(buf, varint_size); }));
// --- String encoding ---
results.push_back(benchmark("strings_mix (old/push_back)", strings_size, [&] { bench_strings_old(buf); }));
results.push_back(
benchmark("strings_mix (new/pointer)", strings_size, [&] { bench_strings_new(buf, strings_size); }));
// --- Fixed32 encoding ---
results.push_back(benchmark("fixed32_x10 (old/push_back)", fixed32_size, [&] { bench_fixed32_old(buf); }));
results.push_back(
benchmark("fixed32_x10 (new/pointer)", fixed32_size, [&] { bench_fixed32_new(buf, fixed32_size); }));
// --- SensorStateResponse ---
results.push_back(benchmark("sensor_state (old/push_back)", sensor_state_size, [&] { bench_sensor_state_old(buf); }));
results.push_back(benchmark("sensor_state (new/pointer)", sensor_state_size,
[&] { bench_sensor_state_new(buf, sensor_state_size); }));
// --- ListEntitiesSensorResponse ---
results.push_back(
benchmark("list_entities (old/push_back)", list_entities_size, [&] { bench_list_entities_old(buf); }));
results.push_back(benchmark("list_entities (new/pointer)", list_entities_size,
[&] { bench_list_entities_new(buf, list_entities_size); }));
// --- BLE batch ---
results.push_back(benchmark("ble_batch_x8 (old/push_back)", ble_batch_size, [&] { bench_ble_batch_old(buf); }));
results.push_back(
benchmark("ble_batch_x8 (new/pointer)", ble_batch_size, [&] { bench_ble_batch_new(buf, ble_batch_size); }));
// --- Log messages ---
results.push_back(benchmark("log_short (old/push_back)", log_msg_size, [&] { bench_log_msg_old(buf); }));
results.push_back(benchmark("log_short (new/pointer)", log_msg_size, [&] { bench_log_msg_new(buf, log_msg_size); }));
results.push_back(benchmark("log_long (old/push_back)", log_long_size, [&] { bench_log_long_old(buf); }));
results.push_back(
benchmark("log_long (new/pointer)", log_long_size, [&] { bench_log_long_new(buf, log_long_size); }));
// --- Full encode cycle (calculate_size + resize + encode) ---
results.push_back(
benchmark("full_cycle_sensor (old/push_back)", sensor_state_size, [&] { bench_full_cycle_sensor_old(buf); }));
results.push_back(
benchmark("full_cycle_sensor (new/pointer)", sensor_state_size, [&] { bench_full_cycle_sensor_new(buf); }));
// Print all results
printf("\n--- Results ---\n\n");
print_results(results);
// Print comparison summary
printf("\n--- Speedup Summary (new vs old) ---\n\n");
for (size_t i = 0; i + 1 < results.size(); i += 2) {
print_comparison(results[i].name, results[i], results[i + 1]);
}
printf("\n--- Encoded Sizes ---\n\n");
printf(" varint_mix: %3zu bytes\n", varint_size);
printf(" strings_mix: %3zu bytes\n", strings_size);
printf(" fixed32_x10: %3zu bytes\n", fixed32_size);
printf(" sensor_state: %3zu bytes\n", sensor_state_size);
printf(" list_entities: %3zu bytes\n", list_entities_size);
printf(" ble_batch_x8: %3zu bytes\n", ble_batch_size);
printf(" log_short: %3zu bytes\n", log_msg_size);
printf(" log_long: %3zu bytes\n", log_long_size);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink