alioth/src/mem/addressable.rs - f5bf11a

addressable.rs98.77%

// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
use std::ops::RangeBounds;
 
use crate::mem::{Result, error};
 
pub trait SlotBackend {
    fn size(&self) -> u64;
}
 
#[derive(Debug)]
struct Slot<B>
where
    B: SlotBackend,
{
    addr: u64,
    backend: B,
}
 
impl<B> Slot<B>
where
    B: SlotBackend,
{
    fn new(addr: u64, backend: B) -> Result<Self> {744x
        if backend.size() == 0 {744x
            return error::ZeroSizedSlot.fail();3x
        }741x
        match (backend.size() - 1).checked_add(addr) {741x
            None => error::ExceedsLimit {3x
                addr,3x
                size: backend.size(),3x
            }3x
            .fail(),3x
            Some(_) => Ok(Self { addr, backend }),738x
        }
    }744x
 
    fn max_addr(&self) -> u64 {2661x
        (self.backend.size() - 1) + self.addr2661x
    }2661x
}
 
#[derive(Debug)]
pub struct Addressable<B>
where
    B: SlotBackend,
{
    slots: Vec<Slot<B>>,
}
 
impl<B> Default for Addressable<B>
where
    B: SlotBackend,
{
    fn default() -> Self {307x
        Addressable { slots: Vec::new() }307x
    }307x
}
 
impl<B> Addressable<B>
where
    B: SlotBackend,
{
    pub fn new() -> Self {226x
        Self::default()226x
    }226x
 
    pub fn iter(&self) -> impl DoubleEndedIterator<Item = (u64, &B)> {27x
        self.slots.iter().map(|slot| (slot.addr, &slot.backend))39x
    }27x
 
    pub fn drain(12x
        &mut self,12x
        range: impl RangeBounds<usize>,12x
    ) -> impl DoubleEndedIterator<Item = (u64, B)> + '_ {12x
        self.slots.drain(range).map(|s| (s.addr, s.backend))12x
    }12x
 
    pub fn is_empty(&self) -> bool {92x
        self.slots.is_empty()92x
    }92x
 
    pub fn last(&self) -> Option<(u64, &B)> {3x
        self.slots.last().map(|slot| (slot.addr, &slot.backend))3x
    }3x
}
 
impl<B> Addressable<B>
where
    B: SlotBackend,
{
    pub fn add(&mut self, addr: u64, backend: B) -> Result<&mut B> {735x
        let slot = Slot::new(addr, backend)?;735x
        let result = match self.slots.binary_search_by_key(&addr, |s| s.addr) {735x
            Ok(index) => Err(&self.slots[index]),3x
            Err(index) => {732x
                if index < self.slots.len() && self.slots[index].addr <= slot.max_addr() {732x
                    Err(&self.slots[index])9x
                } else if index > 0 && slot.addr <= self.slots[index - 1].max_addr() {723x
                    Err(&self.slots[index - 1])9x
                } else {
                    Ok(index)714x
                }
            }
        };
        match result {735x
            Err(curr_slot) => error::Overlap {21x
                new_item: [slot.addr, slot.max_addr()],21x
                exist_item: [curr_slot.addr, curr_slot.max_addr()],21x
            }21x
            .fail(),21x
            Ok(index) => {714x
                self.slots.insert(index, slot);714x
                // TODO add some compiler hint to eliminate bound check?
                Ok(&mut self.slots[index].backend)714x
            }
        }
    }735x
 
    pub fn remove(&mut self, addr: u64) -> Result<B> {51x
        match self.slots.binary_search_by_key(&addr, |s| s.addr) {51x
            Ok(index) => Ok(self.slots.remove(index).backend),48x
            Err(_) => error::NotMapped { addr }.fail(),3x
        }
    }51x
 
    pub fn search(&self, addr: u64) -> Option<(u64, &B)> {2586x
        match self.slots.binary_search_by_key(&addr, |s| s.addr) {2586x
            Ok(index) => Some((self.slots[index].addr, &self.slots[index].backend)),651x
            Err(0) => None,3x
            Err(index) => {1932x
                let candidate = &self.slots[index - 1];1932x
                if addr <= candidate.max_addr() {1932x
                    Some((candidate.addr, &candidate.backend))1743x
                } else {
                    None189x
                }
            }
        }
    }2586x
 
    pub fn search_next(&self, addr: u64) -> Option<(u64, &B)> {426x
        match self.slots.binary_search_by_key(&addr, |s| s.addr) {426x
            Ok(index) => Some((self.slots[index].addr, &self.slots[index].backend)),270x
            Err(0) => None,
            Err(index) => {156x
                let candidate = &self.slots[index - 1];156x
                if addr <= candidate.max_addr() {156x
                    Some((candidate.addr, &candidate.backend))57x
                } else {
                    self.slots.get(index).map(|slot| (slot.addr, &slot.backend))99x
                }
            }
        }
    }426x
}
 
#[cfg(test)]
#[path = "addressable_test.rs"]
mod tests;
 