Возможен ли быстрый Garbage collector на С++?

/*
	Main garbage manager.
*/
class GGarbageCollector
{

public:

	static inline GGarbageCollector* Get()
	{
		static GGarbageCollector GC;
		return &GC;
	}

private:

	inline GGarbageCollector() {}



public:

	/*
		Force collect garbage.
	*/
	inline void ForceGC()
	{ 
		//TODO, об этом далее
	}
	/*
		@return total objects count who are under surveillance.
	*/
	inline unsigned int GetTotalObjectsCount() const noexcept
	{
		//TODO, об этом далее
	}
	/*
		@return the number of objects destroyed at the last iteration of garbage collection.
	*/
	inline unsigned int GetLastGarbagedObjectsCount() const noexcept
	{
		//TODO, об этом далее
	}
	/*
		@return index of the garbage collection iteration.
	*/
	inline unsigned int GetGarbageCollectionIndex() const noexcept
	{
		//TODO, об этом далее
	}

	/*
		Check that object address is in GarbageCollector.
	*/
	inline bool IsGCObjectValid(const void* Object) const noexcept
	{
		//TODO, об этом далее
	}
	/*
		Check that object address is in GarbageCollector and hasn't got any refs.
	*/
	inline bool IsGCObjectPendingToKill(const void* Object) const noexcept
	{
		//TODO, об этом далее
	}
};

template<typename T>
struct TGCPointer
{

public:

	inline TGCPointer() {}
	inline TGCPointer(T* InObject) : Object(InObject)
	{
		//TODO, об этом далее
	}
	inline TGCPointer(T* InObject, bool IsNew) : Object(InObject)
	{
		//TODO, об этом далее
	}
	inline TGCPointer(const TGCPointer& OtherGCPointer) :
		Object(OtherGCPointer.Object)
	{
		//TODO, об этом далее
	}
	inline TGCPointer(TGCPointer&& OtherGCPointer) noexcept :
		Object(OtherGCPointer.Object)
	{
		OtherGCPointer.Object = nullptr;
	}

	~TGCPointer()
	{
		//TODO, об этом далее
	}

public:

	operator bool()
	{
		return IsValid();
	}

	operator T*()
	{
		return Object;
	}

	inline T& operator*() const
	{
		return *Object;
	}

	inline T* operator->() const
	{
		return Object;
	}

	inline TGCPointer& operator=(const TGCPointer& InGCPointer)
	{
		if (InGCPointer.Object == Object) return *this;

		//TODO, об этом далее

		return *this;
	}
	inline TGCPointer& operator=(TGCPointer&& InGCPointer)
	{
		//TODO, об этом далее

		return *this;
	}
	inline TGCPointer& operator=(T* Ptr)
	{
		if (Ptr == Object) return *this;

		//TODO, об этом далее

		return *this;
	}
  
	// операторы сравнения опустил, они очевидны


public:

	inline bool IsValid() const noexcept
	{
		//TODO, об этом далее
	}

	inline T* Get() const noexcept
	{
		return Object;
	}

	inline T* GetChecked() const noexcept
	{
		if (!IsValid())
		{
			Object = nullptr;
		}
		return Object;
	}

	inline void Reset()
	{
		//TODO, об этом далее
		Object = nullptr;
	}



private:

	/*
		Owned object.
	*/
	T* Object = nullptr;
};


template<typename T, typename... Args>
TGCPointer<T> MakeGCPointer(...)
{
	return TGCPointer<T>(new T(Args...));
}

/*
	Helper struct to handle object references.
*/
struct FAddrHandler
{

public:

	inline FAddrHandler() noexcept { }
	inline FAddrHandler(size_t InAddr, unsigned int InCount) noexcept : Addr(InAddr), Count(InCount) { }
	inline FAddrHandler(size_t InAddr) noexcept : Addr(InAddr) { }
	inline FAddrHandler(const void* Ptr, unsigned int InCount) noexcept : Addr((size_t)Ptr), Count(InCount) { }
	inline FAddrHandler(const void* Ptr) noexcept : Addr((size_t)Ptr) { }


public:

