ilyagr/pijul - Change OXZVZDQZEVP7NV3HS6HK5QA7RUD35ODVQ3LL7PWJHTS7DEFM3XTAC

Simplification of missing context repairs

Missing contexts were previously done on each individual hunk, which could be highly inefficient in some cases. The complexity was in O(p·h), where p is the size of the patch and h is the size of history, in the worst case.

This patch fixes this by doing all the context repairs in a single pass at the end of the apply function, which now has complexity O(h). Since the previous solution was to use caches, these are no longer necessary and the memory usage has also improved.

Created by pmeunier on December 18, 2023

OXZVZDQZEVP7NV3HS6HK5QA7RUD35ODVQ3LL7PWJHTS7DEFM3XTAC

Dependencies

In channels

main

Change contents

File deletion: find_alive.rs, find_alive.rs

BF:BFD[10.198146] → [11.1295:1310]

BF:BFD[11.1310] → [10.763306:763306]

BFD:BFD[10.198146] → [10.763290:763305]

BF:BFD[10.763305] → [10.763306:763306]

B:BD[10.763362] → [12.64428:64452]

B:BD[12.64452] → [13.1326:1357]

B:BD[13.1357] → [9.0:42]

∅:D[9.42] → [14.32357:32358]

∅:D[13.1452] → [14.32357:32358]

∅:D[15.85242] → [14.32357:32358]

B:BD[10.763466] → [14.32357:32358]

B:BD[14.32358] → [16.2281:2528]

∅:D[16.2528] → [10.763561:763574]

∅:D[17.114891] → [10.763561:763574]

B:BD[10.763561] → [10.763561:763574]

B:BD[10.763574] → [17.114892:114916]

∅:D[17.114916] → [10.763600:763631]

B:BD[10.763600] → [10.763600:763631]

B:BD[10.763631] → [16.2529:2852]

∅:D[18.91] → [15.85243:85285]

∅:D[13.1637] → [15.85243:85285]

∅:D[16.2852] → [15.85243:85285]

∅:D[19.3715] → [15.85243:85285]

B:BD[20.134264] → [15.85243:85285]

B:BD[15.85285] → [16.2853:3096]

B:BD[16.3152] → [16.3152:3211]

B:BD[16.3211] → [9.43:103]

∅:D[9.103] → [21.0:125]

B:BD[16.3211] → [21.0:125]

∅:D[21.125] → [16.3268:3282]

B:BD[16.3268] → [16.3268:3282]

∅:D[16.3282] → [10.764046:764068]

∅:D[20.134306] → [10.764046:764068]

B:BD[10.764046] → [10.764046:764068]

∅:D[16.3438] → [10.764068:764078]

B:BD[10.764068] → [10.764068:764078]

B:BD[10.764078] → [20.134307:134367]

B:BD[20.134367] → [13.1734:1779]

B:BD[13.1779] → [16.3439:3653]

∅:D[4.416] → [16.3653:3751]

B:BD[16.3653] → [16.3653:3751]

∅:D[16.3751] → [13.1846:1868]

B:BD[13.1846] → [13.1846:1868]

B:BD[13.1935] → [13.1935:1945]

B:BD[16.3653] → [4.285:416]

∅:D[13.1945] → [10.764136:764231]

∅:D[22.63470] → [10.764136:764231]

∅:D[12.64512] → [10.764136:764231]

∅:D[20.134367] → [10.764136:764231]

B:BD[10.764136] → [10.764136:764231]

∅:D[3.42] → [20.134368:134425]

B:BD[10.764231] → [20.134368:134425]

∅:D[20.134425] → [17.115042:115066]

B:BD[17.115042] → [17.115042:115066]

B:BD[17.115066] → [20.134426:134480]

∅:D[20.134480] → [10.764439:764479]

B:BD[10.764439] → [10.764439:764479]

B:BD[10.764546] → [10.764546:764581]

B:BD[10.764581] → [20.134481:134535]

B:BD[20.134535] → [2.0:78]

∅:D[2.78] → [20.134590:134652]

B:BD[20.134590] → [20.134590:134652]

B:BD[20.134694] → [20.134694:134755]

∅:D[20.134755] → [10.764789:764807]

B:BD[10.764789] → [10.764789:764807]

B:BD[10.764807] → [18.140:184]

B:BD[18.184] → [16.3752:4132]

∅:D[19.3758] → [18.276:305]

∅:D[16.4132] → [18.276:305]

B:BD[18.276] → [18.276:305]

B:BD[18.305] → [16.4133:4533]

∅:D[13.2067] → [18.352:456]

∅:D[16.4533] → [18.352:456]

B:BD[18.352] → [18.352:456]

B:BD[18.456] → [3.43:205]

∅:D[3.205] → [10.764978:764996]

B:BD[10.764978] → [10.764978:764996]

∅:D[3.388] → [10.764996:765010]

∅:D[23.500] → [10.764996:765010]

∅:D[16.4573] → [10.764996:765010]

B:BD[10.764996] → [10.764996:765010]

∅:D[18.495] → [10.765103:765119]

∅:D[13.2095] → [10.765103:765119]

∅:D[20.134827] → [10.765103:765119]

B:BD[10.765103] → [10.765103:765119]

B:BD[10.765119] → [16.4574:4593]

∅:D[16.4593] → [10.765133:765135]

B:BD[10.765133] → [10.765133:765135]

B:BD[10.765135] → [14.32413:32414]

B:BD[14.32414] → [16.4594:4634]

∅:D[16.4634] → [10.765228:765241]

∅:D[24.4739] → [10.765228:765241]

∅:D[17.115110] → [10.765228:765241]

B:BD[10.765228] → [10.765228:765241]

B:BD[10.765241] → [17.115111:115135]

∅:D[17.115135] → [25.15587:15630]

B:BD[10.765267] → [25.15587:15630]

∅:D[25.15630] → [10.765267:765298]

B:BD[10.765267] → [10.765267:765298]

B:BD[10.765298] → [25.15631:15653]

B:BD[25.15653] → [16.4635:4848]

∅:D[16.4848] → [13.2203:2247]

B:BD[13.2203] → [13.2203:2247]

∅:D[9.403] → [16.4849:5061]

B:BD[13.2247] → [16.4849:5061]

∅:D[26.93] → [15.85367:85409]

∅:D[18.580] → [15.85367:85409]

∅:D[16.5061] → [15.85367:85409]

B:BD[20.134912] → [15.85367:85409]

B:BD[15.85409] → [26.94:95]

B:BD[26.95] → [16.5062:5111]

B:BD[16.5111] → [9.404:449]

∅:D[26.331] → [20.134913:134947]

∅:D[9.449] → [20.134913:134947]

∅:D[18.621] → [20.134913:134947]

∅:D[16.5111] → [20.134913:134947]

B:BD[10.765737] → [20.134913:134947]

∅:D[20.134947] → [10.765769:765801]

B:BD[10.765769] → [10.765769:765801]

B:BD[10.765801] → [16.5112:5228]

B:BD[16.5285] → [16.5285:5344]

B:BD[16.5344] → [9.450:511]

∅:D[9.511] → [21.126:250]

B:BD[16.5344] → [21.126:250]

∅:D[21.250] → [16.5404:5418]

B:BD[16.5404] → [16.5404:5418]

∅:D[16.5418] → [10.765840:765862]

∅:D[20.134989] → [10.765840:765862]

B:BD[10.765840] → [10.765840:765862]

B:BD[10.765862] → [9.512:523]

∅:D[9.523] → [20.134990:135055]

∅:D[16.5603] → [20.134990:135055]

B:BD[10.765872] → [20.134990:135055]

B:BD[20.135055] → [13.2367:2408]

B:BD[13.2408] → [16.5604:6114]

∅:D[9.657] → [16.6114:6128]

B:BD[16.6114] → [16.6114:6128]

∅:D[9.732] → [16.6128:6160]

B:BD[16.6128] → [16.6128:6160]

B:BD[16.6160] → [9.733:801]

B:BD[16.6128] → [9.658:732]

B:BD[16.6114] → [9.524:657]

∅:D[9.801] → [10.765934:766007]

∅:D[13.2927] → [10.765934:766007]

∅:D[16.6160] → [10.765934:766007]

∅:D[22.63533] → [10.765934:766007]

∅:D[12.64785] → [10.765934:766007]

∅:D[20.135055] → [10.765934:766007]

B:BD[10.765934] → [10.765934:766007]

∅:D[18.661] → [10.766007:766044]

B:BD[10.766007] → [10.766007:766044]

B:BD[10.766044] → [16.6161:6235]

∅:D[16.6235] → [17.115205:115264]

B:BD[25.15740] → [17.115205:115264]

∅:D[17.115264] → [25.15798:15838]

B:BD[25.15798] → [25.15798:15838]

B:BD[25.15838] → [17.115265:115289]

B:BD[17.115289] → [18.662:734]

B:BD[18.734] → [27.5506:5616]

∅:D[18.734] → [20.135056:135095]

∅:D[27.5616] → [20.135056:135095]

B:BD[10.766283] → [20.135056:135095]

∅:D[27.5694] → [20.135095:135145]

B:BD[20.135095] → [20.135095:135145]

∅:D[20.135216] → [25.15993:16033]

B:BD[25.15993] → [25.15993:16033]

B:BD[25.16033] → [20.135217:135257]

∅:D[16.6671] → [20.135257:135299]

B:BD[20.135257] → [20.135257:135299]

∅:D[20.135299] → [17.115290:115360]

B:BD[25.16111] → [17.115290:115360]

B:BD[17.115360] → [20.135300:135384]

∅:D[20.135384] → [17.115442:115464]

B:BD[17.115442] → [17.115442:115464]

B:BD[17.115464] → [16.6672:6705]

∅:D[16.6705] → [13.2928:2995]

B:BD[18.789] → [13.2928:2995]

B:BD[13.2995] → [16.6706:6992]

∅:D[13.3114] → [25.16236:16282]

∅:D[16.6992] → [25.16236:16282]

B:BD[28.5518] → [25.16236:16282]

∅:D[28.5518] → [10.767318:767340]

∅:D[25.16282] → [10.767318:767340]

B:BD[10.767318] → [10.767318:767340]

B:BD[10.767340] → [25.16283:16310]

B:BD[25.16310] → [29.0:69]

B:BD[29.69] → [16.6993:7230]

