protected String toStringForOffHeapByteSource() { return super.toString() + ":<dataSize=" + getDataSize() + " refCount=" + getRefCount() + " addr=" + Long.toHexString(getMemoryAddress()) + ">"; }
/** * Returns an address that can be used with unsafe apis to access this chunks memory. * @param offset the offset from this chunk's first byte of the byte the returned address should point to. Must be >= 0. * @param size the number of bytes that will be read using the returned address. Assertion will use this to verify that all the memory accessed belongs to this chunk. Must be > 0. * @return a memory address that can be used with unsafe apis */ protected final long getUnsafeBaseAddress(int offset, int size) { assert offset >= 0 && offset + size <= getDataSize(): "Offset=" + offset + ",size=" + size + ",dataSize=" + getDataSize() + ", chunkSize=" + getSize() + ", but offset + size must be <= " + getDataSize(); assert size > 0; long result = getBaseDataAddress() + offset; assert validateAddressAndSizeWithinSlab(result, size); return result; }
@Override public int getValueSizeInBytes() { return getDataSize(); }
@Override public void writeBytes(int offset, byte[] bytes, int bytesOffset, int size) { assert offset >= 0 && offset + size <= getDataSize(): "Offset=" + offset + ",size=" + size + ",dataSize=" + getDataSize() + ", chunkSize=" + getSize() + ", but offset + size must be <= " + getDataSize(); UnsafeMemoryChunk.writeAbsoluteBytes(getBaseDataAddress() + offset, bytes, bytesOffset, size); }
@Override public byte readByte(int offset) { assert offset >= 0 && offset < getDataSize(): "Offset=" + offset + ", dataSize=" + getDataSize() + ", chunkSize=" + getSize() + ", but offset must be < dataSize"; return UnsafeMemoryChunk.readAbsoluteByte(getBaseDataAddress() + offset); }
public String getDataType() { if (this.block.getDataType() != null) { return this.block.getDataType(); } if (!isSerialized()) { // byte array return "byte[" + ((Chunk)this.block).getDataSize() + "]"; } //Object obj = EntryEventImpl.deserialize(((Chunk)this.block).getRawBytes()); byte[] bytes = ((Chunk)this.block).getRawBytes(); return DataType.getDataType(bytes); } public boolean isSerialized() {
@Override public void readBytes(int offset, byte[] bytes, int bytesOffset, int size) { assert offset >= 0 && offset + size <= getDataSize(): "Offset=" + offset + ",size=" + size + ",dataSize=" + getDataSize() + ", chunkSize=" + getSize() + ", but offset + size must be <= " + getDataSize(); UnsafeMemoryChunk.readAbsoluteBytes(getBaseDataAddress(), offset, bytes, bytesOffset, size); }
protected byte[] getRawBytes() { byte[] result = new byte[getDataSize()]; readBytes(0, result); //debugLog("reading", true); getAllocator().getStats().incReads(); if (isCompressed()) { result = getAllocator().getCompressor().decompress(result); } return result; }
@Override public void writeByte(int offset, byte value) { assert offset >= 0 && offset < getDataSize(): "Offset=" + offset + ", dataSize=" + getDataSize() + ", chunkSize=" + getSize() + ", but offset must be < dataSize"; UnsafeMemoryChunk.writeAbsoluteByte(getBaseDataAddress() + offset, value); }
@Override public String toString() { return super.toString() + ":<dataSize=" + getDataSize() + " refCount=" + getRefCount() + " addr=" + getMemoryAddress() + " storedObject=" + getDeserializedForReading() + ">"; }
public final int getDataSize() { /*int dataSizeDelta = UnsafeMemoryChunk.readAbsoluteInt(this.memoryAddress+REF_COUNT_OFFSET); dataSizeDelta &= DATA_SIZE_DELTA_MASK; dataSizeDelta >>= DATA_SIZE_SHIFT; return getSize() - dataSizeDelta;*/ return getDataSize(UnsafeMemoryChunk.getUnsafeWrapper(), this.memoryAddress); }