This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8152

revlog: using two new functions in C capsule from Rust code
ClosedPublic

Authored by Alphare on Feb 26 2020, 12:36 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG166349510398: revlog: using two new functions in C capsule from Rust code
Summary

We expose index_length and index_node in the C capsule, so that
the Rust representation of the C index can implement the RevlogIndex
trait.

Because our Node is actually a one-field struct, we have
to decorate it for direct FFI exchange with the C char*

It would be a good thing to get a length from the C layer, but doing
so right now would probably interfere with the upcoming changes that
will happen there for the hash length.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

Alphare created this revision.Feb 26 2020, 12:36 PM
Alphare updated this revision to Diff 20651.Mar 10 2020, 6:51 AM
marmoute added a subscriber: marmoute.Mar 10 2020, 9:34 PM
marmoute updated this revision to Diff 20678.

rebase above latest default up to landed-D8182

gracinet added a commit: rHG166349510398: revlog: using two new functions in C capsule from Rust code.Mar 11 2020, 11:41 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG166349510398: revlog: using two new functions in C capsule from Rust code (authored by gracinet). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 20690

mercurial/cext/revlog.c

typedef struct indexObjectStruct indexObject; typedef struct indexObjectStruct indexObject;
typedef struct { typedef struct {
int children[16]; int children[16];
} nodetreenode; } nodetreenode;
typedef struct { typedef struct {
int abi_version; int abi_version;
Py_ssize_t (*index_length)(const indexObject *);
const char *(*index_node)(indexObject *, Py_ssize_t);
int (*index_parents)(PyObject *, int, int *); int (*index_parents)(PyObject *, int, int *);
} Revlog_CAPI; } Revlog_CAPI;
/* /*
* A base-16 trie for fast node->rev mapping. * A base-16 trie for fast node->rev mapping.
* *
* Positive value is index of the next node in the trie * Positive value is index of the next node in the trie
* Negative value is a leaf: -(rev + 2) * Negative value is a leaf: -(rev + 2)
Py_XDECREF(cache); Py_XDECREF(cache);
Py_XDECREF(tuple); Py_XDECREF(tuple);
return NULL; return NULL;
} }
static Revlog_CAPI CAPI = { static Revlog_CAPI CAPI = {
/* increment the abi_version field upon each change in the Revlog_CAPI /* increment the abi_version field upon each change in the Revlog_CAPI
struct or in the ABI of the listed functions */ struct or in the ABI of the listed functions */
1, 2,
index_length,
index_node,
HgRevlogIndex_GetParents, HgRevlogIndex_GetParents,
}; };
void revlog_module_init(PyObject *mod) void revlog_module_init(PyObject *mod)
{ {
PyObject *caps = NULL; PyObject *caps = NULL;
HgRevlogIndex_Type.tp_new = PyType_GenericNew; HgRevlogIndex_Type.tp_new = PyType_GenericNew;
if (PyType_Ready(&HgRevlogIndex_Type) < 0) if (PyType_Ready(&HgRevlogIndex_Type) < 0)

rust/hg-core/src/revlog/node.rs

/// if they need a loop boundary. /// if they need a loop boundary.
/// ///
/// All methods that create a `Node` either take a type that enforces /// All methods that create a `Node` either take a type that enforces
/// the size or fail immediately at runtime with [`ExactLengthRequired`]. /// the size or fail immediately at runtime with [`ExactLengthRequired`].
/// ///
/// [`nybbles_len`]: #method.nybbles_len /// [`nybbles_len`]: #method.nybbles_len
/// [`ExactLengthRequired`]: struct.NodeError#variant.ExactLengthRequired /// [`ExactLengthRequired`]: struct.NodeError#variant.ExactLengthRequired
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
#[repr(transparent)]
pub struct Node { pub struct Node {
data: NodeData, data: NodeData,
} }
/// The node value for NULL_REVISION /// The node value for NULL_REVISION
pub const NULL_NODE: Node = Node { pub const NULL_NODE: Node = Node {
data: [0; NODE_BYTES_LENGTH], data: [0; NODE_BYTES_LENGTH],
}; };

rust/hg-cpython/src/cindex.rs

// cindex.rs // cindex.rs
// //
// Copyright 2018 Georges Racinet <gracinet@anybox.fr> // Copyright 2018 Georges Racinet <gracinet@anybox.fr>
// //
// 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.
//! Bindings to use the Index defined by the parsers C extension //! Bindings to use the Index defined by the parsers C extension
//! //!
//! Ideally, we should use an Index entirely implemented in Rust, //! Ideally, we should use an Index entirely implemented in Rust,
//! but this will take some time to get there. //! but this will take some time to get there.
use cpython::{exc::ImportError, PyClone, PyErr, PyObject, PyResult, Python}; use cpython::{exc::ImportError, PyClone, PyErr, PyObject, PyResult, Python};
use hg::revlog::{Node, RevlogIndex};
use hg::{Graph, GraphError, Revision, WORKING_DIRECTORY_REVISION}; use hg::{Graph, GraphError, Revision, WORKING_DIRECTORY_REVISION};
use libc::c_int; use libc::c_int;
const REVLOG_CABI_VERSION: c_int = 1; const REVLOG_CABI_VERSION: c_int = 2;
#[repr(C)] #[repr(C)]
pub struct Revlog_CAPI { pub struct Revlog_CAPI {
abi_version: c_int, abi_version: c_int,
index_length:
unsafe extern "C" fn(index: *mut revlog_capi::RawPyObject) -> c_int,
index_node: unsafe extern "C" fn(
index: *mut revlog_capi::RawPyObject,
rev: c_int,
) -> *const Node,
index_parents: unsafe extern "C" fn( index_parents: unsafe extern "C" fn(
index: *mut revlog_capi::RawPyObject, index: *mut revlog_capi::RawPyObject,
rev: c_int, rev: c_int,
ps: *mut [c_int; 2], ps: *mut [c_int; 2],
) -> c_int, ) -> c_int,
} }
py_capsule!( py_capsule!(
) )
}; };
match code { match code {
0 => Ok(res), 0 => Ok(res),
_ => Err(GraphError::ParentOutOfRange(rev)), _ => Err(GraphError::ParentOutOfRange(rev)),
} }
} }
} }
impl RevlogIndex for Index {
/// Note C return type is Py_ssize_t (hence signed), but we shall
/// force it to unsigned, because it's a length
fn len(&self) -> usize {
unsafe { (self.capi.index_length)(self.index.as_ptr()) as usize }
}
fn node<'a>(&'a self, rev: Revision) -> Option<&'a Node> {
let raw = unsafe {
(self.capi.index_node)(self.index.as_ptr(), rev as c_int)
};
if raw.is_null() {
None
} else {
// TODO it would be much better for the C layer to give us
// a length, since the hash length will change in the near
// future, but that's probably out of scope for the nodemap
// patch series.
//
// The root of that unsafety relies in the signature of
// `capi.index_node()` itself: returning a `Node` pointer
// whereas it's a `char *` in the C counterpart.
Some(unsafe { &*raw })
}
}
}