Lines Matching full:region
28 // Region: a part of Space dedicated to a single size class.
36 // A Region looks like this:
100 // When we know the size class (the region base) we can represent a pointer
101 // as a 4-byte integer (offset from the region start shifted right by 4).
126 "SizeClassAllocator: region info"));
145 "SizeClassAllocator: region info");
177 RegionInfo *region = GetRegionInfo(class_id);
181 Lock l(®ion->mutex);
182 uptr old_num_chunks = region->num_freed_chunks;
186 if (UNLIKELY(!EnsureFreeArraySpace(region, region_beg,
196 region->num_freed_chunks = new_num_freed_chunks;
197 region->stats.n_freed += n_chunks;
204 RegionInfo *region = GetRegionInfo(class_id);
208 Lock l(®ion->mutex);
213 if (region->rtoi.last_released_bytes > 0) {
214 MmapFixedOrDie(region_beg, region->mapped_user,
215 "SizeClassAllocator: region data");
216 region->rtoi.n_freed_at_last_release = 0;
217 region->rtoi.last_released_bytes = 0;
220 if (UNLIKELY(region->num_freed_chunks < n_chunks)) {
221 if (UNLIKELY(!PopulateFreeArray(stat, class_id, region,
222 n_chunks - region->num_freed_chunks)))
224 CHECK_GE(region->num_freed_chunks, n_chunks);
226 region->num_freed_chunks -= n_chunks;
227 uptr base_idx = region->num_freed_chunks;
230 region->stats.n_allocated += n_chunks;
269 const RegionInfo *region = AddressSpaceView::Load(GetRegionInfo(class_id));
270 if (region->mapped_user >= next_beg)
313 RegionInfo *region = GetRegionInfo(class_id);
314 if (region->mapped_user == 0) return;
315 uptr in_use = region->stats.n_allocated - region->stats.n_freed;
316 uptr avail_chunks = region->allocated_user / ClassIdToSize(class_id);
320 "last released: %6lldK region: %p\n",
321 region->exhausted ? "F" : " ", class_id, ClassIdToSize(class_id),
322 region->mapped_user >> 10, region->stats.n_allocated,
323 region->stats.n_freed, in_use, region->num_freed_chunks, avail_chunks,
324 rss >> 10, region->rtoi.num_releases,
325 region->rtoi.last_released_bytes >> 10,
340 RegionInfo *region = GetRegionInfo(class_id);
341 if (region->mapped_user != 0) {
342 total_mapped += region->mapped_user;
345 n_allocated += region->stats.n_allocated;
346 n_freed += region->stats.n_freed;
374 RegionInfo *region = GetRegionInfo(class_id);
378 AddressSpaceView::Load(region)->allocated_user;
630 // dedicate 1/8 of the region's virtual space to FreeArray.
641 "Region size exceed largest size");
680 bool exhausted; // Whether region is out of space for new chunks.
741 bool EnsureFreeArraySpace(RegionInfo *region, uptr region_beg,
744 if (region->mapped_free_array < needed_space) {
748 region->mapped_free_array;
749 uptr new_map_size = new_mapped_free_array - region->mapped_free_array;
753 region->mapped_free_array = new_mapped_free_array;
759 bool IsRegionExhausted(RegionInfo *region, uptr class_id,
761 if (LIKELY(region->mapped_user + region->mapped_meta +
764 if (!region->exhausted) {
765 region->exhausted = true;
775 RegionInfo *region, uptr requested_count) {
776 // region->mutex is held.
781 region->allocated_user + requested_count * size;
783 if (LIKELY(total_user_bytes > region->mapped_user)) {
784 if (UNLIKELY(region->mapped_user == 0)) {
787 region->rand_state = static_cast<u32>(region_beg >> 12);
795 region->rtoi.last_release_at_ns = MonotonicNanoTime();
799 RoundUpTo(total_user_bytes - region->mapped_user, kUserMapSize);
800 if (UNLIKELY(IsRegionExhausted(region, class_id, user_map_size)))
802 if (UNLIKELY(!MapWithCallback(region_beg + region->mapped_user,
804 "SizeClassAllocator: region data")))
807 region->mapped_user += user_map_size;
810 (region->mapped_user - region->allocated_user) / size;
815 region->allocated_meta + new_chunks_count * kMetadataSize;
816 const uptr meta_map_size = (total_meta_bytes > region->mapped_meta) ?
817 RoundUpTo(total_meta_bytes - region->mapped_meta, kMetaMapSize) : 0;
820 if (UNLIKELY(IsRegionExhausted(region, class_id, meta_map_size)))
823 GetMetadataEnd(region_beg) - region->mapped_meta - meta_map_size,
824 meta_map_size, "SizeClassAllocator: region metadata")))
826 region->mapped_meta += meta_map_size;
832 const uptr total_freed_chunks = region->num_freed_chunks + new_chunks_count;
833 if (UNLIKELY(!EnsureFreeArraySpace(region, region_beg, total_freed_chunks)))
836 for (uptr i = 0, chunk = region->allocated_user; i < new_chunks_count;
840 RandomShuffle(&free_array[region->num_freed_chunks], new_chunks_count,
841 ®ion->rand_state);
845 region->num_freed_chunks += new_chunks_count;
846 region->allocated_user += new_chunks_count * size;
847 CHECK_LE(region->allocated_user, region->mapped_user);
848 region->allocated_meta += new_chunks_count * kMetadataSize;
849 CHECK_LE(region->allocated_meta, region->mapped_meta);
850 region->exhausted = false;
859 // Attempts to release RAM occupied by freed chunks back to OS. The region is
866 RegionInfo *region = GetRegionInfo(class_id);
870 uptr n = region->num_freed_chunks;
873 if ((region->stats.n_freed -
874 region->rtoi.n_freed_at_last_release) * chunk_size < page_size) {
883 if (region->rtoi.last_release_at_ns + interval_ms * 1000000ULL >
891 RoundUpTo(region->allocated_user, page_size) / page_size, memory_mapper,
896 region->rtoi.n_freed_at_last_release = region->stats.n_freed;
897 region->rtoi.num_releases += ranges;
898 region->rtoi.last_released_bytes = bytes;
900 region->rtoi.last_release_at_ns = MonotonicNanoTime();