SharedStringHashStore.cpp [plain text]
#include "config.h"
#include "SharedStringHashStore.h"
#include <algorithm>
namespace WebKit {
using namespace WebCore;
const unsigned sharedStringHashTableMaxLoad = 2;
static unsigned nextPowerOf2(unsigned v)
{
v--;
v |= v >> 1;
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;
v++;
return v;
}
static unsigned tableSizeForKeyCount(unsigned keyCount)
{
unsigned tableSize = nextPowerOf2(keyCount * sharedStringHashTableMaxLoad);
size_t minimumTableSize = SharedMemory::systemPageSize() / sizeof(SharedStringHash);
if (tableSize < minimumTableSize)
return minimumTableSize;
return tableSize;
}
SharedStringHashStore::SharedStringHashStore(Client& client)
: m_client(client)
, m_pendingOperationsTimer(RunLoop::main(), this, &SharedStringHashStore::processPendingOperations)
{
}
bool SharedStringHashStore::createSharedMemoryHandle(SharedMemory::Handle& handle)
{
return m_table.sharedMemory()->createHandle(handle, SharedMemory::Protection::ReadOnly);
}
void SharedStringHashStore::scheduleAddition(SharedStringHash sharedStringHash)
{
m_pendingOperations.append({ Operation::Add, sharedStringHash });
if (!m_pendingOperationsTimer.isActive())
m_pendingOperationsTimer.startOneShot(0_s);
}
void SharedStringHashStore::scheduleRemoval(WebCore::SharedStringHash sharedStringHash)
{
m_pendingOperations.append({ Operation::Remove, sharedStringHash });
if (!m_pendingOperationsTimer.isActive())
m_pendingOperationsTimer.startOneShot(0_s);
}
bool SharedStringHashStore::contains(WebCore::SharedStringHash sharedStringHash)
{
flushPendingChanges();
return m_table.contains(sharedStringHash);
}
void SharedStringHashStore::clear()
{
m_pendingOperationsTimer.stop();
m_pendingOperations.clear();
m_keyCount = 0;
m_tableSize = 0;
m_table.clear();
}
void SharedStringHashStore::flushPendingChanges()
{
if (!m_pendingOperationsTimer.isActive())
return;
m_pendingOperationsTimer.stop();
processPendingOperations();
}
void SharedStringHashStore::resizeTable(unsigned newTableSize)
{
auto newTableMemory = SharedMemory::allocate(newTableSize * sizeof(SharedStringHash));
if (!newTableMemory) {
LOG_ERROR("Could not allocate shared memory for SharedStringHash table");
return;
}
memset(newTableMemory->data(), 0, newTableMemory->size());
RefPtr<SharedMemory> currentTableMemory = m_table.sharedMemory();
unsigned currentTableSize = m_tableSize;
m_table.setSharedMemory(newTableMemory.releaseNonNull());
m_tableSize = newTableSize;
if (currentTableMemory) {
ASSERT_UNUSED(currentTableSize, currentTableMemory->size() == currentTableSize * sizeof(SharedStringHash));
const SharedStringHash* currentSharedStringHashes = static_cast<const SharedStringHash*>(currentTableMemory->data());
for (unsigned i = 0; i < currentTableSize; ++i) {
auto sharedStringHash = currentSharedStringHashes[i];
if (!sharedStringHash)
continue;
bool didAddSharedStringHash = m_table.add(sharedStringHash);
ASSERT_UNUSED(didAddSharedStringHash, didAddSharedStringHash);
}
}
for (auto& operation : m_pendingOperations) {
switch (operation.type) {
case Operation::Add:
if (m_table.add(operation.sharedStringHash))
++m_keyCount;
break;
case Operation::Remove:
if (m_table.remove(operation.sharedStringHash))
--m_keyCount;
break;
}
}
m_pendingOperations.clear();
m_client.didInvalidateSharedMemory();
}
void SharedStringHashStore::processPendingOperations()
{
unsigned currentTableSize = m_tableSize;
unsigned approximateNewHashCount = std::count_if(m_pendingOperations.begin(), m_pendingOperations.end(), [](auto& operation) {
return operation.type == Operation::Add;
});
unsigned newTableSize = tableSizeForKeyCount(m_keyCount + approximateNewHashCount);
newTableSize = std::max(currentTableSize, newTableSize);
if (currentTableSize != newTableSize) {
resizeTable(newTableSize);
return;
}
Vector<SharedStringHash> addedSharedStringHashes;
Vector<SharedStringHash> removedSharedStringHashes;
addedSharedStringHashes.reserveInitialCapacity(approximateNewHashCount);
removedSharedStringHashes.reserveInitialCapacity(m_pendingOperations.size() - approximateNewHashCount);
for (auto& operation : m_pendingOperations) {
switch (operation.type) {
case Operation::Add:
if (m_table.add(operation.sharedStringHash)) {
addedSharedStringHashes.uncheckedAppend(operation.sharedStringHash);
++m_keyCount;
}
break;
case Operation::Remove:
if (m_table.remove(operation.sharedStringHash)) {
removedSharedStringHashes.uncheckedAppend(operation.sharedStringHash);
--m_keyCount;
}
break;
}
}
m_pendingOperations.clear();
if (!addedSharedStringHashes.isEmpty() || !removedSharedStringHashes.isEmpty())
m_client.didUpdateSharedStringHashes(addedSharedStringHashes, removedSharedStringHashes);
}
}