This is an archive of the discontinued Mercurial Phabricator instance.

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	20335		Feb 26 2020, 12:36 PM	★	★
Diff 2	20379		Feb 28 2020, 1:53 PM	★	★
Diff 3	20659		Mar 10 2020, 6:52 AM	★	★
Diff 4	20698	rHG15febf99a9c637eb15b55cc6036631629be3af6c	Feb 12 2020, 4:53 AM	★	★

Commit	Parents	Author	Summary	Date
36e9a4dc677b	745224291176	Georges Racinet		Feb 12 2020, 4:53 AM

Status	Author	Revision
Closed	marmoute	D8193 nodemap: automatically "vacuum" the persistent nodemap when too sparse
Closed	marmoute	D8192 nodemap: display percentage of unused in `hg debugnodemap`
Closed	marmoute	D8191 nodemap: make sure on disk change get rolled back with the transaction
Closed	marmoute	D8190 nodemap: test that concurrent process don't see the pending transaction
Closed	marmoute	D8316 testlib: adjust wait-on-file timeout according to the global test timeout
Closed	marmoute	D8189 testlib: add a small scrip to help process to synchronise using file
Closed	marmoute	D8188 nodemap: make sure the nodemap docket is updated after the changelog
Closed	marmoute	D8187 nodemap: make sure hooks have access to an up-to-date version
Closed	marmoute	D8186 nodemap: deal with the "debugupdatecache" case using a "fake" transaction
Closed	marmoute	D8185 changelog: change the implementation of `_divertopenener`
Closed	marmoute	D8184 nodemap: track the tip_node for validation
Closed	marmoute	D8183 nodemap: test that an outdated nodemap can catch up
Closed	marmoute	D8182 nodemap: document the docket attributes
Closed	marmoute	D8181 nodemap: add a todo list for getting out of experimental
Closed	Alphare	D8164 rust-nodemap: automatically use the rust index for persistent nodemap
Closed	marmoute	D8180 nodemap: check that a simple lookup works fine
Closed	Alphare	D8163 nodemap: use data from the index in debugnodemap --dump-new
Closed	Alphare	D8162 hghave: add a `rust` keyword to detect the use of compiled rust code
Closed	Alphare	D8161 rust-nodemap: also clear Rust data in `clearcaches`
Closed	Alphare	D8160 rust-nodemap: add binding to `nodemap_update_data`
Closed	Alphare	D8159 rust-nodemap: add binding for `nodemap_data_incremental`
Closed	Alphare	D8158 rust-nodemap: add binding for `nodemap_data_all`
Closed	Alphare	D8157 rust-nodemap: use proper Index API instead of using the C API
Closed	Alphare	D8156 rust-nodemap: add utils for propagating errors
Closed	Alphare	D8155 rust-nodemap: add utils to create `Node`s from Python objects
Closed	Alphare	D8154 rust-index: add `append` method to cindex/Index
Closed	Alphare	D8153 rust-index: moved constructor in separate impl block
Closed	Alphare	D8152 revlog: using two new functions in C capsule from Rust code
Closed	marmoute	D8174 nodemap: refresh the persistent data on nodemap creation
Closed	marmoute	D8173 nodemap: warm the persistent nodemap on disk with debugupdatecache

Diff 20659

