use std::borrow::Cow;
use crate::core::index::{BytesRef, BytesRefBuilder};
use crate::core::util::access::SharedAccessVec;
use crate::core::util::accountable::Accountable;
use crate::core::util::allocator_byte::{AllocatorByte, AllocatorByteEnum, DirectAllocatorByte};
use crate::core::util::array_util::ArrayUtil;
use crate::core::util::error::lucene_error::{LuceneError, Result};
use crate::core::util::ram_usage_estimator::{size_of_array_capacity, size_of_vec};
use crate::core::util::{SliceCopyOps, TryIntoInt};
#[derive(Debug)]
pub struct ByteBlockPool {
buffers: smallvec::SmallVec<[Vec<u8>; 1]>,
pub(crate) buffer_upto: Option<usize>,
allocator: AllocatorByteEnum,
pub(crate) byte_offset: i32,
pub(crate) byte_upto: i32,
}
impl Default for ByteBlockPool {
fn default() -> Self {
let allocator = DirectAllocatorByte::new();
Self::new(allocator)
}
}
impl ByteBlockPool {
pub fn new<T>(allocator: T) -> Self
where
T: Into<AllocatorByteEnum>,
{
let allocator = allocator.into();
ByteBlockPool {
buffers: smallvec::SmallVec::new(),
buffer_upto: None,
allocator,
byte_offset: -BYTE_BLOCK_SIZE,
byte_upto: BYTE_BLOCK_SIZE,
}
}
pub fn reset(&mut self, zero_fill_buffers: bool, reuse_first: bool) {
if let Some(buffer_upto) = self.buffer_upto {
if zero_fill_buffers {
for i in 0..(buffer_upto + 1) {
self.buffers[i].fill(0);
}
}
if buffer_upto > 0 || !reuse_first {
let offset = if reuse_first { 1 } else { 0 };
self
.allocator
.recycle_byte_blocks(&mut self.buffers, offset, buffer_upto + 1);
for _i in offset..(buffer_upto + 1) {
self.buffers.pop();
}
}
if reuse_first {
self.buffer_upto = Some(0);
self.byte_upto = 0;
self.byte_offset = 0;
} else {
self.buffer_upto = None;
self.byte_upto = BYTE_BLOCK_SIZE;
self.byte_offset = -BYTE_BLOCK_SIZE;
}
}
}
pub fn next_buffer(&mut self) -> Result<usize> {
let next_upto = match self.buffer_upto {
Some(upto) => upto + 1,
None => 0,
};
if next_upto == self.buffers.len() {
let block = self.allocator.get_byte_block();
if self.buffers.len() == 1 && !self.buffers.spilled() {
self.buffers.reserve_exact(3);
}
self.buffers.push(block);
}
self.buffer_upto = Some(next_upto);
self.byte_upto = 0;
match self.byte_offset.checked_add(BYTE_BLOCK_SIZE) {
Some(val) => self.byte_offset = val,
None => {
return Err(LuceneError::number_overflow(
"Overflow when calculating byte offset.",
));
},
}
Ok(next_upto)
}
pub fn set_bytes_ref<'a>(
&'a self,
builder: &mut BytesRefBuilder<Vec<u8>>,
result: &mut BytesRef<Cow<'a, Vec<u8>>>,
offset: i64,
length: usize,
) -> Result<()> {
if result.bytes.len() < length {
ArrayUtil::oversize(length, size_of::<u8>())?;
}
let pos = (offset & BYTE_BLOCK_MASK as i64) as usize;
if pos + length > BYTE_BLOCK_SIZE as usize {
if matches!(result.bytes, Cow::Borrowed(_)) {
result.bytes = Cow::Owned(std::mem::take(&mut builder.get_bytes_mut_ref().bytes));
}
ArrayUtil::grow_no_copy(result.bytes.to_mut(), length, || 0)?;
}
result.length = length;
let buffer_index: i32 = (offset >> BYTE_BLOCK_SHIFT).try_convert()?;
if pos + length <= BYTE_BLOCK_SIZE as usize {
let block = &self.buffers[buffer_index as usize];
let _ = &block[pos..pos + length];
let previous = std::mem::replace(&mut result.bytes, Cow::Borrowed(block));
if let Cow::Owned(bytes) = previous {
builder.get_bytes_mut_ref().bytes = bytes;
}
result.offset = pos;
} else {
let bytes = result.bytes.to_mut();
result.offset = 0;
self.read_bytes(offset, bytes, 0, length)?;
}
Ok(())
}
pub fn append_bytes_ref<AV>(&mut self, bytes: &BytesRef<AV>) -> Result<()>
where
AV: SharedAccessVec<u8>,
{
bytes
.bytes
.access(|bytes_ref| self.append_range(bytes_ref, bytes.offset, bytes.length))
}
pub fn append_from_byte_block_pool(
&mut self,
src_pool: &ByteBlockPool,
mut src_offset: i64,
length: usize,
) -> Result<()> {
let mut bytes_left = length;
while bytes_left > 0 {
let buffer_left = (BYTE_BLOCK_SIZE - self.byte_upto) as usize;
if bytes_left < buffer_left {
let source_pos = (src_offset & BYTE_BLOCK_MASK as i64) as usize;
let target_pos = self.byte_upto as usize;
if bytes_left <= BYTE_BLOCK_SIZE as usize - source_pos
&& let Some(buffer_upto) = self.buffer_upto
&& let Ok(source_index) = i32::try_from(src_offset >> BYTE_BLOCK_SHIFT)
&& let Some(source) = src_pool.buffers.get(source_index as usize)
&& let Some(source) = source.get(source_pos..source_pos + bytes_left)
&& let Some(target) = self.buffers.get_mut(buffer_upto)
&& let Some(target) = target.get_mut(target_pos..target_pos + bytes_left)
{
target.copy_from_slice(source);
self.byte_upto += bytes_left as i32;
} else {
self.append_bytes_single_buffer(src_pool, src_offset, bytes_left)?;
}
break;
} else {
if buffer_left > 0 {
self.append_bytes_single_buffer(src_pool, src_offset, buffer_left)?;
bytes_left -= buffer_left;
src_offset += buffer_left as i64;
}
self.next_buffer()?;
}
}
Ok(())
}
fn append_bytes_single_buffer(
&mut self,
src_pool: &ByteBlockPool,
mut src_offset: i64,
mut length: usize,
) -> Result<()> {
debug_assert!(length <= (BYTE_BLOCK_SIZE - self.byte_upto) as usize);
debug_assert!(self.buffer_upto.is_some());
let buffer_upto = self
.buffer_upto
.ok_or_else(|| LuceneError::number_format("buffer not initialized"))?;
while length > 0 {
let src_buffer_index: i32 = (src_offset >> BYTE_BLOCK_SHIFT).try_convert()?;
let src_pos = (src_offset & BYTE_BLOCK_MASK as i64) as usize;
let bytes_to_copy = std::cmp::min(BYTE_BLOCK_SIZE as usize - src_pos, length);
self.buffers[buffer_upto].copy_from(
&src_pool.buffers[src_buffer_index as usize][src_pos..src_pos + bytes_to_copy],
self.byte_upto as usize,
);
length -= bytes_to_copy;
src_offset += bytes_to_copy as i64;
self.byte_upto += bytes_to_copy as i32;
}
Ok(())
}
pub fn append(&mut self, bytes: &[u8]) -> Result<()> {
let length = bytes.len();
self.append_range(bytes, 0, length)
}
pub fn append_range(&mut self, bytes: &[u8], mut offset: usize, length: usize) -> Result<()> {
let mut bytes_left = length;
let mut buffer_upto = self.buffer_upto.unwrap_or_default();
while bytes_left > 0 {
let buffer_left = (BYTE_BLOCK_SIZE - self.byte_upto) as usize;
if bytes_left < buffer_left {
self.buffers[buffer_upto]
.copy_from(&bytes[offset..offset + bytes_left], self.byte_upto as usize);
self.byte_upto += bytes_left as i32;
break;
} else {
if buffer_left > 0 {
self.buffers[buffer_upto].copy_from(
&bytes[offset..offset + buffer_left],
self.byte_upto as usize,
);
}
buffer_upto = self.next_buffer()?;
bytes_left -= buffer_left;
offset += buffer_left;
}
}
Ok(())
}
pub fn read_bytes(
&self,
offset: i64,
bytes: &mut [u8],
mut bytes_offset: usize,
bytes_length: usize,
) -> Result<()> {
let mut bytes_left = bytes_length;
let buffer_index: i32 = (offset >> BYTE_BLOCK_SHIFT).try_convert()?;
let mut buffer_index = buffer_index as usize;
let mut pos = (offset & BYTE_BLOCK_MASK as i64) as usize;
while bytes_left > 0 {
let chunk = std::cmp::min(BYTE_BLOCK_SIZE as usize - pos, bytes_left);
bytes.copy_from(&self.buffers[buffer_index][pos..pos + chunk], bytes_offset);
bytes_offset += chunk;
bytes_left -= chunk;
buffer_index += 1;
pos = 0;
}
Ok(())
}
pub fn read_byte(&self, offset: usize) -> u8 {
let buffer_index = offset >> BYTE_BLOCK_SHIFT;
let pos = offset & BYTE_BLOCK_MASK as usize;
self.buffers[buffer_index][pos]
}
pub fn get_position(&mut self) -> i64 {
debug_assert!(self.allocator.get_block_size() <= i32::MAX as usize);
let buffer_upto = match self.buffer_upto {
Some(upto) => upto as i32,
None => -1,
};
(buffer_upto * self.allocator.get_block_size() as i32 + self.byte_upto) as i64
}
#[inline]
pub fn get_buffer_mut(&mut self, buffer_index: usize) -> &mut Vec<u8> {
&mut self.buffers[buffer_index]
}
pub fn get_buffer(&self, buffer_index: usize) -> &Vec<u8> {
&self.buffers[buffer_index]
}
pub(crate) fn get_buffer_or_empty(&self, buffer_index: usize) -> &[u8] {
self.buffers.get(buffer_index).map_or(&[], Vec::as_slice)
}
pub fn get_bytes_used(&self) -> i64 {
self.allocator.get_used()
}
#[inline]
pub fn buffer_upto(&self) -> Result<usize> {
match self.buffer_upto {
Some(upto) => Ok(upto),
None => Err(LuceneError::illegal_state(
"buffer_upto not initialized yet, call next_buffer first.",
)),
}
}
}
impl Accountable for ByteBlockPool {
fn ram_bytes_used(&self) -> Result<i64> {
let mut bytes = if self.buffers.spilled() {
size_of_array_capacity::<Vec<u8>>(self.buffers.capacity())
} else {
0
};
for buffer in &self.buffers {
bytes = bytes.saturating_add(size_of_vec(buffer));
}
Ok(bytes)
}
}
pub const BYTE_BLOCK_SHIFT: i32 = 15;
pub const BYTE_BLOCK_SIZE: i32 = 1 << BYTE_BLOCK_SHIFT;
pub(crate) const BYTE_BLOCK_MASK: i32 = BYTE_BLOCK_SIZE - 1;