#ifndef WeakBlock_h
#define WeakBlock_h
#include "HeapBlock.h"
#include "WeakHandleOwner.h"
#include "WeakImpl.h"
#include <wtf/DoublyLinkedList.h>
#include <wtf/PageAllocation.h>
#include <wtf/StdLibExtras.h>
namespace JSC {
class HeapRootVisitor;
class JSValue;
class WeakHandleOwner;
class WeakBlock : public DoublyLinkedListNode<WeakBlock> {
public:
friend class WTF::DoublyLinkedListNode<WeakBlock>;
static const size_t blockSize = 4 * KB;
struct FreeCell {
FreeCell* next;
};
struct SweepResult {
SweepResult();
bool isNull() const;
bool blockIsFree;
FreeCell* freeList;
};
static WeakBlock* create();
static void destroy(WeakBlock*);
static WeakImpl* asWeakImpl(FreeCell*);
void sweep();
const SweepResult& sweepResult();
SweepResult takeSweepResult();
void visitLiveWeakImpls(HeapRootVisitor&);
void visitDeadWeakImpls(HeapRootVisitor&);
void finalizeAll();
private:
static FreeCell* asFreeCell(WeakImpl*);
WeakBlock(PageAllocation&);
WeakImpl* firstWeakImpl();
void finalize(WeakImpl*);
WeakImpl* weakImpls();
size_t weakImplCount();
void addToFreeList(FreeCell**, WeakImpl*);
PageAllocation m_allocation;
WeakBlock* m_prev;
WeakBlock* m_next;
SweepResult m_sweepResult;
};
inline WeakBlock::SweepResult::SweepResult()
: blockIsFree(true)
, freeList(0)
{
ASSERT(isNull());
}
inline bool WeakBlock::SweepResult::isNull() const
{
return blockIsFree && !freeList; }
inline WeakImpl* WeakBlock::asWeakImpl(FreeCell* freeCell)
{
return reinterpret_cast<WeakImpl*>(freeCell);
}
inline WeakBlock::SweepResult WeakBlock::takeSweepResult()
{
SweepResult tmp;
std::swap(tmp, m_sweepResult);
ASSERT(m_sweepResult.isNull());
return tmp;
}
inline const WeakBlock::SweepResult& WeakBlock::sweepResult()
{
return m_sweepResult;
}
inline WeakBlock::FreeCell* WeakBlock::asFreeCell(WeakImpl* weakImpl)
{
return reinterpret_cast<FreeCell*>(weakImpl);
}
inline void WeakBlock::finalize(WeakImpl* weakImpl)
{
ASSERT(weakImpl->state() == WeakImpl::Dead);
weakImpl->setState(WeakImpl::Finalized);
WeakHandleOwner* weakHandleOwner = weakImpl->weakHandleOwner();
if (!weakHandleOwner)
return;
weakHandleOwner->finalize(Handle<Unknown>::wrapSlot(&const_cast<JSValue&>(weakImpl->jsValue())), weakImpl->context());
}
inline WeakImpl* WeakBlock::weakImpls()
{
return reinterpret_cast<WeakImpl*>(this) + ((sizeof(WeakBlock) + sizeof(WeakImpl) - 1) / sizeof(WeakImpl));
}
inline size_t WeakBlock::weakImplCount()
{
return (blockSize / sizeof(WeakImpl)) - ((sizeof(WeakBlock) + sizeof(WeakImpl) - 1) / sizeof(WeakImpl));
}
inline void WeakBlock::addToFreeList(FreeCell** freeList, WeakImpl* weakImpl)
{
ASSERT(weakImpl->state() == WeakImpl::Deallocated);
FreeCell* freeCell = asFreeCell(weakImpl);
ASSERT(!*freeList || ((char*)*freeList > (char*)this && (char*)*freeList < (char*)this + blockSize));
ASSERT((char*)freeCell > (char*)this && (char*)freeCell < (char*)this + blockSize);
freeCell->next = *freeList;
*freeList = freeCell;
}
}
#endif // WeakBlock_h