∅:D[26.506] → [25.16444:16466]

∅:D[13.3231] → [25.16444:16466]

∅:D[16.7230] → [25.16444:16466]

B:BD[25.16444] → [25.16444:16466]

B:BD[25.16466] → [18.834:881]

B:BD[18.928] → [18.928:955]

∅:D[18.955] → [10.767445:767463]

∅:D[25.16466] → [10.767445:767463]

B:BD[10.767445] → [10.767445:767463]

B:BD[10.767529] → [10.767529:767543]

B:BD[10.767543] → [20.135439:135477]

∅:D[27.5984] → [16.7231:7589]

B:BD[20.135477] → [16.7231:7589]

∅:D[13.3396] → [25.16574:16616]

∅:D[16.7589] → [25.16574:16616]

B:BD[25.16574] → [25.16574:16616]

∅:D[25.16616] → [10.768635:768653]

B:BD[10.768635] → [10.768635:768653]

B:BD[10.768653] → [25.16617:16640]

B:BD[25.16640] → [16.7590:7611]

∅:D[9.839] → [16.7611:7650]

B:BD[16.7611] → [16.7611:7650]

∅:D[26.549] → [10.768704:768718]

∅:D[18.1038] → [10.768704:768718]

∅:D[16.7650] → [10.768704:768718]

∅:D[20.135509] → [10.768704:768718]

B:BD[10.768704] → [10.768704:768718]

B:BD[10.768834] → [10.768834:768844]

∅:D[25.16684] → [10.768844:768850]

B:BD[10.768844] → [10.768844:768850]

B:BD[10.768850] → [16.7651:7670]

∅:D[16.7670] → [10.768873:768875]

∅:D[25.16699] → [10.768873:768875]

B:BD[10.768873] → [10.768873:768875]

B:BD[10.768844] → [25.16641:16684]

B:BD[16.7611] → [9.802:839]

B:BD[20.135477] → [27.5758:5984]

B:BD[20.135257] → [27.5695:5757]

∅:D[27.5757] → [16.6275:6671]

B:BD[16.6275] → [16.6275:6671]

B:BD[20.135095] → [27.5617:5694]

B:BD[10.766007] → [18.622:661]

B:BD[13.2247] → [9.104:403]

∅:D[3.347] → [23.448:469]

B:BD[10.764996] → [23.448:469]

B:BD[23.469] → [3.348:388]

B:BD[10.764996] → [3.206:347]

B:BD[10.764231] → [3.0:42]

B:BD[10.764068] → [16.3283:3438]

use crate::pristine::*;
use crate::{HashMap, HashSet};
// use std::collections::hash_map::Entry;
/// The following is an unrolled DFS, where each alive vertex is
/// inserted into each "alive set" along the current path (which is
/// recognised by looking at the visited vertices on the stack).
pub(crate) fn find_alive_down<'a, T: GraphTxnT>(
    txn: &T,
    channel: &T::Graph,
    vertex0: Vertex<ChangeId>,
    cache: &'a mut HashMap<Vertex<ChangeId>, Option<HashSet<Vertex<ChangeId>>>>,
) -> Result<&'a Option<HashSet<Vertex<ChangeId>>>, BlockError<T::GraphError>> {
    let mut stack: Vec<(_, Option<HashSet<Vertex<ChangeId>>>)> = vec![(
        SerializedEdge::empty(vertex0.start_pos(), ChangeId::ROOT),
        None,
    )];
    let mut visited = HashSet::default();
    while let Some((elt, alive)) = stack.pop() {
        if let Some(alive) = alive {
            // We've gone through all the descendants, put this in the
            // cache.
            let vertex = txn.find_block(&channel, elt.dest())?;
            if stack.is_empty() {
                // Done!
                cache.insert(*vertex, Some(alive.clone()));
                assert_eq!(vertex0.start_pos(), vertex.start_pos());
                return Ok(cache.get(&vertex).unwrap());
            }
            continue;
        }
        let vertex = txn.find_block(&channel, elt.dest())?;
        if let Some(c) = cache.get(vertex) {
            for st in stack.iter_mut() {
                if let Some(ref mut st) = st.1 {
                    if let Some(c) = c {
                        st.extend(c.iter().cloned());
                    } else {
                        st.insert(*vertex);
                    }
                }
            }
            continue;
        }
                        // A `None` in the cache means that the vertex
                        // itself (the cache key) is alive.
        debug!("elt = {:?}, vertex = {:?}", elt, vertex);
        let elt_index = stack.len();
        for v in iter_adj_all(txn, &channel, *vertex)? {
            let v = v?;
            if v.flag().contains(EdgeFlags::FOLDER) {
                continue;
            }
            debug!("v = {:?}", v);
            if v.flag().contains(EdgeFlags::PARENT) {
                if (v.flag().contains(EdgeFlags::BLOCK) || vertex.is_empty())
                    && !v.flag().contains(EdgeFlags::DELETED)
                    && !v.flag().contains(EdgeFlags::PSEUDO)
                {
                    if *vertex == vertex0 {
                        // vertex0 is alive.
                        stack.truncate(elt_index);
                        let (_, alive) = stack.pop().unwrap();
                        let alive = alive.unwrap();
                        assert!(alive.is_empty());
                        cache.insert(vertex0, None);
                        return Ok(cache.get(&vertex0).unwrap());
                    } else {
                        // vertex is alive, insert it into all the
                        // alive sets on the current DFS path
                        // (including `vertex`).
                        for st in stack.iter_mut() {
                            if let Some(ref mut st) = st.1 {
                                st.insert(*vertex);
                            }
                        }
                        stack.truncate(elt_index);
                        break;
                    }
                }
            } else if v.flag().contains(EdgeFlags::DELETED) {
                if !has_alive_blocks {
                    stack.push((*v, None))
                }
            }
        }
    }
    unreachable!()
}
pub fn find_alive_up<'a, T: GraphTxnT>(
    txn: &T,
    channel: &T::Graph,
    files: &mut HashSet<Vertex<ChangeId>>,
    vertex0: Vertex<ChangeId>,
    change: ChangeId,
    cache: &'a mut HashMap<
        Vertex<ChangeId>,
        (Option<HashSet<Vertex<ChangeId>>>, HashSet<Vertex<ChangeId>>),
    >,
) -> Result<&'a Option<HashSet<Vertex<ChangeId>>>, BlockError<T::GraphError>> {
    debug!("find alive up: {:?}", vertex0);
    let mut stack: Vec<(
        _,
        Option<(HashSet<Vertex<ChangeId>>, HashSet<Vertex<ChangeId>>)>,
    )> = vec![(
        SerializedEdge::empty(vertex0.end_pos(), ChangeId::ROOT),
        None,
    )];
    let mut visited = HashSet::default();
    while let Some((elt, alive)) = stack.pop() {
        debug!("pop {:?} {:?}", elt, alive);
        if elt.dest().is_root() {
            continue;
        }
        if let Some((alive, files_)) = alive {
            let vertex = *txn.find_block_end(&channel, elt.dest())?;
            if stack.is_empty() {
                // Done!
                cache.insert(vertex, (Some(alive), files_));
                assert_eq!(vertex.end_pos(), vertex0.end_pos());
                return Ok(&cache.get(&vertex).unwrap().0);
            }
            continue;
        }
        let vertex = *txn.find_block_end(&channel, elt.dest())?;
        debug!("vertex = {:?}", vertex);
        if let Some((c, d)) = cache.get(&vertex) {
            debug!("Cached: {:?} {:?}", c, d);
            for st in stack.iter_mut() {
                if let Some((ref mut al, ref mut f)) = st.1 {
                    if let Some(c) = c {
                        al.extend(c.iter().cloned());
                    } else {
                        al.insert(vertex);
                    }
                    f.extend(d.iter().cloned());
                    files.extend(d.iter().cloned());
                }
            }
            continue;
        }
        stack.push((elt, Some((HashSet::new(), HashSet::new()))));
            continue;
        }
        if !visited.insert(elt.dest()) {
            }
            if visited.insert(elt.dest()) {
                stack.push((elt, Some((HashSet::new(), HashSet::new()))));
        debug!("find_alive_up: elt = {:?}, vertex = {:?}", elt, vertex);
        let elt_index = stack.len();
        let mut is_file = false; // Is this the "inode" vertex of a file?
        let mut it = iter_adj_all(txn, &channel, vertex)?;
        while let Some(v) = it.next() {
            let v = v?;
            debug!("find_alive_up: v = {:?} change = {:?}", v, change);
            if v.flag() & EdgeFlags::pseudof() == EdgeFlags::PSEUDO {
                continue;
            }
            if !v.flag().is_parent() {
                is_file |= !v.flag().is_folder();
                continue;
            }
            if !v.flag().is_deleted() {
                if v.flag().is_folder() {
                    for e in it {
                        let e = e?;
                        is_file |= !e.flag().intersects(EdgeFlags::parent_folder())
                    }
                    if is_file {
                        debug!("is alive + is file {:?}", vertex);
                        for st in stack.iter_mut() {
                            if let Some((ref mut al, ref mut fi)) = st.1 {
                                al.insert(vertex);
                                fi.insert(vertex);
                            }
                        }
                        files.insert(vertex);
                    }
                    break;
                } else if v.flag().is_block() || vertex.is_empty() {
                    debug!("is alive {:?}", vertex);
                    for st in stack.iter_mut() {
                        if let Some((ref mut st, _)) = st.1 {
                            st.insert(vertex);
                        }
                    }
                    stack.truncate(elt_index);
                    break;
                }
            }
            if v.flag().is_folder() {
                if is_file {
                    debug!("is pseudo-alive folder {:?}", vertex);
                    for st in stack.iter_mut() {
                        if let Some((ref mut al, ref mut fi)) = st.1 {
                            al.insert(vertex);
                            fi.insert(vertex);
                        }
                    }
                    files.insert(vertex);
                }
                break;
            } else {
                stack.push((*v, None))
            }
        }
    }
    unreachable!()
}
        debug!("is_file = {:?}", is_file);
                debug!("just push");
                for e in it {
                    let e = e?;
                    is_file |= !e.flag().intersects(EdgeFlags::parent_folder())
                }
                debug!("{:?} is a file ? {:?}", vertex, is_file);
                if v.flag().is_block() && vertex == vertex0 {
                    // vertex0 is alive.
                    stack.truncate(elt_index);
                    let (_, alive) = stack.pop().unwrap();
                    let (alive, _) = alive.unwrap();
                    assert!(alive.is_empty());
                    cache.insert(vertex0, (None, HashSet::new()));
                    return Ok(&cache.get(&vertex0).unwrap().0);
                }
                debug!("is_file {:?} {:?}", is_file, !v.flag().is_folder());
        debug!("stack = {:?}", stack);
    // Each element of the stack is a pair of (1) an edge pointing to
    // the position we want to visit next and (2) optionally, a set of
    // alive vertices found until now.
    // Every time we find an alive vertex, we add it to the sets of
    // each element on the path to that vertex.
            } else {
                stack.push((*v, None));
            } else if v.flag().contains(EdgeFlags::BLOCK) {
                has_alive_blocks = true;
                stack.push((*v, None));
        let mut has_alive_blocks = false;
        } else {
            if !visited.insert(elt.dest()) {
                continue;
            }
            stack.push((elt, Some(HashSet::new())));

Deletion in libpijul/src/unrecord/mod.rs at line 4 [10.231493]
B:BD[10.231616] → [10.231616:231647]
```
use crate::missing_context::*;
```
Replacement in libpijul/src/unrecord/mod.rs at line 206 [10.231493]
B:BD[10.234990] → [22.2131:2219]
```
    repair_newvertex_contexts::<T, C>(txn, T::graph_mut(channel), &mut ws, change_id)?;
```
[10.234990]
[10.235104]
Deletion in libpijul/src/unrecord/mod.rs at line 213 [10.231493]
∅:D[25.189] → [28.2074:2154]
∅:D[22.2308] → [28.2074:2154]
∅:D[14.9861] → [28.2074:2154]
∅:D[17.24492] → [28.2074:2154]
B:BD[28.2074] → [28.2074:2154]
B:BD[28.2154] → [22.2309:2348]
∅:D[22.2348] → [28.2179:2287]
∅:D[17.24529] → [28.2179:2287]
B:BD[28.2179] → [28.2179:2287]
```
            repair_edges_context(
                changes,
                txn,
                T::graph_mut(channel),
                &mut ws.apply.missing_context,
                change_id,
                n,
            )?
```
Insertion in libpijul/src/unrecord/mod.rs at line 260 [10.231493]
[30.1678]
[30.1678]
```
            crate::apply::repair_zombies(txn, channel, inode)?;
```
Deletion in libpijul/src/unrecord/mod.rs at line 359 [10.231493]
B:BD[10.238934] → [31.11603:11677]
∅:D[14.10183] → [10.238976:238993]
∅:D[31.11677] → [10.238976:238993]
∅:D[17.25244] → [10.238976:238993]
B:BD[10.238976] → [10.238976:238993]
B:BD[10.238993] → [17.25245:25273]
∅:D[17.25273] → [10.239023:239047]
B:BD[10.239023] → [10.239023:239047]
B:BD[10.239047] → [25.1483:1508]
B:BD[25.1508] → [31.11678:11724]
∅:D[14.10237] → [10.239080:239152]
∅:D[31.11724] → [10.239080:239152]
∅:D[17.25332] → [10.239080:239152]
B:BD[10.239080] → [10.239080:239152]
B:BD[10.239152] → [20.17659:17702]
∅:D[20.17702] → [32.42:64]
B:BD[32.42] → [32.42:64]
∅:D[32.64] → [10.239430:239440]
B:BD[10.239430] → [10.239430:239440]
B:BD[10.239440] → [32.65:272]
∅:D[32.272] → [10.239440:239446]
B:BD[10.239440] → [10.239440:239446]
```
fn repair_newvertex_contexts<T: GraphMutTxnT + TreeTxnT, C: ChangeStore>(
    txn: &mut T,
    channel: &mut T::Graph,
    ws: &mut Workspace,
    change_id: ChangeId,
) -> Result<(), UnrecordError<C::Error, T>> {
    debug!("up = {:#?}", ws.up);
    for (up, inode) in ws.up.drain() {
        if !is_alive(txn, channel, &up)? {
            continue;
        }
        crate::missing_context::repair_missing_down_context(
            txn,
            channel,
            &mut ws.apply.missing_context,
            inode,
            up,
            &[up],
        )?
    }
```

Deletion in libpijul/src/unrecord/mod.rs at line 360 [10.231493]

B:BD[10.239447] → [10.239447:239484]

B:BD[10.239484] → [25.1509:1552]

B:BD[25.1552] → [20.17703:17748]

∅:D[20.17748] → [32.317:349]

B:BD[32.317] → [32.317:349]

∅:D[32.349] → [12.8261:8315]

∅:D[25.1552] → [12.8261:8315]

B:BD[10.239578] → [12.8261:8315]

∅:D[12.8315] → [10.239619:239740]

B:BD[10.239619] → [10.239619:239740]

B:BD[10.239740] → [17.25375:25422]

B:BD[17.25422] → [20.17749:17819]

∅:D[22.3007] → [17.25423:25473]

∅:D[20.17819] → [17.25423:25473]

B:BD[12.8385] → [17.25423:25473]

B:BD[17.25473] → [20.17820:17864]

∅:D[25.1596] → [10.239908:239932]

∅:D[20.17864] → [10.239908:239932]

B:BD[10.239908] → [10.239908:239932]

B:BD[10.239932] → [25.1597:1681]

∅:D[25.1681] → [10.240010:240166]

B:BD[10.240010] → [10.240010:240166]

B:BD[10.240166] → [25.1682:1709]

∅:D[25.1709] → [10.240166:240234]

B:BD[10.240166] → [10.240166:240234]

B:BD[10.240261] → [10.240261:240305]

B:BD[10.240305] → [14.10238:10239]

    debug!("down = {:#?}", ws.down);
    for (down, inode) in ws.down.drain() {
        if !is_alive(txn, channel, &down)? {
            continue;
        }
        for parent in iter_adjacent(
            txn,
            channel,
            down,
            EdgeFlags::PARENT,
            EdgeFlags::all() - EdgeFlags::DELETED,
        )? {
            let parent = parent?;
            let parent = txn.find_block_end(channel, parent.dest())?;
            if !is_alive(txn, channel, parent)? {
                ws.parents.insert(*parent);
            }
        }
        debug!("parents {:#?}", ws.parents);
        for up in ws.parents.drain() {
            crate::missing_context::repair_missing_up_context(
                txn,
                channel,
                &mut ws.apply.missing_context,
                change_id,
                inode,
                up,
                &[down],
            )?
        }
    }
    Ok(())
}

