#include "source/common/memory/stats.h"

#include <atomic>

#include <cstdint>

#include "source/common/common/assert.h"

#include "source/common/common/logger.h"

#if defined(TCMALLOC)

#include "tcmalloc/malloc_extension.h"

#elif defined(GPERFTOOLS_TCMALLOC)

#include "gperftools/malloc_extension.h"

#endif

namespace Envoy {

namespace Memory {

namespace {

std::atomic<uint64_t> max_unfreed_memory_bytes{DEFAULT_MAX_UNFREED_MEMORY_BYTES};

} // namespace

#if defined(TCMALLOC)

  return tcmalloc::MallocExtension::GetNumericProperty("generic.current_allocated_bytes")

      .value_or(0);

#elif defined(GPERFTOOLS_TCMALLOC)

  size_t value = 0;

#else

  return 0;

#endif

#if defined(TCMALLOC)

  // In Google's tcmalloc the semantics of generic.heap_size has

  // changed: it doesn't include unmapped bytes.

  return tcmalloc::MallocExtension::GetNumericProperty("generic.heap_size").value_or(0) +

         tcmalloc::MallocExtension::GetNumericProperty("tcmalloc.pageheap_unmapped_bytes")

             .value_or(0);

#elif defined(GPERFTOOLS_TCMALLOC)

  size_t value = 0;

#else

  return 0;

#endif

#if defined(TCMALLOC)

  return tcmalloc::MallocExtension::GetNumericProperty("tcmalloc.current_total_thread_cache_bytes")

      .value_or(0);

#elif defined(GPERFTOOLS_TCMALLOC)

  size_t value = 0;

#else

  return 0;

#endif

#if defined(TCMALLOC)

  return tcmalloc::MallocExtension::GetNumericProperty("tcmalloc.pageheap_free_bytes").value_or(0);

#elif defined(GPERFTOOLS_TCMALLOC)

  size_t value = 0;

#else

  return 0;

#endif

#if defined(TCMALLOC)

  return tcmalloc::MallocExtension::GetNumericProperty("tcmalloc.pageheap_unmapped_bytes")

      .value_or(0);

#elif defined(GPERFTOOLS_TCMALLOC)

  size_t value = 0;

#else

  return 0;

#endif

#if defined(TCMALLOC)

  return tcmalloc::MallocExtension::GetProperties()["generic.physical_memory_used"].value;

#elif defined(GPERFTOOLS_TCMALLOC)

  size_t value = 0;

#else

  return 0;

#endif

#if defined(TCMALLOC)

  ENVOY_LOG_MISC(debug, "TCMalloc stats:\n{}", tcmalloc::MallocExtension::GetStats());

#elif defined(GPERFTOOLS_TCMALLOC)

  constexpr int buffer_size = 100000;

#else

  return;

#endif

#if defined(TCMALLOC)

  return tcmalloc::MallocExtension::GetStats();

#elif defined(GPERFTOOLS_TCMALLOC)

  constexpr int buffer_size = 100000;

#else

  return absl::nullopt;

#endif

namespace {

/**

 * Computes the background release rate in bytes per second from the configured bytes_to_release

 * and memory_release_interval.

 */

size_t computeBackgroundReleaseRate(uint64_t bytes_to_release,

} // namespace

AllocatorManager::AllocatorManager(

    Api::Api& api, const envoy::config::bootstrap::v3::MemoryAllocatorManager& config)

      background_release_rate_bytes_per_second_(

#if defined(TCMALLOC)

  if (tcmalloc_thread_) {

    // Signal the ProcessBackgroundActions loop to exit and wait for the thread to finish.

    tcmalloc::MallocExtension::SetBackgroundProcessActionsEnabled(false);

    tcmalloc_thread_->join();

    tcmalloc_thread_.reset();

    // Reset the release rate and re-enable background actions so that a subsequent

    // AllocatorManager instance can start fresh.

    tcmalloc::MallocExtension::SetBackgroundReleaseRate(

        tcmalloc::MallocExtension::BytesPerSecond{0});

    tcmalloc::MallocExtension::SetBackgroundProcessActionsEnabled(true);

  }

#endif

void AllocatorManager::configureTcmallocOptions(

#if defined(TCMALLOC)

  if (config.has_soft_memory_limit_bytes()) {

    tcmalloc::MallocExtension::SetMemoryLimit(config.soft_memory_limit_bytes().value(),

                                              tcmalloc::MallocExtension::LimitKind::kSoft);

    ENVOY_LOG_MISC(info, "Set tcmalloc soft memory limit to {} bytes.",

                   config.soft_memory_limit_bytes().value());

  }

  if (config.has_max_per_cpu_cache_size_bytes()) {

    tcmalloc::MallocExtension::SetMaxPerCpuCacheSize(config.max_per_cpu_cache_size_bytes().value());

    ENVOY_LOG_MISC(info, "Set tcmalloc max per-CPU cache size to {} bytes.",

                   config.max_per_cpu_cache_size_bytes().value());

  }

#else

/**

 * Configures tcmalloc to use its native ProcessBackgroundActions for background memory

 * maintenance. This enables comprehensive memory management including per-CPU cache reclamation,

 * cache shuffling, size class resizing, transfer cache plundering, and memory release at the

 * configured rate. If `bytes_to_release_` is `0`, no background processing will be started.

 */

#elif defined(TCMALLOC)

  ENVOY_BUG(!tcmalloc_thread_, "Invalid state, tcmalloc has already been initialised.");

  if (bytes_to_release_ > 0) {

    if (!tcmalloc::MallocExtension::NeedsProcessBackgroundActions()) {

      ENVOY_LOG_MISC(warn, "This platform does not support tcmalloc background actions.");

      return;

    }

    tcmalloc::MallocExtension::SetBackgroundReleaseRate(

        tcmalloc::MallocExtension::BytesPerSecond{background_release_rate_bytes_per_second_});

    tcmalloc_thread_ = api_.threadFactory().createThread(

        []() -> void {

          ENVOY_LOG_MISC(debug, "Started {}.", TCMALLOC_ROUTINE_THREAD_ID);

          // ProcessBackgroundActions runs an infinite loop that handles all tcmalloc background

          // maintenance including cache reclamation and memory release. It returns only when

          // SetBackgroundProcessActionsEnabled(false) is called.

          tcmalloc::MallocExtension::ProcessBackgroundActions();

        },

        Thread::Options{std::string(TCMALLOC_ROUTINE_THREAD_ID)});

    ENVOY_LOG_MISC(info, "Configured tcmalloc with background release rate: {} bytes per second.",

                   background_release_rate_bytes_per_second_);

  }

#endif

} // namespace Memory

} // namespace Envoy