blob: 4d601d600298ffd459f6ac3487422084133f6e05 [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_TRACKER_HELPERS_H_
#define NB_MEMORY_TRACKER_HELPERS_H_
#include <map>
#include <vector>
#include "nb/analytics/memory_tracker.h"
#include "nb/atomic.h"
#include "nb/simple_thread.h"
#include "nb/thread_local_boolean.h"
#include "nb/thread_local_pointer.h"
#include "starboard/mutex.h"
#include "starboard/thread.h"
#include "starboard/types.h"
#include "starboard/log.h"
namespace nb {
namespace analytics {
class AllocationGroup;
class AllocationRecord;
// An AllocationGroup is a collection of allocations that are logically lumped
// together, such as "Javascript" or "Graphics".
class AllocationGroup {
public:
explicit AllocationGroup(const std::string& name);
~AllocationGroup();
const std::string& name() const { return name_; }
void AddAllocation(int64_t num_bytes);
void GetAggregateStats(int32_t* num_allocs, int64_t* allocation_bytes) const;
int64_t allocation_bytes() const;
int32_t num_allocations() const;
private:
const std::string name_;
nb::atomic_int64_t allocation_bytes_;
nb::atomic_int32_t num_allocations_;
SB_DISALLOW_COPY_AND_ASSIGN(AllocationGroup);
};
// A self locking data structure that maps strings -> AllocationGroups. This is
// used to resolve MemoryGroup names (e.g. "Javascript") to an AllocationGroup
// which can be used to group allocations together.
class AtomicStringAllocationGroupMap {
public:
AtomicStringAllocationGroupMap();
~AtomicStringAllocationGroupMap();
AllocationGroup* Ensure(const std::string& name);
AllocationGroup* GetDefaultUnaccounted();
bool Erase(const std::string& key);
void GetAll(std::vector<const AllocationGroup*>* output) const;
private:
typedef std::map<std::string, AllocationGroup*> Map;
Map group_map_;
AllocationGroup* unaccounted_group_;
mutable starboard::Mutex mutex_;
SB_DISALLOW_COPY_AND_ASSIGN(AtomicStringAllocationGroupMap);
};
class AllocationGroupStack {
public:
AllocationGroupStack() { Push_DebugBreak(NULL); }
~AllocationGroupStack() {}
void Push(AllocationGroup* group);
void Pop();
AllocationGroup* Peek();
const AllocationGroup* Peek() const;
void Push_DebugBreak(AllocationGroup* ag) { debug_stack_.push_back(ag); }
void Pop_DebugBreak() { debug_stack_.pop_back(); }
AllocationGroup* Peek_DebugBreak() {
if (debug_stack_.empty()) {
return NULL;
}
return debug_stack_.back();
}
const AllocationGroupPtrVec& data() const { return alloc_group_stack_; }
private:
SB_DISALLOW_COPY_AND_ASSIGN(AllocationGroupStack);
AllocationGroupPtrVec alloc_group_stack_, debug_stack_;
};
// A per-pointer map of allocations to AllocRecords. This map is thread safe.
class AtomicAllocationMap {
public:
AtomicAllocationMap();
~AtomicAllocationMap();
// Returns true if Added. Otherwise false means that the pointer
// already existed.
bool Add(const void* memory, const AllocationRecord& alloc_record);
// Returns true if the memory exists in this set.
bool Get(const void* memory, AllocationRecord* alloc_record) const;
// Return true if the memory existed in this set. If true
// then output alloc_record is written with record that was found.
// otherwise the record is written as 0 bytes and null key.
bool Remove(const void* memory, AllocationRecord* alloc_record);
bool Accept(AllocationVisitor* visitor) const;
size_t Size() const;
bool Empty() const;
void Clear();
private:
SB_DISALLOW_COPY_AND_ASSIGN(AtomicAllocationMap);
typedef std::map<const void*, AllocationRecord> PointerMap;
PointerMap pointer_map_;
mutable starboard::Mutex mutex_;
};
// A per-pointer map of allocations to AllocRecords. This is a hybrid data
// structure consisting of a hashtable of maps. Each pointer that is
// stored or retrieved is hashed to a random bucket. Each bucket has it's own
// lock. This distributed pattern increases performance significantly by
// reducing contention. The top-level hashtable is of constant size and does
// not resize. Each bucket is implemented as it's own map of elements.
class ConcurrentAllocationMap {
public:
static const int kNumElements = 511;
ConcurrentAllocationMap();
~ConcurrentAllocationMap();
// Returns true if Added. Otherwise false means that the pointer
// already existed.
bool Add(const void* memory, const AllocationRecord& alloc_record);
// Returns true if the memory exists in this set.
bool Get(const void* memory, AllocationRecord* alloc_record) const;
// Return true if the memory existed in this set. If true
// then output alloc_record is written with record that was found.
// otherwise the record is written as 0 bytes and null key.
bool Remove(const void* memory, AllocationRecord* alloc_record);
size_t Size() const;
bool Empty() const;
void Clear();
// Provides access to all the allocations within in a thread safe manner.
bool Accept(AllocationVisitor* visitor) const;
AtomicAllocationMap& GetMapForPointer(const void* ptr);
const AtomicAllocationMap& GetMapForPointer(const void* ptr) const;
private:
SB_DISALLOW_COPY_AND_ASSIGN(ConcurrentAllocationMap);
// Takes a pointer and generates a hash.
static size_t hash_ptr(const void* ptr);
int ToIndex(const void* ptr) const;
AtomicAllocationMap pointer_map_array_[kNumElements];
};
} // namespace analytics
} // namespace nb
#endif // NB_MEMORY_TRACKER_HELPERS_H_