Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 1 | // Copyright 2011 Google Inc. All Rights Reserved. |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 2 | |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 3 | #include "space.h" |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 4 | |
| 5 | #include <sys/mman.h> |
| 6 | |
Elliott Hughes | 90a3369 | 2011-08-30 13:27:07 -0700 | [diff] [blame] | 7 | #include "UniquePtr.h" |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 8 | #include "file.h" |
| 9 | #include "image.h" |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 10 | #include "logging.h" |
| 11 | #include "mspace.h" |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 12 | #include "os.h" |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 13 | #include "utils.h" |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 14 | |
| 15 | namespace art { |
| 16 | |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 17 | Space* Space::Create(size_t initial_size, size_t maximum_size, byte* requested_base) { |
Elliott Hughes | 90a3369 | 2011-08-30 13:27:07 -0700 | [diff] [blame] | 18 | UniquePtr<Space> space(new Space()); |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 19 | bool success = space->Init(initial_size, maximum_size, requested_base); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 20 | if (!success) { |
| 21 | return NULL; |
| 22 | } else { |
| 23 | return space.release(); |
| 24 | } |
| 25 | } |
| 26 | |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 27 | Space* Space::Create(const char* image_file_name) { |
| 28 | CHECK(image_file_name != NULL); |
Elliott Hughes | 90a3369 | 2011-08-30 13:27:07 -0700 | [diff] [blame] | 29 | UniquePtr<Space> space(new Space()); |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 30 | bool success = space->Init(image_file_name); |
| 31 | if (!success) { |
| 32 | return NULL; |
| 33 | } else { |
| 34 | return space.release(); |
| 35 | } |
| 36 | } |
| 37 | |
| 38 | Space::~Space() {} |
| 39 | |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 40 | void* Space::CreateMallocSpace(void* base, |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 41 | size_t initial_size, |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 42 | size_t maximum_size) { |
| 43 | errno = 0; |
| 44 | bool is_locked = false; |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 45 | size_t commit_size = initial_size / 2; |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 46 | void* msp = create_contiguous_mspace_with_base(commit_size, maximum_size, |
| 47 | is_locked, base); |
| 48 | if (msp != NULL) { |
| 49 | // Do not permit the heap grow past the starting size without our |
| 50 | // intervention. |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 51 | mspace_set_max_allowed_footprint(msp, initial_size); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 52 | } else { |
| 53 | // There is no guarantee that errno has meaning when the call |
| 54 | // fails, but it often does. |
| 55 | PLOG(ERROR) << "create_contiguous_mspace_with_base failed"; |
| 56 | } |
| 57 | return msp; |
| 58 | } |
| 59 | |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 60 | bool Space::Init(size_t initial_size, size_t maximum_size, byte* requested_base) { |
| 61 | if (!(initial_size <= maximum_size)) { |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 62 | LOG(WARNING) << "Failed to create space with initial size > maximum size (" |
| 63 | << initial_size << ">" << maximum_size << ")"; |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 64 | return false; |
| 65 | } |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 66 | size_t length = RoundUp(maximum_size, kPageSize); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 67 | int prot = PROT_READ | PROT_WRITE; |
Elliott Hughes | 90a3369 | 2011-08-30 13:27:07 -0700 | [diff] [blame] | 68 | UniquePtr<MemMap> mem_map(MemMap::Map(requested_base, length, prot)); |
| 69 | if (mem_map.get() == NULL) { |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 70 | LOG(WARNING) << "Failed to allocate " << length << " bytes for space"; |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 71 | return false; |
| 72 | } |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 73 | Init(mem_map.release()); |
| 74 | maximum_size_ = maximum_size; |
| 75 | mspace_ = CreateMallocSpace(base_, initial_size, maximum_size); |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 76 | if (mspace_ == NULL) { |
| 77 | LOG(WARNING) << "Failed to create mspace for space"; |
| 78 | return false; |
| 79 | } |
| 80 | return true; |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 81 | } |
| 82 | |
| 83 | void Space::Init(MemMap* mem_map) { |
| 84 | mem_map_.reset(mem_map); |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 85 | base_ = mem_map_->GetAddress(); |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 86 | limit_ = base_ + mem_map->GetLength(); |
| 87 | } |
| 88 | |
| 89 | |
| 90 | bool Space::Init(const char* image_file_name) { |
Elliott Hughes | 90a3369 | 2011-08-30 13:27:07 -0700 | [diff] [blame] | 91 | UniquePtr<File> file(OS::OpenFile(image_file_name, false)); |
| 92 | if (file.get() == NULL) { |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 93 | LOG(WARNING) << "Failed to open " << image_file_name; |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 94 | return false; |
| 95 | } |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 96 | ImageHeader image_header; |
| 97 | bool success = file->ReadFully(&image_header, sizeof(image_header)); |
| 98 | if (!success || !image_header.IsValid()) { |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 99 | LOG(WARNING) << "Invalid image header " << image_file_name; |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 100 | return false; |
| 101 | } |
Elliott Hughes | 90a3369 | 2011-08-30 13:27:07 -0700 | [diff] [blame] | 102 | UniquePtr<MemMap> map(MemMap::Map(image_header.GetBaseAddr(), |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 103 | file->Length(), |
| 104 | // TODO: selectively PROT_EXEC when image contains a code space |
| 105 | PROT_READ | PROT_WRITE | PROT_EXEC, |
| 106 | MAP_PRIVATE | MAP_FIXED, |
| 107 | file->Fd(), |
| 108 | 0)); |
Elliott Hughes | 90a3369 | 2011-08-30 13:27:07 -0700 | [diff] [blame] | 109 | if (map.get() == NULL) { |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 110 | LOG(WARNING) << "Failed to map " << image_file_name; |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 111 | return false; |
| 112 | } |
| 113 | CHECK_EQ(image_header.GetBaseAddr(), map->GetAddress()); |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 114 | image_header_ = reinterpret_cast<ImageHeader*>(map->GetAddress()); |
| 115 | DCHECK_EQ(0, memcmp(&image_header, image_header_, sizeof(ImageHeader))); |
| 116 | |
Brian Carlstrom | 1619286 | 2011-09-12 17:50:06 -0700 | [diff] [blame] | 117 | Object* jni_stub_array = image_header.GetImageRoot(ImageHeader::kJniStubArray); |
| 118 | Runtime::Current()->SetJniStubArray(down_cast<ByteArray*>(jni_stub_array)); |
| 119 | |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 120 | Init(map.release()); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 121 | return true; |
| 122 | } |
| 123 | |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 124 | Object* Space::AllocWithoutGrowth(size_t num_bytes) { |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 125 | DCHECK(mspace_ != NULL); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 126 | return reinterpret_cast<Object*>(mspace_calloc(mspace_, 1, num_bytes)); |
| 127 | } |
| 128 | |
| 129 | Object* Space::AllocWithGrowth(size_t num_bytes) { |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 130 | DCHECK(mspace_ != NULL); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 131 | // Grow as much as possible within the mspace. |
| 132 | size_t max_allowed = maximum_size_; |
| 133 | mspace_set_max_allowed_footprint(mspace_, max_allowed); |
| 134 | // Try the allocation. |
| 135 | void* ptr = AllocWithoutGrowth(num_bytes); |
| 136 | // Shrink back down as small as possible. |
| 137 | size_t footprint = mspace_footprint(mspace_); |
| 138 | mspace_set_max_allowed_footprint(mspace_, footprint); |
| 139 | // Return the new allocation or NULL. |
| 140 | return reinterpret_cast<Object*>(ptr); |
| 141 | } |
| 142 | |
| 143 | size_t Space::Free(void* ptr) { |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 144 | DCHECK(mspace_ != NULL); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 145 | DCHECK(ptr != NULL); |
| 146 | size_t num_bytes = mspace_usable_size(mspace_, ptr); |
| 147 | mspace_free(mspace_, ptr); |
| 148 | return num_bytes; |
| 149 | } |
| 150 | |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 151 | size_t Space::AllocationSize(const Object* obj) { |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 152 | DCHECK(mspace_ != NULL); |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 153 | return mspace_usable_size(mspace_, obj) + kChunkOverhead; |
| 154 | } |
| 155 | |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 156 | void Space::DontNeed(void* start, void* end, void* num_bytes) { |
Brian Carlstrom | b0460ea | 2011-07-29 10:08:05 -0700 | [diff] [blame] | 157 | start = (void*)RoundUp((uintptr_t)start, kPageSize); |
| 158 | end = (void*)RoundDown((uintptr_t)end, kPageSize); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 159 | if (start >= end) { |
| 160 | return; |
| 161 | } |
| 162 | size_t length = reinterpret_cast<byte*>(end) - reinterpret_cast<byte*>(start); |
| 163 | int result = madvise(start, length, MADV_DONTNEED); |
| 164 | if (result == -1) { |
| 165 | PLOG(WARNING) << "madvise failed"; |
| 166 | } else { |
| 167 | *reinterpret_cast<size_t*>(num_bytes) += length; |
| 168 | } |
| 169 | } |
| 170 | |
| 171 | void Space::Trim() { |
| 172 | CHECK(mspace_ != NULL); |
| 173 | mspace_trim(mspace_, 0); |
| 174 | size_t num_bytes_released = 0; |
| 175 | mspace_walk_free_pages(mspace_, DontNeed, &num_bytes_released); |
| 176 | } |
| 177 | |
| 178 | size_t Space::MaxAllowedFootprint() { |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 179 | DCHECK(mspace_ != NULL); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 180 | return mspace_max_allowed_footprint(mspace_); |
| 181 | } |
| 182 | |
| 183 | void Space::Grow(size_t new_size) { |
Elliott Hughes | 53b6131 | 2011-08-12 18:28:20 -0700 | [diff] [blame] | 184 | UNIMPLEMENTED(FATAL); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 185 | } |
| 186 | |
| 187 | } // namespace art |