Deletion in libpijul/src/unrecord/mod.rs at line 699 [10.231493]

B:BD[25.3885] → [25.3885:3886]

B:BD[25.3886] → [31.12172:12241]

∅:D[31.12241] → [10.246914:246948]

∅:D[17.27114] → [10.246914:246948]

B:BD[10.246914] → [10.246914:246948]

B:BD[10.246948] → [17.27115:27143]

∅:D[17.27143] → [10.246978:247082]

B:BD[10.246978] → [10.246978:247082]

B:BD[10.247082] → [31.12242:12288]

∅:D[31.12288] → [33.461:497]

B:BD[17.27202] → [33.461:497]

∅:D[33.497] → [20.19248:19323]

B:BD[17.27202] → [20.19248:19323]

∅:D[20.19323] → [10.247175:247205]

∅:D[17.27263] → [10.247175:247205]

B:BD[10.247175] → [10.247175:247205]

B:BD[10.247205] → [34.191:240]

∅:D[34.240] → [10.247205:247259]

B:BD[10.247205] → [10.247205:247259]

B:BD[10.247259] → [17.27264:27338]

∅:D[25.4024] → [10.247259:247312]

B:BD[10.247259] → [10.247259:247312]

B:BD[10.247675] → [10.247675:247825]

B:BD[10.247825] → [35.356:418]

∅:D[35.418] → [25.4025:4072]

B:BD[10.247885] → [25.4025:4072]

∅:D[25.4072] → [10.247905:247937]

B:BD[10.247905] → [10.247905:247937]

B:BD[10.248081] → [12.10099:10170]

B:BD[12.10170] → [22.3314:3365]

B:BD[22.3365] → [33.498:535]

∅:D[33.535] → [17.27339:27385]

∅:D[22.3365] → [17.27339:27385]

B:BD[12.10222] → [17.27339:27385]

B:BD[17.27385] → [33.536:573]

∅:D[33.573] → [10.248246:248439]

∅:D[12.10267] → [10.248246:248439]

∅:D[17.27385] → [10.248246:248439]

B:BD[10.248246] → [10.248246:248439]

∅:D[36.62] → [25.4073:4120]

B:BD[10.248499] → [25.4073:4120]

∅:D[25.4120] → [10.248739:248783]

B:BD[10.248739] → [10.248739:248783]


fn repair_edges_context<T: GraphMutTxnT + TreeTxnT, P: ChangeStore>(
    changes: &P,
    txn: &mut T,
    channel: &mut T::Graph,
    ws: &mut crate::missing_context::Workspace,
    change_id: ChangeId,
    n: &EdgeMap<Option<Hash>>,
) -> Result<(), UnrecordError<P::Error, T>> {
    debug!("repair_edges_context");
    let change_hash: Hash = txn.get_external(&change_id)?.unwrap().into();
    for e in n.edges.iter() {
        debug!("repair_edges_context: {:?}", e);
        assert!(!e.flag.contains(EdgeFlags::PARENT));
        let intro = internal(txn, &e.introduced_by, change_id)?.unwrap();
        if e.previous.contains(EdgeFlags::DELETED) {
            repair_context_deleted(
                txn,
                channel,
                ws,
                n.inode,
                intro,
                |h| changes.knows(&change_hash, &h).unwrap(),
                &e.reverse(Some(change_hash)),
            )?
        } else {
            let to = internal_pos(txn, &e.to.start_pos(), change_id)?;
            let to = txn.find_block(channel, to)?;
            debug!("to = {:?}", to);
            if !is_alive(txn, channel, to)? {
                debug!("not alive");
                continue;
            }
            repair_context_nondeleted(
                txn,
                channel,
                ws,
                n.inode,
                intro,
                &e.reverse(Some(change_hash)),
            )?
        }
    }
    Ok(())
}

