slingshot: configurable cache sizes #3

open

opened by

nekomimi.pet 3 weeks ago targeting main from nekomimi.pet/microcosm-rs: main

I noticed defaults were hardcoded

./slingshot --jetstream us-east-1 --cache-dir ./foyer \
    --cache-memory-mb 128 \
    --cache-disk-gb 2

options

unified split

Changed files

+16 -3

slingshot

src

firehose_cache.rs

main.rs

+4 -2

slingshot/src/firehose_cache.rs

···

       4
       4
        
       

     

       5
       5
        
       pub async fn firehose_cache(

     

       6
       6
        
           cache_dir: impl AsRef<Path>,

     

       7
       7
       +
           memory_mb: usize,

     

       8
       8
       +
           disk_gb: usize,

     

       7
       9
        
       ) -> Result<HybridCache<String, CachedRecord>, String> {

     

       8
       10
        
           let cache = HybridCacheBuilder::new()

     

       9
       11
        
               .with_name("firehose")

     

       10
       10
       -
               .memory(64 * 2_usize.pow(20))

     

       12
       12
       +
               .memory(memory_mb * 2_usize.pow(20))

     

       11
       13
        
               .with_weighter(|k: &String, v| k.len() + std::mem::size_of_val(v))

     

       12
       14
        
               .storage(Engine::large())

     

       13
       15
        
               .with_device_options(

     

       14
       16
        
                   DirectFsDeviceOptions::new(cache_dir)

     

       15
       15
       -
                       .with_capacity(2_usize.pow(30)) // TODO: configurable (1GB to have something)

     

       17
       17
       +
                       .with_capacity(disk_gb * 2_usize.pow(30))

     

       16
       18
        
                       .with_file_size(16 * 2_usize.pow(20)), // note: this does limit the max cached item size, warning jumbo records

     

       17
       19
        
               )

     

       18
       20
        
               .build()

+12 -1

slingshot/src/main.rs

···

       25
       25
        
           /// where to keep disk caches

     

       26
       26
        
           #[arg(long)]

     

       27
       27
        
           cache_dir: PathBuf,

     

       28
       28
       +
           /// memory cache size in MB

     

       29
       29
       +
           #[arg(long, default_value_t = 64)]

     

       30
       30
       +
           cache_memory_mb: usize,

     

       31
       31
       +
           /// disk cache size in GB

     

       32
       32
       +
           #[arg(long, default_value_t = 1)]

     

       33
       33
       +
           cache_disk_gb: usize,

     

       28
       34
        
           /// the domain pointing to this server

     

       29
       35
        
           ///

     

       30
       36
        
           /// if present:

     
···

       83
       89
        
           log::info!("cache dir ready at at {cache_dir:?}.");

     

       84
       90
        
       

     

       85
       91
        
           log::info!("setting up firehose cache...");

     

       86
       86
       -
           let cache = firehose_cache(cache_dir.join("./firehose")).await?;

     

       92
       92
       +
           let cache = firehose_cache(

     

       93
       93
       +
               cache_dir.join("./firehose"),

     

       94
       94
       +
               args.cache_memory_mb,

     

       95
       95
       +
               args.cache_disk_gb,

     

       96
       96
       +
           )

     

       97
       97
       +
           .await?;

     

       87
       98
        
           log::info!("firehose cache ready.");

     

       88
       99
        
       

     

       89
       100
        
           let mut tasks: tokio::task::JoinSet<Result<(), MainTaskError>> = tokio::task::JoinSet::new();