BlockAllocator.cpp [plain text]
#include "config.h"
#include "BlockAllocator.h"
#include "CopiedBlock.h"
#include "CopyWorkList.h"
#include "MarkedBlock.h"
#include "JSCInlines.h"
#include "WeakBlock.h"
#include <wtf/CurrentTime.h>
namespace JSC {
inline ThreadIdentifier createBlockFreeingThread(BlockAllocator* allocator)
{
if (!GCActivityCallback::s_shouldCreateGCTimer)
return 0; ThreadIdentifier identifier = createThread(allocator->blockFreeingThreadStartFunc, allocator, "JavaScriptCore::BlockFree");
RELEASE_ASSERT(identifier);
return identifier;
}
BlockAllocator::BlockAllocator()
: m_superRegion()
, m_copiedRegionSet(CopiedBlock::blockSize)
, m_markedRegionSet(MarkedBlock::blockSize)
, m_fourKBBlockRegionSet(WeakBlock::blockSize)
, m_workListRegionSet(CopyWorkListSegment::blockSize)
, m_numberOfEmptyRegions(0)
, m_isCurrentlyAllocating(false)
, m_blockFreeingThreadShouldQuit(false)
, m_blockFreeingThread(createBlockFreeingThread(this))
{
m_regionLock.Init();
}
BlockAllocator::~BlockAllocator()
{
releaseFreeRegions();
{
std::lock_guard<std::mutex> lock(m_emptyRegionConditionMutex);
m_blockFreeingThreadShouldQuit = true;
m_emptyRegionCondition.notify_all();
}
if (m_blockFreeingThread)
waitForThreadCompletion(m_blockFreeingThread);
ASSERT(allRegionSetsAreEmpty());
ASSERT(m_emptyRegions.isEmpty());
}
bool BlockAllocator::allRegionSetsAreEmpty() const
{
return m_copiedRegionSet.isEmpty()
&& m_markedRegionSet.isEmpty()
&& m_fourKBBlockRegionSet.isEmpty()
&& m_workListRegionSet.isEmpty();
}
void BlockAllocator::releaseFreeRegions()
{
while (true) {
Region* region;
{
SpinLockHolder locker(&m_regionLock);
if (!m_numberOfEmptyRegions)
region = 0;
else {
region = m_emptyRegions.removeHead();
RELEASE_ASSERT(region);
m_numberOfEmptyRegions--;
}
}
if (!region)
break;
region->destroy();
}
}
void BlockAllocator::waitForDuration(std::chrono::milliseconds duration)
{
std::unique_lock<std::mutex> lock(m_emptyRegionConditionMutex);
if (m_blockFreeingThreadShouldQuit)
return;
m_emptyRegionCondition.wait_for(lock, duration);
}
void BlockAllocator::blockFreeingThreadStartFunc(void* blockAllocator)
{
static_cast<BlockAllocator*>(blockAllocator)->blockFreeingThreadMain();
}
void BlockAllocator::blockFreeingThreadMain()
{
size_t currentNumberOfEmptyRegions;
while (!m_blockFreeingThreadShouldQuit) {
waitForDuration(std::chrono::seconds(1));
if (m_blockFreeingThreadShouldQuit)
break;
if (m_isCurrentlyAllocating) {
m_isCurrentlyAllocating = false;
continue;
}
{
std::unique_lock<std::mutex> lock(m_emptyRegionConditionMutex);
SpinLockHolder regionLocker(&m_regionLock);
while (!m_numberOfEmptyRegions && !m_blockFreeingThreadShouldQuit) {
m_regionLock.Unlock();
m_emptyRegionCondition.wait(lock);
m_regionLock.Lock();
}
currentNumberOfEmptyRegions = m_numberOfEmptyRegions;
}
size_t desiredNumberOfEmptyRegions = currentNumberOfEmptyRegions / 2;
while (!m_blockFreeingThreadShouldQuit) {
Region* region;
{
SpinLockHolder locker(&m_regionLock);
if (m_numberOfEmptyRegions <= desiredNumberOfEmptyRegions)
region = 0;
else {
region = m_emptyRegions.removeHead();
RELEASE_ASSERT(region);
m_numberOfEmptyRegions--;
}
}
if (!region)
break;
region->destroy();
}
}
}
}