protected long tierAddr(TierBulkData tierBulkData, long tierIndexOffsetWithinBulk) { return tierBulkData.bytesStore.addressForRead(0) + tierBulkData.offset + tierBulkInnerOffsetToTiers + tierIndexOffsetWithinBulk * tierSize; }
@Override public long addressForRead(long offset) throws BufferUnderflowException { return bytesStore.addressForRead(offset); }
public long bsAddress() { return bs.addressForRead(0); }
public long address() { return bytesStore().addressForRead(offset); } }
@Override public void bytesStore(@NotNull BytesStore bytes, long offset, long length) { if (length != maxSize()) throw new IllegalArgumentException(); address = bytes.addressForRead(offset); bytes.reserve(); unsafe = UnsafeMemory.UNSAFE; }
public static void assignBytesStoreToByteBuffer(@org.jetbrains.annotations.NotNull BytesStore bytesStore, @org.jetbrains.annotations.NotNull ByteBuffer byteBuffer) throws BufferUnderflowException { long address = bytesStore.addressForRead(bytesStore.readPosition()); long capacity = bytesStore.readRemaining(); ByteBuffers.setAddressCapacity(byteBuffer, address, capacity); byteBuffer.clear(); }
@Override public long addressForRead(long offset, int buffer) throws UnsupportedOperationException, BufferUnderflowException { if (!bytesStore.inside(offset, buffer)) acquireNextByteStore0(offset, true); return bytesStore.addressForRead(offset); }
@Override public long addressForRead(long offset) throws BufferUnderflowException { if (!bytesStore.inside(offset)) acquireNextByteStore0(offset, true); return bytesStore.addressForRead(offset); }
static long applyAsLong1to7(@NotNull BytesStore store, int remaining) { final long address = store.addressForRead(store.readPosition()); return hash(readIncompleteLong(address, remaining)); }
static long applyAsLong8(@NotNull BytesStore store) { final long address = store.addressForRead(store.readPosition()); return hash0(MEMORY.readLong(address), MEMORY.readInt(address + TOP_BYTES)); }
public void linkAndZeroOutFreeTiers(long firstTierIndex, long lastTierIndex) { for (long tierIndex = firstTierIndex; tierIndex <= lastTierIndex; tierIndex++) { long tierOffset = tierBytesOffset(tierIndex); BytesStore tierBytesStore = tierBytesStore(tierIndex); zeroOutNewlyMappedTier(tierBytesStore, tierOffset); if (tierIndex < lastTierIndex) { long tierCountersAreaOffset = tierOffset + tierHashLookupOuterSize; TierCountersArea.nextTierIndex(tierBytesStore.addressForRead(0) + tierCountersAreaOffset, tierIndex + 1); } } }
public long rawCopy(@NotNull BytesStore bytes, long offset, long length) throws BufferOverflowException, IllegalArgumentException { long len = Math.min(writeRemaining(), Math.min(bytes.capacity() - offset, length)); if (len > 0) { writeCheckOffset(writePosition(), len); OS.memory().copyMemory(bytes.addressForRead(offset), addressForWrite(writePosition()), len); writeSkip(len); } return len; }
public long rawCopy(@NotNull BytesStore bytes, long offset, long length) throws BufferOverflowException, BufferUnderflowException { assert length < safeCopySize(); this.acquireNextByteStore(writePosition(), false); long len = Math.min(writeRemaining(), Math.min(bytes.readRemaining(), length)); if (len > 0) { OS.memory().copyMemory(bytes.addressForRead(offset), addressForWrite(writePosition()), len); uncheckedWritePosition(writePosition() + len); } return len; }
private void allocateTierBulk() throws IOException { int allocatedExtraTierBulks = globalMutableState.getAllocatedExtraTierBulks(); mapTierBulks(allocatedExtraTierBulks); long firstTierIndex = extraTierIndexToTierIndex(allocatedExtraTierBulks * tiersInBulk); BytesStore tierBytesStore = tierBytesStore(firstTierIndex); long firstTierOffset = tierBytesOffset(firstTierIndex); if (tierBulkInnerOffsetToTiers > 0) { // These bytes are bit sets in Replicated version tierBytesStore.zeroOut(firstTierOffset - tierBulkInnerOffsetToTiers, firstTierOffset); } long lastTierIndex = firstTierIndex + tiersInBulk - 1; linkAndZeroOutFreeTiers(firstTierIndex, lastTierIndex); // see HCOLL-397 if (persisted()) { long address = tierBytesStore.addressForRead(firstTierOffset - tierBulkInnerOffsetToTiers); long endAddress = tierBytesStore.addressForRead(tierBytesOffset(lastTierIndex)) + tierSize; long length = endAddress - address; msync(address, length); } // after we are sure the new bulk is initialized, update the global mutable state globalMutableState.setAllocatedExtraTierBulks(allocatedExtraTierBulks + 1); globalMutableState.setFirstFreeTierIndex(firstTierIndex); globalMutableState.addDataStoreSize(tierBulkSizeInBytes); }
BytesStore allocatedTierBytes = tierBytesStore(firstFreeTierIndex); long allocatedTierOffset = tierBytesOffset(firstFreeTierIndex); long tierBaseAddr = allocatedTierBytes.addressForRead(0) + allocatedTierOffset; long tierCountersAreaAddr = tierBaseAddr + tierHashLookupOuterSize; long nextFreeTierIndex = TierCountersArea.nextTierIndex(tierCountersAreaAddr);