This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7721

rust-discovery: postponing random generator init
Needs RevisionPublic

Authored by gracinet on Dec 24 2019, 8:50 AM.

Details

Reviewers
Alphare
baymax
Group Reviewers
hg-reviewers
Summary

This is an example of the benefits we get with the
typestape pattern: we can cleanly postpone the
seeding and initialisation of the random generator.

This makes the default() method a bit cheaper. Its point
is that its output is a placeholder not meand to be really used,
but if that happened, it would now be with the knowledge that
the seed hasn't been initialized (and possible seeding after
morphing into a discovery with undecided set)

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

gracinet created this revision.Dec 24 2019, 8:50 AM
Alphare accepted this revision.Jan 3 2020, 4:56 AM
baymax requested changes to this revision.Apr 22 2020, 11:52 AM

There seems to have been no activities on this Diff for the past 3 Months.

By policy, we are automatically moving it out of the need-review state.

Please, move it back to need-review without hesitation if this diff should still be discussed.

:baymax:need-review-idle:

This revision now requires changes to proceed.Apr 22 2020, 11:52 AM

Revision Contents
Changeset List

PathPackages
Mrust/hg-core/src/discovery.rs (41 lines)

Diff 18929

rust/hg-core/src/discovery.rs

} }
pub struct OnlyCommon<G: Graph + Clone> { pub struct OnlyCommon<G: Graph + Clone> {
target_heads: Vec<Revision>, target_heads: Vec<Revision>,
graph: G, // plays the role of self._repo graph: G, // plays the role of self._repo
common: MissingAncestors<G>, common: MissingAncestors<G>,
respect_size: bool, respect_size: bool,
randomize: bool, randomize: bool,
seed: Seed, seed: Option<Seed>,
} }
pub struct WithUndecided<G: Graph + Clone> { pub struct WithUndecided<G: Graph + Clone> {
graph: G, // plays the role of self._repo graph: G, // plays the role of self._repo
common: MissingAncestors<G>, common: MissingAncestors<G>,
undecided: HashSet<Revision>, undecided: HashSet<Revision>,
children_cache: FastHashMap<Revision, Vec<Revision>>, children_cache: FastHashMap<Revision, Vec<Revision>>,
missing: HashSet<Revision>, missing: HashSet<Revision>,
/// If `false`, a reproductible picking strategy is performed. This is /// If `false`, a reproductible picking strategy is performed. This is
/// useful for integration tests. /// useful for integration tests.
pub fn new( pub fn new(
graph: G, graph: G,
target_heads: Vec<Revision>, target_heads: Vec<Revision>,
respect_size: bool, respect_size: bool,
randomize: bool, randomize: bool,
) -> Self { ) -> Self {
let mut seed = [0; 16]; Com(OnlyCommon::new(
if randomize { graph,
thread_rng().fill_bytes(&mut seed); target_heads,
} None,
Self::new_with_seed(graph, target_heads, seed, respect_size, randomize) respect_size,
randomize,
))
} }
pub fn new_with_seed( pub fn new_with_seed(
graph: G, graph: G,
target_heads: Vec<Revision>, target_heads: Vec<Revision>,
seed: Seed, seed: Seed,
respect_size: bool, respect_size: bool,
randomize: bool, randomize: bool,
) -> Self { ) -> Self {
Com(OnlyCommon::new( Com(OnlyCommon::new(
graph, graph,
target_heads, target_heads,
seed, Some(seed),
respect_size, respect_size,
randomize, randomize,
)) ))
} }
fn get_common(&self) -> &MissingAncestors<G> { fn get_common(&self) -> &MissingAncestors<G> {
match self { match self {
Com(c) => &c.common, Com(c) => &c.common,
/// undecided set. /// undecided set.
/// ///
/// The more common revisions are known, the less the computation of /// The more common revisions are known, the less the computation of
/// the undecided set is expensive. Therefore, we delay it as much /// the undecided set is expensive. Therefore, we delay it as much
/// as possible. /// as possible.
fn new( fn new(
graph: G, graph: G,
target_heads: Vec<Revision>, target_heads: Vec<Revision>,
seed: Seed, seed: Option<Seed>,
respect_size: bool, respect_size: bool,
randomize: bool, randomize: bool,
) -> Self { ) -> Self {
OnlyCommon { OnlyCommon {
graph: graph.clone(), graph: graph.clone(),
target_heads: target_heads, target_heads: target_heads,
respect_size: respect_size, respect_size: respect_size,
randomize: randomize, randomize: randomize,
seed: seed, seed: seed,
common: MissingAncestors::new(graph, vec![]), common: MissingAncestors::new(graph, vec![]),
} }
} }
/// Provide the cheapest possible valid object of type `Self` /// Provide the cheapest possible valid object of type `Self`
/// ///
/// If later on we can insist on `G` implementing `Default`, then /// If later on we can insist on `G` implementing `Default`, then
/// we can drop the `graph` parameter and move this into an `impl Default` /// we can drop the `graph` parameter and move this into an `impl Default`
/// block. Currently, our concrete type for `G` besides in tests is outside /// block. Currently, our concrete type for `G` besides in tests is outside
/// of this crate (wrapper around index Python object). /// of this crate (wrapper around index Python object).
/// We don't want to implement `Default` for it right away. /// We don't want to implement `Default` for it right away.
fn default(graph: &G) -> Self { fn default(graph: &G) -> Self {
Self::new(graph.clone(), Vec::new(), [0; 16], false, false) Self::new(graph.clone(), Vec::new(), None, false, false)
} }
/// Register revisions known as being common /// Register revisions known as being common
pub fn add_common_revisions( pub fn add_common_revisions(
&mut self, &mut self,
common: impl IntoIterator<Item = Revision>, common: impl IntoIterator<Item = Revision>,
) { ) {
self.common.add_bases(common); self.common.add_bases(common);
} }
impl<G: Graph + Clone> WithUndecided<G> { impl<G: Graph + Clone> WithUndecided<G> {
fn new( fn new(
disco: OnlyCommon<G>, disco: OnlyCommon<G>,
undecided: impl IntoIterator<Item = Revision>, undecided: impl IntoIterator<Item = Revision>,
children_cache: FastHashMap<Revision, Vec<Revision>>, children_cache: FastHashMap<Revision, Vec<Revision>>,
) -> Self { ) -> Self {
let seed = disco.seed.unwrap_or_else(|| {
let mut seed: Seed = [0; 16];
if disco.randomize {
thread_rng().fill_bytes(&mut seed);
}
seed
});
WithUndecided { WithUndecided {
undecided: undecided.into_iter().collect(), undecided: undecided.into_iter().collect(),
children_cache: children_cache, children_cache: children_cache,
rng: Rng::from_seed(disco.seed), rng: Rng::from_seed(seed),
graph: disco.graph.clone(), graph: disco.graph.clone(),
missing: HashSet::new(), missing: HashSet::new(),
respect_size: disco.respect_size, respect_size: disco.respect_size,
randomize: disco.randomize, randomize: disco.randomize,
common: disco.common, common: disco.common,
} }
} }
vec![10, 11, 12, 13], vec![10, 11, 12, 13],
[0; 16], [0; 16],
true, true,
true, true,
) )
} }
fn full_disco_with_undecided() -> WithUndecided<SampleGraph> { fn full_disco_with_undecided() -> WithUndecided<SampleGraph> {
OnlyCommon::new(SampleGraph, vec![10, 11, 12, 13], [0; 16], true, true) OnlyCommon::new(
SampleGraph,
vec![10, 11, 12, 13],
Some([0; 16]),
true,
true,
)
.compute_undecided() .compute_undecided()
.unwrap() .unwrap()
} }
/// A PartialDiscovery as for pushing the 12 head of `SampleGraph` /// A PartialDiscovery as for pushing the 12 head of `SampleGraph`
/// ///
/// To avoid actual randomness in tests, we give it a fixed random seed. /// To avoid actual randomness in tests, we give it a fixed random seed.
fn disco12() -> PartialDiscovery<SampleGraph> { fn disco12() -> PartialDiscovery<SampleGraph> {
PartialDiscovery::new_with_seed( PartialDiscovery::new_with_seed(
SampleGraph, SampleGraph,