use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex, Weak};
use crate::image::{Image, WeakImage};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ImageCacheLimits {
pub pixels_mb: u32,
pub files: u32,
pub layers_mb: u32,
}
impl ImageCacheLimits {
pub const DEFAULT: Self = Self { pixels_mb: 96, files: 256, layers_mb: 128 };
pub const PIXELS_MB_RANGE: (u32, u32) = (8, 4096);
pub const FILES_RANGE: (u32, u32) = (16, 65_536);
pub const LAYERS_MB_RANGE: (u32, u32) = (0, 4096);
pub fn clamped(self) -> Self {
Self {
pixels_mb: self.pixels_mb.clamp(Self::PIXELS_MB_RANGE.0, Self::PIXELS_MB_RANGE.1),
files: self.files.clamp(Self::FILES_RANGE.0, Self::FILES_RANGE.1),
layers_mb: self.layers_mb.clamp(Self::LAYERS_MB_RANGE.0, Self::LAYERS_MB_RANGE.1),
}
}
pub fn layers_bytes(self) -> usize {
self.layers_mb as usize * (1 << 20)
}
pub fn pixels_bytes(self) -> usize {
self.pixels_mb as usize * (1 << 20)
}
}
impl Default for ImageCacheLimits {
fn default() -> Self {
Self::DEFAULT
}
}
static PIXELS_MB: AtomicU32 = AtomicU32::new(ImageCacheLimits::DEFAULT.pixels_mb);
static FILES: AtomicU32 = AtomicU32::new(ImageCacheLimits::DEFAULT.files);
static LAYERS_MB: AtomicU32 = AtomicU32::new(ImageCacheLimits::DEFAULT.layers_mb);
static AUTO_LAYERS: AtomicBool = AtomicBool::new(true);
pub fn limits() -> ImageCacheLimits {
ImageCacheLimits { pixels_mb: PIXELS_MB.load(Ordering::Relaxed), files: FILES.load(Ordering::Relaxed), layers_mb: LAYERS_MB.load(Ordering::Relaxed) }
}
pub fn set_limits(limits: ImageCacheLimits) {
let l = limits.clamped();
PIXELS_MB.store(l.pixels_mb, Ordering::Relaxed);
FILES.store(l.files, Ordering::Relaxed);
LAYERS_MB.store(l.layers_mb, Ordering::Relaxed);
}
pub fn auto_layers() -> bool {
AUTO_LAYERS.load(Ordering::Relaxed)
}
pub fn set_auto_layers(on: bool) {
AUTO_LAYERS.store(on, Ordering::Relaxed);
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum LayerCaching {
#[default]
Project,
On,
Off,
}
impl LayerCaching {
pub const ALL: [LayerCaching; 3] = [LayerCaching::Project, LayerCaching::On, LayerCaching::Off];
pub fn enabled(self) -> bool {
match self {
LayerCaching::Project => auto_layers(),
LayerCaching::On => true,
LayerCaching::Off => false,
}
}
}
impl crate::prop::PropEnum for LayerCaching {
const NAMES: &'static [&'static str] = &["project", "on", "off"];
fn from_index(index: usize) -> Option<Self> {
LayerCaching::ALL.get(index).copied()
}
fn index(self) -> usize {
self as usize
}
}
struct Layer<T> {
owner: u64,
value: T,
bytes: usize,
used: u64,
}
pub struct LayerCache<T> {
entries: HashMap<u64, Layer<T>>,
clock: u64,
bytes: usize,
counters: Option<Arc<Counters>>,
}
impl<T> Default for LayerCache<T> {
fn default() -> Self {
Self { entries: HashMap::new(), clock: 0, bytes: 0, counters: None }
}
}
impl<T> LayerCache<T> {
pub fn named(name: &'static str) -> Self {
let counters = Arc::new(Counters { name, images: AtomicUsize::new(0), bytes: AtomicUsize::new(0) });
REGISTRY.lock().unwrap_or_else(|e| e.into_inner()).push(Arc::downgrade(&counters));
Self { counters: Some(counters), ..Self::default() }
}
fn publish(&self) {
if let Some(c) = &self.counters {
c.images.store(self.entries.len(), Ordering::Relaxed);
c.bytes.store(self.bytes, Ordering::Relaxed);
}
}
pub fn accepts(bytes: usize) -> bool {
bytes > 0 && bytes <= limits().layers_bytes()
}
pub fn get(&mut self, key: u64) -> Option<&T> {
self.clock += 1;
let clock = self.clock;
self.entries.get_mut(&key).map(|e| {
e.used = clock;
&e.value
})
}
pub fn insert(&mut self, owner: u64, key: u64, value: T, bytes: usize) {
let max = limits().layers_bytes();
if bytes > max {
return;
}
self.clock += 1;
if let Some(old) = self.entries.insert(key, Layer { owner, value, bytes, used: self.clock }) {
self.bytes -= old.bytes;
}
self.bytes += bytes;
while self.bytes > max {
let Some(oldest) = self.entries.iter().filter(|(k, _)| **k != key).min_by_key(|(_, e)| e.used).map(|(k, _)| *k) else { break };
if let Some(e) = self.entries.remove(&oldest) {
self.bytes -= e.bytes;
}
}
self.publish();
}
pub fn forget(&mut self, owner: u64) {
let mut freed = 0;
self.entries.retain(|_, e| {
let keep = e.owner != owner;
if !keep {
freed += e.bytes;
}
keep
});
if freed > 0 {
self.bytes -= freed;
self.publish();
}
}
pub fn clear(&mut self) {
self.entries.clear();
self.bytes = 0;
self.publish();
}
pub fn len(&self) -> usize {
self.entries.len()
}
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
pub fn bytes(&self) -> usize {
self.bytes
}
}
struct Entry<T> {
image: WeakImage,
value: T,
bytes: usize,
used: u64,
}
struct Counters {
name: &'static str,
images: AtomicUsize,
bytes: AtomicUsize,
}
static REGISTRY: Mutex<Vec<Weak<Counters>>> = Mutex::new(Vec::new());
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct CacheStat {
pub name: &'static str,
pub images: usize,
pub bytes: usize,
}
pub fn stats() -> Vec<CacheStat> {
let mut registry = REGISTRY.lock().unwrap_or_else(|e| e.into_inner());
registry.retain(|w| w.strong_count() > 0);
let mut out: Vec<CacheStat> = Vec::new();
for c in registry.iter().filter_map(Weak::upgrade) {
let (images, bytes) = (c.images.load(Ordering::Relaxed), c.bytes.load(Ordering::Relaxed));
match out.iter_mut().find(|s| s.name == c.name) {
Some(s) => {
s.images += images;
s.bytes += bytes;
}
None => out.push(CacheStat { name: c.name, images, bytes }),
}
}
out
}
pub struct ImageCache<T> {
entries: HashMap<u64, Entry<T>>,
clock: u64,
bytes: usize,
counters: Option<Arc<Counters>>,
}
impl<T> Default for ImageCache<T> {
fn default() -> Self {
Self { entries: HashMap::new(), clock: 0, bytes: 0, counters: None }
}
}
impl<T> ImageCache<T> {
pub fn named(name: &'static str) -> Self {
let counters = Arc::new(Counters { name, images: AtomicUsize::new(0), bytes: AtomicUsize::new(0) });
REGISTRY.lock().unwrap_or_else(|e| e.into_inner()).push(Arc::downgrade(&counters));
Self { counters: Some(counters), ..Self::default() }
}
fn publish(&self) {
if let Some(c) = &self.counters {
c.images.store(self.entries.len(), Ordering::Relaxed);
c.bytes.store(self.bytes, Ordering::Relaxed);
}
}
pub fn get(&mut self, image: &Image) -> Option<&T> {
self.clock += 1;
let clock = self.clock;
self.entries.get_mut(&image.id()).map(|e| {
e.used = clock;
&e.value
})
}
pub fn get_by_id_mut(&mut self, id: u64) -> Option<&mut T> {
self.entries.get_mut(&id).map(|e| &mut e.value)
}
pub fn insert(&mut self, image: &Image, value: T, bytes: usize, max_count: usize, max_bytes: usize) {
self.forget_dropped();
self.clock += 1;
if let Some(old) = self.entries.insert(image.id(), Entry { image: image.downgrade(), value, bytes, used: self.clock }) {
self.bytes -= old.bytes;
}
self.bytes += bytes;
while self.entries.len() > 1 && (self.entries.len() > max_count || self.bytes > max_bytes) {
let Some(oldest) = self.entries.iter().filter(|(id, _)| **id != image.id()).min_by_key(|(_, e)| e.used).map(|(id, _)| *id) else { break };
if let Some(e) = self.entries.remove(&oldest) {
self.bytes -= e.bytes;
}
}
self.publish();
}
pub fn forget_dropped(&mut self) {
let mut freed = 0;
self.entries.retain(|_, e| {
let alive = e.image.is_alive();
if !alive {
freed += e.bytes;
}
alive
});
self.bytes -= freed;
self.publish();
}
pub fn clear(&mut self) {
self.entries.clear();
self.bytes = 0;
self.publish();
}
pub fn len(&self) -> usize {
self.entries.len()
}
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
pub fn bytes(&self) -> usize {
self.bytes
}
}