// Copyright (C) 2022 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <random>

#include <benchmark/benchmark.h>

#include "src/trace_processor/db/column_storage_overlay.h"

using perfetto::trace_processor::BitVector;
using perfetto::trace_processor::ColumnStorageOverlay;
using perfetto::trace_processor::RowMap;

namespace {

static constexpr uint32_t kPoolSize = 100000;
static constexpr uint32_t kSize = 123456;

template <typename Container>
Container CreateRange(uint32_t end) {
  static constexpr uint32_t kRandomSeed = 32;
  std::minstd_rand0 rnd_engine(kRandomSeed);

  uint32_t start = rnd_engine() % end;
  uint32_t size = rnd_engine() % (end - start);
  return Container(start, start + size);
}

std::vector<uint32_t> CreateIndexVector(uint32_t size, uint32_t mod) {
  static constexpr uint32_t kRandomSeed = 476;
  std::minstd_rand0 rnd_engine(kRandomSeed);
  std::vector<uint32_t> rows(size);
  for (uint32_t i = 0; i < size; ++i) {
    rows[i] = rnd_engine() % mod;
  }
  return rows;
}

BitVector CreateBitVector(uint32_t size) {
  static constexpr uint32_t kRandomSeed = 42;
  std::minstd_rand0 rnd_engine(kRandomSeed);
  BitVector bv;
  for (uint32_t i = 0; i < size; ++i) {
    if (rnd_engine() % 2) {
      bv.AppendTrue();
    } else {
      bv.AppendFalse();
    }
  }
  return bv;
}

template <typename Factory>
void BenchFilterInto(benchmark::State& state,
                     ColumnStorageOverlay rm,
                     Factory factory) {
  auto pool_vec = CreateIndexVector(kPoolSize, kSize);

  uint32_t pool_idx = 0;
  for (auto _ : state) {
    state.PauseTiming();
    RowMap out = factory();
    state.ResumeTiming();

    auto fn = [&pool_vec, pool_idx](uint32_t row) {
      return pool_vec[pool_idx] != 0 && (row % pool_vec[pool_idx]) != 0;
    };
    rm.FilterInto(&out, fn);
    pool_idx = (pool_idx + 1) % kPoolSize;

    benchmark::ClobberMemory();
  }
}

}  // namespace

static void BM_CSOFilterIntoRangeWithRange(benchmark::State& state) {
  ColumnStorageOverlay overlay(CreateRange<ColumnStorageOverlay>(kSize));
  uint32_t overlay_size = overlay.size();
  BenchFilterInto(state, std::move(overlay), [overlay_size]() {
    return CreateRange<RowMap>(overlay_size);
  });
}
BENCHMARK(BM_CSOFilterIntoRangeWithRange);

static void BM_CSOFilterIntoRangeWithBv(benchmark::State& state) {
  ColumnStorageOverlay overlay(CreateRange<ColumnStorageOverlay>(kSize));
  uint32_t overlay_size = overlay.size();
  BenchFilterInto(state, std::move(overlay), [overlay_size]() {
    return RowMap(CreateBitVector(overlay_size));
  });
}
BENCHMARK(BM_CSOFilterIntoRangeWithBv);

static void BM_CSOFilterIntoBvWithRange(benchmark::State& state) {
  ColumnStorageOverlay overlay(CreateBitVector(kSize));
  uint32_t overlay_size = overlay.size();
  BenchFilterInto(state, std::move(overlay), [overlay_size]() {
    return CreateRange<RowMap>(overlay_size);
  });
}
BENCHMARK(BM_CSOFilterIntoBvWithRange);

static void BM_CSOFilterIntoBvWithBv(benchmark::State& state) {
  ColumnStorageOverlay overlay(CreateBitVector(kSize));
  uint32_t overlay_size = overlay.size();
  BenchFilterInto(state, std::move(overlay), [overlay_size]() {
    return RowMap(CreateBitVector(overlay_size));
  });
}
BENCHMARK(BM_CSOFilterIntoBvWithBv);

static void BM_CSOFilterIntoIvWithRange(benchmark::State& state) {
  ColumnStorageOverlay overlay(CreateIndexVector(kSize, kSize));
  uint32_t overlay_size = overlay.size();
  BenchFilterInto(state, std::move(overlay), [overlay_size]() {
    return CreateRange<RowMap>(overlay_size);
  });
}
BENCHMARK(BM_CSOFilterIntoIvWithRange);

static void BM_CSOFilterIntoIvWithBv(benchmark::State& state) {
  ColumnStorageOverlay overlay(CreateIndexVector(kSize, kSize));
  uint32_t overlay_size = overlay.size();
  BenchFilterInto(state, std::move(overlay), [overlay_size]() {
    return RowMap(CreateBitVector(overlay_size));
  });
}
BENCHMARK(BM_CSOFilterIntoIvWithBv);