Java BitUtil.align方法代码示例

import org.agrona.BitUtil; //导入方法依赖的package包/类
@SuppressWarnings("SameReturnValue")
private boolean validateFragment1(final UnsafeBuffer buffer, final int offset, final int length)
{
    final DataHeaderFlyweight headerFlyweight = new DataHeaderFlyweight();
    headerFlyweight.wrap(buffer.addressOffset() + offset - HEADER_LENGTH, HEADER_LENGTH);
    if (headerFlyweight.headerType() == HDR_TYPE_PAD)
    {
        return true;
    }

    final int expectedLength = messageLengths[messageCount] - HEADER_LENGTH;
    assertThat("on fragment[" + messageCount + "]", length, is(expectedLength));
    assertThat(buffer.getInt(offset), is(messageCount));
    assertThat(buffer.getByte(offset + 4), is((byte)'z'));

    remaining -= BitUtil.align(messageLengths[messageCount], FrameDescriptor.FRAME_ALIGNMENT);
    messageCount++;

    return true;
}
 

import org.agrona.BitUtil; //导入方法依赖的package包/类
@Test
public void shouldInsertLastFrameIntoBuffer()
{
    final int frameLength = BitUtil.align(256, FRAME_ALIGNMENT);
    final int srcOffset = 0;
    final int tail = TERM_BUFFER_CAPACITY - frameLength;
    final int termOffset = tail;
    final UnsafeBuffer packet = new UnsafeBuffer(ByteBuffer.allocateDirect(frameLength));
    packet.putShort(typeOffset(srcOffset), (short)PADDING_FRAME_TYPE, LITTLE_ENDIAN);
    packet.putInt(srcOffset, frameLength, LITTLE_ENDIAN);

    TermRebuilder.insert(termBuffer, termOffset, packet, frameLength);

    verify(termBuffer).putBytes(
        tail + HEADER_LENGTH, packet, srcOffset + HEADER_LENGTH, frameLength - HEADER_LENGTH);
}
 

import org.agrona.BitUtil; //导入方法依赖的package包/类
@Test
public void shouldFillAfterAGap()
{
    final int frameLength = 50;
    final int alignedFrameLength = BitUtil.align(frameLength, FRAME_ALIGNMENT);
    final int srcOffset = 0;
    final UnsafeBuffer packet = new UnsafeBuffer(ByteBuffer.allocateDirect(alignedFrameLength));
    final int termOffset = alignedFrameLength * 2;

    TermRebuilder.insert(termBuffer, termOffset, packet, alignedFrameLength);

    verify(termBuffer).putBytes(
        (alignedFrameLength * 2) + HEADER_LENGTH,
        packet,
        srcOffset + HEADER_LENGTH,
        alignedFrameLength - HEADER_LENGTH);
}
 

import org.agrona.BitUtil; //导入方法依赖的package包/类
@Test
public void shouldFillGapButNotMoveTailOrHwm()
{
    final int frameLength = 50;
    final int alignedFrameLength = BitUtil.align(frameLength, FRAME_ALIGNMENT);
    final int srcOffset = 0;
    final UnsafeBuffer packet = new UnsafeBuffer(ByteBuffer.allocateDirect(alignedFrameLength));
    final int termOffset = alignedFrameLength * 2;

    TermRebuilder.insert(termBuffer, termOffset, packet, alignedFrameLength);

    verify(termBuffer).putBytes(
        (alignedFrameLength * 2) + HEADER_LENGTH,
        packet,
        srcOffset + HEADER_LENGTH,
        alignedFrameLength - HEADER_LENGTH);
}
 

import org.agrona.BitUtil; //导入方法依赖的package包/类
@Test
public void shouldReadBlockOfThreeMessagesThatFillBuffer()
{
    final int offset = 0;
    final int limit = termBuffer.capacity();
    final int messageLength = 50;
    final int alignedMessageLength = BitUtil.align(messageLength, FRAME_ALIGNMENT);
    final int thirdMessageLength = limit - (alignedMessageLength * 2);

    when(termBuffer.getIntVolatile(lengthOffset(offset))).thenReturn(messageLength);
    when(termBuffer.getIntVolatile(lengthOffset(alignedMessageLength))).thenReturn(messageLength);
    when(termBuffer.getIntVolatile(lengthOffset(alignedMessageLength * 2))).thenReturn(thirdMessageLength);

    final int newOffset = TermBlockScanner.scan(termBuffer, offset, limit);

    assertThat(newOffset, is(limit));
}
 

