2010-07-27 19:14:40 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2010 Apple Inc. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
|
|
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
|
|
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
|
|
|
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2018-10-15 14:24:49 +00:00
|
|
|
#pragma once
|
2010-07-27 19:14:40 +00:00
|
|
|
|
2012-04-18 03:42:43 +00:00
|
|
|
#include <algorithm>
|
2010-07-27 19:14:40 +00:00
|
|
|
#include <wtf/PageAllocation.h>
|
2012-04-18 03:42:43 +00:00
|
|
|
#include <wtf/PageBlock.h>
|
2010-07-27 19:14:40 +00:00
|
|
|
|
|
|
|
namespace WTF {
|
|
|
|
|
|
|
|
#define MINIMUM_BUMP_POOL_SIZE 0x1000
|
|
|
|
|
|
|
|
class BumpPointerPool {
|
2019-08-12 20:57:15 +00:00
|
|
|
WTF_MAKE_FAST_ALLOCATED;
|
2010-07-27 19:14:40 +00:00
|
|
|
public:
|
|
|
|
// ensureCapacity will check whether the current pool has capacity to
|
|
|
|
// allocate 'size' bytes of memory If it does not, it will attempt to
|
|
|
|
// allocate a new pool (which will be added to this one in a chain).
|
|
|
|
//
|
|
|
|
// If allocation fails (out of memory) this method will return null.
|
|
|
|
// If the return value is non-null, then callers should update any
|
|
|
|
// references they have to this current (possibly full) BumpPointerPool
|
|
|
|
// to instead point to the newly returned BumpPointerPool.
|
|
|
|
BumpPointerPool* ensureCapacity(size_t size)
|
|
|
|
{
|
|
|
|
void* allocationEnd = static_cast<char*>(m_current) + size;
|
2013-10-12 18:03:39 +00:00
|
|
|
ASSERT_WITH_SECURITY_IMPLICATION(allocationEnd > m_current); // check for overflow
|
2010-07-27 19:14:40 +00:00
|
|
|
if (allocationEnd <= static_cast<void*>(this))
|
|
|
|
return this;
|
|
|
|
return ensureCapacityCrossPool(this, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
// alloc should only be called after calling ensureCapacity; as such
|
|
|
|
// alloc will never fail.
|
|
|
|
void* alloc(size_t size)
|
|
|
|
{
|
|
|
|
void* current = m_current;
|
|
|
|
void* allocationEnd = static_cast<char*>(current) + size;
|
2013-10-12 18:03:39 +00:00
|
|
|
ASSERT_WITH_SECURITY_IMPLICATION(allocationEnd > current); // check for overflow
|
2010-07-27 19:14:40 +00:00
|
|
|
ASSERT(allocationEnd <= static_cast<void*>(this));
|
|
|
|
m_current = allocationEnd;
|
|
|
|
return current;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The dealloc method releases memory allocated using alloc. Memory
|
|
|
|
// must be released in a LIFO fashion, e.g. if the client calls alloc
|
|
|
|
// four times, returning pointer A, B, C, D, then the only valid order
|
|
|
|
// in which these may be deallocaed is D, C, B, A.
|
|
|
|
//
|
|
|
|
// The client may optionally skip some deallocations. In the example
|
|
|
|
// above, it would be valid to only explicitly dealloc C, A (D being
|
|
|
|
// dealloced along with C, B along with A).
|
|
|
|
//
|
|
|
|
// If pointer was not allocated from this pool (or pools) then dealloc
|
|
|
|
// will CRASH(). Callers should update any references they have to
|
|
|
|
// this current BumpPointerPool to instead point to the returned
|
|
|
|
// BumpPointerPool.
|
|
|
|
BumpPointerPool* dealloc(void* position)
|
|
|
|
{
|
|
|
|
if ((position >= m_start) && (position <= static_cast<void*>(this))) {
|
|
|
|
ASSERT(position <= m_current);
|
|
|
|
m_current = position;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
return deallocCrossPool(this, position);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
// Placement operator new, returns the last 'size' bytes of allocation for use as this.
|
|
|
|
void* operator new(size_t size, const PageAllocation& allocation)
|
|
|
|
{
|
|
|
|
ASSERT(size < allocation.size());
|
|
|
|
return reinterpret_cast<char*>(reinterpret_cast<intptr_t>(allocation.base()) + allocation.size()) - size;
|
|
|
|
}
|
|
|
|
|
|
|
|
BumpPointerPool(const PageAllocation& allocation)
|
|
|
|
: m_current(allocation.base())
|
|
|
|
, m_start(allocation.base())
|
2020-05-08 17:31:54 +00:00
|
|
|
, m_next(nullptr)
|
|
|
|
, m_previous(nullptr)
|
2010-07-27 19:14:40 +00:00
|
|
|
, m_allocation(allocation)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static BumpPointerPool* create(size_t minimumCapacity = 0)
|
|
|
|
{
|
|
|
|
// Add size of BumpPointerPool object, check for overflow.
|
|
|
|
minimumCapacity += sizeof(BumpPointerPool);
|
|
|
|
if (minimumCapacity < sizeof(BumpPointerPool))
|
2020-05-08 17:31:54 +00:00
|
|
|
return nullptr;
|
2010-07-27 19:14:40 +00:00
|
|
|
|
2012-04-18 03:42:43 +00:00
|
|
|
size_t poolSize = std::max(static_cast<size_t>(MINIMUM_BUMP_POOL_SIZE), WTF::pageSize());
|
2010-07-27 19:14:40 +00:00
|
|
|
while (poolSize < minimumCapacity) {
|
|
|
|
poolSize <<= 1;
|
|
|
|
// The following if check relies on MINIMUM_BUMP_POOL_SIZE being a power of 2!
|
|
|
|
ASSERT(!(MINIMUM_BUMP_POOL_SIZE & (MINIMUM_BUMP_POOL_SIZE - 1)));
|
|
|
|
if (!poolSize)
|
2020-05-08 17:31:54 +00:00
|
|
|
return nullptr;
|
2010-07-27 19:14:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
PageAllocation allocation = PageAllocation::allocate(poolSize);
|
|
|
|
if (!!allocation)
|
Placement new does an unnecessary NULL check
https://bugs.webkit.org/show_bug.cgi?id=74676
Reviewed by Sam Weinig.
Source/JavaScriptCore:
We can define our own version, which skips the NULL check.
Not a measurable speedup, but code inspection shows better code generated,
and I believe this is a step toward turning off -fomit-frame-pointer.
* API/JSCallbackConstructor.h:
(JSC::JSCallbackConstructor::create):
* API/JSCallbackFunction.h:
(JSC::JSCallbackFunction::create): Use the NotNull version of placement
new to skip the NULL check.
* API/JSCallbackObject.h: Removed a conflicting, unnecessaray placement new.
(JSC::JSCallbackObject::create):
* debugger/DebuggerActivation.h:
(JSC::DebuggerActivation::create):
* heap/HandleHeap.cpp:
(JSC::HandleHeap::grow):
* heap/HandleHeap.h:
(JSC::HandleHeap::allocate):
* heap/MarkedBlock.cpp:
(JSC::MarkedBlock::create):
(JSC::MarkedBlock::recycle):
* jit/JITCode.h:
(JSC::JITCode::clear):
* jsc.cpp:
(GlobalObject::create):
* profiler/CallIdentifier.h:
* runtime/Arguments.h:
(JSC::Arguments::create):
* runtime/ArrayConstructor.h:
(JSC::ArrayConstructor::create):
* runtime/ArrayPrototype.h:
(JSC::ArrayPrototype::create):
* runtime/BooleanConstructor.h:
(JSC::BooleanConstructor::create):
* runtime/BooleanObject.h:
(JSC::BooleanObject::create):
* runtime/BooleanPrototype.h:
(JSC::BooleanPrototype::create):
* runtime/DateConstructor.h:
(JSC::DateConstructor::create):
* runtime/DateInstance.h:
(JSC::DateInstance::create):
* runtime/DatePrototype.h:
(JSC::DatePrototype::create):
* runtime/Error.h:
(JSC::StrictModeTypeErrorFunction::create):
* runtime/ErrorConstructor.h:
(JSC::ErrorConstructor::create):
* runtime/ErrorInstance.h:
(JSC::ErrorInstance::create):
* runtime/ErrorPrototype.h:
(JSC::ErrorPrototype::create):
* runtime/ExceptionHelpers.h:
(JSC::InterruptedExecutionError::create):
(JSC::TerminatedExecutionError::create):
* runtime/Executable.h:
(JSC::NativeExecutable::create):
(JSC::EvalExecutable::create):
(JSC::ProgramExecutable::create):
(JSC::FunctionExecutable::create):
* runtime/FunctionConstructor.h:
(JSC::FunctionConstructor::create):
* runtime/FunctionPrototype.h:
(JSC::FunctionPrototype::create):
* runtime/GetterSetter.h:
(JSC::GetterSetter::create):
* runtime/JSAPIValueWrapper.h:
(JSC::JSAPIValueWrapper::create):
* runtime/JSActivation.h:
(JSC::JSActivation::create):
* runtime/JSArray.h:
(JSC::JSArray::create):
* runtime/JSBoundFunction.cpp:
(JSC::JSBoundFunction::create):
* runtime/JSByteArray.h:
(JSC::JSByteArray::create): Use the NotNull version of placement
new to skip the NULL check.
* runtime/JSCell.h: Removed a conflicting, unnecessaray placement new.
* runtime/JSFunction.cpp:
(JSC::JSFunction::create):
* runtime/JSFunction.h:
(JSC::JSFunction::create):
* runtime/JSGlobalObject.h:
(JSC::JSGlobalObject::create):
* runtime/JSGlobalThis.h:
(JSC::JSGlobalThis::create):
* runtime/JSNotAnObject.h:
(JSC::JSNotAnObject::create):
* runtime/JSONObject.h:
(JSC::JSONObject::create):
* runtime/JSObject.h:
(JSC::JSFinalObject::create):
* runtime/JSPropertyNameIterator.cpp:
(JSC::JSPropertyNameIterator::create):
* runtime/JSPropertyNameIterator.h:
(JSC::JSPropertyNameIterator::create):
* runtime/JSStaticScopeObject.h:
(JSC::JSStaticScopeObject::create):
* runtime/JSString.cpp:
(JSC::StringObject::create):
* runtime/JSString.h:
(JSC::RopeBuilder::createNull):
(JSC::RopeBuilder::create):
(JSC::RopeBuilder::createHasOtherOwner):
* runtime/MathObject.h:
(JSC::MathObject::create):
* runtime/NativeErrorConstructor.h:
(JSC::NativeErrorConstructor::create):
* runtime/NativeErrorPrototype.h:
(JSC::NativeErrorPrototype::create):
* runtime/NumberConstructor.h:
(JSC::NumberConstructor::create):
* runtime/NumberObject.h:
(JSC::NumberObject::create):
* runtime/NumberPrototype.h:
(JSC::NumberPrototype::create):
* runtime/ObjectConstructor.h:
(JSC::ObjectConstructor::create):
* runtime/ObjectPrototype.h:
(JSC::ObjectPrototype::create):
* runtime/RegExp.cpp:
(JSC::RegExp::createWithoutCaching):
* runtime/RegExpConstructor.h:
(JSC::RegExpConstructor::create):
* runtime/RegExpMatchesArray.h:
(JSC::RegExpMatchesArray::create):
* runtime/RegExpObject.h:
(JSC::RegExpObject::create):
* runtime/RegExpPrototype.h:
(JSC::RegExpPrototype::create):
* runtime/ScopeChain.h:
(JSC::ScopeChainNode::create):
* runtime/StrictEvalActivation.h:
(JSC::StrictEvalActivation::create):
* runtime/StringConstructor.h:
(JSC::StringConstructor::create):
* runtime/StringObject.h:
(JSC::StringObject::create):
* runtime/StringPrototype.h:
(JSC::StringPrototype::create):
* runtime/Structure.h:
(JSC::Structure::create):
(JSC::Structure::createStructure):
* runtime/StructureChain.h:
(JSC::StructureChain::create):
* testRegExp.cpp:
(GlobalObject::create):
* wtf/BitVector.cpp:
(WTF::BitVector::OutOfLineBits::create): Use the NotNull version of placement
new to skip the NULL check.
* wtf/BumpPointerAllocator.h:
(WTF::BumpPointerPool::create): Standardized spacing to make grep easier.
* wtf/ByteArray.cpp:
(WTF::ByteArray::create):
* wtf/Deque.h:
(WTF::::append):
(WTF::::prepend): Use NotNull, as above.
* wtf/FastAllocBase.h: Added a placement new, since this class would otherwise
hide the name of the global placement new.
(WTF::fastNew): Standardized spacing. Most of these functions don't need
NotNull, since they check for NULL, and the optimizer can see that.
* wtf/HashTable.h:
* wtf/HashTraits.h:
(WTF::SimpleClassHashTraits::constructDeletedValue):
* wtf/MetaAllocator.cpp:
(WTF::MetaAllocator::allocFreeSpaceNode): NotNull, as above.
* wtf/StdLibExtras.h:
(throw): This is our NotNull placement new. Declaring that we throw is
the C++ way to say that operator new will not return NULL.
* wtf/ThreadSpecific.h:
(WTF::T):
* wtf/Vector.h:
(WTF::::append):
(WTF::::tryAppend):
(WTF::::uncheckedAppend):
(WTF::::insert):
* wtf/text/AtomicStringHash.h:
* wtf/text/StringImpl.cpp:
(WTF::StringImpl::createUninitialized):
(WTF::StringImpl::reallocate):
* wtf/text/StringImpl.h:
(WTF::StringImpl::tryCreateUninitialized):
* wtf/text/StringStatics.cpp:
(WTF::AtomicString::init): Use NotNull, as above.
* yarr/YarrInterpreter.cpp:
(JSC::Yarr::Interpreter::allocDisjunctionContext):
(JSC::Yarr::Interpreter::ParenthesesDisjunctionContext::ParenthesesDisjunctionContext):
(JSC::Yarr::Interpreter::allocParenthesesDisjunctionContext): Standardized
spacing for easy grep.
Source/WebCore:
* bindings/js/JSImageConstructor.h:
(WebCore::JSImageConstructor::create):
* bindings/scripts/CodeGeneratorJS.pm:
(GenerateHeader):
(GenerateConstructorDeclaration):
* bridge/c/CRuntimeObject.h:
(JSC::Bindings::CRuntimeObject::create):
* bridge/c/c_instance.cpp:
(JSC::Bindings::CRuntimeMethod::create):
* bridge/jni/jsc/JavaInstanceJSC.cpp:
(JavaRuntimeMethod::create):
* bridge/jni/jsc/JavaRuntimeObject.h:
(JSC::Bindings::JavaRuntimeObject::create):
* bridge/objc/ObjCRuntimeObject.h:
(JSC::Bindings::ObjCRuntimeObject::create):
* bridge/objc/objc_instance.mm:
(ObjCRuntimeMethod::create):
* bridge/objc/objc_runtime.h:
(JSC::Bindings::ObjcFallbackObjectImp::create):
* bridge/runtime_array.h:
(JSC::RuntimeArray::create):
* bridge/runtime_method.h:
(JSC::RuntimeMethod::create):
* bridge/runtime_object.h:
(JSC::Bindings::RuntimeObject::create):
* dom/Document.h:
(WebCore::FormElementKeyHashTraits::constructDeletedValue): Use NotNull
placement new, as in JavaScriptCore.
* platform/PODArena.h:
(WebCore::PODArena::allocateObject): No need to check for NULL explicitly,
since that's the built-in behavior of placement new.
* platform/graphics/FontCache.cpp:
(WebCore::FontDataCacheKeyTraits::constructDeletedValue):
* platform/graphics/IntRectHash.h:
* platform/graphics/IntSizeHash.h: More NotNull.
* rendering/RenderObject.h: Declaring that we throw is the C++ way to say
that operator new will not return NULL.
Canonical link: https://commits.webkit.org/91607@main
git-svn-id: https://svn.webkit.org/repository/webkit/trunk@103243 268f45cc-cd09-0410-ab3c-d52691b4dbfc
2011-12-19 17:45:13 +00:00
|
|
|
return new (allocation) BumpPointerPool(allocation);
|
2020-05-08 17:31:54 +00:00
|
|
|
return nullptr;
|
2010-07-27 19:14:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void shrink()
|
|
|
|
{
|
|
|
|
ASSERT(!m_previous);
|
|
|
|
m_current = m_start;
|
|
|
|
while (m_next) {
|
|
|
|
BumpPointerPool* nextNext = m_next->m_next;
|
|
|
|
m_next->destroy();
|
|
|
|
m_next = nextNext;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void destroy()
|
|
|
|
{
|
2010-11-30 22:57:02 +00:00
|
|
|
m_allocation.deallocate();
|
2010-07-27 19:14:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static BumpPointerPool* ensureCapacityCrossPool(BumpPointerPool* previousPool, size_t size)
|
|
|
|
{
|
|
|
|
// The pool passed should not have capacity, so we'll start with the next one.
|
|
|
|
ASSERT(previousPool);
|
|
|
|
ASSERT((static_cast<char*>(previousPool->m_current) + size) > previousPool->m_current); // check for overflow
|
|
|
|
ASSERT((static_cast<char*>(previousPool->m_current) + size) > static_cast<void*>(previousPool));
|
|
|
|
BumpPointerPool* pool = previousPool->m_next;
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
if (!pool) {
|
|
|
|
// We've run to the end; allocate a new pool.
|
|
|
|
pool = BumpPointerPool::create(size);
|
|
|
|
previousPool->m_next = pool;
|
|
|
|
pool->m_previous = previousPool;
|
|
|
|
return pool;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
void* current = pool->m_current;
|
|
|
|
void* allocationEnd = static_cast<char*>(current) + size;
|
2013-10-12 18:03:39 +00:00
|
|
|
ASSERT_WITH_SECURITY_IMPLICATION(allocationEnd > current); // check for overflow
|
2010-07-27 19:14:40 +00:00
|
|
|
if (allocationEnd <= static_cast<void*>(pool))
|
|
|
|
return pool;
|
2019-12-03 22:07:14 +00:00
|
|
|
|
|
|
|
previousPool = pool;
|
|
|
|
pool = pool->m_next;
|
2010-07-27 19:14:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static BumpPointerPool* deallocCrossPool(BumpPointerPool* pool, void* position)
|
|
|
|
{
|
|
|
|
// Should only be called if position is not in the current pool.
|
|
|
|
ASSERT((position < pool->m_start) || (position > static_cast<void*>(pool)));
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
// Unwind the current pool to the start, move back in the chain to the previous pool.
|
|
|
|
pool->m_current = pool->m_start;
|
|
|
|
pool = pool->m_previous;
|
|
|
|
|
|
|
|
// position was nowhere in the chain!
|
|
|
|
if (!pool)
|
|
|
|
CRASH();
|
|
|
|
|
|
|
|
if ((position >= pool->m_start) && (position <= static_cast<void*>(pool))) {
|
|
|
|
ASSERT(position <= pool->m_current);
|
|
|
|
pool->m_current = position;
|
|
|
|
return pool;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void* m_current;
|
|
|
|
void* m_start;
|
|
|
|
BumpPointerPool* m_next;
|
|
|
|
BumpPointerPool* m_previous;
|
|
|
|
PageAllocation m_allocation;
|
|
|
|
|
|
|
|
friend class BumpPointerAllocator;
|
|
|
|
};
|
|
|
|
|
|
|
|
// A BumpPointerAllocator manages a set of BumpPointerPool objects, which
|
|
|
|
// can be used for LIFO (stack like) allocation.
|
|
|
|
//
|
|
|
|
// To begin allocating using this class call startAllocator(). The result
|
|
|
|
// of this method will be null if the initial pool allocation fails, or a
|
|
|
|
// pointer to a BumpPointerPool object that can be used to perform
|
|
|
|
// allocations. Whilst running no memory will be released until
|
|
|
|
// stopAllocator() is called. At this point all allocations made through
|
|
|
|
// this allocator will be reaped, and underlying memory may be freed.
|
|
|
|
//
|
|
|
|
// (In practice we will still hold on to the initial pool to allow allocation
|
|
|
|
// to be quickly restared, but aditional pools will be freed).
|
|
|
|
//
|
|
|
|
// This allocator is non-renetrant, it is encumbant on the clients to ensure
|
|
|
|
// startAllocator() is not called again until stopAllocator() has been called.
|
|
|
|
class BumpPointerAllocator {
|
2019-08-12 20:57:15 +00:00
|
|
|
WTF_MAKE_FAST_ALLOCATED;
|
2010-07-27 19:14:40 +00:00
|
|
|
public:
|
|
|
|
BumpPointerAllocator()
|
2020-05-08 17:31:54 +00:00
|
|
|
: m_head(nullptr)
|
2010-07-27 19:14:40 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
~BumpPointerAllocator()
|
|
|
|
{
|
|
|
|
if (m_head)
|
|
|
|
m_head->destroy();
|
|
|
|
}
|
|
|
|
|
|
|
|
BumpPointerPool* startAllocator()
|
|
|
|
{
|
|
|
|
if (!m_head)
|
|
|
|
m_head = BumpPointerPool::create();
|
|
|
|
return m_head;
|
|
|
|
}
|
|
|
|
|
|
|
|
void stopAllocator()
|
|
|
|
{
|
|
|
|
if (m_head)
|
|
|
|
m_head->shrink();
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
BumpPointerPool* m_head;
|
|
|
|
};
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
using WTF::BumpPointerAllocator;
|