	/*
		Check that this handler represent any object.
	*/
	inline bool IsValid() const noexcept
	{
		return Addr != 0;
	}
	/*
		Check that this object is a candidate to killing by any Garbage Collector.
		@return true if this handler has object, but it has no references.
	*/
	inline bool IsPendingToKill() const noexcept
	{
		return Count == 0 && Addr != 0;
	}


public:

	/*
		Object's memory address in integral type.
	*/
	size_t Addr = 0;
	/*
		Number of references to an object in the program.
	*/
	unsigned int Count = 0;
};

// операторы сравнения опустил, они очевидны

/*
	Helper struct for manage AddrHandlers.
	@see FAddrHandler.
*/
struct FAnyPtrMap
{

public:

	inline FAnyPtrMap() :
	{
		ItemMap = new std::forward_list<FAddrHandler>[BitsPackSize];
	}

	~FAnyPtrMap()
	{
		if (ItemMap != nullptr) delete[] ItemMap;
	}



public:

	FAddrHandler* AddPtr(const void* Ptr)
	{
		//if (Ptr == nullptr) return; //check

		const size_t LAddr = (const size_t)Ptr;

		std::forward_list<FAddrHandler>& LItems = ItemMap[GetLocalAddr(LAddr)];
		auto LItemsEnd = LItems.end();

		auto LAddrHandler = std::find(LItems.begin(), LItemsEnd, LAddr);
		if (LAddrHandler != LItemsEnd)
		{
			++LAddrHandler->Count;
			return &LAddrHandler._Ptr->_Myval;
		}
		else
		{
			++TotalObjectsCount;
			LItems.push_front(FAddrHandler(LAddr, 1));
			return &LItems.front();
		}
	}

	FAddrHandler* AddNewPtr(const void* Ptr)
	{
		//if (Ptr == nullptr) return; //check

		const size_t LAddr = (const size_t)Ptr;

		std::forward_list<FAddrHandler>& LItems = ItemMap[GetLocalAddr(LAddr)];

		++TotalObjectsCount;
		LItems.push_front(FAddrHandler(LAddr, 1));
		return &LItems.front();
	}

	FAddrHandler* RemovePtr(const void* Ptr)
	{
		//TODO, об этом далее
	}

	inline void RemovePtrByHandler(FAddrHandler* PtrHandler)
	{
		//TODO, об этом далее
	}

	void ClearInvalidPtrs()
	{
		//TODO, об этом далее
	}



	FAddrHandler* GetPtrHandler(const void* Ptr) const noexcept
	{
		//if(Ptr == nullptr); //check

		const size_t LAddr = (const size_t)Ptr;
		const std::forward_list<FAddrHandler>& LItems = ItemMap[GetLocalAddr(LAddr)];
		auto LItemsEnd = LItems.end();

		auto LAddrHandler = std::find(LItems.begin(), LItemsEnd, LAddr);
		if (LAddrHandler == LItemsEnd) return nullptr;

		return &LAddrHandler._Ptr->_Myval;
	}

	inline unsigned int GetTotalObjectsCount() const noexcept
	{
		return TotalObjectsCount;
	}

	inline unsigned int GetLastGarbagedObjectsCount() const noexcept
	{
		return LastGarbagedObjectsCount;
	}

	inline int GetGarbageCollectionIndex() const noexcept
	{
		return GarbageCollectionIndex;
	}


private:

	inline unsigned int GetLocalAddr(size_t Addr) const noexcept
	{
		return Addr & BitsPackMask; // Addr % BitsPackSize
	}



public:

	const static unsigned int BitsPackSize = 1048576; //1 MB ~69MB in ram
	const static int BitsPackMask = 0xfffff; // 20 bits 2^20 = 1048576

	//const static unsigned int BitsPackSize = 65536; //64 KB ~4MB in ram
	//const static int BitsPackMask = 0xffff; // 16 bits 2^16 = 65536

private:

	std::forward_list<FAddrHandler>* ItemMap = nullptr;


	/*
		Total objects count who are under surveillance.
	*/
	unsigned int TotalObjectsCount = 0;
	/*
		The number of objects destroyed at the last iteration of ClearInvalidPtrs.
	*/
	unsigned int LastGarbagedObjectsCount = 0;
	/*
		Index of ClearInvalidPtrs iteration.
	*/
	int GarbageCollectionIndex = 0;
};

/*
	Base class for GC pointers.
*/
struct FGCPointerBase
{

public:

