1 /* 2 * Copyright (C) 2015 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_COMPILER_DRIVER_COMPILED_METHOD_STORAGE_H_ 18 #define ART_COMPILER_DRIVER_COMPILED_METHOD_STORAGE_H_ 19 20 #include <iosfwd> 21 #include <map> 22 #include <memory> 23 24 #include "base/array_ref.h" 25 #include "base/length_prefixed_array.h" 26 #include "base/macros.h" 27 #include "utils/dedupe_set.h" 28 #include "utils/swap_space.h" 29 30 namespace art { 31 32 namespace linker { 33 class LinkerPatch; 34 } // namespace linker 35 36 class CompiledMethodStorage { 37 public: 38 explicit CompiledMethodStorage(int swap_fd); 39 ~CompiledMethodStorage(); 40 41 void DumpMemoryUsage(std::ostream& os, bool extended) const; 42 SetDedupeEnabled(bool dedupe_enabled)43 void SetDedupeEnabled(bool dedupe_enabled) { 44 dedupe_enabled_ = dedupe_enabled; 45 } DedupeEnabled()46 bool DedupeEnabled() const { 47 return dedupe_enabled_; 48 } 49 GetSwapSpaceAllocator()50 SwapAllocator<void> GetSwapSpaceAllocator() { 51 return SwapAllocator<void>(swap_space_.get()); 52 } 53 54 const LengthPrefixedArray<uint8_t>* DeduplicateCode(const ArrayRef<const uint8_t>& code); 55 void ReleaseCode(const LengthPrefixedArray<uint8_t>* code); 56 57 const LengthPrefixedArray<uint8_t>* DeduplicateVMapTable(const ArrayRef<const uint8_t>& table); 58 void ReleaseVMapTable(const LengthPrefixedArray<uint8_t>* table); 59 60 const LengthPrefixedArray<uint8_t>* DeduplicateCFIInfo(const ArrayRef<const uint8_t>& cfi_info); 61 void ReleaseCFIInfo(const LengthPrefixedArray<uint8_t>* cfi_info); 62 63 const LengthPrefixedArray<linker::LinkerPatch>* DeduplicateLinkerPatches( 64 const ArrayRef<const linker::LinkerPatch>& linker_patches); 65 void ReleaseLinkerPatches(const LengthPrefixedArray<linker::LinkerPatch>* linker_patches); 66 67 // Returns the code associated with the given patch. 68 // If the code has not been set, returns empty data. 69 // If `debug_name` is not null, stores the associated debug name in `*debug_name`. 70 ArrayRef<const uint8_t> GetThunkCode(const linker::LinkerPatch& linker_patch, 71 /*out*/ std::string* debug_name = nullptr); 72 73 // Sets the code and debug name associated with the given patch. 74 void SetThunkCode(const linker::LinkerPatch& linker_patch, 75 ArrayRef<const uint8_t> code, 76 const std::string& debug_name); 77 78 private: 79 class ThunkMapKey; 80 class ThunkMapValue; 81 using ThunkMapValueType = std::pair<const ThunkMapKey, ThunkMapValue>; 82 using ThunkMap = std::map<ThunkMapKey, 83 ThunkMapValue, 84 std::less<ThunkMapKey>, 85 SwapAllocator<ThunkMapValueType>>; 86 static_assert(std::is_same<ThunkMapValueType, ThunkMap::value_type>::value, "Value type check."); 87 88 static ThunkMapKey GetThunkMapKey(const linker::LinkerPatch& linker_patch); 89 90 template <typename T, typename DedupeSetType> 91 const LengthPrefixedArray<T>* AllocateOrDeduplicateArray(const ArrayRef<const T>& data, 92 DedupeSetType* dedupe_set); 93 94 template <typename T> 95 void ReleaseArrayIfNotDeduplicated(const LengthPrefixedArray<T>* array); 96 97 // DeDuplication data structures. 98 template <typename ContentType> 99 class DedupeHashFunc; 100 101 template <typename T> 102 class LengthPrefixedArrayAlloc; 103 104 template <typename T> 105 using ArrayDedupeSet = DedupeSet<ArrayRef<const T>, 106 LengthPrefixedArray<T>, 107 LengthPrefixedArrayAlloc<T>, 108 size_t, 109 DedupeHashFunc<const T>, 110 4>; 111 112 // Swap pool and allocator used for native allocations. May be file-backed. Needs to be first 113 // as other fields rely on this. 114 std::unique_ptr<SwapSpace> swap_space_; 115 116 bool dedupe_enabled_; 117 118 ArrayDedupeSet<uint8_t> dedupe_code_; 119 ArrayDedupeSet<uint8_t> dedupe_vmap_table_; 120 ArrayDedupeSet<uint8_t> dedupe_cfi_info_; 121 ArrayDedupeSet<linker::LinkerPatch> dedupe_linker_patches_; 122 123 Mutex thunk_map_lock_; 124 ThunkMap thunk_map_ GUARDED_BY(thunk_map_lock_); 125 126 DISALLOW_COPY_AND_ASSIGN(CompiledMethodStorage); 127 }; 128 129 } // namespace art 130 131 #endif // ART_COMPILER_DRIVER_COMPILED_METHOD_STORAGE_H_ 132