chriskyndrid
commented
2 years ago Here is test code that should allow you to reproduce what I assume is a memory leak somewhere:
pub type AsyncResult<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
use std::error::Error;
use std::fmt;
use actix_web::{App, HttpResponse, HttpServer, Scope, web};
use bincode::config::Configuration;
use moka::future::Cache;
use serde::de::DeserializeOwned;
use serde::Serialize;
use uuid::Uuid;
#[macro_use]
extern crate actix_web;
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate serde;
lazy_static! {
static ref MOKA_CACHE: Cache<Uuid, Vec<u8>> = Cache::builder()
.weigher(|_key, value: &Vec<u8>| -> u32 {
value.len().try_into().unwrap_or(u32::MAX)
})
.max_capacity(
256
* 1024
* 1024
)
.build();
}
#[derive(Debug)]
struct MyError(String);
impl fmt::Display for MyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl Error for MyError {}
pub fn api_config_v1(cfg: &mut web::ServiceConfig) {
cfg.service(web::scope("/v1").service(api_config_v1_members()));
}
pub fn api_config_v1_members() -> Scope {
web::scope("/test").service(
web::scope("/moka")
.service(leak)
)
}
#[actix_web::main]
async fn main() -> AsyncResult<()> {
let app = HttpServer::new(move || {
App::new()
.configure(api_config_v1)
}).bind("127.0.0.1:8080")?;
app.run().await?;
Ok(())
}
#[get("/leak")]
pub async fn leak() -> HttpResponse {
let cache_item = TestStruct {
name: "Some name".to_owned()
};
let id = Uuid::new_v4();
set_data::<TestStruct>(&id, &cache_item).await;
get_data::<TestStruct>(&id).await;
let response = TestResponse {
complete: true
};
HttpResponse::Ok()
.content_type("application/json")
.body(serde_json::to_string(&response).unwrap())
}
#[derive(Eq, PartialEq, Clone, Debug, Serialize, Deserialize)]
pub struct TestStruct {
name: String,
}
#[derive(Serialize)]
pub struct TestResponse {
complete: bool,
}
pub async fn set_data<T>(key: &Uuid, cache_data: &T) -> AsyncResult<bool>
where
T: Send + Sync + Serialize,
{
let config = Configuration::standard();
let cache = MOKA_CACHE.clone();
let encoded = bincode::serde::encode_to_vec(&cache_data, config)?;
cache.insert(key.clone(), encoded).await;
Ok(true)
}
pub async fn get_data<T>(key: &Uuid) -> AsyncResult<T>
where
T: Send + Sync + DeserializeOwned,
{
let config = Configuration::standard();
let cache = MOKA_CACHE.clone();
let cache_item = match cache.get(key) {
None => {
return Err(Box::new(MyError("Cache item not found".into())));
}
Some(item) => {
item
}
};
let (decoded, _len): (T, usize) =
bincode::serde::decode_from_slice(&cache_item[..], config)?;
Ok(decoded)
}and cargo.toml
[package]
name = "moka_memory_leak_example"
version = "0.1.0"
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
actix-web = {version = "4.0.0-beta.20", features=["rustls"]}
[dependencies.moka]
version = "0.7.1"
features = ["future"]
[dependencies.lazy_static]
version = "1.4.0"
[dependencies.bincode]
features = ["serde"]
git = "https://github.com/bincode-org/bincode"
[dependencies.serde]
version = "1"
features = ["derive", "serde_derive"]
[dependencies.serde_json]
version = "1"
[dependencies.uuid]
version = "0.8"
features = ["serde", "v4", "v5"]
[dependencies.tokio]
version = "1.15.0"
features = ["full"]and for generating the work, you can use wrk
wrk -d 100 -t 8 -c 100 http://localhost:8080/v1/test/moka/leak
On my machine this results in 2.53GB memory utilization.
tatsuya6502
Thank you for the excellent work on this interesting project. I've implemented Moka in a project I'm working on to utilize as a memory based cache. I'm passing a struct to bincode, encoding it, and storing it the cache, then running the reverse as needed. The system is a web services that utilizes Actix. In practice things are working fine.
However, when I ran a load generating program
wrkagainst a sample call, the memory utilization of the cache increases considerably and does not appear to respect themax_capacity()setting. It does not decrease after load generation completes and subsequentwrktests continue to increase the memory footprint likely indefinitely.As an example:
1: At the start of the load generation:
Top Indicates around 15M of memory utilization:
6488 erp_service_acco 0.0 00:01.19 29 0 50 15M2: Executing a
wrkrequest yieldsTop now indicates around 449M of memory utilization
6488 erp_service_acco 0.0 01:19.42 45 0 66 449M3 Executing a longer
wrkrequest againTop now indicates around 933M of memory utilization
6488 erp_service_acco 0.0 15:53.12 46 0 67 933MMemory utilization continues to grow into the GB+ range. Based on the max_capacity setting above and the documentation in the readme, I would expect the footprint to be around 256MiB + Actix.
In order to remove Actix as a potential component here, I ran these same tests without any calls against my code that interacts with Moka. Actix does not grow beyond a 21MB footprint.
Data is being inserted into the cache like so:
and retrieved like so:
I also repeated the tests without the interaction with
bincode.Is there something I'm misunderstanding on how to restrict the memory utilization of Moka via the
max_capacity()(or another setting) configuration?Any thoughts on this would be greatly appreciated.