private void testSwap(MemorySegment seg1, MemorySegment seg2) { int[] offsetsToTest = { 0, 1, -1, seg1.size(), -seg1.size(), Integer.MAX_VALUE, Integer.MIN_VALUE }; int[] lengthsToTest = { 0, 1, -1, seg1.size(), -seg1.size(), Integer.MAX_VALUE, Integer.MIN_VALUE }; byte[] swapBuffer = new byte[seg1.size()]; for (int off1 : offsetsToTest) { for (int off2 : offsetsToTest) { for (int len : lengthsToTest) { try { seg1.swapBytes(swapBuffer, seg2, off1, off2, len); fail("Should fail with an exception"); } catch (IllegalStateException | IndexOutOfBoundsException | NullPointerException ignored) {} } } } } }
private void testCopy(MemorySegment seg1, MemorySegment seg2) { int[] offsetsToTest = { 0, 1, -1, seg1.size(), -seg1.size(), Integer.MAX_VALUE, Integer.MIN_VALUE }; int[] lengthsToTest = { 0, 1, -1, seg1.size(), -seg1.size(), Integer.MAX_VALUE, Integer.MIN_VALUE }; for (int off1 : offsetsToTest) { for (int off2 : offsetsToTest) { for (int len : lengthsToTest) { try { seg1.copyTo(off1, seg2, off2, len); fail("Should fail with an exception"); } catch (IllegalStateException | IndexOutOfBoundsException | NullPointerException ignored) {} } } } }
private void testCompare(MemorySegment seg1, MemorySegment seg2) { int[] offsetsToTest = { 0, 1, -1, seg1.size(), -seg1.size(), Integer.MAX_VALUE, Integer.MIN_VALUE }; int[] lengthsToTest = { 1, seg1.size(), Integer.MAX_VALUE }; for (int off1 : offsetsToTest) { for (int off2 : offsetsToTest) { for (int len : lengthsToTest) { try { seg1.compare(seg2, off1, off2, len); fail("Should fail with an exception"); } catch (IllegalStateException | IndexOutOfBoundsException | NullPointerException ignored) {} } } } }
private void testCompare(MemorySegment seg1, MemorySegment seg2, Random random) { assertEquals(pageSize, seg1.size()); assertEquals(pageSize, seg2.size()); final byte[] bytes1 = new byte[pageSize]; final byte[] bytes2 = new byte[pageSize]; final int stride = pageSize / 255; final int shift = 16666; for (int i = 0; i < pageSize; i++) { byte val = (byte) ((i / stride) & 0xff); bytes1[i] = val; if (i + shift < bytes2.length) { bytes2[i + shift] = val; } } seg1.put(0, bytes1); seg2.put(0, bytes2); for (int i = 0; i < 1000; i++) { int pos1 = random.nextInt(bytes1.length); int pos2 = random.nextInt(bytes2.length); int len = Math.min(Math.min(bytes1.length - pos1, bytes2.length - pos2), random.nextInt(pageSize / 50)); int cmp = seg1.compare(seg2, pos1, pos2, len); if (pos1 < pos2 - shift) { assertTrue(cmp <= 0); } else { assertTrue(cmp >= 0); } } }
@Test public void testSizeAndFreeing() { // a segment without an owner has a null owner final int segmentSize = 651; MemorySegment seg = createSegment(segmentSize); assertEquals(segmentSize, seg.size()); assertFalse(seg.isFreed()); seg.free(); assertTrue(seg.isFreed()); assertEquals(segmentSize, seg.size()); }
private void testSwap(MemorySegment seg1, MemorySegment seg2, Random random, int smallerSize) { assertEquals(pageSize, seg1.size()); assertEquals(smallerSize, seg2.size()); final byte[] bytes1 = new byte[pageSize]; final byte[] bytes2 = new byte[smallerSize]; Arrays.fill(bytes2, (byte) 1); seg1.put(0, bytes1); seg2.put(0, bytes2); // wap the second half of the first segment with the second segment int pos = 0; while (pos < smallerSize) { int len = random.nextInt(pageSize / 40); len = Math.min(len, smallerSize - pos); seg1.swapBytes(new byte[len], seg2, pos + smallerSize, pos, len); pos += len; } // the second segment should now be all zeros, the first segment should have one in its second half for (int i = 0; i < smallerSize; i++) { assertEquals((byte) 0, seg1.get(i)); assertEquals((byte) 0, seg2.get(i)); assertEquals((byte) 1, seg1.get(i + smallerSize)); } }
segment.get(segment.size()); fail("Should fail with an exception"); segment.get(-segment.size()); fail("Should fail with an exception"); segment.put(segment.size(), (byte) 0); fail("Should fail with an exception"); segment.put(-segment.size(), (byte) 0); fail("Should fail with an exception"); segment.getBoolean(segment.size()); fail("Should fail with an exception"); segment.getBoolean(-segment.size()); fail("Should fail with an exception"); segment.putBoolean(segment.size(), true); fail("Should fail with an exception"); segment.putBoolean(-segment.size(), true); fail("Should fail with an exception"); segment.getChar(segment.size()); fail("Should fail with an exception"); segment.getChar(-segment.size()); fail("Should fail with an exception");
public BytesHashMapSpillMemorySegmentPool(List<MemorySegment> memorySegments) { this.segments = memorySegments; this.pageSize = memorySegments.get(0).size(); this.allocated = 0; }
@Override public String toString() { StringBuilder output = new StringBuilder(); output.append("BitSet:\n"); output.append("\tMemorySegment:").append(memorySegment.size()).append("\n"); output.append("\tOffset:").append(offset).append("\n"); output.append("\tLength:").append(length).append("\n"); return output.toString(); } }
@Override public String toString() { StringBuilder output = new StringBuilder(); output.append("BitSet:\n"); output.append("\tMemorySegment:").append(memorySegment.size()).append("\n"); output.append("\tOffset:").append(offset).append("\n"); output.append("\tLength:").append(byteLength).append("\n"); return output.toString(); } }
@Override public ByteBuf capacity(int newCapacity) { ensureAccessible(); if (newCapacity < 0 || newCapacity > maxCapacity()) { throw new IllegalArgumentException("Size of buffer must be >= 0 and <= " + memorySegment.size() + ", but was " + newCapacity + "."); } this.currentSize = newCapacity; return this; }
@Override public ByteBuf capacity(int newCapacity) { ensureAccessible(); if (newCapacity < 0 || newCapacity > maxCapacity()) { throw new IllegalArgumentException("Size of buffer must be >= 0 and <= " + memorySegment.size() + ", but was " + newCapacity + "."); } this.currentSize = newCapacity; return this; }
public BlockSortedDataFile(FileIOChannel.ID channelID, TypeSerializer<T> serialize, IOManager ioManager, List<MemorySegment> writeMemory) throws IOException { checkArgument(writeMemory.size() > 0, "Write memory are required for the BlockSortedDataFile."); this.channelID = channelID; this.serialize = serialize; this.ioManager = ioManager; blockFileWriter = ioManager.createBlockChannelWriter(channelID); channelWriterOutputView = new ChannelWriterOutputView(blockFileWriter, writeMemory, writeMemory.get(0).size()); }
private static int getIntMultiSeg(MemorySegment[] segments, int offset) { int segSize = segments[0].size(); int segIndex = offset / segSize; int segOffset = offset - segIndex * segSize; // equal to % if (segOffset < segSize - 3) { return segments[segIndex].getInt(segOffset); } else { return getIntSlowly(segments, segSize, segIndex, segOffset); } }
public void setMemorySegment(MemorySegment memorySegment, int offset) { Preconditions.checkArgument(memorySegment != null, "MemorySegment can not be null."); Preconditions.checkArgument(offset >= 0, "Offset should be positive integer."); Preconditions.checkArgument(offset + byteLength <= memorySegment.size(), "Could not set MemorySegment, the remain buffers is not enough."); this.memorySegment = memorySegment; this.offset = offset; }
/** * Constructs {@link BufferConsumer} instance with static content. */ public BufferConsumer(MemorySegment memorySegment, BufferRecycler recycler, boolean isBuffer) { this(new NetworkBuffer(checkNotNull(memorySegment), checkNotNull(recycler), isBuffer), () -> -memorySegment.size(), 0); checkState(memorySegment.size() > 0); checkState(isFinished(), "BufferConsumer with static size must be finished after construction!"); }
public void setMemorySegment(MemorySegment memorySegment, int offset) { Preconditions.checkArgument(memorySegment != null, "MemorySegment can not be null."); Preconditions.checkArgument(offset >= 0, "Offset should be positive integer."); Preconditions.checkArgument(offset + byteLength <= memorySegment.size(), "Could not set MemorySegment, the remain buffers is not enough."); this.memorySegment = memorySegment; this.offset = offset; }