/*
 * Copyright 2016 Google Inc. All Rights Reserved.
 *
 * 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 <algorithm>
#include <map>
#include <sstream>
#include <string>
#include <vector>

#include "nb/allocator.h"
#include "nb/fixed_no_free_allocator.h"
#include "nb/reuse_allocator.h"
#include "starboard/client_porting/wrap_main/wrap_main.h"
#include "starboard/event.h"
#include "starboard/file.h"
#include "starboard/log.h"
#include "starboard/memory.h"
#include "starboard/system.h"
#include "starboard/time.h"
#include "starboard/types.h"

namespace {

inline bool IsAligned(void* ptr, std::size_t boundary) {
  uintptr_t ptr_as_int = reinterpret_cast<uintptr_t>(ptr);
  return ptr_as_int % boundary == 0;
}

// An allocation or free.
// We use 'id' rather than raw pointer since the pointer values are
// meaningless across runs.
struct AllocationCommand {
  uint32_t id;
  uint32_t size;
  uint32_t alignment;
};

std::string ReadFileContent(const std::string& pathname) {
  SB_DLOG(ERROR) << pathname;
  SbFile file =
      SbFileOpen(pathname.c_str(), kSbFileOpenOnly | kSbFileRead, NULL, NULL);
  SB_DCHECK(SbFileIsValid(file));
  SbFileInfo file_info;
  bool result = SbFileGetInfo(file, &file_info);
  SB_DCHECK(result);

  std::vector<char> buffer(file_info.size);
  int bytes_read = SbFileRead(file, &buffer[0], buffer.size());
  SB_DCHECK(bytes_read == file_info.size);
  SbFileClose(file);

  return std::string(buffer.begin(), buffer.end());
}

void LoadAllocationPlayback(std::vector<AllocationCommand>* commands,
                            const std::string& filename) {
  char buffer[SB_FILE_MAX_NAME * 16];
  bool result = SbSystemGetPath(kSbSystemPathSourceDirectory, buffer,
                                SB_ARRAY_SIZE(buffer));
  SB_DCHECK(result);
  std::string path_name = buffer;
  path_name += SB_FILE_SEP_CHAR;
  path_name += "nb";
  path_name += SB_FILE_SEP_CHAR;
  path_name += "testdata";
  path_name += SB_FILE_SEP_CHAR;
  path_name += filename;

  std::map<uint64_t, uint32_t> address_map;
  // Parse each line of this playback file.
  // Each line is a 64-bit hex address, and a 32-bit size and alignment.
  std::stringstream file_stream(ReadFileContent(path_name));

  std::string line;
  int address_id_counter = 0;
  while (std::getline(file_stream, line)) {
    if (!line.empty() && *line.rbegin() == '\n') {
      line.resize(line.size() - 1);
    }
    // Skip empty lines and comments.
    if (line.empty() || line[0] == '#') {
      continue;
    }

    uint64_t address;
    uint32_t size;
    uint32_t alignment;
    std::stringstream line_stream(line);
    line_stream << std::hex;
    line_stream >> address;
    line_stream << std::dec;
    line_stream >> size >> alignment;
    SB_DCHECK(address != 0);
    // Convert the addresses into unique IDs. We don't
    // really care what the values are, just need to match up
    // allocations with frees.
    int cur_address_id;
    std::map<uint64_t, uint32_t>::iterator it = address_map.find(address);
    if (it != address_map.end()) {
      cur_address_id = (*it).second;
    } else {
      cur_address_id = address_id_counter++;
      address_map[address] = cur_address_id;
    }

    AllocationCommand cmd;
    cmd.id = cur_address_id;
    cmd.size = size;
    cmd.alignment = alignment;
    commands->push_back(cmd);
  }
}

void ReplayCommands(nb::Allocator* allocator,
                    const std::vector<AllocationCommand>& commands,
                    SbTimeMonotonic* elapsed_time,
                    std::size_t* actual_bytes_used,
                    std::size_t* actual_high_water_mark,
                    std::size_t* allocator_bytes_used) {
  SbTimeMonotonic start = SbTimeGetMonotonicNow();
  // Execute each command in commands vector.
  // Record total bytes allocated and report.

  // Map from allocation IDs to pointers returned by the allocator.
  std::map<uint32_t, void*> address_table;
  // Map from allocation IDs to size requested.
  std::map<uint32_t, std::size_t> size_table;
  // How many bytes have we actually requested.
  std::size_t cur_bytes_allocated = 0;

  for (std::vector<AllocationCommand>::const_iterator iter = commands.begin();
       iter != commands.end(); ++iter) {
    const AllocationCommand& cmd = *iter;
    bool is_free = cmd.size == 0 && cmd.alignment == 0;
    if (!is_free) {
      void* ptr = allocator->Allocate(cmd.size, cmd.alignment);
      SB_DCHECK(IsAligned(ptr, cmd.alignment));
      cur_bytes_allocated += cmd.size;
      *actual_high_water_mark =
          std::max(*actual_high_water_mark, cur_bytes_allocated);
      size_table[cmd.id] = cmd.size;
      SB_DCHECK(address_table.find(cmd.id) == address_table.end());
      address_table[cmd.id] = ptr;
    } else {
      std::map<uint32_t, void*>::iterator it = address_table.find(cmd.id);
      SB_DCHECK(it != address_table.end());
      void* ptr = it->second;
      allocator->Free(ptr);
      cur_bytes_allocated -= size_table[cmd.id];
      address_table.erase(it);
    }
  }
  SbTimeMonotonic end = SbTimeGetMonotonicNow();
  *elapsed_time = end - start;
  *actual_bytes_used = cur_bytes_allocated;
  *allocator_bytes_used = allocator->GetAllocated();

  // Free any remaining allocations.
  for (std::map<uint32_t, void*>::iterator it = address_table.begin();
       it != address_table.end(); ++it) {
    allocator->Free(it->second);
  }
}

class DefaultAllocator : public nb::Allocator {
 public:
  void* Allocate(std::size_t size) SB_OVERRIDE { return Allocate(size, 0); }
  void* Allocate(std::size_t size, std::size_t alignment) SB_OVERRIDE {
    return SbMemoryAllocateAligned(alignment, size);
  }
  void Free(void* memory) SB_OVERRIDE { SbMemoryDeallocate(memory); }
  std::size_t GetCapacity() const SB_OVERRIDE { return 0; }
  std::size_t GetAllocated() const SB_OVERRIDE { return 0; }
  void PrintAllocations() const SB_OVERRIDE {}
};

void MemoryPlaybackTest(const std::string& filename) {
  const std::size_t kFixedNoFreeMemorySize = 512 * 1024 * 1024;
  void* fixed_no_free_memory = SbMemoryAllocate(kFixedNoFreeMemorySize);
  nb::FixedNoFreeAllocator fallback_allocator(fixed_no_free_memory,
                                              kFixedNoFreeMemorySize);
  nb::ReuseAllocator reuse_allocator(&fallback_allocator);

  std::vector<AllocationCommand> commands;
  LoadAllocationPlayback(&commands, filename);

  std::size_t actual_bytes_used = 0;
  std::size_t actual_high_water_mark = 0;
  std::size_t allocator_bytes_used = 0;
  SbTimeMonotonic elapsed_time;
  ReplayCommands(&reuse_allocator, commands, &elapsed_time, &actual_bytes_used,
                 &actual_high_water_mark, &allocator_bytes_used);
  std::size_t allocator_high_water_mark = reuse_allocator.GetCapacity();
  SB_DLOG(INFO) << "Actual used: " << actual_bytes_used;
  SB_DLOG(INFO) << "Actual high water mark: " << actual_high_water_mark;
  SB_DLOG(INFO) << "Allocator used: " << allocator_bytes_used;
  SB_DLOG(INFO) << "Allocator high water mark: " << allocator_high_water_mark;
  SB_DLOG(INFO) << "Elapsed (ms): " << elapsed_time / kSbTimeMillisecond;

  SbMemoryDeallocate(fixed_no_free_memory);

  // Test again using the system allocator, to compare performance.
  DefaultAllocator default_allocator;
  ReplayCommands(&default_allocator, commands, &elapsed_time,
                 &actual_bytes_used, &actual_high_water_mark,
                 &allocator_bytes_used);
  SB_DLOG(INFO) << "Default allocator elapsed (ms): "
                << elapsed_time / kSbTimeMillisecond;
}

int BenchmarkMain(int argc, char** argv) {
  const char* kBenchmarks[] = {
      "mem_history_cobalt.txt", "mem_history_gpu.txt", "mem_history_main.txt",
  };

  for (std::size_t i = 0; i < SB_ARRAY_SIZE(kBenchmarks); ++i) {
    SB_DLOG(INFO) << "Memory playback test: " << kBenchmarks[i];
    MemoryPlaybackTest(kBenchmarks[i]);
  }

  return 0;
}

}  // namespace

STARBOARD_WRAP_SIMPLE_MAIN(BenchmarkMain);