Java Code Examples for org.apache.flink.core.memory.MemorySegment#copyTo()

private void writeMultiSegmentsToVarLenPart(MemorySegment[] segments, int offset, int size) {
	// Write the bytes to the variable length portion.
	int needCopy = size;
	int fromOffset = offset;
	int toOffset = cursor;
	for (MemorySegment sourceSegment : segments) {
		int remain = sourceSegment.size() - fromOffset;
		if (remain > 0) {
			int copySize = remain > needCopy ? needCopy : remain;
			sourceSegment.copyTo(fromOffset, segment, toOffset, copySize);
			needCopy -= copySize;
			toOffset += copySize;
			fromOffset = 0;
		} else {
			fromOffset -= sourceSegment.size();
		}
	}
}
 

private void writeMultiSegmentsToVarLenPart(MemorySegment[] segments, int offset, int size) {
	// Write the bytes to the variable length portion.
	int needCopy = size;
	int fromOffset = offset;
	int toOffset = cursor;
	for (MemorySegment sourceSegment : segments) {
		int remain = sourceSegment.size() - fromOffset;
		if (remain > 0) {
			int copySize = remain > needCopy ? needCopy : remain;
			sourceSegment.copyTo(fromOffset, segment, toOffset, copySize);
			needCopy -= copySize;
			toOffset += copySize;
			fromOffset = 0;
		} else {
			fromOffset -= sourceSegment.size();
		}
	}
}
 

@Override
public void write(MemorySegment segment, int off, int len) throws IOException {
	int remaining = this.segmentSize - this.positionInSegment;
	if (remaining >= len) {
		segment.copyTo(off, currentSegment, positionInSegment, len);
		this.positionInSegment += len;
	} else {

		if (remaining == 0) {
			advance();
			remaining = this.segmentSize - this.positionInSegment;
		}

		while (true) {
			int toPut = Math.min(remaining, len);
			segment.copyTo(off, currentSegment, positionInSegment, toPut);
			off += toPut;
			len -= toPut;

			if (len > 0) {
				this.positionInSegment = this.segmentSize;
				advance();
				remaining = this.segmentSize - this.positionInSegment;
			}
			else {
				this.positionInSegment += toPut;
				break;
			}
		}
	}
}
 

/**
 * Gets serialized key and namespace from the byte buffer.
 *
 * @param memorySegment the memory segment which stores the skip list key.
 * @param offset     the start position of the skip list key in the byte buffer.
 * @return tuple of serialized key and namespace.
 */
Tuple2<byte[], byte[]> getSerializedKeyAndNamespace(MemorySegment memorySegment, int offset) {
	// read namespace
	int namespaceLen = memorySegment.getInt(offset);
	MemorySegment namespaceSegment = MemorySegmentFactory.allocateUnpooledSegment(namespaceLen);
	memorySegment.copyTo(offset + Integer.BYTES, namespaceSegment, 0, namespaceLen);

	// read key
	int keyOffset = offset + Integer.BYTES + namespaceLen;
	int keyLen = memorySegment.getInt(keyOffset);
	MemorySegment keySegment = MemorySegmentFactory.allocateUnpooledSegment(keyLen);
	memorySegment.copyTo(keyOffset + Integer.BYTES, keySegment, 0, keyLen);

	return Tuple2.of(keySegment.getArray(), namespaceSegment.getArray());
}
 

/**
 * Returns the byte array of serialized state.
 *
 * @param valuePointer pointer to value.
 * @return byte array of serialized value.
 */
byte[] helpGetBytesForState(long valuePointer) {
	Node node = getNodeSegmentAndOffset(valuePointer);
	MemorySegment segment = node.nodeSegment;
	int offsetInSegment = node.nodeOffset;

	int valueLen = SkipListUtils.getValueLen(segment, offsetInSegment);
	MemorySegment valueSegment = MemorySegmentFactory.allocateUnpooledSegment(valueLen);
	segment.copyTo(offsetInSegment + SkipListUtils.getValueMetaLen(), valueSegment, 0 , valueLen);

	return valueSegment.getArray();
}
 

private void setKeySegment(long node) {
	Node nodeStorage = getNodeSegmentAndOffset(node);
	MemorySegment segment = nodeStorage.nodeSegment;
	int offsetInSegment = nodeStorage.nodeOffset;

	int level = SkipListUtils.getLevel(segment, offsetInSegment);
	int keyLen = SkipListUtils.getKeyLen(segment, offsetInSegment);
	int keyDataOffset = offsetInSegment + SkipListUtils.getKeyDataOffset(level);

	MemorySegment nextKeySegment = MemorySegmentFactory.allocateUnpooledSegment(keyLen);
	segment.copyTo(keyDataOffset, nextKeySegment, 0, keyLen);
	this.nextKeySegment = nextKeySegment;
	nextKeyOffset = 0;
}
 

@Override
public void write(MemorySegment segment, int off, int len) throws IOException {
	int remaining = this.segmentSize - this.positionInSegment;
	if (remaining >= len) {
		segment.copyTo(off, currentSegment, positionInSegment, len);
		this.positionInSegment += len;
	} else {

		if (remaining == 0) {
			advance();
			remaining = this.segmentSize - this.positionInSegment;
		}

		while (true) {
			int toPut = Math.min(remaining, len);
			segment.copyTo(off, currentSegment, positionInSegment, toPut);
			off += toPut;
			len -= toPut;

			if (len > 0) {
				this.positionInSegment = this.segmentSize;
				advance();
				remaining = this.segmentSize - this.positionInSegment;
			}
			else {
				this.positionInSegment += toPut;
				break;
			}
		}
	}
}
 

public void write(MemorySegment seg, int off, int len) throws IOException {
	ensureCapacity(len);
	seg.copyTo(off, segment, cursor, len);
	cursor += len;
}
 

public void write(MemorySegment seg, int off, int len) throws IOException {
	ensureCapacity(len);
	seg.copyTo(off, segment, cursor, len);
	cursor += len;
}
 

/**
 * Puts the key data into key space.
 *
 * @param segment memory segment for key space.
 * @param offset offset of key space in memory segment.
 * @param keySegment memory segment for key data.
 * @param keyOffset offset of key data in memory segment.
 * @param keyLen length of key data.
 * @param level level of the key.
 */
public static void putKeyData(
	MemorySegment segment, int offset, MemorySegment keySegment, int keyOffset, int keyLen, int level) {
	keySegment.copyTo(keyOffset, segment, offset + getKeyDataOffset(level), keyLen);
}
 

/**
 * Puts the value data into value space.
 *
 * @param memorySegment memory segment for value space.
 * @param offset offset of value space in memory segment.
 * @param value value data.
 */
public static void putValueData(MemorySegment memorySegment, int offset, byte[] value) {
	MemorySegment valueSegment = MemorySegmentFactory.wrap(value);
	valueSegment.copyTo(0, memorySegment, offset + getValueMetaLen(), value.length);
}