Merge "split LightRefBase out of RefBase" into oc-dev (ed6aad1c) · Commits · e / os / android_system_core

libutils/RefBase.cpp

+0 −2

Original line number	Diff line number	Diff line
		@@ -760,6 +760,4 @@ void RefBase::renameRefId(RefBase* ref,
		ref->mRefs->renameWeakRefId(old_id, new_id);
		}

		VirtualLightRefBase::~VirtualLightRefBase() {}

		}; // namespace android

libutils/include/utils/LightRefBase.h

0 → 100644

+72 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2017 The Android Open Source Project
		*
		* 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.
		*/

		#pragma once

		/*
		* See documentation in RefBase.h
		*/

		#include <atomic>

		#include <sys/types.h>

		namespace android {

		class ReferenceRenamer;

		template <class T>
		class LightRefBase
		{
		public:
		inline LightRefBase() : mCount(0) { }
		inline void incStrong(__attribute__((unused)) const void* id) const {
		mCount.fetch_add(1, std::memory_order_relaxed);
		}
		inline void decStrong(__attribute__((unused)) const void* id) const {
		if (mCount.fetch_sub(1, std::memory_order_release) == 1) {
		std::atomic_thread_fence(std::memory_order_acquire);
		delete static_cast<const T*>(this);
		}
		}
		//! DEBUGGING ONLY: Get current strong ref count.
		inline int32_t getStrongCount() const {
		return mCount.load(std::memory_order_relaxed);
		}

		typedef LightRefBase<T> basetype;

		protected:
		inline ~LightRefBase() { }

		private:
		friend class ReferenceMover;
		inline static void renameRefs(size_t /n/, const ReferenceRenamer& /renamer/) { }
		inline static void renameRefId(T* /ref/, const void* /old_id/ , const void* /new_id/) { }

		private:
		mutable std::atomic<int32_t> mCount;
		};


		// This is a wrapper around LightRefBase that simply enforces a virtual
		// destructor to eliminate the template requirement of LightRefBase
		class VirtualLightRefBase : public LightRefBase<VirtualLightRefBase> {
		public:
		virtual ~VirtualLightRefBase() = default;
		};

		}; // namespace android

libutils/include/utils/RefBase.h

+18 −57

Original line number	Diff line number	Diff line
		@@ -177,6 +177,9 @@
		#include <stdlib.h>
		#include <string.h>

		// LightRefBase used to be declared in this header, so we have to include it
		#include <utils/LightRefBase.h>

		#include <utils/StrongPointer.h>
		#include <utils/TypeHelpers.h>

		@@ -216,7 +219,7 @@ inline bool operator _op_ (const U* o) const { \

		class ReferenceRenamer {
		protected:
		// destructor is purposedly not virtual so we avoid code overhead from
		// destructor is purposely not virtual so we avoid code overhead from
		// subclasses; we have to make it protected to guarantee that it
		// cannot be called from this base class (and to make strict compilers
		// happy).
		@@ -345,48 +348,6 @@ private:

		// ---------------------------------------------------------------------------

		template <class T>
		class LightRefBase
		{
		public:
		inline LightRefBase() : mCount(0) { }
		inline void incStrong(__attribute__((unused)) const void* id) const {
		mCount.fetch_add(1, std::memory_order_relaxed);
		}
		inline void decStrong(__attribute__((unused)) const void* id) const {
		if (mCount.fetch_sub(1, std::memory_order_release) == 1) {
		std::atomic_thread_fence(std::memory_order_acquire);
		delete static_cast<const T*>(this);
		}
		}
		//! DEBUGGING ONLY: Get current strong ref count.
		inline int32_t getStrongCount() const {
		return mCount.load(std::memory_order_relaxed);
		}

		typedef LightRefBase<T> basetype;

		protected:
		inline ~LightRefBase() { }

		private:
		friend class ReferenceMover;
		inline static void renameRefs(size_t /n/, const ReferenceRenamer& /renamer/) { }
		inline static void renameRefId(T* /ref/, const void* /old_id/ , const void* /new_id/) { }

		private:
		mutable std::atomic<int32_t> mCount;
		};

		// This is a wrapper around LightRefBase that simply enforces a virtual
		// destructor to eliminate the template requirement of LightRefBase
		class VirtualLightRefBase : public LightRefBase<VirtualLightRefBase> {
		public:
		virtual ~VirtualLightRefBase();
		};

		// ---------------------------------------------------------------------------

		template <typename T>
		class wp
		{