import org.agrona.BitUtil; //导入方法依赖的package包/类
@Test
public void shouldReadBlockOfTwoMessagesBecauseOfLimit()
{
    final int offset = 0;
    final int messageLength = 50;
    final int alignedMessageLength = BitUtil.align(messageLength, FRAME_ALIGNMENT);
    final int limit = (alignedMessageLength * 2) + 1;

    when(termBuffer.getIntVolatile(lengthOffset(offset))).thenReturn(messageLength);
    when(termBuffer.getIntVolatile(lengthOffset(alignedMessageLength))).thenReturn(messageLength);
    when(termBuffer.getIntVolatile(lengthOffset(alignedMessageLength * 2))).thenReturn(messageLength);

    final int newOffset = TermBlockScanner.scan(termBuffer, offset, limit);

    assertThat(newOffset, is(alignedMessageLength * 2));
}
 

import org.agrona.BitUtil; //导入方法依赖的package包/类
private static boolean verifyLastFile(
    final long recordingId, final int recordingFileCount, final long endSegmentOffset)
{
    final File lastSegmentFile = new File(archiveDir, segmentFileName(recordingId, recordingFileCount - 1));
    try (FileChannel lastFile = FileChannel.open(lastSegmentFile.toPath(), READ))
    {
        TEMP_BUFFER.clear();
        long position = 0L;
        do
        {
            TEMP_BUFFER.clear().limit(DataHeaderFlyweight.HEADER_LENGTH);
            if (lastFile.read(TEMP_BUFFER, position) != DataHeaderFlyweight.HEADER_LENGTH)
            {
                System.err.println("(recordingId=" + recordingId + ") ERR: failed to read fragment header.");
                return true;
            }
            position += BitUtil.align(HEADER_FLYWEIGHT.frameLength(), FrameDescriptor.FRAME_ALIGNMENT);
        }
        while (HEADER_FLYWEIGHT.frameLength() != 0);

        if (position != endSegmentOffset)
        {
            System.err.println("(recordingId=" + recordingId + ") ERR: end segment offset=" +
                position + " (expected=" + endSegmentOffset + ")");
            return true;
        }
    }
    catch (final Exception ex)
    {
        System.err.println("(recordingId=" + recordingId + ") ERR: failed to verify file:" +
            segmentFileName(recordingId, recordingFileCount - 1));
        ex.printStackTrace(System.err);
        return true;
    }

    return false;
}
 

import org.agrona.BitUtil; //导入方法依赖的package包/类
/**
 * Transmit a message to {@link BroadcastReceiver}s via the broadcast buffer.
 *
 * @param msgTypeId type of the message to be transmitted.
 * @param srcBuffer containing the encoded message to be transmitted.
 * @param srcIndex  srcIndex in the source buffer at which the encoded message begins.
 * @param length    in bytes of the encoded message.
 * @throws IllegalArgumentException of the msgTypeId is not valid,
 *                                  or if the message length is greater than {@link #maxMsgLength()}.
 */
public void transmit(final int msgTypeId, final DirectBuffer srcBuffer, final int srcIndex, final int length)
{
    checkTypeId(msgTypeId);
    checkMessageLength(length);

    final AtomicBuffer buffer = this.buffer;
    long currentTail = buffer.getLong(tailCounterIndex);
    int recordOffset = (int)currentTail & (capacity - 1);
    final int recordLength = HEADER_LENGTH + length;
    final int recordLengthAligned = BitUtil.align(recordLength, RECORD_ALIGNMENT);
    final long newTail = currentTail + recordLengthAligned;

    final int toEndOfBuffer = capacity - recordOffset;
    if (toEndOfBuffer < recordLengthAligned)
    {
        signalTailIntent(buffer, newTail + toEndOfBuffer);
        insertPaddingRecord(buffer, recordOffset, toEndOfBuffer);

        currentTail += toEndOfBuffer;
        recordOffset = 0;
    }
    else
    {
        signalTailIntent(buffer, newTail);
    }

    buffer.putInt(lengthOffset(recordOffset), recordLength);
    buffer.putInt(typeOffset(recordOffset), msgTypeId);

    buffer.putBytes(msgOffset(recordOffset), srcBuffer, srcIndex, length);

    buffer.putLong(latestCounterIndex, currentTail);
    buffer.putLongOrdered(tailCounterIndex, currentTail + recordLengthAligned);
}
 

