#ifndef MEMORYUSAGE_H

#define MEMORYUSAGE_H

#include "pandabase.h"

#include "typedObject.h"

#include "memoryInfo.h"

#include "memoryUsagePointerCounts.h"

#include "pmap.h"

#include "memoryHook.h"

class ReferenceCount;

class MemoryUsagePointers;

class EXPCL_PANDA_EXPRESS MemoryUsage : public MemoryHook {

ALWAYS_INLINE static bool get_track_memory_usage();

INLINE static void record_pointer(ReferenceCount *ptr);

INLINE static void record_pointer(void *ptr, TypeHandle type);

INLINE static void update_type(ReferenceCount *ptr, TypeHandle type);

INLINE static void update_type(ReferenceCount *ptr, TypedObject *typed_ptr);

INLINE static void update_type(void *ptr, TypeHandle type);

INLINE static void remove_pointer(ReferenceCount *ptr);

// These are not marked public, but they can be accessed via the MemoryHook

// base class.

virtual void *heap_alloc_single(size_t size);

virtual void heap_free_single(void *ptr);

virtual void *heap_alloc_array(size_t size);

virtual void *heap_realloc_array(void *ptr, size_t size);

virtual void heap_free_array(void *ptr);

virtual void mark_pointer(void *ptr, size_t orig_size, ReferenceCount *ref_ptr);

#if defined(_WIN32) && defined(_DEBUG)

static int win32_malloc_hook(int alloc_type, void *ptr,

size_t size, int block_use, long request,

const unsigned char *filename, int line);

#endif

PUBLISHED:

INLINE static bool is_tracking();

INLINE static bool is_counting();

INLINE static size_t get_current_cpp_size();

INLINE static size_t get_total_cpp_size();

INLINE static size_t get_panda_heap_single_size();

INLINE static size_t get_panda_heap_array_size();

INLINE static size_t get_panda_heap_overhead();

INLINE static size_t get_panda_mmap_size();

INLINE static size_t get_external_size();

INLINE static size_t get_total_size();

INLINE static int get_num_pointers();

INLINE static void get_pointers(MemoryUsagePointers &result);

INLINE static void get_pointers_of_type(MemoryUsagePointers &result,

TypeHandle type);

INLINE static void get_pointers_of_age(MemoryUsagePointers &result,

double from, double to);

INLINE static void get_pointers_with_zero_count(MemoryUsagePointers &result);

INLINE static void freeze();

INLINE static void show_current_types();

INLINE static void show_trend_types();

INLINE static void show_current_ages();

INLINE static void show_trend_ages();

PUBLISHED:

MAKE_PROPERTY(tracking, is_tracking);

MAKE_PROPERTY(counting, is_counting);

MAKE_PROPERTY(current_cpp_size, get_current_cpp_size);

MAKE_PROPERTY(total_cpp_size, get_total_cpp_size);

MAKE_PROPERTY(panda_heap_single_size, get_panda_heap_single_size);

MAKE_PROPERTY(panda_heap_array_size, get_panda_heap_array_size);

MAKE_PROPERTY(panda_heap_overhead, get_panda_heap_overhead);

MAKE_PROPERTY(panda_mmap_size, get_panda_mmap_size);

MAKE_PROPERTY(external_size, get_external_size);

MAKE_PROPERTY(total_size, get_total_size);

virtual void overflow_heap_size();

MemoryUsage(const MemoryHook &copy);

INLINE static MemoryUsage *get_global_ptr();

static void init_memory_usage();

void ns_record_pointer(ReferenceCount *ptr);

void ns_record_pointer(void *ptr, TypeHandle type);

void ns_update_type(void *ptr, TypeHandle type);

void ns_update_type(void *ptr, TypedObject *typed_ptr);

void ns_remove_pointer(ReferenceCount *ptr);

void ns_record_void_pointer(void *ptr, size_t size);

void ns_remove_void_pointer(void *ptr);

size_t ns_get_total_size();

int ns_get_num_pointers();

void ns_get_pointers(MemoryUsagePointers &result);

void ns_get_pointers_of_type(MemoryUsagePointers &result,

TypeHandle type);

void ns_get_pointers_of_age(MemoryUsagePointers &result,

double from, double to);

void ns_get_pointers_with_zero_count(MemoryUsagePointers &result);

void ns_freeze();

void ns_show_current_types();

void ns_show_trend_types();

void ns_show_current_ages();

void ns_show_trend_ages();

#ifdef DO_MEMORY_USAGE

void consolidate_void_ptr(MemoryInfo *info);

void refresh_info_set();

#endif

static MemoryUsage *_global_ptr;

// We shouldn't use a pmap, since that would be recursive! Actually, it

// turns out that it doesn't matter, since somehow the pallocator gets used

// even though we don't specify it here, so we have to make special code

// that handles the recursion anyway.

typedef std::map<void *, MemoryInfo *> Table;

Table _table;

// This table indexes the individual MemoryInfo objects, for unique

// iteration.

typedef std::set<MemoryInfo *> InfoSet;

InfoSet _info_set;

bool _info_set_dirty;

int _freeze_index;

int _count;

size_t _current_cpp_size;

size_t _total_cpp_size;

size_t _total_size;

class TypeHistogram {

};

TypeHistogram _trend_types;

class AgeHistogram {

};

AgeHistogram _trend_ages;

bool _track_memory_usage;

bool _startup_track_memory_usage;

bool _count_memory_usage;

bool _report_memory_usage;

double _report_memory_interval;

double _last_report_time;

static bool _recursion_protect;

};

#include "memoryUsage.I"

#endif