Lines Matching defs:memory
17 #include "base/memory/ptr_util.h"
37 // The amount of memory set aside for holding arbitrary user data (key/value
52 // in the same memory space.
99 // the memory is cleared during the "free" operation.
142 bool OwningProcess::GetOwningProcessId(const void* memory,
145 const OwningProcess* info = reinterpret_cast<const OwningProcess*>(memory);
194 // faster than searching the memory system for free blocks.
200 // clear the memory because that was done when the type was made "free".
205 // Fetch the next "free" object from persistent memory. Rather than restart
337 ActivityUserData::ActivityUserData(void* memory, size_t size, int64_t pid)
338 : memory_(reinterpret_cast<char*>(memory)),
340 header_(reinterpret_cast<MemoryHeader*>(memory)),
387 std::string(reinterpret_cast<char*>(entry.second.memory), size);
392 reinterpret_cast<ReferenceRecord*>(entry.second.memory);
399 value.short_value_ = *reinterpret_cast<char*>(entry.second.memory);
403 value.short_value_ = *reinterpret_cast<uint64_t*>(entry.second.memory);
413 // Another import attempt will validate that the underlying memory has not
440 bool ActivityUserData::GetOwningProcessId(const void* memory,
443 const MemoryHeader* header = reinterpret_cast<const MemoryHeader*>(memory);
449 const void* memory,
496 // Truncate the stored size to the amount of available memory. Stop now if
504 // Allocate a chunk of memory.
509 // Datafill the header and name records. Memory must be zeroed. The |type|
529 info->memory = value_memory;
541 memcpy(info->memory, memory, size);
547 const void* memory,
550 rec.address = reinterpret_cast<uintptr_t>(memory);
581 info.memory = memory_ + value_offset;
592 // Check if memory has been completely reused.
629 // immediately follow this structure in memory.
640 // A memory location used to indicate if changes have been made to the data
655 // are not practical since the memory has to come from the same persistent
720 // Provided memory should either be completely initialized or all zeros.
774 // Get the current depth of the stack. No access to other memory guarded
782 // Since no other memory is being modified, a "relaxed" store is acceptable.
788 // here because the memory is known only to this thread. It will be made
792 // Save the incremented depth. Because this guards |activity| memory filled
946 // Using "cst" memory ordering is relatively expensive but this is only
987 // If the data ID has changed then the tracker has exited and the memory
1034 bool ThreadActivityTracker::GetOwningProcessId(const void* memory,
1037 const Header* header = reinterpret_cast<const Header*>(memory);
1053 void* memory = allocator->GetAsArray<char>(ref, kUserDataSize);
1054 if (memory) {
1056 MakeUnique<ActivityUserData>(memory, kUserDataSize);
1225 GlobalActivityTracker::ThreadSafeUserData::ThreadSafeUserData(void* memory,
1228 : ActivityUserData(memory, size, pid) {}
1234 const void* memory,
1237 ActivityUserData::Set(name, type, memory, size);
1277 // Create and map the file into memory and make it globally available.
1339 // because the underlying allocator wasn't given enough memory to satisfy
1343 // failure can be seen and underlying memory resized appropriately.
1351 // Convert the memory block found above into an actual memory address.
1367 // Create a tracker with the acquired memory and set it as the tracker
1483 // all the data structures it may have allocated in the persistent memory
1500 const void* memory = allocator_->GetAsArray<char>(
1504 if (ActivityUserData::GetOwningProcessId(memory, &found_id,
1507 const ActivityUserData process_data(const_cast<void*>(memory),
1537 const void* memory = allocator_->GetAsArray<char>(
1545 if (OwningProcess::GetOwningProcessId(memory, &found_id,
1549 // cause the erasure of something that is in-use). Memory is cleared
1562 // memory returned by the allocator is guaranteed to be zeroed.
1565 char* memory = allocator_->GetAsArray<char>(ref, kTypeIdGlobalLogMessage,
1567 if (memory) {
1568 memcpy(memory, message.data(), message.size());
1681 // Release this memory for re-use at a later time.
1690 // one at this point because such would involve memory allocations and
