使用clang / llvm的C ++精確垃圾收集器？

Question

好的，我想在C ++中編寫一個精確的'標記和掃描'垃圾收集器。 我希望做出一些可以幫助我的決定，因為我的所有指針都將包含在'RelocObject'中，並且我將為堆提供單個內存塊。 這看起來像這樣：

// This class acts as an indirection to the actual object in memory so that it can be      
// relocated in the sweep phase of garbage collector
class MemBlock
{
public:
    void* Get( void ) { return m_ptr; }

private:
    MemBlock( void ) : m_ptr( NULL ){}

    void* m_ptr;
};

// This is of the same size as the above class and is directly cast to it, but is     
// typed so that we can easily debug the underlying object
template<typename _Type_>
class TypedBlock
{
public:
    _Type_* Get( void ) { return m_pObject; }

private:
    TypedBlock( void ) : m_pObject( NULL ){}

    // Pointer to actual object in memory
    _Type_* m_pObject;
};

// This is our wrapper class that every pointer is wrapped in 
template< typename _Type_ >
class RelocObject
{
public:

    RelocObject( void ) : m_pRef( NULL ) {}

    static RelocObject New( void )
    {
        RelocObject ref( (TypedBlock<_Type_>*)Allocator()->Alloc( this, sizeof(_Type_), __alignof(_Type_) ) );
        new ( ref.m_pRef->Get() ) _Type_();
        return ref;
    }

    ~RelocObject(){}

    _Type_*     operator->  ( void ) const 
    { 
        assert( m_pRef && "ERROR! Object is null\n" ); 
        return (_Type_*)m_pRef->Get(); 
    }

    // Equality
    bool operator ==(const RelocObject& rhs) const { return m_pRef->Get() == rhs.m_pRef->Get(); }
    bool operator !=(const RelocObject& rhs) const { return m_pRef->Get() != rhs.m_pRef->Get(); }

    RelocObject&    operator=   ( const RelocObject& rhs ) 
    {
        if(this == &rhs) return *this;
        m_pRef = rhs.m_pRef;
        return *this; 
    }

private:

    RelocObject( TypedBlock<_Type_>* pRef ) : m_pRef( pRef ) 
    {
        assert( m_pRef && "ERROR! Can't construct a null object\n");
    }

    RelocObject*    operator&   ( void ) { return this; }
    _Type_&     operator*   ( void ) const { return *(_Type_*)m_pRef->Get(); }

    // SS: 
    TypedBlock<_Type_>* m_pRef;
};

// We would use it like so...
typedef RelocObject<Impl::Foo> Foo;

void main( void )
{
    Foo foo = Foo::New();
}

因此，當我在'RelocObject :: New'中分配時，為了找到'root'RelocObjects，我將RelocObject的'this'指針傳遞給allocator（垃圾收集器）。 然后，分配器檢查“this”指針是否在堆的內存塊范圍內，如果是，那么我可以假設它不是根。

因此，當我想使用位於每個子對象內的零個或多個RelocObjects從子對象跟蹤子對象時，問題就出現了。

我想使用'精確'方法在類（即子對象）中找到RelocObjects。 我可以使用反射方法並使用戶在每個類中注冊他或她的RelocObjects。 然而，這將非常容易出錯，因此我想自動執行此操作。

因此，我希望在編譯時使用Clang在類中找到RelocObjects的偏移量，然后在程序啟動時加載此信息，並在垃圾收集器的標記階段使用它來跟蹤並標記子對象。

所以我的問題是Clang能幫忙嗎？ 我聽說你可以使用編譯時鈎子在編譯期間收集各種類型的信息。 如果是這樣，我應該在Clang中尋找什么，即有沒有做這種事情的例子？

只是為了明確：我想使用Clang在FooB中自動找到'Foo'的偏移量（這是RelocObject的typedef）而用戶沒有提供任何“提示”，即他們只是寫：

class FooB
{
public:
    int m_a;
    Foo m_ptr;
};

在此先感謝您的幫助。

Answer 1

每當RelocObject被實例化時，它的地址可以與sizeof(*derivedRelocObject)一起記錄在RelocObject所有權數據庫中，這將立即識別哪個Foo屬於哪個FooB 。 你不需要Clang。 此外，由於Foo將在FooB之后不久創建，因此您的所有權數據庫系統可以非常簡單，因為“我已經創建，這里是我的地址和大小”調用的RelocObject將直接在它擁有的RelocObject實例之前顯示擁有的RelocObject記錄。

每個RelocObject有ownership_been_declared標志初始化為假，在第一次使用（這將是后構造函數已完成，因為沒有真正的工作應該在構造函數中完成），所以當其中任何新創建的對象的第一次使用它請求數據庫更新它的所有權，數據庫通過它的記錄地址隊列，並可以識別哪些對象屬於哪個，清除它的列表中的一些，將他們的ownership_been_declared標志設置為true，你也將有偏移（如果你仍然需要它們）。

---

ps如果你願意我可以分享我多年前寫的增量垃圾收集器的代碼，你可能會發現它很有幫助。