use std::fmt;
use std::mem::size_of;
use std::sync::Arc;
use super::{Charge, ChargeError, Meter, heap_cost};
use crate::budget::BudgetExceeded;
use crate::error::LimitKind;
pub(crate) fn reserve_exact<T>(
vec: &mut Vec<T>,
additional: usize,
charged: u64,
meter: &Meter,
) -> Result<(), BudgetExceeded> {
let got = {
let _mark = crate::counters::Fallible::enter();
vec.try_reserve_exact(additional)
};
got.map_err(|_| {
crate::counters::allocator(meter.reservation());
super::refusal(charged, meter.reservation())
})
}
pub(crate) fn shrink_charged<T>(vec: &mut Vec<T>, charge: &mut Charge) -> Result<(), ChargeError> {
let (len, cap) = (bytes_of::<T>(vec.len()), bytes_of::<T>(vec.capacity()));
if len >= cap {
return Ok(());
}
let (old, exact) = (heap_cost(cap), heap_cost(len));
if super::shrink_moves(len, cap) {
let smaller = charge.meter().charge(exact)?;
let mut moved = Vec::new();
let got = {
let _mark = crate::counters::Fallible::enter();
moved.try_reserve_exact(vec.len())
};
if got.is_err() {
let what = charge.meter().reservation();
crate::counters::allocator(what);
return Err(ChargeError::Budget(super::refusal(exact, what)));
}
moved.append(vec);
*vec = moved;
charge.release(old);
charge.absorb(smaller);
} else {
vec.shrink_to_fit();
charge.release(old - exact);
}
Ok(())
}
fn bytes_of<T>(n: usize) -> u64 {
u64::try_from(n)
.unwrap_or(u64::MAX)
.saturating_mul(u64::try_from(size_of::<T>()).unwrap_or(u64::MAX))
}
pub(crate) fn grow_charged<T>(
vec: &mut Vec<T>,
charge: &mut Charge,
need: usize,
max: usize,
) -> Result<(), ChargeError> {
grow_counted(vec, charge, need, max, 0)
}
pub(crate) fn grow_counted<T>(
vec: &mut Vec<T>,
charge: &mut Charge,
need: usize,
max: usize,
work: u64,
) -> Result<(), ChargeError> {
let _growth = crate::counters::Growing::enter();
let have = vec.capacity();
if need <= have {
if work > 0 {
charge.meter().count_decode(work)?;
}
return Ok(());
}
let mut target = have.saturating_mul(2).min(max).max(need);
loop {
match grow_exact(vec, charge, target, work) {
Ok(()) => return Ok(()),
Err(ChargeError::Limit(l)) if l.kind() == LimitKind::DecodeWork => {
return Err(ChargeError::Limit(l));
}
Err(_) if target > need => target = need + (target - need) / 2,
Err(e) => return Err(e),
}
}
}
fn grow_exact<T>(
vec: &mut Vec<T>,
charge: &mut Charge,
cap: usize,
work: u64,
) -> Result<(), ChargeError> {
let old = heap_cost(bytes_of::<T>(vec.capacity()));
let new = heap_cost(bytes_of::<T>(cap));
let mut extra = charge.meter().charge(new)?;
if work > 0 {
charge.meter().count_decode(work)?;
}
let additional = cap.saturating_sub(vec.len());
if let Err(e) = reserve_exact(vec, additional, new, charge.meter()) {
if work > 0 {
charge.meter().uncount_decode(work);
}
return Err(ChargeError::Budget(e));
}
let got = heap_cost(bytes_of::<T>(vec.capacity()));
if got > new && extra.grow(got - new).is_err() {
vec.shrink_to(cap);
}
charge.release(old);
charge.absorb(extra);
Ok(())
}
pub struct MeteredVec<T> {
vec: Vec<T>,
charge: Charge,
}
const _: () = crate::send_sync::<MeteredVec<u8>>();
impl<T: fmt::Debug> fmt::Debug for MeteredVec<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("MeteredVec")
.field("vec", &self.vec)
.field("charge", &self.charge)
.finish()
}
}
impl<T> MeteredVec<T> {
pub fn new(meter: &Arc<Meter>) -> Self {
Self {
vec: Vec::new(),
charge: Charge::zero(meter),
}
}
pub fn with_capacity(meter: &Arc<Meter>, n: usize) -> Result<Self, ChargeError> {
let mut v = Self::new(meter);
v.reserve_exact(n)?;
Ok(v)
}
pub fn from_vec(vec: Vec<T>, meter: &Arc<Meter>) -> Result<Self, ChargeError> {
let charge = meter.charge(heap_cost(bytes_of::<T>(vec.capacity())))?;
Ok(Self { vec, charge })
}
pub fn pop(&mut self) -> Option<T> {
self.vec.pop()
}
pub fn from_charged_parts(vec: Vec<T>, mut charge: Charge) -> Result<Self, ChargeError> {
let cost = heap_cost(bytes_of::<T>(vec.capacity()));
if cost > charge.bytes() {
charge.grow(cost - charge.bytes())?;
}
Ok(Self { vec, charge })
}
#[must_use]
pub fn as_slice(&self) -> &[T] {
&self.vec
}
pub fn as_mut_slice(&mut self) -> &mut [T] {
&mut self.vec
}
#[must_use]
pub fn len(&self) -> usize {
self.vec.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.vec.is_empty()
}
#[must_use]
pub fn capacity(&self) -> usize {
self.vec.capacity()
}
#[must_use]
pub fn charge(&self) -> &Charge {
&self.charge
}
pub fn reserve(&mut self, additional: usize) -> Result<(), ChargeError> {
let need = self.vec.len().saturating_add(additional);
grow_charged(&mut self.vec, &mut self.charge, need, usize::MAX)
}
pub(crate) fn reserve_within(
&mut self,
additional: usize,
most: usize,
) -> Result<(), ChargeError> {
let need = self.vec.len().saturating_add(additional);
grow_charged(&mut self.vec, &mut self.charge, need, most.max(need))
}
pub fn reserve_exact(&mut self, additional: usize) -> Result<(), ChargeError> {
let need = self.vec.len().saturating_add(additional);
grow_charged(&mut self.vec, &mut self.charge, need, need)
}
pub fn push(&mut self, value: T) -> Result<(), ChargeError> {
self.reserve(1)?;
self.vec.push(value);
Ok(())
}
pub(crate) fn push_charged(&mut self, value: T, charge: Charge) -> Result<(), ChargeError> {
self.reserve(1)?;
self.vec.push(value);
self.charge.absorb(charge);
Ok(())
}
pub(crate) fn keep_charge(&mut self, charge: Charge) {
self.charge.absorb(charge);
}
pub fn truncate(&mut self, len: usize) {
self.vec.truncate(len);
}
pub fn into_parts(self) -> (Vec<T>, Charge) {
(self.vec, self.charge)
}
pub fn shrink_to_fit(&mut self) -> Result<(), ChargeError> {
shrink_charged(&mut self.vec, &mut self.charge)
}
pub fn into_boxed_slice(mut self) -> Result<(Box<[T]>, Charge), ChargeError> {
self.shrink_to_fit()?;
Ok((self.vec.into_boxed_slice(), self.charge))
}
}
impl<T: Clone> MeteredVec<T> {
pub fn extend_from_slice(&mut self, items: &[T]) -> Result<(), ChargeError> {
self.reserve(items.len())?;
self.vec.extend_from_slice(items);
Ok(())
}
}