@Override public void createDurableEntity(A allocator, EntityFactoryProxy[] factoryProxy, DurableType[] gField, boolean autoReclaim, ReclaimContext rctx) throws OutOfHybridMemory { initializeDurableEntity(allocator, factoryProxy, gField, autoReclaim, rctx); this.holder = allocator.createChunk(MAX_OBJECT_SIZE * totalCapacity, autoReclaim, reclaimcontext); this.chunkAddr = allocator.createChunk(MAX_OBJECT_SIZE, autoReclaim, reclaimcontext); unsafe.putLong(chunkAddr.get(), allocator.getChunkHandler(holder)); if (null == this.holder || null == this.chunkAddr) { throw new OutOfHybridMemory("Create Durable Entity Error!"); } initializeAfterCreate(); }
/** * release the memory pool and close it. * */ @Override public void close() { super.close(); }
@Override public void setName(String name, boolean destroy) throws OutOfHybridMemory, RetrieveDurableEntityError { if (destroy && null != getName()) { m_name_1B779B.destroy(); m_name_1B779B = null; m_unsafe_B1757C.putAddress(m_holder_3CE8C3.get() + 0, 0L); } if (null == name) { m_unsafe_B1757C.putLong(m_holder_3CE8C3.get() + 0, 0L); } else { m_name_1B779B = m_allocator_11A68B.createBuffer(name.length() * 2, m_autoreclaim_071A8E); if (null == m_name_1B779B) { throw new OutOfHybridMemory("Create Durable String Error!"); } m_name_1B779B.get().asCharBuffer().put(name); m_unsafe_B1757C.putLong(m_holder_3CE8C3.get() + 0, m_allocator_11A68B.getBufferHandler(m_name_1B779B)); } }
@SuppressWarnings("unchecked") protected V createDurableObjectRecord(long size) { V ret = null; switch (getDurableTypes()[0]) { case DURABLE: ret = (V) getEntityFactoryProxies()[0].create(m_act, m_recparmpair.getRight(), m_recparmpair.getLeft(), false); case BUFFER: if (size > 0) { ret = (V)m_act.createBuffer(size); if (null == ret) { throw new OutOfHybridMemory("Allocate a buffer failed"); } } break; case CHUNK: if (size > 0) { ret = (V)m_act.createChunk(size); if (null == ret) { throw new OutOfHybridMemory("Allocate a chunk failed"); } } break; default: break; } return ret; }
@Override public void restoreDurableEntity(A allocator, EntityFactoryProxy[] factoryProxy, DurableType[] gType, long phandler, boolean autoReclaim, ReclaimContext rctx) throws RestoreDurableEntityError { initializeDurableEntity(allocator, factoryProxy, gType, autoReclaim, rctx); if (0L == phandler) { throw new RestoreDurableEntityError("Input handler is null on restoreDurableEntity."); } holder = allocator.retrieveChunk(phandler, autoReclaim); long rootHandler = unsafe.getLong(holder.get()); root = TreeNodeFactory.restore(allocator, factoryProxy, genericType, rootHandler, autoReclaim, reclaimcontext); initializeAfterRestore(); }
@Override public void createDurableEntity(A allocator, EntityFactoryProxy[] factoryProxy, DurableType[] gType, boolean autoReclaim, ReclaimContext rctx) throws OutOfHybridMemory { initializeDurableEntity(allocator, factoryProxy, gType, autoReclaim, rctx); this.holder = allocator.createChunk(MAX_OBJECT_SIZE, autoReclaim, reclaimcontext); initializeAfterCreate(); }
long phandler = m_unsafe.getAddress(m_fpos); if (0L != phandler) { m_strfield = m_allocator.retrieveBuffer(phandler, m_autoreclaim); if (null == m_strfield) { throw new RetrieveDurableEntityError("Retrieve String Buffer Failure."); long phandler = m_unsafe.getAddress(m_fpos); if (0L != phandler) { m_chunkfield = m_allocator.retrieveChunk(phandler, m_autoreclaim); if (null == m_chunkfield) { throw new RetrieveDurableEntityError("Retrieve Chunk Failure."); long phandler = m_unsafe.getAddress(m_fpos); if (0L != phandler) { m_bufferfield = m_allocator.retrieveBuffer(phandler, m_autoreclaim); if (null == m_bufferfield) { throw new RetrieveDurableEntityError("Retrieve Buffer Failure.");
@Override public long getHandler() { return allocator.getChunkHandler(holder); }
@Override public String getName() throws RetrieveDurableEntityError { if (null == m_name_9807CF) { long phandler = m_unsafe_760FBE.getAddress(m_holder_68BA57.get() + 0); if (0L != phandler) { m_name_9807CF = m_allocator_77CA34.retrieveBuffer(phandler, m_autoreclaim_7E4A25, m_reclaimcontext_B5B531); if (null == m_name_9807CF) { throw new RetrieveDurableEntityError("Retrieve String Buffer Failure."); } } } return null == m_name_9807CF ? null : m_name_9807CF.get().asCharBuffer().toString(); }
@Override public void setName(String name, boolean destroy) throws OutOfHybridMemory, RetrieveDurableEntityError { if (destroy && null != getName()) { m_name_9807CF.destroy(); m_name_9807CF = null; m_unsafe_760FBE.putAddress(m_holder_68BA57.get() + 0, 0L); } if (null == name) { m_unsafe_760FBE.putLong(m_holder_68BA57.get() + 0, 0L); } else { m_name_9807CF = m_allocator_77CA34.createBuffer(name.length() * 2, m_autoreclaim_7E4A25); if (null == m_name_9807CF) { throw new OutOfHybridMemory("Create Durable String Error!"); } m_name_9807CF.get().asCharBuffer().put(name); m_unsafe_760FBE.putLong(m_holder_68BA57.get() + 0, m_allocator_77CA34.getBufferHandler(m_name_9807CF)); } }
@Override public void restoreDurableEntity(ALLOC_PMem3C93D24F59 arg0, EntityFactoryProxy[] arg1, DurableType[] arg2, long arg3, boolean arg4, ReclaimContext arg5) throws RestoreDurableEntityError { initializeDurableEntity(arg0, arg1, arg2, arg4, arg5); if (0L == arg3) { throw new RestoreDurableEntityError("Input handler is null on restoreDurableEntity."); } m_holder_E5EEE3 = m_allocator_873DA6.retrieveChunk(arg3, m_autoreclaim_3AECF4, m_reclaimcontext_11DAB9); if (null == m_holder_E5EEE3) { throw new RestoreDurableEntityError("Retrieve Entity Failure!"); } initializeAfterRestore(); }
@Override public void createDurableEntity(ALLOC_PMem3C93D24F59 arg0, EntityFactoryProxy[] arg1, DurableType[] arg2, boolean arg3, ReclaimContext arg4) throws OutOfHybridMemory { initializeDurableEntity(arg0, arg1, arg2, arg3, arg4); m_holder_00EAAD = m_allocator_7FA20A.createChunk(16, m_autoreclaim_76D4CF, m_reclaimcontext_746C46); if (null == m_holder_00EAAD) { throw new OutOfHybridMemory("Create Durable Entity Error!"); } initializeAfterCreate(); }
@Override public long getHandler() { return m_allocator_11A68B.getChunkHandler(m_holder_3CE8C3); }
@Override public String getName() throws RetrieveDurableEntityError { if (null == m_name_1B779B) { long phandler = m_unsafe_B1757C.getAddress(m_holder_3CE8C3.get() + 0); if (0L != phandler) { m_name_1B779B = m_allocator_11A68B.retrieveBuffer(phandler, m_autoreclaim_071A8E, m_reclaimcontext_9C2BE7); if (null == m_name_1B779B) { throw new RetrieveDurableEntityError("Retrieve String Buffer Failure."); } } } return null == m_name_1B779B ? null : m_name_1B779B.get().asCharBuffer().toString(); }
@Override public void setStr(String str, boolean destroy) throws OutOfHybridMemory, RetrieveDurableEntityError { if (destroy && null != getStr()) { m_str_A55313.destroy(); m_str_A55313 = null; m_unsafe_AE4FB2.putAddress(m_holder_5BC267.get() + 0, 0L); } if (null == str) { m_unsafe_AE4FB2.putLong(m_holder_5BC267.get() + 0, 0L); } else { m_str_A55313 = m_allocator_CF10A9.createBuffer(str.length() * 2, m_autoreclaim_8F4B75); if (null == m_str_A55313) { throw new OutOfHybridMemory("Create Durable String Error!"); } m_str_A55313.get().asCharBuffer().put(str); m_unsafe_AE4FB2.putLong(m_holder_5BC267.get() + 0, m_allocator_CF10A9.getBufferHandler(m_str_A55313)); } }
@Override public void restoreDurableEntity(A allocator, EntityFactoryProxy[] factoryProxy, DurableType[] gField, long phandler, boolean autoReclaim, ReclaimContext rctx) throws RestoreDurableEntityError { initializeDurableEntity(allocator, factoryProxy, gField, autoReclaim, rctx); if (0L == phandler) { throw new RestoreDurableEntityError("Input handler is null on restoreDurableEntity."); } chunkAddr = allocator.retrieveChunk(phandler, autoReclaim, reclaimcontext); long chunkHandler = unsafe.getLong(chunkAddr.get()); holder = allocator.retrieveChunk(chunkHandler, autoReclaim, reclaimcontext); if (null == holder || null == chunkAddr) { throw new RestoreDurableEntityError("Retrieve Entity Failure!"); } setCapacityHint(holder.getSize() / MAX_OBJECT_SIZE); mapSize = recomputeMapSize(); initializeAfterRestore(); }
@Override public void createDurableEntity(A allocator, EntityFactoryProxy[] factoryProxy, DurableType[] gType, boolean autoReclaim, ReclaimContext rctx) throws OutOfHybridMemory { initializeDurableEntity(allocator, factoryProxy, gType, autoReclaim, rctx); this.holder = allocator.createChunk(MAX_OBJECT_SIZE * arraySize, autoReclaim, reclaimcontext); if (null == this.holder) { throw new OutOfHybridMemory("Create Durable Entity Error!"); } genericField = new Object[arraySize]; initializeAfterCreate(); }
long bucketAddr = prevHolder.get(); long maxbucketAddr = bucketAddr + MAX_OBJECT_SIZE * totalCapacity; holder = allocator.createChunk(MAX_OBJECT_SIZE * newCapacity, autoReclaim); if (null == holder) { autoResize = false; unsafe.putLong(chunkAddr.get(), allocator.getChunkHandler(holder)); while (bucketAddr < maxbucketAddr) { long handler = unsafe.getAddress(bucketAddr);
@Override public long getHandler() { return m_allocator_42A80A.getChunkHandler(m_holder_A8BF22); }
@Override public String getStr() throws RetrieveDurableEntityError { if (null == m_str_A55313) { long phandler = m_unsafe_AE4FB2.getAddress(m_holder_5BC267.get() + 0); if (0L != phandler) { m_str_A55313 = m_allocator_CF10A9.retrieveBuffer(phandler, m_autoreclaim_8F4B75, m_reclaimcontext_998750); if (null == m_str_A55313) { throw new RetrieveDurableEntityError("Retrieve String Buffer Failure."); } } } return null == m_str_A55313 ? null : m_str_A55313.get().asCharBuffer().toString(); }