	inline FGCPointerBase() {}
	inline FGCPointerBase(const FGCPointerBase& OtherGCPointerBase) noexcept :
		SyncAddrHandler(OtherGCPointerBase.SyncAddrHandler), SyncIndex(OtherGCPointerBase.SyncIndex)
	{
	}
	inline FGCPointerBase(FGCPointerBase&& OtherGCPointerBase) noexcept:
		SyncAddrHandler(OtherGCPointerBase.SyncAddrHandler), SyncIndex(OtherGCPointerBase.SyncIndex)
	{
		OtherGCPointerBase.SyncAddrHandler = nullptr;
	}


protected:

	/*
		Initialize from other FGCPointerBase.
	*/
	inline void SyncInitFrom(const FGCPointerBase& Other) noexcept
	{
		SyncAddrHandler = Other.SyncAddrHandler;
		SyncIndex = Other.SyncIndex;
	}

	/*
		@param Ptr - Owned object to sync check.
		@return true if this GCPointer synchronized with GC.
	*/
	inline bool IsSync(const void* Ptr) const noexcept
	{
		return SyncAddrHandler != nullptr && GGarbageCollector::Get()->GetGarbageCollectionIndex() == SyncIndex && *SyncAddrHandler == Ptr;
	}

	/*
		Force synchronize this pointer with GC.

		@return synchronization success.
	*/
	inline bool Sync(const void* Ptr) const noexcept
	{
		if (Ptr == nullptr)
		{
			SyncAddrHandler = nullptr;
			return false;
		}

		GGarbageCollector* LGC = GGarbageCollector::Get();
		if (SyncAddrHandler != nullptr && LGC->GetGarbageCollectionIndex() == SyncIndex && *SyncAddrHandler == Ptr) return true;

		SyncAddrHandler = LGC->GetPtrHandler(Ptr);
		SyncIndex = LGC->GetGarbageCollectionIndex();

		return SyncAddrHandler != nullptr;
	}

	/*
		@param Ptr - Owned object to synchronized register in GC.
	*/
	inline void SyncRegister(const void* Ptr)
	{
		if (Ptr == nullptr)
		{
			SyncAddrHandler = nullptr;
			return;
		}

		GGarbageCollector* LGC = GGarbageCollector::Get();
		if (SyncAddrHandler != nullptr && LGC->GetGarbageCollectionIndex() == SyncIndex && *SyncAddrHandler == Ptr)
		{
			++SyncAddrHandler->Count;
		}
		else
		{
			SyncAddrHandler = LGC->RegisterObjectRef(Ptr);
			SyncIndex = LGC->GetGarbageCollectionIndex();
		}
	}

	/*
		@param Ptr - Owned object which is exactly new for GC.
	*/
	inline void SyncRegisterExactlyNew(const void* Ptr)
	{
		if (Ptr == nullptr)
		{
			SyncAddrHandler = nullptr;
			return;
		}

		GGarbageCollector* LGC = GGarbageCollector::Get();
		
		SyncAddrHandler = LGC->RegisterExactlyNewObjectRef(Ptr);
		SyncIndex = LGC->GetGarbageCollectionIndex();
	}

	/*
		@param Ptr - owned object to synchronized unregister in GC.
	*/
	inline void SyncUnregister(const void* Ptr)
	{
		if (Ptr == nullptr)
		{
			SyncAddrHandler = nullptr;
			return;
		}

		GGarbageCollector* LGC = GGarbageCollector::Get();
		if (SyncAddrHandler != nullptr && LGC->GetGarbageCollectionIndex() == SyncIndex && *SyncAddrHandler == Ptr)
		{
			LGC->UnregisterObjectRefByHandler(SyncAddrHandler);
		}
		else
		{
			//if Count == 0 SyncAddrHandler will be nullptr
			SyncAddrHandler = LGC->UnregisterObjectRef(Ptr);
		}
	}


private:

	mutable GarbageCollector_Private::FAddrHandler* SyncAddrHandler = nullptr;
	mutable int SyncIndex = -1;
};

/*
	Main garbage manager.
*/
class GGarbageCollector
{
	friend struct FGCPointerBase;

public:

	static inline GGarbageCollector* Get()
	{
		static GGarbageCollector GC;
		return &GC;
	}

private:

