comparison rust/hg-core/src/revlog/revlog.rs @ 46090:9eb07ab3f2d4

rhg: use persistent nodemap when available

… for node ID → revision number lookups, instead on linear scan in a revlog.

Differential Revision: https://phab.mercurial-scm.org/D9520

46089:8ff2d8359d0f

use micro_timer::timed;
use zstd;

use super::index::Index;
use super::node::{NodePrefixRef, NODE_BYTES_LENGTH, NULL_NODE};
use super::patch;
use crate::revlog::Revision;

pub enum RevlogError {
    IoError(std::io::Error),

    AmbiguousPrefix,
    Corrupted,
    UnknowDataFormat(u8),
}

fn mmap_open(path: &Path) -> Result<Mmap, std::io::Error> {
    let file = File::open(path)?;
    let mmap = unsafe { MmapOptions::new().map(&file) }?;
    Ok(mmap)
}

    /// When index and data are interleaved: bytes of the revlog index and
    /// data.
    index: Index,
    /// When index and data are not interleaved: bytes of the revlog data
    data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>>,
}

impl Revlog {
    /// Open a revlog index file.
    ///

                let data_mmap =
                    mmap_open(data_path).map_err(RevlogError::IoError)?;
                Some(Box::new(data_mmap))
            };

        Ok(Revlog { index, data_bytes })
    }

    /// Return number of entries of the `Revlog`.
    pub fn len(&self) -> usize {
        self.index.len()

    #[timed]
    pub fn get_node_rev(
        &self,
        node: NodePrefixRef,
    ) -> Result<Revision, RevlogError> {
        // This is brute force. But it is fast enough for now.
        // Optimization will come later.
        let mut found_by_prefix = None;
        for rev in (0..self.len() as Revision).rev() {
            let index_entry =
                self.index.get_entry(rev).ok_or(RevlogError::Corrupted)?;
            if node == *index_entry.hash() {

46090:9eb07ab3f2d4

use micro_timer::timed;
use zstd;

use super::index::Index;
use super::node::{NodePrefixRef, NODE_BYTES_LENGTH, NULL_NODE};
use super::nodemap;
use super::nodemap::NodeMap;
use super::nodemap_docket::NodeMapDocket;
use super::patch;
use crate::revlog::Revision;

pub enum RevlogError {
    IoError(std::io::Error),

    AmbiguousPrefix,
    Corrupted,
    UnknowDataFormat(u8),
}

pub(super) fn mmap_open(path: &Path) -> Result<Mmap, std::io::Error> {
    let file = File::open(path)?;
    let mmap = unsafe { MmapOptions::new().map(&file) }?;
    Ok(mmap)
}

    /// When index and data are interleaved: bytes of the revlog index and
    /// data.
    index: Index,
    /// When index and data are not interleaved: bytes of the revlog data
    data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>>,
    /// When present on disk: the persistent nodemap for this revlog
    nodemap: Option<nodemap::NodeTree>,
}

impl Revlog {
    /// Open a revlog index file.
    ///

                let data_mmap =
                    mmap_open(data_path).map_err(RevlogError::IoError)?;
                Some(Box::new(data_mmap))
            };

        let nodemap = NodeMapDocket::read_from_file(index_path)?.map(
            |(docket, data)| {
                nodemap::NodeTree::load_bytes(
                    Box::new(data),
                    docket.data_length,
                )
            },
        );

        Ok(Revlog {
            index,
            data_bytes,
            nodemap,
        })
    }

    /// Return number of entries of the `Revlog`.
    pub fn len(&self) -> usize {
        self.index.len()

    #[timed]
    pub fn get_node_rev(
        &self,
        node: NodePrefixRef,
    ) -> Result<Revision, RevlogError> {
        if let Some(nodemap) = &self.nodemap {
            return nodemap
                .find_bin(&self.index, node)
                // TODO: propagate details of this error:
                .map_err(|_| RevlogError::Corrupted)?
                .ok_or(RevlogError::InvalidRevision);
        }

        // Fallback to linear scan when a persistent nodemap is not present.
        // This happens when the persistent-nodemap experimental feature is not
        // enabled, or for small revlogs.
        //
        // TODO: consider building a non-persistent nodemap in memory to
        // optimize these cases.
        let mut found_by_prefix = None;
        for rev in (0..self.len() as Revision).rev() {
            let index_entry =
                self.index.get_entry(rev).ok_or(RevlogError::Corrupted)?;
            if node == *index_entry.hash() {