import org.agrona.BitUtil; //导入方法依赖的package包/类
/**
 * Read a {@link LossReport} contained in the buffer. This can be done concurrently.
 *
 * @param buffer        containing the loss report.
 * @param entryConsumer to be called to accept each entry in the report.
 * @return the number of entries read.
 */
public static int read(final AtomicBuffer buffer, final EntryConsumer entryConsumer)
{
    final int capacity = buffer.capacity();

    int recordsRead = 0;
    int offset = 0;

    while (offset < capacity)
    {
        final long observationCount = buffer.getLongVolatile(offset + OBSERVATION_COUNT_OFFSET);
        if (observationCount <= 0)
        {
            break;
        }

        ++recordsRead;

        final String channel = buffer.getStringAscii(offset + CHANNEL_OFFSET);
        final String source = buffer.getStringAscii(offset + CHANNEL_OFFSET + SIZE_OF_INT + channel.length());

        entryConsumer.accept(
            observationCount,
            buffer.getLong(offset + TOTAL_BYTES_LOST_OFFSET),
            buffer.getLong(offset + FIRST_OBSERVATION_OFFSET),
            buffer.getLong(offset + LAST_OBSERVATION_OFFSET),
            buffer.getInt(offset + SESSION_ID_OFFSET),
            buffer.getInt(offset + STREAM_ID_OFFSET),
            channel,
            source);

        final int recordLength = CHANNEL_OFFSET + (SIZE_OF_INT * 2) + channel.length() + source.length();
        offset += BitUtil.align(recordLength, ENTRY_ALIGNMENT);
    }

    return recordsRead;
}
 

