| // Copyright 2020 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Benchmarks for a reference encoder / decoder specialized to |
| // Table1Struct, Table16Struct and Table256Struct as defined in |
| // the fidl benchmark suite. |
| |
| #include <algorithm> |
| #include <cstdint> |
| |
| #include "builder.h" |
| #include "decode_benchmark_util.h" |
| #include "encode_benchmark_util.h" |
| #include "util.h" |
| |
| #ifdef __Fuchsia__ |
| #include <zircon/syscalls.h> |
| #endif |
| |
| #include <lib/fit/function.h> |
| |
| namespace { |
| |
| template <size_t N> |
| bool EncodeUint8TableStruct(void* value, const char** error, |
| fit::function<void(const uint8_t*, size_t)> callback) { |
| uint8_t out_buf[sizeof(fidl_vector_t) + sizeof(fidl_envelope_t) * N + 8 * N]; |
| uint8_t* next = out_buf; |
| |
| fidl_vector_t* table_vec = reinterpret_cast<fidl_vector_t*>(value); |
| size_t count = CLEAR_COUNT_OWNERSHIP_BIT(table_vec->count); |
| void* data = CLEAR_PTR_OWNERSHIP_BIT(table_vec->data); |
| if (unlikely(data == nullptr && count != 0)) { |
| *error = "table with null data had non-zero element count"; |
| return false; |
| } |
| *reinterpret_cast<fidl_vector_t*>(next) = fidl_vector_t{ |
| .count = count, |
| .data = reinterpret_cast<void*>(FIDL_ALLOC_PRESENT), |
| }; |
| next += sizeof(fidl_vector_t); |
| |
| fidl_envelope_t* start_envelopes = reinterpret_cast<fidl_envelope_t*>(data); |
| fidl_envelope_t* end_envelopes = start_envelopes + count; |
| uint64_t* next_out_of_line = reinterpret_cast<uint64_t*>(next + count * sizeof(fidl_envelope_t)); |
| |
| for (fidl_envelope_t* envelope = start_envelopes; envelope < end_envelopes; envelope++) { |
| if (envelope->data == nullptr) { |
| *reinterpret_cast<fidl_envelope_t*>(next) = fidl_envelope_t{ |
| .num_bytes = 0, |
| .num_handles = 0, |
| // This doesn't compile when FIDL_ALLOC_ABSENT is used in place of 0. |
| .presence = 0, |
| }; |
| } else { |
| *reinterpret_cast<fidl_envelope_t*>(next) = fidl_envelope_t{ |
| .num_bytes = 8, |
| .num_handles = 0, |
| .presence = FIDL_ALLOC_PRESENT, |
| }; |
| *next_out_of_line = *reinterpret_cast<uint8_t*>(CLEAR_PTR_OWNERSHIP_BIT(envelope->data)); |
| next_out_of_line++; |
| } |
| next += sizeof(fidl_vector_t); |
| } |
| |
| callback(out_buf, static_cast<size_t>(reinterpret_cast<uint8_t*>(next_out_of_line) - out_buf)); |
| return true; |
| } |
| |
| template <size_t N> |
| bool DecodeUint8TableStruct(uint8_t* bytes, size_t bytes_size, zx_handle_t* handles, |
| size_t handles_size, const char** error) { |
| if (handles_size != 0) { |
| *error = "no handles expected"; |
| return false; |
| } |
| |
| fidl_vector_t* table_vec = reinterpret_cast<fidl_vector_t*>(bytes); |
| if (unlikely(table_vec->data == nullptr && table_vec->count != 0)) { |
| *error = "table with null data had non-zero element count"; |
| return false; |
| } |
| |
| fidl_envelope_t* start_envelopes = |
| reinterpret_cast<fidl_envelope_t*>(bytes + sizeof(fidl_vector_t)); |
| table_vec->data = start_envelopes; |
| fidl_envelope_t* end_known_envelopes = start_envelopes + std::min(N, table_vec->count); |
| fidl_envelope_t* end_all_envelopes = start_envelopes + table_vec->count; |
| |
| uint8_t* next_out_of_line = reinterpret_cast<uint8_t*>(end_all_envelopes); |
| if (unlikely(reinterpret_cast<uint8_t*>(next_out_of_line) - bytes > int64_t(bytes_size))) { |
| *error = "byte size exceeds available size"; |
| return false; |
| } |
| |
| for (fidl_envelope_t* envelope = start_envelopes; envelope != end_known_envelopes; envelope++) { |
| if (unlikely(envelope->num_handles != 0)) { |
| *error = "incorrect num_handles in envelope"; |
| return false; |
| } |
| if (envelope->data == nullptr) { |
| if (unlikely(envelope->num_bytes != 0)) { |
| *error = "incorrect num_bytes in envelope"; |
| return false; |
| } |
| } else { |
| if (unlikely(envelope->num_bytes != 8)) { |
| *error = "incorrect num_bytes in envelope"; |
| return false; |
| } |
| if (unlikely((*reinterpret_cast<uint64_t*>(next_out_of_line) & 0xffffffffffffff00) != 0)) { |
| *error = "invalid padding byte"; |
| return false; |
| } |
| envelope->data = next_out_of_line; |
| next_out_of_line += 8; |
| if (unlikely(reinterpret_cast<uint8_t*>(next_out_of_line) - bytes > int64_t(bytes_size))) { |
| *error = "byte size exceeds available size"; |
| return false; |
| } |
| } |
| } |
| |
| // Unknown envelopes |
| uint32_t num_handles = 0; |
| for (fidl_envelope_t* envelope = end_known_envelopes; envelope != end_all_envelopes; envelope++) { |
| if (envelope->data == nullptr) { |
| if (unlikely(envelope->num_bytes != 0)) { |
| *error = "incorrect num_bytes in envelope"; |
| return false; |
| } |
| if (unlikely(envelope->num_handles != 0)) { |
| *error = "incorrect num_handles in envelope"; |
| return false; |
| } |
| } else { |
| size_t aligned_bytes = envelope->num_bytes; |
| if (unlikely(!FidlIsAligned(reinterpret_cast<uint8_t*>(aligned_bytes)))) { |
| *error = "incorrect num_bytes in envelope"; |
| return false; |
| } |
| num_handles += envelope->num_handles; |
| envelope->data = next_out_of_line; |
| next_out_of_line += aligned_bytes; |
| if (unlikely(reinterpret_cast<uint8_t*>(next_out_of_line) - bytes > int64_t(bytes_size))) { |
| *error = "byte size exceeds available size"; |
| return false; |
| } |
| } |
| } |
| #ifdef __Fuchsia__ |
| zx_handle_close_many(handles, num_handles); |
| #endif |
| return true; |
| } |
| |
| bool BenchmarkEncodeTableAllSet1(perftest::RepeatState* state) { |
| return encode_benchmark_util::EncodeBenchmark(state, benchmark_suite::Build_Table_AllSet_1, |
| EncodeUint8TableStruct<1>); |
| } |
| bool BenchmarkEncodeTableAllSet16(perftest::RepeatState* state) { |
| return encode_benchmark_util::EncodeBenchmark(state, benchmark_suite::Build_Table_AllSet_16, |
| EncodeUint8TableStruct<16>); |
| } |
| bool BenchmarkEncodeTableAllSet256(perftest::RepeatState* state) { |
| return encode_benchmark_util::EncodeBenchmark(state, benchmark_suite::Build_Table_AllSet_256, |
| EncodeUint8TableStruct<256>); |
| } |
| bool BenchmarkEncodeTableUnset1(perftest::RepeatState* state) { |
| return encode_benchmark_util::EncodeBenchmark(state, benchmark_suite::Build_Table_Unset_1, |
| EncodeUint8TableStruct<1>); |
| } |
| bool BenchmarkEncodeTableUnset16(perftest::RepeatState* state) { |
| return encode_benchmark_util::EncodeBenchmark(state, benchmark_suite::Build_Table_Unset_16, |
| EncodeUint8TableStruct<16>); |
| } |
| bool BenchmarkEncodeTableUnset256(perftest::RepeatState* state) { |
| return encode_benchmark_util::EncodeBenchmark(state, benchmark_suite::Build_Table_Unset_256, |
| EncodeUint8TableStruct<256>); |
| } |
| bool BenchmarkEncodeTableSingleSet_1_of_1(perftest::RepeatState* state) { |
| return encode_benchmark_util::EncodeBenchmark( |
| state, benchmark_suite::Build_Table_SingleSet_1_of_1, EncodeUint8TableStruct<1>); |
| } |
| bool BenchmarkEncodeTableSingleSet_1_of_16(perftest::RepeatState* state) { |
| return encode_benchmark_util::EncodeBenchmark( |
| state, benchmark_suite::Build_Table_SingleSet_1_of_16, EncodeUint8TableStruct<16>); |
| } |
| bool BenchmarkEncodeTableSingleSet_16_of_16(perftest::RepeatState* state) { |
| return encode_benchmark_util::EncodeBenchmark( |
| state, benchmark_suite::Build_Table_SingleSet_16_of_16, EncodeUint8TableStruct<16>); |
| } |
| bool BenchmarkEncodeTableSingleSet_1_of_256(perftest::RepeatState* state) { |
| return encode_benchmark_util::EncodeBenchmark( |
| state, benchmark_suite::Build_Table_SingleSet_1_of_256, EncodeUint8TableStruct<256>); |
| } |
| bool BenchmarkEncodeTableSingleSet_16_of_256(perftest::RepeatState* state) { |
| return encode_benchmark_util::EncodeBenchmark( |
| state, benchmark_suite::Build_Table_SingleSet_16_of_256, EncodeUint8TableStruct<256>); |
| } |
| bool BenchmarkEncodeTableSingleSet_256_of_256(perftest::RepeatState* state) { |
| return encode_benchmark_util::EncodeBenchmark( |
| state, benchmark_suite::Build_Table_SingleSet_256_of_256, EncodeUint8TableStruct<256>); |
| } |
| bool BenchmarkDecodeTableAllSet1(perftest::RepeatState* state) { |
| return decode_benchmark_util::DecodeBenchmark(state, benchmark_suite::Build_Table_AllSet_1, |
| DecodeUint8TableStruct<1>); |
| } |
| bool BenchmarkDecodeTableAllSet16(perftest::RepeatState* state) { |
| return decode_benchmark_util::DecodeBenchmark(state, benchmark_suite::Build_Table_AllSet_16, |
| DecodeUint8TableStruct<16>); |
| } |
| bool BenchmarkDecodeTableAllSet256(perftest::RepeatState* state) { |
| return decode_benchmark_util::DecodeBenchmark(state, benchmark_suite::Build_Table_AllSet_256, |
| DecodeUint8TableStruct<256>); |
| } |
| bool BenchmarkDecodeTableUnset1(perftest::RepeatState* state) { |
| return decode_benchmark_util::DecodeBenchmark(state, benchmark_suite::Build_Table_Unset_1, |
| DecodeUint8TableStruct<1>); |
| } |
| bool BenchmarkDecodeTableUnset16(perftest::RepeatState* state) { |
| return decode_benchmark_util::DecodeBenchmark(state, benchmark_suite::Build_Table_Unset_16, |
| DecodeUint8TableStruct<16>); |
| } |
| bool BenchmarkDecodeTableUnset256(perftest::RepeatState* state) { |
| return decode_benchmark_util::DecodeBenchmark(state, benchmark_suite::Build_Table_Unset_256, |
| DecodeUint8TableStruct<256>); |
| } |
| bool BenchmarkDecodeTableSingleSet_1_of_1(perftest::RepeatState* state) { |
| return decode_benchmark_util::DecodeBenchmark( |
| state, benchmark_suite::Build_Table_SingleSet_1_of_1, DecodeUint8TableStruct<1>); |
| } |
| bool BenchmarkDecodeTableSingleSet_1_of_16(perftest::RepeatState* state) { |
| return decode_benchmark_util::DecodeBenchmark( |
| state, benchmark_suite::Build_Table_SingleSet_1_of_16, DecodeUint8TableStruct<16>); |
| } |
| bool BenchmarkDecodeTableSingleSet_16_of_16(perftest::RepeatState* state) { |
| return decode_benchmark_util::DecodeBenchmark( |
| state, benchmark_suite::Build_Table_SingleSet_16_of_16, DecodeUint8TableStruct<16>); |
| } |
| bool BenchmarkDecodeTableSingleSet_1_of_256(perftest::RepeatState* state) { |
| return decode_benchmark_util::DecodeBenchmark( |
| state, benchmark_suite::Build_Table_SingleSet_1_of_256, DecodeUint8TableStruct<256>); |
| } |
| bool BenchmarkDecodeTableSingleSet_16_of_256(perftest::RepeatState* state) { |
| return decode_benchmark_util::DecodeBenchmark( |
| state, benchmark_suite::Build_Table_SingleSet_16_of_256, DecodeUint8TableStruct<256>); |
| } |
| bool BenchmarkDecodeTableSingleSet_256_of_256(perftest::RepeatState* state) { |
| return decode_benchmark_util::DecodeBenchmark( |
| state, benchmark_suite::Build_Table_SingleSet_256_of_256, DecodeUint8TableStruct<256>); |
| } |
| |
| void RegisterTests() { |
| perftest::RegisterTest("Reference/Encode/Table/AllSet/1/Steps", BenchmarkEncodeTableAllSet1); |
| perftest::RegisterTest("Reference/Encode/Table/AllSet/16/Steps", BenchmarkEncodeTableAllSet16); |
| perftest::RegisterTest("Reference/Encode/Table/AllSet/256/Steps", BenchmarkEncodeTableAllSet256); |
| perftest::RegisterTest("Reference/Encode/Table/Unset/1/Steps", BenchmarkEncodeTableUnset1); |
| perftest::RegisterTest("Reference/Encode/Table/Unset/16/Steps", BenchmarkEncodeTableUnset16); |
| perftest::RegisterTest("Reference/Encode/Table/Unset/256/Steps", BenchmarkEncodeTableUnset256); |
| perftest::RegisterTest("Reference/Encode/Table/SingleSet/1_of_1/Steps", |
| BenchmarkEncodeTableSingleSet_1_of_1); |
| perftest::RegisterTest("Reference/Encode/Table/SingleSet/1_of_16/Steps", |
| BenchmarkEncodeTableSingleSet_1_of_16); |
| perftest::RegisterTest("Reference/Encode/Table/SingleSet/16_of_16/Steps", |
| BenchmarkEncodeTableSingleSet_16_of_16); |
| perftest::RegisterTest("Reference/Encode/Table/SingleSet/1_of_256/Steps", |
| BenchmarkEncodeTableSingleSet_1_of_256); |
| perftest::RegisterTest("Reference/Encode/Table/SingleSet/16_of_256/Steps", |
| BenchmarkEncodeTableSingleSet_16_of_256); |
| perftest::RegisterTest("Reference/Encode/Table/SingleSet/256_of_256/Steps", |
| BenchmarkEncodeTableSingleSet_256_of_256); |
| perftest::RegisterTest("Reference/Decode/Table/AllSet/1/Steps", BenchmarkDecodeTableAllSet1); |
| perftest::RegisterTest("Reference/Decode/Table/AllSet/16/Steps", BenchmarkDecodeTableAllSet16); |
| perftest::RegisterTest("Reference/Decode/Table/AllSet/256/Steps", BenchmarkDecodeTableAllSet256); |
| perftest::RegisterTest("Reference/Decode/Table/Unset/1/Steps", BenchmarkDecodeTableUnset1); |
| perftest::RegisterTest("Reference/Decode/Table/Unset/16/Steps", BenchmarkDecodeTableUnset16); |
| perftest::RegisterTest("Reference/Decode/Table/Unset/256/Steps", BenchmarkDecodeTableUnset256); |
| perftest::RegisterTest("Reference/Decode/Table/SingleSet/1_of_1/Steps", |
| BenchmarkDecodeTableSingleSet_1_of_1); |
| perftest::RegisterTest("Reference/Decode/Table/SingleSet/1_of_16/Steps", |
| BenchmarkDecodeTableSingleSet_1_of_16); |
| perftest::RegisterTest("Reference/Decode/Table/SingleSet/16_of_16/Steps", |
| BenchmarkDecodeTableSingleSet_16_of_16); |
| perftest::RegisterTest("Reference/Decode/Table/SingleSet/1_of_256/Steps", |
| BenchmarkDecodeTableSingleSet_1_of_256); |
| perftest::RegisterTest("Reference/Decode/Table/SingleSet/16_of_256/Steps", |
| BenchmarkDecodeTableSingleSet_16_of_256); |
| perftest::RegisterTest("Reference/Decode/Table/SingleSet/256_of_256/Steps", |
| BenchmarkDecodeTableSingleSet_256_of_256); |
| } |
| PERFTEST_CTOR(RegisterTests) |
| |
| } // namespace |