	inline GGarbageCollector() {}



public:

	/*
		Force collect garbage.
	*/
	inline void ForceGC()
	{ 
		PtrMap.ClearInvalidPtrs();
	}
	/*
		@return total objects count who are under surveillance.
	*/
	inline unsigned int GetTotalObjectsCount() const noexcept
	{
		return PtrMap.GetTotalObjectsCount();
	}
	/*
		@return the number of objects destroyed at the last iteration of garbage collection.
	*/
	inline unsigned int GetLastGarbagedObjectsCount() const noexcept
	{
		return PtrMap.GetLastGarbagedObjectsCount();
	}
	/*
		@return index of the garbage collection iteration.
	*/
	inline unsigned int GetGarbageCollectionIndex() const noexcept
	{
		return PtrMap.GetGarbageCollectionIndex();
	}

	/*
		Check that object address is in GarbageCollector.
	*/
	inline bool IsGCObjectValid(const void* Object) const noexcept
	{
		return PtrMap.GetPtrHandler(Object) != nullptr;
	}
	/*
		Check that object address is in GarbageCollector and hasn't got any refs.
	*/
	inline bool IsGCObjectPendingToKill(const void* Object) const noexcept
	{
		const GarbageCollector_Private::FAddrHandler* LAddrHandler = PtrMap.GetPtrHandler(Object);
		return LAddrHandler != nullptr && LAddrHandler->IsPendingToKill();
	}



//for FGCPointerBase
protected:

	inline GarbageCollector_Private::FAddrHandler* RegisterObjectRef(const void* Object)
	{
		return PtrMap.AddPtr(Object);
	}

	inline GarbageCollector_Private::FAddrHandler* RegisterExactlyNewObjectRef(const void* Object)
	{
		return PtrMap.AddNewPtr(Object);
	}

	inline GarbageCollector_Private::FAddrHandler* UnregisterObjectRef(const void* Object)
	{
		return PtrMap.RemovePtr(Object);
	}

	inline void UnregisterObjectRefByHandler(GarbageCollector_Private::FAddrHandler* PtrHandler)
	{
		PtrMap.RemovePtrByHandler(PtrHandler);
	}

	inline GarbageCollector_Private::FAddrHandler* GetPtrHandler(const void* Object)
	{
		return PtrMap.GetPtrHandler(Object);
	}



private:

	/*
		Storage of object ptrs.
	*/
	GarbageCollector_Private::FAnyPtrMap PtrMap;
};

template<typename T>
struct TGCPointer : public FGCPointerBase
{

public:

	inline TGCPointer() {}
	inline TGCPointer(T* InObject) : Object(InObject)
	{
		SyncRegister(InObject);
	}
	inline TGCPointer(T* InObject, bool IsNew) : Object(InObject)
	{
		if (IsNew)
		{
			SyncRegisterExactlyNew(InObject);
		}
		else
		{
			SyncRegister(InObject);
		}
	}
	inline TGCPointer(const TGCPointer& OtherGCPointer) : FGCPointerBase(OtherGCPointer),
		Object(OtherGCPointer.Object)
	{
		SyncRegister(Object);
	}
	inline TGCPointer(TGCPointer&& OtherGCPointer) noexcept : FGCPointerBase(OtherGCPointer),
		Object(OtherGCPointer.Object)
	{
		OtherGCPointer.Object = nullptr;
	}

	~TGCPointer()
	{
		SyncUnregister(Object);
	}

public:

	operator bool()
	{
		return IsValid();
	}

	operator T*()
	{
		return Object;
	}

	inline T& operator*() const
	{
		return *Object;
	}

	inline T* operator->() const
	{
		return Object;
	}

	inline TGCPointer& operator=(const TGCPointer& InGCPointer)
	{
		if (InGCPointer.Object == Object) return *this;

		SyncUnregister(Object);
		Object = InGCPointer.Object;
		SyncInitFrom(InGCPointer);
		SyncRegister(Object);

		return *this;
	}
	inline TGCPointer& operator=(TGCPointer&& InGCPointer)
	{
		SyncUnregister(Object);

		SyncInitFrom(InGCPointer);
		Object = InGCPointer.Object;
		InGCPointer.Object = nullptr;

		return *this;
	}
	inline TGCPointer& operator=(T* Ptr)
	{
		if (Ptr == Object) return *this;

		SyncUnregister(Object);
		Object = Ptr;
		SyncRegister(Object);

		return *this;
	}