import org.agrona.BitUtil; //导入方法依赖的package包/类
@Test
public void shouldRecordTwoDistinctObservations()
{
    final long timestampOne = 7;
    final long timestampTwo = 10;
    final int offset = 0;
    final RuntimeException errorOne = new RuntimeException("Test Error One");
    final IllegalStateException errorTwo = new IllegalStateException("Test Error Two");

    when(clock.time()).thenReturn(timestampOne).thenReturn(timestampTwo);

    assertTrue(log.record(errorOne));
    assertTrue(log.record(errorTwo));

    final ArgumentCaptor<Integer> lengthArg = ArgumentCaptor.forClass(Integer.class);

    final InOrder inOrder = inOrder(buffer);
    inOrder.verify(buffer).putBytes(eq(offset + ENCODED_ERROR_OFFSET), any(byte[].class));
    inOrder.verify(buffer).putLong(offset + FIRST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
    inOrder.verify(buffer).putIntOrdered(eq(offset + LENGTH_OFFSET), lengthArg.capture());
    inOrder.verify(buffer).getAndAddInt(offset + OBSERVATION_COUNT_OFFSET, 1);
    inOrder.verify(buffer).putLongOrdered(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);

    final int recordTwoOffset = BitUtil.align(lengthArg.getValue(), RECORD_ALIGNMENT);

    inOrder.verify(buffer).putBytes(eq(recordTwoOffset + ENCODED_ERROR_OFFSET), any(byte[].class));
    inOrder.verify(buffer).putLong(recordTwoOffset + FIRST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
    inOrder.verify(buffer).putIntOrdered(eq(recordTwoOffset + LENGTH_OFFSET), anyInt());
    inOrder.verify(buffer).getAndAddInt(recordTwoOffset + OBSERVATION_COUNT_OFFSET, 1);
    inOrder.verify(buffer).putLongOrdered(recordTwoOffset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
}
 

import org.agrona.BitUtil; //导入方法依赖的package包/类
@Theory
@Test(timeout = 10000)
public void shouldReceivePublishedMessageViaPollFile(final String channel)
{
    launch(channel);

    publishMessage();

    final MutableLong bytesRead = new MutableLong();
    SystemTestHelper.executeUntil(
        () -> bytesRead.value > 0,
        (i) ->
        {
            final long bytes = subscription.rawPoll(rawBlockHandler, Integer.MAX_VALUE);
            if (0 == bytes)
            {
                Thread.yield();
            }
            bytesRead.value += bytes;
        },
        Integer.MAX_VALUE,
        TimeUnit.MILLISECONDS.toNanos(9900));

    final long expectedOffset = 0L;
    final int expectedLength = BitUtil.align(HEADER_LENGTH + SIZE_OF_INT, FRAME_ALIGNMENT);

    final ArgumentCaptor<FileChannel> channelArgumentCaptor = ArgumentCaptor.forClass(FileChannel.class);
    verify(rawBlockHandler).onBlock(
        channelArgumentCaptor.capture(),
        eq(expectedOffset),
        any(UnsafeBuffer.class),
        eq((int)expectedOffset),
        eq(expectedLength),
        anyInt(),
        anyInt());

    assertTrue("File Channel is closed", channelArgumentCaptor.getValue().isOpen());
}
 

import org.agrona.BitUtil; //导入方法依赖的package包/类
@Test
public void shouldFillSingleGap()
{
    final int frameLength = 50;
    final int alignedFrameLength = BitUtil.align(frameLength, FRAME_ALIGNMENT);
    final int srcOffset = 0;
    final int tail = alignedFrameLength;
    final int termOffset = tail;
    final UnsafeBuffer packet = new UnsafeBuffer(ByteBuffer.allocateDirect(alignedFrameLength));

    TermRebuilder.insert(termBuffer, termOffset, packet, alignedFrameLength);

    verify(termBuffer).putBytes(
        tail + HEADER_LENGTH, packet, srcOffset + HEADER_LENGTH, alignedFrameLength - HEADER_LENGTH);
}
 

import org.agrona.BitUtil; //导入方法依赖的package包/类
@Test
public void shouldReadFirstMessage()
{
    final int offset = 0;
    final int limit = termBuffer.capacity();
    final int messageLength = 50;
    final int alignedMessageLength = BitUtil.align(messageLength, FRAME_ALIGNMENT);

    when(termBuffer.getIntVolatile(lengthOffset(offset))).thenReturn(messageLength);

    final int newOffset = TermBlockScanner.scan(termBuffer, offset, limit);

    assertThat(newOffset, is(alignedMessageLength));
}
 

import org.agrona.BitUtil; //导入方法依赖的package包/类
@Test
public void shouldReadBlockOfTwoMessages()
{
    final int offset = 0;
    final int limit = termBuffer.capacity();
    final int messageLength = 50;
    final int alignedMessageLength = BitUtil.align(messageLength, FRAME_ALIGNMENT);

    when(termBuffer.getIntVolatile(lengthOffset(offset))).thenReturn(messageLength);
    when(termBuffer.getIntVolatile(lengthOffset(alignedMessageLength))).thenReturn(messageLength);

    final int newOffset = TermBlockScanner.scan(termBuffer, offset, limit);

    assertThat(newOffset, is(alignedMessageLength * 2));
}
 

import org.agrona.BitUtil; //导入方法依赖的package包/类
@Test
public void shouldFailToReadFirstMessageBecauseOfLimit()
{
    final int offset = 0;
    final int messageLength = 50;
    final int alignedMessageLength = BitUtil.align(messageLength, FRAME_ALIGNMENT);
    final int limit = alignedMessageLength - 1;

    when(termBuffer.getIntVolatile(lengthOffset(offset))).thenReturn(messageLength);

    final int newOffset = TermBlockScanner.scan(termBuffer, offset, limit);

    assertThat(newOffset, is(offset));
}