use std::sync::Arc;
use parking_lot::Mutex;
use uqa_core::memory::{BudgetedVec, MemoryBudget, MemoryError, MemoryReservation};
use uqa_core::Value;
use crate::mvcc::native::NativeRecordOwner;
mod builder;
pub(crate) use builder::ColumnBuilder;
pub(crate) const DEFAULT_LIMIT: usize = 64 * 1024 * 1024;
const PARKED_BUILDS: usize = 4;
pub(crate) type CachedColumns = (Arc<Vec<i64>>, Vec<Arc<Vec<Value>>>);
pub(crate) struct DecodedColumns {
budget: MemoryBudget,
entries: Mutex<Vec<Entry>>,
parked: Mutex<Vec<ColumnBuilder>>,
}
struct Entry {
table: String,
owner: NativeRecordOwner,
generation: i64,
ids: Arc<Vec<i64>>,
columns: Vec<(String, Arc<Vec<Value>>)>,
memory: Vec<MemoryReservation>,
}
impl Entry {
fn matches(&self, table: &str, owner: NativeRecordOwner, generation: i64) -> bool {
self.table == table && self.owner == owner && self.generation == generation
}
}
impl DecodedColumns {
pub(crate) fn new(limit: usize) -> Self {
Self {
budget: MemoryBudget::new(limit),
entries: Mutex::new(Vec::new()),
parked: Mutex::new(Vec::new()),
}
}
pub(crate) fn budget(&self) -> &MemoryBudget {
&self.budget
}
pub(crate) fn get(
&self,
table: &str,
owner: NativeRecordOwner,
generation: i64,
fields: &[&str],
) -> Option<CachedColumns> {
let mut entries = self.entries.lock();
let position = entries
.iter()
.position(|entry| entry.matches(table, owner, generation))?;
let entry = entries.remove(position);
let columns = fields
.iter()
.map(|field| {
entry
.columns
.iter()
.find(|(name, _)| name == field)
.map(|(_, values)| Arc::clone(values))
})
.collect::<Option<Vec<_>>>();
let found = columns.map(|columns| (Arc::clone(&entry.ids), columns));
entries.push(entry);
found
}
pub(crate) fn retire_stale(&self, table: &str, owner: NativeRecordOwner, generation: i64) {
self.entries
.lock()
.retain(|entry| entry.table != table || entry.matches(table, owner, generation));
}
pub(crate) fn evict_other(&self, table: &str) -> bool {
{
let mut parked = self.parked.lock();
if let Some(position) = parked.iter().position(|build| build.table != table) {
parked.remove(position);
return true;
}
}
let mut entries = self.entries.lock();
let Some(position) = entries.iter().position(|entry| entry.table != table) else {
return false;
};
entries.remove(position);
true
}
pub(crate) fn resume(
&self,
table: &str,
owner: NativeRecordOwner,
generation: i64,
fields: &[&str],
after: Option<i64>,
) -> Option<ColumnBuilder> {
let mut parked = self.parked.lock();
let position = parked
.iter()
.position(|build| build.continues(table, owner, generation, fields, after))?;
Some(parked.remove(position))
}
pub(crate) fn park(&self, build: ColumnBuilder) {
let mut parked = self.parked.lock();
if parked.len() == PARKED_BUILDS {
parked.remove(0);
}
parked.push(build);
}
pub(crate) fn finish(&self, build: ColumnBuilder) {
let columns = build.fields.into_iter().zip(build.columns).collect();
self.insert(
&build.table,
build.owner,
build.generation,
build.ids,
columns,
build.strings,
);
}
fn insert(
&self,
table: &str,
owner: NativeRecordOwner,
generation: i64,
ids: BudgetedVec<i64>,
columns: Vec<(String, BudgetedVec<Value>)>,
strings: MemoryReservation,
) {
let mut entries = self.entries.lock();
entries.retain(|entry| entry.table != table || entry.matches(table, owner, generation));
let mut memory = vec![strings];
let position = entries
.iter()
.position(|entry| entry.matches(table, owner, generation));
let mut entry = if let Some(position) = position {
entries.remove(position)
} else {
let (ids, reservation) = ids.into_parts();
memory.push(reservation);
Entry {
table: table.to_owned(),
owner,
generation,
ids: Arc::new(ids),
columns: Vec::new(),
memory: Vec::new(),
}
};
for (field, values) in columns {
if entry.columns.iter().any(|(name, _)| *name == field) {
continue;
}
let (values, reservation) = values.into_parts();
memory.push(reservation);
entry.columns.push((field, Arc::new(values)));
}
entry.memory.extend(memory);
entries.push(entry);
}
}
pub(crate) fn scalar_bytes(value: &Value) -> Option<usize> {
match value {
Value::Null | Value::Bool(_) | Value::Int(_) | Value::Float(_) => Some(0),
Value::Str(text) => Some(text.capacity()),
_ => None,
}
}
pub(crate) fn grow(
cache: &DecodedColumns,
table: &str,
memory: &mut MemoryReservation,
bytes: usize,
) -> Result<(), MemoryError> {
loop {
match memory.grow(bytes) {
Ok(()) => return Ok(()),
Err(error) if !cache.evict_other(table) => return Err(error),
Err(_) => {}
}
}
}
#[cfg(test)]
mod tests;