	// операторы сравнения опустил

public:

	inline bool IsValid() const noexcept
	{
		//if Object not in GC or Object == nullptr then we will be not sync
		return Sync(Object);
	}

	inline T* Get() const noexcept
	{
		return Object;
	}

	inline T* GetChecked() const noexcept
	{
		if (!IsValid())
		{
			Object = nullptr;
		}
		return Object;
	}

	inline void Reset()
	{
		SyncUnregister(Object);
		Object = nullptr;
	}



private:

	/*
		Owned object.
	*/
	T* Object = nullptr;
};

/*
	Large bool mask for memory optimization in GC.
	Each bit is 0/1 mask.

	@param T - Container POD-type of the mask elements.
	@param BitsPackSize - mask size.
*/
template<typename T, int BitsPackSize>
struct TGarbageBoolMask
{

public:

	inline TGarbageBoolMask()
	{
		BoolMask = new T[BitsPackSize / MaskSize];
		Clear();
	}

	~TGarbageBoolMask()
	{
		if (BoolMask != nullptr) delete[] BoolMask;
	}


public:

	/*
		Set mask bit to 1.
		@return bit set success.
	*/
	inline bool SetMaskBit(int Index) noexcept
	{
		const int LMaskIndex = Index / MaskSize;

		// 1 << (Index % 8) - for char(1 byte)
		const T LBitIndexMask = (T)1 << (Index & PackTypeRemainMask);

		//BoolMask[Index / 8] & (1 << (Index % 8)) - for char(1 byte)
		const bool IsSet = BoolMask[LMaskIndex] & LBitIndexMask;
		if (IsSet) return false;

		//BoolMask[Index / 8] |= (1 << (Index % 8)) - for char(1 byte)
		BoolMask[LMaskIndex] |= LBitIndexMask;

		return true;
	}

	/*
		Set mask bit to 0.
	*/
	inline void ClearMaskBit(int Index) noexcept
	{
		//BoolMask[Index / 8] &= ~(1 << (Index % 8)) - for char(1 byte)
		BoolMask[Index / MaskSize] &= ~((T)1 << (Index & PackTypeRemainMask));
	}

	/*
		Set mask to 0.
	*/
	inline void Clear()
	{
		for (T* LMaskElem = BoolMask + BitsPackSize / MaskSize - 1; LMaskElem >= BoolMask; --LMaskElem)
		{
			*LMaskElem = 0;
		}
	}


private:

	const static int MaskSize = sizeof(T) * 8;
	const static int PackTypeRemainMask = sizeof(T) * 8 - 1;

	T* BoolMask = nullptr;
};

/*
	Helper struct to manage of garbage lists to be cleared.
*/
struct FGarbageListsToClearArray
{

public:

	FGarbageListsToClearArray() = delete;
	inline FGarbageListsToClearArray(int ListsCount) :
		MaxListsCount(ListsCount)
	{
		IndexesToClean = new int[ListsCount];
	}

	~FGarbageListsToClearArray()
	{
		if (IndexesToClean != nullptr) delete[] IndexesToClean;
	}

public:

	inline int& operator[](int Index)
	{
		//check Index < CountOfListsToClean

		return IndexesToClean[Index];
	}


public:

	/*
		Add new list index to array.
	*/
	inline void Push(int Index)
	{
		//check CountOfListsToClean < MaxListsCount

		IndexesToClean[CountOfListsToClean] = Index;
		++CountOfListsToClean;
	}

	/*
		@return count of lists to clear.
	*/
	inline int Num() const noexcept
	{
		return CountOfListsToClean;
	}

	/*
		Remove all lists from array.
	*/
	inline void Clear() noexcept
	{
		CountOfListsToClean = 0;
	}

	/*
		Check if any list has been pushed.
	*/
	inline bool IsEmpty() const noexcept
	{
		return CountOfListsToClean == 0;
	}



private:

	/*
		Array of list indexes.
	*/
	int* IndexesToClean = nullptr;
	/*
		Count of pushed lists.
	*/
	int CountOfListsToClean = 0;
	/*
		Max count of lists indexes to contain.
	*/
	int MaxListsCount = 0;
};