rust/hg-cpython/src/revlog.rs

	// revlog.rs			// revlog.rs
	//			//
	// Copyright 2019-2020 Georges Racinet <georges.racinet@octobus.net>			// Copyright 2019-2020 Georges Racinet <georges.racinet@octobus.net>
	//			//
	// This software may be used and distributed according to the terms of the			// This software may be used and distributed according to the terms of the
	// GNU General Public License version 2 or any later version.			// GNU General Public License version 2 or any later version.

	use crate::{			use crate::{
	cindex,			cindex,
	utils::{node_from_py_bytes, node_from_py_object},			utils::{node_from_py_bytes, node_from_py_object},
	};			};
	use cpython::{			use cpython::{
				buffer::{Element, PyBuffer},
	exc::{IndexError, ValueError},			exc::{IndexError, ValueError},
	ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyModule, PyObject,			ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyModule, PyObject,
	PyResult, PyString, PyTuple, Python, PythonObject, ToPyObject,			PyResult, PyString, PyTuple, Python, PythonObject, ToPyObject,
	};			};
	use hg::{			use hg::{
	nodemap::{Block, NodeMapError, NodeTree},			nodemap::{Block, NodeMapError, NodeTree},
	revlog::{nodemap::NodeMap, RevlogIndex},			revlog::{nodemap::NodeMap, RevlogIndex},
	NodeError, Revision,			NodeError, Revision,
	Err(_) => cindex::Index::new(py, index),			Err(_) => cindex::Index::new(py, index),
	}			}
	}			}

	py_class!(pub class MixedIndex \|py\| {			py_class!(pub class MixedIndex \|py\| {
	data cindex: RefCell<cindex::Index>;			data cindex: RefCell<cindex::Index>;
	data nt: RefCell<Option<NodeTree>>;			data nt: RefCell<Option<NodeTree>>;
	data docket: RefCell<Option<PyObject>>;			data docket: RefCell<Option<PyObject>>;
				// Holds a reference to the mmap'ed persistent nodemap data
				data mmap: RefCell<Option<PyBuffer>>;

	def __new__(_cls, cindex: PyObject) -> PyResult<MixedIndex> {			def __new__(_cls, cindex: PyObject) -> PyResult<MixedIndex> {
	Self::new(py, cindex)			Self::new(py, cindex)
	}			}

	/// Compatibility layer used for Python consumers needing access to the C index			/// Compatibility layer used for Python consumers needing access to the C index
	///			///
	/// Only use case so far is `scmutil.shortesthexnodeidprefix`,			/// Only use case so far is `scmutil.shortesthexnodeidprefix`,

	def nodemap_data_all(&self) -> PyResult<PyBytes> {			def nodemap_data_all(&self) -> PyResult<PyBytes> {
	self.inner_nodemap_data_all(py)			self.inner_nodemap_data_all(py)
	}			}

	def nodemap_data_incremental(&self) -> PyResult<PyObject> {			def nodemap_data_incremental(&self) -> PyResult<PyObject> {
	self.inner_nodemap_data_incremental(py)			self.inner_nodemap_data_incremental(py)
	}			}
				def update_nodemap_data(
				&self,
				docket: PyObject,
				nm_data: PyObject
				) -> PyResult<PyObject> {
				self.inner_update_nodemap_data(py, docket, nm_data)
				}


	});			});

	impl MixedIndex {			impl MixedIndex {
	fn new(py: Python, cindex: PyObject) -> PyResult<MixedIndex> {			fn new(py: Python, cindex: PyObject) -> PyResult<MixedIndex> {
	Self::create_instance(			Self::create_instance(
	py,			py,
	RefCell::new(cindex::Index::new(py, cindex)?),			RefCell::new(cindex::Index::new(py, cindex)?),
	RefCell::new(None),			RefCell::new(None),
	RefCell::new(None),			RefCell::new(None),
				RefCell::new(None),
	)			)
	}			}

	/// This is scaffolding at this point, but it could also become			/// This is scaffolding at this point, but it could also become
	/// a way to start a persistent nodemap or perform a			/// a way to start a persistent nodemap or perform a
	/// vacuum / repack operation			/// vacuum / repack operation
	fn fill_nodemap(			fn fill_nodemap(
	&self,			&self,
	let masked_blocks = node_tree.masked_readonly_blocks();			let masked_blocks = node_tree.masked_readonly_blocks();
	let (_, data) = node_tree.into_readonly_and_added_bytes();			let (_, data) = node_tree.into_readonly_and_added_bytes();
	let changed = masked_blocks * std::mem::size_of::<Block>();			let changed = masked_blocks * std::mem::size_of::<Block>();

	Ok((docket, changed, PyBytes::new(py, &data))			Ok((docket, changed, PyBytes::new(py, &data))
	.to_py_object(py)			.to_py_object(py)
	.into_object())			.into_object())
	}			}

				/// Update the nodemap from the new (mmaped) data.
				/// The docket is kept as a reference for later incremental calls.
				fn inner_update_nodemap_data(
				&self,
				py: Python,
				docket: PyObject,
				nm_data: PyObject,
				) -> PyResult<PyObject> {
				let buf = PyBuffer::get(py, &nm_data)?;
				let len = buf.item_count();

				// Build a slice from the mmap'ed buffer data
				let cbuf = buf.buf_ptr();
				let bytes = if std::mem::size_of::<u8>() == buf.item_size()
				&& buf.is_c_contiguous()
				&& u8::is_compatible_format(buf.format())
				{
				unsafe { std::slice::from_raw_parts(cbuf as *const u8, len) }
				} else {
				return Err(PyErr::new::<ValueError, _>(
				py,
				"Nodemap data buffer has an invalid memory representation"
				.to_string(),
				));
				};

				// Keep a reference to the mmap'ed buffer, otherwise we get a dangling
				// pointer.
				self.mmap(py).borrow_mut().replace(buf);

				let mut nt = NodeTree::load_bytes(Box::new(bytes), len);

				let data_tip =
				docket.getattr(py, "tip_rev")?.extract::<Revision>(py)?;
				self.docket(py).borrow_mut().replace(docket.clone_ref(py));
				let idx = self.cindex(py).borrow();
				let current_tip = idx.len();

				for r in (data_tip + 1)..current_tip as Revision {
				let rev = r as Revision;
				// in this case node() won't ever return None
				nt.insert(&*idx, idx.node(rev).unwrap(), rev)
				.map_err(\|e\| nodemap_error(py, e))?
				}

				*self.nt(py).borrow_mut() = Some(nt);

				Ok(py.None())
				}
	}			}

	fn revlog_error(py: Python) -> PyErr {			fn revlog_error(py: Python) -> PyErr {
	match py			match py
	.import("mercurial.error")			.import("mercurial.error")
	.and_then(\|m\| m.get(py, "RevlogError"))			.and_then(\|m\| m.get(py, "RevlogError"))
	{			{
	Err(e) => e,			Err(e) => e,

This is an archive of the discontinued Mercurial Phabricator instance.

rust-nodemap: add binding to `nodemap_update_data`ClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 20659

rust/hg-cpython/src/revlog.rs

rust-nodemap: add binding to `nodemap_update_data`
ClosedPublic

Revision Contents
Changeset List