blob: 9c9446bf76300f63d62b32060c8c072b023bba47 [file] [log] [blame]
/*
* 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.
*/
#ifndef NB_MEMORY_SCOPE_H_
#define NB_MEMORY_SCOPE_H_
#include "starboard/types.h"
///////////////////////////////////////////////////////////////////////////////
// Macros to define the memory scope objects. These are objects that are used
// to annotate sections of the code base as belonging to a particular memory
// scope. Note that this is an annotation and does not memory allocation.
///////////////////////////////////////////////////////////////////////////////
// Macro to track the memory scope inside a function or block of code. The
// memory scope is in effect until the end of the code block.
// Example:
// void Foo() {
// TRACK_MEMORY_SCOPE("FooMemoryScope");
// // pops the memory scope at the end.
// }
#if !defined(__cplusplus)
// Disallow macro use for non-C++ builds.
#define TRACK_MEMORY_SCOPE(STR) error_forbidden_in_non_c_plus_plus_code
#define TRACK_MEMORY_SCOPE_DYNAMIC(STR) error_forbidden_in_non_c_plus_plus_code
#elif defined(STARBOARD_ALLOWS_MEMORY_TRACKING)
#define TRACK_MEMORY_SCOPE(STR) TRACK_MEMORY_STATIC_CACHED(STR)
#define TRACK_MEMORY_SCOPE_DYNAMIC(STR) TRACK_MEMORY_STATIC_NOT_CACHED(STR)
#else
// No-op when starboard does not allow memory tracking.
#define TRACK_MEMORY_SCOPE(STR)
#define TRACK_MEMORY_SCOPE_DYNAMIC(STR)
#endif
// Preprocessor needs double expansion in order to __FILE__, __LINE__ and
// __FUNCTION__ properly.
#define TRACK_MEMORY_STATIC_CACHED(STR) \
TRACK_MEMORY_STATIC_CACHED_IMPL_2(STR, __FILE__, __LINE__, __FUNCTION__)
#define TRACK_MEMORY_STATIC_NOT_CACHED(STR) \
TRACK_MEMORY_STATIC_NOT_CACHED_IMPL_2(STR, __FILE__, __LINE__, __FUNCTION__)
// Only enable TRACK_MEMORY_STATIC_CACHED_IMPL_2 if starboard allows memory
// tracking.
#define TRACK_MEMORY_STATIC_CACHED_IMPL_2(Str, FileStr, LineNum, FuncStr) \
static NbMemoryScopeInfo memory_scope_handle_##LineNum = \
{ 0, Str, FileStr, LineNum, FuncStr, true }; \
NbPushMemoryScope(&memory_scope_handle_##LineNum); \
NbPopMemoryScopeOnScopeEnd pop_on_scope_end_##LineNum;
#define TRACK_MEMORY_STATIC_NOT_CACHED_IMPL_2(Str, FileStr, LineNum, FuncStr) \
NbMemoryScopeInfo memory_scope_handle_##LineNum = { \
0, Str, FileStr, LineNum, FuncStr, false}; \
NbPushMemoryScope(&memory_scope_handle_##LineNum); \
NbPopMemoryScopeOnScopeEnd pop_on_scope_end_##LineNum;
#ifdef __cplusplus
extern "C" {
#endif
struct NbMemoryScopeReporter;
struct NbMemoryScopeInfo;
// Sets the memory reporter. Returns true on success, false something
// goes wrong.
bool NbSetMemoryScopeReporter(NbMemoryScopeReporter* reporter);
// Note that we pass by pointer because the memory scope contains a
// variable allowing the result to be cached.
void NbPushMemoryScope(NbMemoryScopeInfo* memory_scope);
void NbPopMemoryScope();
///////////////////////////////////////////////////////////////////////////////
// Implementation
///////////////////////////////////////////////////////////////////////////////
// Interface for handling memory scopes.
typedef void (*NbReportPushMemoryScopeCallback)(void* context,
NbMemoryScopeInfo* info);
typedef void (*NbReportPopMemoryScopeCallback)(void* context);
struct NbMemoryScopeReporter {
// Callback to report pushing of memory scope.
NbReportPushMemoryScopeCallback push_memory_scope_cb;
// Callback to report poping of the memory scope.
NbReportPopMemoryScopeCallback pop_memory_scope_cb;
// Optional, is passed to the callbacks as first argument.
void* context;
};
// This MemoryScope must remain a POD data type so that it can be statically
// initialized.
struct NbMemoryScopeInfo {
// cached_handle_ allows a cached result of the the fields represented in
// this struct to be generated and the handle be placed into this field.
// See also allows_caching_.
uintptr_t cached_handle_;
// Represents the name of the memory scope. I.E. "Javascript" or "Gfx".
const char* memory_scope_name_;
// Represents the file name that this memory scope was created at.
const char* file_name_;
// Represents the line number that this memory scope was created at.
int line_number_;
// Represents the function name that this memory scope was created at.
const char* function_name_;
// When true, if cached_handle_ is 0 then an object may be created that
// represents the fields of this object. The handle that represents this
// cached object is then placed in cached_hanlde_.
const bool allows_caching_;
};
// NbPopMemoryScopeOnScopeEnd is only allowed for C++ builds.
#ifdef __cplusplus
// A helper that pops the memory scope at the end of the current code block.
struct NbPopMemoryScopeOnScopeEnd {
~NbPopMemoryScopeOnScopeEnd() { NbPopMemoryScope(); }
};
#endif
#ifdef __cplusplus
} // extern "C"
#endif
#endif // NB_MEMORY_SCOPE_H_