replace available() w/ used() API

Signed-off-by: ylzh10 <[email protected]>

Author: ylzh10

CHANGELOG.md

@@ -4,8 +4,8 @@
 
 ### Added
 
-- Added `available()` API in `AddressAllocator` to allow
-  getting the available memories after `allocate/free()`s
+- Added `used()` API in `AddressAllocator` to allow
+  getting the used memories after `allocate/free()`s
 
 ### Changed
 ### Fixed

src/address_allocator.rs

@@ -29,11 +29,8 @@ pub struct AddressAllocator {
     // tree will represent a memory location and can have two states either
     // `NodeState::Free` or `NodeState::Allocated`.
     interval_tree: IntervalTree,
-    // Available free memory space in the address space.
-    // NOTE that due to fragmentations, |available| may not give the actual
-    // available (contiguous) memory block that can be allocated in next
-    // allocate() call.
-    available: usize,
+    // Used memory space in the address space.
+    used: usize,
 }
 
 impl AddressAllocator {
@@ -48,7 +45,7 @@ impl AddressAllocator {
         Ok(AddressAllocator {
             address_space: aux_range,
             interval_tree: IntervalTree::new(aux_range),
-            available: aux_range.len() as usize,
+            used: 0,
         })
     }
 
@@ -70,24 +67,24 @@ impl AddressAllocator {
     ) -> Result<RangeInclusive> {
         let constraint = Constraint::new(size, alignment, policy)?;
         let allocated = self.interval_tree.allocate(constraint)?;
-        self.available -= allocated.len() as usize;
+        self.used += allocated.len() as usize;
         Ok(allocated)
     }
 
     /// Deletes the specified memory slot or returns `ResourceNotAvailable` if
     /// the node was not allocated before.
     pub fn free(&mut self, key: &RangeInclusive) -> Result<()> {
         self.interval_tree.free(key)?;
-        self.available += key.len() as usize;
+        self.used -= key.len() as usize;
         Ok(())
     }
 
-    /// Returns the available memory size in this allocator.
+    /// Returns the used memory size in this allocator.
     /// NOTE that due to fragmentations, it's not guaranteed that the next
-    /// allocate() call after querying the available memory can succeed with
-    /// allocating those available memories and it may still return OOM.
-    pub fn available(&self) -> usize {
-        self.available
+    /// allocate() call after querying the used memory can succeed with
+    /// allocating all unused memories and it may still return OOM.
+    pub fn used(&self) -> usize {
+        self.used
     }
 }
 
@@ -176,27 +173,27 @@ mod tests {
     #[test]
     fn test_allocate_with_alignment_first_ok() {
         let mut pool = AddressAllocator::new(0x1000, 0x1000).unwrap();
-        assert_eq!(pool.available(), 0x1000);
+        assert_eq!(pool.used(), 0);
         // Allocate 0x110
         assert_eq!(
             pool.allocate(0x110, 0x100, AllocPolicy::FirstMatch)
                 .unwrap(),
             RangeInclusive::new(0x1000, 0x110F).unwrap()
         );
-        assert_eq!(pool.available(), 0x1000 - 0x110);
+        assert_eq!(pool.used(), 0x110);
         // Allocate 0x100
         assert_eq!(
             pool.allocate(0x100, 0x100, AllocPolicy::FirstMatch)
                 .unwrap(),
             RangeInclusive::new(0x1200, 0x12FF).unwrap()
         );
-        assert_eq!(pool.available(), 0x1000 - 0x110 - 0x100);
+        assert_eq!(pool.used(), 0x110 + 0x100);
         // Allocate 0x10
         assert_eq!(
             pool.allocate(0x10, 0x100, AllocPolicy::FirstMatch).unwrap(),
             RangeInclusive::new(0x1300, 0x130F).unwrap()
         );
-        assert_eq!(pool.available(), 0x1000 - 0x110 - 0x100 - 0x10);
+        assert_eq!(pool.used(), 0x110 + 0x100 + 0x10);
     }
 
     #[test]
@@ -255,24 +252,24 @@ mod tests {
     #[test]
     fn test_tree_allocate_address_free_and_realloc() {
         let mut pool = AddressAllocator::new(0x1000, 0x1000).unwrap();
-        assert_eq!(pool.available(), 0x1000);
+        assert_eq!(pool.used(), 0);
         // Allocate 0x800
         assert_eq!(
             pool.allocate(0x800, 0x100, AllocPolicy::FirstMatch)
                 .unwrap(),
             RangeInclusive::new(0x1000, 0x17FF).unwrap()
         );
-        assert_eq!(pool.available(), 0x1000 - 0x800);
+        assert_eq!(pool.used(), 0x800);
         // Free 0x800
         let _ = pool.free(&RangeInclusive::new(0x1000, 0x17FF).unwrap());
-        assert_eq!(pool.available(), 0x1000);
+        assert_eq!(pool.used(), 0);
         // Allocate 0x800 again
         assert_eq!(
             pool.allocate(0x800, 0x100, AllocPolicy::FirstMatch)
                 .unwrap(),
             RangeInclusive::new(0x1000, 0x17FF).unwrap()
         );
-        assert_eq!(pool.available(), 0x1000 - 0x800);
+        assert_eq!(pool.used(), 0x800);
     }
 
     #[test]