1 /* 2 * Copyright (c) 2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "common_interfaces/thread/thread_holder_manager.h" 17 18 #include <algorithm> 19 20 #include "common_components/mutator/mutator_manager.h" 21 #include "common_components/log/log.h" 22 #include "common_interfaces/thread/thread_holder-inl.h" 23 24 namespace common { RegisterThreadHolder(ThreadHolder * holder)25void ThreadHolderManager::RegisterThreadHolder([[maybe_unused]] ThreadHolder *holder) 26 { 27 Mutator *mutator = static_cast<Mutator *>(holder->GetMutator()); 28 29 auto& mutator_manager = MutatorManager::Instance(); 30 mutator_manager.MutatorManagementRLock(); 31 32 { 33 std::lock_guard<std::mutex> guard(mutator_manager.allMutatorListLock_); 34 mutator_manager.allMutatorList_.push_back(mutator); 35 } 36 mutator->SetMutatorPhase(Heap::GetHeap().GetGCPhase()); 37 38 mutator_manager.MutatorManagementRUnlock(); 39 } 40 BindMutator(ThreadHolder * holder)41void ThreadHolderManager::BindMutator(ThreadHolder *holder) 42 { 43 Mutator *mutator = static_cast<Mutator *>(holder->GetMutator()); 44 45 auto& mutator_manager = MutatorManager::Instance(); 46 mutator_manager.MutatorManagementRLock(); 47 48 mutator_manager.BindMutator(*mutator); 49 50 mutator_manager.MutatorManagementRUnlock(); 51 } 52 UnbindMutator(ThreadHolder * holder)53void ThreadHolderManager::UnbindMutator(ThreadHolder *holder) 54 { 55 Mutator *mutator = static_cast<Mutator *>(holder->GetMutator()); 56 57 auto& mutator_manager = MutatorManager::Instance(); 58 mutator_manager.MutatorManagementRLock(); 59 60 mutator_manager.UnbindMutator(*mutator); 61 62 mutator_manager.MutatorManagementRUnlock(); 63 } 64 65 // Note: currently only called when thread is to be destroyed. UnregisterThreadHolder(ThreadHolder * holder)66void ThreadHolderManager::UnregisterThreadHolder(ThreadHolder *holder) 67 { 68 Mutator *mutator = static_cast<Mutator *>(holder->GetMutator()); 69 70 auto& mutator_manager = MutatorManager::Instance(); 71 mutator_manager.MutatorManagementRLock(); 72 73 { 74 std::lock_guard<std::mutex> guard(mutator_manager.allMutatorListLock_); 75 auto& list = mutator_manager.allMutatorList_; 76 auto it = std::find(list.begin(), list.end(), mutator); 77 if (it != list.end()) { 78 list.erase(it); 79 } 80 } 81 mutator->ResetMutator(); 82 mutator_manager.MutatorManagementRUnlock(); 83 } 84 SuspendAll(ThreadHolder * current)85void ThreadHolderManager::SuspendAll(ThreadHolder *current) 86 { 87 DCHECK_CC(current != nullptr); 88 DCHECK_CC(!current->IsInRunningState()); 89 SuspendAllImpl(current); 90 } 91 ResumeAll(ThreadHolder * current)92void ThreadHolderManager::ResumeAll(ThreadHolder *current) 93 { 94 DCHECK_CC(current != nullptr); 95 DCHECK_CC(!current->IsInRunningState()); 96 ResumeAllImpl(current); 97 } 98 IterateAll(CommonRootVisitor visitor)99void ThreadHolderManager::IterateAll(CommonRootVisitor visitor) 100 { 101 MutatorManager::Instance().VisitAllMutators([&visitor] (Mutator &mutator) { 102 mutator.GetThreadHolder()->VisitAllThreads(visitor); 103 }); 104 } 105 SuspendAllImpl(ThreadHolder * current)106void ThreadHolderManager::SuspendAllImpl([[maybe_unused]] ThreadHolder *current) 107 { 108 MutatorManager::Instance().StopTheWorld(false, GCPhase::GC_PHASE_IDLE); 109 } 110 ResumeAllImpl(ThreadHolder * current)111void ThreadHolderManager::ResumeAllImpl(ThreadHolder *current) 112 { 113 MutatorManager::Instance().StartTheWorld(); 114 } 115 } // namespace common 116