/** THIS METHOD IS NOT THREAD-SAFE. Use only at load time (or be mindful of thread safety). */ public void setUnsafeReadPoint(long offset) { setReadPoint(offset, unsafeReadPos); }
public long readNByteLong(long offset, int bytes, Position readPos) { setReadPoint(offset, readPos); long v = 0; if (isAllInOneReadBuffer(bytes, readPos)) { for (int i = 0; i < bytes; ++i) { v = (v << 8) + (readPos.buffer[readPos.offset + i] & 0xff); } readPos.offset += bytes; } else { for (int i = 0; i < bytes; ++i) { v = (v << 8) + (readNextByte(readPos) & 0xff); } } return v; }
public void getKey(long keyRefWord, ByteSegmentRef keyByteSegmentRef, WriteBuffers.Position readPos) { int storedKeyLength = (int) ((keyRefWord & SmallKeyLength.bitMask) >> SmallKeyLength.bitShift); boolean isKeyLengthSmall = (storedKeyLength != SmallKeyLength.allBitsOn); long absoluteKeyOffset = (keyRefWord & AbsoluteKeyOffset.bitMask); writeBuffers.setReadPoint(absoluteKeyOffset, readPos); if (!isKeyLengthSmall) { // Read big key length we wrote with the key. storedKeyLength = writeBuffers.readVInt(readPos); } writeBuffers.getByteSegmentRefToCurrent(keyByteSegmentRef, storedKeyLength, readPos); }
public int readInt(long offset, Position readPos) { setReadPoint(offset, readPos); long v = 0; if (isAllInOneReadBuffer(4, readPos)) { for (int i = 0; i < 4; ++i) { v = (v << 8) + (readPos.buffer[readPos.offset + i] & 0xff); } readPos.offset += 4; } else { for (int i = 0; i < 4; ++i) { v = (v << 8) + (readNextByte(readPos) & 0xff); } } return (int) v; }
public boolean equalKey(long keyRefWord, byte[] keyBytes, int keyStart, int keyLength, WriteBuffers.Position readPos) { int storedKeyLength = (int) ((keyRefWord & SmallKeyLength.bitMask) >> SmallKeyLength.bitShift); boolean isKeyLengthSmall = (storedKeyLength != SmallKeyLength.allBitsOn); if (isKeyLengthSmall && storedKeyLength != keyLength) { return false; } long absoluteKeyOffset = (keyRefWord & AbsoluteKeyOffset.bitMask); writeBuffers.setReadPoint(absoluteKeyOffset, readPos); if (!isKeyLengthSmall) { // Read big value length we wrote with the value. storedKeyLength = writeBuffers.readVInt(readPos); if (storedKeyLength != keyLength) { return false; } } // Our reading is positioned to the key. if (!writeBuffers.isEqual(keyBytes, keyStart, readPos, keyLength)) { return false; } // LOG.debug("VectorMapJoinFastKeyStore equalKey match on bytes"); return true; }
public int hashCode(long offset, int length, Position readPos) { setReadPoint(offset, readPos); if (isAllInOneReadBuffer(length, readPos)) { int result = HashCodeUtil.murmurHash(readPos.buffer, readPos.offset, length); readPos.offset += length; return result; } // Rare case of buffer boundary. Unfortunately we'd have to copy some bytes. byte[] bytes = new byte[length]; int destOffset = 0; while (destOffset < length) { ponderNextBufferToRead(readPos); int toRead = Math.min(length - destOffset, wbSize - readPos.offset); System.arraycopy(readPos.buffer, readPos.offset, bytes, destOffset, toRead); readPos.offset += toRead; destOffset += toRead; } return HashCodeUtil.murmurHash(bytes, 0, bytes.length); }
hashMapStore.writeBuffers.setReadPoint( referenceAbsoluteOffset, readPos); long relativeNextValueOffset = hashMapStore.writeBuffers.setReadPoint(firstValueAbsoluteOffset, readPos); nextValueLength = hashMapStore.writeBuffers.readVInt(readPos); } else { hashMapStore.writeBuffers.setReadPoint(nextAbsoluteValueOffset, readPos);
public boolean equalKey(long keyRefWord, byte[] keyBytes, int keyStart, int keyLength, WriteBuffers.Position readPos) { int storedKeyLengthLength = (int) ((keyRefWord & SmallKeyLength.bitMask) >> SmallKeyLength.bitShift); boolean isKeyLengthSmall = (storedKeyLengthLength != SmallKeyLength.allBitsOn); // LOG.debug("VectorMapJoinFastKeyStore equalKey keyLength " + keyLength + " isKeyLengthSmall " + isKeyLengthSmall + " storedKeyLengthLength " + storedKeyLengthLength + " keyRefWord " + Long.toHexString(keyRefWord)); if (isKeyLengthSmall && storedKeyLengthLength != keyLength) { return false; } long absoluteKeyOffset = (keyRefWord & AbsoluteKeyOffset.bitMask); writeBuffers.setReadPoint(absoluteKeyOffset, readPos); if (!isKeyLengthSmall) { // Read big value length we wrote with the value. storedKeyLengthLength = writeBuffers.readVInt(readPos); if (storedKeyLengthLength != keyLength) { // LOG.debug("VectorMapJoinFastKeyStore equalKey no match big length"); return false; } } // Our reading is positioned to the key. if (!writeBuffers.isEqual(keyBytes, keyStart, readPos, keyLength)) { // LOG.debug("VectorMapJoinFastKeyStore equalKey no match on bytes"); return false; } // LOG.debug("VectorMapJoinFastKeyStore equalKey match on bytes"); return true; }
/** * Mark the key matched with equalKey as a match and set up for reading the values. * Afterward, methods isSingleRow, cappedCount, first, next, etc may be called. */ public void setMatch() { hasRows = true; isSingleRow = KeyRef.getIsSingleFlag(refWord); // We must set the position since equalKey does not leave us positioned correctly. hashMapStore.writeBuffers.setReadPoint( keyAbsoluteOffset + keyLength, readPos); // Save first value absolute offset... firstValueAbsoluteOffset = hashMapStore.writeBuffers.getReadPoint(readPos); // Position to beginning. readIndex = 0; isNextEof = false; setJoinResult(JoinResult.MATCH); }
public void getKey(long refWord, ByteSegmentRef keyByteSegmentRef, WriteBuffers.Position readPos) { final long absoluteOffset = KeyRef.getAbsoluteOffset(refWord); writeBuffers.setReadPoint(absoluteOffset, readPos); int keyLength = KeyRef.getSmallKeyLength(refWord); boolean isKeyLengthSmall = (keyLength != KeyRef.SmallKeyLength.allBitsOn); if (!isKeyLengthSmall) { // Read big key length we wrote with the key. keyLength = writeBuffers.readVInt(readPos); } writeBuffers.getByteSegmentRefToCurrent(keyByteSegmentRef, keyLength, readPos); }
/** * Setup for reading the key of an entry with the equalKey method. * @param setStore * @param refWord */ public void setKey(VectorMapJoinFastBytesHashSetStore setStore, long refWord) { // Preconditions.checkState(!KeyRef.getIsInvalidFlag(refWord)); this.setStore = setStore; absoluteOffset = KeyRef.getAbsoluteOffset(refWord); // Position after next relative offset (fixed length) to the key. setStore.writeBuffers.setReadPoint(absoluteOffset, readPos); keyLength = KeyRef.getSmallKeyLength(refWord); boolean isKeyLengthSmall = (keyLength != KeyRef.SmallKeyLength.allBitsOn); if (!isKeyLengthSmall) { // And, if current value is big we must read it. keyLength = setStore.writeBuffers.readVInt(readPos); } // NOTE: Reading is now positioned before the key bytes. }
/** * Setup for reading the key of an entry with the equalKey method. * @param multiSetStore * @param refWord */ public void setKey(VectorMapJoinFastBytesHashMultiSetStore multiSetStore, long refWord) { // Preconditions.checkState(!KeyRef.getIsInvalidFlag(refWord)); this.multiSetStore = multiSetStore; this.refWord = refWord; absoluteOffset = KeyRef.getAbsoluteOffset(refWord); // Position after next relative offset (fixed length) to the key. multiSetStore.writeBuffers.setReadPoint(absoluteOffset, readPos); keyLength = KeyRef.getSmallKeyLength(refWord); boolean isKeyLengthSmall = (keyLength != KeyRef.SmallKeyLength.allBitsOn); if (!isKeyLengthSmall) { // And, if current value is big we must read it. keyLength = multiSetStore.writeBuffers.readVInt(readPos); } // NOTE: Reading is now positioned before the key bytes. }
public static int calculateHashCode(long refWord, WriteBuffers writeBuffers, WriteBuffers.Position readPos) { // Preconditions.checkState((refWord & KeyRef.IsInvalidFlag.flagOnMask) == 0); final long absoluteOffset = KeyRef.getAbsoluteOffset(refWord); int actualKeyLength = KeyRef.getSmallKeyLength(refWord); boolean isKeyLengthSmall = (actualKeyLength != KeyRef.SmallKeyLength.allBitsOn); final long keyAbsoluteOffset; if (!isKeyLengthSmall) { // Position after next relative offset (fixed length) to the key. writeBuffers.setReadPoint(absoluteOffset, readPos); // And, if current value is big we must read it. actualKeyLength = writeBuffers.readVInt(readPos); keyAbsoluteOffset = absoluteOffset + actualKeyLength; } else { keyAbsoluteOffset = absoluteOffset; } return writeBuffers.unsafeHashCode(keyAbsoluteOffset, actualKeyLength); }
public static boolean equalKey(long refWord, byte[] keyBytes, int keyStart, int keyLength, WriteBuffers writeBuffers, WriteBuffers.Position readPos) { // Preconditions.checkState((refWord & KeyRef.IsInvalidFlag.flagOnMask) == 0); final long absoluteOffset = KeyRef.getAbsoluteOffset(refWord); writeBuffers.setReadPoint(absoluteOffset, readPos); int actualKeyLength = KeyRef.getSmallKeyLength(refWord); boolean isKeyLengthSmall = (actualKeyLength != KeyRef.SmallKeyLength.allBitsOn); if (!isKeyLengthSmall) { // And, if current value is big we must read it. actualKeyLength = writeBuffers.readVInt(readPos); } if (actualKeyLength != keyLength) { return false; } // Our reading was positioned to the key. if (!writeBuffers.isEqual(keyBytes, keyStart, readPos, keyLength)) { return false; } return true; }
/** * Setup for reading the key of an entry with the equalKey method. * @param hashMapStore * @param refWord */ public void setKey(VectorMapJoinFastBytesHashMapStore hashMapStore, long refWord) { // Preconditions.checkState(!KeyRef.getIsInvalidFlag(refWord)); this.hashMapStore = hashMapStore; this.refWord = refWord; absoluteOffset = KeyRef.getAbsoluteOffset(refWord); // Position after next relative offset (fixed length) to the key. hashMapStore.writeBuffers.setReadPoint(absoluteOffset, readPos); keyLength = KeyRef.getSmallKeyLength(refWord); boolean isKeyLengthSmall = (keyLength != KeyRef.SmallKeyLength.allBitsOn); if (isKeyLengthSmall) { keyAbsoluteOffset = absoluteOffset; } else { // And, if current value is big we must read it. keyLength = hashMapStore.writeBuffers.readVInt(readPos); keyAbsoluteOffset = hashMapStore.writeBuffers.getReadPoint(readPos); } // NOTE: Reading is now positioned before the key bytes. }
hashMap.writeBuffers.setReadPoint(firstOffset, readPos); int valueLength = (int) hashMap.writeBuffers.readVLong(readPos); hashMap.writeBuffers.setReadPoint(firstOffset + relativeOffset, readPos); int valueLength = (int) hashMap.writeBuffers.readVLong(readPos); hashMap.writeBuffers.setReadPoint(nextTailOffset, readPos);
hashMap.writeBuffers.setReadPoint(firstOffset, readPos); int valueLength = (int) hashMap.writeBuffers.readVLong(readPos); hashMap.writeBuffers.setReadPoint(firstOffset + relativeOffset, readPos); int valueLength = (int) hashMap.writeBuffers.readVLong(readPos); hashMap.writeBuffers.setReadPoint(nextTailOffset, readPos);
/** * Same as {@link #isSameKey(long, int, long, int)} but for externally stored key. */ private boolean isSameKey(byte[] key, int offset, int length, long ref, int hashCode, WriteBuffers.Position readPos) { if (!compareHashBits(ref, hashCode)) { return false; // Hash bits don't match. } writeBuffers.setReadPoint(getFirstRecordLengthsOffset(ref, readPos), readPos); int valueLength = (int)writeBuffers.readVLong(readPos), keyLength = (int)writeBuffers.readVLong(readPos); long keyOffset = Ref.getOffset(ref) - (valueLength + keyLength); // See the comment in the other isSameKey if (offset == 0) { return writeBuffers.isEqual(key, length, keyOffset, keyLength); } else { return writeBuffers.isEqual(key, offset, length, keyOffset, keyLength); } }
/** * Same as {@link #isSameKey(long, int, long, int)} but for externally stored key. */ private boolean isSameKey(byte[] key, int offset, int length, long ref, int hashCode, WriteBuffers.Position readPos) { if (!compareHashBits(ref, hashCode)) { return false; // Hash bits don't match. } writeBuffers.setReadPoint(getFirstRecordLengthsOffset(ref, readPos), readPos); int valueLength = (int)writeBuffers.readVLong(readPos), keyLength = (int)writeBuffers.readVLong(readPos); long keyOffset = Ref.getOffset(ref) - (valueLength + keyLength); // See the comment in the other isSameKey if (offset == 0) { return writeBuffers.isEqual(key, length, keyOffset, keyLength); } else { return writeBuffers.isEqual(key, offset, length, keyOffset, keyLength); } }
writeBuffers.setReadPoint(getFirstRecordLengthsOffset(ref, readPos), readPos); int valueLength = (int) writeBuffers.readVLong(readPos); int keyLength = (int) writeBuffers.readVLong(readPos);