Elliott Hughes | 2faa5f1 | 2012-01-30 14:42:07 -0800 | [diff] [blame] | 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 | */ |
Brian Carlstrom | 7e93b50 | 2011-08-04 14:16:22 -0700 | [diff] [blame] | 16 | |
| 17 | #include "intern_table.h" |
| 18 | |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 19 | #include <memory> |
| 20 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 21 | #include "gc_root-inl.h" |
Mathieu Chartier | 9750995 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 22 | #include "gc/collector/garbage_collector.h" |
Ian Rogers | 7dfb28c | 2013-08-22 08:18:36 -0700 | [diff] [blame] | 23 | #include "gc/space/image_space.h" |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 24 | #include "gc/weak_root_state.h" |
Mathieu Chartier | 4a26f17 | 2016-01-26 14:26:18 -0800 | [diff] [blame] | 25 | #include "image-inl.h" |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 26 | #include "mirror/dex_cache-inl.h" |
Ian Rogers | 7dfb28c | 2013-08-22 08:18:36 -0700 | [diff] [blame] | 27 | #include "mirror/object_array-inl.h" |
| 28 | #include "mirror/object-inl.h" |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 29 | #include "mirror/string-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 30 | #include "thread.h" |
Elliott Hughes | 814e403 | 2011-08-23 12:07:56 -0700 | [diff] [blame] | 31 | #include "utf.h" |
Brian Carlstrom | 7e93b50 | 2011-08-04 14:16:22 -0700 | [diff] [blame] | 32 | |
| 33 | namespace art { |
| 34 | |
Ian Rogers | 7dfb28c | 2013-08-22 08:18:36 -0700 | [diff] [blame] | 35 | InternTable::InternTable() |
Vladimir Marko | 1a1de67 | 2016-10-13 12:53:15 +0100 | [diff] [blame] | 36 | : log_new_roots_(false), |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 37 | weak_intern_condition_("New intern condition", *Locks::intern_table_lock_), |
| 38 | weak_root_state_(gc::kWeakRootStateNormal) { |
Mathieu Chartier | c11d9b8 | 2013-09-19 10:01:59 -0700 | [diff] [blame] | 39 | } |
Elliott Hughes | de69d7f | 2011-08-18 16:49:37 -0700 | [diff] [blame] | 40 | |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 41 | size_t InternTable::Size() const { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 42 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 43 | return strong_interns_.Size() + weak_interns_.Size(); |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 44 | } |
| 45 | |
Hiroshi Yamauchi | a91a4bc | 2014-06-13 16:44:55 -0700 | [diff] [blame] | 46 | size_t InternTable::StrongSize() const { |
| 47 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 48 | return strong_interns_.Size(); |
Hiroshi Yamauchi | a91a4bc | 2014-06-13 16:44:55 -0700 | [diff] [blame] | 49 | } |
| 50 | |
| 51 | size_t InternTable::WeakSize() const { |
| 52 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 53 | return weak_interns_.Size(); |
Hiroshi Yamauchi | a91a4bc | 2014-06-13 16:44:55 -0700 | [diff] [blame] | 54 | } |
| 55 | |
Elliott Hughes | cac6cc7 | 2011-11-03 20:31:21 -0700 | [diff] [blame] | 56 | void InternTable::DumpForSigQuit(std::ostream& os) const { |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 57 | os << "Intern table: " << StrongSize() << " strong; " << WeakSize() << " weak\n"; |
Elliott Hughes | cac6cc7 | 2011-11-03 20:31:21 -0700 | [diff] [blame] | 58 | } |
| 59 | |
Mathieu Chartier | bb87e0f | 2015-04-03 11:21:55 -0700 | [diff] [blame] | 60 | void InternTable::VisitRoots(RootVisitor* visitor, VisitRootFlags flags) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 61 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 62 | if ((flags & kVisitRootFlagAllRoots) != 0) { |
Mathieu Chartier | bb87e0f | 2015-04-03 11:21:55 -0700 | [diff] [blame] | 63 | strong_interns_.VisitRoots(visitor); |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 64 | } else if ((flags & kVisitRootFlagNewRoots) != 0) { |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 65 | for (auto& root : new_strong_intern_roots_) { |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 66 | ObjPtr<mirror::String> old_ref = root.Read<kWithoutReadBarrier>(); |
Mathieu Chartier | bb87e0f | 2015-04-03 11:21:55 -0700 | [diff] [blame] | 67 | root.VisitRoot(visitor, RootInfo(kRootInternedString)); |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 68 | ObjPtr<mirror::String> new_ref = root.Read<kWithoutReadBarrier>(); |
Mathieu Chartier | c2e2062 | 2014-11-03 11:41:47 -0800 | [diff] [blame] | 69 | if (new_ref != old_ref) { |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 70 | // The GC moved a root in the log. Need to search the strong interns and update the |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 71 | // corresponding object. This is slow, but luckily for us, this may only happen with a |
| 72 | // concurrent moving GC. |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 73 | strong_interns_.Remove(old_ref); |
| 74 | strong_interns_.Insert(new_ref); |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 75 | } |
| 76 | } |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 77 | } |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 78 | if ((flags & kVisitRootFlagClearRootLog) != 0) { |
| 79 | new_strong_intern_roots_.clear(); |
| 80 | } |
| 81 | if ((flags & kVisitRootFlagStartLoggingNewRoots) != 0) { |
| 82 | log_new_roots_ = true; |
| 83 | } else if ((flags & kVisitRootFlagStopLoggingNewRoots) != 0) { |
| 84 | log_new_roots_ = false; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 85 | } |
Mathieu Chartier | 423d2a3 | 2013-09-12 17:33:56 -0700 | [diff] [blame] | 86 | // Note: we deliberately don't visit the weak_interns_ table and the immutable image roots. |
Brian Carlstrom | 7e93b50 | 2011-08-04 14:16:22 -0700 | [diff] [blame] | 87 | } |
| 88 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 89 | ObjPtr<mirror::String> InternTable::LookupWeak(Thread* self, ObjPtr<mirror::String> s) { |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 90 | MutexLock mu(self, *Locks::intern_table_lock_); |
| 91 | return LookupWeakLocked(s); |
Mathieu Chartier | f7fd970 | 2015-11-09 11:16:49 -0800 | [diff] [blame] | 92 | } |
| 93 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 94 | ObjPtr<mirror::String> InternTable::LookupStrong(Thread* self, ObjPtr<mirror::String> s) { |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 95 | MutexLock mu(self, *Locks::intern_table_lock_); |
| 96 | return LookupStrongLocked(s); |
| 97 | } |
| 98 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 99 | ObjPtr<mirror::String> InternTable::LookupStrong(Thread* self, |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 100 | uint32_t utf16_length, |
| 101 | const char* utf8_data) { |
| 102 | DCHECK_EQ(utf16_length, CountModifiedUtf8Chars(utf8_data)); |
| 103 | Utf8String string(utf16_length, |
| 104 | utf8_data, |
| 105 | ComputeUtf16HashFromModifiedUtf8(utf8_data, utf16_length)); |
| 106 | MutexLock mu(self, *Locks::intern_table_lock_); |
| 107 | return strong_interns_.Find(string); |
| 108 | } |
| 109 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 110 | ObjPtr<mirror::String> InternTable::LookupWeakLocked(ObjPtr<mirror::String> s) { |
Nicolas Geoffray | 1bc977c | 2016-01-23 14:15:49 +0000 | [diff] [blame] | 111 | return weak_interns_.Find(s); |
| 112 | } |
| 113 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 114 | ObjPtr<mirror::String> InternTable::LookupStrongLocked(ObjPtr<mirror::String> s) { |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 115 | return strong_interns_.Find(s); |
| 116 | } |
| 117 | |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 118 | void InternTable::AddNewTable() { |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 119 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 120 | weak_interns_.AddNewTable(); |
| 121 | strong_interns_.AddNewTable(); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 122 | } |
| 123 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 124 | ObjPtr<mirror::String> InternTable::InsertStrong(ObjPtr<mirror::String> s) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 125 | Runtime* runtime = Runtime::Current(); |
| 126 | if (runtime->IsActiveTransaction()) { |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 127 | runtime->RecordStrongStringInsertion(s); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 128 | } |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 129 | if (log_new_roots_) { |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 130 | new_strong_intern_roots_.push_back(GcRoot<mirror::String>(s)); |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 131 | } |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 132 | strong_interns_.Insert(s); |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 133 | return s; |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 134 | } |
| 135 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 136 | ObjPtr<mirror::String> InternTable::InsertWeak(ObjPtr<mirror::String> s) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 137 | Runtime* runtime = Runtime::Current(); |
| 138 | if (runtime->IsActiveTransaction()) { |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 139 | runtime->RecordWeakStringInsertion(s); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 140 | } |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 141 | weak_interns_.Insert(s); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 142 | return s; |
| 143 | } |
| 144 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 145 | void InternTable::RemoveStrong(ObjPtr<mirror::String> s) { |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 146 | strong_interns_.Remove(s); |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 147 | } |
| 148 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 149 | void InternTable::RemoveWeak(ObjPtr<mirror::String> s) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 150 | Runtime* runtime = Runtime::Current(); |
| 151 | if (runtime->IsActiveTransaction()) { |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 152 | runtime->RecordWeakStringRemoval(s); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 153 | } |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 154 | weak_interns_.Remove(s); |
Brian Carlstrom | 7e93b50 | 2011-08-04 14:16:22 -0700 | [diff] [blame] | 155 | } |
| 156 | |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 157 | // Insert/remove methods used to undo changes made during an aborted transaction. |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 158 | ObjPtr<mirror::String> InternTable::InsertStrongFromTransaction(ObjPtr<mirror::String> s) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 159 | DCHECK(!Runtime::Current()->IsActiveTransaction()); |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 160 | return InsertStrong(s); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 161 | } |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 162 | |
| 163 | ObjPtr<mirror::String> InternTable::InsertWeakFromTransaction(ObjPtr<mirror::String> s) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 164 | DCHECK(!Runtime::Current()->IsActiveTransaction()); |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 165 | return InsertWeak(s); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 166 | } |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 167 | |
| 168 | void InternTable::RemoveStrongFromTransaction(ObjPtr<mirror::String> s) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 169 | DCHECK(!Runtime::Current()->IsActiveTransaction()); |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 170 | RemoveStrong(s); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 171 | } |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 172 | |
| 173 | void InternTable::RemoveWeakFromTransaction(ObjPtr<mirror::String> s) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 174 | DCHECK(!Runtime::Current()->IsActiveTransaction()); |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 175 | RemoveWeak(s); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 176 | } |
| 177 | |
Mathieu Chartier | 205b762 | 2016-01-06 15:47:09 -0800 | [diff] [blame] | 178 | void InternTable::AddImagesStringsToTable(const std::vector<gc::space::ImageSpace*>& image_spaces) { |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 179 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
Mathieu Chartier | 205b762 | 2016-01-06 15:47:09 -0800 | [diff] [blame] | 180 | for (gc::space::ImageSpace* image_space : image_spaces) { |
| 181 | const ImageHeader* const header = &image_space->GetImageHeader(); |
| 182 | // Check if we have the interned strings section. |
| 183 | const ImageSection& section = header->GetImageSection(ImageHeader::kSectionInternedStrings); |
| 184 | if (section.Size() > 0) { |
| 185 | AddTableFromMemoryLocked(image_space->Begin() + section.Offset()); |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 186 | } |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 187 | } |
Ian Rogers | 7dfb28c | 2013-08-22 08:18:36 -0700 | [diff] [blame] | 188 | } |
| 189 | |
Hiroshi Yamauchi | 0b71357 | 2015-06-16 18:29:23 -0700 | [diff] [blame] | 190 | void InternTable::BroadcastForNewInterns() { |
| 191 | CHECK(kUseReadBarrier); |
| 192 | Thread* self = Thread::Current(); |
| 193 | MutexLock mu(self, *Locks::intern_table_lock_); |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 194 | weak_intern_condition_.Broadcast(self); |
Hiroshi Yamauchi | 0b71357 | 2015-06-16 18:29:23 -0700 | [diff] [blame] | 195 | } |
| 196 | |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 197 | void InternTable::WaitUntilAccessible(Thread* self) { |
| 198 | Locks::intern_table_lock_->ExclusiveUnlock(self); |
Mathieu Chartier | f1d666e | 2015-09-03 16:13:34 -0700 | [diff] [blame] | 199 | { |
| 200 | ScopedThreadSuspension sts(self, kWaitingWeakGcRootRead); |
| 201 | MutexLock mu(self, *Locks::intern_table_lock_); |
Hiroshi Yamauchi | 9e6f097 | 2016-11-03 13:03:20 -0700 | [diff] [blame] | 202 | while ((!kUseReadBarrier && weak_root_state_ == gc::kWeakRootStateNoReadsOrWrites) || |
| 203 | (kUseReadBarrier && !self->GetWeakRefAccessEnabled())) { |
Mathieu Chartier | f1d666e | 2015-09-03 16:13:34 -0700 | [diff] [blame] | 204 | weak_intern_condition_.Wait(self); |
| 205 | } |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 206 | } |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 207 | Locks::intern_table_lock_->ExclusiveLock(self); |
| 208 | } |
| 209 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 210 | ObjPtr<mirror::String> InternTable::Insert(ObjPtr<mirror::String> s, |
| 211 | bool is_strong, |
| 212 | bool holding_locks) { |
Mathieu Chartier | c2e2062 | 2014-11-03 11:41:47 -0800 | [diff] [blame] | 213 | if (s == nullptr) { |
| 214 | return nullptr; |
| 215 | } |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 216 | Thread* const self = Thread::Current(); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 217 | MutexLock mu(self, *Locks::intern_table_lock_); |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 218 | if (kDebugLocking && !holding_locks) { |
| 219 | Locks::mutator_lock_->AssertSharedHeld(self); |
| 220 | CHECK_EQ(2u, self->NumberOfHeldMutexes()) << "may only safely hold the mutator lock"; |
Mathieu Chartier | c11d9b8 | 2013-09-19 10:01:59 -0700 | [diff] [blame] | 221 | } |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 222 | while (true) { |
Mathieu Chartier | 90ef3db | 2015-08-04 15:19:41 -0700 | [diff] [blame] | 223 | if (holding_locks) { |
| 224 | if (!kUseReadBarrier) { |
| 225 | CHECK_EQ(weak_root_state_, gc::kWeakRootStateNormal); |
| 226 | } else { |
| 227 | CHECK(self->GetWeakRefAccessEnabled()); |
| 228 | } |
| 229 | } |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 230 | // Check the strong table for a match. |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 231 | ObjPtr<mirror::String> strong = LookupStrongLocked(s); |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 232 | if (strong != nullptr) { |
| 233 | return strong; |
| 234 | } |
Mathieu Chartier | 90ef3db | 2015-08-04 15:19:41 -0700 | [diff] [blame] | 235 | if ((!kUseReadBarrier && weak_root_state_ != gc::kWeakRootStateNoReadsOrWrites) || |
| 236 | (kUseReadBarrier && self->GetWeakRefAccessEnabled())) { |
| 237 | break; |
| 238 | } |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 239 | // weak_root_state_ is set to gc::kWeakRootStateNoReadsOrWrites in the GC pause but is only |
| 240 | // cleared after SweepSystemWeaks has completed. This is why we need to wait until it is |
| 241 | // cleared. |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 242 | CHECK(!holding_locks); |
| 243 | StackHandleScope<1> hs(self); |
| 244 | auto h = hs.NewHandleWrapper(&s); |
| 245 | WaitUntilAccessible(self); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 246 | } |
Mathieu Chartier | 90ef3db | 2015-08-04 15:19:41 -0700 | [diff] [blame] | 247 | if (!kUseReadBarrier) { |
| 248 | CHECK_EQ(weak_root_state_, gc::kWeakRootStateNormal); |
| 249 | } else { |
| 250 | CHECK(self->GetWeakRefAccessEnabled()); |
| 251 | } |
Mathieu Chartier | c2e2062 | 2014-11-03 11:41:47 -0800 | [diff] [blame] | 252 | // There is no match in the strong table, check the weak table. |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 253 | ObjPtr<mirror::String> weak = LookupWeakLocked(s); |
Mathieu Chartier | c2e2062 | 2014-11-03 11:41:47 -0800 | [diff] [blame] | 254 | if (weak != nullptr) { |
| 255 | if (is_strong) { |
| 256 | // A match was found in the weak table. Promote to the strong table. |
| 257 | RemoveWeak(weak); |
| 258 | return InsertStrong(weak); |
| 259 | } |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 260 | return weak; |
| 261 | } |
Mathieu Chartier | c2e2062 | 2014-11-03 11:41:47 -0800 | [diff] [blame] | 262 | // No match in the strong table or the weak table. Insert into the strong / weak table. |
| 263 | return is_strong ? InsertStrong(s) : InsertWeak(s); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 264 | } |
| 265 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 266 | ObjPtr<mirror::String> InternTable::InternStrong(int32_t utf16_length, const char* utf8_data) { |
Mathieu Chartier | ed0fc1d | 2014-03-21 14:09:35 -0700 | [diff] [blame] | 267 | DCHECK(utf8_data != nullptr); |
Vladimir Marko | d2bdb9b | 2016-07-08 17:23:22 +0100 | [diff] [blame] | 268 | Thread* self = Thread::Current(); |
| 269 | // Try to avoid allocation. |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 270 | ObjPtr<mirror::String> s = LookupStrong(self, utf16_length, utf8_data); |
Vladimir Marko | d2bdb9b | 2016-07-08 17:23:22 +0100 | [diff] [blame] | 271 | if (s != nullptr) { |
| 272 | return s; |
| 273 | } |
Ian Rogers | 7dfb28c | 2013-08-22 08:18:36 -0700 | [diff] [blame] | 274 | return InternStrong(mirror::String::AllocFromModifiedUtf8( |
Vladimir Marko | d2bdb9b | 2016-07-08 17:23:22 +0100 | [diff] [blame] | 275 | self, utf16_length, utf8_data)); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 276 | } |
| 277 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 278 | ObjPtr<mirror::String> InternTable::InternStrong(const char* utf8_data) { |
Mathieu Chartier | ed0fc1d | 2014-03-21 14:09:35 -0700 | [diff] [blame] | 279 | DCHECK(utf8_data != nullptr); |
| 280 | return InternStrong(mirror::String::AllocFromModifiedUtf8(Thread::Current(), utf8_data)); |
Brian Carlstrom | c74255f | 2011-09-11 22:47:39 -0700 | [diff] [blame] | 281 | } |
| 282 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 283 | ObjPtr<mirror::String> InternTable::InternStrongImageString(ObjPtr<mirror::String> s) { |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 284 | // May be holding the heap bitmap lock. |
| 285 | return Insert(s, true, true); |
| 286 | } |
| 287 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 288 | ObjPtr<mirror::String> InternTable::InternStrong(ObjPtr<mirror::String> s) { |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 289 | return Insert(s, true, false); |
Brian Carlstrom | c74255f | 2011-09-11 22:47:39 -0700 | [diff] [blame] | 290 | } |
| 291 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 292 | ObjPtr<mirror::String> InternTable::InternWeak(ObjPtr<mirror::String> s) { |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 293 | return Insert(s, false, false); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 294 | } |
| 295 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 296 | bool InternTable::ContainsWeak(ObjPtr<mirror::String> s) { |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 297 | return LookupWeak(Thread::Current(), s) == s; |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 298 | } |
| 299 | |
Mathieu Chartier | 9750995 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 300 | void InternTable::SweepInternTableWeaks(IsMarkedVisitor* visitor) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 301 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
Mathieu Chartier | 9750995 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 302 | weak_interns_.SweepWeaks(visitor); |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 303 | } |
| 304 | |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 305 | size_t InternTable::AddTableFromMemory(const uint8_t* ptr) { |
Mathieu Chartier | d39645e | 2015-06-09 17:50:29 -0700 | [diff] [blame] | 306 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 307 | return AddTableFromMemoryLocked(ptr); |
Mathieu Chartier | d39645e | 2015-06-09 17:50:29 -0700 | [diff] [blame] | 308 | } |
| 309 | |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 310 | size_t InternTable::AddTableFromMemoryLocked(const uint8_t* ptr) { |
| 311 | return strong_interns_.AddTableFromMemory(ptr); |
Mathieu Chartier | d39645e | 2015-06-09 17:50:29 -0700 | [diff] [blame] | 312 | } |
| 313 | |
| 314 | size_t InternTable::WriteToMemory(uint8_t* ptr) { |
| 315 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 316 | return strong_interns_.WriteToMemory(ptr); |
Mathieu Chartier | d39645e | 2015-06-09 17:50:29 -0700 | [diff] [blame] | 317 | } |
| 318 | |
Mathieu Chartier | c2e2062 | 2014-11-03 11:41:47 -0800 | [diff] [blame] | 319 | std::size_t InternTable::StringHashEquals::operator()(const GcRoot<mirror::String>& root) const { |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 320 | if (kIsDebugBuild) { |
| 321 | Locks::mutator_lock_->AssertSharedHeld(Thread::Current()); |
| 322 | } |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 323 | return static_cast<size_t>(root.Read<kWithoutReadBarrier>()->GetHashCode()); |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 324 | } |
| 325 | |
| 326 | bool InternTable::StringHashEquals::operator()(const GcRoot<mirror::String>& a, |
Mathieu Chartier | c2e2062 | 2014-11-03 11:41:47 -0800 | [diff] [blame] | 327 | const GcRoot<mirror::String>& b) const { |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 328 | if (kIsDebugBuild) { |
| 329 | Locks::mutator_lock_->AssertSharedHeld(Thread::Current()); |
| 330 | } |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 331 | return a.Read<kWithoutReadBarrier>()->Equals(b.Read<kWithoutReadBarrier>()); |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 332 | } |
| 333 | |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 334 | bool InternTable::StringHashEquals::operator()(const GcRoot<mirror::String>& a, |
| 335 | const Utf8String& b) const { |
| 336 | if (kIsDebugBuild) { |
| 337 | Locks::mutator_lock_->AssertSharedHeld(Thread::Current()); |
| 338 | } |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 339 | ObjPtr<mirror::String> a_string = a.Read<kWithoutReadBarrier>(); |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 340 | uint32_t a_length = static_cast<uint32_t>(a_string->GetLength()); |
| 341 | if (a_length != b.GetUtf16Length()) { |
| 342 | return false; |
| 343 | } |
jessicahandojo | 3aaa37b | 2016-07-29 14:46:37 -0700 | [diff] [blame] | 344 | if (a_string->IsCompressed()) { |
| 345 | size_t b_byte_count = strlen(b.GetUtf8Data()); |
| 346 | size_t b_utf8_length = CountModifiedUtf8Chars(b.GetUtf8Data(), b_byte_count); |
| 347 | // Modified UTF-8 single byte character range is 0x01 .. 0x7f |
| 348 | // The string compression occurs on regular ASCII with same exact range, |
| 349 | // not on extended ASCII which up to 0xff |
| 350 | const bool is_b_regular_ascii = (b_byte_count == b_utf8_length); |
| 351 | if (is_b_regular_ascii) { |
| 352 | return memcmp(b.GetUtf8Data(), |
| 353 | a_string->GetValueCompressed(), a_length * sizeof(uint8_t)) == 0; |
| 354 | } else { |
| 355 | return false; |
| 356 | } |
| 357 | } else { |
| 358 | const uint16_t* a_value = a_string->GetValue(); |
| 359 | return CompareModifiedUtf8ToUtf16AsCodePointValues(b.GetUtf8Data(), a_value, a_length) == 0; |
| 360 | } |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 361 | } |
| 362 | |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 363 | size_t InternTable::Table::AddTableFromMemory(const uint8_t* ptr) { |
Mathieu Chartier | d39645e | 2015-06-09 17:50:29 -0700 | [diff] [blame] | 364 | size_t read_count = 0; |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 365 | UnorderedSet set(ptr, /*make copy*/false, &read_count); |
Mathieu Chartier | 619a457 | 2016-04-05 19:13:37 -0700 | [diff] [blame] | 366 | if (set.Empty()) { |
| 367 | // Avoid inserting empty sets. |
| 368 | return read_count; |
| 369 | } |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 370 | // TODO: Disable this for app images if app images have intern tables. |
| 371 | static constexpr bool kCheckDuplicates = true; |
| 372 | if (kCheckDuplicates) { |
| 373 | for (GcRoot<mirror::String>& string : set) { |
| 374 | CHECK(Find(string.Read()) == nullptr) << "Already found " << string.Read()->ToModifiedUtf8(); |
| 375 | } |
| 376 | } |
Mathieu Chartier | 619a457 | 2016-04-05 19:13:37 -0700 | [diff] [blame] | 377 | // Insert at the front since we add new interns into the back. |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 378 | tables_.insert(tables_.begin(), std::move(set)); |
Mathieu Chartier | d39645e | 2015-06-09 17:50:29 -0700 | [diff] [blame] | 379 | return read_count; |
| 380 | } |
| 381 | |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 382 | size_t InternTable::Table::WriteToMemory(uint8_t* ptr) { |
| 383 | if (tables_.empty()) { |
| 384 | return 0; |
| 385 | } |
| 386 | UnorderedSet* table_to_write; |
| 387 | UnorderedSet combined; |
| 388 | if (tables_.size() > 1) { |
| 389 | table_to_write = &combined; |
| 390 | for (UnorderedSet& table : tables_) { |
| 391 | for (GcRoot<mirror::String>& string : table) { |
| 392 | combined.Insert(string); |
| 393 | } |
| 394 | } |
| 395 | } else { |
| 396 | table_to_write = &tables_.back(); |
| 397 | } |
| 398 | return table_to_write->WriteToMemory(ptr); |
Mathieu Chartier | d39645e | 2015-06-09 17:50:29 -0700 | [diff] [blame] | 399 | } |
| 400 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 401 | void InternTable::Table::Remove(ObjPtr<mirror::String> s) { |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 402 | for (UnorderedSet& table : tables_) { |
| 403 | auto it = table.Find(GcRoot<mirror::String>(s)); |
| 404 | if (it != table.end()) { |
| 405 | table.Erase(it); |
| 406 | return; |
| 407 | } |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 408 | } |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 409 | LOG(FATAL) << "Attempting to remove non-interned string " << s->ToModifiedUtf8(); |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 410 | } |
| 411 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 412 | ObjPtr<mirror::String> InternTable::Table::Find(ObjPtr<mirror::String> s) { |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 413 | Locks::intern_table_lock_->AssertHeld(Thread::Current()); |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 414 | for (UnorderedSet& table : tables_) { |
| 415 | auto it = table.Find(GcRoot<mirror::String>(s)); |
| 416 | if (it != table.end()) { |
| 417 | return it->Read(); |
| 418 | } |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 419 | } |
| 420 | return nullptr; |
| 421 | } |
| 422 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 423 | ObjPtr<mirror::String> InternTable::Table::Find(const Utf8String& string) { |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 424 | Locks::intern_table_lock_->AssertHeld(Thread::Current()); |
| 425 | for (UnorderedSet& table : tables_) { |
| 426 | auto it = table.Find(string); |
| 427 | if (it != table.end()) { |
| 428 | return it->Read(); |
| 429 | } |
| 430 | } |
| 431 | return nullptr; |
| 432 | } |
| 433 | |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 434 | void InternTable::Table::AddNewTable() { |
| 435 | tables_.push_back(UnorderedSet()); |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 436 | } |
| 437 | |
Mathieu Chartier | 9e86809 | 2016-10-31 14:58:04 -0700 | [diff] [blame] | 438 | void InternTable::Table::Insert(ObjPtr<mirror::String> s) { |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 439 | // Always insert the last table, the image tables are before and we avoid inserting into these |
| 440 | // to prevent dirty pages. |
| 441 | DCHECK(!tables_.empty()); |
| 442 | tables_.back().Insert(GcRoot<mirror::String>(s)); |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 443 | } |
| 444 | |
Mathieu Chartier | bb87e0f | 2015-04-03 11:21:55 -0700 | [diff] [blame] | 445 | void InternTable::Table::VisitRoots(RootVisitor* visitor) { |
Mathieu Chartier | 4809d0a | 2015-04-07 10:39:04 -0700 | [diff] [blame] | 446 | BufferedRootVisitor<kDefaultBufferedRootCount> buffered_visitor( |
| 447 | visitor, RootInfo(kRootInternedString)); |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 448 | for (UnorderedSet& table : tables_) { |
| 449 | for (auto& intern : table) { |
| 450 | buffered_visitor.VisitRoot(intern); |
| 451 | } |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 452 | } |
| 453 | } |
| 454 | |
Mathieu Chartier | 9750995 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 455 | void InternTable::Table::SweepWeaks(IsMarkedVisitor* visitor) { |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 456 | for (UnorderedSet& table : tables_) { |
| 457 | SweepWeaks(&table, visitor); |
| 458 | } |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 459 | } |
| 460 | |
Mathieu Chartier | 9750995 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 461 | void InternTable::Table::SweepWeaks(UnorderedSet* set, IsMarkedVisitor* visitor) { |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 462 | for (auto it = set->begin(), end = set->end(); it != end;) { |
| 463 | // This does not need a read barrier because this is called by GC. |
Mathieu Chartier | c2e2062 | 2014-11-03 11:41:47 -0800 | [diff] [blame] | 464 | mirror::Object* object = it->Read<kWithoutReadBarrier>(); |
Mathieu Chartier | 9750995 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 465 | mirror::Object* new_object = visitor->IsMarked(object); |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 466 | if (new_object == nullptr) { |
Mathieu Chartier | c2e2062 | 2014-11-03 11:41:47 -0800 | [diff] [blame] | 467 | it = set->Erase(it); |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 468 | } else { |
Mathieu Chartier | c2e2062 | 2014-11-03 11:41:47 -0800 | [diff] [blame] | 469 | *it = GcRoot<mirror::String>(new_object->AsString()); |
Mathieu Chartier | eb175f7 | 2014-10-31 11:49:27 -0700 | [diff] [blame] | 470 | ++it; |
| 471 | } |
| 472 | } |
| 473 | } |
| 474 | |
Mathieu Chartier | c2e2062 | 2014-11-03 11:41:47 -0800 | [diff] [blame] | 475 | size_t InternTable::Table::Size() const { |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 476 | return std::accumulate(tables_.begin(), |
| 477 | tables_.end(), |
Mathieu Chartier | 205b762 | 2016-01-06 15:47:09 -0800 | [diff] [blame] | 478 | 0U, |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 479 | [](size_t sum, const UnorderedSet& set) { |
| 480 | return sum + set.Size(); |
| 481 | }); |
Mathieu Chartier | c2e2062 | 2014-11-03 11:41:47 -0800 | [diff] [blame] | 482 | } |
| 483 | |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 484 | void InternTable::ChangeWeakRootState(gc::WeakRootState new_state) { |
| 485 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
| 486 | ChangeWeakRootStateLocked(new_state); |
| 487 | } |
| 488 | |
| 489 | void InternTable::ChangeWeakRootStateLocked(gc::WeakRootState new_state) { |
Hiroshi Yamauchi | fdbd13c | 2015-09-02 16:16:58 -0700 | [diff] [blame] | 490 | CHECK(!kUseReadBarrier); |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 491 | weak_root_state_ = new_state; |
| 492 | if (new_state != gc::kWeakRootStateNoReadsOrWrites) { |
| 493 | weak_intern_condition_.Broadcast(Thread::Current()); |
| 494 | } |
| 495 | } |
| 496 | |
Mathieu Chartier | 32cc9ee | 2015-10-15 09:19:15 -0700 | [diff] [blame] | 497 | InternTable::Table::Table() { |
| 498 | Runtime* const runtime = Runtime::Current(); |
Mathieu Chartier | ea0831f | 2015-12-29 13:17:37 -0800 | [diff] [blame] | 499 | // Initial table. |
| 500 | tables_.push_back(UnorderedSet()); |
| 501 | tables_.back().SetLoadFactor(runtime->GetHashTableMinLoadFactor(), |
| 502 | runtime->GetHashTableMaxLoadFactor()); |
Mathieu Chartier | 32cc9ee | 2015-10-15 09:19:15 -0700 | [diff] [blame] | 503 | } |
| 504 | |
Brian Carlstrom | 7e93b50 | 2011-08-04 14:16:22 -0700 | [diff] [blame] | 505 | } // namespace art |