Insertion in libpijul/src/pristine/mod.rs at line 1338 [10.586748]
[7.65]
[17.67345]
```
        let stack_len = stack.len();
```
Insertion in libpijul/src/pristine/mod.rs at line 1353 [10.586748]
[10.617113]
[10.617156]
```
        (&mut stack[stack_len..]).reverse()
```

Deletion in libpijul/src/pristine/edge.rs at line 25 [10.648958]

B:BD[25.8459] → [25.8459:8549]

    pub(crate) fn db() -> Self {
        Self::DELETED | Self::BLOCK
    }
    #[inline]

Deletion in libpijul/src/missing_context.rs at line 3 [10.696460]
B:BD[10.696575] → [10.696575:696601]
```
use crate::find_alive::*;
```

Deletion in libpijul/src/missing_context.rs at line 56 [10.696460]

B:BD[10.697932] → [10.697932:697950]

B:BD[10.697950] → [14.26444:26445]

∅:D[14.26445] → [10.698005:698054]

B:BD[10.698005] → [10.698005:698054]

B:BD[10.698054] → [17.89079:89100]

∅:D[17.89100] → [10.698070:698140]

B:BD[10.698070] → [10.698070:698140]

B:BD[10.698140] → [17.89101:89129]

∅:D[17.89129] → [10.698170:698194]

B:BD[10.698170] → [10.698170:698194]

B:BD[10.698194] → [25.9450:9475]

∅:D[25.9475] → [10.698194:698264]

B:BD[10.698194] → [10.698194:698264]

B:BD[10.698264] → [17.89130:89177]

∅:D[14.26488] → [10.698320:698361]

∅:D[17.89177] → [10.698320:698361]

B:BD[10.698320] → [10.698320:698361]

B:BD[10.698361] → [13.43:197]

B:BD[13.197] → [16.0:226]

∅:D[16.226] → [10.698527:698528]

B:BD[10.698527] → [10.698527:698528]

B:BD[10.698528] → [16.227:700]

∅:D[16.700] → [10.698931:698941]

B:BD[10.698931] → [10.698931:698941]

B:BD[10.698941] → [16.701:777]

∅:D[23.146] → [10.699912:699918]

∅:D[13.379] → [10.699912:699918]

∅:D[16.777] → [10.699912:699918]

∅:D[25.9719] → [10.699912:699918]

∅:D[17.89250] → [10.699912:699918]

B:BD[10.699912] → [10.699912:699918]

∅:D[37.48] → [10.699962:699976]

B:BD[10.699962] → [10.699962:699976]

B:BD[10.699976] → [17.89251:89290]

∅:D[25.9754] → [10.700008:700025]

∅:D[17.89290] → [10.700008:700025]

B:BD[10.700008] → [10.700008:700025]

B:BD[10.700025] → [17.89291:89319]

∅:D[17.89319] → [25.9755:9840]

B:BD[10.700055] → [25.9755:9840]

B:BD[25.9840] → [17.89320:89361]

∅:D[17.89361] → [25.9868:9904]

B:BD[25.9868] → [25.9868:9904]

B:BD[25.9904] → [13.380:444]

∅:D[13.444] → [25.9968:10155]

B:BD[25.9968] → [25.9968:10155]

B:BD[25.10215] → [25.10215:10293]

∅:D[37.105] → [10.700569:700588]

∅:D[25.10293] → [10.700569:700588]

∅:D[14.26694] → [10.700569:700588]

B:BD[10.700569] → [10.700569:700588]

B:BD[10.700588] → [14.26695:26696]

∅:D[14.26696] → [10.700643:700694]

B:BD[10.700643] → [10.700643:700694]

B:BD[10.700694] → [17.89362:89383]

∅:D[17.89383] → [10.700710:700780]

B:BD[10.700710] → [10.700710:700780]

B:BD[10.700780] → [17.89384:89412]

∅:D[17.89412] → [10.700810:700904]

B:BD[10.700810] → [10.700810:700904]

B:BD[10.700904] → [17.89413:89460]

B:BD[17.89460] → [13.445:496]

∅:D[13.496] → [10.700937:700978]

∅:D[14.26739] → [10.700937:700978]

∅:D[17.89460] → [10.700937:700978]

B:BD[10.700937] → [10.700937:700978]

B:BD[10.700978] → [13.497:574]

B:BD[13.574] → [16.778:1145]

        }
    }
}
pub(crate) fn repair_missing_up_context<
    'a,
    T: GraphMutTxnT,
    I: IntoIterator<Item = &'a Vertex<ChangeId>>,
>(
    txn: &mut T,
    channel: &mut T::Graph,
    ws: &mut Workspace,
    change_id: ChangeId,
    inode: Position<Option<Hash>>,
    c: Vertex<ChangeId>,
    d: I,
) -> Result<(), MissingError<T::GraphError>> {
    let now = std::time::Instant::now();
    let alive = find_alive_up(
        txn,
        channel,
        &mut ws.files,
        c,
        change_id,
        &mut ws.alive_up_cache,
    )?;
    if let Some(alive) = alive {
        let mut alive = alive.clone();
        debug!("files = {:?}", ws.files);
        crate::TIMERS.lock().unwrap().find_alive += now.elapsed();
        ws.load_graph(txn, channel, inode)?;
        debug!("repair_missing_up_context, alive = {:?}", alive);
        for &d in d {
            if let Some((graph, vids)) = ws.graphs.0.get(&inode) {
                crate::alive::remove_redundant_parents(
                    graph,
                    vids,
                    &mut alive,
                    &mut ws.covered_parents,
                    d,
                );
            }
            repair_regular_up(txn, channel, &alive, d, EdgeFlags::PSEUDO)?;
        }
    } else {
        debug!("repair_missing_up_context: {:?} is alive", c);
    }
    Ok(())
}
fn repair_regular_up<T: GraphMutTxnT>(
    txn: &mut T,
    channel: &mut T::Graph,
    alive: &HashSet<Vertex<ChangeId>>,
    d: Vertex<ChangeId>,
    flag: EdgeFlags,
) -> Result<(), TxnErr<T::GraphError>> {
    for &ancestor in alive.iter() {
        debug!("repair_regular_up {:?} → {:?}", ancestor, d);
        if ancestor == d {
            info!(
                "repair_missing_up_context, alive: {:?} == {:?}",
                ancestor, d
            );
            continue;
        }
        put_graph_with_rev(txn, channel, flag, ancestor, d, ChangeId::ROOT)?;
    }
    Ok(())
}
pub(crate) fn repair_missing_down_context<
    'a,
    T: GraphMutTxnT,
    I: IntoIterator<Item = &'a Vertex<ChangeId>>,