/*
	Helper struct for manage AddrHandlers.
	@see FAddrHandler.
*/
struct FAnyPtrMap
{

public:

	inline FAnyPtrMap() :
		ListsIndexesToClean(BitsPackSize)
	{
		ItemMap = new std::forward_list<FAddrHandler>[BitsPackSize];
	}

	~FAnyPtrMap()
	{
		if (ItemMap != nullptr) delete[] ItemMap;
	}



public:

	FAddrHandler* AddPtr(const void* Ptr)
	{
		//if (Ptr == nullptr) return; //check

		const size_t LAddr = (const size_t)Ptr;

		std::forward_list<FAddrHandler>& LItems = ItemMap[GetLocalAddr(LAddr)];
		auto LItemsEnd = LItems.end();

		auto LAddrHandler = std::find(LItems.begin(), LItemsEnd, LAddr);
		if (LAddrHandler != LItemsEnd)
		{
			++LAddrHandler->Count;
			return &LAddrHandler._Ptr->_Myval;
		}
		else
		{
			++TotalObjectsCount;
			LItems.push_front(FAddrHandler(LAddr, 1));
			return &LItems.front();
		}
	}

	FAddrHandler* AddNewPtr(const void* Ptr)
	{
		//if (Ptr == nullptr) return; //check

		const size_t LAddr = (const size_t)Ptr;

		std::forward_list<FAddrHandler>& LItems = ItemMap[GetLocalAddr(LAddr)];

		++TotalObjectsCount;
		LItems.push_front(FAddrHandler(LAddr, 1));
		return &LItems.front();
	}

	FAddrHandler* RemovePtr(const void* Ptr)
	{
		//if (Ptr == nullptr) return; //check

		const size_t LAddr = (const size_t)Ptr;

		const unsigned int LocalAddr = GetLocalAddr(LAddr);
		std::forward_list<FAddrHandler>& LItems = ItemMap[LocalAddr];
		auto LItemsEnd = LItems.end();

		auto LAddrHandler = std::find(LItems.begin(), LItemsEnd, LAddr);
		if (LAddrHandler == LItemsEnd || LAddrHandler->Count == 0) return nullptr;

		if (--LAddrHandler->Count == 0)
		{
			if (ListsIndexesToCleanMask.SetMaskBit(LocalAddr))
			{
				ListsIndexesToClean.Push(LocalAddr);
			}
		}

		return &LAddrHandler._Ptr->_Myval;
	}

	inline void RemovePtrByHandler(FAddrHandler* PtrHandler)
	{
		if (PtrHandler == nullptr || PtrHandler->Count == 0 || !PtrHandler->IsValid()) return;

		if (--PtrHandler->Count == 0)
		{
			const unsigned int LocalAddr = GetLocalAddr(PtrHandler->Addr);
			if (ListsIndexesToCleanMask.SetMaskBit(LocalAddr))
			{
				ListsIndexesToClean.Push(LocalAddr);
			}
		}
	}

	void ClearInvalidPtrs()
	{
		LastGarbagedObjectsCount = 0;
		if (ListsIndexesToClean.IsEmpty()) return;

		++GarbageCollectionIndex;
		for (int i = 0; i < ListsIndexesToClean.Num(); ++i)
		{
			ItemMap[ListsIndexesToClean[i]].remove_if([this](FAddrHandler& LAddrHandler)
				{
					if (!LAddrHandler.IsPendingToKill()) return false;

					delete (void*)LAddrHandler.Addr;
					++LastGarbagedObjectsCount;
					return true;
				});

			ListsIndexesToCleanMask.ClearMaskBit(ListsIndexesToClean[i]);
		}
		
		TotalObjectsCount -= LastGarbagedObjectsCount;
		ListsIndexesToClean.Clear();
	}



	FAddrHandler* GetPtrHandler(const void* Ptr) const noexcept
	{
		//if(Ptr == nullptr); //check

		const size_t LAddr = (const size_t)Ptr;
		const std::forward_list<FAddrHandler>& LItems = ItemMap[GetLocalAddr(LAddr)];
		auto LItemsEnd = LItems.end();

		auto LAddrHandler = std::find(LItems.begin(), LItemsEnd, LAddr);
		if (LAddrHandler == LItemsEnd) return nullptr;

		return &LAddrHandler._Ptr->_Myval;
	}

