Lines Matching defs:Size
39 // may be larger than the page size.
84 #define DCHECK_OBJECT_SIZE(size) \
85 DCHECK((0 < size) && (size <= Page::kMaxRegularHeapObjectSize))
554 size_t size() const { return size_; }
556 void set_size(size_t size) { size_ = size; }
680 static MemoryChunk* Initialize(Heap* heap, Address base, size_t size,
698 // A page is a memory chunk of a size 1MB. Large object pages may be larger.
747 // Page size in bytes. This must be a multiple of the OS page size.
750 // Maximum object size that fits in a page. Objects larger than that size
756 // Page size mask.
831 // Returns allocated size.
832 virtual intptr_t Size() = 0;
834 // Returns size of objects. Can differ from the allocated size
836 virtual intptr_t SizeOfObjects() { return Size(); }
838 virtual int RoundSizeDownToObjectAlignment(int size) {
840 return RoundDown(size, kCodeAlignment);
842 return RoundDown(size, kPointerSize);
886 return start <= address && address < start + code_range_->size();
908 : start(start_arg), size(size_arg) {
910 DCHECK(size >= static_cast<size_t>(Page::kPageSize));
913 : start(static_cast<Address>(start_arg)), size(size_arg) {
915 DCHECK(size >= static_cast<size_t>(Page::kPageSize));
919 size_t size;
956 void AddObject(Address addr, int size) {
958 int end_region = RegionNumber(addr + size - kPointerSize);
968 static void Update(Address addr, int size) {
976 list->AddObject(addr, size);
1007 Page* AllocatePage(intptr_t size, PagedSpace* owner,
1019 intptr_t Size() { return size_; }
1060 bool CommitMemory(Address addr, size_t size, Executability executable);
1063 void FreeMemory(Address addr, size_t size, Executability executable);
1066 // the address is not NULL, the size is greater than zero, and that the
1069 bool CommitBlock(Address start, size_t size, Executability executable);
1071 // Uncommit a contiguous block of memory [start..(start+size)[.
1072 // start is not NULL, the size is greater than zero, and the
1075 bool UncommitBlock(Address start, size_t size);
1077 // Zaps a contiguous block of memory [start..(start+size)[ thus
1079 void ZapBlock(Address start, size_t size);
1082 size_t size);
1110 // Maximum space size in bytes.
1115 // Allocated space size in bytes.
1117 // Allocated executable space size in bytes.
1185 // If the size function is not given, the iterator calls the default
1186 // Object::Size().
1209 HeapObjectCallback size_func_; // Size function or NULL.
1301 // including page bookkeeping structures) currently in the space. The 'size'
1307 // capacity is the sum of size, waste, and available.
1340 intptr_t Size() { return size_; }
1344 // being in use (part of the size), but will normally be immediately freed,
1356 // during sweeping, bytes have been marked as being in use (part of the size)
1364 // Allocate from available bytes (available -> size).
1370 // Free allocated bytes, making them available (size -> available).
1395 // a heap object). They have a size and a next pointer. The next pointer is
1408 // Set the size in bytes, which can be read with HeapObject::Size(). This
1501 // limit when the object we need to allocate is 1-31 words in size. These
1504 // limit when the object we need to allocate is 32-255 words in size. These
1507 // and limit when the object we need to allocate is 256-2047 words in size.
1526 // Place a node on the free list. The block of size 'size_in_bytes'
1531 // aligned, and the size should be a non-zero multiple of the word size.
1549 // Allocate a block of size 'size_in_bytes' from the free list. The block
1552 // 'wasted_bytes'. The size should be a non-zero multiple of the word size.
1578 // The size range of blocks, in bytes.
1683 // Current capacity without growing (Size() + Available()).
1712 // capacity and the size when it is encountered. As free spaces are
1713 // discovered during the sweeping they are subtracted from the size and added
1735 virtual intptr_t Size() { return accounting_stats_.Size(); }
1737 // As size, but the bytes in lazily swept pages are estimated and the bytes
1795 void IncreaseCapacity(int size);
1868 // Return size of allocatable area on a page in this space.
1916 // size limit has been hit.
1945 void increment_bytes(int size) { bytes_ += size; }
2137 virtual intptr_t Size() {
2233 // no size function is given, the iterator calls Object::Size().
2237 // Iterate over all of allocated to-space, with a custome size function.
2256 int size = (size_func_ == NULL) ? object->Size() : size_func_(object);
2258 current_ += size;
2356 virtual intptr_t Size() {
2364 int SizeAsInt() { return static_cast<int>(Size()); }
2373 // Return the current size of a semispace, allocatable and non-allocatable
2396 intptr_t Available() { return Capacity() - Size(); }
2627 virtual int RoundSizeDownToObjectAlignment(int size) {
2629 return RoundDown(size, Map::kSize);
2631 return (size / Map::kSize) * Map::kSize;
2662 virtual int RoundSizeDownToObjectAlignment(int size) {
2664 return RoundDown(size, Cell::kSize);
2666 return (size / Cell::kSize) * Cell::kSize;
2687 virtual int RoundSizeDownToObjectAlignment(int size) {
2689 return RoundDown(size, PropertyCell::kSize);
2691 return (size / PropertyCell::kSize) * PropertyCell::kSize;
2734 virtual intptr_t Size() { return size_; }
2740 intptr_t CommittedMemory() { return Size(); }
2786 intptr_t objects_size_; // size of objects
2872 int size;
2876 size = 0;
