##// END OF EJS Templates
rust-index: find_gca_candidates bit sets genericization...
rust-index: find_gca_candidates bit sets genericization This allows to use arbitratry size of inputs in `find_gca_candidates()`. We're genericizing so that the common case of up to 63 inputs can be treated with the efficient implementation backed by `u64`. Some complications with the borrow checker came, because arbitrary sized bit sets will not be `Copy`, hence mutating them keeps a mut ref on the `seen` vector. This is solved by some cloning, most of which can be avoided, preferably in a follow-up after proof that this works (hence after exposition to Python layer). As far as performance is concerned, calling `clone()` on a `Copy` object (good case when number of revs is less than 64) should end up just doing a copy, according to this excerpt of the `Clone` trait documentation: Types that are Copy should have a trivial implementation of Clone. More formally: if T: Copy, x: T, and y: &T, then let x = y.clone(); is equivalent to let x = *y;. Manual implementations should be careful to uphold this invariant; however, unsafe code must not rely on it to ensure memory safety. We kept the general structure, hence why there are some double negations. This also could be made nicer in a follow-up. The `NonStaticPoisonableBitSet` is included to ensure that the `PoisonableBitSet` trait is general enough (had to correct `vec_of_empty()` for instance). Moving the genericization one level to encompass the `seen` vector and not its elements would be better for performance, if worth it.
Georges Racinet on incendie.racinet.fr -
r52117:43241f31 default
Show More
Name Size Modified Last Commit Author
/ rust / hgcli
.cargo
src
Cargo.lock Loading ...
Cargo.toml Loading ...
README.md Loading ...
build.rs Loading ...
pyoxidizer.bzl Loading ...

Oxidized Mercurial

This project provides a Rust implementation of the Mercurial (hg)
version control tool.

Under the hood, the project uses
PyOxidizer to embed a Python
interpreter in a binary built with Rust. At run-time, the Rust fn main()
is called and Rust code handles initial process startup. An in-process
Python interpreter is started (if needed) to provide additional
functionality.

Building

First, acquire and build a copy of PyOxidizer; you probably want to do this in
some directory outside of your clone of Mercurial:

$ git clone https://github.com/indygreg/PyOxidizer.git
$ cd PyOxidizer
$ cargo build --release

Then build this Rust project using the built pyoxidizer executable:

$ /path/to/pyoxidizer/target/release/pyoxidizer build --release

If all goes according to plan, there should be an assembled application
under build/<arch>/release/app/ with an hg executable:

$ build/x86_64-unknown-linux-gnu/release/app/hg version
Mercurial Distributed SCM (version 5.3.1+433-f99cd77d53dc+20200331)
(see https://mercurial-scm.org for more information)

Copyright (C) 2005-2020 Olivia Mackall and others
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Running Tests

To run tests with a built hg executable, you can use the --with-hg
argument to run-tests.py. But there's a wrinkle: many tests run custom
Python scripts that need to import modules provided by Mercurial. Since
these modules are embedded in the produced hg executable, a regular
Python interpreter can't access them! To work around this, set PYTHONPATH
to the Mercurial source directory. e.g.:

$ cd /path/to/hg/src/tests
$ PYTHONPATH=`pwd`/.. python3.9 run-tests.py \
    --with-hg `pwd`/../rust/hgcli/build/x86_64-unknown-linux-gnu/release/app/hg