	inline unsigned int GetTotalObjectsCount() const noexcept
	{
		return TotalObjectsCount;
	}

	inline unsigned int GetLastGarbagedObjectsCount() const noexcept
	{
		return LastGarbagedObjectsCount;
	}

	inline int GetGarbageCollectionIndex() const noexcept
	{
		return GarbageCollectionIndex;
	}

private:

	inline unsigned int GetLocalAddr(size_t Addr) const noexcept
	{
		return Addr & BitsPackMask; // Addr % BitsPackSize
	}



public:

	const static unsigned int BitsPackSize = 1048576; //1 MB ~69MB in ram
	const static int BitsPackMask = 0xfffff; // 20 bits 2^20 = 1048576

	//const static unsigned int BitsPackSize = 65536; //64 KB ~4MB in ram
	//const static int BitsPackMask = 0xffff; // 16 bits 2^16 = 65536

private:

	std::forward_list<FAddrHandler>* ItemMap = nullptr;

	FGarbageListsToClearArray ListsIndexesToClean;
	TGarbageBoolMask<size_t, BitsPackSize> ListsIndexesToCleanMask;
		

	/*
		Total objects count who are under surveillance.
	*/
	unsigned int TotalObjectsCount = 0;
	/*
		The number of objects destroyed at the last iteration of ClearInvalidPtrs.
	*/
	unsigned int LastGarbagedObjectsCount = 0;
	/*
		Index of ClearInvalidPtrs iteration.
	*/
	int GarbageCollectionIndex = 0;
};

void ClearInvalidPtrs()
{
	LastGarbagedObjectsCount = 0;
	if (ListsIndexesToClean.IsEmpty()) return;

	++GarbageCollectionIndex;

			
	if (GarbageCleaningThreadsCount > 1 && ListsIndexesToClean.Num() > GarbageCleaningThreadsCount)
	{
		std::thread* LThreads = new std::thread[GarbageCleaningThreadsCount];
		int* LThreadGarabagedObjectsCount = new int[GarbageCleaningThreadsCount];

		const int LStep = ListsIndexesToClean.Num() / GarbageCleaningThreadsCount + 1;
		int L = 0;
		int R = LStep;
		int LThreadIndex = 0;
		for (LThreadIndex; LThreadIndex < GarbageCleaningThreadsCount; ++LThreadIndex)
		{
			if (R > ListsIndexesToClean.Num()) R = ListsIndexesToClean.Num();
			if (L == R)
			{
				break;
			}

			LThreads[LThreadIndex] = std::thread([this, L, R, LThreadIndex, LThreadGarabagedObjectsCount]()
				{
					int LGarbagedObjectsCount = 0;
					for (int i = L; i < R; ++i)
					{
						ItemMap[ListsIndexesToClean[i]].remove_if([this, &LGarbagedObjectsCount](FAddrHandler& LAddrHandler)
							{
								if (!LAddrHandler.IsPendingToKill()) return false;

								delete (void*)LAddrHandler.Addr;
								++LGarbagedObjectsCount;
								return true;
							});
					}

					LThreadGarabagedObjectsCount[LThreadIndex] = LGarbagedObjectsCount;
				});

			L = R;
			R += LStep;
		}

		for (int i = 0; i < LThreadIndex; ++i)
		{
			LThreads[i].join();
			LastGarbagedObjectsCount += LThreadGarabagedObjectsCount[i];
		}

		ListsIndexesToCleanMask.Clear();

		delete[] LThreads;
		delete[] LThreadGarabagedObjectsCount;
	}
	else
	{
		for (int i = 0; i < ListsIndexesToClean.Num(); ++i)
		{
			ItemMap[ListsIndexesToClean[i]].remove_if([this](FAddrHandler& LAddrHandler)
				{
					if (!LAddrHandler.IsPendingToKill()) return false;

					delete (void*)LAddrHandler.Addr;
					++LastGarbagedObjectsCount;
					return true;
				});

			ListsIndexesToCleanMask.ClearMaskBit(ListsIndexesToClean[i]);
		}
	}

	TotalObjectsCount -= LastGarbagedObjectsCount;
	ListsIndexesToClean.Clear();
}