// Copyright 2021 the V8 project authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

#ifndef INCLUDE_V8_STATISTICS_H_

#define INCLUDE_V8_STATISTICS_H_

#include <stddef.h>

#include <stdint.h>

#include <memory>

#include <utility>

#include <vector>

#include "v8-local-handle.h"  // NOLINT(build/include_directory)

#include "v8-memory-span.h"   // NOLINT(build/include_directory)

#include "v8-promise.h"       // NOLINT(build/include_directory)

#include "v8config.h"         // NOLINT(build/include_directory)

namespace v8 {

class Context;

class Isolate;

namespace internal {

class ReadOnlyHeap;

}  // namespace internal

/**

 * Controls how the default MeasureMemoryDelegate reports the result of

 * the memory measurement to JS. With kSummary only the total size is reported.

 * With kDetailed the result includes the size of each native context.

 */

enum class MeasureMemoryMode { kSummary, kDetailed };

/**

 * Controls how promptly a memory measurement request is executed.

 * By default the measurement is folded with the next scheduled GC which may

 * happen after a while and is forced after some timeout.

 * The kEager mode starts incremental GC right away and is useful for testing.

 * The kLazy mode does not force GC.

 */

enum class MeasureMemoryExecution { kDefault, kEager, kLazy };

/**

 * The delegate is used in Isolate::MeasureMemory API.

 *

 * It specifies the contexts that need to be measured and gets called when

 * the measurement is completed to report the results.

 *

 * Both MeasurementComplete() callbacks will be invoked on completion.

 * Each implementation of this class should hence implement only one of them,

 * and leave the other empty.

 */

class V8_EXPORT MeasureMemoryDelegate {

 public:

  virtual ~MeasureMemoryDelegate() = default;

  /**

   * Returns true if the size of the given context needs to be measured.

   */

  virtual bool ShouldMeasure(Local<Context> context) = 0;

  /** Holds the result of a memory measurement request. */

  struct Result {

    /**

     * Two spans of equal length: the first includes each context for which

     * ShouldMeasure returned true and that was not garbage collected while

     * the memory measurement was in progress; the second includes the size

     * of the respective context.

     */

    const MemorySpan<const Local<Context>>& contexts;

    const MemorySpan<const size_t>& sizes_in_bytes;

    /**

     * Total size of objects that were not attributed to any context (i.e. are

     * likely shared objects).

     */

    size_t unattributed_size_in_bytes;

    /** Total size of generated code for Wasm (shared across contexts). */

    size_t wasm_code_size_in_bytes;

    /** Total size of Wasm metadata (except code; shared across contexts). */

    size_t wasm_metadata_size_in_bytes;

  };

  /**

   * This function is called when memory measurement finishes.

   *

   * \param result the result of the measurement.

   */

  virtual void MeasurementComplete(Result result) {}

  /**

   * Returns a default delegate that resolves the given promise when

   * the memory measurement completes.

   *

   * \param isolate the current isolate

   * \param context the current context

   * \param promise_resolver the promise resolver that is given the

   *   result of the memory measurement.

   * \param mode the detail level of the result.

   */

  static std::unique_ptr<MeasureMemoryDelegate> Default(

      Isolate* isolate, Local<Context> context,

      Local<Promise::Resolver> promise_resolver, MeasureMemoryMode mode);

};

/**

 * Collection of shared per-process V8 memory information.

 *

 * Instances of this class can be passed to

 * v8::V8::GetSharedMemoryStatistics to get shared memory statistics from V8.

 */

class V8_EXPORT SharedMemoryStatistics {

 public:

  SharedMemoryStatistics();

  size_t read_only_space_size() { return read_only_space_size_; }

  size_t read_only_space_used_size() { return read_only_space_used_size_; }

  size_t read_only_space_physical_size() {

    return read_only_space_physical_size_;

  }

 private:

  size_t read_only_space_size_;

  size_t read_only_space_used_size_;

  size_t read_only_space_physical_size_;

  friend class V8;

  friend class internal::ReadOnlyHeap;

};

/**

 * Collection of V8 heap information.

 *

 * Instances of this class can be passed to v8::Isolate::GetHeapStatistics to

 * get heap statistics from V8.

 */

class V8_EXPORT HeapStatistics {

 public:

  HeapStatistics();

  size_t total_heap_size() { return total_heap_size_; }

  size_t total_heap_size_executable() { return total_heap_size_executable_; }

  size_t total_physical_size() { return total_physical_size_; }

  size_t total_available_size() { return total_available_size_; }

  size_t total_global_handles_size() { return total_global_handles_size_; }

  size_t used_global_handles_size() { return used_global_handles_size_; }

  size_t used_heap_size() { return used_heap_size_; }

  size_t heap_size_limit() { return heap_size_limit_; }

  size_t malloced_memory() { return malloced_memory_; }

  size_t external_memory() { return external_memory_; }

  size_t peak_malloced_memory() { return peak_malloced_memory_; }

  size_t number_of_native_contexts() { return number_of_native_contexts_; }

  size_t number_of_detached_contexts() { return number_of_detached_contexts_; }

  /**

   * Returns a 0/1 boolean, which signifies whether the V8 overwrite heap

   * garbage with a bit pattern.

   */

  size_t does_zap_garbage() { return does_zap_garbage_; }

 private:

  size_t total_heap_size_;

  size_t total_heap_size_executable_;

  size_t total_physical_size_;

  size_t total_available_size_;

  size_t used_heap_size_;

  size_t heap_size_limit_;

  size_t malloced_memory_;

  size_t external_memory_;

  size_t peak_malloced_memory_;

  bool does_zap_garbage_;

  size_t number_of_native_contexts_;

  size_t number_of_detached_contexts_;

  size_t total_global_handles_size_;

  size_t used_global_handles_size_;

  friend class V8;

  friend class Isolate;

};

class V8_EXPORT HeapSpaceStatistics {

 public:

  HeapSpaceStatistics();

  const char* space_name() { return space_name_; }

  size_t space_size() { return space_size_; }

  size_t space_used_size() { return space_used_size_; }

  size_t space_available_size() { return space_available_size_; }

  size_t physical_space_size() { return physical_space_size_; }

 private:

  const char* space_name_;

  size_t space_size_;

  size_t space_used_size_;

  size_t space_available_size_;

  size_t physical_space_size_;

  friend class Isolate;

};

class V8_EXPORT HeapObjectStatistics {

 public:

  HeapObjectStatistics();

  const char* object_type() { return object_type_; }

  const char* object_sub_type() { return object_sub_type_; }

  size_t object_count() { return object_count_; }

  size_t object_size() { return object_size_; }

 private:

  const char* object_type_;

  const char* object_sub_type_;

  size_t object_count_;

  size_t object_size_;

  friend class Isolate;

};

class V8_EXPORT HeapCodeStatistics {

 public:

  HeapCodeStatistics();

  size_t code_and_metadata_size() { return code_and_metadata_size_; }

  size_t bytecode_and_metadata_size() { return bytecode_and_metadata_size_; }

  size_t external_script_source_size() { return external_script_source_size_; }

  size_t cpu_profiler_metadata_size() { return cpu_profiler_metadata_size_; }

 private:

  size_t code_and_metadata_size_;

  size_t bytecode_and_metadata_size_;

  size_t external_script_source_size_;

  size_t cpu_profiler_metadata_size_;

  friend class Isolate;

};

}  // namespace v8

#endif  // INCLUDE_V8_STATISTICS_H_