private static class InMemoryRepository.ByteArrayReadableChannel extends java.lang.Object implements ReadableChannel
Modifier and Type | Field and Description |
---|---|
private int |
blockSize |
private byte[] |
data |
private boolean |
open |
private int |
position |
Constructor and Description |
---|
ByteArrayReadableChannel(byte[] buf,
int blockSize) |
Modifier and Type | Method and Description |
---|---|
int |
blockSize()
Get the recommended alignment for reads.
|
void |
close() |
boolean |
isOpen() |
long |
position()
Get the current position of the channel.
|
void |
position(long newPosition)
Seek the current position of the channel to a new offset.
|
int |
read(java.nio.ByteBuffer dst) |
void |
setReadAheadBytes(int b)
Recommend the channel maintain a read-ahead buffer.
|
long |
size()
Get the total size of the channel.
|
private final byte[] data
private final int blockSize
private int position
private boolean open
public int read(java.nio.ByteBuffer dst)
read
in interface java.nio.channels.ReadableByteChannel
public void close()
close
in interface java.io.Closeable
close
in interface java.lang.AutoCloseable
close
in interface java.nio.channels.Channel
public boolean isOpen()
isOpen
in interface java.nio.channels.Channel
public long position()
ReadableChannel
position
in interface ReadableChannel
public void position(long newPosition)
ReadableChannel
position
in interface ReadableChannel
newPosition
- position to move the channel to. The next read will start from
here. This should be a multiple of the ReadableChannel.blockSize()
.public long size()
ReadableChannel
Prior to reading from a channel the size might not yet be known. Implementors may return -1 until after the first read method call. Once a read has been completed, the underlying file size should be available.
size
in interface ReadableChannel
public int blockSize()
ReadableChannel
Starting a read at multiples of the blockSize is more efficient than starting a read at any other position. If 0 or -1 the channel does not have any specific block size recommendation.
Channels should not recommend large block sizes. Sizes up to 1-4 MiB may
be reasonable, but sizes above that may be horribly inefficient. The
DfsBlockCache
favors the
alignment suggested by the channel rather than the configured size under
the assumption that reads are very expensive and the channel knows what
size is best to access it with.
blockSize
in interface ReadableChannel
public void setReadAheadBytes(int b)
ReadableChannel
A read-ahead buffer of approximately bufferSize
in bytes may be
allocated and used by the channel to smooth out latency for read.
Callers can continue to read in smaller than bufferSize
chunks.
With read-ahead buffering enabled read latency may fluctuate in a pattern
of one slower read followed by (bufferSize / readSize) - 1
fast
reads satisfied by the read-ahead buffer. When summed up overall time to
read the same contiguous range should be lower than if read-ahead was not
enabled, as the implementation can combine reads to increase throughput.
To avoid unnecessary IO callers should only enable read-ahead if the majority of the channel will be accessed in order.
Implementations may chose to read-ahead using asynchronous APIs or background threads, or may simply aggregate reads using a buffer.
This read ahead stays in effect until the channel is closed or the buffer size is set to 0.
setReadAheadBytes
in interface ReadableChannel
b
- requested size of the read ahead buffer, in bytes.