From 15ec07bb96145d771c7044d016b0a8e7666aca96 Mon Sep 17 00:00:00 2001 From: Max Murphy Date: Thu, 1 Feb 2024 15:57:12 +0100 Subject: [PATCH 1/3] Implement into_inner for memory manager --- src/memory_manager.rs | 14 ++++++++++++++ src/tests.rs | 9 +++++++++ 2 files changed, 23 insertions(+) diff --git a/src/memory_manager.rs b/src/memory_manager.rs index 567d3559..7f0b8a1a 100644 --- a/src/memory_manager.rs +++ b/src/memory_manager.rs @@ -155,6 +155,15 @@ impl MemoryManager { memory_manager: self.inner.clone(), } } + + /// Returns the underlying memory. + /// + /// # Returns + /// - The underlying memory, if there is exactly one strong reference to the memory manager. Please see [`Rc::try_unwrap`](https://doc.rust-lang.org/std/rc/struct.Rc.html#method.try_unwrap) for more details. + /// - None otherwise. + pub fn into_inner(self) -> Option { + Rc::into_inner(self.inner).map(|inner| inner.into_inner().into_inner()) + } } #[repr(C, packed)] @@ -419,6 +428,11 @@ impl MemoryManagerInner { // Ceiling division. (num_pages + self.bucket_size_in_pages as u64 - 1) / self.bucket_size_in_pages as u64 } + + // Returns the underlying memory. + pub fn into_inner(self) -> M { + self.memory + } } struct Segment { diff --git a/src/tests.rs b/src/tests.rs index 6bd1caee..315b82ea 100644 --- a/src/tests.rs +++ b/src/tests.rs @@ -1,4 +1,5 @@ use super::*; +use crate::memory_manager::MemoryManager; use std::cell::RefCell; use std::rc::Rc; @@ -48,3 +49,11 @@ fn vec_exposes_init_err() { #[allow(unused_imports)] use crate::vec::InitError; } + +#[test] +fn should_be_able_to_recover_memory_from_memory_manager() { + let raw_memory = DefaultMemoryImpl::default(); + let memory_manager = MemoryManager::init(raw_memory); + let recovered_memory = memory_manager.into_inner(); + assert!(recovered_memory.is_some()); +} From 6ecf5ece5511958aa90eff23af68b654ba9d31f7 Mon Sep 17 00:00:00 2001 From: Max Murphy Date: Thu, 1 Feb 2024 16:15:58 +0100 Subject: [PATCH 2/3] Rename to into_memory --- src/memory_manager.rs | 6 +++--- src/tests.rs | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/memory_manager.rs b/src/memory_manager.rs index 7f0b8a1a..a84075be 100644 --- a/src/memory_manager.rs +++ b/src/memory_manager.rs @@ -161,8 +161,8 @@ impl MemoryManager { /// # Returns /// - The underlying memory, if there is exactly one strong reference to the memory manager. Please see [`Rc::try_unwrap`](https://doc.rust-lang.org/std/rc/struct.Rc.html#method.try_unwrap) for more details. /// - None otherwise. - pub fn into_inner(self) -> Option { - Rc::into_inner(self.inner).map(|inner| inner.into_inner().into_inner()) + pub fn into_memory(self) -> Option { + Rc::into_inner(self.inner).map(|inner| inner.into_inner().into_memory()) } } @@ -430,7 +430,7 @@ impl MemoryManagerInner { } // Returns the underlying memory. - pub fn into_inner(self) -> M { + pub fn into_memory(self) -> M { self.memory } } diff --git a/src/tests.rs b/src/tests.rs index 315b82ea..ac9407f2 100644 --- a/src/tests.rs +++ b/src/tests.rs @@ -54,6 +54,6 @@ fn vec_exposes_init_err() { fn should_be_able_to_recover_memory_from_memory_manager() { let raw_memory = DefaultMemoryImpl::default(); let memory_manager = MemoryManager::init(raw_memory); - let recovered_memory = memory_manager.into_inner(); + let recovered_memory = memory_manager.into_memory(); assert!(recovered_memory.is_some()); } From 265020dead947d0381866882bf936909a07c63ea Mon Sep 17 00:00:00 2001 From: Max Murphy Date: Tue, 20 Feb 2024 12:03:46 +0100 Subject: [PATCH 3/3] Test that the raw memory is not returned if it is in use. --- src/tests.rs | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/src/tests.rs b/src/tests.rs index ac9407f2..3d138d68 100644 --- a/src/tests.rs +++ b/src/tests.rs @@ -1,5 +1,5 @@ use super::*; -use crate::memory_manager::MemoryManager; +use crate::memory_manager::{MemoryId, MemoryManager}; use std::cell::RefCell; use std::rc::Rc; @@ -57,3 +57,12 @@ fn should_be_able_to_recover_memory_from_memory_manager() { let recovered_memory = memory_manager.into_memory(); assert!(recovered_memory.is_some()); } + +#[test] +fn should_fail_to_recover_memory_from_memory_manager_if_memory_is_in_use() { + let raw_memory = DefaultMemoryImpl::default(); + let memory_manager = MemoryManager::init(raw_memory); + let _a_virtual_memory = memory_manager.get(MemoryId::new(0)); + let recovered_memory = memory_manager.into_memory(); + assert!(recovered_memory.is_none()); +}