image_space.h revision 31f441464c0c8f840aba37e236ad133f30308d70
1/* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifndef ART_RUNTIME_GC_SPACE_IMAGE_SPACE_H_ 18#define ART_RUNTIME_GC_SPACE_IMAGE_SPACE_H_ 19 20#include "space.h" 21 22namespace art { 23 24class OatFile; 25 26namespace gc { 27namespace space { 28 29// An image space is a space backed with a memory mapped image. 30class ImageSpace : public MemMapSpace { 31 public: 32 SpaceType GetType() const { 33 return kSpaceTypeImageSpace; 34 } 35 36 // Create a Space from an image file. Cannot be used for future 37 // allocation or collected. 38 // 39 // Create also opens the OatFile associated with the image file so 40 // that it be contiguously allocated with the image before the 41 // creation of the alloc space. The ReleaseOatFile will later be 42 // used to transfer ownership of the OatFile to the ClassLinker when 43 // it is initialized. 44 static ImageSpace* Create(const char* image) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 45 46 // Releases the OatFile from the ImageSpace so it can be transfer to 47 // the caller, presumably the ClassLinker. 48 OatFile* ReleaseOatFile() 49 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 50 51 void VerifyImageAllocations() 52 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 53 54 const ImageHeader& GetImageHeader() const { 55 return *reinterpret_cast<ImageHeader*>(Begin()); 56 } 57 58 const std::string GetImageFilename() const { 59 return GetName(); 60 } 61 62 accounting::SpaceBitmap* GetLiveBitmap() const { 63 return live_bitmap_.get(); 64 } 65 66 accounting::SpaceBitmap* GetMarkBitmap() const { 67 // ImageSpaces have the same bitmap for both live and marked. This helps reduce the number of 68 // special cases to test against. 69 return live_bitmap_.get(); 70 } 71 72 void Dump(std::ostream& os) const; 73 74 // Sweeping image spaces is a NOP. 75 void Sweep(bool /* swap_bitmaps */, size_t* /* freed_objects */, size_t* /* freed_bytes */) { 76 } 77 78 bool CanMoveObjects() const OVERRIDE { 79 return false; 80 } 81 82 private: 83 // Tries to initialize an ImageSpace from the given image path, 84 // returning NULL on error. 85 // 86 // If validate_oat_file is false (for /system), do not verify that 87 // image's OatFile is up-to-date relative to its DexFile 88 // inputs. Otherwise (for /data), validate the inputs and generate 89 // the OatFile in /data/dalvik-cache if necessary. 90 static ImageSpace* Init(const char* image, bool validate_oat_file, std::string* error_msg) 91 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 92 93 OatFile* OpenOatFile(const char* image, std::string* error_msg) const 94 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 95 96 bool ValidateOatFile(std::string* error_msg) const 97 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 98 99 friend class Space; 100 101 static Atomic<uint32_t> bitmap_index_; 102 103 UniquePtr<accounting::SpaceBitmap> live_bitmap_; 104 105 ImageSpace(const std::string& name, MemMap* mem_map, accounting::SpaceBitmap* live_bitmap); 106 107 // The OatFile associated with the image during early startup to 108 // reserve space contiguous to the image. It is later released to 109 // the ClassLinker during it's initialization. 110 UniquePtr<OatFile> oat_file_; 111 112 DISALLOW_COPY_AND_ASSIGN(ImageSpace); 113}; 114 115} // namespace space 116} // namespace gc 117} // namespace art 118 119#endif // ART_RUNTIME_GC_SPACE_IMAGE_SPACE_H_ 120