diff --git a/bundle.json b/bundle.json index 8a34f71354009a03bc88823af680209cb83a90ab..fa70ee9c9fa46be144b7129d6edf5e5462ad9728 100644 --- a/bundle.json +++ b/bundle.json @@ -23,8 +23,7 @@ "hilog", "hitrace", "init", - "ipc", - "ffrt" + "ipc" ], "third_party": [] }, diff --git a/libpurgeablemem/BUILD.gn b/libpurgeablemem/BUILD.gn index c6c3e7aa095d5cd903f5ed1cd13d7b28da0068cb..4480bf1296ac1e952bfd2dbf995cf4d9b704092c 100644 --- a/libpurgeablemem/BUILD.gn +++ b/libpurgeablemem/BUILD.gn @@ -16,12 +16,10 @@ import("//build/ohos/ndk/ndk.gni") config("libpurgeable_config") { include_dirs = [ - "include", "c/include", "common/include", "cpp/include", "interfaces/kits/c", - "//foundation/resourceschedule/ffrt/interfaces/kits/", ] cflags_cc = [ "-fexceptions" ] } @@ -37,12 +35,11 @@ ohos_shared_library("libpurgeablemem") { "cpp/src/purgeable_mem.cpp", "cpp/src/purgeable_mem_base.cpp", "cpp/src/purgeable_mem_builder.cpp", - "cpp/src/purgeable_resource_manager.cpp", "cpp/src/ux_page_table.cpp", ] + include_dirs = [ "include" ] external_deps = [ "c_utils:utils", - "ffrt:libffrt", "hilog:libhilog", "hitrace:hitrace_meter", "init:libbegetutil", diff --git a/libpurgeablemem/cpp/include/purgeable_mem_base.h b/libpurgeablemem/cpp/include/purgeable_mem_base.h index 7ec423c7d8c18c758858c383678fb7eefb288999..53d459f43070a9bb4cbe1314d2b9efe3e473a9de 100644 --- a/libpurgeablemem/cpp/include/purgeable_mem_base.h +++ b/libpurgeablemem/cpp/include/purgeable_mem_base.h @@ -25,9 +25,7 @@ #include #include "purgeable_mem_builder.h" -#include "purgeable_resource_manager.h" #include "ux_page_table.h" -#include "ffrt.h" namespace OHOS { namespace PurgeableMem { @@ -111,7 +109,7 @@ public: protected: void *dataPtr_ = nullptr; - ffrt::mutex dataLock_; + std::mutex dataLock_; bool isDataValid_ {true}; size_t dataSizeInput_ = 0; std::unique_ptr builder_ = nullptr; @@ -125,7 +123,6 @@ protected: virtual int GetPinStatus() const; virtual void AfterRebuildSucc(); virtual std::string ToString() const; - friend class PurgeableResourceManager; }; } /* namespace PurgeableMem */ } /* namespace OHOS */ diff --git a/libpurgeablemem/cpp/include/purgeable_resource_manager.h b/libpurgeablemem/cpp/include/purgeable_resource_manager.h deleted file mode 100644 index 863fee27feca92e16ae859c74a028de788ff66c8..0000000000000000000000000000000000000000 --- a/libpurgeablemem/cpp/include/purgeable_resource_manager.h +++ /dev/null @@ -1,102 +0,0 @@ -/* - * Copyright (c) 2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_UTILS_MEMORY_LIBPURGEABLEMEM_CPP_INCLUDE_PURGEABLE_RESOURCE_MANAGER_H -#define OHOS_UTILS_MEMORY_LIBPURGEABLEMEM_CPP_INCLUDE_PURGEABLE_RESOURCE_MANAGER_H - -#include -#include -#include -#include - -#include "ffrt.h" - -namespace OHOS { -namespace PurgeableMem { -const std::string THREAD_POOL_NAME = "PurgeThread"; -class PurgeableMemBase; - -class PurgeableResourceManager { -public: - PurgeableResourceManager(const PurgeableResourceManager&) = delete; - PurgeableResourceManager& operator=(const PurgeableResourceManager&) = delete; - ~PurgeableResourceManager(); - - static PurgeableResourceManager &GetInstance(); - void BeginAccessPurgeableMem(); - void EndAccessPurgeableMem(); - void AddResource(std::shared_ptr resourcePtr); - void RemoveResource(std::shared_ptr resourcePtr); - void SetRecentUsedResource(std::shared_ptr resourcePtr); - void SetLruCacheCapacity(int32_t capacity); - void Clear(); - void RemoveLastResource(); - void ShowLruCache() const; - -private: - PurgeableResourceManager(); - int32_t GetThreadPoolTaskNumFromSysPara() const; - int32_t GetLruCacheCapacityFromSysPara() const; - void ChangeDataValid(std::shared_ptr resourcePtr, bool isVaild) const; - void AddResourceInner(std::shared_ptr resourcePtr); - void RemoveResourceInner(std::shared_ptr resourcePtr); - class LruCache { - public: - /* - * Visited: visit the cache entry with the given key. - * If the entry is found, it will be move to the most-recent position in the cache. - */ - void Visited(std::shared_ptr key); - - /* - * Insert: insert the PurgeableMemBase key in the lrucache. - * Input: @key: ptr of PurgeableMemBase. - */ - void Insert(std::shared_ptr key); - - /* - * Erase: erase the PurgeableMemBase key in the lrucache. - * Input: @key: ptr of PurgeableMemBase. - */ - void Erase(std::shared_ptr key); - - /* - * SetCapacity: set the capacity of the lrucache. - * Input: the capacity of lrucache. - */ - void SetCapacity(int32_t capacity); - - /* - * Clear: clear the resourcePtrList and positionMap of the lrucache. - */ - void Clear(); - - using ListSharedPtrIterator = std::list>::iterator; - std::list> GetResourcePtrList() const; - std::shared_ptr GetLastResourcePtr() const; - size_t Size() const; - - private: - size_t lruCacheCapacity_ = 0; - std::list> resourcePtrList_; - std::unordered_map, ListSharedPtrIterator> positionMap_; - }; - - mutable ffrt::mutex lruCacheMutex_; - LruCache lruCache_; -}; -} /* namespace PurgeableMem */ -} /* namespace OHOS */ -#endif /* OHOS_UTILS_MEMORY_LIBPURGEABLEMEM_CPP_INCLUDE_PURGEABLE_RESOURCE_MANAGER_H */ \ No newline at end of file diff --git a/libpurgeablemem/cpp/src/purgeable_mem_base.cpp b/libpurgeablemem/cpp/src/purgeable_mem_base.cpp index 686130e0be24e61f9e56302bd9c6832634880654..75c3eae32149b9d256fd10c4a8294e7aefc1c70f 100644 --- a/libpurgeablemem/cpp/src/purgeable_mem_base.cpp +++ b/libpurgeablemem/cpp/src/purgeable_mem_base.cpp @@ -167,7 +167,7 @@ bool PurgeableMemBase::BeginReadWithDataLock() return false; } - std::lock_guard lock(dataLock_); + std::lock_guard lock(dataLock_); if (!isDataValid_) { return false; } diff --git a/libpurgeablemem/cpp/src/purgeable_resource_manager.cpp b/libpurgeablemem/cpp/src/purgeable_resource_manager.cpp deleted file mode 100644 index c111ced7d9951ed47f64123a8ebfd59010d741e6..0000000000000000000000000000000000000000 --- a/libpurgeablemem/cpp/src/purgeable_resource_manager.cpp +++ /dev/null @@ -1,326 +0,0 @@ -/* - * Copyright (c) 2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "hitrace_meter.h" -#include "parameters.h" -#include "pm_log.h" -#include "purgeable_mem_base.h" -#include "purgeable_resource_manager.h" - -namespace OHOS { -namespace PurgeableMem { -namespace { -/* System parameter name */ -const std::string LRU_CACHE_CAPACITY_SYS_NAME = "persist.commonlibrary.purgeable.lrucachecapacity"; -constexpr int32_t LRU_CACHE_CAPACITY = 200; -constexpr int32_t MIN_LRU_CACHE_CAPACITY = 1; -constexpr int32_t MAX_LRU_CACHE_CAPACITY = 2000; -} - -void PurgeableResourceManager::LruCache::Visited(std::shared_ptr key) -{ - if (key == nullptr) { - return; - } - - auto resourcePtrIter = positionMap_.find(key); - if (resourcePtrIter != positionMap_.end()) { - resourcePtrList_.splice(resourcePtrList_.begin(), resourcePtrList_, resourcePtrIter->second); - resourcePtrIter->second = resourcePtrList_.begin(); - } -} - -void PurgeableResourceManager::LruCache::Insert(std::shared_ptr key) -{ - if (key == nullptr) { - return; - } - - auto resourcePtrIter = positionMap_.find(key); - if (resourcePtrIter != positionMap_.end()) { - resourcePtrList_.splice(resourcePtrList_.begin(), resourcePtrList_, resourcePtrIter->second); - resourcePtrIter->second = resourcePtrList_.begin(); - return; - } - - resourcePtrList_.emplace_front(key); - positionMap_.emplace(key, resourcePtrList_.begin()); - if (resourcePtrList_.size() > lruCacheCapacity_) { - auto popResource = resourcePtrList_.back(); - if (popResource->GetPinStatus() == 0) { - popResource->Pin(); - } - positionMap_.erase(resourcePtrList_.back()); - resourcePtrList_.pop_back(); - } -} - -void PurgeableResourceManager::LruCache::Erase(std::shared_ptr key) -{ - if (key == nullptr) { - return; - } - - auto resourcePtrIter = positionMap_.find(key); - if (resourcePtrIter == positionMap_.end()) { - return; - } - - resourcePtrList_.erase(resourcePtrIter->second); - positionMap_.erase(key); -} - -void PurgeableResourceManager::LruCache::SetCapacity(int32_t capacity) -{ - if (capacity < 0 || capacity > MAX_LRU_CACHE_CAPACITY) { - PM_HILOG_DEBUG(LOG_CORE, "[PurgeableResourceManager] SetCapacity FAILED: capacity value is invalid!"); - return; - } - - lruCacheCapacity_ = capacity; - while (lruCacheCapacity_ < Size()) { - Erase(resourcePtrList_.back()); - } -} - -void PurgeableResourceManager::LruCache::Clear() -{ - positionMap_.clear(); - resourcePtrList_.clear(); -} - -std::list> PurgeableResourceManager::LruCache::GetResourcePtrList() const -{ - return resourcePtrList_; -} - -std::shared_ptr PurgeableResourceManager::LruCache::GetLastResourcePtr() const -{ - return resourcePtrList_.back(); -} - -size_t PurgeableResourceManager::LruCache::Size() const -{ - return positionMap_.size(); -} - -PurgeableResourceManager::PurgeableResourceManager() -{ - int32_t lruCacheCapacity = GetLruCacheCapacityFromSysPara(); - if (lruCacheCapacity < MIN_LRU_CACHE_CAPACITY || lruCacheCapacity > MAX_LRU_CACHE_CAPACITY) { - PM_HILOG_ERROR(LOG_CORE, "[PurgeableResourceManager] Get error lrucache capacity from system parameter."); - lruCacheCapacity = LRU_CACHE_CAPACITY; - } - lruCache_.SetCapacity(lruCacheCapacity); - PM_HILOG_DEBUG(LOG_CORE, "PurgeableResourceManager init. lruCacheCapacity is: %{public}d", lruCacheCapacity); -} - -PurgeableResourceManager::~PurgeableResourceManager() -{ - std::lock_guard lock(lruCacheMutex_); - lruCache_.Clear(); -} - -PurgeableResourceManager &PurgeableResourceManager::GetInstance() -{ - static PurgeableResourceManager instance; - return instance; -} - -void PurgeableResourceManager::BeginAccessPurgeableMem() -{ - StartTrace(HITRACE_TAG_ZIMAGE, "OHOS::PurgeableMem::PurgeableResourceManager::BeginAccessPurgeableMem"); - std::list> resourcePtrList = lruCache_.GetResourcePtrList(); - - if (resourcePtrList.size() == 0) { - FinishTrace(HITRACE_TAG_ZIMAGE); - return; - } - - std::lock_guard lock(lruCacheMutex_); - if (resourcePtrList.size() == 0) { - FinishTrace(HITRACE_TAG_ZIMAGE); - return; - } - - for (auto &resourcePtr : resourcePtrList) { - ffrt::submit([this, resourcePtr] { - if (resourcePtr == nullptr) { - return; - } - resourcePtr->BeginReadWithDataLock(); - }); - } - - FinishTrace(HITRACE_TAG_ZIMAGE); - PM_HILOG_DEBUG(LOG_CORE, "[PurgeableResourceManager] BeginAccessPurgeableMem list size: %{public}zu", - lruCache_.Size()); -} - -void PurgeableResourceManager::EndAccessPurgeableMem() -{ - StartTrace(HITRACE_TAG_ZIMAGE, "OHOS::PurgeableMem::PurgeableResourceManager::EndAccessPurgeableMem"); - std::list> resourcePtrList = lruCache_.GetResourcePtrList(); - - if (resourcePtrList.size() == 0) { - FinishTrace(HITRACE_TAG_ZIMAGE); - return; - } - - std::lock_guard lock(lruCacheMutex_); - if (resourcePtrList.size() == 0) { - FinishTrace(HITRACE_TAG_ZIMAGE); - return; - } - - for (auto &resourcePtr : resourcePtrList) { - ffrt::submit([this, resourcePtr] { - if (resourcePtr == nullptr) { - return; - } - resourcePtr->EndReadWithDataLock(); - }); - } - - FinishTrace(HITRACE_TAG_ZIMAGE); - PM_HILOG_DEBUG(LOG_CORE, "[PurgeableResourceManager] EndAccessPurgeableMem list size: %{public}zu", - lruCache_.Size()); -} - -void PurgeableResourceManager::ChangeDataValid(std::shared_ptr resourcePtr, bool isVaild) const -{ - if (resourcePtr == nullptr) { - return; - } - - StartTrace(HITRACE_TAG_ZIMAGE, "OHOS::PurgeableMem::PurgeableResourceManager::ChangeDataValid"); - std::lock_guard dataLock(resourcePtr->dataLock_); - resourcePtr->SetDataValid(isVaild); - if (!isVaild && resourcePtr->GetPinStatus() == 0) { - resourcePtr->Pin(); - } - FinishTrace(HITRACE_TAG_ZIMAGE); -} - -void PurgeableResourceManager::AddResource(std::shared_ptr resourcePtr) -{ - ffrt::submit([this, resourcePtr] { - if (resourcePtr == nullptr) { - return; - } - AddResourceInner(resourcePtr); - }); -} - -void PurgeableResourceManager::AddResourceInner(std::shared_ptr resourcePtr) -{ - StartTrace(HITRACE_TAG_ZIMAGE, "OHOS::PurgeableMem::PurgeableResourceManager::AddResource"); - std::lock_guard lock(lruCacheMutex_); - if (resourcePtr == nullptr) { - FinishTrace(HITRACE_TAG_ZIMAGE); - return; - } - - lruCache_.Insert(resourcePtr); - FinishTrace(HITRACE_TAG_ZIMAGE); - PM_HILOG_DEBUG(LOG_CORE, "[PurgeableResourceManager] AddResource resourcePtr: 0x%{public}lx, " - "list size: %{public}zu", (long)resourcePtr.get(), lruCache_.Size()); -} - -void PurgeableResourceManager::RemoveResource(std::shared_ptr resourcePtr) -{ - ChangeDataValid(resourcePtr, false); - ffrt::submit([this, resourcePtr] { - if (resourcePtr == nullptr) { - return; - } - RemoveResourceInner(resourcePtr); - }); -} - -void PurgeableResourceManager::RemoveResourceInner(std::shared_ptr resourcePtr) -{ - StartTrace(HITRACE_TAG_ZIMAGE, "OHOS::PurgeableMem::PurgeableResourceManager::RemoveResource"); - std::lock_guard lock(lruCacheMutex_); - if (resourcePtr == nullptr) { - FinishTrace(HITRACE_TAG_ZIMAGE); - return; - } - - lruCache_.Erase(resourcePtr); - FinishTrace(HITRACE_TAG_ZIMAGE); -} - -void PurgeableResourceManager::SetRecentUsedResource(std::shared_ptr resourcePtr) -{ - std::lock_guard lock(lruCacheMutex_); - if (resourcePtr == nullptr) { - return; - } - - lruCache_.Visited(resourcePtr); -} - -void PurgeableResourceManager::SetLruCacheCapacity(int32_t capacity) -{ - std::lock_guard lock(lruCacheMutex_); - lruCache_.SetCapacity(capacity); -} - -void PurgeableResourceManager::Clear() -{ - std::lock_guard lock(lruCacheMutex_); - lruCache_.Clear(); -} - -void PurgeableResourceManager::RemoveLastResource() -{ - std::lock_guard lock(lruCacheMutex_); - StartTrace(HITRACE_TAG_ZIMAGE, "OHOS::PurgeableMem::PurgeableResourceManager::RemoveLastResource"); - if (lruCache_.Size() == 0) { - FinishTrace(HITRACE_TAG_ZIMAGE); - return; - } - - std::shared_ptr resourcePtr = lruCache_.GetLastResourcePtr(); - if (resourcePtr == nullptr) { - FinishTrace(HITRACE_TAG_ZIMAGE); - return; - } - - lruCache_.Erase(resourcePtr); - FinishTrace(HITRACE_TAG_ZIMAGE); - PM_HILOG_DEBUG(LOG_CORE, "[PurgeableResourceManager] RemoveLastResource resourcePtr: 0x%{public}lx, " - "list size: %{public}zu", (long)resourcePtr.get(), lruCache_.Size()); -} - -void PurgeableResourceManager::ShowLruCache() const -{ - std::lock_guard lock(lruCacheMutex_); - std::list> resourcePtrList = lruCache_.GetResourcePtrList(); - int cnt = 0; - for (auto &resourcePtr : resourcePtrList) { - cnt++; - PM_HILOG_DEBUG(LOG_CORE, "[PurgeableResourceManager] ShowLruCache (resourcePtr: 0x%{public}lx, " - "%{public}d th, list size: %{public}zu)", (long)resourcePtr.get(), cnt, lruCache_.Size()); - } -} - -int32_t PurgeableResourceManager::GetLruCacheCapacityFromSysPara() const -{ - return system::GetIntParameter(LRU_CACHE_CAPACITY_SYS_NAME, LRU_CACHE_CAPACITY); -} -} /* namespace PurgeableMem */ -} /* namespace OHOS */ \ No newline at end of file diff --git a/libpurgeablemem/test/BUILD.gn b/libpurgeablemem/test/BUILD.gn index 417fec815f6ae22352d4f6668ac04274a2a17179..92d5f1b3fcd1934ef4dd038cd542cf25a76f5d65 100644 --- a/libpurgeablemem/test/BUILD.gn +++ b/libpurgeablemem/test/BUILD.gn @@ -61,24 +61,11 @@ ohos_unittest("purgeableashmem_test") { part_name = "memory_utils" } -ohos_unittest("purgeableresourcemanager_test") { - module_out_path = module_output_path - sources = [ "purgeableresourcemanager_test.cpp" ] - if (is_standard_system) { - external_deps = purgeable_external_deps - public_deps = purgeable_public_deps - } - - subsystem_name = "commonlibrary" - part_name = "memory_utils" -} - group("libpurgeablemem_test") { testonly = true deps = [ ":purgeable_c_test", ":purgeable_cpp_test", ":purgeableashmem_test", - ":purgeableresourcemanager_test", ] } diff --git a/libpurgeablemem/test/purgeableresourcemanager_test.cpp b/libpurgeablemem/test/purgeableresourcemanager_test.cpp deleted file mode 100644 index e8fcd7be1d9975bbfe7e66bb6d2e8120c746f718..0000000000000000000000000000000000000000 --- a/libpurgeablemem/test/purgeableresourcemanager_test.cpp +++ /dev/null @@ -1,199 +0,0 @@ -/* - * Copyright (c) 2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "gtest/gtest.h" - -#define private public -#define protected public -#include "purgeable_mem_base.h" -#include "purgeable_resource_manager.h" -#undef private -#undef protected - -namespace OHOS { -namespace PurgeableMem { -using namespace testing; -using namespace testing::ext; -constexpr int32_t MAX_LRU_CACHE_CAPACITY = 2000; - -class PurgeableResourceManagerTest : public testing::Test { -public: - static void SetUpTestCase(); - static void TearDownTestCase(); - void SetUp(); - void TearDown(); -}; - -void PurgeableResourceManagerTest::SetUpTestCase() -{ -} - -void PurgeableResourceManagerTest::TearDownTestCase() -{ -} - -void PurgeableResourceManagerTest::SetUp() -{ -} - -void PurgeableResourceManagerTest::TearDown() -{ - sleep(1); -} - -HWTEST_F(PurgeableResourceManagerTest, VisitedTest, TestSize.Level1) -{ - std::shared_ptr key = std::make_shared(); - int32_t capacity = 1; - PurgeableResourceManager::LruCache lrucache; - lrucache.SetCapacity(capacity); - lrucache.Visited(nullptr); - lrucache.Visited(key); - lrucache.Insert(key); - EXPECT_EQ(lrucache.Size(), 1); - lrucache.Visited(key); - lrucache.Clear(); - EXPECT_EQ(lrucache.Size(), 0); -} - -HWTEST_F(PurgeableResourceManagerTest, InsertTest, TestSize.Level1) -{ - std::shared_ptr key = std::make_shared(); - std::shared_ptr key1 = std::make_shared(); - int32_t capacity = 1; - PurgeableResourceManager::LruCache lrucache; - lrucache.SetCapacity(capacity); - lrucache.Insert(nullptr); - lrucache.Insert(key); - lrucache.Insert(key); - lrucache.Insert(key1); - EXPECT_EQ(lrucache.Size(), 1); - lrucache.Visited(key); - lrucache.Clear(); - EXPECT_EQ(lrucache.Size(), 0); -} - -HWTEST_F(PurgeableResourceManagerTest, EraseTest, TestSize.Level1) -{ - std::shared_ptr key = std::make_shared(); - int32_t capacity = 1; - PurgeableResourceManager::LruCache lrucache; - lrucache.SetCapacity(capacity); - lrucache.Clear(); - lrucache.Erase(nullptr); - lrucache.Erase(key); - EXPECT_EQ(lrucache.Size(), 0); - lrucache.Insert(key); - EXPECT_EQ(lrucache.Size(), 1); - lrucache.Erase(key); - EXPECT_EQ(lrucache.Size(), 0); -} - -HWTEST_F(PurgeableResourceManagerTest, SetCapacityTest, TestSize.Level1) -{ - std::shared_ptr key = std::make_shared(); - std::shared_ptr key1 = std::make_shared(); - int32_t capacity = -1; - PurgeableResourceManager::LruCache lrucache; - lrucache.SetCapacity(capacity); - capacity = MAX_LRU_CACHE_CAPACITY + 1; - lrucache.SetCapacity(capacity); - capacity = 2; - lrucache.SetCapacity(capacity); - lrucache.Erase(key); - lrucache.Erase(key1); - capacity = 1; - lrucache.SetCapacity(capacity); - lrucache.Clear(); - EXPECT_EQ(lrucache.Size(), 0); -} - -HWTEST_F(PurgeableResourceManagerTest, BeginAccessPurgeableMemTest, TestSize.Level1) -{ - std::shared_ptr key = std::make_shared(); - PurgeableResourceManager::GetInstance().BeginAccessPurgeableMem(); - PurgeableResourceManager::GetInstance().lruCache_.Insert(key); - PurgeableResourceManager::GetInstance().BeginAccessPurgeableMem(); - PurgeableResourceManager::GetInstance().BeginAccessPurgeableMem(); - EXPECT_NE(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0); - PurgeableResourceManager::GetInstance().Clear(); -} - -HWTEST_F(PurgeableResourceManagerTest, EndAccessPurgeableMemTest, TestSize.Level1) -{ - std::shared_ptr key = std::make_shared(); - PurgeableResourceManager::GetInstance().EndAccessPurgeableMem(); - PurgeableResourceManager::GetInstance().lruCache_.Insert(key); - PurgeableResourceManager::GetInstance().EndAccessPurgeableMem(); - PurgeableResourceManager::GetInstance().EndAccessPurgeableMem(); - EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 1); - PurgeableResourceManager::GetInstance().Clear(); -} - -HWTEST_F(PurgeableResourceManagerTest, AddResourceTest, TestSize.Level1) -{ - std::shared_ptr key = std::make_shared(); - PurgeableResourceManager::GetInstance().AddResource(key); - PurgeableResourceManager::GetInstance().AddResource(nullptr); - PurgeableResourceManager::GetInstance().Clear(); - EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0); -} - -HWTEST_F(PurgeableResourceManagerTest, RemoveResourceTest, TestSize.Level1) -{ - std::shared_ptr key = std::make_shared(); - PurgeableResourceManager::GetInstance().RemoveResource(nullptr); - PurgeableResourceManager::GetInstance().AddResource(key); - PurgeableResourceManager::GetInstance().RemoveResource(key); - PurgeableResourceManager::GetInstance().ChangeDataValid(key, true) ; - PurgeableResourceManager::GetInstance().ChangeDataValid(nullptr, true); - PurgeableResourceManager::GetInstance().Clear(); - EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0); -} - -HWTEST_F(PurgeableResourceManagerTest, SetRecentUsedResourceTest, TestSize.Level1) -{ - std::shared_ptr key = std::make_shared(); - PurgeableResourceManager::GetInstance().SetRecentUsedResource(nullptr); - PurgeableResourceManager::GetInstance().SetRecentUsedResource(key); - PurgeableResourceManager::GetInstance().Clear(); - EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0); -} - -HWTEST_F(PurgeableResourceManagerTest, SetLruCacheCapacityTest, TestSize.Level1) -{ - std::shared_ptr key = std::make_shared(); - int32_t capacity = 1; - PurgeableResourceManager::GetInstance().SetLruCacheCapacity(capacity); - PurgeableResourceManager::GetInstance().SetRecentUsedResource(key); - EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.lruCacheCapacity_, capacity); -} - -HWTEST_F(PurgeableResourceManagerTest, RemoveLastResourceTest, TestSize.Level1) -{ - std::shared_ptr key = std::make_shared(); - PurgeableResourceManager::GetInstance().Clear(); - PurgeableResourceManager::GetInstance().RemoveLastResource(); - PurgeableResourceManager::GetInstance().ShowLruCache(); - EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0); - PurgeableResourceManager::GetInstance().AddResource(key); - PurgeableResourceManager::GetInstance().RemoveLastResource(); - PurgeableResourceManager::GetInstance().ShowLruCache(); - EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0); - size_t newSize = 0; - key->ResizeData(newSize); -} -} -}