>(
    txn: &mut T,
    channel: &mut T::Graph,
    ws: &mut Workspace,
    inode: Position<Option<Hash>>,
    c: Vertex<ChangeId>,
    d: I,
) -> Result<(), MissingError<T::GraphError>> {
    debug!("repair_missing_down_context {:?}", c);
    let now = std::time::Instant::now();
    let alive = find_alive_down(txn, channel, c, &mut ws.alive_down_cache)?;
    if let Some(alive) = alive {
        let mut alive = alive.clone();
        debug!("alive = {:?}", alive);
        crate::TIMERS.lock().unwrap().find_alive += now.elapsed();
        ws.load_graph(txn, channel, inode)?;
        if let Some((graph, vids)) = ws.graphs.0.get(&inode) {
            crate::alive::remove_redundant_children(graph, vids, &mut alive, c);

Deletion in libpijul/src/missing_context.rs at line 57 [10.696460]

∅:D[16.1155] → [10.701277:701278]

B:BD[10.701277] → [10.701277:701278]

B:BD[10.701278] → [16.1156:1269]

∅:D[16.1269] → [10.701379:701380]

B:BD[10.701379] → [10.701379:701380]

B:BD[10.701380] → [16.1270:1660]

∅:D[16.1660] → [10.701647:701661]

B:BD[10.701647] → [10.701647:701661]

∅:D[25.10699] → [10.701825:701835]

∅:D[14.26796] → [10.701825:701835]

∅:D[12.57387] → [10.701825:701835]

∅:D[17.89552] → [10.701825:701835]

B:BD[10.701825] → [10.701825:701835]

B:BD[10.701835] → [16.1661:1731]


        if !alive.is_empty() {
            debug!("repair_missing_down_context alive = {:#?}", alive);
        }
        for &d in d {
            for &desc in alive.iter() {
                if d == desc {
                    info!("repair_missing_down_context, alive: {:?} == {:?}", d, desc);
                    continue;
                }
                debug!("repair_missing_down {:?} {:?}", d, desc);
                put_graph_with_rev(txn, channel, EdgeFlags::PSEUDO, d, desc, ChangeId::ROOT)?;
            }
        }
    } else {
        debug!("repair_missing_down: {:?} is alive", c);

Deletion in libpijul/src/missing_context.rs at line 58 [10.696460]
B:BD[10.701841] → [10.701841:701852]
```
    Ok(())
```
Replacement in libpijul/src/missing_context.rs at line 60 [10.696460]
B:BD[14.26798] → [33.978:1036]
∅:D[33.1036] → [10.701965:701982]
∅:D[17.89614] → [10.701965:701982]
B:BD[10.701965] → [10.701965:701982]
B:BD[10.701982] → [17.89615:89643]
∅:D[17.89643] → [10.702012:702071]
B:BD[10.702012] → [10.702012:702071]
```
pub(crate) fn repair_context_nondeleted<T: GraphMutTxnT>(
    txn: &mut T,
    channel: &mut T::Graph,
    ws: &mut Workspace,
    inode: Position<Option<Hash>>,
```
[14.26798]
[10.702071]
```
pub(crate) fn has_missing_context_nondeleted<T: GraphMutTxnT>(
    txn: &T,
    channel: &T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 65 [10.696460]
B:BD[10.702145] → [33.1037:1084]
```
) -> Result<(), MissingError<T::GraphError>> {
```
[10.702145]
[25.10700]
```
) -> Result<bool, MissingError<T::GraphError>> {
```
Replacement in libpijul/src/missing_context.rs at line 67 [10.696460]
B:BD[25.10744] → [25.10744:10767]
```
        return Ok(());
```
[25.10744]
[10.703811]
```
        return Ok(false);
```

Replacement in libpijul/src/missing_context.rs at line 75 [10.696460]

∅:D[5.113] → [33.1085:1172]

B:BD[20.123202] → [33.1085:1172]

∅:D[33.1172] → [25.11149:11219]

B:BD[25.11149] → [25.11149:11219]

B:BD[25.11219] → [35.482:525]

B:BD[35.525] → [5.114:260]

    repair_missing_up_context(txn, channel, ws, change_id, inode, source, &[target])?;
    reconnect_target_up(txn, channel, ws, inode, target, change_id)?;
    if e.flag.contains(EdgeFlags::BLOCK) {
        let mut missing_down = std::mem::replace(&mut ws.missing_down, Vec::new());
        missing_down.clear();
        for e in iter_adjacent(

[5.113]

[5.260]

    if is_alive(txn, channel, &source)? && e.flag.contains(EdgeFlags::BLOCK) {
        Ok(iter_adjacent(

Replacement in libpijul/src/missing_context.rs at line 82 [10.696460]

B:BD[5.400] → [5.400:644]

∅:D[5.644] → [20.123203:123252]

B:BD[35.607] → [20.123203:123252]

∅:D[20.123252] → [35.655:754]

B:BD[35.655] → [35.655:754]

∅:D[35.754] → [25.11301:11303]

B:BD[25.11301] → [25.11301:11303]

∅:D[25.11303] → [10.704008:704009]

B:BD[10.704008] → [10.704008:704009]

B:BD[10.704009] → [17.89765:89806]

∅:D[17.89806] → [25.11340:11357]

B:BD[25.11340] → [25.11340:11357]

B:BD[25.11357] → [17.89807:89835]

∅:D[17.89835] → [25.11387:11501]

B:BD[25.11387] → [25.11387:11501]

B:BD[25.11501] → [17.89836:89883]

B:BD[17.89883] → [15.83424:83466]

∅:D[15.83466] → [17.89884:89963]

B:BD[10.704213] → [17.89884:89963]

B:BD[17.89963] → [20.123253:123323]

∅:D[25.11668] → [10.704390:704422]

∅:D[20.123323] → [10.704390:704422]

B:BD[10.704390] → [10.704390:704422]

B:BD[10.704422] → [20.123324:123368]

∅:D[20.123368] → [25.11711:11759]

B:BD[25.11711] → [25.11711:11759]

∅:D[25.11759] → [10.704542:704620]

B:BD[10.704542] → [10.704542:704620]

B:BD[10.704620] → [25.11760:11822]

B:BD[25.11822] → [20.123369:123434]

∅:D[12.57866] → [10.704732:704770]

∅:D[22.59136] → [10.704732:704770]

∅:D[20.123434] → [10.704732:704770]

B:BD[10.704732] → [10.704732:704770]

B:BD[10.704770] → [25.11823:11910]

        )? {
            let e = e?;
            ws.missing_down.push(*txn.find_block(&channel, e.dest())?)
        }
        repair_missing_down_context(txn, channel, ws, inode, target, &missing_down)?;
        ws.missing_down = missing_down;
    } else if is_alive(txn, channel, &source)? {
        repair_missing_down_context(txn, channel, ws, inode, target, &[source])?;
    }
    Ok(())
}
fn reconnect_target_up<T: GraphMutTxnT>(
    txn: &mut T,
    channel: &mut T::Graph,
    ws: &mut Workspace,
    inode: Position<Option<Hash>>,
    target: Vertex<ChangeId>,
    change_id: ChangeId,
) -> Result<(), MissingError<T::GraphError>> {
    let mut unknown = HashSet::default();
    for v in iter_deleted_parents(txn, channel, target)? {
        let v = v?;
        if v.dest().change.is_root() || v.introduced_by().is_root() {
            continue;
        }
        if v.introduced_by() == change_id {
            unknown.clear();
            break;
        }
        // Else change ~v.introduced_by~ is a change we don't know,
        // since no change can create a conflict with itself.
        unknown.insert(*txn.find_block_end(channel, v.dest())?);
    }
    for up in unknown.drain() {
        repair_missing_up_context(txn, channel, ws, change_id, inode, up, &[target])?;

[5.400]

[10.705601]

        )?
        .next()
        .is_some())
    } else {
        Ok(true)

Deletion in libpijul/src/missing_context.rs at line 88 [10.696460]
B:BD[10.705736] → [10.705736:705747]
```
    Ok(())
```
Replacement in libpijul/src/missing_context.rs at line 90 [10.696460]
B:BD[10.705750] → [17.90568:90626]
∅:D[17.90626] → [10.705858:705875]
B:BD[10.705858] → [10.705858:705875]
B:BD[10.705875] → [17.90627:90655]
∅:D[17.90655] → [10.705905:705964]
B:BD[10.705905] → [10.705905:705964]
```
pub(crate) fn repair_context_deleted<T: GraphMutTxnT, K>(
    txn: &mut T,
    channel: &mut T::Graph,
    ws: &mut Workspace,
    inode: Position<Option<Hash>>,
```
[10.705750]
[10.705964]
```
pub(crate) fn has_missing_context_deleted<T: GraphMutTxnT, K>(
    txn: &T,
    channel: &T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 96 [10.696460]
B:BD[10.706038] → [17.90656:90701]
```
) -> Result<(), MissingError<T::GraphError>>
```
[10.706038]
[10.706069]
```
) -> Result<bool, MissingError<T::GraphError>>
```
Replacement in libpijul/src/missing_context.rs at line 101 [10.696460]
B:BD[25.13117] → [25.13117:13140]
```
        return Ok(());
```
[25.13117]
[25.13140]
```
        return Ok(false);
```

Replacement in libpijul/src/missing_context.rs at line 107 [10.696460]

B:BD[10.706422] → [10.706422:706520]

        repair_children_of_deleted(txn, channel, ws, inode, &mut known, change_id, dest_vertex)?;

[10.706422]

[25.13147]


        if has_unknown_children(txn, channel, dest_vertex, change_id, &mut known)? {
            return Ok(true);
        }

Replacement in libpijul/src/missing_context.rs at line 118 [10.696460]
B:BD[10.706653] → [10.706653:706664]
```
    Ok(())
```
[10.706653]
[10.706664]
```
    Ok(false)
```

Replacement in libpijul/src/missing_context.rs at line 218 [10.696460]

B:BD[38.3800] → [27.5414:5505]

        debug!("detect folder conflict resolution, deleting {:?} → {:?} {:?}", v, e, p);

[38.3800]

        debug!(
            "detect folder conflict resolution, deleting {:?} → {:?} {:?}",
            v, e, p
        );

Replacement in libpijul/src/missing_context.rs at line 316 [10.696460]
B:BD[10.708025] → [17.90795:90841]
```
fn collect_unknown_children<T: GraphTxnT, K>(
```
[10.708025]
[10.708066]
```
fn has_unknown_children<T: GraphTxnT, K>(
```
Deletion in libpijul/src/missing_context.rs at line 319 [10.696460]
∅:D[17.90866] → [10.708105:708129]
B:BD[10.708105] → [10.708105:708129]
```
    ws: &mut Workspace,
```
Replacement in libpijul/src/missing_context.rs at line 322 [10.696460]
B:BD[10.708208] → [17.90867:90906]
```
) -> Result<(), TxnErr<T::GraphError>>
```
[10.708208]
[17.90906]
```
) -> Result<bool, TxnErr<T::GraphError>>
```
Deletion in libpijul/src/missing_context.rs at line 336 [10.696460]
B:BD[20.123922] → [20.123922:123969]
```
            ws.pseudo.push((dest_vertex, *v));
```

Replacement in libpijul/src/missing_context.rs at line 355 [10.696460]

B:BD[10.709260] → [20.124107:124144]

∅:D[20.124144] → [10.709296:709326]

B:BD[10.709296] → [10.709296:709326]

B:BD[10.709326] → [17.91352:91363]

∅:D[17.91363] → [10.709326:709329]

B:BD[10.709326] → [10.709326:709329]

B:BD[10.709329] → [17.91364:91415]

∅:D[17.91415] → [10.709375:709392]

B:BD[10.709375] → [10.709375:709392]

B:BD[10.709392] → [17.91416:91444]

∅:D[17.91444] → [10.709422:709559]

B:BD[10.709422] → [10.709422:709559]

B:BD[10.709559] → [17.91445:91490]

∅:D[14.26923] → [10.709590:709626]

∅:D[17.91490] → [10.709590:709626]

B:BD[10.709590] → [10.709590:709626]

B:BD[10.709685] → [10.709685:709745]

B:BD[10.709745] → [17.91491:91576]

∅:D[17.91576] → [10.709829:709899]

B:BD[10.709829] → [10.709829:709899]

B:BD[10.709899] → [25.14431:14503]

∅:D[25.14503] → [10.710052:710088]

B:BD[10.710052] → [10.710052:710088]

B:BD[10.710088] → [20.124145:124260]

∅:D[20.124260] → [25.14561:14621]

B:BD[25.14561] → [25.14561:14621]

B:BD[25.14621] → [17.91577:91664]

∅:D[17.91664] → [25.14707:14730]

B:BD[14.26980] → [25.14707:14730]

B:BD[25.14730] → [20.124261:124327]

∅:D[22.59321] → [25.14796:14894]

∅:D[20.124327] → [25.14796:14894]

B:BD[25.14796] → [25.14796:14894]

B:BD[25.14894] → [17.91665:91750]

∅:D[17.91750] → [25.14978:15044]

B:BD[14.27053] → [25.14978:15044]

                ws.unknown.push(*v);
            }
        }
    }
    Ok(())
}
fn repair_children_of_deleted<T: GraphMutTxnT, K>(
    txn: &mut T,
    channel: &mut T::Graph,
    ws: &mut Workspace,
    inode: Position<Option<Hash>>,
    mut known: K,
    change_id: ChangeId,
    dest_vertex: Vertex<ChangeId>,
) -> Result<(), MissingError<T::GraphError>>
where
    K: FnMut(Hash) -> bool,
{
    trace!("repair_children_of_deleted {:?}", dest_vertex);
    collect_unknown_children(txn, channel, ws, dest_vertex, change_id, &mut known)?;
    let mut unknown = std::mem::replace(&mut ws.unknown, Vec::new());
    debug!("dest_vertex = {:?}, unknown = {:?}", dest_vertex, unknown);
    for edge in unknown.drain(..) {
        let p = *txn.find_block(channel, edge.dest())?;
        assert!(!edge.flag().contains(EdgeFlags::FOLDER));
        debug!("dest_vertex {:?}, p {:?}", dest_vertex, p);
        put_graph_with_rev(txn, channel, EdgeFlags::db(), dest_vertex, p, change_id)?;
        let mut u = p;
        while let Ok(&v) = txn.find_block(channel, u.end_pos()) {
            if u != v {
                debug!("repair_children_of_deleted: {:?} -> {:?}", u, v);
                put_graph_with_rev(txn, channel, EdgeFlags::db(), u, v, change_id)?;
                u = v
            } else {
                break;

[10.709260]

[10.711082]

                return Ok(true);

Deletion in libpijul/src/missing_context.rs at line 358 [10.696460]

B:BD[10.711106] → [20.124328:124369]

∅:D[17.91791] → [25.15084:15179]

∅:D[20.124369] → [25.15084:15179]

B:BD[25.15084] → [25.15084:15179]

∅:D[25.15179] → [10.711414:711431]

B:BD[10.711414] → [10.711414:711431]

B:BD[10.711431] → [16.1936:2029]

∅:D[16.2029] → [13.1091:1275]

B:BD[13.1091] → [13.1091:1275]

B:BD[13.1275] → [16.2030:2083]

∅:D[16.2083] → [13.1309:1325]

B:BD[13.1309] → [13.1309:1325]

∅:D[13.1325] → [10.711583:711593]

∅:D[25.15277] → [10.711583:711593]

B:BD[10.711583] → [10.711583:711593]

        if is_alive(txn, channel, &p)? {
            repair_missing_up_context(txn, channel, ws, change_id, inode, dest_vertex, &[p])?;
        } else {
            let alive = find_alive_down(txn, channel, p, &mut ws.alive_down_cache)?.clone();
            repair_missing_up_context(
                txn,
                channel,
                ws,
                change_id,
                inode,
                dest_vertex,
                alive.iter().flat_map(|t| t.iter()),
            )?;
        }

Replacement in libpijul/src/missing_context.rs at line 359 [10.696460]
B:BD[10.711599] → [10.711599:711636]
```
    ws.unknown = unknown;
    Ok(())
```
[10.711599]
[10.711636]
```
    Ok(false)
```

Deletion in libpijul/src/missing_context.rs at line 361 [10.696460]

B:BD[10.711638] → [12.58890:58891]

B:BD[12.58891] → [17.91792:91844]

∅:D[17.91844] → [10.711740:711757]

B:BD[10.711740] → [10.711740:711757]

B:BD[10.711757] → [17.91845:91873]

∅:D[17.91873] → [10.711787:711811]

B:BD[10.711787] → [10.711787:711811]

B:BD[10.711811] → [17.91874:91921]

∅:D[14.27096] → [10.711844:711914]

∅:D[17.91921] → [10.711844:711914]

B:BD[10.711844] → [10.711844:711914]

B:BD[10.711914] → [25.15278:15332]

∅:D[25.15332] → [10.711964:712042]

B:BD[10.711964] → [10.711964:712042]

B:BD[10.712042] → [20.124370:124630]

∅:D[17.92062] → [12.59054:59118]

∅:D[20.124630] → [12.59054:59118]

B:BD[12.59054] → [12.59054:59118]

B:BD[12.59118] → [20.124631:124775]

∅:D[25.15530] → [10.712510:712549]

∅:D[14.27169] → [10.712510:712549]

∅:D[17.92159] → [10.712510:712549]

∅:D[20.124775] → [10.712510:712549]

B:BD[10.712510] → [10.712510:712549]

B:BD[10.712549] → [20.124776:124887]

∅:D[17.92209] → [12.59295:59363]

∅:D[20.124887] → [12.59295:59363]

B:BD[12.59295] → [12.59295:59363]

B:BD[12.59363] → [20.124888:124988]

∅:D[20.125429] → [10.714122:714140]

B:BD[10.714122] → [10.714122:714140]

B:BD[10.715906] → [10.715906:715930]

B:BD[10.716708] → [10.716708:716728]

B:BD[10.716728] → [17.92810:92868]

∅:D[17.92868] → [10.716781:716798]

B:BD[10.716781] → [10.716781:716798]

B:BD[10.716798] → [17.92869:92897]

∅:D[17.92897] → [10.716828:716852]

B:BD[10.716828] → [10.716828:716852]

B:BD[10.716852] → [17.92898:92945]

∅:D[14.27635] → [10.716885:717371]

∅:D[17.92945] → [10.716885:717371]

B:BD[10.716885] → [10.716885:717371]


pub(crate) fn delete_pseudo_edges<T: GraphMutTxnT>(
    txn: &mut T,
    channel: &mut T::Graph,
    ws: &mut Workspace,
) -> Result<(), MissingError<T::GraphError>> {
    if ws.pseudo.is_empty() {
        debug!("no pseudo edges")
    }
    for (dest_vertex, mut e) in ws.pseudo.drain(..) {
        debug!("repair_context_deleted, deleting {:?} {:?}", dest_vertex, e);
        if !is_alive(txn, channel, &dest_vertex)? && !ws.repaired.contains(&dest_vertex) {
            if e.flag().contains(EdgeFlags::PARENT) {
                let p = *txn.find_block_end(channel, e.dest())?;
                if !is_alive(txn, channel, &p)? {
                    debug!("delete {:?} {:?}", p, dest_vertex);
                    e -= EdgeFlags::PARENT;
                    del_graph_with_rev(txn, channel, e.flag(), p, dest_vertex, e.introduced_by())?;
                }
            } else {
                let p = *txn.find_block(channel, e.dest())?;
                if !is_alive(txn, channel, &p)? {
                    debug!("delete (2) {:?} {:?}", dest_vertex, p);
                    del_graph_with_rev(txn, channel, e.flag(), dest_vertex, p, e.introduced_by())?;
                }
            }
        }
    }
    Ok(())
}
pub(crate) fn repair_parents_of_deleted<T: GraphMutTxnT>(
    txn: &mut T,
    channel: &mut T::Graph,
    ws: &mut Workspace,
) -> Result<(), MissingError<T::GraphError>> {
    debug!("repair_parents_of_deleted");
    let mut unknown = std::mem::replace(&mut ws.unknown_parents, Vec::new());
    for (dest_vertex, p, inode, flag) in unknown.drain(..) {
        if flag.contains(EdgeFlags::FOLDER) {
            repair_missing_down_context(txn, channel, ws, inode, dest_vertex, &[dest_vertex])?
        } else {
            repair_missing_down_context(txn, channel, ws, inode, dest_vertex, &[p])?
        }
    }
    ws.unknown_parents = unknown;
    Ok(())
}

Deletion in libpijul/src/lib.rs at line 22 [10.717381]
B:BD[10.717679] → [24.4292:4312]
```
pub mod find_alive;
```
Replacement in libpijul/src/apply.rs at line 51 [10.944089]
∅:D[8.16] → [39.752:810]
B:BD[17.123233] → [39.752:810]
```
    MakeChange(#[from]crate::change::MakeChangeError<T>),
```
[8.16]
[14.94263]
```
    MakeChange(#[from] crate::change::MakeChangeError<T>),
```

Replacement in libpijul/src/apply.rs at line 340 [10.944089]

B:BD[10.949433] → [27.5985:6337]

                Atom::NewVertex(ref n) => {
                    put_newvertex(
                        txn,
                        T::graph_mut(channel),
                        changes,
                        change,
                        ws,
                        change_id,
                        n,
                    )?
                },

[10.949433]

[10.949531]

                Atom::NewVertex(ref n) => put_newvertex(
                    txn,
                    T::graph_mut(channel),
                    changes,
                    change,
                    ws,
                    change_id,
                    n,
                )?,

Deletion in libpijul/src/apply.rs at line 385 [10.944089]

B:BD[10.951555] → [27.6338:7040]


                    {
                        let file = Vertex {
                            change: ChangeId(L64(5867590239053715538)),
                            start: ChangePosition(204370u64.into()),
                            end: ChangePosition(204370u64.into()),
                        };
                        let still_here: Vec<_> = iter_adjacent(
                            txn,
                            T::graph_mut(channel),
                            file,
                            EdgeFlags::empty(),
                            EdgeFlags::all(),
                        )?.collect();
                        debug!("still here! {:?}", still_here);
                    }

Deletion in libpijul/src/apply.rs at line 387 [10.944089]
B:BD[10.951611] → [6.131:132]

Replacement in libpijul/src/apply.rs at line 391 [10.944089]

B:BD[10.951686] → [22.65200:65277]

    clean_obsolete_pseudo_edges(txn, T::graph_mut(channel), ws, change_id)?;

[10.951686]

[10.951738]

    let mut inodes = clean_obsolete_pseudo_edges(txn, T::graph_mut(channel), ws, change_id)?;
    collect_missing_contexts(txn, txn.graph(channel), ws, &change, change_id, &mut inodes)?;
    for i in inodes {
        repair_zombies(txn, T::graph_mut(channel), i)?;
    }

Deletion in libpijul/src/apply.rs at line 397 [10.944089]

B:BD[10.951739] → [10.951739:951780]

B:BD[10.951780] → [22.65278:65359]

    info!("repairing missing contexts");
    repair_missing_contexts(txn, T::graph_mut(channel), ws, change_id, change)?;

Insertion in libpijul/src/apply.rs at line 562 [10.944089]

[10.962677]

[14.97503]


pub(crate) fn repair_zombies<T: GraphMutTxnT + TreeTxnT>(
    txn: &mut T,
    channel: &mut T::Graph,
    root: Position<ChangeId>,
) -> Result<(), LocalApplyError<T>> {
    let mut stack = vec![(root.inode_vertex(), true, false)];
    let mut visited = HashSet::new();

Replacement in libpijul/src/apply.rs at line 572 [10.944089]

B:BD[14.97504] → [31.42243:42314]

pub(crate) fn clean_obsolete_pseudo_edges<T: GraphMutTxnT + TreeTxnT>(

[14.97504]

[10.971306]

    while let Some((current, alive, on_path)) = stack.pop() {
        stack.push((current, alive, true));
        let is_first_visit = visited.insert(current);
        let len = stack.len();
        if !on_path {
            // If this is the first visit, find the children, starting
            // with in flag order (alive first), since we don't want
            // to reconnect vertices multiple times.
            for e in iter_adjacent(txn, channel, current, EdgeFlags::empty(), EdgeFlags::all())? {
                let e = e?;
                if e.flag().contains(EdgeFlags::PARENT) {
                    if e.flag() & (EdgeFlags::BLOCK | EdgeFlags::DELETED) == EdgeFlags::BLOCK {
                        // This vertex is alive!
                        stack[len - 1].1 = true;
                    }
                    continue;
                }
                if is_first_visit {
                    let child = txn.find_block(channel, e.dest())?;
                    stack.push((*child, false, false));
                }
            }
        }
        if len >= 2 && stack[len - 1].1 {
            if let Some(last_on_path) = (&stack[..len - 1]).iter().rev().position(|x| x.2) {
                let last_on_path = len - 2 - last_on_path;
                // If the last vertex on the path to `current` is not
                // alive, a reconnect is needed.
                if !stack[last_on_path].1 {
                    if let Some(last_alive_on_path) =
                        (&stack[..last_on_path]).iter().rev().position(|x| x.1)
                    {
                        let last_alive_on_path = last_on_path - 1 - last_alive_on_path;
                        debug!("repair zombies {:?} {:?}", last_alive_on_path, len - 1);
                        // We need to reconnect, and we can do it now
                        // since we won't have a chance to visit that
                        // edge (because non-PARENT edge we are
                        // inserting now starts from a vertex that is
                        // on the path, which means we've already
                        // pushed all its children onto the stack.).
                        put_graph_with_rev(
                            txn,
                            channel,
                            EdgeFlags::PSEUDO,
                            stack[last_alive_on_path].0,
                            stack[len - 1].0,
                            ChangeId::ROOT,
                        )?;
                    }
                }
            }
        }
        // If no children, pop.
        if stack.len() == len {
            stack.pop();
        }
    }
    Ok(())
}
pub fn clean_obsolete_pseudo_edges<T: GraphMutTxnT + TreeTxnT>(

Replacement in libpijul/src/apply.rs at line 644 [10.944089]

B:BD[25.20894] → [31.42315:42353]

) -> Result<(), LocalApplyError<T>> {

[25.20894]

[34.508]

) -> Result<HashSet<Position<ChangeId>>, LocalApplyError<T>> {
    info!(
        "clean_obsolete_pseudo_edges, ws.pseudo.len() = {}",
        ws.pseudo.len()
    );

Insertion in libpijul/src/apply.rs at line 651 [10.944089]
[34.672]
[10.971451]
```
    let mut inodes = HashSet::new();
```

Replacement in libpijul/src/apply.rs at line 655 [10.944089]

B:BD[10.971508] → [27.7041:7126]

        debug!("clean_obsolete_pseudo_edges {:?} {:?} {:?}", next_vertex, p, inode);

[10.971508]

[27.7126]

        debug!(
            "clean_obsolete_pseudo_edges {:?} {:?} {:?}",
            next_vertex, p, inode
        );

Replacement in libpijul/src/apply.rs at line 667 [10.944089]

B:BD[27.7334] → [27.7334:7453]

            )?.collect();
            debug!("pseudo edge still here ? {:?} {:?}", next_vertex.change.0.0, still_here)

[27.7334]

[27.7453]

            )?
            .collect();
            debug!(
                "pseudo edge still here ? {:?} {:?}",
                next_vertex.change.0 .0, still_here
            )

Deletion in libpijul/src/apply.rs at line 744 [10.944089]
∅:D[25.21227] → [10.972853:972877]
∅:D[17.132503] → [10.972853:972877]
B:BD[10.972853] → [10.972853:972877]
B:BD[10.972877] → [40.284:319]
∅:D[40.319] → [25.21228:21333]
B:BD[10.972877] → [25.21228:21333]
∅:D[25.21333] → [12.71094:71140]
B:BD[12.71094] → [12.71094:71140]
B:BD[12.71140] → [25.21334:21398]
∅:D[25.21398] → [12.71203:71222]
B:BD[12.71203] → [12.71203:71222]
B:BD[12.71222] → [25.21399:21421]
∅:D[25.21421] → [14.99202:99216]
B:BD[12.71255] → [14.99202:99216]
B:BD[14.99216] → [25.21422:21475]
B:BD[25.21475] → [20.147383:147439]
∅:D[20.147439] → [40.374:407]
B:BD[40.374] → [40.374:407]
```
        if a_is_alive {
            debug!("repair down");
            debug_assert!(!b_is_alive);
            crate::missing_context::repair_missing_down_context(
                txn,
                channel,
                &mut ws.missing_context,
                inode,
                b,
                &[a],
            )
            .map_err(LocalApplyError::from_missing)?
        } else if b_is_alive && !p.flag().is_folder() {
            debug!("repair up");
```

Replacement in libpijul/src/apply.rs at line 745 [10.944089]

B:BD[34.1982] → [34.1982:2142]

∅:D[40.407] → [25.21515:21578]

∅:D[34.2142] → [25.21515:21578]

B:BD[25.21515] → [25.21515:21578]

∅:D[25.21578] → [12.71305:71351]

B:BD[12.71305] → [12.71305:71351]

B:BD[12.71351] → [25.21579:21670]

∅:D[25.21670] → [12.71395:71414]

B:BD[12.71395] → [12.71395:71414]

B:BD[12.71414] → [25.21671:21693]

∅:D[25.21693] → [14.99351:99365]

B:BD[12.71466] → [14.99351:99365]

B:BD[14.99365] → [25.21694:21747]

            // Note: if this is a folder edge,
            // repair_missing_up_context will stop immediately, so we
            // don't even need to call it.
            crate::missing_context::repair_missing_up_context(
                txn,
                channel,
                &mut ws.missing_context,
                change_id,
                inode,
                a,
                &[b],
            )
            .map_err(LocalApplyError::from_missing)?

[34.1982]

[10.974222]

        if a_is_alive || (b_is_alive && !p.flag().is_folder()) {
            // A context repair is needed.
            inodes.insert(internal_pos(txn, &inode, change_id)?);

Insertion in libpijul/src/apply.rs at line 750 [10.944089]
[10.974238]
[34.2143]
Replacement in libpijul/src/apply.rs at line 753 [10.944089]
∅:D[34.2215] → [10.974238:974249]
B:BD[10.974238] → [10.974238:974249]
```
    Ok(())
```
[34.2215]
[10.974249]
```
    Ok(inodes)
```
Replacement in libpijul/src/apply.rs at line 807 [10.944089]
∅:D[34.3809] → [31.42354:42410]
B:BD[41.1060] → [31.42354:42410]
∅:D[31.42410] → [10.974346:974363]
∅:D[17.132549] → [10.974346:974363]
B:BD[10.974346] → [10.974346:974363]
B:BD[10.974363] → [17.132550:132578]
```
fn repair_missing_contexts<T: GraphMutTxnT + TreeTxnT>(
    txn: &mut T,
    channel: &mut T::Graph,
```
[34.3809]
[10.974393]
```
fn collect_missing_contexts<T: GraphMutTxnT + TreeTxnT>(
    txn: &T,
    channel: &T::Graph,
```
Insertion in libpijul/src/apply.rs at line 811 [10.944089]
[10.974417]
[10.974417]
```
    change: &Change,
```
Replacement in libpijul/src/apply.rs at line 813 [10.944089]
B:BD[10.974442] → [10.974442:974463]
```
    change: &Change,
```
[10.974442]
[31.42411]
```
    inodes: &mut HashSet<Position<ChangeId>>,
```

Replacement in libpijul/src/apply.rs at line 815 [10.944089]

∅:D[31.42449] → [10.974496:974537]

∅:D[14.99456] → [10.974496:974537]

∅:D[17.132629] → [10.974496:974537]

B:BD[10.974496] → [10.974496:974537]

B:BD[10.974537] → [14.99457:99600]

    let now = std::time::Instant::now();
    crate::missing_context::repair_parents_of_deleted(txn, channel, &mut ws.missing_context)
        .map_err(LocalApplyError::from_missing)?;

[31.42449]

[10.974632]

    inodes.extend(
        ws.missing_context
            .unknown_parents
            .drain(..)
            .map(|x| internal_pos(txn, &x.2, change_id).unwrap()),
    );

Replacement in libpijul/src/apply.rs at line 824 [10.944089]

∅:D[25.21811] → [10.974756:974920]

B:BD[10.974756] → [10.974756:974920]

B:BD[10.974920] → [25.21812:21988]

                let vertex = Vertex {
                    change: change_id,
                    start: n.start,
                    end: n.end,
                };
                repair_new_vertex_context_up(txn, channel, ws, change_id, n, vertex)?;
                repair_new_vertex_context_down(txn, channel, ws, change_id, n, vertex)?;

[25.21811]

[10.976945]

                let inode = internal_pos(txn, &n.inode, change_id)?;
                if !inodes.contains(&inode) {
                    for up in n.up_context.iter() {
                        let up =
                            *txn.find_block_end(channel, internal_pos(txn, &up, change_id)?)?;
                        if !is_alive(txn, channel, &up)? {
                            inodes.insert(inode);
                            break;
                        }
                    }
                    for down in n.down_context.iter() {
                        let down =
                            *txn.find_block(channel, internal_pos(txn, &down, change_id)?)?;
                        let mut down_has_other_parents = false;
                        for e in iter_adjacent(
                            txn,
                            channel,
                            down,
                            EdgeFlags::PARENT,
                            EdgeFlags::all() - EdgeFlags::DELETED,
                        )? {
                            let e = e?;
                            if e.introduced_by() != change_id {
                                down_has_other_parents = true;
                                break;
                            }
                        }
                        if !down_has_other_parents {
                            inodes.insert(inode);
                            break;
                        }
                    }
                }

Replacement in libpijul/src/apply.rs at line 860 [10.944089]

B:BD[10.976997] → [25.22027:22105]

∅:D[25.22105] → [10.977637:977667]

B:BD[10.977637] → [10.977637:977667]

B:BD[10.978406] → [14.99969:100106]

∅:D[14.100106] → [10.978495:978575]

B:BD[10.978495] → [10.978495:978575]

B:BD[10.978575] → [41.1061:1062]

B:BD[41.1062] → [31.42450:42511]

∅:D[31.42511] → [25.22151:22168]

∅:D[17.132680] → [25.22151:22168]

B:BD[25.22151] → [25.22151:22168]

B:BD[25.22168] → [17.132681:132709]

∅:D[17.132709] → [25.22198:22310]

B:BD[25.22198] → [25.22198:22310]

B:BD[25.22310] → [31.42512:42550]

∅:D[31.42550] → [25.22355:22391]

∅:D[17.132760] → [25.22355:22391]

B:BD[25.22355] → [25.22355:22391]

B:BD[25.22391] → [20.147440:147567]

∅:D[17.132803] → [25.22516:22912]

∅:D[20.147567] → [25.22516:22912]

B:BD[25.22516] → [25.22516:22912]

B:BD[25.22912] → [31.42551:42614]

∅:D[31.42614] → [25.22959:22976]

∅:D[17.132856] → [25.22959:22976]

B:BD[25.22959] → [25.22959:22976]

B:BD[25.22976] → [17.132857:132885]

∅:D[17.132885] → [25.23006:23118]

B:BD[25.23006] → [25.23006:23118]

B:BD[25.23118] → [31.42615:42653]

∅:D[31.42653] → [25.23163:23294]

∅:D[17.132936] → [25.23163:23294]

B:BD[25.23163] → [25.23163:23294]

B:BD[25.23294] → [17.132937:132985]

B:BD[17.132985] → [20.147568:147652]

∅:D[22.66872] → [17.132986:133018]

∅:D[20.147652] → [17.132986:133018]

B:BD[25.23418] → [17.132986:133018]

∅:D[17.133018] → [25.23444:23582]

B:BD[25.23444] → [25.23444:23582]

B:BD[25.23582] → [17.133019:133056]

B:BD[17.133056] → [20.147653:147701]

∅:D[20.147701] → [17.133102:133135]

B:BD[17.133102] → [17.133102:133135]

                repair_edge_context(txn, channel, ws, change_id, change, n)?;
            }
        }
    }
    crate::missing_context::delete_pseudo_edges(txn, channel, &mut ws.missing_context)
        .map_err(LocalApplyError::from_missing)?;
    crate::TIMERS.lock().unwrap().repair_context += now.elapsed();
    Ok(())
}
fn repair_new_vertex_context_up<T: GraphMutTxnT + TreeTxnT>(
    txn: &mut T,
    channel: &mut T::Graph,
    ws: &mut Workspace,
    change_id: ChangeId,
    n: &NewVertex<Option<Hash>>,
    vertex: Vertex<ChangeId>,
) -> Result<(), LocalApplyError<T>> {
    for up in n.up_context.iter() {
        let up = *txn.find_block_end(channel, internal_pos(txn, &up, change_id)?)?;
        if !is_alive(txn, channel, &up)? {
            debug!("repairing missing up context {:?} {:?}", up, vertex);
            repair_missing_up_context(
                txn,
                channel,
                &mut ws.missing_context,
                change_id,
                n.inode,
                up,
                &[vertex],
            )
            .map_err(LocalApplyError::from_missing)?
        }
    }
    Ok(())
}
fn repair_new_vertex_context_down<T: GraphMutTxnT + TreeTxnT>(
    txn: &mut T,
    channel: &mut T::Graph,
    ws: &mut Workspace,
    change_id: ChangeId,
    n: &NewVertex<Option<Hash>>,
    vertex: Vertex<ChangeId>,
) -> Result<(), LocalApplyError<T>> {
    debug!("repairing missing context for {:?}", vertex);
    if n.flag.contains(EdgeFlags::FOLDER) {
        return Ok(());
    }
    'outer: for down in n.down_context.iter() {
        let down = *txn.find_block(channel, internal_pos(txn, &down, change_id)?)?;
        for e in iter_adjacent(
            txn,
            channel,
            down,
            EdgeFlags::PARENT,
            EdgeFlags::all() - EdgeFlags::DELETED,
        )? {
            let e = e?;
            if e.introduced_by() != change_id {
                continue 'outer;

[10.976997]

[17.133135]

                has_missing_edge_context(txn, channel, change_id, change, n, inodes)?;

Deletion in libpijul/src/apply.rs at line 863 [10.944089]

B:BD[25.23681] → [25.23681:23988]

        debug!("repairing missing down context {:?} {:?}", down, vertex);
        repair_missing_down_context(
            txn,
            channel,
            &mut ws.missing_context,
            n.inode,
            down,
            &[vertex],
        )
        .map_err(LocalApplyError::from_missing)?

Replacement in libpijul/src/apply.rs at line 867 [10.944089]
B:BD[25.24008] → [31.42654:42706]
∅:D[25.24044] → [10.978666:978683]
∅:D[31.42706] → [10.978666:978683]
∅:D[17.133191] → [10.978666:978683]
B:BD[10.978666] → [10.978666:978683]
B:BD[10.978683] → [17.133192:133220]
∅:D[17.133220] → [10.978713:978737]
B:BD[10.978713] → [10.978713:978737]
```
fn repair_edge_context<T: GraphMutTxnT + TreeTxnT>(
    txn: &mut T,
    channel: &mut T::Graph,
    ws: &mut Workspace,
```
[25.24008]
[10.978737]
```
fn has_missing_edge_context<T: GraphMutTxnT + TreeTxnT>(
    txn: &T,
    channel: &T::Graph,
```
Insertion in libpijul/src/apply.rs at line 873 [10.944089]
[25.24076]
[31.42707]
```
    inodes: &mut HashSet<Position<ChangeId>>,
```

Replacement in libpijul/src/apply.rs at line 875 [10.944089]

∅:D[31.42745] → [25.24121:24687]

∅:D[17.133271] → [25.24121:24687]

B:BD[25.24121] → [25.24121:24687]

B:BD[25.24687] → [33.1227:1327]

    for e in n.edges.iter() {
        assert!(!e.flag.contains(EdgeFlags::PARENT));
        if e.flag.contains(EdgeFlags::DELETED) {
            trace!("repairing context deleted {:?}", e);
            repair_context_deleted(
                txn,
                channel,
                &mut ws.missing_context,
                n.inode,
                change_id,
                |h| change.knows(&h),
                e,
            )
            .map_err(LocalApplyError::from_missing)?
        } else {
            trace!("repairing context nondeleted {:?}", e);
            repair_context_nondeleted(txn, channel, &mut ws.missing_context, n.inode, change_id, e)

[31.42745]

[33.1327]

    let inode = internal_pos(txn, &n.inode, change_id)?;
    if !inodes.contains(&inode) {
        for e in n.edges.iter() {
            assert!(!e.flag.contains(EdgeFlags::PARENT));
            if e.flag.contains(EdgeFlags::DELETED) {
                trace!("repairing context deleted {:?}", e);
                if has_missing_context_deleted(txn, channel, change_id, |h| change.knows(&h), e)
                    .map_err(LocalApplyError::from_missing)?
                {
                    inodes.insert(inode);
                    break;
                }
            } else {
                trace!("repairing context nondeleted {:?}", e);
                if has_missing_context_nondeleted(
                    txn,
                    channel,
                    change_id,
                    e,
                )

Insertion in libpijul/src/apply.rs at line 896 [10.944089]

[33.1384]

[25.24989]

                {
                    inodes.insert(inode);
                    break;
                }
            }

Simplification of missing context repairs

Dependencies

In channels

Change contents

File deletion: find_alive.rs, find_alive.rs

Deletion in libpijul/src/unrecord/mod.rs at line 4 [10.231493]

Replacement in libpijul/src/unrecord/mod.rs at line 206 [10.231493]

Deletion in libpijul/src/unrecord/mod.rs at line 213 [10.231493]

Insertion in libpijul/src/unrecord/mod.rs at line 260 [10.231493]

Deletion in libpijul/src/unrecord/mod.rs at line 359 [10.231493]

Deletion in libpijul/src/unrecord/mod.rs at line 360 [10.231493]

Deletion in libpijul/src/unrecord/mod.rs at line 699 [10.231493]

Insertion in libpijul/src/pristine/mod.rs at line 1338 [10.586748]

Insertion in libpijul/src/pristine/mod.rs at line 1353 [10.586748]

Deletion in libpijul/src/pristine/edge.rs at line 25 [10.648958]

Deletion in libpijul/src/missing_context.rs at line 3 [10.696460]

Deletion in libpijul/src/missing_context.rs at line 56 [10.696460]

Deletion in libpijul/src/missing_context.rs at line 57 [10.696460]

Deletion in libpijul/src/missing_context.rs at line 58 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 60 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 65 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 67 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 75 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 82 [10.696460]

Deletion in libpijul/src/missing_context.rs at line 88 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 90 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 96 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 101 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 107 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 118 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 218 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 316 [10.696460]

Deletion in libpijul/src/missing_context.rs at line 319 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 322 [10.696460]

Deletion in libpijul/src/missing_context.rs at line 336 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 355 [10.696460]

Deletion in libpijul/src/missing_context.rs at line 358 [10.696460]

Replacement in libpijul/src/missing_context.rs at line 359 [10.696460]

Deletion in libpijul/src/missing_context.rs at line 361 [10.696460]

Deletion in libpijul/src/lib.rs at line 22 [10.717381]

Replacement in libpijul/src/apply.rs at line 51 [10.944089]

Replacement in libpijul/src/apply.rs at line 340 [10.944089]

Deletion in libpijul/src/apply.rs at line 385 [10.944089]

Deletion in libpijul/src/apply.rs at line 387 [10.944089]

Replacement in libpijul/src/apply.rs at line 391 [10.944089]

Deletion in libpijul/src/apply.rs at line 397 [10.944089]

Insertion in libpijul/src/apply.rs at line 562 [10.944089]

Replacement in libpijul/src/apply.rs at line 572 [10.944089]

Replacement in libpijul/src/apply.rs at line 644 [10.944089]

Insertion in libpijul/src/apply.rs at line 651 [10.944089]

Replacement in libpijul/src/apply.rs at line 655 [10.944089]

Replacement in libpijul/src/apply.rs at line 667 [10.944089]

Deletion in libpijul/src/apply.rs at line 744 [10.944089]

Replacement in libpijul/src/apply.rs at line 745 [10.944089]

Insertion in libpijul/src/apply.rs at line 750 [10.944089]

Replacement in libpijul/src/apply.rs at line 753 [10.944089]

Replacement in libpijul/src/apply.rs at line 807 [10.944089]

Insertion in libpijul/src/apply.rs at line 811 [10.944089]

Replacement in libpijul/src/apply.rs at line 813 [10.944089]