Lines Matching defs:memory
20 #include <memory>
76 // from memory without loading the entire structure for analysis. This will
78 static bool GetOwningProcessId(const void* memory,
112 uint64_t lock_address; // The memory address of the lock object.
115 uint64_t event_address; // The memory address of the event object.
183 // A helper class that is used for managing memory allocations within a
184 // persistent memory allocator. Instances of this class are NOT thread-safe.
204 // a null reference if it was not possible to allocate the memory.
233 // An iterator for going through persistent memory looking for free'd objects.
320 // Reference to arbitrary user data within the persistent memory segment
349 // memory.
382 // These methods return references to process memory as originally provided
384 // the referenced memory is assessible or useful. It's possible that:
385 // - the memory was free'd and reallocated for a different purpose
386 // - the memory has been released back to the OS
387 // - the memory belongs to a different process's address space
388 // Dereferencing the returned StringPiece when the memory is not accessible
405 // data or an active one that writes to a given (zeroed) memory block.
407 ActivityUserData(void* memory, size_t size, int64_t pid = 0);
424 // the memory buffer is full or the associated activity is beyond the maximum
426 void Set(StringPiece name, const void* memory, size_t size) {
427 Set(name, RAW_VALUE, memory, size);
450 // persistent memory. They store unaltered pointers along with a size. These
451 // can be used in conjuction with a memory dump to find certain large pieces
453 void SetReference(StringPiece name, const void* memory, size_t size) {
454 SetReference(name, RAW_VALUE_REFERENCE, memory, size);
467 // Gets the base memory address used for storing data.
474 // from tracker memory without loading the entire structure for analysis. This
476 static bool GetOwningProcessId(const void* memory,
483 const void* memory,
491 // A structure that defines the structure header in memory.
499 // Header to a key/value record held in persistent memory.
510 // A structure used to reference data held outside of persistent memory.
525 void* memory; // Where the "value" is held.
532 const void* memory,
535 // Loads any data already in the memory segment. This allows for accessing
542 // A map of all the values within the memory block, keyed by name for quick
547 // Information about the memory block in which new data can be stored. These
553 // A pointer to the memory header for this instance.
567 // memory allocation. In order to support an operational mode where another
646 // A ThreadActivityTracker runs on top of memory that is managed externally.
715 // Gets the base memory address used for storing data.
722 // from tracker memory without loading the entire structure for analysis. This
724 static bool GetOwningProcessId(const void* memory,
728 // Calculates the memory size required for a given stack depth, including
751 // The global tracker manages all the individual thread trackers. Memory for
756 // Type identifiers used when storing in persistent memory so they can be
869 // Creates a global tracker using a given persistent-memory |allocator| and
891 // Like above but internally creates an allocator using local heap memory of
918 // Gets the persistent-memory-allocator in which data is stored. Callers
1057 ThreadSafeUserData(void* memory, size_t size, int64_t pid = 0);
1063 const void* memory,
1071 // State of a module as stored in persistent memory. This supports a single
1111 // Determines the required memory size for the encoded storage.
1127 // The reference into persistent memory from which the thread-tracker's
1128 // memory was created.
1131 // The physical address used for the thread-tracker's memory.
1138 // Creates a global tracker using a given persistent-memory |allocator| and
1147 // Returns the memory used by an activity-tracker managed by this class.
1165 // The persistent-memory allocator from which the memory for all trackers
1169 // The size (in bytes) of memory required by a ThreadActivityTracker to
1183 // A caching memory allocator for thread-tracker objects.
1187 // A caching memory allocator for user data attached to activity data.
