Merge pull request #4892 from remotion-dev/compositor-equal-cache

`@remotion/compositor`: Simplify cache rules - every thread has equal share of cache

Author: JonnyBurger

packages/compositor-darwin-arm64/remotion

@@ -3,7 +3,6 @@ use std::{collections::HashMap, sync::Mutex};
 use ffmpeg_next::Rational;
 
 use crate::{
-    cache_references::FRAME_CACHE_REFERENCES,
     errors::ErrorWithBacktrace,
     frame_cache::{FrameCache, FrameCacheItem, FrameCacheReference},
     global_printer::_print_verbose,
@@ -36,17 +35,56 @@ impl FrameCacheManager {
         self.cache.clear();
     }
 
+    fn get_frames_to_prune(
+        &mut self,
+        maximum_frame_cache_size_in_bytes: u64,
+    ) -> Result<Vec<FrameCacheReference>, ErrorWithBacktrace> {
+        let references = self.get_frame_references()?;
+        let mut sorted = references.clone();
+        sorted.sort_by(|a, b| a.last_used.cmp(&b.last_used));
+
+        let max_cache_size = max_cache_size::get_instance().lock().unwrap();
+
+        let current_cache_size_in_bytes =
+            max_cache_size.get_cache_size_for_thread(self.thread_index);
+
+        let mut to_remove: Vec<FrameCacheReference> = vec![];
+
+        let bytes_to_free = match current_cache_size_in_bytes > maximum_frame_cache_size_in_bytes {
+            true => current_cache_size_in_bytes - maximum_frame_cache_size_in_bytes,
+            false => {
+                return Ok(to_remove);
+            }
+        };
+
+        let mut removed = 0;
+        let mut removed_count = 0;
+
+        for removal in sorted {
+            removed += removal.size;
+            removed_count += 1;
+            to_remove.push(removal.clone());
+            if removed >= bytes_to_free {
+                break;
+            }
+        }
+
+        _print_verbose(&format!(
+            "Need to free {}MB, Selected {} frames ({}MB) for removal",
+            bytes_to_free / 1024 / 1024,
+            removed_count,
+            removed / 1024 / 1024
+        ))?;
+
+        Ok(to_remove)
+    }
+
     pub fn get_to_prune_local(
         &mut self,
         max_cache_size: u64,
     ) -> Result<Vec<FrameCacheReference>, ErrorWithBacktrace> {
-        let to_prune = {
-            FRAME_CACHE_REFERENCES
-                .lock()
-                .unwrap()
-                .get_frames_to_prune(max_cache_size, Some(self.thread_index))?
-        };
-        let of_thread: Vec<FrameCacheReference> = to_prune[self.thread_index].clone();
+        let to_prune = { self.get_frames_to_prune(max_cache_size)? };
+        let of_thread: Vec<FrameCacheReference> = to_prune.clone();
         Ok(of_thread)
     }
 
@@ -265,14 +303,6 @@ impl FrameCacheManager {
         return Ok(total_size);
     }
 
-    pub fn copy_to_global(&mut self) -> Result<(), ErrorWithBacktrace> {
-        FRAME_CACHE_REFERENCES
-            .lock()
-            .unwrap()
-            .set_cache_references(self.thread_index, self.get_frame_references()?);
-        Ok(())
-    }
-
     fn remove_item_by_id(
         &mut self,
         removal: FrameCacheReference,

packages/compositor-darwin-x64/remotion

@@ -7,7 +7,6 @@ use std::{
 };
 
 use crate::{
-    cache_references::FRAME_CACHE_REFERENCES,
     commands::execute_command_and_print,
     errors::ErrorWithBacktrace,
     global_printer::{self, print_error},
@@ -205,26 +204,20 @@ impl LongRunningProcess {
     }
 
     fn prune(&mut self, maximum_frame_cache_size_in_bytes: u64) -> Result<(), ErrorWithBacktrace> {
-        let frames_to_prune = FRAME_CACHE_REFERENCES
-            .lock()
-            .unwrap()
-            .get_frames_to_prune(maximum_frame_cache_size_in_bytes, None)?;
-
-        for thread in frames_to_prune {
-            if thread.is_empty() {
-                continue;
-            }
-            let first_item = thread.get(0).unwrap();
-            self.send_to_thread_handles[first_item.thread_index].send(CliInputAndMaxCacheSize {
+        let threads = self.send_to_thread_handles.len();
+        for i in 0..threads {
+            self.send_to_thread_handles[i].send(CliInputAndMaxCacheSize {
                 cli_input: CliInputCommand {
                     payload: CliInputCommandPayload::DeleteFramesFromCache(DeleteFramesFromCache {
-                        cache_references: thread,
+                        maximum_frame_cache_size_in_bytes: maximum_frame_cache_size_in_bytes
+                            / threads as u64,
                     }),
                     nonce: "".to_string(),
                 },
                 max_cache_size: self.maximum_frame_cache_size_in_bytes,
             })?;
         }
+
         Ok(())
     }
 

packages/compositor-linux-arm64-gnu/remotion

@@ -1,4 +1,3 @@
-mod cache_references;
 mod commands;
 mod errors;
 mod extract_audio;
@@ -55,7 +54,7 @@ fn mainfn() -> Result<(), ErrorWithBacktrace> {
                 .unwrap_or(get_ideal_maximum_frame_cache_size());
 
             _print_verbose(&format!(
-                "Starting Rust process. Max video cache size: {}MB, max concurrency = {}",
+                "Starting Rust process. Max video cache size: {}MB, max threads = {}",
                 max_video_cache_size / 1024 / 1024,
                 payload.concurrency
             ))?;

packages/compositor-linux-arm64-musl/remotion

@@ -34,10 +34,6 @@ impl MaxCacheSize {
             None => 0,
         }
     }
-
-    pub fn thread_count(&self) -> usize {
-        self.thread_cache_sizes.len()
-    }
 }
 
 // Global static instance of MaxCacheSize

packages/compositor-linux-x64-gnu/remotion

@@ -139,7 +139,6 @@ impl OpenedStream {
                         index: frame_cache_id,
                         pts: video.pts().expect("pts"),
                     });
-                    frame_cache_manager.copy_to_global().unwrap();
 
                 }
                 Ok(None) => {
@@ -380,7 +379,6 @@ impl OpenedStream {
                                 thread_index
                             );
 
-                        frame_cache_manager.copy_to_global().unwrap();
 
                         items_in_loop += 1;
 

packages/compositor-linux-x64-musl/remotion

@@ -4,7 +4,7 @@ extern crate serde;
 extern crate serde_json;
 
 pub mod payloads {
-    use crate::{errors::ErrorWithBacktrace, frame_cache::FrameCacheReference};
+    use crate::errors::ErrorWithBacktrace;
     use serde::{Deserialize, Serialize};
 
     #[derive(Serialize, Deserialize, Debug)]
@@ -245,7 +245,7 @@ pub mod payloads {
 
     #[derive(Clone, Serialize, Deserialize, Debug)]
     pub struct DeleteFramesFromCache {
-        pub cache_references: Vec<FrameCacheReference>,
+        pub maximum_frame_cache_size_in_bytes: u64,
     }
 
     #[derive(Serialize, Deserialize, Debug, Clone)]

packages/compositor-win32-x64-msvc/remotion.exe

@@ -96,7 +96,7 @@ impl WorkerThread {
         cache_references: DeleteFramesFromCache,
     ) -> Result<(), ErrorWithBacktrace> {
         self.frame_cache_manager
-            .execute_prune(cache_references.cache_references, self.thread_index)?;
+            .prune_on_thread(cache_references.maximum_frame_cache_size_in_bytes)?;
         self.opened_video_manager
             .close_videos_if_cache_empty(&mut self.frame_cache_manager)
     }