// 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 Table63Struct as defined in
// the fidl benchmark suite.

#include <lib/fit/function.h>
#include <zircon/fidl.h>

#include <algorithm>
#include <cstdint>

#include "builder.h"
#include "decode_benchmark_util.h"
#include "encode_benchmark_util.h"

#ifdef __Fuchsia__
#include <zircon/syscalls.h>
#endif

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];
  fidl_vector_t* table_vec = reinterpret_cast<fidl_vector_t*>(value);
  size_t count = table_vec->count;
  void* data = 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*>(out_buf) = fidl_vector_t{
      .count = count,
      .data = reinterpret_cast<void*>(FIDL_ALLOC_PRESENT),
  };
  memcpy(out_buf + sizeof(fidl_vector_t), data, sizeof(fidl_envelope_t) * N);
  callback(out_buf, sizeof 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(next_out_of_line - bytes > static_cast<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 (unlikely(envelope->flags != FIDL_ENVELOPE_FLAGS_INLINING_MASK)) {
      *error = "invalid envelope flags";
      return false;
    }
  }

  // Unknown envelopes
  uint32_t num_handles = 0;
  for (fidl_envelope_t* envelope = end_known_envelopes; envelope != end_all_envelopes; envelope++) {
    uint16_t flags = envelope->flags;
    if (flags == FIDL_ENVELOPE_FLAGS_INLINING_MASK) {
      continue;
    }
    if (unlikely(flags != 0)) {
      *error = "invalid envelope flags";
      return false;
    }
    size_t num_bytes = envelope->num_bytes;
    if (unlikely(num_bytes % 8 != 0)) {
      *error = "incorrect num_bytes in envelope";
      return false;
    }
    num_handles += envelope->num_handles;
    auto envelope_as_ptr = reinterpret_cast<uint8_t**>(envelope);
    *envelope_as_ptr = next_out_of_line;
    next_out_of_line += num_bytes;
    if (unlikely(next_out_of_line - bytes > static_cast<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 BenchmarkEncodeTableAllSet63(perftest::RepeatState* state) {
  return encode_benchmark_util::EncodeBenchmark(state, benchmark_suite::Build_Table_AllSet_63,
                                                EncodeUint8TableStruct<63>);
}
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 BenchmarkEncodeTableUnset63(perftest::RepeatState* state) {
  return encode_benchmark_util::EncodeBenchmark(state, benchmark_suite::Build_Table_Unset_63,
                                                EncodeUint8TableStruct<63>);
}
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_63(perftest::RepeatState* state) {
  return encode_benchmark_util::EncodeBenchmark(
      state, benchmark_suite::Build_Table_SingleSet_1_of_63, EncodeUint8TableStruct<63>);
}
bool BenchmarkEncodeTableSingleSet_16_of_63(perftest::RepeatState* state) {
  return encode_benchmark_util::EncodeBenchmark(
      state, benchmark_suite::Build_Table_SingleSet_16_of_63, EncodeUint8TableStruct<63>);
}
bool BenchmarkEncodeTableSingleSet_63_of_63(perftest::RepeatState* state) {
  return encode_benchmark_util::EncodeBenchmark(
      state, benchmark_suite::Build_Table_SingleSet_63_of_63, EncodeUint8TableStruct<63>);
}
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 BenchmarkDecodeTableAllSet63(perftest::RepeatState* state) {
  return decode_benchmark_util::DecodeBenchmark(state, benchmark_suite::Build_Table_AllSet_63,
                                                DecodeUint8TableStruct<63>);
}
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 BenchmarkDecodeTableUnset63(perftest::RepeatState* state) {
  return decode_benchmark_util::DecodeBenchmark(state, benchmark_suite::Build_Table_Unset_63,
                                                DecodeUint8TableStruct<63>);
}
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_63(perftest::RepeatState* state) {
  return decode_benchmark_util::DecodeBenchmark(
      state, benchmark_suite::Build_Table_SingleSet_1_of_63, DecodeUint8TableStruct<63>);
}
bool BenchmarkDecodeTableSingleSet_16_of_63(perftest::RepeatState* state) {
  return decode_benchmark_util::DecodeBenchmark(
      state, benchmark_suite::Build_Table_SingleSet_16_of_63, DecodeUint8TableStruct<63>);
}
bool BenchmarkDecodeTableSingleSet_63_of_63(perftest::RepeatState* state) {
  return decode_benchmark_util::DecodeBenchmark(
      state, benchmark_suite::Build_Table_SingleSet_63_of_63, DecodeUint8TableStruct<63>);
}

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/63/Steps", BenchmarkEncodeTableAllSet63);
  perftest::RegisterTest("Reference/Encode/Table/Unset/1/Steps", BenchmarkEncodeTableUnset1);
  perftest::RegisterTest("Reference/Encode/Table/Unset/16/Steps", BenchmarkEncodeTableUnset16);
  perftest::RegisterTest("Reference/Encode/Table/Unset/63/Steps", BenchmarkEncodeTableUnset63);
  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_63/Steps",
                         BenchmarkEncodeTableSingleSet_1_of_63);
  perftest::RegisterTest("Reference/Encode/Table/SingleSet/16_of_63/Steps",
                         BenchmarkEncodeTableSingleSet_16_of_63);
  perftest::RegisterTest("Reference/Encode/Table/SingleSet/63_of_63/Steps",
                         BenchmarkEncodeTableSingleSet_63_of_63);
  perftest::RegisterTest("Reference/Decode/Table/AllSet/1/Steps", BenchmarkDecodeTableAllSet1);
  perftest::RegisterTest("Reference/Decode/Table/AllSet/16/Steps", BenchmarkDecodeTableAllSet16);
  perftest::RegisterTest("Reference/Decode/Table/AllSet/63/Steps", BenchmarkDecodeTableAllSet63);
  perftest::RegisterTest("Reference/Decode/Table/Unset/1/Steps", BenchmarkDecodeTableUnset1);
  perftest::RegisterTest("Reference/Decode/Table/Unset/16/Steps", BenchmarkDecodeTableUnset16);
  perftest::RegisterTest("Reference/Decode/Table/Unset/63/Steps", BenchmarkDecodeTableUnset63);
  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_63/Steps",
                         BenchmarkDecodeTableSingleSet_1_of_63);
  perftest::RegisterTest("Reference/Decode/Table/SingleSet/16_of_63/Steps",
                         BenchmarkDecodeTableSingleSet_16_of_63);
  perftest::RegisterTest("Reference/Decode/Table/SingleSet/63_of_63/Steps",
                         BenchmarkDecodeTableSingleSet_63_of_63);
}
PERFTEST_CTOR(RegisterTests)

}  // namespace