Various post-fire fixes

[?]

Apr 20, 2021, 8:32 PM

I24UEJQLCH2SOXA4UHIYWTRDCHSOPU7AFTRUOTX7HZIAV4AZKYEQC

Dependencies

[2] O4DNWMPD Cleaunp and proofreading of libpijul::record
[3] IYJZVLET Cleaning up the literate programming bits
[4] NZIK34IM Fixing a bug in diff, where some changes were ignored for no reason
[5] YWUZQU3T Formatting (for some reason, this previously escaped the hooks)
[6] VL7ZYKHB Running hooks through shell on Windows and Unix
[7] OU243LAB Support for staging
[8] PKIHBUGT Setting the oldest modification time to EPOCH if no file has changed
[9] NF4O25IE Cleaning up useless operations in InodeMetadata
[10] I6DVZEFU Do not ask for user input if the SSH channel is already closed
[11] ADPAFSMY Proper old metadata when recording
[12] YTQS4ES3 Fixing a parsing problem (related to permissions), and the associated permissions
[13] VE2UWMW4 Trying to fix channel touch
[14] YDTN6BGI Touch the channel if no file was changed
[15] QV66H4YA Prevent --channel from being used with a single file in `pijul reset`
[16] 2D7P2VKJ Change completions (where the whole progress bar story started)
[17] X7OHUPL5 Fixing a bug in unrecord, and fixing the tests
[18] MFTN7GBW Pre-tags cleanup + fast Sanakirja
[19] EEOOHGQQ More atomic "file moves+transaction"
[20] UDHP4ZVB Fixing SSH asynchronicity issues
[21] FXT5FS5W Updating Cargo.nix
[22] EGSVRZJV Avoid converting between base32 and hash in pijul::commands::unrecord
[23] NA5I4WYN Fixing the inverse of conflict resolutions
[24] 3AMEP2Y5 More convenient interface for channels
[25] CZX6TRWR Fixing a shortcut to detect alive children without iterating
[26] HSVGP2G4 Version bump + formatting
[27] ATZ3BWSE Fixing the double-deletion of repairs for folder edges
[28] H3NAKE2I Adding num_cpus to Cargo.lock
[29] 23LVKATN Use pager crate for log output
[30] 62XVBWPY remove redundant Clap attributes
[31] WKX5S4Z4 remove unneccesary explicit lifetimes
[32] HDGRZISM Version updates
[33] BNPSVXIC Friendlier progress bars
[34] OUWD436A Version bump
[35] KUMJITTF Version bump in the lockfiles
[36] KDF6FJRV bigger clippy refactors
[37] UBCBQ5FG Removing pijul/src/commands/checkout.rs (unused file), as well as litorg comments
[38] MHQBEHJD unrecord --reset without a pending change
[39] 7FFFKQZU add 'Default' implementations
[40] XWETQ4DE Upgrading versions
[41] 4OCC6D42 Recursive add
[42] I7VL7VPZ Minor cleanup
[43] I52XSRUH Massive cleanup, and simplification
[44] OJZWJUF2 MUCH faster `pijul add -r`
[45] JRSBH6HT Identification of line numbers in replacements
[46] SPA2OL5I keep-changes feature (default) to avoid deleting problematic changes
[47] 5BRU2RRW Cleanup (debugging a crash related to trees/inodes)
[48] NLGQAH4H Credit and reset relative to current directory instead of the root
[49] WIORLB47 Version bump
[50] ZXTHL45O address clippy lints
[51] ZRUPLBBT Colours in diff and change: separating concerns and dependencies
[52] 43AJ37IX Getting rid of edge validation, which does not work for zombie conflicts
[53] IM6UFPOZ Fixing a test related to the tree/revtree tables
[54] MDADYULS Fix a panic when switching between channels that have different files
[55] 6YMDOZIB Refactoring apply
[56] K6GWUOD5 Styling progress bars
[57] X243Z3Y5 Recording only the required metadata (can even be changed later!)
[58] H62VFFJE Cargo.nix, and solving conflicts
[59] XJPQKIUG
[60] XA23FMQM Reset only files that have been modified
[61] Q7CAYX5N Fixing Windows compilation
[62] B5Z4IMEU Generating Cargo.nix for pijul 1.0.0-alpha.6
[63] YDKNUL6B Add `diff --short` that lists changes without showing them
[64] 7ZFRYVVQ Cargo.nix and formatting
[65] BD5PC25A Deleting conflict resolution vertices when the sides are deleted
[66] VIHXB7SG commands: set up pager for diff, change, and credit
[67] HR3WK6A7 When lock times out, check that there are no more clients before quitting
[68] VO5OQW4W Removing anyhow in libpijul
[69] R3H7D42U Debugging `pijul git`: proper error reporting
[70] HKEOO4QJ Version bump
[71] 5BB266P6 Optional colours in the global config file
[72] LLT3GY6U When recording, do not consider deleted filenames as current
[73] 6DOXSHWG Cleanup, and version bump
[74] VLPIKNFS clone: make source remote the default
[75] PJ7T2VFL Do not hang on locked repositories
[76] VMPAOJS2 Don't output after pushing to a local channel
[77] Q45QHPO4 Feedback on network stuff
[78] ENKQ3QZG Forward the exit status messages from the SSH background loop to the client (solving hangs)
[79] I2D35LLF More accurate recording of modification time
[80] J63VVQ5I pijul reset: fixed help message
[81] 5DVRL6MF Hard-unrecord
[82] 7UPL3Y2A Unrecord: don't restore the same unrecorded file deletion twice in the inodes and tree tables
[83] Y7YAFMFF Fix path prefix striping on Windows.
[84] LGEJSLTY Fixing output (including its uses in reset and pull)
[85] JP3BYVXX Fixing file paths on Windows
[86] YN63NUZO Sanakirja 1.0
[87] SAGSYAPX Various version bumps
[88] L4JXJHWX pijul/*: reorganize imports and remove extern crate
[89] CXM5CBS2 Fixing `pijul remove` when files are not deleted
[90] A3DMBJJA Upgrading the `git` subcommand to the latest Sanakirja and Libpijul
[91] QE64ATLZ Fixing asynchronicity problems in SSH
[92] SQVWP4LU When clone fails, only remove directories we have created (not other directories)
[93] 44BN7FWS Do not output files introduced by patches that were not applied during a push
[94] 7A2TSC4P Conflict solving code (FOLDER edges)
[95] JRENVH5D Reqwest 0.11
[96] 4H2XTVJ2 Fix some mistakes in the docs
[97] WZVCLZKY address clippy lints
[98] ZBNKSYA6 Fixing a bus error when starting a transaction on a full disk
[99] TKEVOH7H Fixing a bug when downloading changes, and making change download more efficient (more async)
[100] DJYHARZ7 Skipping old files when recording
[101] PH7B6I3U Fixing log --hash-only
[102] RXNT67OT Sanakirja version, and removing an unwrap
[103] SLJ3OHD4 unrecord: show list of changes if none were given as arguments
[104] G734WNM6 flake.nix: use crate2nix
[105] KWAMD2KR A few fixes in the documentation comments
[106] VXZNQQHC If an existing file is moved to a new directory that is deleted before the record, record the deletion
[107] L4LAD4XM Fixing clone on WSL (Windows Subsystem for Linux)
[108] GVQ7YSED Checking for dependencies even for a local change
[109] 3M7WBE24 Re-adding anyhow in the tests of libpijul
[110] JL4WKA5P Implement the Sanakirja concurrency model in a cross-process way
[111] VYHHOEYH Versions and formatting
[112] TZ42DX3B Properly dropping a channel
[113] VQPAUKBQ channel switch as an alias to reset
[114] 3VJB4ULD Updating Cargo.nix
[115] GHO6DWPI Refactoring iterators
[116] ZHABNS3S Canonicalize all paths
[117] LYTVEPH3 Avoid cloning into an existing path
[118] 7PM25EXL Recursive apply was written a little too fast…
[119] 33SQMZYX New versions of dependencies
[120] 4VWXL6KQ Correct handling of ignore files
[121] 76PCXGML Pushing to, and pulling from the local repository
[122] DNQHXWRZ address clippy hard errors
[123] MU5GSJAW Partial push and pull (WARNING: breaks the existing protocol)
[124] 3YDPHBAN address non-controversial clippy lints
[125] UFCZKKLX Upgrading to the latest Sanakirja/Rand
[126] NMX52UOG Fixing the "invalid change" errors
[127] 6RVT5X4L Current state: return zero instead of an Option if there is no change on the channel
[128] G6S6PWZE Do not touch the channel if this is a partial record
[129] DIGICKHO Fixing a conflict (probably due to unrecord)
[130] MF3WAHBI commands/record: amend current change if unspecified
[131] QNJBR73K don't return Result for infallible functions
[132] KJDQ2WOM Fixing the parsing of section headers in the text change format
[133] VNBLGT6G Do not output unmodified files when resetting (fix)
[134] A6R6SGCP Fixing a panic in `pijul change`
[135] 2K7JLB4Z No pager on Windows
[136] HQ56ADNS Formatting, and version bump
[137] OCBM7IFE New release: pijul-1.0.0-alpha.8
[138] BT2ZHPY4 Version bumps
[139] BZSC7VMY address clippy lints
[140] TPEH2XNB 1.0.0-alpha.28, with Tokio 1.0
[141] 3KRGVQFU Do not update the mtime of unmodified files
[142] CCLLB7OI Upgrading to Sanakirja 0.15 + version bump
[143] UNZXTNSJ Change text format: order dependencies in the order they were on the channel at record time
[144] SXEYMYF7 Fixing the bad changes in history (unfortunately, by rebooting).
[145] 23OFHED6 Remove .pijul after a failed cloned, in the case we created it but did not its parent
[146] SEWGHUHQ .pijul/config: simplify remotes and hooks
[147] BXD3IQYN Fixing --features git
[148] CCFJ7VO3 Renaming "Record" to "Hunk" in the changes
[149] QMTANHVN Reset: only output changed files
[150] EQLDTLXV Fixing a bug with empty new files, and another one with empty replacements
[151] YAJAXIV5 Unrecording changes atomically
[152] KVBLRDOU Concatenating edits with order conflict resolutions (if relevant), and parsing the text format of the result
[153] HMMMKONL Fixing alive vertices
[154] NO2QPRFL Adding rollback test
[155] H23LO7U7 a few more clippy lints addressed
[156] KWAGWB73 Adding extra dependencies from the config file
[157] IIV3EL2X Cleanup, formatting, and fixing the Git feature
[158] ZXCRG5RP It seems change inverses will need a little more work
[159] BZCGXVS7 Fixing two bugs around conflicts on the last line, where invalid patches were produced (first bug) and applied (second bug)
[160] Y6EVFMTA Don't output files if they aren't in the current channel
[161] ZAEUSICJ File deletions were not shown with their names in the metadata during record
[162] B3QWIGDE Fixing the Git features with the latest Pijul (+ conflicts in Cargo.toml)
[*] 3WIQYEIS Fixing conflicts in Cargo.lock

Change contents

edit in pijul/src/repository.rs at line 1

[20.21496]→[20.21496:21516](∅→∅)

use std::io::Write;
edit in pijul/src/repository.rs at line 2

[20.21540]

[20.21540]

use std::sync::Arc;
replacement in pijul/src/repository.rs at line 12

[20.21688]→[20.21688:21758](∅→∅)

pub working_copy: libpijul::working_copy::filesystem::FileSystem,

[20.21688]

[20.21758]

pub working_copy: Arc<libpijul::working_copy::filesystem::FileSystem>,
edit in pijul/src/repository.rs at line 23

[20.22013]

[20.22013]

pub fn config_path(&self) -> PathBuf {
self.path.join(DOT_DIR).join(CONFIG_FILE)
}
replacement in pijul/src/repository.rs at line 28

[20.22074]→[20.22074:22262](∅→∅)

let config = toml::to_string(&self.config)?;
let mut file = std::fs::File::create(&self.path.join(DOT_DIR).join(CONFIG_FILE))?;
file.write_all(config.as_bytes())?;

[20.22074]

[20.22262]

self.config.save(&self.config_path())?;
replacement in pijul/src/repository.rs at line 82

[20.1623]→[20.23967:24052](∅→∅),[20.5906]→[20.23967:24052](∅→∅),[20.23967]→[20.23967:24052](∅→∅)

working_copy: libpijul::working_copy::filesystem::FileSystem::from_root(

[20.5906]

[20.24052]

working_copy: Arc::new(libpijul::working_copy::filesystem::FileSystem::from_root(
replacement in pijul/src/repository.rs at line 84

[20.24087]→[20.24087:24102](∅→∅)

),

[20.24087]

[20.24102]

)),
replacement in pijul/src/repository.rs at line 108

[20.1926]→[20.24973:25068](∅→∅),[20.6006]→[20.24973:25068](∅→∅),[20.24973]→[20.24973:25068](∅→∅)

working_copy: libpijul::working_copy::filesystem::FileSystem::from_root(&cur),

[20.6006]

[20.25068]

working_copy: Arc::new(libpijul::working_copy::filesystem::FileSystem::from_root(
&cur,
)),
replacement in pijul/src/remote/mod.rs at line 174

[20.57008]→[20.57008:57072](∅→∅)

.dichotomy_changelist(txn, &remote.borrow().remote)

[20.57008]

[20.57072]

.dichotomy_changelist(txn, &remote.lock()?.remote)
replacement in pijul/src/remote/mod.rs at line 178

[20.57166]→[20.8344:8398](∅→∅)

.iter_remote(&remote.borrow().remote, n)?

[20.57166]

[20.8398]

.iter_remote(&remote.lock()?.remote, n)?
replacement in pijul/src/remote/mod.rs at line 542

[20.74338]→[20.9340:9404](∅→∅)

for x in txn.iter_remote(&remote.borrow().remote, 0)? {

[20.74338]

[20.7808]

for x in txn.iter_remote(&remote.lock()?.remote, 0)? {
replacement in pijul/src/remote/mod.rs at line 619

[20.76875]→[20.76875:76925](∅→∅)

let channel = local_channel.borrow();

[20.76875]

[20.2348]

let channel = local_channel.read()?;
replacement in pijul/src/remote/mod.rs at line 653

[20.78339]→[20.9673:9745](∅→∅)

for x in txn.iter_remote(&remote_changes.borrow().remote, 0)? {

[20.78339]

[20.8361]

for x in txn.iter_remote(&remote_changes.lock()?.remote, 0)? {
replacement in pijul/src/remote/local.rs at line 3

[20.11587]→[20.11587:11607](∅→∅)

use std::sync::Arc;

[20.11587]

[20.534]

use std::sync::{Arc, RwLock};
replacement in pijul/src/remote/local.rs at line 28

[20.3239]→[20.9984:10054](∅→∅)

Ok(txn.reverse_log(&channel.borrow(), None)?.next().map(|n| {

[20.3239]

[20.10054]

Ok(txn.reverse_log(&*channel.read()?, None)?.next().map(|n| {
replacement in pijul/src/remote/local.rs at line 70

[20.10533]→[20.10533:10589](∅→∅)

&remote_channel.borrow().graph,

[20.10533]

[20.10589]

&remote_channel.read()?.graph,
replacement in pijul/src/remote/local.rs at line 78

[20.4961]→[20.10701:10768](∅→∅)

for x in remote_txn.log(&remote_channel.borrow(), from)? {

[20.4961]

[20.10768]

for x in remote_txn.log(&*remote_channel.read()?, from)? {
replacement in pijul/src/remote/local.rs at line 120

[20.83228]→[20.83228:83322](∅→∅)

let mut repo = libpijul::working_copy::filesystem::FileSystem::from_root(&self.root);

[20.83228]

[20.0]

let repo = libpijul::working_copy::filesystem::FileSystem::from_root(&self.root);
replacement in pijul/src/remote/local.rs at line 122

[20.66]→[20.64:156](∅→∅)

txn.output_repository_no_pending(&mut repo, &store, &mut channel, "", true, None)?;

[20.66]

[20.83408]

let txn = Arc::new(RwLock::new(txn));
let wc = Arc::new(repo);
libpijul::output::output_repository_no_pending(
wc,
&store,
txn.clone(),
channel.clone(),
"",
true,
None,
num_cpus::get(),
)?;
let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
txn.into_inner().unwrap()
} else {
unreachable!()
};
replacement in pijul/src/main.rs at line 88

[20.102]→[20.85378:85407](∅→∅),[20.85378]→[20.85378:85407](∅→∅)

#[cfg(debug_assertions)]

[20.102]

[20.85435]

// #[cfg(debug_assertions)]
replacement in pijul/src/main.rs at line 205

[20.5246]→[20.89250:89283](∅→∅),[20.89250]→[20.89250:89283](∅→∅)

#[cfg(debug_assertions)]

[20.5246]

[20.5247]

// #[cfg(debug_assertions)]
edit in pijul/src/config.rs at line 2

[20.89898]

[20.89898]

use std::io::Write;
edit in pijul/src/config.rs at line 132

[6.1582]→[6.1582:1614](∅→∅)

use std::io::Write;
edit in pijul/src/config.rs at line 141

[20.91314]

[20.0]

pub fn save(&self, path: &std::path::Path) -> Result<(), anyhow::Error> {
let config = toml::to_string(self)?;
let mut file = std::fs::File::create(path)?;
file.write_all(config.as_bytes())?;
Ok(())
}
edit in pijul/src/commands/unrecord.rs at line 2

[20.95785]

[20.1143]

use std::sync::{Arc, RwLock};
replacement in pijul/src/commands/unrecord.rs at line 40

[20.362]→[20.119:173](∅→∅),[20.173]→[20.11721:11790](∅→∅),[20.96409]→[20.11721:11790](∅→∅),[20.11790]→[20.314:485](∅→∅),[20.314]→[20.314:485](∅→∅)

let mut txn = repo.pristine.mut_txn_begin()?;
if let Some(mut channel) = txn.load_channel(channel_name)? {
let pending_hash = if self.reset {
super::pending(&mut txn, &mut channel, &mut repo)?
} else {
None
};

[20.362]

[20.485]

let txn = repo.pristine.mut_txn_begin()?;
let channel = if let Some(channel) = txn.load_channel(channel_name)? {
channel
} else {
bail!("No such channel: {:?}", channel_name);
};
let txn = Arc::new(RwLock::new(txn));
let pending_hash = if self.reset {
super::pending(txn.clone(), &channel, &mut repo)?
} else {
None
};
let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
txn.into_inner().unwrap()
} else {
unreachable!()
};
replacement in pijul/src/commands/unrecord.rs at line 58

[20.486]→[20.0:41](∅→∅)

let mut hashes = Vec::new();

[20.486]

[20.41]

let mut hashes = Vec::new();
replacement in pijul/src/commands/unrecord.rs at line 60

[20.42]→[20.42:85](∅→∅),[20.85]→[20.1459:2257](∅→∅),[20.1459]→[20.1459:2257](∅→∅),[20.2257]→[20.86:120](∅→∅),[20.120]→[20.11791:11850](∅→∅),[20.2290]→[20.11791:11850](∅→∅),[20.11850]→[20.9091:9145](∅→∅),[20.9145]→[20.2390:2477](∅→∅),[20.11897]→[20.2390:2477](∅→∅),[20.2390]→[20.2390:2477](∅→∅),[20.2477]→[20.121:279](∅→∅),[20.279]→[20.9146:9224](∅→∅),[20.9224]→[20.349:367](∅→∅),[20.349]→[20.349:367](∅→∅)

if self.change_id.is_empty() {
// No change ids were given, present a list for choosing
// The number can be set in the global config or passed as a command-line option
let number_of_changes = if let Some(n) = self.show_changes {
n
} else {
let cfg = crate::config::Global::load()?;
cfg.unrecord_changes.ok_or_else(|| {
anyhow!(
"Can't determine how many changes to show. \
Please set the `unrecord_changes` option in \
your global config or run `pijul unrecord` \
with the `--show-changes` option."
)
})?
};
let hashes_ = txn
.reverse_log(&channel.borrow(), None)?
.map(|h| (h.unwrap().1).0.into())
.take(number_of_changes)
.collect::<Vec<_>>();
let o = make_changelist(&repo.changes, &hashes_, "unrecord")?;
for h in parse_changelist(&edit::edit_bytes(&o[..])?).iter() {
hashes.push((*h, *txn.get_internal(&h.into())?.unwrap()))
}

[20.42]

[20.2724]

if self.change_id.is_empty() {
// No change ids were given, present a list for choosing
// The number can be set in the global config or passed as a command-line option
let number_of_changes = if let Some(n) = self.show_changes {
n
replacement in pijul/src/commands/unrecord.rs at line 66

[20.2745]→[20.368:544](∅→∅)

for c in self.change_id.iter() {
let (hash, cid) = txn.hash_from_prefix(c)?;
hashes.push((hash, cid))
}

[20.2745]

[20.2776]

let cfg = crate::config::Global::load()?;
cfg.unrecord_changes.ok_or_else(|| {
anyhow!(
"Can't determine how many changes to show. \
Please set the `unrecord_changes` option in \
your global config or run `pijul unrecord` \
with the `--show-changes` option."
)
})?
replacement in pijul/src/commands/unrecord.rs at line 76

[20.2791]→[20.356:401](∅→∅),[20.356]→[20.356:401](∅→∅),[20.401]→[20.9225:9303](∅→∅),[20.9303]→[20.545:591](∅→∅),[20.2834]→[20.545:591](∅→∅),[20.591]→[20.1855:1883](∅→∅),[20.506]→[20.1855:1883](∅→∅),[20.1883]→[20.9304:9375](∅→∅),[20.70]→[20.1954:1985](∅→∅),[20.499]→[20.1954:1985](∅→∅),[20.9375]→[20.1954:1985](∅→∅),[20.1954]→[20.1954:1985](∅→∅),[20.1985]→[20.9376:9447](∅→∅)

let channel_ = channel.borrow();
let mut changes: Vec<(Hash, ChangeId, Option<u64>)> = Vec::new();
for (hash, change_id) in hashes {
let n = txn
.get_changeset(txn.changes(&channel_), &change_id)
.unwrap();
changes.push((hash, change_id, n.map(|&x| x.into())));

[20.2791]

[20.648]

let hashes_ = txn
.reverse_log(&*channel.read()?, None)?
.map(|h| (h.unwrap().1).0.into())
.take(number_of_changes)
.collect::<Vec<_>>();
let o = make_changelist(&repo.changes, &hashes_, "unrecord")?;
for h in parse_changelist(&edit::edit_bytes(&o[..])?).iter() {
hashes.push((*h, *txn.get_internal(&h.into())?.unwrap()))
}
} else {
for c in self.change_id.iter() {
let (hash, cid) = txn.hash_from_prefix(c)?;
hashes.push((hash, cid))
replacement in pijul/src/commands/unrecord.rs at line 90

[20.662]→[20.662:751](∅→∅),[20.751]→[20.645:695](∅→∅),[20.695]→[20.96673:96722](∅→∅),[20.804]→[20.96673:96722](∅→∅),[20.96673]→[20.96673:96722](∅→∅),[20.96722]→[20.9448:9504](∅→∅),[20.9504]→[20.11953:11990](∅→∅),[20.11953]→[20.11953:11990](∅→∅),[20.11990]→[20.9505:9545](∅→∅),[20.9545]→[20.96820:96854](∅→∅),[20.96820]→[20.96820:96854](∅→∅),[20.96854]→[20.9546:9593](∅→∅),[20.9593]→[20.96900:96931](∅→∅),[20.96900]→[20.96900:96931](∅→∅)

std::mem::drop(channel_);
changes.sort_by(|a, b| b.2.cmp(&a.2));
for (hash, change_id, _) in changes {
let channel_ = channel.borrow();
for p in txn.iter_revdep(&change_id)? {
let (p, d) = p?;
if p < &change_id {
continue;
} else if p > &change_id {
break;

[20.662]

[20.96931]

};
let channel_ = channel.read()?;
let mut changes: Vec<(Hash, ChangeId, Option<u64>)> = Vec::new();
for (hash, change_id) in hashes {
let n = txn
.get_changeset(txn.changes(&channel_), &change_id)
.unwrap();
changes.push((hash, change_id, n.map(|&x| x.into())));
}
std::mem::drop(channel_);
changes.sort_by(|a, b| b.2.cmp(&a.2));
for (hash, change_id, _) in changes {
let channel_ = channel.read()?;
for p in txn.iter_revdep(&change_id)? {
let (p, d) = p?;
if p < &change_id {
continue;
} else if p > &change_id {
break;
}
if txn.get_changeset(txn.changes(&channel_), d)?.is_some() {
let dep: Hash = txn.get_external(d)?.unwrap().into();
if Some(dep) == pending_hash {
bail!(
"Cannot unrecord change {} because unrecorded changes depend on it",
hash.to_base32()
);
} else {
bail!(
"Cannot unrecord change {} because {} depend on it",
hash.to_base32(),
dep.to_base32()
);
edit in pijul/src/commands/unrecord.rs at line 124

[20.96953]→[20.71:152](∅→∅),[20.152]→[20.9594:9672](∅→∅),[20.9672]→[20.551:742](∅→∅),[20.12138]→[20.551:742](∅→∅),[20.551]→[20.551:742](∅→∅),[20.742]→[20.696:745](∅→∅),[20.745]→[20.776:960](∅→∅),[20.776]→[20.776:960](∅→∅),[20.960]→[20.746:796](∅→∅),[20.796]→[20.995:1100](∅→∅),[20.995]→[20.995:1100](∅→∅),[20.1009]→[20.97363:97385](∅→∅),[20.1100]→[20.97363:97385](∅→∅),[20.2047]→[20.97363:97385](∅→∅),[20.97363]→[20.97363:97385](∅→∅)

if txn.get_changeset(txn.changes(&channel_), d)?.is_some() {
let dep: Hash = txn.get_external(d)?.unwrap().into();
if Some(dep) == pending_hash {
bail!(
"Cannot unrecord change {} because unrecorded changes depend on it",
hash.to_base32()
);
} else {
bail!(
"Cannot unrecord change {} because {} depend on it",
hash.to_base32(),
dep.to_base32()
);
}
}
edit in pijul/src/commands/unrecord.rs at line 125

[20.97403]→[20.97403:97445](∅→∅),[20.97445]→[20.1010:1077](∅→∅)

std::mem::drop(channel_);
txn.unrecord(&repo.changes, &mut channel, &hash)?;
replacement in pijul/src/commands/unrecord.rs at line 126

[20.97582]→[20.363:413](∅→∅),[20.28]→[20.1145:1308](∅→∅),[20.413]→[20.1145:1308](∅→∅),[20.1145]→[20.1145:1308](∅→∅),[20.556]→[20.1308:1358](∅→∅),[20.1308]→[20.1308:1358](∅→∅),[20.1358]→[20.38:64](∅→∅),[20.64]→[20.1358:1378](∅→∅),[20.1358]→[20.1358:1378](∅→∅)

if self.reset && is_current_channel {
txn.output_repository_no_pending(
&mut repo.working_copy,
&repo.changes,
&mut channel,
"",
true,
None,
)?;

[20.97582]

[20.29]

std::mem::drop(channel_);
txn.unrecord(&repo.changes, &channel, &hash)?;
}

let txn = Arc::new(RwLock::new(txn));
if self.reset && is_current_channel {
libpijul::output::output_repository_no_pending(
repo.working_copy.clone(),
&repo.changes,
txn.clone(),
channel.clone(),
"",
true,
None,
num_cpus::get(),
)?;
}
if let Some(h) = pending_hash {
txn.write().unwrap().unrecord(&repo.changes, &channel, &h)?;
if cfg!(feature = "keep-changes") {
repo.changes.del_change(&h)?;
edit in pijul/src/commands/unrecord.rs at line 148

[20.43]→[20.43:87](∅→∅),[20.87]→[20.1378:1442](∅→∅),[20.1378]→[20.1378:1442](∅→∅),[20.1442]→[20.0:120](∅→∅),[20.120]→[20.1488:1502](∅→∅),[20.1488]→[20.1488:1502](∅→∅)

if let Some(h) = pending_hash {
txn.unrecord(&repo.changes, &mut channel, &h)?;
if cfg!(feature = "keep-changes") {
repo.changes.del_change(&h)?;
}
}
edit in pijul/src/commands/unrecord.rs at line 149

[20.97592]

[20.97592]

let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
txn.into_inner().unwrap()
} else {
unreachable!()
};
edit in pijul/src/commands/reset.rs at line 3

[20.1313]

[20.1313]

use std::sync::{Arc, RwLock};
replacement in pijul/src/commands/reset.rs at line 9

[20.62]→[20.89:164](∅→∅),[20.89]→[20.89:164](∅→∅),[20.164]→[20.1331:1347](∅→∅),[20.2100]→[20.1331:1347](∅→∅),[20.97774]→[20.1331:1347](∅→∅)

use libpijul::{ChannelTxnT, DepsTxnT, MutTxnT, MutTxnTExt, TxnT, TxnTExt};
use log::debug;

[20.62]

[20.1347]

use libpijul::{ChannelTxnT, DepsTxnT, MutTxnT, TxnT, TxnTExt};
use log::*;
replacement in pijul/src/commands/reset.rs at line 41

[20.98218]→[20.6094:6163](∅→∅),[20.6163]→[20.174:228](∅→∅),[20.228]→[20.414:504](∅→∅),[20.98334]→[20.414:504](∅→∅)

let mut repo = Repository::find_root(self.repo_path).await?;
let mut txn = repo.pristine.mut_txn_begin()?;
let (channel_name, _) = repo.config.get_current_channel(self.channel.as_deref());

[20.98218]

[20.39]

let repo = Repository::find_root(self.repo_path).await?;
let txn = repo.pristine.mut_txn_begin()?;

let config_path = repo.config_path();
let mut config = repo.config;
let (channel_name, _) = config.get_current_channel(self.channel.as_deref());
replacement in pijul/src/commands/reset.rs at line 48

[20.108]→[20.12139:12223](∅→∅)

let mut channel = if let Some(channel) = txn.load_channel(&channel_name)? {

[20.108]

[20.98538]

let channel = if let Some(channel) = txn.load_channel(&channel_name)? {
edit in pijul/src/commands/reset.rs at line 53

[20.98818]

[20.98818]
replacement in pijul/src/commands/reset.rs at line 69

[20.99409]→[20.99409:99438](∅→∅)

txn.output_file(

[20.99409]

[20.99438]

libpijul::output::output_file(
replacement in pijul/src/commands/reset.rs at line 71

[20.99469]→[20.99469:99495](∅→∅)

&channel,

[20.99469]

[20.99495]

&txn,
&channel.read().unwrap(),
replacement in pijul/src/commands/reset.rs at line 76

[20.99610]→[20.99610:99627](∅→∅),[20.99627]→[20.505:583](∅→∅),[20.583]→[20.538:604](∅→∅),[20.99700]→[20.538:604](∅→∅),[20.604]→[20.63:138](∅→∅),[20.138]→[20.869:887](∅→∅),[20.545]→[20.869:887](∅→∅),[20.2136]→[20.869:887](∅→∅),[20.869]→[20.869:887](∅→∅),[20.577]→[20.887:934](∅→∅),[20.887]→[20.887:934](∅→∅),[20.934]→[15.0:141](∅→∅)

} else {
let (current_channel, _) = repo.config.get_current_channel(None);
if self.channel.as_deref() == Some(current_channel) {
if !overwrite_changes {
return Ok(());
}
} else if self.channel.is_some() {
if !self.files.is_empty() {
bail!("Cannot use --channel with individual paths. Did you mean --dry-run?")

[20.99610]

[15.141]

return Ok(());
}

let txn = Arc::new(RwLock::new(txn));

let (current_channel, _) = config.get_current_channel(None);
if self.channel.as_deref() == Some(current_channel) {
if !overwrite_changes {
return Ok(());
}
} else if self.channel.is_some() {
if !self.files.is_empty() {
bail!("Cannot use --channel with individual paths. Did you mean --dry-run?")
}
let channel = {
let txn = txn.read().unwrap();
txn.load_channel(current_channel)?
};
if let Some(channel) = channel {
let mut state = libpijul::RecordBuilder::new();
state.record(
txn.clone(),
libpijul::Algorithm::default(),
channel.clone(),
repo.working_copy.clone(),
&repo.changes,
"",
num_cpus::get(),
)?;
let rec = state.finish();
debug!("actions = {:?}", rec.actions);
if !rec.actions.is_empty() {
bail!("Cannot change channel, as there are unrecorded changes.")
edit in pijul/src/commands/reset.rs at line 110

[15.159]→[20.12282:12362](∅→∅),[20.934]→[20.12282:12362](∅→∅),[20.12362]→[20.99917:100440](∅→∅),[20.99917]→[20.99917:100440](∅→∅),[20.100440]→[20.12363:12452](∅→∅),[20.12452]→[20.100509:100549](∅→∅),[20.100509]→[20.100509:100549](∅→∅)

if let Some(mut channel) = txn.load_channel(current_channel)? {
let mut state = libpijul::RecordBuilder::new();
txn.record(
&mut state,
libpijul::Algorithm::default(),
&mut channel,
&mut repo.working_copy,
&repo.changes,
"",
)?;
let rec = state.finish();
debug!("actions = {:?}", rec.actions);
if !rec.actions.is_empty() {
bail!("Cannot change channel, as there are unrecorded changes.")
}
}
edit in pijul/src/commands/reset.rs at line 111

[20.100715]

[20.100715]

}
replacement in pijul/src/commands/reset.rs at line 113

[20.100716]→[20.6510:6559](∅→∅),[20.6559]→[20.100907:100946](∅→∅),[20.100907]→[20.100907:100946](∅→∅),[20.100946]→[20.139:494](∅→∅),[20.539]→[20.539:773](∅→∅),[20.6211]→[20.773:826](∅→∅),[20.773]→[20.773:826](∅→∅),[20.826]→[20.578:1226](∅→∅),[20.100946]→[20.578:1226](∅→∅)

let now = std::time::Instant::now();
if self.files.is_empty() {
if self.channel.is_none() || self.channel.as_deref() == Some(current_channel) {
let last_modified = last_modified(&txn, &channel.borrow());
txn.output_repository_no_pending(
&mut repo.working_copy,
&repo.changes,
&mut channel,
"",
true,
Some(last_modified),
)?;
txn.touch_channel(&mut channel.borrow_mut(), None);
txn.commit()?;
return Ok(());
}
let mut inodes = HashSet::new();
if let Some(cur) = txn.load_channel(current_channel)? {
let mut changediff = HashSet::new();
let (a, b, s) = libpijul::pristine::last_common_state(
&txn,
&cur.borrow(),
&channel.borrow(),
)?;
debug!("last common state {:?}", s);
changes_after(&txn, &cur.borrow(), a, &mut changediff, &mut inodes)?;
changes_after(&txn, &channel.borrow(), b, &mut changediff, &mut inodes)?;
}

[20.100716]

[20.1226]

let now = std::time::Instant::now();
if self.files.is_empty() {
if self.channel.is_none() || self.channel.as_deref() == Some(current_channel) {
let last_modified = last_modified(&*txn.read().unwrap(), &*channel.read()?);
libpijul::output::output_repository_no_pending(
repo.working_copy.clone(),
&repo.changes,
txn.clone(),
channel.clone(),
"",
true,
Some(last_modified),
num_cpus::get(),
)?;
let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
txn.into_inner().unwrap()
} else {
unreachable!()
};
txn.touch_channel(&mut *channel.write()?, None);
txn.commit()?;
return Ok(());
}
let mut inodes = HashSet::new();
let txn_ = txn.read().unwrap();
if let Some(cur) = txn_.load_channel(current_channel)? {
let mut changediff = HashSet::new();
let (a, b, s) = libpijul::pristine::last_common_state(
&*txn_,
&*cur.read()?,
&*channel.read()?,
)?;
debug!("last common state {:?}", s);
changes_after(&*txn_, &*cur.read()?, a, &mut changediff, &mut inodes)?;
changes_after(&*txn_, &*channel.read()?, b, &mut changediff, &mut inodes)?;
}
replacement in pijul/src/commands/reset.rs at line 150

[20.1227]→[20.1227:1376](∅→∅)

if self.channel.is_some() {
repo.config.current_channel = self.channel;
repo.save_config()?;

[20.1227]

[20.1376]

if self.channel.is_some() {
config.current_channel = self.channel;
config.save(&config_path)?;
}
let mut paths = Vec::with_capacity(inodes.len());
for pos in inodes.iter() {
if let Some((path, _)) =
libpijul::fs::find_path(&repo.changes, &*txn_, &*channel.read()?, false, *pos)?
{
paths.push(path)
} else {
paths.clear();
break;
replacement in pijul/src/commands/reset.rs at line 164

[20.1394]→[20.0:66](∅→∅),[20.66]→[20.1395:1438](∅→∅),[20.1395]→[20.1395:1438](∅→∅),[20.1438]→[20.67:137](∅→∅),[20.137]→[20.1499:1672](∅→∅),[20.1499]→[20.1499:1672](∅→∅),[20.1672]→[20.138:343](∅→∅),[20.343]→[16.4180:4442](∅→∅),[16.4442]→[20.343:386](∅→∅),[20.343]→[20.343:386](∅→∅),[20.386]→[20.1696:1927](∅→∅),[20.1696]→[20.1696:1927](∅→∅),[20.1972]→[20.1972:2033](∅→∅),[20.2033]→[20.192:222](∅→∅),[20.222]→[20.2033:2075](∅→∅),[20.2033]→[20.2033:2075](∅→∅),[20.2075]→[20.387:734](∅→∅),[20.734]→[16.4443:4476](∅→∅),[20.734]→[20.101179:101200](∅→∅),[20.2075]→[20.101179:101200](∅→∅),[16.4476]→[20.101179:101200](∅→∅),[20.101179]→[20.101179:101200](∅→∅),[20.101200]→[16.4477:4739](∅→∅),[20.678]→[20.101200:101310](∅→∅),[16.4739]→[20.101200:101310](∅→∅),[20.101200]→[20.101200:101310](∅→∅),[20.101310]→[20.265:346](∅→∅),[20.346]→[20.101391:101570](∅→∅),[20.101391]→[20.101391:101570](∅→∅),[20.714]→[20.101570:101631](∅→∅),[20.101570]→[20.101570:101631](∅→∅),[20.101631]→[20.223:253](∅→∅),[20.253]→[20.101631:101673](∅→∅),[20.101631]→[20.101631:101673](∅→∅),[20.101673]→[16.4740:4773](∅→∅)

let mut paths = Vec::with_capacity(inodes.len());
for pos in inodes.iter() {
if let Some((path, _)) = libpijul::fs::find_path(
&repo.changes,
&txn,
&channel.borrow(),
false,
*pos,
)? {
paths.push(path)
} else {
paths.clear();
break;
}
}
PROGRESS
.borrow_mut()
.unwrap()
.push(crate::progress::Cursor::Spin {
i: 0,
pre: "Outputting repository".into(),
});
for path in paths.iter() {
debug!("resetting {:?}", path);
txn.output_repository_no_pending(
&mut repo.working_copy,
&repo.changes,
&mut channel,
&path,
true,
None,
)?;
}
if paths.is_empty() {
txn.output_repository_no_pending(
&mut repo.working_copy,
&repo.changes,
&mut channel,
"",
true,
None,
)?;
}
PROGRESS.join();
} else {
PROGRESS
.borrow_mut()
.unwrap()
.push(crate::progress::Cursor::Spin {
i: 0,
pre: "Outputting repository".into(),
});
for root in self.files.iter() {
let root = std::fs::canonicalize(&root)?;
let path = root.strip_prefix(&repo_path)?.to_str().unwrap();
txn.output_repository_no_pending(
&mut repo.working_copy,
&repo.changes,
&mut channel,
&path,
true,
None,
)?;
}
PROGRESS.join();

[20.1394]

[20.101673]

}
PROGRESS
.borrow_mut()
.unwrap()
.push(crate::progress::Cursor::Spin {
i: 0,
pre: "Outputting repository".into(),
});
std::mem::drop(txn_);
for path in paths.iter() {
debug!("resetting {:?}", path);
libpijul::output::output_repository_no_pending(
repo.working_copy.clone(),
&repo.changes,
txn.clone(),
channel.clone(),
&path,
true,
None,
num_cpus::get(),
)?;
}
if paths.is_empty() {
libpijul::output::output_repository_no_pending(
repo.working_copy,
&repo.changes,
txn.clone(),
channel,
"",
true,
None,
num_cpus::get(),
)?;
}
PROGRESS.join();
} else {
PROGRESS
.borrow_mut()
.unwrap()
.push(crate::progress::Cursor::Spin {
i: 0,
pre: "Outputting repository".into(),
});
for root in self.files.iter() {
let root = std::fs::canonicalize(&root)?;
let path = root.strip_prefix(&repo_path)?.to_str().unwrap();
libpijul::output::output_repository_no_pending(
repo.working_copy.clone(),
&repo.changes,
txn.clone(),
channel.clone(),
&path,
true,
None,
num_cpus::get(),
)?;
replacement in pijul/src/commands/reset.rs at line 221

[20.101687]→[20.6560:6587](∅→∅),[20.6251]→[20.6587:6636](∅→∅),[20.6587]→[20.6587:6636](∅→∅)

txn.commit()?;
debug!("now = {:?}", now.elapsed());

[20.101687]

[20.101713]

PROGRESS.join();
edit in pijul/src/commands/reset.rs at line 223

[20.101723]

[20.6637]

let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
txn.into_inner().unwrap()
} else {
unreachable!()
};
txn.commit()?;
debug!("now = {:?}", now.elapsed());
replacement in pijul/src/commands/reset.rs at line 231

[20.6691]→[20.6691:6707](∅→∅)

debug!(

[20.6691]

[20.6707]

info!(
edit in pijul/src/commands/record.rs at line 1

[20.101759]→[20.64:106](∅→∅)

use std::collections::{HashMap, HashSet};
edit in pijul/src/commands/record.rs at line 3

[20.24]

[20.1485]

use std::sync::{Arc, RwLock};
replacement in pijul/src/commands/record.rs at line 11

[20.101876]→[20.0:40](∅→∅),[20.40]→[20.107:192](∅→∅)

use libpijul::pristine::ChannelMutTxnT;
use libpijul::{Base32, ChannelRef, ChannelTxnT, MutTxnT, MutTxnTExt, TxnT, TxnTExt};

[20.101876]

[20.1504]

use libpijul::{
Base32, ChannelMutTxnT, ChannelRef, ChannelTxnT, MutTxnT, MutTxnTExt, TxnT, TxnTExt,
};
use libpijul::{HashMap, HashSet};
replacement in pijul/src/commands/record.rs at line 59

[20.102832]→[20.6252:6329](∅→∅)

let mut repo = Repository::find_root(self.repo_path.clone()).await?;

[20.102832]

[20.102903]

let repo = Repository::find_root(self.repo_path.clone()).await?;
replacement in pijul/src/commands/record.rs at line 79

[20.357]→[20.10065:10133](∅→∅)

.get_changeset(txn.changes(&channel.borrow()), &c)?

[20.357]

[20.424]

.get_changeset(txn.changes(&*channel.read()?), &c)?
replacement in pijul/src/commands/record.rs at line 85

[20.590]→[20.590:632](∅→∅)

channel.borrow().name

[20.590]

[20.632]

channel.read().unwrap().name
replacement in pijul/src/commands/record.rs at line 94

[20.174]→[20.12472:12559](∅→∅)

} else if let Some(h) = txn.reverse_log(&channel.borrow(), None)?.next() {

[20.174]

[20.10134]

} else if let Some(h) = txn.reverse_log(&*channel.read()?, None)?.next() {
replacement in pijul/src/commands/record.rs at line 115

[7.355]→[7.355:440](∅→∅)

let (repo_path, mut working_copy) = if let Some(ref w) = self.working_copy {

[7.355]

[7.440]

let (repo_path, working_copy) = if let Some(ref w) = self.working_copy {
replacement in pijul/src/commands/record.rs at line 118

[7.506]→[7.506:590](∅→∅)

Some(libpijul::working_copy::filesystem::FileSystem::from_root(w)),

[7.506]

[7.590]

Some(Arc::new(
libpijul::working_copy::filesystem::FileSystem::from_root(w),
)),
edit in pijul/src/commands/record.rs at line 125

[7.696]

[20.104054]

let txn = Arc::new(RwLock::new(txn));
replacement in pijul/src/commands/record.rs at line 128

[14.17]→[20.104110:104136](∅→∅),[20.104110]→[20.104110:104136](∅→∅),[20.104136]→[7.697:766](∅→∅)

&mut channel,
working_copy.as_mut().unwrap_or(&mut repo.working_copy),

[14.17]

[20.104172]

channel.clone(),
working_copy.clone().unwrap_or(repo.working_copy.clone()),
replacement in pijul/src/commands/record.rs at line 135

[20.104255]→[14.18:95](∅→∅)

if let Some((mut txn, mut change, updates, hash, oldest)) = result {

[20.104255]

[20.104315]

if let Some((txn, mut change, updates, hash, oldest)) = result {
edit in pijul/src/commands/record.rs at line 157

[20.105115]

[20.10252]

let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
txn.into_inner().unwrap()
} else {
unreachable!()
};
replacement in pijul/src/commands/record.rs at line 180

[18.699]→[20.82:158](∅→∅),[20.82]→[20.82:158](∅→∅)

txn.touch_channel(&mut channel.borrow_mut(), Some(oldest));

[18.699]

[20.158]

txn.touch_channel(&mut *channel.write()?, Some(oldest));
replacement in pijul/src/commands/record.rs at line 223

[20.106435]→[20.2210:2266](∅→∅)

fn record<T: TxnTExt + MutTxnTExt, C: ChangeStore>(

[20.106435]

[20.106498]

fn record<
T: TxnTExt + MutTxnTExt + Sync + Send + 'static,
C: ChangeStore + Send + Clone + 'static,
>(
replacement in pijul/src/commands/record.rs at line 228

[20.106516]→[14.96:116](∅→∅),[14.116]→[20.106537:106637](∅→∅),[20.106537]→[20.106537:106637](∅→∅)

mut txn: T,
channel: &mut ChannelRef<T>,
working_copy: &mut libpijul::working_copy::FileSystem,

[20.106516]

[20.106637]

txn: Arc<RwLock<T>>,
channel: ChannelRef<T>,
working_copy: Arc<libpijul::working_copy::FileSystem>,
replacement in pijul/src/commands/record.rs at line 237

[20.106748]→[14.117:132](∅→∅)

T,

[20.106748]

[20.106748]

Arc<RwLock<T>>,
replacement in pijul/src/commands/record.rs at line 256

[7.1193]→[7.1193:1269](∅→∅)

txn.record(
&mut state,

[7.1193]

[7.1269]

state.record(
txn.clone(),
replacement in pijul/src/commands/record.rs at line 259

[7.1329]→[7.1329:1408](∅→∅)

channel,
working_copy,

[7.1329]

[7.1408]

channel.clone(),
working_copy.clone(),
edit in pijul/src/commands/record.rs at line 263

[7.1494]

[7.1494]

num_cpus::get(),
replacement in pijul/src/commands/record.rs at line 268

[7.1582]→[7.1582:1642](∅→∅)

txn.record(
&mut state,

[7.1582]

[7.1642]

state.record(
txn.clone(),
replacement in pijul/src/commands/record.rs at line 271

[7.1694]→[7.1694:1757](∅→∅)

channel,
working_copy,

[7.1694]

[7.1757]

channel.clone(),
working_copy.clone(),
edit in pijul/src/commands/record.rs at line 275

[7.1810]

[7.1810]

num_cpus::get(),
replacement in pijul/src/commands/record.rs at line 281

[20.107320]→[14.133:159](∅→∅),[14.159]→[20.107341:107366](∅→∅),[20.107341]→[20.107341:107366](∅→∅)

&mut txn,
channel,

[20.107320]

[20.107366]

txn.clone(),
channel.clone(),
edit in pijul/src/commands/record.rs at line 290

[20.107504]

[20.107504]
replacement in pijul/src/commands/record.rs at line 293

[20.107578]→[14.160:224](∅→∅)

txn.touch_channel(&mut channel.borrow_mut(), None);

[20.107578]

[14.224]

let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
txn.into_inner().unwrap()
} else {
unreachable!()
};
txn.touch_channel(&mut *channel.write()?, None);
edit in pijul/src/commands/record.rs at line 302

[20.107617]

[20.107617]

debug!("TAKING LOCK {}", line!());
let txn_ = txn.write().unwrap();
replacement in pijul/src/commands/record.rs at line 307

[20.107689]→[14.252:305](∅→∅)

.map(|rec| rec.globalize(&txn).unwrap())

[20.107689]

[20.107732]

.map(|rec| rec.globalize(&*txn_).unwrap())
edit in pijul/src/commands/record.rs at line 309

[20.107756]

[20.762]

let contents = if let Ok(c) = Arc::try_unwrap(rec.contents) {
c.into_inner().unwrap()
} else {
unreachable!()
};
replacement in pijul/src/commands/record.rs at line 315

[20.787]→[14.306:403](∅→∅)

LocalChange::make_change(&txn, channel, actions, rec.contents, header, Vec::new())?;

[20.787]

[20.788]

LocalChange::make_change(&*txn_, &channel, actions, contents, header, Vec::new())?;
replacement in pijul/src/commands/record.rs at line 346

[20.108852]→[14.404:495](∅→∅)

Change::read_and_deps(&mut change, &mut rec.updatables, &txn, channel)

[20.108852]

[20.108942]

Change::read_and_deps(&mut change, &mut rec.updatables, &*txn_, &channel)
edit in pijul/src/commands/record.rs at line 374

[20.109803]

[20.750]

std::mem::drop(txn_);
edit in pijul/src/commands/pushpull.rs at line 4

[20.1695]

[20.1695]

use std::sync::{Arc, RwLock};
replacement in pijul/src/commands/pushpull.rs at line 170

[20.12983]→[20.12983:13071](∅→∅)

libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?

[20.12983]

[20.13071]

libpijul::fs::iter_graph_descendants(&txn, &channel.read()?.graph, p)?
replacement in pijul/src/commands/pushpull.rs at line 176

[20.10513]→[20.13129:13190](∅→∅),[20.116268]→[20.13129:13190](∅→∅)

for x in txn.reverse_log(&channel.borrow(), None)? {

[20.10513]

[20.13190]

for x in txn.reverse_log(&*channel.read()?, None)? {
replacement in pijul/src/commands/pushpull.rs at line 197

[20.13572]→[20.5206:5258](∅→∅),[20.5206]→[20.5206:5258](∅→∅)

let channel = channel.borrow();

[20.13572]

[20.13573]

let channel = channel.read()?;
replacement in pijul/src/commands/pushpull.rs at line 314

[20.8812]→[20.13810:13890](∅→∅)

for x in txn.iter_remote(&remote_changes.borrow().remote, 0)? {

[20.8812]

[20.11155]

for x in txn.iter_remote(&remote_changes.lock()?.remote, 0)? {
replacement in pijul/src/commands/pushpull.rs at line 317

[20.27]→[20.11200:11281](∅→∅)

.channel_has_state(txn.states(&channel.borrow()), &p.b)?

[20.27]

[20.105]

.channel_has_state(txn.states(&*channel.read()?), &p.b)?
replacement in pijul/src/commands/pushpull.rs at line 334

[20.14103]→[20.14103:14199](∅→∅)

libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?

[20.14103]

[20.14199]

libpijul::fs::iter_graph_descendants(&txn, &channel.read()?.graph, p)?
replacement in pijul/src/commands/pushpull.rs at line 343

[20.14430]→[20.7193:7259](∅→∅),[20.7193]→[20.7193:7259](∅→∅)

let remote_channel = remote_channel.borrow();

[20.14430]

[20.14431]

let remote_channel = remote_channel.read()?;
replacement in pijul/src/commands/pushpull.rs at line 347

[20.194]→[20.11504:11587](∅→∅)

.channel_has_state(txn.states(&channel.borrow()), &m)?

[20.194]

[20.276]

.channel_has_state(txn.states(&*channel.read()?), &m)?
replacement in pijul/src/commands/pushpull.rs at line 354

[20.7561]→[20.429:512](∅→∅)

.get_changeset(txn.changes(&channel.borrow()), h_int)?

[20.7561]

[20.7644]

.get_changeset(txn.changes(&*channel.read()?), h_int)?
replacement in pijul/src/commands/pushpull.rs at line 380

[20.9828]→[20.9828:9899](∅→∅)

let hash = super::pending(&mut txn, &mut channel, &mut repo)?;

[20.9828]

[20.0]

let txn = Arc::new(RwLock::new(txn));
let hash = super::pending(txn.clone(), &mut channel, &mut repo)?;
let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
txn.into_inner().unwrap()
} else {
unreachable!()
};
replacement in pijul/src/commands/pushpull.rs at line 451

[20.1432]→[20.1432:1479](∅→∅)

touched.insert(inode);

[20.1432]

[20.1479]

touched.insert(*inode);
edit in pijul/src/commands/pushpull.rs at line 456

[20.1543]

[20.847]

let txn = Arc::new(RwLock::new(txn));
replacement in pijul/src/commands/pushpull.rs at line 460

[20.974]→[20.974:1129](∅→∅)

if let Some((path, _)) =
libpijul::fs::find_path(&repo.changes, &txn, &channel.borrow(), false, *i)?
{

[20.974]

[20.1129]

if let Some((path, _)) = libpijul::fs::find_path(
&repo.changes,
&*txn.read().unwrap(),
&*channel.read()?,
false,
i,
)? {
edit in pijul/src/commands/pushpull.rs at line 482

[16.5040]

[20.1366]

let mut conflicts = Vec::new();
replacement in pijul/src/commands/pushpull.rs at line 488

[20.1570]→[20.1570:1831](∅→∅)

txn.output_repository_no_pending(
&mut repo.working_copy,
&repo.changes,
&mut channel,
path,
true,
None,
)?;

[20.1570]

[20.1831]

conflicts.extend(
libpijul::output::output_repository_no_pending(
repo.working_copy.clone(),
&repo.changes,
txn.clone(),
channel.clone(),
path,
true,
None,
num_cpus::get(),
)?
.into_iter(),
);
replacement in pijul/src/commands/pushpull.rs at line 504

[20.1902]→[20.1902:2161](∅→∅)

txn.output_repository_no_pending(
&mut repo.working_copy,
&repo.changes,
&mut channel,
"",
true,
None,
)?;

[20.1902]

[20.665]

conflicts.extend(
libpijul::output::output_repository_no_pending(
repo.working_copy.clone(),
&repo.changes,
txn.clone(),
channel.clone(),
"",
true,
None,
num_cpus::get(),
)?
.into_iter(),
);
edit in pijul/src/commands/pushpull.rs at line 520

[20.11136]

[20.120956]

let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
txn.into_inner().unwrap()
} else {
unreachable!()
};
edit in pijul/src/commands/protocol.rs at line 5

[20.1913]

[20.1913]

use std::sync::{Arc, RwLock};
replacement in pijul/src/commands/protocol.rs at line 73

[20.125737]→[20.15338:15402](∅→∅)

for x in txn.log(&channel.borrow(), pos)? {

[20.125737]

[20.15402]

for x in txn.log(&*channel.read()?, pos)? {
replacement in pijul/src/commands/protocol.rs at line 88

[20.126196]→[20.15449:15540](∅→∅)

} else if let Some(x) = txn.reverse_log(&channel.borrow(), None)?.next() {

[20.126196]

[20.15540]

} else if let Some(x) = txn.reverse_log(&*channel.read()?, None)?.next() {
replacement in pijul/src/commands/protocol.rs at line 112

[20.15745]→[20.15745:15845](∅→∅)

libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?

[20.15745]

[20.15845]

libpijul::fs::iter_graph_descendants(&txn, &channel.read()?.graph, p)?
replacement in pijul/src/commands/protocol.rs at line 121

[20.11929]→[20.16036:16097](∅→∅)

for x in txn.log(&channel.borrow(), from)? {

[20.11929]

[20.16097]

for x in txn.log(&*channel.read()?, from)? {
replacement in pijul/src/commands/protocol.rs at line 201

[20.131779]→[20.16677:16769](∅→∅)

if txn.current_state(&channel.borrow())? == state && extra.is_empty() {

[20.131779]

[20.131876]

if txn.current_state(&*channel.read()?)? == state && extra.is_empty() {
replacement in pijul/src/commands/protocol.rs at line 236

[20.133262]→[20.133262:133390](∅→∅)

for (_, mut channel) in applied {
txn.output_repository_no_pending(
&mut repo.working_copy,

[20.133262]

[20.133390]

let txn = Arc::new(RwLock::new(txn));
for (_, channel) in applied {
libpijul::output::output_repository_no_pending(
repo.working_copy.clone(),
replacement in pijul/src/commands/protocol.rs at line 241

[20.133421]→[20.133421:133451](∅→∅)

&mut channel,

[20.133421]

[20.133451]

txn.clone(),
channel.clone(),
edit in pijul/src/commands/protocol.rs at line 246

[20.490]

[20.133493]

num_cpus::get(),
edit in pijul/src/commands/protocol.rs at line 250

[20.133549]

[20.133549]

let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
txn.into_inner().unwrap()
} else {
unreachable!()
};
replacement in pijul/src/commands/mod.rs at line 57

[20.91]→[20.134253:134278](∅→∅),[20.134253]→[20.134253:134278](∅→∅)

#[cfg(debug_assertions)]

[20.91]

[20.134278]

// #[cfg(debug_assertions)]
replacement in pijul/src/commands/mod.rs at line 59

[20.134289]→[20.134289:134314](∅→∅)

#[cfg(debug_assertions)]

[20.134289]

[20.134314]

// #[cfg(debug_assertions)]
replacement in pijul/src/commands/mod.rs at line 64

[20.1687]→[20.1687:1801](∅→∅)

fn pending<T: libpijul::MutTxnTExt + libpijul::TxnT>(
txn: &mut T,
channel: &mut libpijul::ChannelRef<T>,

[20.1687]

[20.1801]

fn pending<T: libpijul::MutTxnTExt + libpijul::TxnT + Send + Sync + 'static>(
txn: std::sync::Arc<std::sync::RwLock<T>>,
channel: &libpijul::ChannelRef<T>,
replacement in pijul/src/commands/mod.rs at line 70

[20.1944]→[20.1944:1979](∅→∅)

let recorded = txn.record_all(

[20.1944]

[20.1979]

let mut builder = libpijul::record::Builder::new();
builder.record(
txn.clone(),
replacement in pijul/src/commands/mod.rs at line 75

[20.2019]→[20.2019:2068](∅→∅)

channel,
&mut repo.working_copy,

[20.2019]

[20.2068]

channel.clone(),
repo.working_copy.clone(),
edit in pijul/src/commands/mod.rs at line 79

[20.2103]

[20.2103]

num_cpus::get(),
edit in pijul/src/commands/mod.rs at line 81

[20.2111]

[20.2111]

let recorded = builder.finish();
edit in pijul/src/commands/mod.rs at line 85

[20.2179]

[20.2179]

let mut txn = txn.write().unwrap();
replacement in pijul/src/commands/mod.rs at line 89

[20.2244]→[20.16770:16818](∅→∅)

.map(|rec| rec.globalize(txn).unwrap())

[20.2244]

[20.2283]

.map(|rec| rec.globalize(&*txn).unwrap())
edit in pijul/src/commands/mod.rs at line 91

[20.2303]

[20.2303]

let contents = if let Ok(c) = std::sync::Arc::try_unwrap(recorded.contents) {
c.into_inner().unwrap()
} else {
unreachable!()
};
replacement in pijul/src/commands/mod.rs at line 97

[20.2371]→[20.2371:2384](∅→∅)

txn,

[20.2371]

[20.2384]

&*txn,
replacement in pijul/src/commands/mod.rs at line 100

[20.2418]→[20.2418:2445](∅→∅)

recorded.contents,

[20.2418]

[20.2445]

contents,
replacement in pijul/src/commands/mod.rs at line 105

[20.2561]→[20.16828:16924](∅→∅)

libpijul::change::dependencies(txn, &channel.borrow(), pending_change.changes.iter())?;

[20.2561]

[20.2646]

libpijul::change::dependencies(&*txn, &*channel.read()?, pending_change.changes.iter())?;
replacement in pijul/src/commands/log.rs at line 44

[20.135542]→[20.17082:17147](∅→∅)

for h in txn.reverse_log(&channel.borrow(), None)? {

[20.135542]

[20.12912]

for h in txn.reverse_log(&*channel.read()?, None)? {
replacement in pijul/src/commands/log.rs at line 50

[20.135743]→[20.17182:17247](∅→∅)

for h in txn.reverse_log(&channel.borrow(), None)? {

[20.135743]

[20.17247]

for h in txn.reverse_log(&*channel.read()?, None)? {
edit in pijul/src/commands/file_operations.rs at line 3

[19.32]

[20.2404]

use std::sync::{Arc, RwLock};
replacement in pijul/src/commands/file_operations.rs at line 124

[20.13499]→[20.677:731](∅→∅)

let mut txn = repo.pristine.mut_txn_begin()?;

[20.13499]

[20.192]

let txn = repo.pristine.mut_txn_begin()?;
edit in pijul/src/commands/file_operations.rs at line 128

[20.44]

[20.171551]

let txn = Arc::new(RwLock::new(txn));
replacement in pijul/src/commands/file_operations.rs at line 148

[20.861]→[20.861:895](∅→∅)

&mut txn,

[20.861]

[20.895]

txn.clone(),
edit in pijul/src/commands/file_operations.rs at line 156

[20.172105]

[20.562]

let mut txn = txn.write().unwrap();
replacement in pijul/src/commands/file_operations.rs at line 170

[20.172416]→[20.172416:172439](∅→∅)

txn.commit()?;

[20.172416]

[20.172439]

if let Ok(txn) = Arc::try_unwrap(txn) {
txn.into_inner().unwrap().commit()?;
} else {
unreachable!()
}
edit in pijul/src/commands/diff.rs at line 4

[20.173738]

[20.2553]

use std::sync::{Arc, RwLock};
replacement in pijul/src/commands/diff.rs at line 9

[20.2595]→[20.4174:4211](∅→∅)

use libpijul::{MutTxnT, MutTxnTExt};

[20.2595]

[20.2654]

use libpijul::MutTxnT;
replacement in pijul/src/commands/diff.rs at line 37

[20.15461]→[20.15461:15538](∅→∅)

let mut repo = Repository::find_root(self.repo_path.clone()).await?;

[20.15461]

[20.787]

let repo = Repository::find_root(self.repo_path.clone()).await?;
replacement in pijul/src/commands/diff.rs at line 40

[20.174275]→[20.174275:174301](∅→∅)

let mut channel =

[20.174275]

[20.2348]

let channel =
edit in pijul/src/commands/diff.rs at line 44

[20.174455]

[20.174455]

let txn = Arc::new(RwLock::new(txn));
replacement in pijul/src/commands/diff.rs at line 46

[20.174493]→[20.174493:174545](∅→∅)

txn.record(
&mut state,

[20.174493]

[20.174545]

state.record(
txn.clone(),
replacement in pijul/src/commands/diff.rs at line 49

[20.174593]→[20.174593:174663](∅→∅)

&mut channel,
&mut repo.working_copy,

[20.174593]

[20.174663]

channel.clone(),
repo.working_copy.clone(),
edit in pijul/src/commands/diff.rs at line 53

[20.174714]

[20.174714]

num_cpus::get(),
replacement in pijul/src/commands/diff.rs at line 58

[20.174837]→[20.174837:174893](∅→∅)

&mut txn,
&mut channel,

[20.174837]

[20.174893]

txn.clone(),
channel.clone(),
edit in pijul/src/commands/diff.rs at line 71

[20.175145]

[20.175145]

let txn = txn.write().unwrap();
replacement in pijul/src/commands/diff.rs at line 75

[20.175217]→[20.17520:17573](∅→∅)

.map(|rec| rec.globalize(&txn).unwrap())

[20.175217]

[20.175261]

.map(|rec| rec.globalize(&*txn).unwrap())
edit in pijul/src/commands/diff.rs at line 77

[20.175285]

[20.175285]

let contents = if let Ok(cont) = std::sync::Arc::try_unwrap(rec.contents) {
cont.into_inner().unwrap()
} else {
unreachable!()
};
replacement in pijul/src/commands/diff.rs at line 83

[20.175336]→[20.175336:175354](∅→∅)

&txn,

[20.175336]

[20.175354]

&*txn,
replacement in pijul/src/commands/diff.rs at line 86

[20.175397]→[20.175397:175423](∅→∅)

rec.contents,

[20.175397]

[20.175423]

contents,
replacement in pijul/src/commands/diff.rs at line 92

[20.175552]→[20.17587:17634](∅→∅)

full_dependencies(&txn, &channel)?

[20.175552]

[20.175598]

full_dependencies(&*txn, &channel)?
replacement in pijul/src/commands/diff.rs at line 94

[20.175615]→[20.17635:17709](∅→∅)

dependencies(&txn, &channel.borrow(), change.changes.iter())?

[20.175615]

[20.175679]

dependencies(&*txn, &*channel.read()?, change.changes.iter())?
replacement in pijul/src/commands/diff.rs at line 163

[20.177037]→[20.177037:177063](∅→∅)

change.write(

[20.177037]

[20.177063]

match change.write(
replacement in pijul/src/commands/diff.rs at line 174

[20.466]→[20.177323:177338](∅→∅),[20.177323]→[20.177323:177338](∅→∅)

)?

[20.466]

[20.177338]

) {
Ok(()) => {}
Err(libpijul::change::TextSerError::Io(e))
if e.kind() == std::io::ErrorKind::BrokenPipe => {}
Err(e) => return Err(e.into()),
}
edit in pijul/src/commands/debug.rs at line 14

[20.178003]

[20.21]

#[clap(long = "sanakirja-only")]
sanakirja_only: bool,
edit in pijul/src/commands/debug.rs at line 23

[20.178176]→[20.5663:5711](∅→∅),[20.5711]→[20.63:114](∅→∅),[20.114]→[20.5711:5818](∅→∅),[20.5711]→[20.5711:5818](∅→∅)

libpijul::pristine::debug_inodes(&txn);
libpijul::pristine::debug_revinodes(&txn);
libpijul::pristine::debug_tree_print(&txn);
libpijul::pristine::debug_revtree_print(&txn);
replacement in pijul/src/commands/debug.rs at line 29

[20.178559]→[20.32:264](∅→∅),[20.264]→[20.17868:17909](∅→∅),[20.17909]→[20.299:425](∅→∅),[20.299]→[20.299:425](∅→∅),[20.425]→[20.58:102](∅→∅),[20.58]→[20.58:102](∅→∅),[20.102]→[20.17910:17991](∅→∅)

if let Some(root) = self.root {
let (pos, _) = txn
.follow_oldest_path(&repo.changes, &channel, &root)
.unwrap();
libpijul::pristine::debug_root(
&txn,
&channel.borrow().graph,
pos.inode_vertex(),
std::io::stdout(),
true,
)?;
} else {
let channel = channel.borrow();
libpijul::pristine::debug(&txn, &channel.graph, std::io::stdout())?;

[20.178559]

[20.177]

if !self.sanakirja_only {
libpijul::pristine::debug_inodes(&txn);
libpijul::pristine::debug_revinodes(&txn);
libpijul::pristine::debug_tree_print(&txn);
libpijul::pristine::debug_revtree_print(&txn);
if let Some(root) = self.root {
let (pos, _) = txn
.follow_oldest_path(&repo.changes, &channel, &root)
.unwrap();
libpijul::pristine::debug_root(
&txn,
&channel.read()?.graph,
pos.inode_vertex(),
std::io::stdout(),
true,
)?;
} else {
let channel = channel.read()?;
libpijul::pristine::debug(&txn, &channel.graph, std::io::stdout())?;
}
libpijul::pristine::check_alive_debug(&repo.changes, &txn, &*channel.read()?, 0)?;
edit in pijul/src/commands/debug.rs at line 51

[20.187]→[20.17992:18083](∅→∅)

libpijul::pristine::check_alive_debug(&repo.changes, &txn, &channel.borrow(), 0)?;
edit in pijul/src/commands/debug.rs at line 52

[20.50]

[20.178648]

let channel = channel.read()?;
::sanakirja::debug::debug(&txn.txn, &[&channel.graph], "debug.sanakirja", true);
edit in pijul/src/commands/credit.rs at line 52

[20.180243]→[20.180243:180284](∅→∅)

let channel_ = channel.borrow();
replacement in pijul/src/commands/credit.rs at line 53

[20.178]→[20.180284:180309](∅→∅),[20.237]→[20.180284:180309](∅→∅),[20.180284]→[20.180284:180309](∅→∅)

txn.output_file(

[20.237]

[20.180309]

let channel = channel.read().unwrap();
libpijul::output::output_file(
edit in pijul/src/commands/credit.rs at line 56

[20.180336]

[20.180336]

&txn,
replacement in pijul/src/commands/credit.rs at line 59

[20.180375]→[20.180375:180443](∅→∅)

&mut Creditor::new(std::io::stdout(), &txn, &channel_),

[20.180375]

[20.180443]

&mut Creditor::new(std::io::stdout(), &txn, &channel),
replacement in pijul/src/commands/clone.rs at line 6

[20.2941]→[20.6191:6228](∅→∅)

use libpijul::{MutTxnT, MutTxnTExt};

[20.2941]

[20.2942]

use libpijul::MutTxnT;
edit in pijul/src/commands/clone.rs at line 8

[20.2958]

[20.183024]

use std::sync::{Arc, RwLock};
replacement in pijul/src/commands/clone.rs at line 62

[20.53]→[20.412:451](∅→∅)

let repo_path_ = path.clone();

[20.53]

[20.35]

let repo_path_ = repo_path.clone();
replacement in pijul/src/commands/clone.rs at line 64

[20.72]→[20.452:516](∅→∅)

std::fs::remove_dir_all(&repo_path_).unwrap_or(());

[20.72]

[20.1705]

repo_path_.remove();
replacement in pijul/src/commands/clone.rs at line 88

[20.2562]→[20.185601:185679](∅→∅),[16.5072]→[20.185601:185679](∅→∅),[20.185601]→[20.185601:185679](∅→∅)

txn.output_repository_no_pending(
&mut repo.working_copy,

[16.5072]

[20.185679]

let config_path = repo.config_path();
let mut config = repo.config;

let txn = Arc::new(RwLock::new(txn));
libpijul::output::output_repository_no_pending(
repo.working_copy.clone(),
replacement in pijul/src/commands/clone.rs at line 95

[20.185706]→[20.185706:185732](∅→∅)

&mut channel,

[20.185706]

[20.185732]

txn.clone(),
channel,
edit in pijul/src/commands/clone.rs at line 100

[20.509]

[20.185766]

num_cpus::get(),
edit in pijul/src/commands/clone.rs at line 103

[20.534]

[20.185778]

let txn = if let Ok(t) = Arc::try_unwrap(txn) {
t.into_inner().unwrap()
} else {
unreachable!()
};
replacement in pijul/src/commands/clone.rs at line 109

[20.2590]→[20.185801:185859](∅→∅),[20.185801]→[20.185801:185859](∅→∅)

repo.config.current_channel = Some(self.channel);

[20.185801]

[20.1742]

config.current_channel = Some(self.channel);
replacement in pijul/src/commands/clone.rs at line 111

[20.1808]→[20.1808:1881](∅→∅)

repo.config.default_remote = std::fs::canonicalize(&l.root)?

[20.1808]

[20.1881]

config.default_remote = std::fs::canonicalize(&l.root)?
replacement in pijul/src/commands/clone.rs at line 115

[20.1965]→[20.1965:2025](∅→∅)

repo.config.default_remote = Some(self.remote);

[20.1965]

[20.2025]

config.default_remote = Some(self.remote);
replacement in pijul/src/commands/clone.rs at line 117

[20.56]→[20.185859:185888](∅→∅),[20.2035]→[20.185859:185888](∅→∅),[20.185859]→[20.185859:185888](∅→∅)

repo.save_config()?;

[20.2035]

[20.277]

config.save(&config_path)?;
replacement in pijul/src/commands/channel.rs at line 43

[20.18744]→[20.18744:18788](∅→∅),[20.18788]→[20.187844:187896](∅→∅),[20.187844]→[20.187844:187896](∅→∅),[20.187896]→[20.513:564](∅→∅)

let channel = channel?;
let channel = channel.borrow();
let name = txn.name(&channel);

[20.18744]

[20.187943]

let (_, channel) = channel?;
let channel = channel.read()?;
let name = txn.name(&*channel);
replacement in pijul/src/commands/change.rs at line 35

[20.243]→[20.243:287](∅→∅),[20.287]→[20.19124:19195](∅→∅)

let channel = channel.borrow();
if let Some(h) = txn.reverse_log(&channel, None)?.next() {

[20.243]

[20.14140]

let channel = channel.read()?;
if let Some(h) = txn.reverse_log(&*channel, None)?.next() {
edit in pijul/src/commands/apply.rs at line 1

[20.194289]→[20.510:552](∅→∅)

use std::collections::{HashMap, HashSet};
edit in pijul/src/commands/apply.rs at line 2

[20.3361]

[20.3361]

use std::sync::{Arc, RwLock};
edit in pijul/src/commands/apply.rs at line 8

[20.617]

[20.14202]

use libpijul::{HashMap, HashSet};
replacement in pijul/src/commands/apply.rs at line 31

[20.16631]→[20.16631:16700](∅→∅)

let mut repo = Repository::find_root(self.repo_path).await?;

[20.16631]

[20.1086]

let repo = Repository::find_root(self.repo_path).await?;
replacement in pijul/src/commands/apply.rs at line 51

[20.195794]→[20.195794:195886](∅→∅)

let change = libpijul::change::Change::read(&mut change, &mut HashMap::new())?;

[20.195794]

[20.979]

let change = libpijul::change::Change::read(&mut change, &mut HashMap::default())?;
replacement in pijul/src/commands/apply.rs at line 65

[20.619]→[20.619:661](∅→∅)

let mut touched = HashSet::new();

[20.619]

[20.661]

let mut touched = HashSet::default();
edit in pijul/src/commands/apply.rs at line 82

[20.1107]

[20.2923]

let txn = Arc::new(RwLock::new(txn));
edit in pijul/src/commands/apply.rs at line 85

[20.3026]

[20.3026]

let txn_ = txn.read().unwrap();
replacement in pijul/src/commands/apply.rs at line 88

[20.3098]→[20.3098:3193](∅→∅)

libpijul::fs::find_path(&repo.changes, &txn, &channel.borrow(), false, i)?

[20.3098]

[20.3193]

libpijul::fs::find_path(&repo.changes, &*txn_, &*channel.read()?, false, i)?
edit in pijul/src/commands/apply.rs at line 96

[20.3383]

[16.5105]

std::mem::drop(txn_);
replacement in pijul/src/commands/apply.rs at line 105

[20.3430]→[20.3430:3524](∅→∅)

txn.output_repository_no_pending(
&mut repo.working_copy,

[20.3430]

[20.3524]

libpijul::output::output_repository_no_pending(
repo.working_copy.clone(),
replacement in pijul/src/commands/apply.rs at line 108

[20.3559]→[20.3559:3593](∅→∅)

&mut channel,

[20.3559]

[20.3593]

txn.clone(),
channel.clone(),
edit in pijul/src/commands/apply.rs at line 113

[20.3672]

[20.3672]

num_cpus::get(),
replacement in pijul/src/commands/apply.rs at line 117

[20.3749]→[20.3749:3843](∅→∅)

txn.output_repository_no_pending(
&mut repo.working_copy,

[20.3749]

[20.3843]

libpijul::output::output_repository_no_pending(
repo.working_copy.clone(),
replacement in pijul/src/commands/apply.rs at line 120

[20.3878]→[20.3878:3912](∅→∅)

&mut channel,

[20.3878]

[20.3912]

txn.clone(),
channel.clone(),
edit in pijul/src/commands/apply.rs at line 125

[20.3988]

[20.3988]

num_cpus::get(),
edit in pijul/src/commands/apply.rs at line 130

[20.1652]

[20.196314]

let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
txn.into_inner().unwrap()
} else {
unreachable!()
};
replacement in pijul/Cargo.toml at line 64

[10.151]→[20.565:589](∅→∅),[20.222]→[20.565:589](∅→∅),[20.1634]→[20.565:589](∅→∅)

thrussh-keys = "0.20.1"

[10.151]

[20.1656]

thrussh-keys = "0.20.3"
replacement in pijul/Cargo.toml at line 68

[20.197874]→[18.700:758](∅→∅)

sanakirja = { version = "1.1.7", features = [ "crc32" ] }

[20.197874]

[20.197895]

sanakirja = { version = "1.2.0", features = [ "crc32" ] }
edit in libpijul/src/working_copy/mod.rs at line 11

[20.1193]→[20.1193:1367](∅→∅),[20.1367]→[20.198424:198425](∅→∅),[20.198424]→[20.198424:198425](∅→∅)

#[derive(Debug, Error)]
pub enum WriteError<E: std::error::Error + 'static> {
#[error(transparent)]
E(E),
#[error(transparent)]
Io(#[from] std::io::Error),
}
replacement in libpijul/src/working_copy/mod.rs at line 12

[20.198449]→[20.1368:1476](∅→∅)

type Error: std::error::Error;
fn create_dir_all(&mut self, path: &str) -> Result<(), Self::Error>;

[20.198449]

[20.1476]

type Error: std::error::Error + Send;
fn create_dir_all(&self, path: &str) -> Result<(), Self::Error>;
replacement in libpijul/src/working_copy/mod.rs at line 17

[20.1728]→[20.1728:2064](∅→∅),[20.2064]→[20.199114:199172](∅→∅),[20.199114]→[20.199114:199172](∅→∅),[20.199172]→[20.2065:2100](∅→∅)

fn remove_path(&mut self, name: &str) -> Result<(), Self::Error>;
fn rename(&mut self, former: &str, new: &str) -> Result<(), Self::Error>;
fn set_permissions(&mut self, name: &str, permissions: u16) -> Result<(), Self::Error>;
fn write_file<A, E: std::error::Error, F: FnOnce(&mut dyn std::io::Write) -> Result<A, E>>(
&mut self,
file: &str,
writer: F,
) -> Result<A, WriteError<E>>;

[20.1728]

[20.199207]

fn remove_path(&self, name: &str) -> Result<(), Self::Error>;
fn rename(&self, former: &str, new: &str) -> Result<(), Self::Error>;
fn set_permissions(&self, name: &str, permissions: u16) -> Result<(), Self::Error>;

type Writer: std::io::Write;
fn write_file(&self, file: &str) -> Result<Self::Writer, Self::Error>;
replacement in libpijul/src/working_copy/memory.rs at line 3

[20.199328]→[20.199328:199359](∅→∅)

use std::collections::HashMap;

[20.199328]

[20.199359]

use crate::HashMap;
use std::sync::{Arc, Mutex};
replacement in libpijul/src/working_copy/memory.rs at line 8

[20.199404]→[20.199404:199484](∅→∅)

pub struct Memory {
pub files: FileTree,
pub last_modified: SystemTime,

[20.199404]

[20.199484]

pub struct Memory(Mutex<Memory_>);

#[derive(Debug)]
struct Memory_ {
files: FileTree,
last_modified: SystemTime,
replacement in libpijul/src/working_copy/memory.rs at line 17

[20.26]→[20.199504:199526](∅→∅),[20.199504]→[20.199504:199526](∅→∅)

pub struct FileTree {

[20.26]

[20.199526]

struct FileTree {
replacement in libpijul/src/working_copy/memory.rs at line 25

[20.199671]→[20.199671:199698](∅→∅)

contents: Vec<u8>,

[20.199671]

[20.199698]

contents: Arc<Mutex<Vec<u8>>>,
replacement in libpijul/src/working_copy/memory.rs at line 36

[20.80]→[20.80:95](∅→∅)

Self {

[20.80]

[20.95]

Memory(Mutex::new(Memory_ {
replacement in libpijul/src/working_copy/memory.rs at line 39

[20.200014]→[20.200014:200024](∅→∅)

}

[20.200014]

[20.200024]

}))
edit in libpijul/src/working_copy/memory.rs at line 48

[20.200077]

[20.200077]

let m = self.0.lock().unwrap();
replacement in libpijul/src/working_copy/memory.rs at line 50

[20.200114]→[20.200114:200182](∅→∅)

let mut current_files = vec![(String::new(), &self.files)];

[20.200114]

[20.200182]

let mut current_files = vec![(String::new(), &m.files)];
replacement in libpijul/src/working_copy/memory.rs at line 85

[20.201388]→[20.201388:201429](∅→∅)

contents: file_contents,

[20.201388]

[20.201429]

contents: Arc::new(Mutex::new(file_contents)),
replacement in libpijul/src/working_copy/memory.rs at line 99

[20.201780]→[20.201780:201826](∅→∅)

children: HashMap::new(),

[20.201780]

[20.201826]

children: HashMap::default(),
replacement in libpijul/src/working_copy/memory.rs at line 105

[20.201877]→[20.201877:201978](∅→∅)

fn add_inode(&mut self, file: &str, inode: Inode) {
let mut file_tree = &mut self.files;

[20.201877]

[20.201978]

fn add_inode(&self, file: &str, inode: Inode) {
let mut m = self.0.lock().unwrap();
replacement in libpijul/src/working_copy/memory.rs at line 108

[20.202016]→[20.202016:202051](∅→∅)

self.last_modified = last;

[20.202016]

[20.202051]

m.last_modified = last;
let mut file_tree = &mut m.files;
replacement in libpijul/src/working_copy/memory.rs at line 120

[20.202493]→[20.202493:202547](∅→∅)

children: HashMap::new(),

[20.202493]

[20.202547]

children: HashMap::default(),
edit in libpijul/src/working_copy/memory.rs at line 136

[20.203014]

[20.203014]

}
edit in libpijul/src/working_copy/memory.rs at line 138

[20.203015]

[20.203015]

impl Memory_ {
edit in libpijul/src/working_copy/memory.rs at line 183

[20.204591]

[20.204591]

self.last_modified = SystemTime::now();
edit in libpijul/src/working_copy/memory.rs at line 187

[20.204738]→[20.204738:204786](∅→∅)

self.last_modified = SystemTime::now();
replacement in libpijul/src/working_copy/memory.rs at line 217

[20.2240]→[20.2240:2314](∅→∅),[20.2314]→[20.205510:205553](∅→∅),[20.205510]→[20.205510:205553](∅→∅)

fn create_dir_all(&mut self, file: &str) -> Result<(), Self::Error> {
if self.get_file(file).is_none() {

[20.2240]

[20.205553]

fn create_dir_all(&self, file: &str) -> Result<(), Self::Error> {
let m = self.0.lock().unwrap();
if m.get_file(file).is_none() {
replacement in libpijul/src/working_copy/memory.rs at line 226

[20.205780]→[20.205780:205830](∅→∅)

children: HashMap::new(),

[20.205780]

[20.205830]

children: HashMap::default(),
replacement in libpijul/src/working_copy/memory.rs at line 235

[20.2395]→[20.206041:206077](∅→∅),[20.206041]→[20.206041:206077](∅→∅)

match self.get_file(file) {

[20.2395]

[20.206077]

let m = self.0.lock().unwrap();
match m.get_file(file) {
replacement in libpijul/src/working_copy/memory.rs at line 245

[20.2543]→[20.206432:206468](∅→∅),[20.206432]→[20.206432:206468](∅→∅)

match self.get_file(file) {

[20.2543]

[20.206468]

let m = self.0.lock().unwrap();
match m.get_file(file) {
replacement in libpijul/src/working_copy/memory.rs at line 249

[20.206603]→[20.206603:206644](∅→∅)

buffer.extend(contents);

[20.206603]

[20.206644]

buffer.extend(&contents.lock().unwrap()[..]);
replacement in libpijul/src/working_copy/memory.rs at line 258

[20.2693]→[20.206969:207000](∅→∅),[20.206969]→[20.206969:207000](∅→∅)

Ok(self.last_modified)

[20.2693]

[20.207000]

let m = self.0.lock().unwrap();
Ok(m.last_modified)
replacement in libpijul/src/working_copy/memory.rs at line 262

[20.207007]→[20.2694:2765](∅→∅),[20.2765]→[20.207080:207113](∅→∅),[20.207080]→[20.207080:207113](∅→∅)

fn remove_path(&mut self, path: &str) -> Result<(), Self::Error> {
self.remove_path_(path);

[20.207007]

[20.207113]

fn remove_path(&self, path: &str) -> Result<(), Self::Error> {
self.0.lock().unwrap().remove_path_(path);
replacement in libpijul/src/working_copy/memory.rs at line 267

[20.207135]→[20.2766:2842](∅→∅)

fn rename(&mut self, old: &str, new: &str) -> Result<(), Self::Error> {

[20.207135]

[20.207213]

fn rename(&self, old: &str, new: &str) -> Result<(), Self::Error> {
replacement in libpijul/src/working_copy/memory.rs at line 269

[20.207262]→[20.207262:207316](∅→∅)

if let Some(inode) = self.remove_path_(old) {

[20.207262]

[20.207316]

let mut m = self.0.lock().unwrap();
if let Some(inode) = m.remove_path_(old) {
replacement in libpijul/src/working_copy/memory.rs at line 275

[20.207386]→[20.2843:2936](∅→∅)

fn set_permissions(&mut self, file: &str, permissions: u16) -> Result<(), Self::Error> {

[20.207386]

[20.207481]

fn set_permissions(&self, file: &str, permissions: u16) -> Result<(), Self::Error> {
replacement in libpijul/src/working_copy/memory.rs at line 277

[20.207527]→[20.207527:207567](∅→∅)

match self.get_file_mut(file) {

[20.207527]

[20.207567]

let mut m = self.0.lock().unwrap();
match m.get_file_mut(file) {
replacement in libpijul/src/working_copy/memory.rs at line 289

[20.207946]→[20.2937:3033](∅→∅),[20.3033]→[20.208032:208090](∅→∅),[20.208032]→[20.208032:208090](∅→∅),[20.208090]→[20.3034:3070](∅→∅),[20.3070]→[20.208126:208166](∅→∅),[20.208126]→[20.208126:208166](∅→∅)

fn write_file<A, E: std::error::Error, F: FnOnce(&mut dyn std::io::Write) -> Result<A, E>>(
&mut self,
file: &str,
writer: F,
) -> Result<A, WriteError<E>> {
match self.get_file_mut(file) {

[20.207946]

[20.208166]

type Writer = Writer;
fn write_file(&self, file: &str) -> Result<Self::Writer, Self::Error> {
let mut m = self.0.lock().unwrap();
match m.get_file_mut(file) {
replacement in libpijul/src/working_copy/memory.rs at line 297

[20.208254]→[20.208254:208288](∅→∅),[20.208288]→[20.3071:3127](∅→∅)

contents.clear();
writer(contents).map_err(WriteError::E)

[20.208254]

[20.208321]

contents.lock().unwrap().clear();
Ok(Writer {
w: contents.clone(),
})
replacement in libpijul/src/working_copy/memory.rs at line 303

[20.208357]→[20.208357:208404](∅→∅)

let mut contents = Vec::new();

[20.208357]

[20.208404]

let contents = Arc::new(Mutex::new(Vec::new()));
edit in libpijul/src/working_copy/memory.rs at line 305

[20.208459]→[20.3128:3199](∅→∅)

let a = writer(&mut contents).map_err(WriteError::E)?;
replacement in libpijul/src/working_copy/memory.rs at line 309

[17.460]→[20.208663:208697](∅→∅),[20.208663]→[20.208663:208697](∅→∅)

contents,

[17.460]

[20.208697]

contents: contents.clone(),
replacement in libpijul/src/working_copy/memory.rs at line 313

[20.208778]→[20.208778:208800](∅→∅)

Ok(a)

[20.208778]

[20.208800]

Ok(Writer { w: contents })
edit in libpijul/src/working_copy/memory.rs at line 319

[20.208883]

pub struct Writer {
w: Arc<Mutex<Vec<u8>>>,
}

impl std::io::Write for Writer {
fn write(&mut self, b: &[u8]) -> Result<usize, std::io::Error> {
self.w.lock().unwrap().write(b)
}
fn flush(&mut self) -> Result<(), std::io::Error> {
Ok(())
}
}
edit in libpijul/src/working_copy/filesystem.rs at line 7

[20.209063]

[20.209063]

use std::sync::{Arc, RwLock};
replacement in libpijul/src/working_copy/filesystem.rs at line 97

[20.210105]→[20.210105:210196](∅→∅)

T: crate::MutTxnTExt + crate::TxnTExt,
C: crate::changestore::ChangeStore,

[20.210105]

[20.210196]

T: crate::MutTxnTExt + crate::TxnTExt + Send + Sync + 'static,
C: crate::changestore::ChangeStore + Clone + Send + 'static,
replacement in libpijul/src/working_copy/filesystem.rs at line 101

[20.210227]→[20.210227:210321](∅→∅)

&mut self,
txn: &mut T,
channel: &mut crate::pristine::ChannelRef<T>,

[20.210227]

[20.210321]

self: Arc<Self>,
txn: Arc<RwLock<T>>,
channel: crate::pristine::ChannelRef<T>,
replacement in libpijul/src/working_copy/filesystem.rs at line 109

[20.398]→[20.19577:19631](∅→∅)

) -> Result<(), Error<C::Error, T::GraphError>> {

[20.398]

[20.210471]

) -> Result<(), Error<C::Error, T::GraphError>>
where
T::Channel: Send + Sync,
{
replacement in libpijul/src/working_copy/filesystem.rs at line 114

[20.210511]→[20.399:477](∅→∅)

self.record_prefix(
txn,
channel,

[20.210511]

[20.477]

self.clone().record_prefix(
txn.clone(),
channel.clone(),
replacement in libpijul/src/working_copy/filesystem.rs at line 140

[20.1702]→[20.1702:1723](∅→∅)

txn: &mut T,

[20.1702]

[20.1756]

txn: Arc<RwLock<T>>,
edit in libpijul/src/working_copy/filesystem.rs at line 207

[20.2858]

[20.2858]

let mut txn = txn.write().unwrap();
replacement in libpijul/src/working_copy/filesystem.rs at line 225

[20.210978]→[20.210978:211069](∅→∅)

T: crate::MutTxnTExt + crate::TxnTExt,
C: crate::changestore::ChangeStore,

[20.210978]

[20.211069]

T: crate::MutTxnTExt + crate::TxnTExt + Send + Sync + 'static,
C: crate::changestore::ChangeStore + Clone + Send + 'static,
replacement in libpijul/src/working_copy/filesystem.rs at line 228

[20.211076]→[20.211076:211170](∅→∅)

&mut self,
txn: &mut T,
channel: &mut crate::pristine::ChannelRef<T>,

[20.211076]

[20.211170]

self: Arc<Self>,
txn: Arc<RwLock<T>>,
channel: crate::pristine::ChannelRef<T>,
replacement in libpijul/src/working_copy/filesystem.rs at line 236

[20.3130]→[20.19765:19819](∅→∅)

) -> Result<(), Error<C::Error, T::GraphError>> {

[20.3130]

[20.2643]

) -> Result<(), Error<C::Error, T::GraphError>>
where
T::Channel: Send + Sync,
{
replacement in libpijul/src/working_copy/filesystem.rs at line 241

[20.2726]→[20.2726:2800](∅→∅)

self.add_prefix_rec(txn, repo_path, full, &prefix, threads)?;

[20.2726]

[20.213590]

self.add_prefix_rec(txn.clone(), repo_path, full, &prefix, threads)?;
replacement in libpijul/src/working_copy/filesystem.rs at line 243

[20.213648]→[20.213648:213695](∅→∅)

txn.record(
state,

[20.213648]

[20.213695]

state.record(
txn.clone(),
edit in libpijul/src/working_copy/filesystem.rs at line 250

[20.213837]

[20.213837]

1,
replacement in libpijul/src/working_copy/filesystem.rs at line 266

[20.3951]→[20.3951:4025](∅→∅)

fn create_dir_all(&mut self, file: &str) -> Result<(), Self::Error> {

[20.3951]

[20.159]

fn create_dir_all(&self, file: &str) -> Result<(), Self::Error> {
debug!("create_dir_all {:?}", file);
edit in libpijul/src/working_copy/filesystem.rs at line 271

[20.4106]

[20.215]

debug!("metadata {:?}", file);
edit in libpijul/src/working_copy/filesystem.rs at line 279

[20.214542]

[20.273]

debug!("read_file {:?}", file);
edit in libpijul/src/working_copy/filesystem.rs at line 285

[20.4283]

[20.334]

debug!("modified_time {:?}", file);
replacement in libpijul/src/working_copy/filesystem.rs at line 290

[20.214848]→[20.4284:4355](∅→∅)

fn remove_path(&mut self, path: &str) -> Result<(), Self::Error> {

[20.214848]

[20.392]

fn remove_path(&self, path: &str) -> Result<(), Self::Error> {
debug!("remove_path {:?}", path);
replacement in libpijul/src/working_copy/filesystem.rs at line 304

[20.215297]→[20.4356:4435](∅→∅)

fn rename(&mut self, former: &str, new: &str) -> Result<(), Self::Error> {

[20.215297]

[20.429]

fn rename(&self, former: &str, new: &str) -> Result<(), Self::Error> {
debug!("rename {:?} {:?}", former, new);
replacement in libpijul/src/working_copy/filesystem.rs at line 317

[20.215737]→[20.4436:4529](∅→∅)

fn set_permissions(&mut self, name: &str, permissions: u16) -> Result<(), Self::Error> {

[20.215737]

[20.215832]

fn set_permissions(&self, name: &str, permissions: u16) -> Result<(), Self::Error> {
replacement in libpijul/src/working_copy/filesystem.rs at line 327

[20.216195]→[20.634:697](∅→∅)

current.set_mode(current.mode() | permissions as u32);

[20.216195]

[20.216241]

if permissions & 0o100 != 0 {
current.set_mode(current.mode() | 0o100);
} else {
current.set_mode(current.mode() & ((!0o777) | 0o666));
}
debug!("setting {:?}", current);
edit in libpijul/src/working_copy/filesystem.rs at line 334

[20.216291]

[20.216291]

debug!("set");
replacement in libpijul/src/working_copy/filesystem.rs at line 341

[20.216450]→[20.4626:4722](∅→∅),[20.4722]→[20.216536:216594](∅→∅),[20.216536]→[20.216536:216594](∅→∅),[20.216594]→[20.4723:4759](∅→∅)

fn write_file<A, E: std::error::Error, F: FnOnce(&mut dyn std::io::Write) -> Result<A, E>>(
&mut self,
file: &str,
writer: F,
) -> Result<A, WriteError<E>> {

[20.216450]

[20.541]

type Writer = std::io::BufWriter<std::fs::File>;
fn write_file(&self, file: &str) -> Result<Self::Writer, Self::Error> {
edit in libpijul/src/working_copy/filesystem.rs at line 345

[20.577]

[20.216671]

debug!("path = {:?}", path);
replacement in libpijul/src/working_copy/filesystem.rs at line 347

[20.216712]→[20.4760:4824](∅→∅)

std::fs::create_dir_all(p).map_err(WriteError::Io)?

[20.216712]

[20.216752]

std::fs::create_dir_all(p).unwrap_or(())
edit in libpijul/src/working_copy/filesystem.rs at line 349

[20.216762]

[20.216762]

debug!("write_file: dir created");
replacement in libpijul/src/working_copy/filesystem.rs at line 351

[20.216813]→[20.4825:4989](∅→∅)

let mut file =
std::io::BufWriter::new(std::fs::File::create(&path).map_err(WriteError::Io)?);
writer(&mut file).map_err(WriteError::E)

[20.216813]

[20.216918]

let file = std::io::BufWriter::new(std::fs::File::create(&path)?);
debug!("file");
Ok(file)
replacement in libpijul/src/unrecord/mod.rs at line 49

[20.231814]→[20.231814:231847](∅→∅)

channel: &mut ChannelRef<T>,

[20.231814]

[20.231847]

channel: &ChannelRef<T>,
replacement in libpijul/src/unrecord/mod.rs at line 62

[20.22721]→[20.232148:232194](∅→∅),[20.232148]→[20.232148:232194](∅→∅)

let mut channel = channel.r.borrow_mut();

[20.22721]

[20.232194]

let mut channel = channel.write().unwrap();
replacement in libpijul/src/unrecord/mod.rs at line 120

[20.23536]→[20.233695:233731](∅→∅),[20.233695]→[20.233695:233731](∅→∅)

let channel = channel.borrow();

[20.23536]

[20.23537]

let channel = channel.read().unwrap();
replacement in libpijul/src/unrecord/mod.rs at line 122

[20.23576]→[20.23576:23598](∅→∅),[20.23598]→[20.233769:233799](∅→∅),[20.233769]→[20.233769:233799](∅→∅),[20.233799]→[20.1015:1062](∅→∅),[20.1062]→[20.16603:16677](∅→∅),[20.1135]→[20.1779:1789](∅→∅),[20.16677]→[20.1779:1789](∅→∅),[20.1779]→[20.1779:1789](∅→∅)

let br = br?;
let br = br.borrow();
if txn.name(&br) != txn.name(&channel)
&& txn.get_changeset(txn.changes(&br), &change_id)?.is_some()
{

[20.23576]

[20.23698]

let (name, br) = br?;
if name.as_str() == txn.name(&channel) {
continue;
}
let br = br.read().unwrap();
if txn.get_changeset(txn.changes(&br), &change_id)?.is_some() {
edit in libpijul/src/unrecord/mod.rs at line 154

[20.24110]

[20.24110]

change,
edit in libpijul/src/unrecord/mod.rs at line 363

[20.240533]

[20.240533]

change: &Change,
edit in libpijul/src/unrecord/mod.rs at line 380

[20.241619]

[20.241619]

|h| change.knows(h),
replacement in libpijul/src/tests/unrecord.rs at line 16

[20.249265]→[20.249265:249304](∅→∅)

let mut txn = env.mut_txn_begin();

[20.249265]

[20.249304]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/unrecord.rs at line 64

[20.250611]→[20.250611:250650](∅→∅)

let mut txn = env.mut_txn_begin();

[20.250611]

[20.250650]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/unrecord.rs at line 114

[20.251955]→[20.251955:251994](∅→∅)

let mut txn = env.mut_txn_begin();

[20.251955]

[20.251994]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/unrecord.rs at line 188

[20.253870]→[20.253870:253991](∅→∅)

let mut txn = env.mut_txn_begin();
let mut txn2 = env2.mut_txn_begin();
let mut txn3 = env3.mut_txn_begin();

[20.253870]

[20.253991]

let mut txn = env.mut_txn_begin().unwrap();
let mut txn2 = env2.mut_txn_begin().unwrap();
let mut txn3 = env3.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/unrecord.rs at line 291

[20.256536]→[20.256536:256616](∅→∅)

let mut txn = env.mut_txn_begin();
let mut txn2 = env2.mut_txn_begin();

[20.256536]

[20.256616]

let mut txn = env.mut_txn_begin().unwrap();
let mut txn2 = env2.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/unrecord.rs at line 407

[20.259760]→[20.259760:259799](∅→∅)

let mut txn = env.mut_txn_begin();

[20.259760]

[20.259799]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/unrecord.rs at line 482

[20.261703]→[20.261703:261742](∅→∅)

let mut txn = env.mut_txn_begin();

[20.261703]

[20.261742]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/unrecord.rs at line 558

[20.263990]→[20.263990:264029](∅→∅)

let mut txn = env.mut_txn_begin();

[20.263990]

[20.264029]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/unrecord.rs at line 621

[20.265798]→[20.265798:265837](∅→∅)

let mut txn = env.mut_txn_begin();

[20.265798]

[20.265837]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/unrecord.rs at line 728

[20.268744]→[20.268744:268783](∅→∅)

let mut txn = env.mut_txn_begin();

[20.268744]

[20.268783]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/unrecord.rs at line 818

[20.271253]→[20.271253:271292](∅→∅)

let mut txn = env.mut_txn_begin();

[20.271253]

[20.271292]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/unrecord.rs at line 881

[20.273221]→[20.273221:273260](∅→∅)

let mut txn = env.mut_txn_begin();

[20.273221]

[20.273260]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/unrecord.rs at line 988

[20.781]→[20.781:820](∅→∅)

let mut txn = env.mut_txn_begin();

[20.781]

[20.820]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/rollback.rs at line 13

[20.361]→[20.361:400](∅→∅)

let mut txn = env.mut_txn_begin();

[20.361]

[20.400]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/rollback.rs at line 98

[20.2876]→[20.2876:2915](∅→∅)

let mut txn = env.mut_txn_begin();

[20.2876]

[20.2915]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/rm_file.rs at line 17

[20.276599]→[20.276599:276650](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.276599]

[20.276650]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/rm_file.rs at line 19

[20.276712]→[20.276712:276759](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.276712]

[20.276759]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/performance.rs at line 16

[20.278660]→[20.278660:278699](∅→∅)

let mut txn = env.mut_txn_begin();

[20.278660]

[20.278699]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/performance.rs at line 81

[20.24391]→[20.280502:280541](∅→∅),[20.280502]→[20.280502:280541](∅→∅)

let mut txn = env.mut_txn_begin();

[20.24391]

[20.280541]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/partial.rs at line 18

[20.285788]→[20.285788:285827](∅→∅)

let mut txn = env.mut_txn_begin();

[20.285788]

[20.285827]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/partial.rs at line 61

[20.287232]→[20.287232:287271](∅→∅)

let mut txn = env.mut_txn_begin();

[20.287232]

[20.287271]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/partial.rs at line 88

[20.288108]→[20.288108:288149](∅→∅)

let mut txn2 = env2.mut_txn_begin();

[20.288108]

[20.288149]

let mut txn2 = env2.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/partial.rs at line 127

[20.289223]→[20.289223:289264](∅→∅)

let mut txn2 = env2.mut_txn_begin();

[20.289223]

[20.289264]

let mut txn2 = env2.mut_txn_begin().unwrap();
edit in libpijul/src/tests/mod.rs at line 7

[20.289563]

[20.289563]

use std::sync::{Arc, RwLock};
replacement in libpijul/src/tests/mod.rs at line 24

[20.1847]→[20.289795:289813](∅→∅),[20.289795]→[20.289795:289813](∅→∅)

repo: &mut R,

[20.1847]

[20.289813]

repo: &R,
replacement in libpijul/src/tests/mod.rs at line 27

[20.289845]→[20.289845:289878](∅→∅)

channel: &mut ChannelRef<T>,

[20.289845]

[20.289878]

channel: &ChannelRef<T>,
replacement in libpijul/src/tests/mod.rs at line 37

[20.28285]→[20.28285:28320](∅→∅)

&mut channel.borrow_mut(),

[20.28285]

[20.28320]

&mut *channel.lock().unwrap(),
replacement in libpijul/src/tests/mod.rs at line 82

[20.291162]→[20.1848:1939](∅→∅),[20.1939]→[20.291259:291344](∅→∅),[20.291259]→[20.291259:291344](∅→∅)

fn record_all_output<T: MutTxnT, R: WorkingCopy, P: ChangeStore + Clone + Send + 'static>(
repo: &mut R,
changes: &P,
txn: &mut T,
channel: &mut ChannelRef<T>,

[20.291162]

[20.291344]

fn record_all_output<
T: MutTxnT + Send + Sync + 'static,
R: WorkingCopy + Send + Sync + 'static,
P: ChangeStore + Clone + Send + Sync + 'static,
>(
repo: Arc<R>,
changes: Arc<P>,
txn: Arc<RwLock<T>>,
channel: &ChannelRef<T>,
edit in libpijul/src/tests/mod.rs at line 95

[20.1783]

[20.1783]

T::Channel: Send + Sync + 'static,
replacement in libpijul/src/tests/mod.rs at line 97

[20.1785]→[20.291397:291462](∅→∅),[20.291397]→[20.291397:291462](∅→∅),[20.291462]→[20.25833:25929](∅→∅)

let hash = record_all(repo, changes, txn, channel, prefix)?;
output::output_repository_no_pending(repo, changes, txn, channel, "", true, None).unwrap();

[20.1785]

[20.291552]

let hash = record_all(
repo.as_ref(),
changes.as_ref(),
&mut *txn.write().unwrap(),
channel,
prefix,
)?;
output::output_repository_no_pending(repo, changes, txn, channel.clone(), "", true, None, 1)
.unwrap();
replacement in libpijul/src/tests/missing_context.rs at line 27

[20.292375]→[20.292375:292426](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.292375]

[20.292426]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/missing_context.rs at line 42

[20.292844]→[20.292844:292891](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.292844]

[20.292891]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/missing_context.rs at line 220

[20.297328]→[20.297328:297379](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.297328]

[20.297379]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/missing_context.rs at line 235

[20.297854]→[20.297854:297901](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.297854]

[20.297901]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/filesystem.rs at line 19

[20.26914]→[20.300988:301027](∅→∅),[20.300988]→[20.300988:301027](∅→∅)

let mut txn = env.mut_txn_begin();

[20.26914]

[20.301027]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/filesystem.rs at line 64

[20.27160]→[20.302279:302318](∅→∅),[20.302279]→[20.302279:302318](∅→∅)

let mut txn = env.mut_txn_begin();

[20.27160]

[20.302318]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/filesystem.rs at line 108

[20.27406]→[20.303581:303620](∅→∅),[20.303581]→[20.303581:303620](∅→∅)

let mut txn = env.mut_txn_begin();

[20.27406]

[20.303620]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/filesystem.rs at line 148

[20.27652]→[20.304674:304713](∅→∅),[20.304674]→[20.304674:304713](∅→∅)

let mut txn = env.mut_txn_begin();

[20.27652]

[20.304713]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 28

[20.306276]→[20.306276:306327](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.306276]

[20.306327]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 30

[20.306389]→[20.306389:306436](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.306389]

[20.306436]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 189

[20.310854]→[20.310854:310905](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.310854]

[20.310905]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 191

[20.310967]→[20.310967:311014](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.310967]

[20.311014]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 335

[20.315362]→[20.315362:315413](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.315362]

[20.315413]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 337

[20.315475]→[20.315475:315522](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.315475]

[20.315522]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 392

[20.317279]→[20.317279:317334](∅→∅)

let mut txn_charlie = env_charlie.mut_txn_begin();

[20.317279]

[20.317334]

let mut txn_charlie = env_charlie.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 522

[20.320575]→[20.320575:320626](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.320575]

[20.320626]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 524

[20.320688]→[20.320688:320735](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.320688]

[20.320735]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 654

[20.324441]→[20.324441:324492](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.324441]

[20.324492]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 656

[20.324554]→[20.324554:324601](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.324554]

[20.324601]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 786

[20.328500]→[20.328500:328551](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.328500]

[20.328551]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 788

[20.328613]→[20.328613:328660](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.328613]

[20.328660]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 920

[20.332645]→[20.332645:332696](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.332645]

[20.332696]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 922

[20.332758]→[20.332758:332805](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.332758]

[20.332805]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 924

[20.332871]→[20.332871:332926](∅→∅)

let mut txn_charlie = env_charlie.mut_txn_begin();

[20.332871]

[20.332926]

let mut txn_charlie = env_charlie.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 1138

[20.339458]→[20.339458:339509](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.339458]

[20.339509]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 1140

[20.339571]→[20.339571:339618](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.339571]

[20.339618]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 1142

[20.339684]→[20.339684:339739](∅→∅)

let mut txn_charlie = env_charlie.mut_txn_begin();

[20.339684]

[20.339739]

let mut txn_charlie = env_charlie.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 1351

[20.346128]→[20.346128:346179](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.346128]

[20.346179]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 1364

[20.346538]→[20.346538:346585](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.346538]

[20.346585]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 1489

[20.350433]→[20.350433:350484](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.350433]

[20.350484]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 1502

[20.350852]→[20.350852:350899](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.350852]

[20.350899]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 1588

[20.353672]→[20.353672:353723](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.353672]

[20.353723]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 1603

[20.354144]→[20.354144:354191](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.354144]

[20.354191]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 16

[20.357879]→[20.357879:357918](∅→∅)

let mut txn = env.mut_txn_begin();

[20.357879]

[20.357918]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 182

[20.363167]→[20.363167:363206](∅→∅)

let mut txn = env.mut_txn_begin();

[20.363167]

[20.363206]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 417

[20.370487]→[20.370487:370526](∅→∅)

let mut txn = env.mut_txn_begin();

[20.370487]

[20.370526]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 541

[20.374452]→[20.374452:374491](∅→∅)

let mut txn = env.mut_txn_begin();

[20.374452]

[20.374491]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 674

[20.378650]→[20.378650:378689](∅→∅)

let mut txn = env.mut_txn_begin();

[20.378650]

[20.378689]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 798

[20.382540]→[20.382540:382579](∅→∅)

let mut txn = env.mut_txn_begin();

[20.382540]

[20.382579]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 941

[20.386856]→[20.386856:386895](∅→∅)

let mut txn = env.mut_txn_begin();

[20.386856]

[20.386895]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 1081

[20.391307]→[20.391307:391346](∅→∅)

let mut txn = env.mut_txn_begin();

[20.391307]

[20.391346]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 1329

[20.398925]→[20.398925:398964](∅→∅)

let mut txn = env.mut_txn_begin();

[20.398925]

[20.398964]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 1453

[20.402784]→[20.402784:402823](∅→∅)

let mut txn = env.mut_txn_begin();

[20.402784]

[20.402823]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 1598

[20.407484]→[20.407484:407535](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.407484]

[20.407535]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 1600

[20.407597]→[20.407597:407644](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.407597]

[20.407644]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 1742

[20.411913]→[20.411913:411964](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.411913]

[20.411964]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 1744

[20.412026]→[20.412026:412073](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.412026]

[20.412073]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 1869

[20.415761]→[20.415761:415800](∅→∅)

let mut txn = env.mut_txn_begin();

[20.415761]

[20.415800]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 2007

[20.420284]→[20.420284:420323](∅→∅)

let mut txn = env.mut_txn_begin();

[20.420284]

[20.420323]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 2228

[20.427320]→[20.427320:427359](∅→∅)

let mut txn = env.mut_txn_begin();

[20.427320]

[20.427359]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 2483

[20.436021]→[20.436021:436119](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();
let mut txn_bob = env_bob.mut_txn_begin();

[20.436021]

[20.436119]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 2568

[20.438662]→[20.438662:438713](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.438662]

[20.438713]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/conflict.rs at line 2573

[20.438885]→[20.438885:438932](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.438885]

[20.438932]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/clone.rs at line 17

[20.441948]→[20.441948:441987](∅→∅)

let mut txn = env.mut_txn_begin();

[20.441948]

[20.441987]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/clone.rs at line 49

[20.443043]→[20.443043:443084](∅→∅)

let mut txn2 = env2.mut_txn_begin();

[20.443043]

[20.443084]

let mut txn2 = env2.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/clone.rs at line 89

[20.444336]→[20.444336:444375](∅→∅)

let mut txn = env.mut_txn_begin();

[20.444336]

[20.444375]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/clone.rs at line 116

[20.445212]→[20.445212:445253](∅→∅)

let mut txn2 = env2.mut_txn_begin();

[20.445212]

[20.445253]

let mut txn2 = env2.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/clone.rs at line 155

[20.446327]→[20.446327:446368](∅→∅)

let mut txn2 = env2.mut_txn_begin();

[20.446327]

[20.446368]

let mut txn2 = env2.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/change.rs at line 38

[20.447764]→[20.447764:447803](∅→∅)

let mut txn = env.mut_txn_begin();

[20.447764]

[20.447803]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/change.rs at line 145

[20.450511]→[20.450511:450550](∅→∅)

let mut txn = env.mut_txn_begin();

[20.450511]

[20.450550]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/change.rs at line 170

[20.451437]→[20.451437:451478](∅→∅)

let mut txn2 = env2.mut_txn_begin();

[20.451437]

[20.451478]

let mut txn2 = env2.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/change.rs at line 222

[20.452756]→[20.452756:452848](∅→∅)

let change1 = Change::read(std::io::Cursor::new(&v[..]), &mut HashMap::new()).unwrap();

[20.452756]

[20.452848]

let change1 = Change::read(std::io::Cursor::new(&v[..]), &mut HashMap::default()).unwrap();
replacement in libpijul/src/tests/add_file.rs at line 15

[20.454514]→[20.454514:454557](∅→∅)

let mut txn = env.mut_txn_begin();

[20.454514]

[20.454557]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 23

[20.454845]→[20.25478:25544](∅→∅)

debug_to_file(&txn, &channel.borrow(), "debug").unwrap();

[20.454845]

[20.454900]

debug_to_file(&txn, &channel, "debug").unwrap();
replacement in libpijul/src/tests/add_file.rs at line 34

[20.30201]→[20.455225:455266](∅→∅),[20.455225]→[20.455225:455266](∅→∅)

let channel = channel_.borrow();

[20.30201]

[20.30202]

let channel = channel_.lock().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 43

[20.43645]→[20.30545:30626](∅→∅),[20.30545]→[20.30545:30626](∅→∅)

crate::fs::iter_paths(&txn, &channel_.borrow().graph, file_key, |path| {

[20.43645]

[20.455717]

crate::fs::iter_paths(&txn, &channel.graph, file_key, |path| {
replacement in libpijul/src/tests/add_file.rs at line 52

[20.30657]→[20.25545:25613](∅→∅)

debug_to_file(&txn, &channel_.borrow(), "debug2").unwrap();

[20.30657]

[20.455959]

debug_to_file(&txn, &channel_, "debug2").unwrap();
replacement in libpijul/src/tests/add_file.rs at line 74

[20.456600]→[20.456600:456639](∅→∅)

let mut txn = env.mut_txn_begin();

[20.456600]

[20.456639]

let mut txn = env.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 101

[20.457332]→[20.457332:457442](∅→∅)

let mut repo = working_copy::memory::Memory::new();
let changes = changestore::memory::Memory::new();

[20.457332]

[20.457442]

let mut repo = Arc::new(working_copy::memory::Memory::new());
let changes = Arc::new(changestore::memory::Memory::new());
replacement in libpijul/src/tests/add_file.rs at line 106

[20.457507]→[20.457507:457550](∅→∅),[20.457550]→[20.43735:43849](∅→∅)

let mut txn = env.mut_txn_begin();
txn.add_file("dir/file").unwrap();
let mut channel = txn.open_or_create_channel("main").unwrap();

[20.457507]

[20.457648]

let mut txn = Arc::new(RwLock::new(env.mut_txn_begin().unwrap()));
txn.write().unwrap().add_file("dir/file").unwrap();
let mut channel = txn.write().unwrap().open_or_create_channel("main").unwrap();
replacement in libpijul/src/tests/add_file.rs at line 111

[20.457716]→[20.43850:43935](∅→∅),[20.43935]→[20.25614:25681](∅→∅),[20.457793]→[20.25614:25681](∅→∅),[20.25681]→[20.457849:457925](∅→∅),[20.31890]→[20.457849:457925](∅→∅),[20.457849]→[20.457849:457925](∅→∅)

record_all_output(&mut repo, &changes, &mut txn, &mut channel, "").unwrap();
debug_to_file(&txn, &channel.borrow(), "debug0").unwrap();
let files: Vec<_> = crate::fs::iter_working_copy(&txn, Inode::ROOT)

[20.457716]

[20.31171]

record_all_output(
repo.clone(),
changes.clone(),
txn.clone(),
&channel.clone(),
"",
)
.unwrap();
debug_to_file(&*txn.read().unwrap(), &channel, "debug0").unwrap();
let files: Vec<_> = crate::fs::iter_working_copy(&*txn.read().unwrap(), Inode::ROOT)
replacement in libpijul/src/tests/add_file.rs at line 126

[20.43983]→[20.43983:44024](∅→∅)

txn.remove_file("dir").unwrap();

[20.43983]

[20.458109]

txn.write().unwrap().remove_file("dir").unwrap();
replacement in libpijul/src/tests/add_file.rs at line 128

[20.458110]→[20.458110:458186](∅→∅)

let files: Vec<_> = crate::fs::iter_working_copy(&txn, Inode::ROOT)

[20.458110]

[20.31207]

let files: Vec<_> = crate::fs::iter_working_copy(&*txn.read().unwrap(), Inode::ROOT)
replacement in libpijul/src/tests/add_file.rs at line 134

[20.458320]→[20.44025:44110](∅→∅),[20.44110]→[20.25682:25748](∅→∅),[20.458397]→[20.25682:25748](∅→∅)

record_all_output(&mut repo, &changes, &mut txn, &mut channel, "").unwrap();
debug_to_file(&txn, &channel.borrow(), "debug").unwrap();

[20.458320]

[20.458452]

record_all_output(repo, changes, txn, &channel, "").unwrap();
debug_to_file(&*txn.read().unwrap(), &channel, "debug").unwrap();
replacement in libpijul/src/tests/add_file.rs at line 137

[20.458453]→[20.458453:458529](∅→∅)

let files: Vec<_> = crate::fs::iter_working_copy(&txn, Inode::ROOT)

[20.458453]

[20.31243]

let files: Vec<_> = crate::fs::iter_working_copy(&*txn.read().unwrap(), Inode::ROOT)
replacement in libpijul/src/tests/add_file.rs at line 144

[20.458708]→[20.44111:44197](∅→∅),[20.44197]→[20.31279:31377](∅→∅),[20.458778]→[20.31279:31377](∅→∅),[20.31377]→[20.458876:458927](∅→∅),[20.458876]→[20.458876:458927](∅→∅),[20.458927]→[20.44198:44229](∅→∅)

txn.add_file("dir2/file").unwrap();
txn.remove_file("dir2").unwrap();
assert!(crate::fs::iter_working_copy(&txn, Inode::ROOT).all(|f| f.unwrap().1 != "dir2"));
assert!(txn.remove_file("dir2").is_err());
txn.commit().unwrap();

[20.458708]

[20.458950]

txn.write().unwrap().add_file("dir2/file").unwrap();
txn.write().unwrap().remove_file("dir2").unwrap();
assert!(
crate::fs::iter_working_copy(&*txn.read().unwrap(), Inode::ROOT)
.all(|f| f.unwrap().1 != "dir2")
);
assert!(txn.write().unwrap().remove_file("dir2").is_err());
txn.write().unwrap().commit().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 169

[20.3034]→[20.3034:3144](∅→∅)

let mut repo = working_copy::memory::Memory::new();
let changes = changestore::memory::Memory::new();

[20.3034]

[20.3144]

let mut repo = Arc::new(working_copy::memory::Memory::new());
let changes = Arc::new(changestore::memory::Memory::new());
replacement in libpijul/src/tests/add_file.rs at line 173

[20.3203]→[20.3203:3333](∅→∅)

let mut txn = env.mut_txn_begin();
txn.add_file("a/b/c/d/e")?;
let mut channel = txn.open_or_create_channel("main")?;

[20.3203]

[20.3333]

let mut txn = Arc::new(RwLock::new(env.mut_txn_begin().unwrap()));
txn.write().unwrap().add_file("a/b/c/d/e")?;
let mut channel = txn.write().unwrap().open_or_create_channel("main")?;
replacement in libpijul/src/tests/add_file.rs at line 178

[20.3398]→[20.3398:3471](∅→∅),[20.3471]→[20.25749:25812](∅→∅),[20.25812]→[20.3525:3597](∅→∅),[20.3525]→[20.3525:3597](∅→∅)

record_all_output(&mut repo, &changes, &mut txn, &mut channel, "")?;
debug_to_file(&txn, &channel.borrow(), "debug0").unwrap();
let files: Vec<_> = crate::fs::iter_working_copy(&txn, Inode::ROOT)

[20.3398]

[20.31414]

record_all_output(repo.clone(), changes.clone(), txn.clone(), &channel, "")?;
debug_to_file(&*txn.read().unwrap(), &channel, "debug0").unwrap();
let files: Vec<_> = crate::fs::iter_working_copy(&*txn.read().unwrap(), Inode::ROOT)
replacement in libpijul/src/tests/add_file.rs at line 187

[20.3793]→[20.3793:3866](∅→∅),[20.3866]→[20.25813:25875](∅→∅)

record_all_output(&mut repo, &changes, &mut txn, &mut channel, "")?;
debug_to_file(&txn, &channel.borrow(), "debug").unwrap();

[20.3793]

[20.3919]

record_all_output(repo.clone(), changes.clone(), txn.clone(), &channel, "")?;
debug_to_file(&*txn.read().unwrap(), &channel, "debug").unwrap();
replacement in libpijul/src/tests/add_file.rs at line 190

[20.3920]→[20.3920:3977](∅→∅)

let mut repo2 = working_copy::memory::Memory::new();

[20.3920]

[20.5386]

let mut repo2 = Arc::new(working_copy::memory::Memory::new());
replacement in libpijul/src/tests/add_file.rs at line 192

[20.5428]→[20.5428:5506](∅→∅)

&mut repo2,
&changes,
&mut txn,
&mut channel,

[20.5428]

[20.5506]

repo2,
changes,
txn.clone(),
channel.clone(),
edit in libpijul/src/tests/add_file.rs at line 199

[20.5546]

[20.5546]

1,
replacement in libpijul/src/tests/add_file.rs at line 203

[20.4131]→[20.4131:4203](∅→∅)

let files: Vec<_> = crate::fs::iter_working_copy(&txn, Inode::ROOT)

[20.4131]

[20.31446]

let files: Vec<_> = crate::fs::iter_working_copy(&*txn.read().unwrap(), Inode::ROOT)
replacement in libpijul/src/tests/add_file.rs at line 216

[20.459375]→[20.459375:459485](∅→∅)

let mut repo = working_copy::memory::Memory::new();
let changes = changestore::memory::Memory::new();

[20.459375]

[20.459485]

let mut repo = Arc::new(working_copy::memory::Memory::new());
let changes = Arc::new(changestore::memory::Memory::new());
replacement in libpijul/src/tests/add_file.rs at line 220

[20.459544]→[20.459544:459673](∅→∅)

let mut txn = env.mut_txn_begin();
txn.add_file("dir/file")?;
let mut channel = txn.open_or_create_channel("main")?;

[20.459544]

[20.459673]

let mut txn = Arc::new(RwLock::new(env.mut_txn_begin().unwrap()));
txn.write().unwrap().add_file("dir/file")?;
let mut channel = txn.write().unwrap().open_or_create_channel("main")?;
replacement in libpijul/src/tests/add_file.rs at line 225

[20.459737]→[20.459737:459818](∅→∅),[20.459818]→[20.25876:25938](∅→∅)

record_all_output(&mut repo, &changes, &mut txn, &mut channel, "").unwrap();
debug_to_file(&txn, &channel.borrow(), "debug").unwrap();

[20.459737]

[20.459869]

record_all_output(repo.clone(), changes.clone(), txn.clone(), &channel, "").unwrap();
debug_to_file(&*txn.read().unwrap(), &channel, "debug").unwrap();
replacement in libpijul/src/tests/add_file.rs at line 228

[20.459870]→[20.7882:7944](∅→∅),[20.7944]→[20.459908:460049](∅→∅),[20.459908]→[20.459908:460049](∅→∅)

repo.write_file::<_, std::io::Error, _>("dir/file", |w| {
w.write_all(b"a\nb\nc\n")?;
Ok(())
})?;
record_all_output(&mut repo, &changes, &mut txn, &mut channel, "").unwrap();

[20.459870]

[20.460049]

repo.write_file("dir/file")
.unwrap()
.write_all(b"a\nb\nc\n")
.unwrap();
record_all_output(repo.clone(), changes.clone(), txn.clone(), &channel, "").unwrap();
replacement in libpijul/src/tests/add_file.rs at line 237

[20.26001]→[20.460244:460263](∅→∅),[20.32056]→[20.460244:460263](∅→∅),[20.460244]→[20.460244:460263](∅→∅)

txn.commit()?;

[20.26001]

[20.460263]

txn.write().unwrap().commit()?;
replacement in libpijul/src/tests/add_file.rs at line 250

[20.460591]→[20.460591:460720](∅→∅)

let mut txn = env.mut_txn_begin();
txn.add_file("dir/file")?;
let mut channel = txn.open_or_create_channel("main")?;

[20.460591]

[20.460720]

let mut txn = env.mut_txn_begin().unwrap();
txn.write().unwrap().add_file("dir/file")?;
let mut channel = txn.write().unwrap().open_or_create_channel("main")?;
replacement in libpijul/src/tests/add_file.rs at line 278

[20.26193]→[20.461680:461699](∅→∅),[20.32221]→[20.461680:461699](∅→∅),[20.461680]→[20.461680:461699](∅→∅)

txn.commit()?;

[20.26193]

[20.461699]

txn.write().unwrap().commit()?;
replacement in libpijul/src/tests/add_file.rs at line 293

[20.462103]→[20.462103:462154](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.462103]

[20.462154]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 306

[20.462723]→[20.462723:462770](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.462723]

[20.462770]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 351

[20.464130]→[20.464130:464181](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.464130]

[20.464181]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 379

[20.465323]→[20.465323:465370](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.465323]

[20.465370]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 434

[20.466813]→[20.466813:466864](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.466813]

[20.466864]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 469

[20.467955]→[20.467955:468006](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.467955]

[20.468006]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 489

[20.468866]→[20.468866:468913](∅→∅)

let mut txn_bob = env_bob.mut_txn_begin();

[20.468866]

[20.468913]

let mut txn_bob = env_bob.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 667

[20.474074]→[20.474074:474125](∅→∅)

let mut txn_alice = env_alice.mut_txn_begin();

[20.474074]

[20.474125]

let mut txn_alice = env_alice.mut_txn_begin().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 778

[20.477335]→[20.477335:477412](∅→∅)

let mut txn = env.mut_txn_begin();
txn.add_file("filedir").unwrap();

[20.477335]

[20.477412]

let mut txn = env.mut_txn_begin().unwrap();
txn.write().unwrap().add_file("filedir").unwrap();
replacement in libpijul/src/tests/add_file.rs at line 781

[20.477413]→[20.477413:477480](∅→∅)

let mut channel = txn.open_or_create_channel("main").unwrap();

[20.477413]

[20.477480]

let mut channel = txn.write().unwrap().open_or_create_channel("main").unwrap();
replacement in libpijul/src/tests/add_file.rs at line 786

[20.477664]→[20.477664:477707](∅→∅)

txn.add_file("filedir/file").unwrap();

[20.477664]

[20.477707]

txn.write().unwrap().add_file("filedir/file").unwrap();
replacement in libpijul/src/tests/add_file.rs at line 802

[20.478129]→[20.478129:478270](∅→∅)

let mut txn = env.mut_txn_begin();
txn.add_file("dir/file")?;
let mut channel = txn.open_or_create_channel("main")?;

[20.478129]

[20.478270]

let mut txn = env.mut_txn_begin().unwrap();
txn.write().unwrap().add_file("dir/file")?;
let mut channel = txn.write().unwrap().open_or_create_channel("main")?;
replacement in libpijul/src/tests/add_file.rs at line 824

[20.478868]→[20.478868:478974](∅→∅)

let mut txn = env.mut_txn_begin();
let mut channel = txn.open_or_create_channel("main")?;

[20.478868]

[20.478974]

let mut txn = env.mut_txn_begin().unwrap();
let mut channel = txn.write().unwrap().open_or_create_channel("main")?;
replacement in libpijul/src/tests/add_file.rs at line 844

[20.479571]→[20.479571:479669](∅→∅)

let mut txn = env.mut_txn_begin();
let mut channel = txn.open_or_create_channel("main")?;

[20.479571]

[20.479669]

let mut txn = env.mut_txn_begin().unwrap();
let mut channel = txn.write().unwrap().open_or_create_channel("main")?;
replacement in libpijul/src/tests/add_file.rs at line 858

[20.480052]→[20.480052:480150](∅→∅)

let mut txn = env.mut_txn_begin();
let mut channel = txn.open_or_create_channel("main")?;

[20.480052]

[20.480150]

let mut txn = env.mut_txn_begin().unwrap();
let mut channel = txn.write().unwrap().open_or_create_channel("main")?;
replacement in libpijul/src/tests/add_file.rs at line 862

[20.480210]→[20.480210:480237](∅→∅)

txn.add_file("file")?;

[20.480210]

[20.480237]

txn.write().unwrap().add_file("file")?;
replacement in libpijul/src/record.rs at line 11

[20.489199]→[17.935:977](∅→∅)

use std::collections::{HashMap, HashSet};

[20.489199]

[20.11033]

use crate::{HashMap, HashSet};
use std::collections::VecDeque;
use std::sync::{Arc, Mutex, RwLock};
replacement in libpijul/src/record.rs at line 51

[20.489392]→[20.489392:489422](∅→∅),[20.489422]→[20.48769:48836](∅→∅),[20.48836]→[20.489479:489628](∅→∅),[20.489479]→[20.489479:489628](∅→∅)

pub(crate) rec: Recorded,
pub(crate) redundant: Vec<(Vertex<ChangeId>, SerializedEdge)>,
recorded_inodes: HashMap<Inode, Position<Option<ChangeId>>>,
deleted_vertices: HashSet<Position<ChangeId>>,
former_parents: Vec<Parent>,

[20.489392]

[7.1844]

pub(crate) rec: Vec<Arc<Mutex<Recorded>>>,
recorded_inodes: Arc<Mutex<HashMap<Inode, Position<Option<ChangeId>>>>>,
deleted_vertices: Arc<Mutex<HashSet<Position<ChangeId>>>>,
edit in libpijul/src/record.rs at line 56

[7.1902]

[20.489652]

pub contents: Arc<Mutex<Vec<u8>>>,
replacement in libpijul/src/record.rs at line 69

[20.489885]→[20.489885:489912](∅→∅)

pub contents: Vec<u8>,

[20.489885]

[20.489912]

pub contents: Arc<Mutex<Vec<u8>>>,
edit in libpijul/src/record.rs at line 82

[20.1061]

[20.490405]

/// Redundant edges found during the comparison.
pub redundant: Vec<(Vertex<ChangeId>, SerializedEdge)>,
/// Force a re-diff
force_rediff: bool,
deleted_vertices: Arc<Mutex<HashSet<Position<ChangeId>>>>,
recorded_inodes: Arc<Mutex<HashMap<Inode, Position<Option<ChangeId>>>>>,
replacement in libpijul/src/record.rs at line 93

[20.454]→[20.1062:1283](∅→∅),[20.1283]→[8.0:66](∅→∅),[8.66]→[20.1344:1359](∅→∅),[20.1344]→[20.1344:1359](∅→∅),[20.492]→[20.490736:490902](∅→∅),[20.1359]→[20.490736:490902](∅→∅),[20.490736]→[20.490736:490902](∅→∅)

rec: Recorded {
contents: Vec::new(),
actions: Vec::new(),
updatables: HashMap::new(),
largest_file: 0,
has_binary_files: false,
oldest_change: std::time::SystemTime::UNIX_EPOCH,
},
redundant: Vec::new(),
recorded_inodes: HashMap::new(),
deleted_vertices: HashSet::new(),
former_parents: Vec::new(),

[20.454]

[20.1360]

rec: Vec::new(),
recorded_inodes: Arc::new(Mutex::new(HashMap::default())),
edit in libpijul/src/record.rs at line 97

[7.1938]

[20.490934]

deleted_vertices: Arc::new(Mutex::new(HashSet::default())),
contents: Arc::new(Mutex::new(Vec::new())),
edit in libpijul/src/record.rs at line 109

[20.601]

[20.490951]

pub fn recorded(&mut self) -> Arc<Mutex<Recorded>> {
let m = Arc::new(Mutex::new(self.recorded_()));
self.rec.push(m.clone());
m
}

fn recorded_(&self) -> Recorded {
Recorded {
contents: self.contents.clone(),
actions: Vec::new(),
updatables: HashMap::default(),
largest_file: 0,
has_binary_files: false,
oldest_change: std::time::SystemTime::UNIX_EPOCH,
redundant: Vec::new(),
force_rediff: self.force_rediff,
deleted_vertices: self.deleted_vertices.clone(),
recorded_inodes: self.recorded_inodes.clone(),
}
}
replacement in libpijul/src/record.rs at line 131

[20.490981]→[20.490981:491036](∅→∅)

pub fn finish(self) -> Recorded {
self.rec

[20.490981]

[20.491036]

pub fn finish(mut self) -> Recorded {
if self.rec.is_empty() {
self.recorded();
}
let mut it = self.rec.into_iter();
let mut result = if let Ok(rec) = Arc::try_unwrap(it.next().unwrap()) {
rec.into_inner().unwrap()
} else {
unreachable!()
};
for rec in it {
let rec = if let Ok(rec) = Arc::try_unwrap(rec) {
rec.into_inner().unwrap()
} else {
unreachable!()
};
let off = result.actions.len();
result.actions.extend(rec.actions.into_iter());
for (a, b) in rec.updatables {
result.updatables.insert(a + off, b);
}
result.largest_file = result.largest_file.max(rec.largest_file);
result.has_binary_files |= rec.has_binary_files;
result.oldest_change = result.oldest_change.min(rec.oldest_change);
result.redundant.extend(rec.redundant.into_iter())
}
debug!(
"result = {:?}, updatables = {:?}",
result.actions, result.updatables
);
result
replacement in libpijul/src/record.rs at line 183

[20.491573]→[20.491573:491597](∅→∅)

struct RecordItem<'a> {

[20.491573]

[20.491597]

struct RecordItem {
edit in libpijul/src/record.rs at line 190

[20.491746]→[20.491746:491778](∅→∅)

components: Components<'a>,
replacement in libpijul/src/record.rs at line 192

[20.491781]→[20.491781:491846](∅→∅)

impl<'a> RecordItem<'a> {
fn root(prefix: &'a str) -> Self {

[20.491781]

[20.491846]

impl RecordItem {
fn root() -> Self {
edit in libpijul/src/record.rs at line 201

[20.492099]→[20.492099:492143](∅→∅)

components: components(prefix),
edit in libpijul/src/record.rs at line 208

[20.492241]

[20.48837]

fn get_inodes_<T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>>(
txn: Arc<RwLock<T>>,
channel: ChannelRef<T>,
inode: &Inode,
) -> Result<Option<Position<ChangeId>>, TxnErr<T::GraphError>> {
let txn = txn.read().unwrap();
let channel = channel.r.read().unwrap();
Ok(get_inodes(&*txn, &*channel, inode)?.map(|x| *x))
}
replacement in libpijul/src/record.rs at line 224

[20.32350]→[20.492397:492412](∅→∅),[20.492397]→[20.492397:492412](∅→∅),[20.492412]→[20.49031:49097](∅→∅),[20.1201]→[20.492478:492501](∅→∅),[20.28094]→[20.492478:492501](∅→∅),[20.32418]→[20.492478:492501](∅→∅),[20.49097]→[20.492478:492501](∅→∅),[20.492478]→[20.492478:492501](∅→∅)

if txn
.get_changeset(txn.changes(channel), &vertex.change)?
.is_some()

[20.32350]

[20.492501]

if let Some(e) = iter_adjacent(
txn,
txn.graph(channel),
vertex.inode_vertex(),
EdgeFlags::PARENT,
EdgeFlags::all(),
)?
.next()
replacement in libpijul/src/record.rs at line 233

[20.492511]→[20.32419:32448](∅→∅),[20.32448]→[20.492536:492553](∅→∅),[20.492536]→[20.492536:492553](∅→∅),[20.492553]→[20.32449:32470](∅→∅)

Ok(Some(vertex))
} else {
Ok(None)

[20.492511]

[20.492570]

if e?.flag().is_alive_parent() {
return Ok(Some(vertex));
}
edit in libpijul/src/record.rs at line 237

[20.492580]

[20.492580]

Ok(None)
edit in libpijul/src/record.rs at line 241

[20.492612]

[20.492612]

}

struct Tasks {
stop: bool,
t: VecDeque<(
RecordItem,
Position<ChangeId>,
Arc<Mutex<Recorded>>,
Option<Position<Option<ChangeId>>>,
)>,
replacement in libpijul/src/record.rs at line 254

[20.492630]→[20.28095:28149](∅→∅)

pub fn record<T, W: WorkingCopy, C: ChangeStore>(

[20.492630]

[20.492700]

pub fn record<
T,
W: WorkingCopy + Send + Sync + 'static,
C: ChangeStore + Clone + Send + 'static,
>(
replacement in libpijul/src/record.rs at line 260

[20.492719]→[20.492719:492740](∅→∅)

txn: &mut T,

[20.492719]

[20.492740]

txn: Arc<RwLock<T>>,
replacement in libpijul/src/record.rs at line 262

[20.492781]→[20.28150:28184](∅→∅),[20.28184]→[20.492818:492848](∅→∅),[20.32585]→[20.492818:492848](∅→∅),[20.492818]→[20.492818:492848](∅→∅)

channel: &mut T::Channel,
working_copy: &mut W,

[20.492781]

[20.492848]

channel: ChannelRef<T>,
working_copy: Arc<W>,
edit in libpijul/src/record.rs at line 266

[20.492891]

[20.32586]

_n_workers: usize,
replacement in libpijul/src/record.rs at line 269

[20.32664]→[20.28185:28265](∅→∅)

T: ChannelMutTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,

[20.32664]

[20.32756]

T: ChannelMutTxnT
+ TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>
+ Send
+ Sync
+ 'static,
T::Channel: Send + Sync,
edit in libpijul/src/record.rs at line 277

[20.32806]

[20.492928]

let work = Arc::new(Mutex::new(Tasks {
t: VecDeque::new(),
stop: false,
}));
let mut workers: Vec<std::thread::JoinHandle<()>> = Vec::new();
for t in 0..0 {
// n_workers - 1 {
let working_copy = working_copy.clone();
let changes = changes.clone();
let channel = channel.clone();
let work = work.clone();
let txn = txn.clone();
workers.push(std::thread::spawn(move || loop {
let (w, stop) = {
let mut work = work.lock().unwrap();
(work.t.pop_front(), work.stop)
};
if let Some((item, vertex, rec, new_papa)) = w {
// This parent has changed.
info!("record existing file {:?} on thread {:?}", item, t);
rec.lock()
.unwrap()
.record_existing_file(
txn.clone(),
diff_algorithm,
channel.clone(),
working_copy.clone(),
&changes,
&item,
new_papa,
vertex,
)
.unwrap();
} else if stop {
info!("stop {:?}", t);
break;
} else {
info!("yield {:?}", t);
std::thread::park_timeout(std::time::Duration::from_secs(1));
}
}))
}
replacement in libpijul/src/record.rs at line 321

[20.493013]→[20.493013:493118](∅→∅)

let mut stack = vec![RecordItem::root(prefix)];
while let Some(mut item) = stack.pop() {

[20.492973]

[20.493118]

let mut stack = vec![(RecordItem::root(), components(prefix))];
while let Some((mut item, mut components)) = stack.pop() {
replacement in libpijul/src/record.rs at line 326

[20.493224]→[20.493224:493335](∅→∅)

let vertex = if let Some(vertex) = self.recorded_inodes.get(&item.inode) {
*vertex

[20.493224]

[20.493335]

let vertex: Option<Position<Option<ChangeId>>> = self
.recorded_inodes
.lock()
.unwrap()
.get(&item.inode)
.cloned();
let vertex = if let Some(vertex) = vertex {
vertex
edit in libpijul/src/record.rs at line 336

[20.493422]

[20.493422]

.lock()
.unwrap()
edit in libpijul/src/record.rs at line 339

[20.493487]

[20.493487]

debug!("TAKING LOCK {}", line!());
let txn = txn.read().unwrap();
debug!("TAKEN");
let channel = channel.r.read().unwrap();
debug!("TAKEN 2");
replacement in libpijul/src/record.rs at line 345

[20.493534]→[20.493534:493559](∅→∅),[20.493559]→[20.1202:1242](∅→∅),[20.1242]→[20.493589:493623](∅→∅),[20.28305]→[20.493589:493623](∅→∅),[20.32843]→[20.493589:493623](∅→∅),[20.493589]→[20.493589:493623](∅→∅)

txn,
txn.graph(channel),
working_copy,

[20.493534]

[20.0]

&*txn,
txn.graph(&channel),
working_copy.as_ref(),
replacement in libpijul/src/record.rs at line 353

[20.493753]→[20.49098:49182](∅→∅),[20.49182]→[20.0:72](∅→∅),[20.32947]→[20.0:72](∅→∅),[20.72]→[20.1243:1283](∅→∅),[20.1283]→[20.111:259](∅→∅),[20.111]→[20.111:259](∅→∅),[20.259]→[20.493834:494183](∅→∅),[20.32947]→[20.493834:494183](∅→∅),[20.493834]→[20.493834:494183](∅→∅)

} else if let Some(&vertex) = get_inodes(txn, &channel, &item.inode)? {
self.delete_obsolete_children(
txn,
txn.graph(channel),
working_copy,
changes,
&item.full_path,
vertex,
)?;
self.record_existing_file(
txn,
diff_algorithm,
&channel,
working_copy,
changes,
&item,
vertex,
)?;
self.recorded_inodes.insert(item.inode, vertex.to_option());

[20.493753]

[20.494411]

} else if let Some(vertex) = get_inodes_(txn.clone(), channel.clone(), &item.inode)? {
{
let mut txn = txn.write().unwrap();
let mut channel = channel.r.write().unwrap();
let mut graph = txn.graph(&mut *channel);
self.delete_obsolete_children(
&mut *txn,
&mut graph,
working_copy.as_ref(),
changes,
&item.full_path,
vertex,
)?;
}

let rec = self.recorded();
let new_papa = {
let mut recorded = self.recorded_inodes.lock().unwrap();
recorded.insert(item.inode, vertex.to_option());
recorded.get(&item.papa).cloned()
};
let mut work = work.lock().unwrap();
work.t.push_back((item.clone(), vertex, rec, new_papa));
std::mem::drop(work);
for t in workers.iter() {
t.thread().unpark()
}
replacement in libpijul/src/record.rs at line 383

[20.494467]→[20.494467:494533](∅→∅)

match self.add_file(working_copy, item.clone()) {

[20.494467]

[20.494533]

let rec = self.recorded();
debug!("TAKING LOCK {}", line!());
let mut rec = rec.lock().unwrap();
match rec.add_file(working_copy.as_ref(), item.clone()) {
replacement in libpijul/src/record.rs at line 389

[20.494649]→[20.494649:494722](∅→∅)

self.recorded_inodes.insert(item.inode, vertex);

[20.494649]

[20.494722]

self.recorded_inodes
.lock()
.unwrap()
.insert(item.inode, vertex);
edit in libpijul/src/record.rs at line 400

[20.495237]

[20.11697]

debug!("TAKING LOCK {}", line!());
let txn = txn.read().unwrap();
let channel = channel.r.read().unwrap();
replacement in libpijul/src/record.rs at line 404

[20.11740]→[20.495269:495346](∅→∅),[20.495269]→[20.495269:495346](∅→∅)

txn,
&channel,
working_copy,

[20.11740]

[20.495346]

&*txn,
&*channel,
working_copy.as_ref(),
edit in libpijul/src/record.rs at line 408

[20.495373]

[20.495373]

&mut components,
edit in libpijul/src/record.rs at line 413

[20.495465]

[20.495465]

}

info!("stop work");
work.lock().unwrap().stop = true;
for t in workers.iter() {
t.thread().unpark()
}
loop {
let w = {
let mut work = work.lock().unwrap();
debug!("waiting, stop = {:?}", work.stop);
work.t.pop_front()
};
if let Some((item, vertex, rec, new_papa)) = w {
// This parent has changed.
info!("record existing file {:?}", item);
rec.lock()
.unwrap()
.record_existing_file(
txn.clone(),
diff_algorithm,
channel.clone(),
working_copy.clone(),
changes,
&item,
new_papa,
vertex,
)
.unwrap();
} else {
break;
}
}
for (n, t) in workers.into_iter().enumerate() {
debug!("WAITING {:?}", n);
t.join().unwrap()
edit in libpijul/src/record.rs at line 451

[20.495538]

[20.495538]

info!("record done");
edit in libpijul/src/record.rs at line 455

[2.1]

[20.495618]

fn delete_obsolete_children<
T: GraphTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
W: WorkingCopy,
C: ChangeStore,
>(
&mut self,
txn: &T,
channel: &T::Graph,
working_copy: &W,
changes: &C,
full_path: &str,
v: Position<ChangeId>,
) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
where
<W as WorkingCopy>::Error: 'static,
{
if self.ignore_missing {
return Ok(());
}
let f0 = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
let f1 = f0 | EdgeFlags::PSEUDO;
debug!("delete_obsolete_children, v = {:?}", v);
for child in iter_adjacent(txn, channel, v.inode_vertex(), f0, f1)? {
let child = child?;
let child = txn.find_block(channel, child.dest()).unwrap();
for grandchild in iter_adjacent(txn, channel, *child, f0, f1)? {
let grandchild = grandchild?;
debug!("grandchild {:?}", grandchild);
let needs_deletion =
if let Some(inode) = txn.get_revinodes(&grandchild.dest(), None)? {
debug!("inode = {:?} {:?}", inode, txn.get_revtree(inode, None));
if let Some(path) = crate::fs::inode_filename(txn, *inode)? {
working_copy.file_metadata(&path).is_err()
} else {
true
}
} else {
true
};
if needs_deletion {
let mut name = Vec::new();
changes
.get_contents(
|p| txn.get_external(&p).unwrap().map(From::from),
*child,
&mut name,
)
.map_err(RecordError::Changestore)?;
let mut full_path = full_path.to_string();
if name.len() > 2 {
if let Ok(name) = std::str::from_utf8(&name[2..]) {
if !full_path.is_empty() {
full_path.push('/');
}
full_path.push_str(name);
}
}
// delete recursively.
let rec = self.recorded();
let mut rec = rec.lock().unwrap();
rec.record_deleted_file(
txn,
&channel,
working_copy,
&full_path,
grandchild.dest(),
)?
}
}
}
Ok(())
}

fn push_children<
'a,
T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
W: WorkingCopy,
C: ChangeStore,
>(
&mut self,
txn: &T,
channel: &T::Channel,
working_copy: &W,
item: &mut RecordItem,
components: &mut Components<'a>,
vertex: Position<Option<ChangeId>>,
stack: &mut Vec<(RecordItem, Components<'a>)>,
prefix: &str,
) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
where
<W as crate::working_copy::WorkingCopy>::Error: 'static,
{
debug!("push_children, item = {:?}", item);
let comp = components.next();
let full_path = item.full_path.clone();
let fileid = OwnedPathId {
parent_inode: item.inode,
basename: SmallString::new(),
};
let mut has_matching_children = false;
for x in txn.iter_tree(&fileid, None)? {
let (fileid_, child_inode) = x?;
debug!("push_children {:?} {:?}", fileid_, child_inode);
if fileid_.parent_inode < fileid.parent_inode || fileid_.basename.is_empty() {
continue;
} else if fileid_.parent_inode > fileid.parent_inode {
break;
}
if let Some(comp) = comp {
if comp != fileid_.basename.as_str() {
continue;
}
}
has_matching_children = true;
let basename = fileid_.basename.as_str().to_string();
let full_path = if full_path.is_empty() {
basename.clone()
} else {
full_path.clone() + "/" + &basename
};
debug!("fileid_ {:?} child_inode {:?}", fileid_, child_inode);
if let Ok(meta) = working_copy.file_metadata(&full_path) {
stack.push((
RecordItem {
papa: item.inode,
inode: *child_inode,
v_papa: vertex,
basename,
full_path,
metadata: meta,
},
components.clone(),
));
} else if let Some(vertex) = get_inodes(txn, &channel, child_inode)? {
let rec = self.recorded();
let mut rec = rec.lock().unwrap();
rec.record_deleted_file(txn, txn.graph(channel), working_copy, &full_path, *vertex)?
}
}
if comp.is_some() && !has_matching_children {
debug!("comp = {:?}", comp);
return Err(RecordError::PathNotInRepo(prefix.to_string()));
}
Ok(())
}
}

fn modified_since_last_commit<T: ChannelTxnT, W: WorkingCopy>(
txn: &T,
channel: &T::Channel,
working_copy: &W,
prefix: &str,
) -> Result<bool, std::time::SystemTimeError> {
if let Ok(last_modified) = working_copy.modified_time(prefix) {
debug!(
"last_modified = {:?}, channel.last = {:?}",
last_modified
.duration_since(std::time::UNIX_EPOCH)?
.as_secs(),
txn.last_modified(channel)
);
Ok(last_modified
.duration_since(std::time::UNIX_EPOCH)?
.as_secs()
>= txn.last_modified(channel))
} else {
Ok(true)
}
}

impl Recorded {
replacement in libpijul/src/record.rs at line 628

[20.495670]→[20.495670:495700](∅→∅)

working_copy: &mut W,

[20.495670]

[20.495700]

working_copy: &W,
replacement in libpijul/src/record.rs at line 633

[20.495974]→[20.49183:49256](∅→∅),[20.49256]→[20.496047:496160](∅→∅),[20.496047]→[20.496047:496160](∅→∅),[20.496160]→[20.49257:49328](∅→∅),[20.49328]→[20.496294:496329](∅→∅),[20.496294]→[20.496294:496329](∅→∅),[20.496329]→[20.49329:49401](∅→∅),[20.49401]→[20.496401:496436](∅→∅),[20.496401]→[20.496401:496436](∅→∅)

let name_start = ChangePosition(self.rec.contents.len().into());
meta.write(&mut self.rec.contents).unwrap();
self.rec.contents.extend(item.basename.as_bytes());
let name_end = ChangePosition(self.rec.contents.len().into());
self.rec.contents.push(0);
let inode_pos = ChangePosition(self.rec.contents.len().into());
self.rec.contents.push(0);

[20.495974]

[20.496436]

let mut contents = self.contents.lock().unwrap();
let name_start = ChangePosition(contents.len().into());
// Push the metadata, big-endian.
contents.push((meta.0 >> 8) as u8);
contents.push((meta.0 & 0xff) as u8);
//
contents.extend(item.basename.as_bytes());
let name_end = ChangePosition(contents.len().into());
contents.push(0);
let inode_pos = ChangePosition(contents.len().into());
contents.push(0);
replacement in libpijul/src/record.rs at line 646

[20.496480]→[20.49402:49474](∅→∅),[20.49474]→[20.496552:496630](∅→∅),[20.496552]→[20.496552:496630](∅→∅),[20.496630]→[20.49475:49643](∅→∅),[20.49643]→[20.496780:496823](∅→∅),[20.496780]→[20.496780:496823](∅→∅)

let start = ChangePosition(self.rec.contents.len().into());
working_copy.read_file(&item.full_path, &mut self.rec.contents)?;
let end = ChangePosition(self.rec.contents.len().into());
self.rec.largest_file = self.rec.largest_file.max(end.0.as_u64() - start.0.as_u64());
self.rec.has_binary_files |= {

[20.496480]

[20.49644]

let start = ChangePosition(contents.len().into());
working_copy.read_file(&item.full_path, &mut contents)?;
let end = ChangePosition(contents.len().into());
self.largest_file = self.largest_file.max(end.0.as_u64() - start.0.as_u64());
self.has_binary_files |= {
replacement in libpijul/src/record.rs at line 653

[20.49750]→[20.496931:497005](∅→∅),[20.496931]→[20.496931:497005](∅→∅)

let utf8 = std::str::from_utf8(&self.rec.contents[s..e]);

[20.49750]

[20.497005]

let utf8 = std::str::from_utf8(&contents[s..e]);
replacement in libpijul/src/record.rs at line 660

[20.497208]→[20.497208:497247](∅→∅)

self.rec.contents.push(0);

[20.497208]

[20.0]

contents.push(0);
replacement in libpijul/src/record.rs at line 682

[20.497912]→[20.1663:1709](∅→∅)

self.rec.actions.push(Hunk::FileAdd {

[20.497912]

[20.498023]

self.actions.push(Hunk::FileAdd {
replacement in libpijul/src/record.rs at line 705

[20.498812]→[20.498812:498870](∅→∅),[20.498933]→[20.498933:499005](∅→∅)

debug!("{:?}", self.rec.actions.last().unwrap());
self.rec.updatables.insert(
self.rec.actions.len(),

[20.498812]

[20.499005]

debug!("{:?}", self.actions.last().unwrap());
self.updatables.insert(
self.actions.len(),
replacement in libpijul/src/record.rs at line 724

[20.32977]→[20.28306:28386](∅→∅)

T: ChannelMutTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,

[20.32977]

[20.33054]

T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
replacement in libpijul/src/record.rs at line 729

[20.499475]→[20.499475:499496](∅→∅)

txn: &mut T,

[20.499475]

[20.499496]

txn: Arc<RwLock<T>>,
replacement in libpijul/src/record.rs at line 731

[20.499537]→[20.28387:28417](∅→∅),[20.28417]→[20.499567:499597](∅→∅),[20.499567]→[20.499567:499597](∅→∅)

channel: &T::Channel,
working_copy: &mut W,

[20.499537]

[20.499597]

channel: ChannelRef<T>,
working_copy: Arc<W>,
edit in libpijul/src/record.rs at line 735

[20.499645]

[20.499645]

new_papa: Option<Position<Option<ChangeId>>>,
replacement in libpijul/src/record.rs at line 746

[20.499882]→[20.499882:499919](∅→∅)

self.former_parents.clear();

[20.499882]

[20.499919]

let mut former_parents = Vec::new();
replacement in libpijul/src/record.rs at line 750

[20.500045]→[20.49751:49752](∅→∅),[20.49752]→[20.1284:1378](∅→∅),[20.500045]→[20.1284:1378](∅→∅)

for name_ in iter_adjacent(txn, txn.graph(channel), vertex.inode_vertex(), f0, f1)? {

[20.500045]

[20.49753]

let txn_ = txn.read().unwrap();
let channel_ = channel.read().unwrap();
for name_ in iter_adjacent(
&*txn_,
txn_.graph(&*channel_),
vertex.inode_vertex(),
f0,
f1,
)? {
replacement in libpijul/src/record.rs at line 770

[20.500452]→[20.6417:6515](∅→∅)

let name_dest = txn
.find_block_end(txn.graph(channel), name_.dest())

[20.500452]

[20.6515]

let name_dest = txn_
.find_block_end(txn_.graph(&*channel_), name_.dest())
replacement in libpijul/src/record.rs at line 776

[20.6574]→[20.6574:6645](∅→∅)

|p| txn.get_external(&p).unwrap().map(From::from),

[20.6574]

[20.6645]

|p| txn_.get_external(&p).unwrap().map(From::from),
replacement in libpijul/src/record.rs at line 788

[20.905]→[20.50150:50251](∅→∅)

if let Some(v_papa) = iter_adjacent(txn, txn.graph(channel), *name_dest, f0, f1)?.next()

[20.905]

[20.495]

if let Some(v_papa) =
iter_adjacent(&*txn_, txn_.graph(&*channel_), *name_dest, f0, f1)?.next()
replacement in libpijul/src/record.rs at line 793

[20.50317]→[20.150:204](∅→∅),[20.150]→[20.150:204](∅→∅)

self.former_parents.push(Parent {

[20.50317]

[20.204]

former_parents.push(Parent {
replacement in libpijul/src/record.rs at line 803

[20.501290]→[20.501290:501341](∅→∅)

item, self.former_parents, is_deleted,

[20.501290]

[20.501341]

item, former_parents, is_deleted,
replacement in libpijul/src/record.rs at line 805

[20.501352]→[20.501352:501402](∅→∅)

assert!(!self.former_parents.is_empty());

[20.501352]

[20.501402]

assert!(!former_parents.is_empty());
replacement in libpijul/src/record.rs at line 808

[20.501527]→[20.501527:501772](∅→∅)

if self.former_parents.len() > 1
|| self.former_parents[0].basename != item.basename
|| self.former_parents[0].metadata != item.metadata
|| self.former_parents[0].parent != item.v_papa

[20.501527]

[20.501772]

if former_parents.len() > 1
|| former_parents[0].basename != item.basename
|| former_parents[0].metadata != item.metadata
|| former_parents[0].parent != item.v_papa
edit in libpijul/src/record.rs at line 814

[20.501816]→[20.501816:501939](∅→∅)

// This parent has changed.
let new_papa = *self.recorded_inodes.get(&item.papa).unwrap();
replacement in libpijul/src/record.rs at line 817

[20.502061]→[20.502061:502086](∅→∅),[20.502086]→[20.1572:1612](∅→∅)

txn,
txn.graph(channel),

[20.502061]

[20.502116]

&*txn_,
txn_.graph(&*channel_),
replacement in libpijul/src/record.rs at line 821

[20.502171]→[20.502171:502201](∅→∅)

new_papa,

[20.502171]

[20.33880]

new_papa.unwrap(),
replacement in libpijul/src/record.rs at line 826

[20.502359]→[20.1613:1698](∅→∅),[20.1698]→[20.380:452](∅→∅),[20.380]→[20.380:452](∅→∅)

|| self.modified_since_last_commit(
txn,
&channel,
working_copy,

[20.502359]

[20.452]

|| modified_since_last_commit(
&*txn_,
&*channel_,
working_copy.as_ref(),
replacement in libpijul/src/record.rs at line 833

[20.502466]→[20.1699:1773](∅→∅)

let mut ret = retrieve(txn, txn.graph(channel), vertex)?;

[20.502466]

[20.502529]

let mut ret = retrieve(&*txn_, txn_.graph(&*channel_), vertex)?;
replacement in libpijul/src/record.rs at line 839

[20.502673]→[20.502673:502723](∅→∅)

let len = self.rec.actions.len();

[20.502673]

[20.502723]

let len = self.actions.len();
replacement in libpijul/src/record.rs at line 842

[20.502779]→[20.502779:502834](∅→∅)

txn,
&channel,

[20.502779]

[20.502834]

&*txn_,
&*channel_,
replacement in libpijul/src/record.rs at line 850

[20.503028]→[20.1501:1551](∅→∅)

if self.rec.actions.len() > len {

[20.503028]

[20.1551]

if self.actions.len() > len {
replacement in libpijul/src/record.rs at line 852

[20.1644]→[8.67:224](∅→∅)

if self.rec.oldest_change == std::time::SystemTime::UNIX_EPOCH {
self.rec.oldest_change = last_modified;

[20.1644]

[8.224]

if self.oldest_change == std::time::SystemTime::UNIX_EPOCH {
self.oldest_change = last_modified;
replacement in libpijul/src/record.rs at line 855

[8.257]→[8.257:353](∅→∅)

self.rec.oldest_change = self.rec.oldest_change.min(last_modified);

[8.257]

[8.353]

self.oldest_change = self.oldest_change.min(last_modified);
replacement in libpijul/src/record.rs at line 861

[20.2878]→[20.2878:2972](∅→∅)

&self.rec.actions.len() - len,
self.rec.actions.len()

[20.2878]

[20.2972]

&self.actions.len() - len,
self.actions.len()
replacement in libpijul/src/record.rs at line 868

[20.28957]→[20.28957:28978](∅→∅),[20.28978]→[20.1774:1810](∅→∅),[20.1810]→[20.29013:29043](∅→∅),[20.29013]→[20.29013:29043](∅→∅)

txn,
txn.graph(channel),
working_copy,

[20.28957]

[20.29043]

&*txn_,
txn_.graph(&*channel_),
working_copy.as_ref(),
edit in libpijul/src/record.rs at line 878

[20.503333]→[20.34070:34202](∅→∅),[20.34202]→[20.30:54](∅→∅),[20.54]→[20.34202:34209](∅→∅),[20.34202]→[20.34202:34209](∅→∅),[20.444]→[20.503398:503434](∅→∅),[20.34209]→[20.503398:503434](∅→∅),[20.503398]→[20.503398:503434](∅→∅),[20.503434]→[20.34210:34238](∅→∅),[20.34238]→[20.503464:503490](∅→∅),[20.503464]→[20.503464:503490](∅→∅),[20.503490]→[20.55:76](∅→∅),[20.76]→[20.503490:503546](∅→∅),[20.503490]→[20.503490:503546](∅→∅),[20.503546]→[20.77:205](∅→∅),[20.205]→[7.1939:2009](∅→∅),[20.205]→[20.503554:503650](∅→∅),[7.2009]→[20.503554:503650](∅→∅),[20.34284]→[20.503554:503650](∅→∅),[20.503554]→[20.503554:503650](∅→∅),[20.503650]→[20.260:317](∅→∅),[20.317]→[20.34285:34395](∅→∅),[20.503681]→[20.34285:34395](∅→∅),[20.34395]→[20.50378:50527](∅→∅),[20.50527]→[20.34542:34588](∅→∅),[20.34542]→[20.34542:34588](∅→∅),[20.34469]→[20.503904:503959](∅→∅),[20.34588]→[20.503904:503959](∅→∅),[20.503904]→[20.503904:503959](∅→∅),[20.503959]→[20.34589:34626](∅→∅),[20.34626]→[20.50528:50616](∅→∅),[20.50616]→[20.34711:34801](∅→∅),[20.34711]→[20.34711:34801](∅→∅),[20.34801]→[20.50617:50703](∅→∅),[20.50703]→[20.34886:35049](∅→∅),[20.34886]→[20.34886:35049](∅→∅),[20.35049]→[20.147:205](∅→∅),[20.147]→[20.147:205](∅→∅),[20.205]→[20.35050:35073](∅→∅),[20.35073]→[20.504274:504310](∅→∅),[20.504274]→[20.504274:504310](∅→∅),[20.504310]→[20.206:281](∅→∅),[20.281]→[20.6727:6946](∅→∅),[20.6946]→[20.371:851](∅→∅),[20.50812]→[20.371:851](∅→∅),[20.371]→[20.371:851](∅→∅),[20.851]→[20.504310:504500](∅→∅),[20.504310]→[20.504310:504500](∅→∅),[20.504500]→[20.852:888](∅→∅),[20.888]→[20.50813:50856](∅→∅),[20.50856]→[20.35074:35097](∅→∅),[20.504576]→[20.35074:35097](∅→∅),[20.35097]→[20.504598:504640](∅→∅),[20.504598]→[20.504598:504640](∅→∅),[20.504640]→[20.35098:35113](∅→∅),[20.35113]→[20.504640:504647](∅→∅),[20.504640]→[20.504640:504647](∅→∅),[20.504647]→[20.35114:35280](∅→∅),[20.12307]→[20.504701:504737](∅→∅),[20.35280]→[20.504701:504737](∅→∅),[20.504701]→[20.504701:504737](∅→∅),[20.504737]→[20.29187:29217](∅→∅),[20.29217]→[20.504767:504935](∅→∅),[20.504767]→[20.504767:504935](∅→∅),[20.504935]→[20.35281:35430](∅→∅),[20.35430]→[20.318:370](∅→∅),[20.370]→[20.504972:505236](∅→∅),[20.12373]→[20.504972:505236](∅→∅),[20.35430]→[20.504972:505236](∅→∅),[20.504972]→[20.504972:505236](∅→∅),[20.505236]→[20.50857:50906](∅→∅),[20.50906]→[20.35487:35532](∅→∅),[20.35487]→[20.35487:35532](∅→∅),[20.35532]→[20.889:958](∅→∅),[20.958]→[20.505312:506196](∅→∅),[20.35532]→[20.505312:506196](∅→∅),[20.505312]→[20.505312:506196](∅→∅),[20.506196]→[20.50907:50948](∅→∅),[20.50948]→[20.506236:506445](∅→∅),[20.506236]→[20.506236:506445](∅→∅),[20.506445]→[20.35533:35616](∅→∅),[20.35616]→[20.6947:7168](∅→∅),[20.1912]→[20.506617:506695](∅→∅),[20.7168]→[20.506617:506695](∅→∅),[20.29318]→[20.506617:506695](∅→∅),[20.35713]→[20.506617:506695](∅→∅),[20.51051]→[20.506617:506695](∅→∅),[20.506617]→[20.506617:506695](∅→∅),[20.506695]→[20.1620:1661](∅→∅),[20.1661]→[20.12374:12446](∅→∅),[20.12446]→[20.506821:506852](∅→∅),[20.506821]→[20.506821:506852](∅→∅),[20.506854]→[20.506854:506855](∅→∅),[20.506855]→[20.1777:1863](∅→∅),[20.1863]→[20.1913:1930](∅→∅),[20.1930]→[20.1863:2268](∅→∅),[20.1863]→[20.1863:2268](∅→∅),[20.2268]→[20.1931:1974](∅→∅),[20.1974]→[20.2310:2354](∅→∅),[20.2310]→[20.2310:2354](∅→∅),[20.2354]→[20.518:601](∅→∅),[20.601]→[13.46:93](∅→∅),[13.93]→[20.2499:2547](∅→∅),[20.667]→[20.2499:2547](∅→∅),[20.2021]→[20.2499:2547](∅→∅),[20.2499]→[20.2499:2547](∅→∅),[20.2547]→[20.507547:507555](∅→∅),[20.507547]→[20.507547:507555](∅→∅),[20.507555]→[2.2:3](∅→∅),[2.3]→[20.507610:507625](∅→∅),[20.507610]→[20.507610:507625](∅→∅)

fn delete_obsolete_children<
T: GraphTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
W: WorkingCopy,
C: ChangeStore,
>(
&mut self,
txn: &T,
channel: &T::Graph,
working_copy: &W,
changes: &C,
full_path: &str,
v: Position<ChangeId>,
) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
where
<W as WorkingCopy>::Error: 'static,
{
if self.ignore_missing {
return Ok(());
}
let f0 = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
let f1 = f0 | EdgeFlags::PSEUDO;
debug!("delete_obsolete_children, v = {:?}", v);
for child in iter_adjacent(txn, channel, v.inode_vertex(), f0, f1)? {
let child = child?;
let child = txn.find_block(channel, child.dest()).unwrap();
for grandchild in iter_adjacent(txn, channel, *child, f0, f1)? {
let grandchild = grandchild?;
debug!("grandchild {:?}", grandchild);
let needs_deletion =
if let Some(inode) = txn.get_revinodes(&grandchild.dest(), None)? {
debug!("inode = {:?} {:?}", inode, txn.get_revtree(inode, None));
if let Some(path) = crate::fs::inode_filename(txn, *inode)? {
working_copy.file_metadata(&path).is_err()
} else {
true
}
} else {
true
};
if needs_deletion {
let mut name = Vec::new();
changes
.get_contents(
|p| txn.get_external(&p).unwrap().map(From::from),
*child,
&mut name,
)
.map_err(RecordError::Changestore)?;
let mut full_path = full_path.to_string();
if name.len() > 2 {
if let Ok(name) = std::str::from_utf8(&name[2..]) {
if !full_path.is_empty() {
full_path.push('/');
}
full_path.push_str(name);
}
}
// delete recursively.
self.record_deleted_file(
txn,
&channel,
working_copy,
&full_path,
grandchild.dest(),
)?
}
}
}
Ok(())
}

fn push_children<
'a,
T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
W: WorkingCopy,
C: ChangeStore,
>(
&mut self,
txn: &T,
channel: &T::Channel,
working_copy: &W,
item: &mut RecordItem<'a>,
vertex: Position<Option<ChangeId>>,
stack: &mut Vec<RecordItem<'a>>,
prefix: &str,
) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
where
<W as crate::working_copy::WorkingCopy>::Error: 'static,
{
debug!("push_children, item = {:?}", item);
let comp = item.components.next();
let full_path = item.full_path.clone();
let fileid = OwnedPathId {
parent_inode: item.inode,
basename: SmallString::new(),
};
let mut has_matching_children = false;
for x in txn.iter_tree(&fileid, None)? {
let (fileid_, child_inode) = x?;
debug!("push_children {:?} {:?}", fileid_, child_inode);
if fileid_.parent_inode < fileid.parent_inode || fileid_.basename.is_empty() {
continue;
} else if fileid_.parent_inode > fileid.parent_inode {
break;
}
if let Some(comp) = comp {
if comp != fileid_.basename.as_str() {
continue;
}
}
has_matching_children = true;
let basename = fileid_.basename.as_str().to_string();
let full_path = if full_path.is_empty() {
basename.clone()
} else {
full_path.clone() + "/" + &basename
};
debug!("fileid_ {:?} child_inode {:?}", fileid_, child_inode);
if let Ok(meta) = working_copy.file_metadata(&full_path) {
stack.push(RecordItem {
papa: item.inode,
inode: *child_inode,
v_papa: vertex,
basename,
full_path,
metadata: meta,
components: item.components.clone(),
})
} else if let Some(vertex) = get_inodes(txn, &channel, child_inode)? {
self.record_deleted_file(
txn,
txn.graph(channel),
working_copy,
&full_path,
*vertex,
)?
}
}
if comp.is_some() && !has_matching_children {
debug!("comp = {:?}", comp);
return Err(RecordError::PathNotInRepo(prefix.to_string()));
}
Ok(())
}

fn modified_since_last_commit<T: ChannelTxnT, W: WorkingCopy>(
&mut self,
txn: &T,
channel: &T::Channel,
working_copy: &W,
prefix: &str,
) -> Result<bool, std::time::SystemTimeError> {
if let Ok(last_modified) = working_copy.modified_time(prefix) {
debug!(
"last_modified = {:?}, channel.last = {:?}",
last_modified
.duration_since(std::time::UNIX_EPOCH)?
.as_secs(),
txn.last_modified(channel)
);
Ok(last_modified
.duration_since(std::time::UNIX_EPOCH)?
.as_secs()
>= txn.last_modified(channel))
} else {
Ok(true)
}
}
}

impl Builder {
replacement in libpijul/src/record.rs at line 891

[11.48]→[20.51052:51125](∅→∅),[20.508005]→[20.51052:51125](∅→∅),[20.51125]→[20.12529:12591](∅→∅),[20.508141]→[20.12529:12591](∅→∅),[20.12591]→[20.508195:508255](∅→∅),[20.508195]→[20.508195:508255](∅→∅),[20.508255]→[20.51126:51197](∅→∅),[20.51197]→[20.508326:508361](∅→∅),[20.508326]→[20.508326:508361](∅→∅),[20.508361]→[20.51198:51285](∅→∅)

let name_start = ChangePosition(self.rec.contents.len().into());
item.metadata.write(&mut self.rec.contents).unwrap();
self.rec.contents.extend(item.basename.as_bytes());
let name_end = ChangePosition(self.rec.contents.len().into());
self.rec.contents.push(0);
let name = &self.rec.contents[name_start.0.as_usize()..name_end.0.as_usize()];

[11.48]

[20.36030]

let mut contents = self.contents.lock().unwrap();
let name_start = ChangePosition(contents.len().into());
// Push the metadata, big-endian.
contents.push((item.metadata.0 >> 8) as u8);
contents.push((item.metadata.0 & 0xff) as u8);
//
contents.extend(item.basename.as_bytes());
let name_end = ChangePosition(contents.len().into());
contents.push(0);
let name = &contents[name_start.0.as_usize()..name_end.0.as_usize()];
replacement in libpijul/src/record.rs at line 916

[20.6391]→[20.1710:1762](∅→∅)

self.rec.actions.push(Hunk::FileUndel {

[20.6391]

[20.508991]

self.actions.push(Hunk::FileUndel {
replacement in libpijul/src/record.rs at line 927

[20.509321]→[20.1763:1818](∅→∅)

self.rec.actions.push(Hunk::FileMove {

[20.509321]

[20.509378]

self.actions.push(Hunk::FileMove {
replacement in libpijul/src/record.rs at line 943

[20.510020]→[20.1819:1883](∅→∅)

self.rec.actions.push(Hunk::SolveNameConflict {

[20.510020]

[20.510086]

self.actions.push(Hunk::SolveNameConflict {
replacement in libpijul/src/record.rs at line 950

[20.510318]→[20.51286:51354](∅→∅)

self.rec.contents.truncate(name_start.0.as_usize())

[20.510318]

[20.510384]

contents.truncate(name_start.0.as_usize())
replacement in libpijul/src/record.rs at line 953

[20.510415]→[20.51355:51419](∅→∅)

self.rec.contents.truncate(name_start.0.as_usize())

[20.510415]

[20.510477]

contents.truncate(name_start.0.as_usize())
replacement in libpijul/src/record.rs at line 986

[20.511272]→[20.511272:511346](∅→∅)

let mut del_del = HashMap::new();
let mut alive = HashMap::new();

[20.511272]

[20.511346]

let mut del_del = HashMap::default();
let mut alive = HashMap::default();
replacement in libpijul/src/record.rs at line 1163

[2.7]→[20.518326:518341](∅→∅),[20.518326]→[20.518326:518341](∅→∅)

impl Builder {

[2.7]

[20.37155]

impl Recorded {
replacement in libpijul/src/record.rs at line 1177

[20.518708]→[20.518708:518750](∅→∅)

let mut visited = HashSet::new();

[20.518708]

[20.518750]

let mut visited = HashSet::default();
replacement in libpijul/src/record.rs at line 1193

[20.3486]→[20.3486:3587](∅→∅)

if !self.deleted_vertices.insert(vertex.start_pos()) {
continue;

[20.3486]

[20.3587]

{
let mut deleted_vertices = self.deleted_vertices.lock().unwrap();
if !deleted_vertices.insert(vertex.start_pos()) {
continue;
}
edit in libpijul/src/record.rs at line 1205

[20.3893]

[20.53959]

.lock()
.unwrap()
replacement in libpijul/src/record.rs at line 1208

[20.54032]→[20.7280:7463](∅→∅)

self.rec.updatables.insert(
self.rec.actions.len(),
InodeUpdate::Deleted { inode: *inode },
);

[20.54032]

[20.520235]

self.updatables
.insert(self.actions.len(), InodeUpdate::Deleted { inode: *inode });
replacement in libpijul/src/record.rs at line 1302

[20.523440]→[20.1884:1934](∅→∅)

self.rec.actions.push(Hunk::FileDel {

[20.523440]

[20.523492]

self.actions.push(Hunk::FileDel {
replacement in libpijul/src/record.rs at line 1323

[20.523985]→[20.523985:524026](∅→∅)

}) = self.rec.actions.last_mut()

[20.523985]

[20.524026]

}) = self.actions.last_mut()
edit in libpijul/src/pristine/sanakirja.rs at line 2

[20.531126]

[20.56954]

use crate::HashMap;
edit in libpijul/src/pristine/sanakirja.rs at line 4

[20.56974]→[20.531262:531286](∅→∅),[20.531262]→[20.531262:531286](∅→∅)

use std::cell::RefCell;
edit in libpijul/src/pristine/sanakirja.rs at line 5

[20.531325]→[20.531325:531356](∅→∅)

use std::collections::HashMap;
replacement in libpijul/src/pristine/sanakirja.rs at line 6

[20.531377]→[20.531377:531397](∅→∅)

use std::sync::Arc;

[20.531377]

[20.531397]

use std::sync::{Arc, Mutex};
replacement in libpijul/src/pristine/sanakirja.rs at line 139

[20.58301]→[20.533810:533931](∅→∅),[20.533810]→[20.533810:533931](∅→∅)

open_channels: RefCell::new(HashMap::new()),
open_remotes: RefCell::new(HashMap::new()),

[20.58301]

[20.533931]

open_channels: Mutex::new(HashMap::default()),
open_remotes: Mutex::new(HashMap::default()),
edit in libpijul/src/pristine/sanakirja.rs at line 142

[20.533952]

[20.533952]

counter: 0,
replacement in libpijul/src/pristine/sanakirja.rs at line 227

[20.3608]→[20.536055:536168](∅→∅),[20.59923]→[20.536055:536168](∅→∅),[20.536055]→[20.536055:536168](∅→∅)

open_channels: RefCell::new(HashMap::new()),
open_remotes: RefCell::new(HashMap::new()),

[20.3608]

[20.536168]

open_channels: Mutex::new(HashMap::default()),
open_remotes: Mutex::new(HashMap::default()),
edit in libpijul/src/pristine/sanakirja.rs at line 230

[20.536185]

[20.3609]

counter: 0,
replacement in libpijul/src/pristine/sanakirja.rs at line 268

[20.60428]→[20.60428:60507](∅→∅),[20.60507]→[20.537793:537859](∅→∅),[20.537793]→[20.537793:537859](∅→∅)

pub(crate) open_channels: RefCell<HashMap<SmallString, ChannelRef<Self>>>,
open_remotes: RefCell<HashMap<SmallString, RemoteRef<Self>>>,

[20.60428]

[20.537859]

pub(crate) open_channels: Mutex<HashMap<SmallString, ChannelRef<Self>>>,
open_remotes: Mutex<HashMap<SmallString, RemoteRef<Self>>>,
counter: usize,
edit in libpijul/src/pristine/sanakirja.rs at line 484

[20.34364]

[20.34364]

debug!("find_block: BLOCK ERROR");
edit in libpijul/src/pristine/sanakirja.rs at line 504

[20.35289]

[20.35289]

debug!("find_block: BLOCK ERROR");
edit in libpijul/src/pristine/sanakirja.rs at line 513

[20.35500]

[20.35572]

debug!("find_block: BLOCK ERROR");
replacement in libpijul/src/pristine/sanakirja.rs at line 533

[20.68287]→[20.68287:68519](∅→∅),[20.68519]→[20.36384:36459](∅→∅),[20.36384]→[20.36384:36459](∅→∅)

let mut k = if let Some((k, _)) = cursor
.set(txn, &key, None)
.map_err(|x| BlockError::Txn(x.into()))?
{
k
} else if let Some((k, _)) = cursor.prev(txn).map_err(|x| BlockError::Txn(x.into()))? {
k
} else {
return Err(BlockError::Block { block: p });

[20.68287]

[20.36459]

let mut k = match cursor.set(txn, &key, None) {
Ok(Some((k, _))) => k,
Ok(None) => {
if let Some((k, _)) = cursor.prev(txn).map_err(|x| BlockError::Txn(x.into()))? {
k
} else {
debug!("find_block_end, no prev");
return Err(BlockError::Block { block: p });
}
}
Err(e) => {
debug!("find_block_end: BLOCK ERROR");
return Err(BlockError::Txn(e.into()));
}
edit in libpijul/src/pristine/sanakirja.rs at line 549

[20.36592]

[20.36705]

debug!("find_block_end, loop, k = {:?}, p = {:?}", k, p);
edit in libpijul/src/pristine/sanakirja.rs at line 571

[20.37414]

[20.37525]

debug!("find_block_end, {:?} {:?}", k, p);
edit in libpijul/src/pristine/sanakirja.rs at line 579

[20.37729]

[20.37841]

debug!("find_block_end, {:?} {:?}", k, p);
edit in libpijul/src/pristine/sanakirja.rs at line 585

[20.38015]

[20.38015]

debug!("find_block_end: BLOCK ERROR");
replacement in libpijul/src/pristine/sanakirja.rs at line 991

[20.545759]→[20.618:647](∅→∅)

#[cfg(debug_assertions)]

[20.545759]

[20.647]

// #[cfg(debug_assertions)]
replacement in libpijul/src/pristine/sanakirja.rs at line 1022

[20.43857]→[20.75738:75767](∅→∅)

#[cfg(debug_assertions)]

[20.43857]

[20.75767]

// #[cfg(debug_assertions)]
replacement in libpijul/src/pristine/sanakirja.rs at line 1025

[20.75895]→[20.43857:43886](∅→∅),[20.43857]→[20.43857:43886](∅→∅)

#[cfg(debug_assertions)]

[20.75895]

[20.43886]

// #[cfg(debug_assertions)]
replacement in libpijul/src/pristine/sanakirja.rs at line 1120

[20.46014]→[20.46014:46052](∅→∅)

let remote = remote.borrow();

[20.46014]

[20.77276]

let remote = remote.db.lock().unwrap();
replacement in libpijul/src/pristine/sanakirja.rs at line 1161

[20.549208]→[20.549208:549276](∅→∅)

match self.open_channels.borrow_mut().entry(name.clone()) {

[20.549208]

[20.549276]

match self.open_channels.lock().unwrap().entry(name.clone()) {
replacement in libpijul/src/pristine/sanakirja.rs at line 1166

[20.45033]→[20.45033:45090](∅→∅)

r: Rc::new(RefCell::new(c)),

[20.45033]

[20.45090]

r: Arc::new(RwLock::new(c)),
replacement in libpijul/src/pristine/sanakirja.rs at line 1180

[20.550434]→[20.550434:550501](∅→∅)

match self.open_remotes.borrow_mut().entry(name.clone()) {

[20.550434]

[20.8251]

match self.open_remotes.lock().unwrap().entry(name.clone()) {
replacement in libpijul/src/pristine/sanakirja.rs at line 1204

[20.9362]→[20.9362:9416](∅→∅)

db: Rc::new(RefCell::new(r)),

[20.9362]

[20.9416]

db: Arc::new(Mutex::new(r)),
replacement in libpijul/src/pristine/sanakirja.rs at line 1292

[20.555360]→[20.555360:555427](∅→∅)

match self.open_remotes.borrow_mut().entry(name.clone()) {

[20.555360]

[20.9588]

match self.open_remotes.lock().unwrap().entry(name.clone()) {
replacement in libpijul/src/pristine/sanakirja.rs at line 1296

[20.9788]→[20.9788:9846](∅→∅)

db: Rc::new(RefCell::new(Remote {

[20.9788]

[20.9846]

db: Arc::new(Mutex::new(Remote {
replacement in libpijul/src/pristine/sanakirja.rs at line 1309

[20.556166]→[20.48699:48758](∅→∅)

Ok(self.open_remotes.borrow().get(&name).cloned())

[20.556166]

[20.556231]

Ok(self.open_remotes.lock().unwrap().get(&name).cloned())
replacement in libpijul/src/pristine/sanakirja.rs at line 1346

[20.49468]→[20.81991:82067](∅→∅)

match btree::get(&self.txn, &remote.db.borrow().rev, hash, None)? {

[20.49468]

[20.82067]

match btree::get(&self.txn, &remote.db.lock().unwrap().rev, hash, None)? {
replacement in libpijul/src/pristine/sanakirja.rs at line 1356

[20.49685]→[20.82187:82263](∅→∅)

match btree::get(&self.txn, &remote.db.borrow().states, m, None)? {

[20.49685]

[20.82263]

match btree::get(&self.txn, &remote.db.lock().unwrap().states, m, None)? {
edit in libpijul/src/pristine/sanakirja.rs at line 1370

[20.50063]

[20.82408]

self.counter += 1;
debug!("put_graph {:?} {:?}, counter = {:?}", k, e, self.counter);
/*
if self.counter >= 12965 {
let mut x = None;
let mut cursor = btree::cursor::Cursor::new(&self.txn, graph)?;
let mut panic = None;
while let Some((k, v)) = cursor.next(&self.txn)? {
if let Some((ref k_, ref v_)) = x {
if k_ > k || (k_== k && v_ > v) {
panic = Some((*k, *v));
break
}
}
x = Some((*k, *v))
}
self.debug(graph, ".put");
if panic.is_some() {
panic!("{:?}", x);
}
}
*/
replacement in libpijul/src/pristine/sanakirja.rs at line 1401

[20.50114]→[20.82528:82580](∅→∅)

Ok(btree::del(&mut self.txn, graph, k, e)?)

[20.50114]

[20.559388]

self.counter += 1;
debug!("del_graph {:?} {:?}, counter = {:?}", k, e, self.counter);
/*
if self.counter >= 12965 {
let mut x = None;
let mut cursor = btree::cursor::Cursor::new(&self.txn, graph)?;
let mut panic = None;
while let Some((k, v)) = cursor.next(&self.txn)? {
if let Some((ref k_, ref v_)) = x {
if k_ > k || (k_== k && v_ > v) {
panic = Some((*k, *v));
break
}
}
x = Some((*k, *v))
}
self.debug(graph, ".del");
if panic.is_some() {
panic!("{:?}", x);
}
}

let change = ChangeId::from_base32(b"MM6XEY5S32WRA").unwrap();
let mm6v = Vertex {
change,
start: ChangePosition(L64(1478218)),
end: ChangePosition(L64(1478229)),
};
let mm6e = (Edge {
flag: EdgeFlags::BLOCK | EdgeFlags::FOLDER | EdgeFlags::PARENT,
dest: Position {
change,
pos: ChangePosition(L64(1466149)),
},
introduced_by: change,
}).into();

let has_mm6 = if let Some((v, e)) = btree::get(&self.txn, graph, &mm6v, Some(&mm6e)).unwrap() {
v == &mm6v && e == &mm6e
} else {
false
};
*/
let result = Ok(btree::del(&mut self.txn, graph, k, e)?);
/*
if has_mm6 && (k != &mm6v || e != Some(&mm6e)) {
if let Some((v, e)) = btree::get(&self.txn, graph, &mm6v, Some(&mm6e)).unwrap() {
assert_eq!(v, &mm6v);
assert_eq!(e, &mm6e)
} else {
panic!("Not found")
}
}
*/
result
}

fn debug(&mut self, graph: &mut Self::Graph, extra: &str) {
::sanakirja::debug::debug(
&self.txn,
&[graph],
format!("debug{}{}", self.counter, extra),
true,
);
edit in libpijul/src/pristine/sanakirja.rs at line 1466

[20.559394]

[20.82581]
replacement in libpijul/src/pristine/sanakirja.rs at line 1706

[20.14616]→[20.562358:562404](∅→∅),[20.52526]→[20.562358:562404](∅→∅),[20.562358]→[20.562358:562404](∅→∅)

let mut remote = remote.borrow_mut();

[20.52526]

[20.85694]

let mut remote = remote.db.lock().unwrap();
replacement in libpijul/src/pristine/sanakirja.rs at line 1724

[20.14715]→[20.562707:562753](∅→∅),[20.52661]→[20.562707:562753](∅→∅),[20.562707]→[20.562707:562753](∅→∅)

let mut remote = remote.borrow_mut();

[20.52661]

[20.86073]

let mut remote = remote.db.lock().unwrap();
replacement in libpijul/src/pristine/sanakirja.rs at line 1749

[20.563283]→[20.48406:48487](∅→∅)

let result = match self.open_channels.borrow_mut().entry(name.clone()) {

[20.563283]

[20.563351]

let result = match self.open_channels.lock().unwrap().entry(name.clone()) {
replacement in libpijul/src/pristine/sanakirja.rs at line 1753

[20.79]→[20.79:137](∅→∅)

r: Rc::new(RefCell::new(Channel {

[20.79]

[20.137]

r: Arc::new(RwLock::new(Channel {
replacement in libpijul/src/pristine/sanakirja.rs at line 1766

[20.11175]→[20.11175:11237](∅→∅)

r: Rc::new(RefCell::new(Channel {

[20.11175]

[20.11237]

r: Arc::new(RwLock::new(Channel {
replacement in libpijul/src/pristine/sanakirja.rs at line 1796

[20.14873]→[20.565273:565315](∅→∅),[20.52923]→[20.565273:565315](∅→∅),[20.565273]→[20.565273:565315](∅→∅)

let channel = channel.r.borrow();

[20.52923]

[20.565315]

let channel = channel.r.read().unwrap();
replacement in libpijul/src/pristine/sanakirja.rs at line 1806

[20.88794]→[20.88794:88848](∅→∅)

r: Rc::new(RefCell::new(Channel {

[20.88794]

[20.88848]

r: Arc::new(RwLock::new(Channel {
replacement in libpijul/src/pristine/sanakirja.rs at line 1822

[20.89660]→[20.89660:89734](∅→∅)

self.open_channels.borrow_mut().insert(name, br.clone());

[20.89660]

[20.89734]

self.open_channels.lock().unwrap().insert(name, br.clone());
replacement in libpijul/src/pristine/sanakirja.rs at line 1844

[20.90098]→[20.90098:90142](∅→∅)

&channel.borrow().name,

[20.90098]

[20.15970]

&channel.r.read().unwrap().name,
replacement in libpijul/src/pristine/sanakirja.rs at line 1850

[20.90275]→[20.90275:90369](∅→∅)

.borrow_mut()
.remove(&channel.borrow().name)

[20.90275]

[20.90369]

.lock()
.unwrap()
.remove(&channel.r.read().unwrap().name)
replacement in libpijul/src/pristine/sanakirja.rs at line 1855

[20.90423]→[20.12239:12376](∅→∅)

std::cell::RefCell::borrow_mut(&std::rc::Rc::get_mut(&mut channel.r).unwrap())
.name = name.clone();

[20.90423]

[20.566916]

channel.r.write().unwrap().name = name.clone();
replacement in libpijul/src/pristine/sanakirja.rs at line 1857

[20.566951]→[20.566951:566985](∅→∅)

.borrow_mut()

[20.566951]

[20.90560]

.lock()
.unwrap()
replacement in libpijul/src/pristine/sanakirja.rs at line 1867

[20.218]→[20.218:363](∅→∅)

let channel = if let Some(channel) = self.open_channels.borrow_mut().remove(&name) {
let channel = Rc::try_unwrap(channel.r)

[20.218]

[20.3664]

let channel = if let Some(channel) = self.open_channels.lock().unwrap().remove(&name) {
let channel = Arc::try_unwrap(channel.r)
replacement in libpijul/src/pristine/sanakirja.rs at line 1872

[20.3783]→[20.445:476](∅→∅),[20.445]→[20.445:476](∅→∅)

.into_inner();

[20.3783]

[20.476]

.into_inner()
.unwrap();
replacement in libpijul/src/pristine/sanakirja.rs at line 1906

[20.568188]→[20.568188:568255](∅→∅)

match self.open_remotes.borrow_mut().entry(name.clone()) {

[20.568188]

[20.568255]

match self.open_remotes.lock().unwrap().entry(name.clone()) {
replacement in libpijul/src/pristine/sanakirja.rs at line 1910

[20.12543]→[20.12543:12601](∅→∅)

db: Rc::new(RefCell::new(Remote {

[20.12543]

[20.12601]

db: Arc::new(Mutex::new(Remote {
replacement in libpijul/src/pristine/sanakirja.rs at line 1919

[20.12982]→[20.12982:13044](∅→∅)

db: Rc::new(RefCell::new(Remote {

[20.12982]

[20.13044]

db: Arc::new(Mutex::new(Remote {
replacement in libpijul/src/pristine/sanakirja.rs at line 1937

[20.569492]→[20.569492:569559](∅→∅)

Ok(self.open_remotes.borrow().get(&name).unwrap().clone())

[20.569492]

[20.569559]

Ok(self
.open_remotes
.lock()
.unwrap()
.get(&name)
.unwrap()
.clone())
replacement in libpijul/src/pristine/sanakirja.rs at line 1948

[20.569694]→[20.569694:569765](∅→∅)

let r = self.open_remotes.borrow_mut().remove(&name).unwrap();

[20.569694]

[20.569765]

let r = self.open_remotes.lock().unwrap().remove(&name).unwrap();
replacement in libpijul/src/pristine/sanakirja.rs at line 1950

[20.569797]→[20.569797:569845](∅→∅)

assert_eq!(Rc::strong_count(&r.db), 1);

[20.569797]

[20.92084]

assert_eq!(Arc::strong_count(&r.db), 1);
replacement in libpijul/src/pristine/sanakirja.rs at line 1956

[20.570159]→[20.570159:570283](∅→∅)

if let Some(r) = self.open_remotes.borrow_mut().remove(&name) {
assert_eq!(Rc::strong_count(&r.db), 1);

[20.570159]

[20.570283]

if let Some(r) = self.open_remotes.lock().unwrap().remove(&name) {
assert_eq!(Arc::strong_count(&r.db), 1);
replacement in libpijul/src/pristine/sanakirja.rs at line 1965

[20.570575]→[20.570575:570703](∅→∅)

let open_channels =
std::mem::replace(self.open_channels.borrow_mut().deref_mut(), HashMap::new());

[20.570575]

[20.570703]

let open_channels = std::mem::replace(
self.open_channels.lock().unwrap().deref_mut(),
HashMap::default(),
);
replacement in libpijul/src/pristine/sanakirja.rs at line 1975

[20.570887]→[20.570887:571013](∅→∅)

let open_remotes =
std::mem::replace(self.open_remotes.borrow_mut().deref_mut(), HashMap::new());

[20.570887]

[20.92228]

let open_remotes = std::mem::replace(
self.open_remotes.lock().unwrap().deref_mut(),
HashMap::default(),
);
edit in libpijul/src/pristine/sanakirja.rs at line 1984

[20.571127]

[20.92330]

// No need to set `Root::Version`, it is set at init.
replacement in libpijul/src/pristine/sanakirja.rs at line 2032

[20.183]→[20.572929:572976](∅→∅),[20.572929]→[20.572929:572976](∅→∅)

let channel = channel.r.try_borrow()?;

[20.183]

[20.572976]

let channel = channel.r.read().unwrap();
replacement in libpijul/src/pristine/sanakirja.rs at line 2063

[20.574705]→[20.574705:574786](∅→∅)

.borrow_mut()
.remove(&channel.r.borrow().name),

[20.574705]

[20.574786]

.lock()
.unwrap()
.remove(&channel.r.read().unwrap().name),
replacement in libpijul/src/pristine/sanakirja.rs at line 2073

[20.94732]→[20.575500:575536](∅→∅),[20.575500]→[20.575500:575536](∅→∅)

let r = remote.db.borrow();

[20.94732]

[20.94733]

let r = remote.db.lock().unwrap();
replacement in libpijul/src/pristine/sanakirja.rs at line 2085

[20.16900]→[20.575923:576000](∅→∅),[20.53881]→[20.575923:576000](∅→∅),[20.575923]→[20.575923:576000](∅→∅)

std::mem::drop(self.open_remotes.borrow_mut().remove(&remote.name));

[20.53881]

[20.576000]

std::mem::drop(self.open_remotes.lock().unwrap().remove(&remote.name));
replacement in libpijul/src/pristine/mod.rs at line 3

[20.586854]→[20.586854:586920](∅→∅)

use std::cell::RefCell;
use std::collections::{HashMap, HashSet};

[20.586854]

[20.586920]

use crate::{HashMap, HashSet};
replacement in libpijul/src/pristine/mod.rs at line 5

[20.586940]→[20.586940:586957](∅→∅)

use std::rc::Rc;

[20.586940]

[20.586957]

use std::sync::{Arc, Mutex, RwLock};
replacement in libpijul/src/pristine/mod.rs at line 138

[20.53960]→[20.48707:48750](∅→∅)

pub(crate) r: Rc<RefCell<T::Channel>>,

[20.53960]

[20.587883]

pub(crate) r: Arc<RwLock<T::Channel>>,
}

#[derive(Debug, Error)]
#[error("Mutex poison error")]
pub struct PoisonError {}

impl<T: ChannelTxnT> ChannelRef<T> {
pub fn read(&self) -> Result<std::sync::RwLockReadGuard<T::Channel>, PoisonError> {
self.r.read().map_err(|_| PoisonError {})
}
pub fn write(&self) -> Result<std::sync::RwLockWriteGuard<T::Channel>, PoisonError> {
self.r.write().map_err(|_| PoisonError {})
}
edit in libpijul/src/pristine/mod.rs at line 164

[20.588197]→[20.588197:588199](∅→∅)

}
replacement in libpijul/src/pristine/mod.rs at line 165

[20.588200]→[20.54079:54116](∅→∅),[20.54116]→[20.48751:48808](∅→∅),[20.48808]→[20.588287:588311](∅→∅),[20.588287]→[20.588287:588311](∅→∅)

impl<T: ChannelTxnT> ChannelRef<T> {
pub fn borrow(&self) -> std::cell::Ref<T::Channel> {
self.r.borrow()

[20.588200]

[20.588311]

pub fn lock(&self) -> Result<std::sync::MutexGuard<Remote<T>>, PoisonError> {
self.db.lock().map_err(|_| PoisonError {})
edit in libpijul/src/pristine/mod.rs at line 168

[20.588317]→[20.48809:48877](∅→∅),[20.48877]→[20.588385:588419](∅→∅),[20.588385]→[20.588385:588419](∅→∅)

pub fn borrow_mut(&mut self) -> std::cell::RefMut<T::Channel> {
self.r.borrow_mut()
}
replacement in libpijul/src/pristine/mod.rs at line 177

[20.588628]→[20.588628:588660](∅→∅)

db: Rc<RefCell<Remote<T>>>,

[20.588628]

[20.588660]

db: Arc<Mutex<Remote<T>>>,
edit in libpijul/src/pristine/mod.rs at line 187

[20.588855]→[20.588855:588974](∅→∅)

}
}

impl<T: TxnT> RemoteRef<T> {
pub fn borrow(&self) -> std::cell::Ref<Remote<T>> {
self.db.borrow()
edit in libpijul/src/pristine/mod.rs at line 188

[20.588980]→[20.588980:589082](∅→∅)

pub fn borrow_mut(&mut self) -> std::cell::RefMut<Remote<T>> {
self.db.borrow_mut()
}
replacement in libpijul/src/pristine/mod.rs at line 261

[20.54965]→[20.49581:49599](∅→∅)

type Channel;

[20.54965]

[20.49599]

type Channel: Sync + Send;
replacement in libpijul/src/pristine/mod.rs at line 464

[20.590029]→[20.57544:57573](∅→∅)

#[cfg(debug_assertions)]

[20.590029]

[20.57573]

// #[cfg(debug_assertions)]
replacement in libpijul/src/pristine/mod.rs at line 466

[20.57635]→[20.57635:57664](∅→∅)

#[cfg(debug_assertions)]

[20.57635]

[20.57664]

// #[cfg(debug_assertions)]
replacement in libpijul/src/pristine/mod.rs at line 847

[20.608593]→[20.43325:43350](∅→∅)

#[cfg(debug_assertions)]

[20.608593]

[20.65191]

// #[cfg(debug_assertions)]
replacement in libpijul/src/pristine/mod.rs at line 863

[20.608677]→[20.43719:43744](∅→∅)

#[cfg(debug_assertions)]

[20.608677]

[20.65343]

// #[cfg(debug_assertions)]
replacement in libpijul/src/pristine/mod.rs at line 876

[20.44154]→[20.44154:44179](∅→∅)

#[cfg(debug_assertions)]

[20.44154]

[20.53834]

// #[cfg(debug_assertions)]
replacement in libpijul/src/pristine/mod.rs at line 879

[20.44250]→[20.53912:53938](∅→∅)

channel: &T::Channel,

[20.44250]

[20.44279]

channel: &ChannelRef<T>,
replacement in libpijul/src/pristine/mod.rs at line 884

[20.44404]→[20.3337:3393](∅→∅)

let done = debug(txn, txn.graph(channel), &mut f)?;

[20.44404]

[20.44488]

let channel = channel.r.read().unwrap();
let done = debug(txn, txn.graph(&*channel), &mut f)?;
replacement in libpijul/src/pristine/mod.rs at line 891

[20.44560]→[20.44560:44585](∅→∅)

#[cfg(debug_assertions)]

[20.44560]

[20.65606]

// #[cfg(debug_assertions)]
replacement in libpijul/src/pristine/mod.rs at line 903

[20.610461]→[20.44846:44871](∅→∅)

#[cfg(debug_assertions)]

[20.610461]

[20.65771]

// #[cfg(debug_assertions)]
replacement in libpijul/src/pristine/mod.rs at line 910

[20.611456]→[20.44999:45024](∅→∅)

#[cfg(debug_assertions)]

[20.611456]

[20.65918]

// #[cfg(debug_assertions)]
replacement in libpijul/src/pristine/mod.rs at line 919

[20.611728]→[20.1210:1235](∅→∅)

#[cfg(debug_assertions)]

[20.611728]

[20.66056]

// #[cfg(debug_assertions)]
replacement in libpijul/src/pristine/mod.rs at line 930

[20.45329]→[20.45329:45354](∅→∅)

#[cfg(debug_assertions)]

[20.45329]

[20.53995]

// #[cfg(debug_assertions)]
replacement in libpijul/src/pristine/mod.rs at line 961

[20.46222]→[20.46222:46262](∅→∅)

let mut reachable = HashSet::new();

[20.46222]

[20.46262]

let mut reachable = HashSet::default();
replacement in libpijul/src/pristine/mod.rs at line 983

[20.46734]→[20.46734:46782](∅→∅)

let mut alive_unreachable = HashMap::new();

[20.46734]

[20.4007]

let mut alive_unreachable = HashMap::default();
replacement in libpijul/src/pristine/mod.rs at line 986

[20.409]→[20.46843:46881](∅→∅),[20.54330]→[20.46843:46881](∅→∅),[20.66568]→[20.46843:46881](∅→∅),[20.46843]→[20.46843:46881](∅→∅)

let mut visited = HashSet::new();

[20.54330]

[20.46881]

let mut visited = HashSet::default();
replacement in libpijul/src/pristine/mod.rs at line 1072

[20.49237]→[20.49237:49275](∅→∅)

let mut visited = HashSet::new();

[20.49237]

[20.49275]

let mut visited = HashSet::default();
replacement in libpijul/src/pristine/mod.rs at line 1270

[20.68648]→[20.1431:1456](∅→∅),[20.621548]→[20.1431:1456](∅→∅)

#[cfg(debug_assertions)]

[20.68648]

[20.68649]

// #[cfg(debug_assertions)]
replacement in libpijul/src/pristine/mod.rs at line 1439

[20.625794]→[20.72086:72148](∅→∅)

type Item = Result<ChannelRef<T>, TxnErr<T::GraphError>>;

[20.625794]

[20.625825]

type Item = Result<(&'txn SmallStr, ChannelRef<T>), TxnErr<T::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 1444

[20.72314]→[20.72314:72399](∅→∅)

Ok(Some((name, _))) => self.txn.load_channel(name.as_str()).transpose(),

[20.72314]

[20.72399]

Ok(Some((name, _))) => Some(Ok((name, self.txn.load_channel(name.as_str()).unwrap()?))),
edit in libpijul/src/pristine/mod.rs at line 1486

[20.55422]

[20.55422]

/// Delete a key and a value from a graph. Returns `true` if and only if `(k, v)` was in the graph.
fn debug(&mut self, channel: &mut Self::Graph, extra: &str);
replacement in libpijul/src/pristine/mod.rs at line 1679

[20.52571]→[20.52571:52598](∅→∅),[20.52598]→[20.75944:75959](∅→∅),[20.75959]→[20.110165:110178](∅→∅),[20.110178]→[20.16190:16327](∅→∅),[20.16327]→[20.52831:52866](∅→∅),[20.110256]→[20.52831:52866](∅→∅),[20.52831]→[20.52831:52866](∅→∅),[20.52866]→[20.75960:75975](∅→∅),[20.75975]→[20.110257:110270](∅→∅),[20.110270]→[20.16328:16483](∅→∅),[20.16483]→[20.53117:53125](∅→∅),[20.110366]→[20.53117:53125](∅→∅),[20.53117]→[20.53117:53125](∅→∅),[20.53125]→[20.110367:110399](∅→∅)

let a = txn.del_graph(
graph,
&k0,
Some(&SerializedEdge::new(
flag,
k1.change,
k1.start,
introduced_by,
)),
)?;
let b = txn.del_graph(
graph,
&k1,
Some(&SerializedEdge::new(
flag | EdgeFlags::PARENT,
k0.change,
k0.end,
introduced_by,
)),
)?;
if (a && !b) || (!a && b) {

[20.52571]

[20.16484]

let v0 = SerializedEdge::new(flag, k1.change, k1.start, introduced_by);
let a = txn.del_graph(graph, &k0, Some(&v0))?;
{
if let Some(&ee) = txn.get_graph(graph, &k0, Some(&v0))? {
if ee == v0 {
txn.debug(graph, ".3");
panic!("Not deleted: {:?} {:?}", k0, v0);
}
}
}
let v1 = SerializedEdge::new(flag | EdgeFlags::PARENT, k0.change, k0.end, introduced_by);
let b = txn.del_graph(graph, &k1, Some(&v1))?;
{
if let Some(&ee) = txn.get_graph(graph, &k1, Some(&v1))? {
if ee == v1 {
txn.debug(graph, ".3");
panic!("Not deleted: {:?} {:?}", k1, v1);
}
}
}
if a != b {
txn.debug(graph, ".2");
edit in libpijul/src/pristine/mod.rs at line 1724

[20.53652]

[20.53652]

let gaeul = ChangeId::from_base32(b"GAEULYDRSLJSC").unwrap();
let has_gaeul1 = {
let v = Vertex {
change: gaeul,
start: ChangePosition(L64(1677892)),
end: ChangePosition(L64(1677893)),
};
let e = SerializedEdge::new(
EdgeFlags::PSEUDO | EdgeFlags::PARENT,
gaeul,
ChangePosition(L64(1677837)),
ChangeId::ROOT,
);
if let Some(&ee) = txn.get_graph(graph, &v, Some(&e))? {
ee == e
} else {
false
}
};
edit in libpijul/src/pristine/mod.rs at line 1757

[20.54294]

[20.54294]

let has_gaeul1_ = {
let v = Vertex {
change: gaeul,
start: ChangePosition(L64(1677892)),
end: ChangePosition(L64(1677893)),
};
let e = SerializedEdge::new(
EdgeFlags::PSEUDO | EdgeFlags::PARENT,
gaeul,
ChangePosition(L64(1677837)),
ChangeId::ROOT,
);
if let Some(&ee) = txn.get_graph(graph, &v, Some(&e))? {
ee == e
} else {
false
}
};

if has_gaeul1 && !has_gaeul1_ {
txn.debug(graph, ".GAEUL");
panic!("GAEULT");
}
replacement in libpijul/src/pristine/mod.rs at line 1933

[20.1547]→[20.1547:1579](∅→∅)

let mut h = HashMap::new();

[20.1547]

[20.1579]

let mut h = HashMap::default();
replacement in libpijul/src/pristine/mod.rs at line 1954

[20.3821]→[20.2245:2277](∅→∅),[20.56163]→[20.2245:2277](∅→∅),[20.77260]→[20.2245:2277](∅→∅),[20.2245]→[20.2245:2277](∅→∅)

let mut h = HashSet::new();

[20.3821]

[20.2277]

let mut h = HashSet::default();
replacement in libpijul/src/pristine/inode_metadata.rs at line 8

[20.641877]→[20.641877:641931](∅→∅)

use byteorder::{BigEndian, ByteOrder, WriteBytesExt};

[20.641877]

[20.641931]

use byteorder::{BigEndian, ByteOrder};
edit in libpijul/src/pristine/inode_metadata.rs at line 58

[9.220]→[20.643482:643608](∅→∅),[20.643482]→[20.643482:643608](∅→∅)

}

pub fn write<W: std::io::Write>(&self, mut w: W) -> std::io::Result<()> {
w.write_u16::<BigEndian>(self.0)
edit in libpijul/src/pristine/hash.rs at line 160

[20.16907]

[20.114950]

}

impl std::hash::Hash for SerializedHash {
fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
self.t.hash(hasher);
if self.t == HashAlgorithm::Blake3 as u8 {
unsafe { self.h.blake3.hash(hasher) }
}
}
edit in libpijul/src/pristine/hash.rs at line 262

[20.117151]

impl SerializedHash {
pub fn size(b: &[u8]) -> usize {
if b[0] == HashAlgorithm::Blake3 as u8 {
1 + BLAKE3_BYTES
} else if b[0] == HashAlgorithm::None as u8 {
1
} else {
panic!("Unknown hash algorithm {:?}", b[0])
}
}

pub unsafe fn size_from_ptr(b: *const u8) -> usize {
if *b == HashAlgorithm::Blake3 as u8 {
1 + BLAKE3_BYTES
} else if *b == HashAlgorithm::None as u8 {
1
} else {
panic!("Unknown hash algorithm {:?}", *b)
}
}
}
edit in libpijul/src/output/output.rs at line 11

[20.672295]

[20.672295]

use crate::{HashMap, HashSet};
replacement in libpijul/src/output/output.rs at line 14

[20.672334]→[20.672334:672376](∅→∅)

use std::collections::{HashMap, HashSet};

[20.672334]

[20.672376]

use std::sync::{Arc, RwLock};
replacement in libpijul/src/output/output.rs at line 32

[20.673008]→[20.673008:673107](∅→∅)

pub fn output_repository_no_pending<T: MutTxnT, R: WorkingCopy, P: ChangeStore>(
repo: &mut R,

[20.673008]

[20.673107]

pub fn output_repository_no_pending<
T: MutTxnT + Send + Sync + 'static,
R: WorkingCopy + Send + Sync + 'static,
P: ChangeStore + Send + Clone + 'static,
>(
repo: Arc<R>,
replacement in libpijul/src/output/output.rs at line 39

[20.673124]→[20.673124:673174](∅→∅)

txn: &mut T,
channel: &mut ChannelRef<T>,

[20.673124]

[20.673174]

txn: Arc<RwLock<T>>,
channel: ChannelRef<T>,
replacement in libpijul/src/output/output.rs at line 44

[20.1615]→[20.81906:81983](∅→∅),[20.673225]→[20.81906:81983](∅→∅)

) -> Result<Vec<Conflict>, OutputError<P::Error, T::GraphError, R::Error>> {

[20.1615]

[20.673269]

n_workers: usize,
) -> Result<Vec<Conflict>, OutputError<P::Error, T::GraphError, R::Error>>
where
T::Channel: Send + Sync + 'static,
{
replacement in libpijul/src/output/output.rs at line 53

[20.673336]→[20.673336:673373](∅→∅)

&mut channel.r.borrow_mut(),

[20.673336]

[20.673373]

channel,
edit in libpijul/src/output/output.rs at line 58

[20.1643]

[20.673474]

n_workers,
edit in libpijul/src/output/output.rs at line 62

[20.673483]

[20.673538]

fn output_loop<
T: TreeMutTxnT + ChannelMutTxnT + GraphMutTxnT<GraphError = <T as TreeTxnT>::TreeError>,
R: WorkingCopy + 'static,
P: ChangeStore + Clone + Send,
>(
repo: Arc<R>,
changes: &P,
txn: Arc<RwLock<T>>,
channel: ChannelRef<T>,
work: Arc<crossbeam_deque::Injector<(OutputItem, String)>>,
stop: Arc<std::sync::atomic::AtomicBool>,
t: usize,
) -> Result<(), OutputError<P::Error, T::GraphError, R::Error>> {
use crossbeam_deque::*;
// let backoff = crossbeam_utils::Backoff::new();
// let w: Worker<(OutputItem, String)> = Worker::new_fifo();
loop {
match work.steal() {
Steal::Success((item, path)) => {
let mut conflicts = Vec::new();
info!("Outputting {:?}, on thread {}", path, t);
output_item::<_, _, R>(
txn.clone(),
channel.clone(),
changes,
&item,
&mut conflicts,
&repo,
&path,
)?;
debug!("setting permissions for {:?}", path);
repo.set_permissions(&path, item.meta.permissions())
.map_err(OutputError::WorkingCopy)?;
debug!("output {:?}", path);
}
Steal::Retry => {}
Steal::Empty => {
if stop.load(std::sync::atomic::Ordering::Relaxed) {
break;
}
}
}
}
Ok(())
}
replacement in libpijul/src/output/output.rs at line 110

[20.673568]→[20.57617:57710](∅→∅),[20.57710]→[20.673584:673624](∅→∅),[20.82074]→[20.673584:673624](∅→∅),[20.673584]→[20.673584:673624](∅→∅)

T: TreeMutTxnT + ChannelMutTxnT + GraphMutTxnT<GraphError = <T as TreeTxnT>::TreeError>,
R: WorkingCopy,
P: ChangeStore,

[20.673568]

[20.673624]

T: TreeMutTxnT
+ ChannelMutTxnT
+ GraphMutTxnT<GraphError = <T as TreeTxnT>::TreeError>
+ Send
+ Sync
+ 'static,
R: WorkingCopy + Send + Sync + 'static,
P: ChangeStore + Send + Clone + 'static,
replacement in libpijul/src/output/output.rs at line 120

[20.673660]→[20.673660:673678](∅→∅)

repo: &mut R,

[20.673660]

[20.673678]

repo: Arc<R>,
replacement in libpijul/src/output/output.rs at line 122

[20.673695]→[20.673695:673712](∅→∅),[20.673712]→[20.57711:57741](∅→∅)

txn: &mut T,
channel: &mut T::Channel,

[20.673695]

[20.673742]

txn: Arc<RwLock<T>>,
channel: ChannelRef<T>,
replacement in libpijul/src/output/output.rs at line 128

[20.1698]→[20.82075:82151](∅→∅),[20.673828]→[20.82075:82151](∅→∅)

) -> Result<Vec<Conflict>, OutputError<P::Error, T::TreeError, R::Error>> {

[20.1698]

[20.673931]

n_workers: usize,
) -> Result<Vec<Conflict>, OutputError<P::Error, T::TreeError, R::Error>>
where
T::Channel: Send + Sync + 'static,
{
let work = Arc::new(crossbeam_deque::Injector::new());
let stop = Arc::new(std::sync::atomic::AtomicBool::new(false));
let mut threads = Vec::new();
for t in 0..n_workers - 1 {
let repo = repo.clone();
let work = work.clone();
let stop = stop.clone();
let txn = txn.clone();
let channel = channel.clone();
let changes = changes.clone();
threads.push(std::thread::spawn(move || {
output_loop(repo, &changes, txn, channel, work, stop, t + 1)
}))
}
replacement in libpijul/src/output/output.rs at line 149

[20.673967]→[20.673967:674044](∅→∅)

let mut files = HashMap::new();
let mut next_files = HashMap::new();

[20.673967]

[20.674044]

let mut files = HashMap::default();
let mut next_files = HashMap::default();
replacement in libpijul/src/output/output.rs at line 154

[20.980]→[20.980:1077](∅→∅)

let dead = collect_dead_files(txn, txn.graph(channel), pending_change_id, Inode::ROOT)?;

[20.980]

[20.1077]

let dead = {
let txn_ = txn.read().unwrap();
let channel = channel.read().unwrap();
let graph = txn_.graph(&*channel);
collect_dead_files(&*txn_, graph, pending_change_id, Inode::ROOT)?
};
replacement in libpijul/src/output/output.rs at line 161

[20.1133]→[20.1133:1188](∅→∅)

kill_dead_files::<T, R, P>(txn, repo, &dead)?;

[20.1133]

[20.1188]

if !dead.is_empty() {
let mut txn = txn.write().unwrap();
kill_dead_files::<T, R, P>(&mut *txn, repo.clone(), &dead)?;
}
replacement in libpijul/src/output/output.rs at line 167

[20.1225]→[20.674094:674146](∅→∅),[20.674094]→[20.674094:674146](∅→∅),[20.674146]→[20.4336:4364](∅→∅),[20.4364]→[20.674163:674278](∅→∅),[20.57769]→[20.674163:674278](∅→∅),[20.82176]→[20.674163:674278](∅→∅),[20.674163]→[20.674163:674278](∅→∅)

collect_children(
txn,
changes,
txn.graph(channel),
Position::ROOT,
Inode::ROOT,
"",
next_prefix_basename,
&mut files,
)?;

[20.1225]

[20.674574]

{
let txn = txn.read().unwrap();
let channel = channel.read().unwrap();
collect_children(
&*txn,
&*changes,
txn.graph(&*channel),
Position::ROOT,
Inode::ROOT,
"",
next_prefix_basename,
&mut files,
)?;
}
replacement in libpijul/src/output/output.rs at line 182

[20.674653]→[20.674653:674695](∅→∅),[20.674695]→[20.1226:1270](∅→∅)

let mut done_inodes = HashSet::new();
let mut done_vertices = HashMap::new();

[20.674618]

[20.674695]

let mut done_inodes = HashSet::default();
let mut done_vertices = HashMap::default();
replacement in libpijul/src/output/output.rs at line 194

[20.675153]→[20.9361:9401](∅→∅),[20.9401]→[20.119754:119824](∅→∅),[20.4532]→[20.675254:675284](∅→∅),[20.57935]→[20.675254:675284](∅→∅),[20.119824]→[20.675254:675284](∅→∅),[20.675254]→[20.675254:675284](∅→∅),[20.675284]→[20.741:767](∅→∅),[20.767]→[20.119825:119904](∅→∅),[20.119904]→[20.845:906](∅→∅),[20.845]→[20.845:906](∅→∅),[20.906]→[20.675450:675466](∅→∅),[20.4622]→[20.675450:675466](∅→∅),[20.58024]→[20.675450:675466](∅→∅),[20.675450]→[20.675450:675466](∅→∅)

b.sort_unstable_by(|u, v| {
txn.get_changeset(txn.changes(&channel), &u.0.change)
.unwrap()
.cmp(
&txn.get_changeset(txn.changes(&channel), &v.0.change)
.unwrap(),
)
});

[20.675153]

[20.675466]

{
let txn = txn.read().unwrap();
let channel = channel.read().unwrap();
b.sort_unstable_by(|u, v| {
txn.get_changeset(txn.changes(&channel), &u.0.change)
.unwrap()
.cmp(
&txn.get_changeset(txn.changes(&channel), &v.0.change)
.unwrap(),
)
});
}
replacement in libpijul/src/output/output.rs at line 223

[20.82272]→[20.82272:82312](∅→∅)

let output_item_inode =

[20.82272]

[20.119905]

let output_item_inode = {
let txn = txn.read().unwrap();
replacement in libpijul/src/output/output.rs at line 229

[20.82532]→[20.82532:82555](∅→∅)

};

[20.82532]

[20.82555]

}
};
replacement in libpijul/src/output/output.rs at line 258

[20.20338]→[20.677425:677476](∅→∅),[20.677425]→[20.677425:677476](∅→∅)

txn,
repo,

[20.20338]

[20.677476]

txn.clone(),
repo.clone(),
edit in libpijul/src/output/output.rs at line 266

[20.677628]

[20.677628]

debug!("inode = {:?}", inode);
replacement in libpijul/src/output/output.rs at line 268

[20.677697]→[20.58025:58056](∅→∅),[20.58056]→[20.4623:4719](∅→∅)

let dead =
collect_dead_files(txn, txn.graph(channel), pending_change_id, inode)?;

[20.677697]

[20.677788]

let dead = {
let txn_ = txn.read().unwrap();
let channel = channel.read().unwrap();
collect_dead_files(&*txn_, txn_.graph(&*channel), pending_change_id, inode)?
};
replacement in libpijul/src/output/output.rs at line 274

[20.677856]→[20.20339:20406](∅→∅)

kill_dead_files::<T, R, P>(txn, repo, &dead)?;

[20.677856]

[20.677912]

if !dead.is_empty() {
let mut txn = txn.write().unwrap();
kill_dead_files::<T, R, P>(&mut *txn, repo.clone(), &dead)?;
}
replacement in libpijul/src/output/output.rs at line 283

[20.20515]→[20.678140:678240](∅→∅),[20.678140]→[20.678140:678240](∅→∅),[20.678240]→[20.4720:4764](∅→∅),[20.4764]→[20.678273:678463](∅→∅),[20.58195]→[20.678273:678463](∅→∅),[20.82799]→[20.678273:678463](∅→∅),[20.678273]→[20.678273:678463](∅→∅),[20.678463]→[20.82800:82824](∅→∅)

collect_children(
txn,
changes,
txn.graph(channel),
output_item.pos,
inode,
&path,
next_prefix_basename,
&mut next_files,
)?;

[20.20515]

[20.678486]

{
let txn = txn.read().unwrap();
let channel = channel.read().unwrap();
collect_children(
&*txn,
&*changes,
txn.graph(&*channel),
output_item.pos,
inode,
&path,
next_prefix_basename,
&mut next_files,
)?;
}
debug!("setting permissions for {:?}", path);
repo.set_permissions(&path, output_item.meta.permissions())
.map_err(OutputError::WorkingCopy)?;
replacement in libpijul/src/output/output.rs at line 301

[20.678511]→[20.892:962](∅→∅),[20.962]→[20.2082:2517](∅→∅),[20.2082]→[20.2082:2517](∅→∅),[20.2517]→[20.1244:1297](∅→∅)

if needs_output(repo, if_modified_after, &path) {
repo.write_file(&path, |w: &mut dyn std::io::Write| {
output_file::<_, _, R>(
txn,
channel,
changes,
&output_item,
&mut conflicts,
w,
)
})
.map_err(OutputError::from)?

[20.678511]

[20.963]

if needs_output(repo.as_ref(), if_modified_after, &path) {
work.push((output_item.clone(), path.clone()));
edit in libpijul/src/output/output.rs at line 312

[20.678910]→[20.20887:21020](∅→∅)

repo.set_permissions(&path, output_item.meta.permissions())
.map_err(OutputError::WorkingCopy)?;
edit in libpijul/src/output/output.rs at line 318

[20.21082]

[20.679209]

}

stop.store(true, std::sync::atomic::Ordering::Relaxed);
let o = output_loop(repo, changes, txn, channel, work, stop, 0);
for t in threads {
t.join().unwrap()?
edit in libpijul/src/output/output.rs at line 325

[20.679215]

[20.679215]

o?;
replacement in libpijul/src/output/output.rs at line 359

[20.21147]→[20.679732:679767](∅→∅),[20.82892]→[20.679732:679767](∅→∅),[20.679732]→[20.679732:679767](∅→∅)

txn: &mut T,
repo: &mut R,

[20.82892]

[20.679767]

txn: Arc<RwLock<T>>,
repo: Arc<R>,
replacement in libpijul/src/output/output.rs at line 377

[20.680369]→[20.83074:83144](∅→∅)

if let Some(ref current_name) = inode_filename(txn, inode)? {

[20.680369]

[20.680438]

let txn_ = txn.read().unwrap();
if let Some(ref current_name) = inode_filename(&*txn_, inode)? {
replacement in libpijul/src/output/output.rs at line 381

[20.680552]→[20.120116:120197](∅→∅)

let parent = txn.get_revtree(&inode, None)?.unwrap().to_owned();

[20.680552]

[20.680631]

std::mem::drop(txn_);
let mut txn_ = txn.write().unwrap();
let parent = txn_.get_revtree(&inode, None)?.unwrap().to_owned();
replacement in libpijul/src/output/output.rs at line 385

[20.680701]→[20.120198:120256](∅→∅)

del_tree_with_rev(txn, &parent, &inode)?;

[20.680701]

[20.680852]

del_tree_with_rev(&mut *txn_, &parent, &inode)?;
replacement in libpijul/src/output/output.rs at line 403

[20.681455]→[20.120257:120397](∅→∅)

if let Some(&inode) = txn.get_tree(&file_id, None)? {
crate::fs::rec_delete(txn, &file_id, inode, true)

[20.681455]

[20.21529]

if let Some(&inode) = txn_.get_tree(&file_id, None)? {
crate::fs::rec_delete(&mut *txn_, &file_id, inode, true)
replacement in libpijul/src/output/output.rs at line 407

[20.681620]→[20.120398:120526](∅→∅)

put_inodes_with_rev(txn, &inode, &output_item.pos)?;
put_tree_with_rev(txn, &file_id, &inode)?;

[20.681620]

[20.681836]

put_inodes_with_rev(&mut *txn_, &inode, &output_item.pos)?;
put_tree_with_rev(&mut *txn_, &file_id, &inode)?;
replacement in libpijul/src/output/output.rs at line 412

[20.120603]→[20.120603:120735](∅→∅)

if let Some(&inode) = txn.get_tree(&file_id, None)? {
crate::fs::rec_delete(txn, &file_id, inode, true)

[20.120603]

[20.21878]

std::mem::drop(txn_);
let mut txn_ = txn.write().unwrap();
if let Some(&inode) = txn_.get_tree(&file_id, None)? {
crate::fs::rec_delete(&mut *txn_, &file_id, inode, true)
replacement in libpijul/src/output/output.rs at line 418

[20.682097]→[20.120736:120856](∅→∅)

put_inodes_with_rev(txn, &inode, &output_item.pos)?;
put_tree_with_rev(txn, &file_id, &inode)?;

[20.682097]

[20.682297]

put_inodes_with_rev(&mut *txn_, &inode, &output_item.pos)?;
put_tree_with_rev(&mut *txn_, &file_id, &inode)?;
replacement in libpijul/src/output/output.rs at line 423

[20.682397]→[20.120857:120919](∅→∅),[20.120919]→[20.17458:17555](∅→∅)

if let Some(&inode) = txn.get_tree(&file_id, None)? {
crate::fs::rec_delete(txn, &file_id, inode, true).map_err(PristineOutputError::Fs)?;

[20.682397]

[20.682528]

let mut txn_ = txn.write().unwrap();
if let Some(&inode) = txn_.get_tree(&file_id, None)? {
crate::fs::rec_delete(&mut *txn_, &file_id, inode, true)
.map_err(PristineOutputError::Fs)?;
replacement in libpijul/src/output/output.rs at line 428

[20.682538]→[20.83738:83782](∅→∅)

let inode = create_new_inode(txn)?;

[20.682538]

[20.682581]

let inode = create_new_inode(&mut *txn_)?;
replacement in libpijul/src/output/output.rs at line 433

[20.682701]→[20.121027:121139](∅→∅)

put_inodes_with_rev(txn, &inode, &output_item.pos)?;
put_tree_with_rev(txn, &file_id, &inode)?;

[20.682701]

[20.239]

put_inodes_with_rev(&mut *txn_, &inode, &output_item.pos)?;
put_tree_with_rev(&mut *txn_, &file_id, &inode)?;
replacement in libpijul/src/output/output.rs at line 440

[20.416]→[20.121140:121185](∅→∅)

txn.put_tree(&path_id, &inode)?;

[20.416]

[20.523]

txn_.put_tree(&path_id, &inode)?;
replacement in libpijul/src/output/output.rs at line 446

[20.22422]→[20.58196:58278](∅→∅),[20.22482]→[20.683010:683027](∅→∅),[20.58278]→[20.683010:683027](∅→∅),[20.84029]→[20.683010:683027](∅→∅),[20.683010]→[20.683010:683027](∅→∅),[20.683027]→[20.58279:58309](∅→∅)

fn output_file<T: ChannelMutTxnT + GraphMutTxnT, P: ChangeStore, W: WorkingCopy>(
txn: &mut T,
channel: &mut T::Channel,

[20.22422]

[20.683057]

fn output_item<T: ChannelMutTxnT + GraphMutTxnT, P: ChangeStore, W: WorkingCopy>(
txn: Arc<RwLock<T>>,
channel: ChannelRef<T>,
replacement in libpijul/src/output/output.rs at line 452

[20.683139]→[20.683139:683171](∅→∅)

w: &mut dyn std::io::Write,

[20.683139]

[20.84030]

repo: &W,
path: &str,
edit in libpijul/src/output/output.rs at line 455

[20.84096]→[20.4887:4956](∅→∅),[20.4956]→[20.683261:683347](∅→∅),[20.58378]→[20.683261:683347](∅→∅),[20.84161]→[20.683261:683347](∅→∅),[20.683261]→[20.683261:683347](∅→∅)

let mut l = retrieve(txn, txn.graph(channel), output_item.pos)?;
let mut f = vertex_buffer::ConflictsWriter::new(w, &output_item.path, conflicts);
replacement in libpijul/src/output/output.rs at line 456

[20.683381]→[20.22545:22668](∅→∅)

alive::output_graph(changes, txn, channel, &mut f, &mut l, &mut forward)
.map_err(PristineOutputError::from)?;

[20.683381]

[20.683460]

{
let txn = txn.read().unwrap();
let channel = channel.read().unwrap();
let mut l = retrieve(&*txn, txn.graph(&*channel), output_item.pos)?;
let w = repo.write_file(&path).map_err(OutputError::WorkingCopy)?;
let mut f = vertex_buffer::ConflictsWriter::new(w, &output_item.path, conflicts);
alive::output_graph(changes, &*txn, &*channel, &mut f, &mut l, &mut forward)
.map_err(PristineOutputError::from)?;
}
if forward.is_empty() {
return Ok(());
}
let mut txn = txn.write().unwrap();
let mut channel = channel.write().unwrap();
replacement in libpijul/src/output/output.rs at line 472

[20.683557]→[20.121186:121264](∅→∅)

let dest = *txn.find_block(txn.graph(channel), edge.dest()).unwrap();

[20.683557]

[20.683622]

let dest = *txn.find_block(txn.graph(&*channel), edge.dest()).unwrap();
replacement in libpijul/src/output/output.rs at line 475

[20.84263]→[20.84263:84280](∅→∅),[20.84280]→[20.58454:58489](∅→∅)

txn,
T::graph_mut(channel),

[20.84263]

[20.121265]

&mut *txn,
T::graph_mut(&mut *channel),
replacement in libpijul/src/output/output.rs at line 486

[20.22806]→[20.84418:84510](∅→∅),[20.84510]→[20.683894:683911](∅→∅),[20.683894]→[20.683894:683911](∅→∅)

fn collect_dead_files<T: TreeMutTxnT + GraphTxnT<GraphError = <T as TreeTxnT>::TreeError>>(
txn: &mut T,

[20.22806]

[20.84511]

fn collect_dead_files<T: TreeTxnT + GraphTxnT<GraphError = <T as TreeTxnT>::TreeError>>(
txn: &T,
replacement in libpijul/src/output/output.rs at line 494

[20.684122]→[20.684122:684157](∅→∅)

let mut dead = HashMap::new();

[20.684122]

[20.684157]

let mut dead = HashMap::default();
replacement in libpijul/src/output/output.rs at line 533

[20.685468]→[20.685468:685486](∅→∅)

repo: &mut W,

[20.685468]

[20.685486]

repo: Arc<W>,
replacement in libpijul/src/output/mod.rs at line 4

[20.686269]→[20.686269:686300](∅→∅)

use std::collections::HashMap;

[20.686269]

[20.686300]

use crate::HashMap;
replacement in libpijul/src/output/mod.rs at line 15

[20.23329]→[20.23329:23365](∅→∅)

W: std::error::Error + 'static,

[20.23329]

[20.23365]

W: std::error::Error + Send + 'static,
edit in libpijul/src/output/mod.rs at line 34

[20.23889]→[20.23889:24228](∅→∅),[20.24228]→[20.85289:85295](∅→∅)

}

use crate::working_copy::WriteError;

impl<C: std::error::Error, T: std::error::Error + 'static, W: std::error::Error>
OutputError<C, T, W>
{
fn from(e: WriteError<Self>) -> Self {
match e {
WriteError::Io(e) => OutputError::Pristine(PristineOutputError::Io(e)),
WriteError::E(e) => e,
}
}
replacement in libpijul/src/output/mod.rs at line 44

[20.85492]→[20.85492:85618](∅→∅)

impl<C: std::error::Error, T: std::error::Error + 'static, W: std::error::Error> From<TxnErr<T>>
for OutputError<C, T, W>

[20.85492]

[20.85618]

impl<C: std::error::Error, T: std::error::Error + 'static, W: std::error::Error + Send>
From<TxnErr<T>> for OutputError<C, T, W>
replacement in libpijul/src/output/mod.rs at line 80

[20.24779]→[20.686366:686383](∅→∅),[20.86195]→[20.686366:686383](∅→∅),[20.686366]→[20.686366:686383](∅→∅)

#[derive(Debug)]

[20.86195]

[20.686383]

#[derive(Debug, Clone)]
edit in libpijul/src/output/mod.rs at line 192

[20.87456]

[20.690028]

}

pub fn output_file<
T: TreeTxnT + ChannelTxnT,
C: crate::changestore::ChangeStore,
V: crate::vertex_buffer::VertexBuffer,
>(
changes: &C,
txn: &T,
channel: &T::Channel,
v0: Position<ChangeId>,
out: &mut V,
) -> Result<(), FileError<C::Error, T::GraphError>> {
let mut forward = Vec::new();
let mut graph = crate::alive::retrieve(&*txn, txn.graph(&*channel), v0)?;
crate::alive::output_graph(changes, &*txn, &*channel, out, &mut graph, &mut forward)?;
Ok(())
edit in libpijul/src/output/archive.rs at line 4

[20.690117]

[20.690117]

use crate::{HashMap, HashSet};
edit in libpijul/src/output/archive.rs at line 6

[20.690156]→[20.690156:690198](∅→∅)

use std::collections::{HashMap, HashSet};
replacement in libpijul/src/output/archive.rs at line 146

[20.25953]→[20.692403:692439](∅→∅),[20.88013]→[20.692403:692439](∅→∅),[20.692403]→[20.692403:692439](∅→∅)

let channel = channel.borrow();

[20.88013]

[20.692439]

let channel = channel.read().unwrap();
replacement in libpijul/src/output/archive.rs at line 148

[20.692475]→[20.692475:692552](∅→∅)

let mut files = HashMap::new();
let mut next_files = HashMap::new();

[20.692475]

[20.692552]

let mut files = HashMap::default();
let mut next_files = HashMap::default();
replacement in libpijul/src/output/archive.rs at line 162

[20.692788]→[20.692788:692865](∅→∅)

let mut done = HashMap::new();
let mut done_inodes = HashSet::new();

[20.692788]

[20.692865]

let mut done = HashMap::default();
let mut done_inodes = HashSet::default();
edit in libpijul/src/missing_context.rs at line 5

[20.696625]

[20.696625]

use crate::{HashMap, HashSet};
edit in libpijul/src/missing_context.rs at line 7

[20.696664]→[20.696664:696706](∅→∅)

use std::collections::{HashMap, HashSet};
replacement in libpijul/src/missing_context.rs at line 48

[20.697611]→[20.697611:697661](∅→∅)

let mut ids = HashMap::new();

[20.697611]

[20.697661]

let mut ids = HashMap::default();
replacement in libpijul/src/missing_context.rs at line 185

[20.11543]→[20.704175:704213](∅→∅),[20.89883]→[20.704175:704213](∅→∅),[20.704175]→[20.704175:704213](∅→∅)

let mut unknown = HashSet::new();

[20.89883]

[20.89884]

let mut unknown = HashSet::default();
replacement in libpijul/src/missing_context.rs at line 236

[20.706744]→[20.706744:706771](∅→∅)

unknown_parents: Vec<(

[20.706744]

[20.706771]

pub(crate) unknown_parents: Vec<(
replacement in libpijul/src/missing_context.rs at line 243

[20.123715]→[20.123715:123806](∅→∅)

parents: HashSet<SerializedEdge>,
pseudo: Vec<(Vertex<ChangeId>, SerializedEdge)>,

[20.123715]

[20.106]

pub(crate) parents: HashSet<SerializedEdge>,
pub(crate) pseudo: Vec<(Vertex<ChangeId>, SerializedEdge)>,
edit in libpijul/src/missing_context.rs at line 419

[20.27318]→[20.712749:712811](∅→∅),[20.59459]→[20.712749:712811](∅→∅),[20.92306]→[20.712749:712811](∅→∅),[20.124988]→[20.712749:712811](∅→∅),[20.712749]→[20.712749:712811](∅→∅),[20.712811]→[20.92307:92365](∅→∅),[20.92365]→[20.712864:712881](∅→∅),[20.712864]→[20.712864:712881](∅→∅),[20.712881]→[20.92366:92394](∅→∅),[20.92394]→[20.712911:713044](∅→∅),[20.712911]→[20.712911:713044](∅→∅),[20.713044]→[20.92395:92440](∅→∅),[20.27359]→[20.713075:713184](∅→∅),[20.92440]→[20.713075:713184](∅→∅),[20.713075]→[20.713075:713184](∅→∅),[20.713184]→[20.59460:59594](∅→∅),[20.59594]→[20.713316:713358](∅→∅),[20.713316]→[20.713316:713358](∅→∅),[20.713358]→[20.124989:125054](∅→∅),[20.59508]→[20.59660:59770](∅→∅),[20.125054]→[20.59660:59770](∅→∅),[20.59660]→[20.59660:59770](∅→∅),[20.59770]→[20.713458:713587](∅→∅),[20.713458]→[20.713458:713587](∅→∅),[20.713587]→[20.92441:92478](∅→∅),[20.92478]→[20.125055:125132](∅→∅),[20.125132]→[20.713672:713712](∅→∅),[20.713672]→[20.713672:713712](∅→∅),[20.713712]→[20.125133:125229](∅→∅),[20.125229]→[20.713805:713845](∅→∅),[20.713805]→[20.713805:713845](∅→∅),[20.713845]→[20.125230:125284](∅→∅),[20.125284]→[20.713897:713956](∅→∅),[20.713897]→[20.713897:713956](∅→∅),[20.713956]→[20.125285:125368](∅→∅),[20.92552]→[20.714028:714063](∅→∅),[20.125368]→[20.714028:714063](∅→∅),[20.714028]→[20.714028:714063](∅→∅),[20.714063]→[20.59771:59819](∅→∅),[20.59819]→[20.125369:125429](∅→∅)

}
}
}
}
Ok(())
}

pub(crate) fn collect_zombie_context<T: GraphMutTxnT, K>(
txn: &mut T,
channel: &mut T::Graph,
ws: &mut Workspace,
inode: Position<Option<Hash>>,
n: &NewEdge<Option<Hash>>,
change_id: ChangeId,
mut known: K,
) -> Result<(), MissingError<T::GraphError>>
where
K: FnMut(Hash) -> bool,
{
if n.flag.contains(EdgeFlags::FOLDER) {
return Ok(());
}
let mut pos = internal_pos(txn, &n.to.start_pos(), change_id)?;
let end_pos = internal_pos(txn, &n.to.end_pos(), change_id)?;
let mut unknown_parents = Vec::new();
while let Ok(&dest_vertex) = txn.find_block(&channel, pos) {
debug!("collect zombie context: {:?}", dest_vertex);
for v in iter_adjacent(
txn,
channel,
dest_vertex,
EdgeFlags::empty(),
EdgeFlags::all() - EdgeFlags::DELETED,
)? {
let v = v?;
if v.introduced_by() == change_id || v.dest().change.is_root() {
continue;
}
if v.introduced_by().is_root() {
ws.pseudo.push((dest_vertex, *v));
continue;
}
if v.flag().contains(EdgeFlags::PARENT) {
// Unwrap ok, since `v` is in the channel.
let intro = txn.get_external(&v.introduced_by())?.unwrap().into();
if !known(intro) {
debug!("unknown: {:?}", v);
unknown_parents.push((dest_vertex, *v))
edit in libpijul/src/missing_context.rs at line 420

[20.714140]→[20.714140:714391](∅→∅),[20.714391]→[20.92553:92582](∅→∅),[20.92582]→[20.714415:714432](∅→∅),[20.714415]→[20.714415:714432](∅→∅),[20.714432]→[20.92583:92611](∅→∅),[20.92611]→[20.714462:714567](∅→∅),[20.714462]→[20.714462:714567](∅→∅),[20.714567]→[20.125430:125482](∅→∅),[20.125482]→[20.92612:92659](∅→∅),[20.714609]→[20.92612:92659](∅→∅),[20.27402]→[20.714642:714691](∅→∅),[20.92659]→[20.714642:714691](∅→∅),[20.714642]→[20.714642:714691](∅→∅),[20.714691]→[20.125483:125543](∅→∅),[20.125543]→[20.17857:17941](∅→∅),[20.17941]→[20.715147:715192](∅→∅),[20.125614]→[20.715147:715192](∅→∅),[20.715147]→[20.715147:715192](∅→∅),[20.715192]→[20.342:410](∅→∅),[20.410]→[20.715438:715461](∅→∅),[20.715438]→[20.715438:715461](∅→∅),[20.715461]→[20.125615:125687](∅→∅),[20.59638]→[20.715532:715608](∅→∅),[20.59951]→[20.715532:715608](∅→∅),[20.125687]→[20.715532:715608](∅→∅),[20.715532]→[20.715532:715608](∅→∅),[20.715608]→[20.59952:60013](∅→∅),[20.60013]→[20.715648:715820](∅→∅),[20.715648]→[20.715648:715820](∅→∅),[20.715820]→[20.92660:92680](∅→∅),[20.27467]→[20.715840:715906](∅→∅),[20.92680]→[20.715840:715906](∅→∅),[20.715840]→[20.715840:715906](∅→∅)

}
}
zombify(txn, channel, ws, change_id, inode, n.flag, &unknown_parents)?;
if dest_vertex.end < end_pos.pos {
pos.pos = dest_vertex.end
} else {
break;
}
}
Ok(())
}

fn zombify<T: GraphMutTxnT>(
txn: &mut T,
channel: &mut T::Graph,
ws: &mut Workspace,
change_id: ChangeId,
inode: Position<Option<Hash>>,
flag: EdgeFlags,
unknown: &[(Vertex<ChangeId>, SerializedEdge)],
) -> Result<(), MissingError<T::GraphError>> {
for &(dest_vertex, edge) in unknown.iter() {
let p = *txn.find_block_end(channel, edge.dest())?;
ws.unknown_parents
.push((dest_vertex, p, inode, edge.flag()));
let fold = flag & EdgeFlags::FOLDER;
debug!("zombify p {:?}, dest_vertex {:?}", p, dest_vertex);
let mut v = p;
while let Ok(&u) = txn.find_block_end(channel, v.start_pos()) {
if u != v {
debug!("u = {:?}, v = {:?}", u, v);
put_graph_with_rev(
txn,
channel,
EdgeFlags::DELETED | EdgeFlags::BLOCK | fold,
u,
v,
change_id,
)?;
v = u
} else {
break;
edit in libpijul/src/missing_context.rs at line 422

[20.715930]→[20.715930:715979](∅→∅),[20.715979]→[20.60014:60068](∅→∅),[20.60068]→[20.716020:716138](∅→∅),[20.716020]→[20.716020:716138](∅→∅),[20.716138]→[20.92681:92728](∅→∅),[20.92728]→[20.125688:125792](∅→∅),[20.125792]→[20.716251:716367](∅→∅),[20.716251]→[20.716251:716367](∅→∅),[20.716367]→[20.125793:125869](∅→∅),[20.59712]→[20.716440:716506](∅→∅),[20.60143]→[20.716440:716506](∅→∅),[20.125869]→[20.716440:716506](∅→∅),[20.716440]→[20.716440:716506](∅→∅),[20.716506]→[20.125870:125929](∅→∅),[20.125929]→[20.716563:716619](∅→∅),[20.716563]→[20.716563:716619](∅→∅),[20.716619]→[20.92729:92809](∅→∅),[20.27592]→[20.716698:716708](∅→∅),[20.60224]→[20.716698:716708](∅→∅),[20.92809]→[20.716698:716708](∅→∅),[20.716698]→[20.716698:716708](∅→∅)

// Zombify the first chunk of the split.
for parent in iter_adjacent(
txn,
channel,
v,
EdgeFlags::PARENT,
EdgeFlags::all() - EdgeFlags::DELETED,
)? {
let parent = parent?;
if !parent.flag().contains(EdgeFlags::PSEUDO) {
ws.parents.insert(*parent);
}
}
debug!("ws.parents = {:?}", ws.parents);
for parent in ws.parents.drain() {
let parent_dest = *txn.find_block_end(channel, parent.dest())?;
let mut flag = EdgeFlags::DELETED | EdgeFlags::BLOCK;
if parent.flag().contains(EdgeFlags::FOLDER) {
flag |= EdgeFlags::FOLDER
}
put_graph_with_rev(txn, channel, flag, parent_dest, v, change_id)?;
}
replacement in libpijul/src/lib.rs at line 105

[20.720352]→[20.720352:720383](∅→∅)

use std::collections::HashMap;

[20.720352]

[20.720383]

// Making hashmaps deterministic (for testing)
pub type HashMap<K, V> =
std::collections::HashMap<K, V, std::hash::BuildHasherDefault<twox_hash::XxHash64>>;
pub type HashSet<K> =
std::collections::HashSet<K, std::hash::BuildHasherDefault<twox_hash::XxHash64>>;
// pub type HashMap<K, V> = std::collections::HashMap<K, V, std::collections::hash_map::RandomState>;
// pub type HashSet<K> = std::collections::HashSet<K, std::collections::hash_map::RandomState>;
replacement in libpijul/src/lib.rs at line 168

[20.722235]→[20.722235:722285](∅→∅)

channel: &mut pristine::ChannelRef<Self>,

[20.722235]

[20.722285]

channel: &pristine::ChannelRef<Self>,
replacement in libpijul/src/lib.rs at line 179

[20.722651]→[20.722651:722708](∅→∅)

channel: &mut crate::pristine::ChannelRef<Self>,

[20.722651]

[20.722708]

channel: &crate::pristine::ChannelRef<Self>,
edit in libpijul/src/lib.rs at line 187

[20.722981]

[20.722981]

/*
replacement in libpijul/src/lib.rs at line 203

[20.93967]→[20.93967:94006](∅→∅)

&mut channel.borrow_mut(),

[20.93967]

[20.94006]

&mut channel.lock().unwrap(),
replacement in libpijul/src/lib.rs at line 213

[20.723558]→[20.723558:723608](∅→∅)

channel: &mut pristine::ChannelRef<Self>,

[20.723558]

[20.723608]

channel: &pristine::ChannelRef<Self>,
replacement in libpijul/src/lib.rs at line 225

[20.94336]→[20.94336:94375](∅→∅)

&mut channel.borrow_mut(),

[20.94336]

[20.94375]

&mut channel.lock().unwrap(),
edit in libpijul/src/lib.rs at line 232

[20.723911]

[20.723911]

*/
replacement in libpijul/src/lib.rs at line 242

[20.724271]→[20.724271:724318](∅→∅)

hasher.update(&recorded.contents);

[20.724271]

[20.724318]

hasher.update(&recorded.contents.lock().unwrap()[..]);
replacement in libpijul/src/lib.rs at line 261

[20.724970]→[20.724970:725011](∅→∅)

contents: recorded.contents,

[20.724970]

[20.725011]

contents: std::sync::Arc::try_unwrap(recorded.contents)
.unwrap()
.into_inner()
.unwrap(),
replacement in libpijul/src/lib.rs at line 276

[20.725282]→[20.725282:725332](∅→∅)

channel: &mut pristine::ChannelRef<Self>,

[20.725282]

[20.725332]

channel: &pristine::ChannelRef<Self>,
edit in libpijul/src/lib.rs at line 282

[20.725466]

[20.725466]

/*
edit in libpijul/src/lib.rs at line 303

[20.725984]

[20.725984]

*/
edit in libpijul/src/lib.rs at line 333

[20.727226]→[20.727226:727232](∅→∅),[20.727232]→[20.126258:126265](∅→∅),[20.126265]→[20.727233:727334](∅→∅),[20.727233]→[20.727233:727334](∅→∅),[20.727334]→[20.29300:29376](∅→∅),[20.29376]→[20.95239:95307](∅→∅),[20.95307]→[20.29439:29486](∅→∅),[20.29439]→[20.29439:29486](∅→∅),[20.29486]→[20.95308:95356](∅→∅),[20.95356]→[20.29487:29669](∅→∅),[20.727465]→[20.29487:29669](∅→∅),[20.29669]→[20.727603:727620](∅→∅),[20.727603]→[20.727603:727620](∅→∅),[20.727620]→[20.29670:29741](∅→∅),[20.29741]→[20.727740:727750](∅→∅),[20.727740]→[20.727740:727750](∅→∅)

}
/*
#[cfg(feature = "dump")]
fn channel_from_dump<'a>(
&'a mut self,
name: &str,
) -> Result<
pristine::channel_dump::ChannelFromDump<'a, Self>,
pristine::channel_dump::ChannelDumpError<Self::GraphError>,
> {
use pristine::channel_dump::*;
if self.load_channel(name)?.is_none() {
let channel = pristine::MutTxnT::open_or_create_channel(self, name)
.map_err(ChannelDumpError::Txn)?;
Ok(ChannelFromDump::new(self, channel))
} else {
Err(ChannelDumpError::ChannelNameExists(name.to_string()))
}
replacement in libpijul/src/lib.rs at line 334

[20.727756]→[20.126266:126273](∅→∅)

*/

[20.727756]

[20.2901]
replacement in libpijul/src/lib.rs at line 374

[20.728883]→[20.95569:95647](∅→∅)

for x in pristine::changeid_rev_log(self, &channel.borrow(), None)? {

[20.728883]

[20.126344]

for x in pristine::changeid_rev_log(self, &channel.read().unwrap(), None)? {
replacement in libpijul/src/lib.rs at line 419

[20.126860]→[20.5370:5439](∅→∅),[20.96148]→[20.5370:5439](∅→∅)

self.get_changeset(self.changes(&channel.borrow()), cid)

[20.126860]

[20.96217]

self.get_changeset(self.changes(&channel.read().unwrap()), cid)
replacement in libpijul/src/lib.rs at line 505

[20.127430]→[20.127430:127483](∅→∅)

self.rev_changes(&channel.borrow()),

[20.127430]

[20.127483]

self.rev_changes(&channel.read().unwrap()),
replacement in libpijul/src/lib.rs at line 528

[20.127881]→[20.5586:5653](∅→∅),[20.98064]→[20.5586:5653](∅→∅)

self.get_changeset(self.changes(&channel.borrow()), h)

[20.127881]

[20.98065]

self.get_changeset(self.changes(&channel.read().unwrap()), h)
replacement in libpijul/src/lib.rs at line 558

[20.732181]→[20.732181:732254](∅→∅)

fs::find_path(changes, self, &channel.borrow(), false, position)

[20.732181]

[20.732254]

fs::find_path(changes, self, &channel.read().unwrap(), false, position)
replacement in libpijul/src/lib.rs at line 571

[20.732653]→[20.732653:732725](∅→∅)

fs::find_path(changes, self, &channel.borrow(), true, position)

[20.732653]

[20.732725]

fs::find_path(changes, self, &channel.read().unwrap(), true, position)
replacement in libpijul/src/lib.rs at line 583

[20.98933]→[20.98933:99004](∅→∅),[20.99004]→[20.733032:733275](∅→∅),[20.733032]→[20.733032:733275](∅→∅),[20.733275]→[20.99005:99074](∅→∅),[20.30231]→[20.733312:733390](∅→∅),[20.99074]→[20.733312:733390](∅→∅),[20.733312]→[20.733312:733390](∅→∅),[20.733390]→[20.5654:5728](∅→∅),[20.5728]→[20.733451:733552](∅→∅),[20.60580]→[20.733451:733552](∅→∅),[20.99143]→[20.733451:733552](∅→∅),[20.733451]→[20.733451:733552](∅→∅)

fs::follow_oldest_path(changes, self, &channel.borrow(), path)
}

fn output_file<C: changestore::ChangeStore, V: vertex_buffer::VertexBuffer>(
&self,
changes: &C,
channel: &pristine::ChannelRef<Self>,
v0: pristine::Position<pristine::ChangeId>,
out: &mut V,
) -> Result<(), output::FileError<C::Error, Self::GraphError>> {
let mut forward = Vec::new();
let channel = channel.borrow();
let mut graph = alive::retrieve(self, self.graph(&channel), v0)?;
alive::output_graph(changes, self, &channel, out, &mut graph, &mut forward)?;
Ok(())

[20.98933]

[20.733552]

fs::follow_oldest_path(changes, self, &channel.read().unwrap(), path)
replacement in libpijul/src/fs.rs at line 20

[20.738443]→[20.13068:13099](∅→∅)

use std::collections::HashSet;

[20.738443]

[20.738461]

use crate::HashSet;
replacement in libpijul/src/fs.rs at line 538

[20.109176]→[20.15293:15326](∅→∅),[20.15293]→[20.15293:15326](∅→∅)

visited: HashSet::new(),

[20.109176]

[20.15326]

visited: HashSet::default(),
replacement in libpijul/src/find_alive.rs at line 2

[20.64452]→[20.763435:763466](∅→∅),[20.763435]→[20.763435:763466](∅→∅)

use std::collections::HashSet;

[20.64452]

[20.32357]

use crate::HashSet;
replacement in libpijul/src/find_alive.rs at line 10

[20.134264]→[20.763834:763908](∅→∅),[20.763834]→[20.763834:763908](∅→∅)

let mut visited = HashSet::new();
let mut alive = HashSet::new();

[20.134264]

[20.763967]

let mut visited = HashSet::default();
let mut alive = HashSet::default();
replacement in libpijul/src/find_alive.rs at line 51

[20.15706]→[20.765386:765422](∅→∅),[20.32501]→[20.765386:765422](∅→∅),[20.115204]→[20.765386:765422](∅→∅),[20.765386]→[20.765386:765422](∅→∅)

let mut alive = HashSet::new();

[20.115204]

[20.134828]

let mut alive = HashSet::default();
replacement in libpijul/src/find_alive.rs at line 53

[20.134912]→[20.765600:765638](∅→∅),[20.765600]→[20.765600:765638](∅→∅)

let mut visited = HashSet::new();

[20.134912]

[20.765697]

let mut visited = HashSet::default();
replacement in libpijul/src/diff/vertex_buffer.rs at line 3

[20.769009]→[20.769009:769051](∅→∅)

use std::collections::{HashMap, HashSet};

[20.769009]

[20.769106]

use crate::{HashMap, HashSet};
replacement in libpijul/src/diff/vertex_buffer.rs at line 69

[20.771121]→[20.771121:771162](∅→∅)

missing_eol: HashSet::new(),

[20.771121]

[20.771162]

missing_eol: HashSet::default(),
replacement in libpijul/src/diff/vertex_buffer.rs at line 76

[20.771354]→[20.771354:771390](∅→∅)

marker: HashMap::new(),

[20.771354]

[20.771390]

marker: HashMap::default(),
replacement in libpijul/src/diff/vertex_buffer.rs at line 83

[20.771601]→[20.771601:771647](∅→∅)

solved_conflicts: HashSet::new(),

[20.771601]

[20.771647]

solved_conflicts: HashSet::default(),
replacement in libpijul/src/diff/split.rs at line 1

[20.778648]→[20.778648:778679](∅→∅)

use std::collections::HashSet;

[20.778592]

[20.778679]

use crate::HashSet;
replacement in libpijul/src/diff/replace.rs at line 6

[20.780197]→[20.780197:780267](∅→∅)

use crate::record::Builder;
use std::collections::{HashMap, HashSet};

[20.780197]

[3.0]

use crate::record::Recorded;
use crate::{HashMap, HashSet};
replacement in libpijul/src/diff/replace.rs at line 19

[20.780618]→[20.780618:780766](∅→∅)

side_ends: HashMap::new(),
up: HashMap::new(),
active: HashSet::new(),
reorderings: HashMap::new(),

[20.780618]

[20.780766]

side_ends: HashMap::default(),
up: HashMap::default(),
active: HashSet::default(),
reorderings: HashMap::default(),
replacement in libpijul/src/diff/replace.rs at line 27

[3.3]→[20.780839:780854](∅→∅),[20.780839]→[20.780839:780854](∅→∅)

impl Builder {

[3.3]

[20.780854]

impl Recorded {
edit in libpijul/src/diff/replace.rs at line 42

[20.781307]

[20.781307]

let start = self.contents.lock().unwrap().len();
replacement in libpijul/src/diff/replace.rs at line 55

[20.781536]→[20.781536:781573](∅→∅)

self.rec.contents.len(),

[20.781536]

[20.781573]

start,
replacement in libpijul/src/diff/replace.rs at line 61

[20.142]→[20.781585:781630](∅→∅),[20.781585]→[20.781585:781630](∅→∅)

let start = self.rec.contents.len();

[20.142]

[20.781630]

let mut contents = self.contents.lock().unwrap();
replacement in libpijul/src/diff/replace.rs at line 63

[20.781690]→[20.781690:781736](∅→∅)

self.rec.contents.extend(line.l);

[20.781690]

[20.781736]

contents.extend(line.l);
replacement in libpijul/src/diff/replace.rs at line 65

[20.781746]→[20.781746:781789](∅→∅)

let end = self.rec.contents.len();

[20.781746]

[20.30]

let end = contents.len();
replacement in libpijul/src/diff/replace.rs at line 69

[20.86]→[20.781789:781824](∅→∅),[20.781789]→[20.781789:781824](∅→∅)

self.rec.contents.push(0);

[20.86]

[20.0]

contents.push(0);
std::mem::drop(contents);
replacement in libpijul/src/diff/replace.rs at line 81

[20.782186]→[20.782186:782229](∅→∅)

match self.rec.actions.pop() {

[20.782186]

[20.2024]

match self.actions.pop() {
replacement in libpijul/src/diff/replace.rs at line 84

[20.52]→[20.2084:2150](∅→∅)

self.rec.actions.push(Hunk::Replacement {

[20.52]

[20.782406]

self.actions.push(Hunk::Replacement {
replacement in libpijul/src/diff/replace.rs at line 91

[20.782625]→[20.2151:2230](∅→∅)

self.rec.actions.push(Hunk::Edit { change: c, local })

[20.782625]

[20.782706]

self.actions.push(Hunk::Edit { change: c, local })
replacement in libpijul/src/diff/replace.rs at line 94

[20.782746]→[20.782746:782799](∅→∅)

Some(c) => self.rec.actions.push(c),

[20.782746]

[4.0]

Some(c) => self.actions.push(c),
replacement in libpijul/src/diff/replace.rs at line 98

[20.782847]→[20.2231:2274](∅→∅)

self.rec.actions.push(Hunk::Edit {

[20.782847]

[20.782892]

self.actions.push(Hunk::Edit {
replacement in libpijul/src/diff/mod.rs at line 4

[20.793340]→[20.793340:793368](∅→∅)

use crate::record::Builder;

[20.793340]

[20.793368]

use crate::record::Recorded;
replacement in libpijul/src/diff/mod.rs at line 49

[20.794101]→[20.794101:794116](∅→∅)

impl Builder {

[20.794101]

[20.115840]

impl Recorded {
replacement in libpijul/src/diff/mod.rs at line 61

[20.33418]→[20.794425:794500](∅→∅),[20.115955]→[20.794425:794500](∅→∅),[20.794425]→[20.794425:794500](∅→∅)

self.rec.largest_file = self.rec.largest_file.max(b.len() as u64);

[20.115955]

[20.794500]

self.largest_file = self.largest_file.max(b.len() as u64);
replacement in libpijul/src/diff/mod.rs at line 149

[20.116221]→[20.797596:797638](∅→∅),[20.797596]→[20.797596:797638](∅→∅)

self.rec.has_binary_files = true;

[20.116221]

[5.52]

self.has_binary_files = true;
replacement in libpijul/src/diff/mod.rs at line 151

[5.129]→[20.797717:797895](∅→∅),[20.2352]→[20.797717:797895](∅→∅),[20.797717]→[20.797717:797895](∅→∅)

let pos = self.rec.contents.len();
self.rec.contents.extend_from_slice(&b[..]);
let pos_end = self.rec.contents.len();
self.rec.contents.push(0);

[5.129]

[20.797895]

let mut contents = self.contents.lock().unwrap();
let pos = contents.len();
contents.extend_from_slice(&b[..]);
let pos_end = contents.len();
contents.push(0);
std::mem::drop(contents);
replacement in libpijul/src/diff/mod.rs at line 202

[20.799869]→[20.2353:2400](∅→∅)

self.rec.actions.push(Hunk::Edit {

[20.799869]

[20.799918]

self.actions.push(Hunk::Edit {
replacement in libpijul/src/diff/mod.rs at line 213

[20.800193]→[20.2401:2451](∅→∅)

self.rec.actions.push(Hunk::Replacement {

[20.800193]

[20.548]

self.actions.push(Hunk::Replacement {
replacement in libpijul/src/diff/delete.rs at line 8

[20.805674]→[20.805674:805702](∅→∅)

use crate::record::Builder;

[20.805674]

[20.805702]

use crate::record::Recorded;
replacement in libpijul/src/diff/delete.rs at line 10

[20.805703]→[20.805703:805718](∅→∅)

impl Builder {

[20.805703]

[20.116378]

impl Recorded {
replacement in libpijul/src/diff/delete.rs at line 46

[20.806700]→[20.806700:806715](∅→∅)

impl Builder {

[20.806700]

[20.116574]

impl Recorded {
replacement in libpijul/src/diff/delete.rs at line 58

[20.807024]→[20.2513:2560](∅→∅)

self.rec.actions.push(Hunk::Edit {

[20.807024]

[20.807073]

self.actions.push(Hunk::Edit {
replacement in libpijul/src/diff/delete.rs at line 70

[20.807902]→[20.2561:2620](∅→∅)

self.rec.actions.push(Hunk::ResurrectZombies {

[20.807902]

[20.807963]

self.actions.push(Hunk::ResurrectZombies {
replacement in libpijul/src/diff/delete.rs at line 208

[20.812430]→[20.812430:812445](∅→∅)

impl Builder {

[20.812430]

[20.812445]

impl Recorded {
replacement in libpijul/src/diff/delete.rs at line 227

[20.813147]→[20.813147:813182](∅→∅),[20.813182]→[20.137170:137236](∅→∅),[20.137236]→[20.813248:813283](∅→∅),[20.813248]→[20.813248:813283](∅→∅)

self.rec.contents.push(0);
let pos = ChangePosition(self.rec.contents.len().into());
self.rec.contents.push(0);

[20.813084]

[20.813346]

let mut contents = self.contents.lock().unwrap();
contents.push(0);
let pos = ChangePosition(contents.len().into());
contents.push(0);
let contents_len = contents.len();
std::mem::drop(contents);
replacement in libpijul/src/diff/delete.rs at line 249

[20.813743]→[20.813743:813784](∅→∅)

self.rec.contents.len(),

[20.813743]

[20.813784]

contents_len,
replacement in libpijul/src/diff/delete.rs at line 253

[20.813947]→[20.2621:2678](∅→∅)

self.rec.actions.push(Hunk::SolveOrderConflict {

[20.813947]

[20.814006]

self.actions.push(Hunk::SolveOrderConflict {
replacement in libpijul/src/changestore/memory.rs at line 4

[20.820864]→[20.820864:820895](∅→∅)

use std::collections::HashMap;

[20.820846]

[20.820895]

use crate::HashMap;
edit in libpijul/src/changestore/filesystem.rs at line 4

[20.824179]

[20.824179]

use std::cell::{RefCell, RefMut};
edit in libpijul/src/changestore/filesystem.rs at line 6

[20.824211]→[20.824211:824252](∅→∅)

use std::sync::{Arc, Mutex, MutexGuard};
replacement in libpijul/src/changestore/filesystem.rs at line 10

[20.824324]→[20.824324:824493](∅→∅)

#[derive(Clone)]
pub struct FileSystem(Arc<FileSystem_>);

struct FileSystem_ {
change_cache: Mutex<lru_cache::LruCache<ChangeId, Arc<Mutex<ChangeFile<'static>>>>>,

[20.824324]

[20.824493]

pub struct FileSystem {
change_cache: RefCell<lru_cache::LruCache<ChangeId, ChangeFile<'static>>>,
edit in libpijul/src/changestore/filesystem.rs at line 13

[20.824519]

[20.35133]

}

impl Clone for FileSystem {
fn clone(&self) -> Self {
FileSystem {
changes_dir: self.changes_dir.clone(),
change_cache: RefCell::new(lru_cache::LruCache::new(CHANGE_CACHE_SIZE)),
}
}
replacement in libpijul/src/changestore/filesystem.rs at line 51

[20.824914]→[20.824914:824965](∅→∅)

let mut path = self.0.changes_dir.clone();

[20.824914]

[20.824965]

let mut path = self.changes_dir.clone();
replacement in libpijul/src/changestore/filesystem.rs at line 72

[20.825724]→[20.825724:825766](∅→∅)

FileSystem(Arc::new(FileSystem_ {

[20.825724]

[20.825766]

FileSystem {
replacement in libpijul/src/changestore/filesystem.rs at line 74

[20.825791]→[20.825791:825886](∅→∅)

change_cache: Mutex::new(lru_cache::LruCache::new(CHANGE_CACHE_SIZE)),
}))

[20.825791]

[20.825886]

change_cache: RefCell::new(lru_cache::LruCache::new(CHANGE_CACHE_SIZE)),
}
replacement in libpijul/src/changestore/filesystem.rs at line 83

[20.826014]→[20.826014:826098](∅→∅)

MutexGuard<lru_cache::LruCache<ChangeId, Arc<Mutex<ChangeFile<'static>>>>>,

[20.826014]

[20.35450]

RefMut<lru_cache::LruCache<ChangeId, ChangeFile<'static>>>,
replacement in libpijul/src/changestore/filesystem.rs at line 86

[20.826129]→[20.826129:826232](∅→∅)

let mut cache = self.0.change_cache.lock().unwrap();
if !cache.contains_key(&change) {

[20.826129]

[20.826232]

let mut change_cache = self.change_cache.borrow_mut();
if !change_cache.contains_key(&change) {
edit in libpijul/src/changestore/filesystem.rs at line 90

[20.826317]

[20.826317]

debug!("changefile: {:?}", path);
replacement in libpijul/src/changestore/filesystem.rs at line 92

[20.826399]→[20.826399:826458](∅→∅)

cache.insert(change, Arc::new(Mutex::new(p)));

[20.826399]

[20.826458]

debug!("patch done");
change_cache.insert(change, p);
replacement in libpijul/src/changestore/filesystem.rs at line 95

[20.826468]→[20.826468:826486](∅→∅)

Ok(cache)

[20.826468]

[20.826486]

Ok(change_cache)
replacement in libpijul/src/changestore/filesystem.rs at line 115

[20.35653]→[20.826928:827003](∅→∅),[20.826928]→[20.826928:827003](∅→∅)

let mut f = tempfile::NamedTempFile::new_in(&self.0.changes_dir)?;

[20.35653]

[20.827003]

let mut f = tempfile::NamedTempFile::new_in(&self.changes_dir)?;
replacement in libpijul/src/changestore/filesystem.rs at line 123

[20.827293]→[20.827293:827395](∅→∅)

let mut cache = self.0.change_cache.lock().unwrap();
cache.remove(change_id);

[20.827293]

[20.827395]

self.change_cache.borrow_mut().remove(change_id);
replacement in libpijul/src/changestore/filesystem.rs at line 133

[20.827590]→[20.827590:827996](∅→∅)

let mut cache = self.0.change_cache.lock().unwrap();
let mut poisoned = false;
if let Some(c) = cache.get_mut(change_id) {
if let Ok(l) = c.lock() {
return l.has_contents();
} else {
poisoned = true
}
}
if poisoned {
cache.remove(change_id);

[20.827590]

[20.827996]

if let Some(l) = self.change_cache.borrow_mut().get_mut(change_id) {
return l.has_contents();
edit in libpijul/src/changestore/filesystem.rs at line 157

[20.35792]

[20.137809]

debug!("get_contents {:?}", key);
edit in libpijul/src/changestore/filesystem.rs at line 160

[20.828761]

[20.828761]

debug!("return 0");
edit in libpijul/src/changestore/filesystem.rs at line 165

[20.828904]→[20.828904:828943](∅→∅)

let mut p = p.lock().unwrap();
edit in libpijul/src/changestore/filesystem.rs at line 166

[20.137921]

[20.828995]

debug!("get_contents {:?}", n);
edit in libpijul/src/changestore/filesystem.rs at line 195

[20.829911]→[20.829911:829946](∅→∅)

let p = p.lock().unwrap();
replacement in libpijul/src/changestore/filesystem.rs at line 204

[20.35944]→[20.830227:830302](∅→∅),[20.830227]→[20.830227:830302](∅→∅)

let mut f = tempfile::NamedTempFile::new_in(&self.0.changes_dir)?;

[20.35944]

[20.830302]

let mut f = tempfile::NamedTempFile::new_in(&self.changes_dir)?;
edit in libpijul/src/change.rs at line 2

[20.831409]

[20.831409]

use crate::HashSet;
replacement in libpijul/src/change.rs at line 4

[17.1226]→[20.831438:831481](∅→∅),[20.831438]→[20.831438:831481](∅→∅)

use std::collections::{BTreeSet, HashSet};

[20.831438]

[20.831519]

use std::collections::BTreeSet;
replacement in libpijul/src/change.rs at line 11

[20.36136]→[20.2514:2553](∅→∅)

pub use text_changes::WriteChangeLine;

[20.36136]

[20.36136]

pub use text_changes::{TextDeError, TextSerError, WriteChangeLine};
replacement in libpijul/src/change.rs at line 269

[20.837958]→[20.837958:837994](∅→∅)

let channel = channel.borrow();

[20.837958]

[20.138351]

let channel = channel.read().unwrap();
replacement in libpijul/src/change.rs at line 362

[20.840488]→[20.840488:840533](∅→∅)

let mut internal_deps_ = HashSet::new();

[20.840488]

[20.840533]

let mut internal_deps_ = HashSet::default();
replacement in libpijul/src/change.rs at line 378

[20.841017]→[20.841017:841055](∅→∅)

let mut visited = HashSet::new();

[20.841017]

[20.841055]

let mut visited = HashSet::default();
replacement in libpijul/src/change.rs at line 1175

[20.122645]→[20.122645:122742](∅→∅)

let (dependencies, extra_known) = dependencies(txn, &channel.borrow(), changes.iter())?;

[20.122645]

[20.867489]

let (dependencies, extra_known) =
dependencies(txn, &channel.read().unwrap(), changes.iter())?;
edit in libpijul/src/change/text_changes.rs at line 4

[20.38019]

[20.38019]

use crate::HashMap;
edit in libpijul/src/change/text_changes.rs at line 6

[20.38058]→[20.38058:38089](∅→∅)

use std::collections::HashMap;
replacement in libpijul/src/change/text_changes.rs at line 112

[20.41386]→[20.41386:41427](∅→∅)

let mut hashes = HashMap::new();

[20.41386]

[20.41427]

let mut hashes = HashMap::default();
replacement in libpijul/src/change/text_changes.rs at line 172

[20.122944]→[20.122944:123033](∅→∅)

dependencies(txn, &channel.borrow(), change.hashed.changes.iter()).unwrap();

[20.122944]

[20.43278]

dependencies(txn, &channel.read().unwrap(), change.hashed.changes.iter()).unwrap();
replacement in libpijul/src/change/text_changes.rs at line 241

[20.45638]→[20.45638:45730](∅→∅)

let mut deps = HashMap::new();
let mut extra_dependencies = HashSet::new();

[20.45638]

[20.45730]

let mut deps = HashMap::default();
let mut extra_dependencies = HashSet::default();
replacement in libpijul/src/change/text_changes.rs at line 254

[20.46248]→[20.46248:46297](∅→∅)

offsets: HashMap::new(),

[20.46248]

[20.46297]

offsets: HashMap::default(),
replacement in libpijul/src/change/text_changes.rs at line 536

[20.56748]→[20.56748:56785](∅→∅)

mut contents_: &mut Vec<u8>,

[20.56748]

[20.56785]

contents_: &mut Vec<u8>,
replacement in libpijul/src/change/text_changes.rs at line 545

[20.57069]→[12.156:286](∅→∅)

Regex::new(r#"^(?P<n>\d+)\. File addition: "(?P<name>[^"]*)" in "(?P<parent>[^"]*)"(?P<perm> [^ ]+)?"#).unwrap();

[20.57069]

[20.57195]

Regex::new(r#"^(?P<n>\d+)\. File addition: "(?P<name>[^"]*)" in "(?P<parent>[^"]*)"(?P<perm> \S+)?"#).unwrap();
edit in libpijul/src/change/text_changes.rs at line 589

[20.59406]

[20.2608]

debug!("cap = {:?}", cap);
replacement in libpijul/src/change/text_changes.rs at line 602

[20.59651]→[20.59651:59700](∅→∅)

meta.write(&mut contents_).unwrap();

[20.59651]

[20.59700]

contents_.push((meta.0 >> 8) as u8);
contents_.push((meta.0 & 0xff) as u8);
replacement in libpijul/src/change/text_changes.rs at line 739

[20.64590]→[20.64590:64639](∅→∅)

meta.write(&mut contents_).unwrap();

[20.64590]

[20.64639]

contents_.push((meta.0 >> 8) as u8);
contents_.push((meta.0 & 0xff) as u8);
replacement in libpijul/src/apply.rs at line 2

[20.944165]→[20.17202:17266](∅→∅)

use crate::change::{Atom, Change, EdgeMap, NewEdge, NewVertex};

[20.944165]

[20.944220]

use crate::change::{Atom, Change, EdgeMap, NewVertex};
replacement in libpijul/src/apply.rs at line 7

[20.944362]→[20.944362:944404](∅→∅)

use std::collections::{HashMap, HashSet};

[20.944344]

[20.93395]

use crate::{HashMap, HashSet};
edit in libpijul/src/apply.rs at line 9

[20.93417]

[20.93417]

mod edge;
pub(crate) use edge::*;
mod vertex;
pub(crate) use vertex::*;
replacement in libpijul/src/apply.rs at line 94

[20.944998]→[20.944998:945044](∅→∅)

let mut channel = channel.r.borrow_mut();

[20.944998]

[20.94700]

let mut channel = channel.write().unwrap();
replacement in libpijul/src/apply.rs at line 137

[20.946218]→[20.946218:946264](∅→∅)

let mut channel = channel.r.borrow_mut();

[20.946218]

[20.946264]

let mut channel = channel.write().unwrap();
replacement in libpijul/src/apply.rs at line 140

[20.143642]→[20.64:102](∅→∅),[20.946321]→[20.64:102](∅→∅)

let mut visited = HashSet::new();

[20.143642]

[20.946321]

let mut visited = HashSet::default();
edit in libpijul/src/apply.rs at line 252

[20.126099]

[20.17435]

|h| change.knows(h),
edit in libpijul/src/apply.rs at line 274

[20.126451]

[20.126451]

|h| change.knows(h),
edit in libpijul/src/apply.rs at line 276

[20.126479]→[20.1126:1231](∅→∅),[20.1126]→[20.1126:1231](∅→∅),[20.1231]→[20.65148:65199](∅→∅),[20.65199]→[20.1268:1481](∅→∅),[20.126528]→[20.1268:1481](∅→∅),[20.1268]→[20.1268:1481](∅→∅),[20.1481]→[20.95915:96006](∅→∅)

crate::missing_context::collect_zombie_context(
txn,
T::graph_mut(channel),
&mut ws.missing_context,
n.inode,
edge,
change_id,
|h| change.knows(&h),
)
.map_err(LocalApplyError::from_missing)?
replacement in libpijul/src/apply.rs at line 303

[20.952507]→[20.952507:952540](∅→∅)

channel: &mut ChannelRef<T>,

[20.952507]

[20.952540]

channel: &ChannelRef<T>,
replacement in libpijul/src/apply.rs at line 309

[20.96241]→[20.952760:952806](∅→∅),[20.126984]→[20.952760:952806](∅→∅),[20.952760]→[20.952760:952806](∅→∅)

let mut channel = channel.r.borrow_mut();

[20.126984]

[20.144106]

let mut channel = channel.write().unwrap();
replacement in libpijul/src/apply.rs at line 341

[20.953497]→[20.953497:953530](∅→∅)

channel: &mut ChannelRef<T>,

[20.953497]

[20.953530]

channel: &ChannelRef<T>,
edit in libpijul/src/apply.rs at line 387

[20.3590]→[20.955450:955493](∅→∅),[20.96840]→[20.955450:955493](∅→∅),[20.128119]→[20.955450:955493](∅→∅),[20.144970]→[20.955450:955493](∅→∅),[20.955450]→[20.955450:955493](∅→∅),[20.955493]→[20.3591:3592](∅→∅),[20.3592]→[20.128120:128155](∅→∅),[20.128155]→[20.955578:955595](∅→∅),[20.955578]→[20.955578:955595](∅→∅),[20.955595]→[20.128156:128182](∅→∅),[20.128182]→[20.955625:955721](∅→∅),[20.955625]→[20.955625:955721](∅→∅),[20.955721]→[20.128183:128233](∅→∅),[20.96886]→[20.955754:955847](∅→∅),[20.128233]→[20.955754:955847](∅→∅),[20.955754]→[20.955754:955847](∅→∅),[20.955847]→[20.207:266](∅→∅),[20.266]→[20.21:194](∅→∅),[20.194]→[20.447:448](∅→∅),[20.447]→[20.447:448](∅→∅),[20.448]→[20.955847:956052](∅→∅),[20.955847]→[20.955847:956052](∅→∅),[20.956052]→[20.67441:67490](∅→∅),[20.67490]→[20.128234:128381](∅→∅),[20.128381]→[20.17747:17757](∅→∅),[20.17747]→[20.17747:17757](∅→∅),[20.17757]→[20.956160:956206](∅→∅),[20.956160]→[20.956160:956206](∅→∅),[20.956206]→[20.67491:67544](∅→∅),[20.67544]→[20.17758:17793](∅→∅),[20.17793]→[20.128382:128438](∅→∅),[20.128438]→[20.17849:17859](∅→∅),[20.17849]→[20.17849:17859](∅→∅),[20.17859]→[20.128439:128591](∅→∅),[20.128591]→[20.18012:18022](∅→∅),[20.18012]→[20.18012:18022](∅→∅),[20.18022]→[20.956322:956376](∅→∅),[20.956322]→[20.956322:956376](∅→∅),[20.956376]→[20.18023:18089](∅→∅),[20.18089]→[20.956376:956497](∅→∅),[20.956376]→[20.956376:956497](∅→∅),[20.956497]→[20.18090:18139](∅→∅),[20.18139]→[20.128592:128671](∅→∅)

}
}
}
Ok(())
}

fn put_newvertex<T: GraphMutTxnT>(
txn: &mut T,
graph: &mut T::Graph,
ch: &Change,
ws: &mut Workspace,
change: ChangeId,
n: &NewVertex<Option<Hash>>,
) -> Result<(), LocalApplyError<T::GraphError>> {
let vertex = Vertex {
change,
start: n.start,
end: n.end,
};
if txn.find_block_end(graph, vertex.end_pos()).is_ok()
|| txn.find_block(graph, vertex.start_pos()).is_ok()
{
error!("Invalid change: {:?}", vertex);
return Err(LocalApplyError::InvalidChange);
}

debug!(
"put_newvertex {:?} {:?} {:?} {:?} {:?}",
vertex, n.up_context, n.down_context, n.flag, change
);
assert!(ws.deleted_by.is_empty());
for up in n.up_context.iter() {
let up = internal_pos(txn, up, change)?;
if put_up_context(txn, graph, ch, ws, up)? && n.flag.contains(EdgeFlags::FOLDER) {
return Err(LocalApplyError::InvalidChange);
}
}
for down in n.down_context.iter() {
let down = internal_pos(txn, down, change)?;
if down.change == change {
return Err(LocalApplyError::InvalidChange);
}
if put_down_context(txn, graph, ch, ws, down)? && !n.flag.contains(EdgeFlags::FOLDER) {
return Err(LocalApplyError::InvalidChange);
}
}
debug!("deleted by: {:?}", ws.deleted_by);

let up_flag = n.flag | EdgeFlags::BLOCK | EdgeFlags::DELETED;
for up in ws.up_context.drain(..) {
assert_ne!(up, vertex);
if !n.flag.contains(EdgeFlags::FOLDER) {
for change in ws.deleted_by.iter() {
put_graph_with_rev(txn, graph, up_flag, up, vertex, *change)?;
edit in libpijul/src/apply.rs at line 389

[20.956727]→[20.128672:128760](∅→∅)

put_graph_with_rev(txn, graph, n.flag | EdgeFlags::BLOCK, up, vertex, change)?;
edit in libpijul/src/apply.rs at line 390

[20.956822]→[20.956822:956872](∅→∅),[20.956872]→[20.18353:18458](∅→∅),[20.18458]→[20.67775:67819](∅→∅),[20.956872]→[20.67775:67819](∅→∅),[20.67819]→[20.956932:956966](∅→∅),[20.956932]→[20.956932:956966](∅→∅),[20.956966]→[20.128761:128835](∅→∅),[20.128835]→[20.18534:18617](∅→∅),[20.97176]→[20.18534:18617](∅→∅),[20.18617]→[20.957497:957540](∅→∅),[20.68283]→[20.957497:957540](∅→∅),[20.97236]→[20.957497:957540](∅→∅),[20.957497]→[20.957497:957540](∅→∅)

debug!("down_context {:?}", ws.down_context);
let mut down_flag = n.flag;
if !n.flag.is_folder() {
down_flag -= EdgeFlags::BLOCK
}
for down in ws.down_context.drain(..) {
assert_ne!(down, vertex);
put_graph_with_rev(txn, graph, down_flag, vertex, down, change)?;
if n.flag.is_folder() {
ws.missing_context.files.insert(down);
}
}
ws.deleted_by.clear();
edit in libpijul/src/apply.rs at line 391

[20.957551]→[20.957551:957553](∅→∅),[20.957553]→[20.1047:1048](∅→∅),[20.1048]→[20.128836:128872](∅→∅),[20.128872]→[20.957639:957656](∅→∅),[20.957639]→[20.957639:957656](∅→∅),[20.957656]→[20.128873:128899](∅→∅),[20.128899]→[20.957686:957703](∅→∅),[20.957686]→[20.957686:957703](∅→∅),[20.957738]→[20.957738:957790](∅→∅),[20.957790]→[20.128900:128952](∅→∅),[20.18665]→[20.957823:957945](∅→∅),[20.97282]→[20.957823:957945](∅→∅),[20.128952]→[20.957823:957945](∅→∅),[20.957823]→[20.957823:957945](∅→∅),[20.957945]→[20.144971:145020](∅→∅),[20.65645]→[20.957995:958151](∅→∅),[20.68335]→[20.957995:958151](∅→∅),[20.129002]→[20.957995:958151](∅→∅),[20.145020]→[20.957995:958151](∅→∅),[20.957995]→[20.957995:958151](∅→∅),[20.958151]→[20.18666:18835](∅→∅),[20.18835]→[20.145021:145085](∅→∅),[20.65709]→[20.958502:958670](∅→∅),[20.68386]→[20.958502:958670](∅→∅),[20.97363]→[20.958502:958670](∅→∅),[20.129067]→[20.958502:958670](∅→∅),[20.145085]→[20.958502:958670](∅→∅),[20.958502]→[20.958502:958670](∅→∅),[20.958670]→[20.68387:68505](∅→∅),[20.68505]→[20.18836:18871](∅→∅),[20.18871]→[20.129068:129170](∅→∅),[20.129170]→[20.21769:21884](∅→∅),[20.18973]→[20.68579:68597](∅→∅),[20.21884]→[20.68579:68597](∅→∅),[20.145189]→[20.68579:68597](∅→∅),[20.68579]→[20.68579:68597](∅→∅),[20.68597]→[20.145190:145210](∅→∅),[20.145210]→[20.68615:68706](∅→∅),[20.68615]→[20.68615:68706](∅→∅),[20.68706]→[20.145211:145303](∅→∅),[20.129253]→[20.68849:68892](∅→∅),[20.145303]→[20.68849:68892](∅→∅),[20.68849]→[20.68849:68892](∅→∅),[20.68892]→[20.145304:145366](∅→∅),[20.19034]→[20.69008:69022](∅→∅),[20.145366]→[20.69008:69022](∅→∅),[20.69008]→[20.69008:69022](∅→∅),[20.69262]→[20.959143:959194](∅→∅),[20.959143]→[20.959143:959194](∅→∅),[20.959194]→[20.19035:19057](∅→∅),[20.19057]→[20.959205:959207](∅→∅),[20.959205]→[20.959205:959207](∅→∅),[20.959207]→[20.1049:1050](∅→∅),[20.1050]→[20.129254:129292](∅→∅),[20.129292]→[20.959295:959312](∅→∅),[20.959295]→[20.959295:959312](∅→∅),[20.959312]→[20.129293:129319](∅→∅),[20.129319]→[20.959342:959359](∅→∅),[20.959342]→[20.959342:959359](∅→∅),[20.959394]→[20.959394:959448](∅→∅),[20.959448]→[20.129320:129372](∅→∅),[20.129372]→[20.145367:145411](∅→∅),[20.65753]→[20.959540:959659](∅→∅),[20.69309]→[20.959540:959659](∅→∅),[20.129416]→[20.959540:959659](∅→∅),[20.145411]→[20.959540:959659](∅→∅),[20.959540]→[20.959540:959659](∅→∅),[20.959659]→[20.19106:19263](∅→∅),[20.19263]→[20.145412:145474](∅→∅),[20.65815]→[20.960115:960275](∅→∅),[20.69358]→[20.960115:960275](∅→∅),[20.97502]→[20.960115:960275](∅→∅),[20.129479]→[20.960115:960275](∅→∅),[20.145474]→[20.960115:960275](∅→∅),[20.960115]→[20.960115:960275](∅→∅),[20.960275]→[20.69359:69360](∅→∅),[20.69360]→[20.960275:960393](∅→∅),[20.960275]→[20.960275:960393](∅→∅),[20.960393]→[20.19264:19295](∅→∅),[20.19295]→[20.129480:129585](∅→∅),[20.129585]→[20.21885:21995](∅→∅),[20.21995]→[20.145559:145789](∅→∅),[20.145559]→[20.145559:145789](∅→∅),[20.129672]→[20.960764:960811](∅→∅),[20.145789]→[20.960764:960811](∅→∅),[20.960764]→[20.960764:960811](∅→∅),[20.960811]→[20.145790:145856](∅→∅),[20.19443]→[20.960935:960953](∅→∅),[20.145856]→[20.960935:960953](∅→∅),[20.960935]→[20.960935:960953](∅→∅),[20.69573]→[20.961010:961040](∅→∅),[20.961010]→[20.961010:961040](∅→∅),[20.961040]→[20.69574:69613](∅→∅),[20.69613]→[20.19444:19462](∅→∅)

}

fn put_up_context<T: GraphMutTxnT>(
txn: &mut T,
graph: &mut T::Graph,
ch: &Change,
ws: &mut Workspace,
up: Position<ChangeId>,
) -> Result<bool, LocalApplyError<T::GraphError>> {
let up_vertex = if up.change.is_root() {
Vertex::ROOT
} else {
debug!("put_up_context {:?}", up);
let k = *txn.find_block_end(graph, up)?;
assert_eq!(k.change, up.change);
assert!(k.start <= up.pos);
debug!("k = {:?}", k);
if k.start < up.pos && k.end > up.pos {
// The missing context "graphs" are only used at the
// DELETION stage, check that:
assert!(ws.missing_context.graphs.0.is_empty());
txn.split_block(graph, &k, up.pos, &mut ws.adjbuf)?
}
Vertex {
change: k.change,
start: k.start,
end: up.pos,
}
};
debug!("up_vertex {:?}", up_vertex);
let flag0 = EdgeFlags::PARENT | EdgeFlags::BLOCK;
let flag1 = flag0 | EdgeFlags::DELETED | EdgeFlags::FOLDER;
let mut is_non_folder = false;
for parent in iter_adjacent(txn, graph, up_vertex, flag0, flag1)? {
let parent = parent?;
is_non_folder |=
parent.flag() & (EdgeFlags::PARENT | EdgeFlags::FOLDER) == EdgeFlags::PARENT;
if parent
.flag()
.contains(EdgeFlags::PARENT | EdgeFlags::DELETED | EdgeFlags::BLOCK)
{
let introduced_by = txn.get_external(&parent.introduced_by())?.unwrap().into();
if !ch.knows(&introduced_by) {
ws.deleted_by.insert(parent.introduced_by());
}
}
}
ws.up_context.push(up_vertex);
Ok(is_non_folder)
}

fn put_down_context<T: GraphMutTxnT>(
txn: &mut T,
graph: &mut T::Graph,
ch: &Change,
ws: &mut Workspace,
down: Position<ChangeId>,
) -> Result<bool, LocalApplyError<T::GraphError>> {
let k = *txn.find_block(&graph, down)?;
assert_eq!(k.change, down.change);
assert!(k.end >= down.pos);
if k.start < down.pos && k.end > down.pos {
// The missing context "graphs" are only used at the
// DELETION stage, check that:
assert!(ws.missing_context.graphs.0.is_empty());
txn.split_block(graph, &k, down.pos, &mut ws.adjbuf)?
}
let down_vertex = Vertex {
change: k.change,
start: down.pos,
end: k.end,
};
debug!("down_vertex {:?}", down_vertex);

let flag0 = EdgeFlags::PARENT;
let flag1 = flag0 | EdgeFlags::FOLDER | EdgeFlags::BLOCK | EdgeFlags::DELETED;
let mut is_folder = false;
for parent in iter_adjacent(txn, &graph, down_vertex, flag0, flag1)? {
let parent = parent?;
is_folder |= parent
.flag()
.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER);
if parent.flag().contains(EdgeFlags::PARENT | EdgeFlags::BLOCK) {
if parent.flag().contains(EdgeFlags::DELETED) {
let introduced_by = txn.get_external(&parent.introduced_by())?.unwrap().into();
if !ch.knows(&introduced_by) {
ws.deleted_by.insert(parent.introduced_by());
}
}
}
}
ws.down_context.push(down_vertex);
Ok(is_folder)
edit in libpijul/src/apply.rs at line 434

[20.97504]→[20.97504:97540](∅→∅),[20.355]→[20.962794:962811](∅→∅),[20.97540]→[20.962794:962811](∅→∅),[20.962794]→[20.962794:962811](∅→∅),[20.962811]→[20.129810:129836](∅→∅),[20.129836]→[20.962841:962973](∅→∅),[20.962841]→[20.962841:962973](∅→∅),[20.962973]→[20.97541:97560](∅→∅),[20.97560]→[20.963004:963010](∅→∅),[20.963004]→[20.963004:963010](∅→∅),[20.963010]→[20.129837:130022](∅→∅),[20.97692]→[20.963317:963319](∅→∅),[20.130022]→[20.963317:963319](∅→∅),[20.963317]→[20.963317:963319](∅→∅),[20.963319]→[20.19499:19547](∅→∅),[20.19547]→[20.963319:963364](∅→∅),[20.963319]→[20.963319:963364](∅→∅),[20.963364]→[20.97693:97720](∅→∅),[20.97720]→[20.130023:130125](∅→∅),[20.97825]→[20.963425:963431](∅→∅),[20.130125]→[20.963425:963431](∅→∅),[20.963425]→[20.963425:963431](∅→∅),[20.963431]→[20.350:403](∅→∅),[20.403]→[20.19600:19664](∅→∅),[20.19600]→[20.19600:19664](∅→∅),[20.19664]→[20.130126:130185](∅→∅),[20.130185]→[20.19722:19728](∅→∅),[20.19722]→[20.19722:19728](∅→∅),[20.19728]→[20.963431:963432](∅→∅),[20.963431]→[20.963431:963432](∅→∅),[20.963432]→[20.19729:19814](∅→∅),[20.19814]→[20.130186:130272](∅→∅),[20.69741]→[20.963637:963660](∅→∅),[20.130272]→[20.963637:963660](∅→∅),[20.963637]→[20.963637:963660](∅→∅),[20.963660]→[20.130273:130332](∅→∅),[20.19873]→[20.963721:963729](∅→∅),[20.97953]→[20.963721:963729](∅→∅),[20.130332]→[20.963721:963729](∅→∅),[20.963721]→[20.963721:963729](∅→∅),[20.963729]→[20.130333:130511](∅→∅),[20.130511]→[20.963911:963912](∅→∅),[20.963911]→[20.963911:963912](∅→∅),[20.963912]→[20.19874:19974](∅→∅),[20.19974]→[20.963912:964016](∅→∅),[20.963912]→[20.963912:964016](∅→∅),[20.964016]→[20.19975:20045](∅→∅),[20.20045]→[20.145969:146041](∅→∅),[20.475]→[20.964696:964790](∅→∅),[20.69800]→[20.964696:964790](∅→∅),[20.98042]→[20.964696:964790](∅→∅),[20.130632]→[20.964696:964790](∅→∅),[20.146041]→[20.964696:964790](∅→∅),[20.964696]→[20.964696:964790](∅→∅),[20.964790]→[20.1333:1434](∅→∅),[20.1434]→[20.476:542](∅→∅),[20.964790]→[20.476:542](∅→∅),[20.542]→[20.964858:964911](∅→∅),[20.130730]→[20.964858:964911](∅→∅),[20.964858]→[20.964858:964911](∅→∅),[20.964911]→[20.130731:130803](∅→∅),[20.130803]→[20.964985:965032](∅→∅),[20.964985]→[20.964985:965032](∅→∅),[20.965032]→[20.20046:20078](∅→∅),[20.20078]→[20.965032:965043](∅→∅),[20.965032]→[20.965032:965043](∅→∅),[20.965043]→[20.130804:131021](∅→∅),[20.69979]→[20.965876:965923](∅→∅),[20.98311]→[20.965876:965923](∅→∅),[20.131021]→[20.965876:965923](∅→∅),[20.965876]→[20.965876:965923](∅→∅),[20.965923]→[20.20166:20265](∅→∅),[20.20265]→[20.965969:966024](∅→∅),[20.965969]→[20.965969:966024](∅→∅),[20.966024]→[20.146042:146064](∅→∅),[20.146064]→[20.65907:66002](∅→∅),[20.65907]→[20.65907:66002](∅→∅),[20.66002]→[20.966085:966141](∅→∅),[20.70042]→[20.966085:966141](∅→∅),[20.98406]→[20.966085:966141](∅→∅),[20.131113]→[20.966085:966141](∅→∅),[20.966085]→[20.966085:966141](∅→∅),[20.966141]→[20.131114:131154](∅→∅),[20.131154]→[20.966231:966248](∅→∅),[20.966231]→[20.966231:966248](∅→∅),[20.966248]→[20.131155:131183](∅→∅),[20.131183]→[20.966278:966415](∅→∅),[20.966278]→[20.966278:966415](∅→∅),[20.966415]→[20.131184:131248](∅→∅),[20.98466]→[20.966462:966496](∅→∅),[20.131248]→[20.966462:966496](∅→∅),[20.966462]→[20.966462:966496](∅→∅),[20.966496]→[20.146065:146153](∅→∅),[20.66090]→[20.966582:966729](∅→∅),[20.70131]→[20.966582:966729](∅→∅),[20.146153]→[20.966582:966729](∅→∅),[20.966582]→[20.966582:966729](∅→∅),[20.966729]→[20.20266:20332](∅→∅),[20.20332]→[20.146154:146224](∅→∅),[20.66160]→[20.967333:967388](∅→∅),[20.70186]→[20.967333:967388](∅→∅),[20.98551]→[20.967333:967388](∅→∅),[20.131319]→[20.967333:967388](∅→∅),[20.146224]→[20.967333:967388](∅→∅),[20.967333]→[20.967333:967388](∅→∅),[20.967388]→[20.131320:131360](∅→∅),[20.131360]→[20.967423:967440](∅→∅),[20.967423]→[20.967423:967440](∅→∅),[20.967440]→[20.131361:131389](∅→∅),[20.131389]→[20.967470:967603](∅→∅),[20.967470]→[20.967470:967603](∅→∅),[20.967603]→[20.131390:131454](∅→∅),[20.98611]→[20.70187:70249](∅→∅),[20.131454]→[20.70187:70249](∅→∅),[20.967650]→[20.70187:70249](∅→∅),[20.70249]→[20.20333:20382](∅→∅),[20.20382]→[20.146225:146281](∅→∅),[20.66216]→[20.967800:967922](∅→∅),[20.70306]→[20.967800:967922](∅→∅),[20.146281]→[20.967800:967922](∅→∅),[20.967800]→[20.967800:967922](∅→∅),[20.967922]→[20.20383:20449](∅→∅),[20.20449]→[20.146282:146352](∅→∅),[20.66286]→[20.968526:968582](∅→∅),[20.70361]→[20.968526:968582](∅→∅),[20.98696]→[20.968526:968582](∅→∅),[20.131525]→[20.968526:968582](∅→∅),[20.146352]→[20.968526:968582](∅→∅),[20.968526]→[20.968526:968582](∅→∅),[20.968582]→[20.1053:1054](∅→∅),[20.1054]→[20.131526:131568](∅→∅),[20.131568]→[20.968674:968691](∅→∅),[20.968674]→[20.968674:968691](∅→∅),[20.968691]→[20.131569:131597](∅→∅),[20.131597]→[20.968721:968808](∅→∅),[20.968721]→[20.968721:968808](∅→∅),[20.968808]→[20.131598:131648](∅→∅),[20.98742]→[20.70362:70403](∅→∅),[20.131648]→[20.70362:70403](∅→∅),[20.968841]→[20.70362:70403](∅→∅),[20.70403]→[20.968873:968977](∅→∅),[20.968873]→[20.968873:968977](∅→∅),[20.968977]→[20.131649:131678](∅→∅),[20.131678]→[20.968985:969041](∅→∅),[20.968985]→[20.968985:969041](∅→∅),[20.969041]→[20.146353:146522](∅→∅),[20.66349]→[20.131679:131727](∅→∅),[20.146522]→[20.131679:131727](∅→∅),[20.70467]→[20.131679:131727](∅→∅),[20.131727]→[20.146523:146569](∅→∅),[20.146569]→[20.969295:969334](∅→∅),[20.969295]→[20.969295:969334](∅→∅),[20.969334]→[20.146570:146685](∅→∅),[20.146685]→[20.53:165](∅→∅),[20.53]→[20.53:165](∅→∅),[20.165]→[20.146686:146733](∅→∅),[20.146733]→[20.66549:66567](∅→∅),[20.66549]→[20.66549:66567](∅→∅),[20.66567]→[20.969434:969458](∅→∅),[20.969434]→[20.969434:969458](∅→∅),[20.969458]→[20.146734:146831](∅→∅),[20.146831]→[20.969552:969581](∅→∅),[20.969552]→[20.969552:969581](∅→∅),[20.969581]→[20.1055:1056](∅→∅),[20.1056]→[20.131728:131772](∅→∅),[20.131772]→[20.969675:969692](∅→∅),[20.969675]→[20.969675:969692](∅→∅),[20.969692]→[20.131773:131801](∅→∅),[20.131801]→[20.969722:969811](∅→∅),[20.969722]→[20.969722:969811](∅→∅),[20.969811]→[20.131802:131852](∅→∅),[20.131852]→[20.20450:20507](∅→∅),[20.98788]→[20.20450:20507](∅→∅),[20.20507]→[20.970152:970181](∅→∅),[20.970152]→[20.970152:970181](∅→∅),[20.970181]→[20.20508:20509](∅→∅),[20.20509]→[20.131853:132022](∅→∅),[20.20572]→[20.970270:970271](∅→∅),[20.132022]→[20.970270:970271](∅→∅),[20.970270]→[20.970270:970271](∅→∅),[20.970443]→[20.970443:970806](∅→∅),[20.970906]→[20.970906:970907](∅→∅),[20.970907]→[20.20573:20607](∅→∅),[20.20607]→[20.146832:146892](∅→∅),[20.132082]→[20.20657:20720](∅→∅),[20.146892]→[20.20657:20720](∅→∅),[20.20657]→[20.20657:20720](∅→∅),[20.20720]→[20.146893:146961](∅→∅),[20.233]→[20.132150:132242](∅→∅),[20.146961]→[20.132150:132242](∅→∅),[20.132150]→[20.132150:132242](∅→∅),[20.70752]→[20.971153:971196](∅→∅),[20.98986]→[20.971153:971196](∅→∅),[20.132242]→[20.971153:971196](∅→∅),[20.971153]→[20.971153:971196](∅→∅),[20.971196]→[20.1057:1058](∅→∅)

pub(crate) fn put_newedge<T, E, F>(
txn: &mut T,
graph: &mut T::Graph,
ws: &mut Workspace,
change: ChangeId,
inode: Position<Option<Hash>>,
n: &NewEdge<Option<Hash>>,
apply_check: F,
) -> Result<(), E>
where
T: GraphMutTxnT,
E: From<LocalApplyError<T::GraphError>> + From<TxnErr<T::GraphError>>,
F: Fn(&mut T, &mut T::Graph, Vertex<ChangeId>, Vertex<ChangeId>) -> Result<bool, E>,
{
debug!("put_newedge {:?} {:?}", n, change);
if n.flag.contains(EdgeFlags::DELETED) {
ws.missing_context
.load_graph(txn, graph, inode)
.map_err(|_| LocalApplyError::InvalidChange)?;
}
if (n.previous.is_block() && !n.flag.is_block())
|| (n.previous.is_folder() != n.flag.is_folder())
{
return Err(LocalApplyError::InvalidChange.into());
}

debug_assert!(ws.children.is_empty());
debug_assert!(ws.parents.is_empty());
let n_introduced_by = if let Some(n) = internal(txn, &n.introduced_by, change)? {
n
} else {
return Err(LocalApplyError::InvalidChange.into());
};

let mut source = find_source_vertex(txn, graph, &n.from, change, inode, n.flag, ws)?;
let mut target = find_target_vertex(txn, graph, &n.to, change, inode, n.flag, ws)?;

if n.flag.contains(EdgeFlags::FOLDER) {
ws.missing_context.files.insert(target);
}

loop {
if target.end > n.to.end {
assert!(!n.flag.contains(EdgeFlags::FOLDER));
ws.missing_context.graphs.split(inode, target, n.to.end);
txn.split_block(graph, &target, n.to.end, &mut ws.adjbuf)?;
target.end = n.to.end
}

if n.flag.contains(EdgeFlags::DELETED) {
debug_assert!(ws.children.is_empty());
debug_assert!(ws.parents.is_empty());
collect_pseudo_edges(txn, graph, ws, inode, target)?;
if !n.flag.contains(EdgeFlags::FOLDER) {
reconnect_pseudo_edges(txn, graph, inode, ws, target)?;
}
ws.children.clear();
ws.parents.clear();
}

del_graph_with_rev(txn, graph, n.previous, source, target, n_introduced_by)?;
if apply_check(txn, graph, source, target)? {
put_graph_with_rev(txn, graph, n.flag, source, target, change)?;
}

if target.end >= n.to.end {
debug!("{:?} {:?}", target, n.to);
debug_assert_eq!(target.end, n.to.end);
break;
}

source = target;
target = *txn
.find_block(graph, target.end_pos())
.map_err(LocalApplyError::from)?;
assert_ne!(source, target);
}
Ok(())
}

fn find_source_vertex<T: GraphMutTxnT>(
txn: &mut T,
channel: &mut T::Graph,
from: &Position<Option<Hash>>,
change: ChangeId,
inode: Position<Option<Hash>>,
flag: EdgeFlags,
ws: &mut Workspace,
) -> Result<Vertex<ChangeId>, LocalApplyError<T::GraphError>> {
debug!("find_source_vertex");
let mut source = *txn.find_block_end(&channel, internal_pos(txn, &from, change)?)?;
debug!("source = {:?}", source);
if source.start < from.pos && source.end > from.pos {
assert!(!flag.contains(EdgeFlags::FOLDER));
ws.missing_context.graphs.split(inode, source, from.pos);
txn.split_block(channel, &source, from.pos, &mut ws.adjbuf)?;
source.end = from.pos;
}
Ok(source)
}

fn find_target_vertex<T: GraphMutTxnT>(
txn: &mut T,
channel: &mut T::Graph,
to: &Vertex<Option<Hash>>,
change: ChangeId,
inode: Position<Option<Hash>>,
flag: EdgeFlags,
ws: &mut Workspace,
) -> Result<Vertex<ChangeId>, LocalApplyError<T::GraphError>> {
let to_pos = internal_pos(txn, &to.start_pos(), change)?;
debug!("find_target_vertex, to = {:?}", to);
let mut target = *txn.find_block(channel, to_pos)?;
debug!("target = {:?}", target);
if target.start < to.start {
assert!(!flag.contains(EdgeFlags::FOLDER));
ws.missing_context.graphs.split(inode, target, to.start);
txn.split_block(channel, &target, to.start, &mut ws.adjbuf)?;
target.start = to.start;
}
Ok(target)
}

fn collect_pseudo_edges<T: GraphMutTxnT>(
txn: &mut T,
channel: &mut T::Graph,
apply: &mut Workspace,
inode: Position<Option<Hash>>,
v: Vertex<ChangeId>,
) -> Result<(), LocalApplyError<T::GraphError>> {
for e in iter_adjacent(
txn,
&channel,
v,
EdgeFlags::empty(),
EdgeFlags::all() - EdgeFlags::DELETED,
)? {
let e = e?;
debug!("collect_pseudo_edges {:?} {:?}", v, e);
if !e.flag().contains(EdgeFlags::FOLDER) {
if e.flag().contains(EdgeFlags::PARENT) {
let p = txn.find_block_end(channel, e.dest())?;
if is_alive(txn, channel, p)? {
apply.parents.insert(*p);
}
} else {
let p = txn.find_block(channel, e.dest())?;
if e.flag().contains(EdgeFlags::BLOCK)
|| p.is_empty()
|| is_alive(txn, channel, p).unwrap()
{
apply.children.insert(*p);
}
}
}
if e.flag().contains(EdgeFlags::PSEUDO) {
apply.pseudo.push((v, *e, inode));
}
}
Ok(())
}

fn reconnect_pseudo_edges<T: GraphMutTxnT>(
txn: &mut T,
channel: &mut T::Graph,
inode: Position<Option<Hash>>,
ws: &mut Workspace,
target: Vertex<ChangeId>,
) -> Result<(), LocalApplyError<T::GraphError>> {
if ws.parents.is_empty() || ws.children.is_empty() {
return Ok(());
}

let (graph, vids) = if let Some(x) = ws.missing_context.graphs.get(inode) {
x
} else {
return Err(LocalApplyError::InvalidChange.into());
};

crate::alive::remove_redundant_parents(
&graph,
&vids,
&mut ws.parents,
&mut ws.missing_context.covered_parents,
target,
);
for &p in ws.parents.iter() {
ws.missing_context.covered_parents.insert((p, target));
}

crate::alive::remove_redundant_children(&graph, &vids, &mut ws.children, target);

for &p in ws.parents.iter() {
debug_assert!(is_alive(txn, channel, &p).unwrap());
for &c in ws.children.iter() {
if p != c {
debug_assert!(is_alive(txn, channel, &c).unwrap());
put_graph_with_rev(txn, channel, EdgeFlags::PSEUDO, p, c, ChangeId::ROOT)?;
}
}
}
Ok(())
}
replacement in libpijul/src/apply.rs at line 638

[20.978857]→[20.25138:25224](∅→∅)

let mut files = std::mem::replace(&mut ws.missing_context.files, HashSet::new());

[20.978857]

[20.25224]

let mut files = std::mem::replace(&mut ws.missing_context.files, HashSet::default());
file addition: apply (d--r------)

[20.198146]
file addition: vertex.rs (----------)

[0.90446]

use super::{LocalApplyError, Workspace};
use crate::change::{Change, NewVertex};
use crate::pristine::*;
use crate::{ChangeId, EdgeFlags, Hash, Vertex};

pub fn put_newvertex<T: GraphMutTxnT>(
txn: &mut T,
graph: &mut T::Graph,
ch: &Change,
ws: &mut Workspace,
change: ChangeId,
n: &NewVertex<Option<Hash>>,
) -> Result<(), LocalApplyError<T::GraphError>> {
let vertex = Vertex {
change,
start: n.start,
end: n.end,
};
if txn.find_block_end(graph, vertex.end_pos()).is_ok()
|| txn.find_block(graph, vertex.start_pos()).is_ok()
{
error!("Invalid change: {:?}", vertex);
return Err(LocalApplyError::InvalidChange);
}
debug!(
"put_newvertex {:?} {:?} {:?} {:?} {:?}",
vertex, n.up_context, n.down_context, n.flag, change
);
assert!(ws.deleted_by.is_empty());
for up in n.up_context.iter() {
let up = internal_pos(txn, up, change)?;
if put_up_context(txn, graph, ch, ws, up)? && n.flag.contains(EdgeFlags::FOLDER) {
return Err(LocalApplyError::InvalidChange);
}
}
for down in n.down_context.iter() {
let down = internal_pos(txn, down, change)?;
if down.change == change {
return Err(LocalApplyError::InvalidChange);
}
if put_down_context(txn, graph, ch, ws, down)? && !n.flag.contains(EdgeFlags::FOLDER) {
return Err(LocalApplyError::InvalidChange);
}
}
debug!("deleted by: {:?}", ws.deleted_by);

let up_flag = n.flag | EdgeFlags::BLOCK | EdgeFlags::DELETED;
for up in ws.up_context.drain(..) {
assert_ne!(up, vertex);
if !n.flag.contains(EdgeFlags::FOLDER) {
for change in ws.deleted_by.iter() {
put_graph_with_rev(txn, graph, up_flag, up, vertex, *change)?;
}
}
put_graph_with_rev(txn, graph, n.flag | EdgeFlags::BLOCK, up, vertex, change)?;
}
debug!("down_context {:?}", ws.down_context);
let mut down_flag = n.flag;
if !n.flag.is_folder() {
down_flag -= EdgeFlags::BLOCK
}
for down in ws.down_context.drain(..) {
assert_ne!(down, vertex);
put_graph_with_rev(txn, graph, down_flag, vertex, down, change)?;
if n.flag.is_folder() {
ws.missing_context.files.insert(down);
}
}
ws.deleted_by.clear();
Ok(())
}

fn put_up_context<T: GraphMutTxnT>(
txn: &mut T,
graph: &mut T::Graph,
ch: &Change,
ws: &mut Workspace,
up: Position<ChangeId>,
) -> Result<bool, LocalApplyError<T::GraphError>> {
let up_vertex = if up.change.is_root() {
Vertex::ROOT
} else {
debug!("put_up_context {:?}", up);
let k = *txn.find_block_end(graph, up)?;
assert_eq!(k.change, up.change);
assert!(k.start <= up.pos);
debug!("k = {:?}", k);
if k.start < up.pos && k.end > up.pos {
// The missing context "graphs" are only used at the
// DELETION stage, check that:
assert!(ws.missing_context.graphs.0.is_empty());
txn.split_block(graph, &k, up.pos, &mut ws.adjbuf)?
}
Vertex {
change: k.change,
start: k.start,
end: up.pos,
}
};
debug!("up_vertex {:?}", up_vertex);
let flag0 = EdgeFlags::PARENT | EdgeFlags::BLOCK;
let flag1 = flag0 | EdgeFlags::DELETED | EdgeFlags::FOLDER;
let mut is_non_folder = false;
for parent in iter_adjacent(txn, graph, up_vertex, flag0, flag1)? {
let parent = parent?;
is_non_folder |=
parent.flag() & (EdgeFlags::PARENT | EdgeFlags::FOLDER) == EdgeFlags::PARENT;
if parent
.flag()
.contains(EdgeFlags::PARENT | EdgeFlags::DELETED | EdgeFlags::BLOCK)
{
let introduced_by = txn.get_external(&parent.introduced_by())?.unwrap().into();
if !ch.knows(&introduced_by) {
ws.deleted_by.insert(parent.introduced_by());
}
}
}
ws.up_context.push(up_vertex);
Ok(is_non_folder)
}

fn put_down_context<T: GraphMutTxnT>(
txn: &mut T,
graph: &mut T::Graph,
ch: &Change,
ws: &mut Workspace,
down: Position<ChangeId>,
) -> Result<bool, LocalApplyError<T::GraphError>> {
let k = *txn.find_block(&graph, down)?;
assert_eq!(k.change, down.change);
assert!(k.end >= down.pos);
if k.start < down.pos && k.end > down.pos {
// The missing context "graphs" are only used at the
// DELETION stage, check that:
assert!(ws.missing_context.graphs.0.is_empty());
txn.split_block(graph, &k, down.pos, &mut ws.adjbuf)?
}
let down_vertex = Vertex {
change: k.change,
start: down.pos,
end: k.end,
};
debug!("down_vertex {:?}", down_vertex);

let flag0 = EdgeFlags::PARENT;
let flag1 = flag0 | EdgeFlags::FOLDER | EdgeFlags::BLOCK | EdgeFlags::DELETED;
let mut is_folder = false;
for parent in iter_adjacent(txn, &graph, down_vertex, flag0, flag1)? {
let parent = parent?;
is_folder |= parent
.flag()
.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER);
if parent.flag().contains(EdgeFlags::PARENT | EdgeFlags::BLOCK) {
if parent.flag().contains(EdgeFlags::DELETED) {
let introduced_by = txn.get_external(&parent.introduced_by())?.unwrap().into();
if !ch.knows(&introduced_by) {
ws.deleted_by.insert(parent.introduced_by());
}
}
}
}
ws.down_context.push(down_vertex);
Ok(is_folder)
}
file addition: edge.rs (----------)

[0.90446]

use super::LocalApplyError;
use crate::change::NewEdge;
use crate::missing_context::*;
use crate::pristine::*;

pub fn put_newedge<T, E, F, K>(
txn: &mut T,
graph: &mut T::Graph,
ws: &mut super::Workspace,
change: ChangeId,
inode: Position<Option<Hash>>,
n: &NewEdge<Option<Hash>>,
apply_check: F,
mut known: K,
) -> Result<(), E>
where
T: GraphMutTxnT,
E: From<LocalApplyError<T::GraphError>> + From<TxnErr<T::GraphError>>,
F: Fn(&mut T, &mut T::Graph, Vertex<ChangeId>, Vertex<ChangeId>) -> Result<bool, E>,
K: FnMut(&Hash) -> bool,
{
debug!("put_newedge {:?} {:?}", n, change);
check_valid(txn, graph, inode, n, ws)?;
let n_introduced_by = if let Some(n) = internal(txn, &n.introduced_by, change)? {
n
} else {
return Err(LocalApplyError::InvalidChange.into());
};

let mut source = find_source_vertex(txn, graph, &n.from, change, inode, n.flag, ws)?;
let mut target = find_target_vertex(txn, graph, &n.to, change, inode, n.flag, ws)?;

if n.flag.contains(EdgeFlags::FOLDER) {
ws.missing_context.files.insert(target);
}

let mut zombies = Vec::new();

loop {
if !n.flag.contains(EdgeFlags::DELETED) {
collect_nondeleted_zombies::<_, E, _>(
txn,
graph,
&mut known,
source,
target,
&mut zombies,
)?;
}
if target.end > n.to.end {
assert!(!n.flag.contains(EdgeFlags::FOLDER));
ws.missing_context.graphs.split(inode, target, n.to.end);
txn.split_block(graph, &target, n.to.end, &mut ws.adjbuf)?;
target.end = n.to.end
}

if n.flag.contains(EdgeFlags::DELETED) {
debug_assert!(ws.children.is_empty());
debug_assert!(ws.parents.is_empty());
collect_pseudo_edges(txn, graph, ws, inode, target)?;
if !n.flag.contains(EdgeFlags::FOLDER) {
reconnect_pseudo_edges(txn, graph, inode, ws, target)?;
}
ws.children.clear();
ws.parents.clear();
}

del_graph_with_rev(txn, graph, n.previous, source, target, n_introduced_by)?;
if apply_check(txn, graph, source, target)? {
put_graph_with_rev(txn, graph, n.flag, source, target, change)?;
for intro in zombies.drain(..) {
put_graph_with_rev(txn, graph, EdgeFlags::DELETED, source, target, intro)?;
}
}

if target.end >= n.to.end {
debug!("{:?} {:?}", target, n.to);
debug_assert_eq!(target.end, n.to.end);
break;
}

source = target;
target = *txn
.find_block(graph, target.end_pos())
.map_err(LocalApplyError::from)?;
assert_ne!(source, target);
}
if n.flag.contains(EdgeFlags::DELETED) {
collect_zombie_context(txn, graph, &mut ws.missing_context, inode, n, change, known)
.map_err(LocalApplyError::from_missing)?;
}
Ok(())
}

fn collect_nondeleted_zombies<T, E, K>(
txn: &mut T,
graph: &mut T::Graph,
mut known: K,
source: Vertex<ChangeId>,
target: Vertex<ChangeId>,
zombies: &mut Vec<ChangeId>,
) -> Result<(), E>
where
T: GraphMutTxnT,
E: From<LocalApplyError<T::GraphError>> + From<TxnErr<T::GraphError>>,
K: FnMut(&Hash) -> bool,
{
for v in iter_deleted_parents(txn, graph, source)? {
let v = v?;
let intro = v.introduced_by();
if !known(&txn.get_external(&intro)?.unwrap().into()) {
zombies.push(intro)
}
}
for v in iter_adjacent(txn, graph, target, EdgeFlags::empty(), EdgeFlags::all())? {
let v = v?;
if v.flag().contains(EdgeFlags::PARENT) {
continue;
}
for v in iter_deleted_parents(txn, graph, target)? {
let v = v?;
let intro = v.introduced_by();
if !known(&txn.get_external(&intro)?.unwrap().into()) {
zombies.push(intro)
}
}
}
Ok(())
}

fn check_valid<T: GraphMutTxnT>(
txn: &mut T,
graph: &mut T::Graph,
inode: Position<Option<Hash>>,
n: &NewEdge<Option<Hash>>,
ws: &mut super::Workspace,
) -> Result<(), LocalApplyError<T::GraphError>> {
if n.flag.contains(EdgeFlags::DELETED) {
ws.missing_context
.load_graph(txn, graph, inode)
.map_err(|_| LocalApplyError::InvalidChange)?;
}
if (n.previous.is_block() && !n.flag.is_block())
|| (n.previous.is_folder() != n.flag.is_folder())
{
return Err(LocalApplyError::InvalidChange.into());
}

debug_assert!(ws.children.is_empty());
debug_assert!(ws.parents.is_empty());
Ok(())
}

fn find_source_vertex<T: GraphMutTxnT>(
txn: &mut T,
channel: &mut T::Graph,
from: &Position<Option<Hash>>,
change: ChangeId,
inode: Position<Option<Hash>>,
flag: EdgeFlags,
ws: &mut super::Workspace,
) -> Result<Vertex<ChangeId>, LocalApplyError<T::GraphError>> {
debug!("find_source_vertex");
let mut source = *txn.find_block_end(&channel, internal_pos(txn, &from, change)?)?;
debug!("source = {:?}", source);
if source.start < from.pos && source.end > from.pos {
assert!(!flag.contains(EdgeFlags::FOLDER));
ws.missing_context.graphs.split(inode, source, from.pos);
txn.split_block(channel, &source, from.pos, &mut ws.adjbuf)?;
source.end = from.pos;
}
Ok(source)
}

fn find_target_vertex<T: GraphMutTxnT>(
txn: &mut T,
channel: &mut T::Graph,
to: &Vertex<Option<Hash>>,
change: ChangeId,
inode: Position<Option<Hash>>,
flag: EdgeFlags,
ws: &mut super::Workspace,
) -> Result<Vertex<ChangeId>, LocalApplyError<T::GraphError>> {
let to_pos = internal_pos(txn, &to.start_pos(), change)?;
debug!("find_target_vertex, to = {:?}", to);
let mut target = *txn.find_block(channel, to_pos)?;
debug!("target = {:?}", target);
if target.start < to.start {
assert!(!flag.contains(EdgeFlags::FOLDER));
ws.missing_context.graphs.split(inode, target, to.start);
txn.split_block(channel, &target, to.start, &mut ws.adjbuf)?;
target.start = to.start;
}
Ok(target)
}

fn collect_pseudo_edges<T: GraphMutTxnT>(
txn: &mut T,
channel: &mut T::Graph,
apply: &mut super::Workspace,
inode: Position<Option<Hash>>,
v: Vertex<ChangeId>,
) -> Result<(), LocalApplyError<T::GraphError>> {
for e in iter_adjacent(
txn,
&channel,
v,
EdgeFlags::empty(),
EdgeFlags::all() - EdgeFlags::DELETED,
)? {
let e = e?;
debug!("collect_pseudo_edges {:?} {:?}", v, e);
if !e.flag().contains(EdgeFlags::FOLDER) {
if e.flag().contains(EdgeFlags::PARENT) {
let p = txn.find_block_end(channel, e.dest())?;
if is_alive(txn, channel, p)? {
apply.parents.insert(*p);
}
} else {
let p = txn.find_block(channel, e.dest())?;
if e.flag().contains(EdgeFlags::BLOCK)
|| p.is_empty()
|| is_alive(txn, channel, p).unwrap()
{
apply.children.insert(*p);
}
}
}
if e.flag().contains(EdgeFlags::PSEUDO) {
apply.pseudo.push((v, *e, inode));
}
}
Ok(())
}

fn reconnect_pseudo_edges<T: GraphMutTxnT>(
txn: &mut T,
channel: &mut T::Graph,
inode: Position<Option<Hash>>,
ws: &mut super::Workspace,
target: Vertex<ChangeId>,
) -> Result<(), LocalApplyError<T::GraphError>> {
if ws.parents.is_empty() || ws.children.is_empty() {
return Ok(());
}

let (graph, vids) = if let Some(x) = ws.missing_context.graphs.get(inode) {
x
} else {
return Err(LocalApplyError::InvalidChange.into());
};

crate::alive::remove_redundant_parents(
&graph,
&vids,
&mut ws.parents,
&mut ws.missing_context.covered_parents,
target,
);
for &p in ws.parents.iter() {
ws.missing_context.covered_parents.insert((p, target));
}

crate::alive::remove_redundant_children(&graph, &vids, &mut ws.children, target);

for &p in ws.parents.iter() {
debug_assert!(is_alive(txn, channel, &p).unwrap());
for &c in ws.children.iter() {
if p != c {
debug_assert!(is_alive(txn, channel, &c).unwrap());
put_graph_with_rev(txn, channel, EdgeFlags::PSEUDO, p, c, ChangeId::ROOT)?;
}
}
}
Ok(())
}
fn collect_zombie_context<T: GraphMutTxnT, K>(
txn: &mut T,
channel: &mut T::Graph,
ws: &mut crate::missing_context::Workspace,
inode: Position<Option<Hash>>,
n: &NewEdge<Option<Hash>>,
change_id: ChangeId,
mut known: K,
) -> Result<(), MissingError<T::GraphError>>
where
K: FnMut(&Hash) -> bool,
{
if n.flag.contains(EdgeFlags::FOLDER) {
return Ok(());
}
let mut pos = internal_pos(txn, &n.to.start_pos(), change_id)?;
let end_pos = internal_pos(txn, &n.to.end_pos(), change_id)?;
let mut unknown_parents = Vec::new();
while let Ok(&dest_vertex) = txn.find_block(&channel, pos) {
debug!("collect zombie context: {:?}", dest_vertex);
for v in iter_adjacent(
txn,
channel,
dest_vertex,
EdgeFlags::empty(),
EdgeFlags::all() - EdgeFlags::DELETED,
)? {
let v = v?;
if v.introduced_by() == change_id || v.dest().change.is_root() {
continue;
}
if v.introduced_by().is_root() {
ws.pseudo.push((dest_vertex, *v));
continue;
}
if v.flag().contains(EdgeFlags::PARENT) {
// Unwrap ok, since `v` is in the channel.
let intro = txn.get_external(&v.introduced_by())?.unwrap().into();
if !known(&intro) {
debug!("unknown: {:?}", v);
unknown_parents.push((dest_vertex, *v))
}
}
}
zombify(txn, channel, ws, change_id, inode, n.flag, &unknown_parents)?;
if dest_vertex.end < end_pos.pos {
pos.pos = dest_vertex.end
} else {
break;
}
}
Ok(())
}

fn zombify<T: GraphMutTxnT>(
txn: &mut T,
channel: &mut T::Graph,
ws: &mut crate::missing_context::Workspace,
change_id: ChangeId,
inode: Position<Option<Hash>>,
flag: EdgeFlags,
unknown: &[(Vertex<ChangeId>, SerializedEdge)],
) -> Result<(), MissingError<T::GraphError>> {
for &(dest_vertex, edge) in unknown.iter() {
let p = *txn.find_block_end(channel, edge.dest())?;
ws.unknown_parents
.push((dest_vertex, p, inode, edge.flag()));
let fold = flag & EdgeFlags::FOLDER;
debug!("zombify p {:?}, dest_vertex {:?}", p, dest_vertex);
let mut v = p;
while let Ok(&u) = txn.find_block_end(channel, v.start_pos()) {
if u != v {
debug!("u = {:?}, v = {:?}", u, v);
put_graph_with_rev(
txn,
channel,
EdgeFlags::DELETED | EdgeFlags::BLOCK | fold,
u,
v,
change_id,
)?;
v = u
} else {
break;
}
}
// Zombify the first chunk of the split.
for parent in iter_adjacent(
txn,
channel,
v,
EdgeFlags::PARENT,
EdgeFlags::all() - EdgeFlags::DELETED,
)? {
let parent = parent?;
if !parent.flag().contains(EdgeFlags::PSEUDO) {
ws.parents.insert(*parent);
}
}
debug!("ws.parents = {:?}", ws.parents);
for parent in ws.parents.drain() {
let parent_dest = *txn.find_block_end(channel, parent.dest())?;
let mut flag = EdgeFlags::DELETED | EdgeFlags::BLOCK;
if parent.flag().contains(EdgeFlags::FOLDER) {
flag |= EdgeFlags::FOLDER
}
put_graph_with_rev(txn, channel, flag, parent_dest, v, change_id)?;
}
}
Ok(())
}
edit in libpijul/src/alive/retrieve.rs at line 3

[20.984712]

[20.984712]

use crate::HashMap;
edit in libpijul/src/alive/retrieve.rs at line 5

[20.984751]→[20.984751:984782](∅→∅)

use std::collections::HashMap;
replacement in libpijul/src/alive/retrieve.rs at line 17

[20.985151]→[20.985151:985226](∅→∅)

let mut cache: HashMap<Position<ChangeId>, VertexId> = HashMap::new();

[20.985092]

[20.985226]

let mut cache: HashMap<Position<ChangeId>, VertexId> = HashMap::default();
edit in libpijul/src/alive/mod.rs at line 2

[20.149335]

[20.995267]

use crate::{HashMap, HashSet};
edit in libpijul/src/alive/mod.rs at line 87

[20.997255]→[20.100952:100953](∅→∅),[20.100953]→[20.997310:997352](∅→∅),[20.997310]→[20.997310:997352](∅→∅)

use std::collections::{HashMap, HashSet};
replacement in libpijul/src/alive/mod.rs at line 110

[20.997975]→[20.997975:998013](∅→∅)

let mut visited = HashSet::new();

[20.997975]

[20.998013]

let mut visited = HashSet::default();
replacement in libpijul/src/alive/mod.rs at line 151

[20.999288]→[20.999288:999326](∅→∅)

let mut visited = HashSet::new();

[20.999288]

[20.999326]

let mut visited = HashSet::default();
replacement in libpijul/src/alive/dfs.rs at line 4

[20.1000568]→[20.1000568:1000599](∅→∅)

use std::collections::HashSet;

[20.1000568]

[20.100954]

use crate::HashSet;
replacement in libpijul/src/alive/dfs.rs at line 23

[20.1000970]→[20.1000970:1001004](∅→∅)

sccs: HashSet::new(),

[20.1000970]

[20.1001004]

sccs: HashSet::default(),
replacement in libpijul/src/alive/dfs.rs at line 147

[20.1004207]→[20.1004207:1004299](∅→∅)

let mut forward_scc = HashSet::new();
let mut regular_scc = HashSet::new();

[20.1004207]

[20.1004299]

let mut forward_scc = HashSet::default();
let mut regular_scc = HashSet::default();
replacement in libpijul/src/alive/dfs.rs at line 333

[20.1012295]→[20.1012295:1012331](∅→∅)

let mut sccs0 = HashSet::new();

[20.1012236]

[20.1012331]

let mut sccs0 = HashSet::default();
replacement in libpijul/src/alive/debug.rs at line 4

[20.137907]→[20.1014700:1014742](∅→∅),[20.1014700]→[20.1014700:1014742](∅→∅)

use std::collections::{HashMap, HashSet};

[20.137907]

[20.1014742]

use crate::{HashMap, HashSet};
replacement in libpijul/src/alive/debug.rs at line 21

[20.1015187]→[20.1015187:1015227](∅→∅)

let mut cache = HashMap::new();

[20.1015187]

[20.1015227]

let mut cache = HashMap::default();
replacement in libpijul/src/alive/debug.rs at line 33

[20.1015559]→[20.1015559:1015600](∅→∅)

let mut others = HashSet::new();

[20.1015559]

[20.1015600]

let mut others = HashSet::default();
edit in libpijul/Cargo.toml at line 113

[20.1023338]

[20.675]

twox-hash = "*"
crossbeam-deque = "*"
crossbeam-utils = "*"
edit in libpijul/Cargo.toml at line 128

[20.1023704]

[20.1023704]
edit in Cargo.nix at line 781

[20.31074]

[20.76365]

};
"crossbeam-deque" = rec {
crateName = "crossbeam-deque";
version = "0.8.0";
edition = "2018";
sha256 = "1ad995vzq74k7jd1pgn9zxbacyzj9ii6l0svhlb2dxzy8vxnxbwl";
authors = [
"The Crossbeam Project Developers"
];
dependencies = [
{
name = "cfg-if";
packageId = "cfg-if 1.0.0";
}
{
name = "crossbeam-epoch";
packageId = "crossbeam-epoch";
optional = true;
usesDefaultFeatures = false;
}
{
name = "crossbeam-utils";
packageId = "crossbeam-utils";
optional = true;
usesDefaultFeatures = false;
}
];
features = {
"default" = [ "std" ];
"std" = [ "crossbeam-epoch/std" "crossbeam-utils/std" ];
};
resolvedDefaultFeatures = [ "crossbeam-epoch" "crossbeam-utils" "default" "std" ];
};
"crossbeam-epoch" = rec {
crateName = "crossbeam-epoch";
version = "0.9.3";
edition = "2018";
sha256 = "04jbrwrm6ibmd83anc3difsvk0fgjyr1aqs9k33sizlmxcwzd115";
authors = [
"The Crossbeam Project Developers"
];
dependencies = [
{
name = "cfg-if";
packageId = "cfg-if 1.0.0";
}
{
name = "crossbeam-utils";
packageId = "crossbeam-utils";
usesDefaultFeatures = false;
}
{
name = "lazy_static";
packageId = "lazy_static";
optional = true;
}
{
name = "memoffset";
packageId = "memoffset";
}
{
name = "scopeguard";
packageId = "scopeguard";
usesDefaultFeatures = false;
}
];
features = {
"default" = [ "std" ];
"loom" = [ "loom-crate" "crossbeam-utils/loom" ];
"nightly" = [ "crossbeam-utils/nightly" "const_fn" ];
"std" = [ "alloc" "crossbeam-utils/std" "lazy_static" ];
};
resolvedDefaultFeatures = [ "alloc" "lazy_static" "std" ];
edit in Cargo.nix at line 2674

[20.85537]

[20.85537]

}
{
name = "crossbeam-deque";
packageId = "crossbeam-deque";
}
{
name = "crossbeam-utils";
packageId = "crossbeam-utils";
replacement in Cargo.nix at line 2725

[20.86519]→[20.2511:2543](∅→∅)

packageId = "rand";

[20.86519]

[20.86551]

packageId = "rand 0.8.3";
edit in Cargo.nix at line 2770

[20.87495]

[20.87495]

name = "twox-hash";
packageId = "twox-hash";
}
{
edit in Cargo.nix at line 3042

[20.4090]

[20.95019]

};
"memoffset" = rec {
crateName = "memoffset";
version = "0.6.1";
edition = "2015";
sha256 = "11yxgw330cf8g4wy0fnb20ag8gg1b33fsnfmg2g8z6h5wc444yqm";
authors = [
"Gilad Naaman <gilad.naaman@gmail.com>"
];
buildDependencies = [
{
name = "autocfg";
packageId = "autocfg";
}
];
features = {
};
resolvedDefaultFeatures = [ "default" ];
replacement in Cargo.nix at line 3753

[20.116677]→[20.2918:2950](∅→∅)

packageId = "rand";

[20.116677]

[20.116709]

packageId = "rand 0.8.3";
replacement in Cargo.nix at line 4073

[20.128398]→[20.3391:3412](∅→∅)

"rand" = rec {

[20.128398]

[20.3618]

"rand 0.7.3" = rec {
crateName = "rand";
version = "0.7.3";
edition = "2018";
sha256 = "00sdaimkbz491qgi6qxkv582yivl32m2jd401kzbn94vsiwicsva";
authors = [
"The Rand Project Developers"
"The Rust Project Developers"
];
dependencies = [
{
name = "getrandom";
packageId = "getrandom 0.1.16";
rename = "getrandom_package";
optional = true;
}
{
name = "libc";
packageId = "libc";
optional = true;
usesDefaultFeatures = false;
target = { target, features }: (target."unix" or false);
}
{
name = "rand_chacha";
packageId = "rand_chacha 0.2.2";
usesDefaultFeatures = false;
target = { target, features }: (!(target."os" == "emscripten"));
}
{
name = "rand_core";
packageId = "rand_core 0.5.1";
}
{
name = "rand_hc";
packageId = "rand_hc 0.2.0";
target = { target, features }: (target."os" == "emscripten");
}
];
devDependencies = [
{
name = "rand_hc";
packageId = "rand_hc 0.2.0";
}
];
features = {
"alloc" = [ "rand_core/alloc" ];
"default" = [ "std" ];
"getrandom" = [ "getrandom_package" "rand_core/getrandom" ];
"nightly" = [ "simd_support" ];
"simd_support" = [ "packed_simd" ];
"small_rng" = [ "rand_pcg" ];
"std" = [ "rand_core/std" "rand_chacha/std" "alloc" "getrandom" "libc" ];
"stdweb" = [ "getrandom_package/stdweb" ];
"wasm-bindgen" = [ "getrandom_package/wasm-bindgen" ];
};
resolvedDefaultFeatures = [ "alloc" "default" "getrandom" "getrandom_package" "libc" "std" ];
};
"rand 0.8.3" = rec {
replacement in Cargo.nix at line 4150

[20.4165]→[20.3515:3554](∅→∅)

packageId = "rand_chacha";

[20.4165]

[20.4210]

packageId = "rand_chacha 0.3.0";
replacement in Cargo.nix at line 4161

[20.4510]→[20.3555:3590](∅→∅)

packageId = "rand_hc";

[20.4510]

[20.4551]

packageId = "rand_hc 0.3.0";
replacement in Cargo.nix at line 4169

[20.4747]→[20.3591:3626](∅→∅)

packageId = "rand_hc";

[20.4747]

[20.4788]

packageId = "rand_hc 0.3.0";
replacement in Cargo.nix at line 4183

[20.5320]→[20.3627:3655](∅→∅)

"rand_chacha" = rec {

[20.5320]

[20.128426]

"rand_chacha 0.2.2" = rec {
edit in Cargo.nix at line 4185

[20.128461]

[20.5468]

version = "0.2.2";
edition = "2018";
sha256 = "00il36fkdbsmpr99p9ksmmp6dn1md7rmnwmz0rr77jbrca2yvj7l";
authors = [
"The Rand Project Developers"
"The Rust Project Developers"
"The CryptoCorrosion Contributors"
];
dependencies = [
{
name = "ppv-lite86";
packageId = "ppv-lite86";
usesDefaultFeatures = false;
features = [ "simd" ];
}
{
name = "rand_core";
packageId = "rand_core 0.5.1";
}
];
features = {
"default" = [ "std" "simd" ];
"std" = [ "ppv-lite86/std" ];
};
resolvedDefaultFeatures = [ "std" ];
};
"rand_chacha 0.3.0" = rec {
crateName = "rand_chacha";
replacement in Cargo.nix at line 4283

[20.129862]→[20.3656:3680](∅→∅)

"rand_hc" = rec {

[20.129862]

[20.129886]

"rand_hc 0.2.0" = rec {
crateName = "rand_hc";
version = "0.2.0";
edition = "2018";
sha256 = "0g31sqwpmsirdlwr0svnacr4dbqyz339im4ssl9738cjgfpjjcfa";
authors = [
"The Rand Project Developers"
];
dependencies = [
{
name = "rand_core";
packageId = "rand_core 0.5.1";
}
];

};
"rand_hc 0.3.0" = rec {
replacement in Cargo.nix at line 4766

[20.144463]→[18.818:845](∅→∅)

version = "1.1.7";

[20.144463]

[20.144491]

version = "1.2.0";
replacement in Cargo.nix at line 4768

[20.144517]→[18.846:919](∅→∅)

sha256 = "1v73b74y36jyqjab2qmycchbqkkg4flwybzwij2v7lazc77qfbgi";

[20.144517]

[20.144590]

src = lib.cleanSourceWith { filter = sourceFilter; src = ../sanakirja/sanakirja; };
replacement in Cargo.nix at line 4820

[20.10521]→[20.343:370](∅→∅)

version = "1.1.1";

[20.10521]

[20.10548]

version = "1.2.3";
replacement in Cargo.nix at line 4823

[20.10597]→[20.371:444](∅→∅)

sha256 = "1i0d8kidgfrhxnv6gwbad1dn783x5y8365ki081v8l0ljd0rv6hi";

[20.10597]

[20.10670]

src = lib.cleanSourceWith { filter = sourceFilter; src = ../sanakirja/sanakirja-core; };
edit in Cargo.nix at line 5130

[20.153908]

[20.4260]

"static_assertions" = rec {
crateName = "static_assertions";
version = "1.1.0";
edition = "2015";
sha256 = "0gsl6xmw10gvn3zs1rv99laj5ig7ylffnh71f9l34js4nr4r7sx2";
authors = [
"Nikolai Vazquez"
];
features = {
};
};
replacement in Cargo.nix at line 5251

[20.157717]→[20.6224:6256](∅→∅)

packageId = "rand";

[20.157717]

[20.157749]

packageId = "rand 0.8.3";
replacement in Cargo.nix at line 5509

[20.163485]→[20.877:905](∅→∅)

version = "0.20.2";

[20.163485]

[20.163513]

version = "0.20.3";
replacement in Cargo.nix at line 5511

[20.163539]→[20.906:979](∅→∅)

sha256 = "0mny64g0b22dj663lihwkzvyvdsc69c3wcqcpbaj020rmqhsqd9j";

[20.163539]

[20.163612]

sha256 = "0582s732sdgns8dsgwpm52p26vrr8jwr14w7fmvmlzrjw8r4q89j";
edit in Cargo.nix at line 5961

[20.6823]

[20.177881]

};
"twox-hash" = rec {
crateName = "twox-hash";
version = "1.6.0";
edition = "2018";
crateBin = [];
sha256 = "0ndb4pil758kn0av83jjgq8kkfkwc5lhi5ii7fk5yw96h1wapy04";
authors = [
"Jake Goulding <jake.goulding@gmail.com>"
];
dependencies = [
{
name = "cfg-if";
packageId = "cfg-if 0.1.10";
usesDefaultFeatures = false;
}
{
name = "rand";
packageId = "rand 0.7.3";
optional = true;
}
{
name = "static_assertions";
packageId = "static_assertions";
usesDefaultFeatures = false;
}
];
features = {
"default" = [ "std" ];
"serialize" = [ "serde" ];
"std" = [ "rand" ];
};
resolvedDefaultFeatures = [ "default" "rand" "std" ];
edit in Cargo.lock at line 257

[20.1038874]

[20.1038874]

dependencies = [
"cfg-if 1.0.0",
]

[[package]]
name = "crossbeam-deque"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "94af6efb46fef72616855b036a624cf27ba656ffc9be1b9a3c931cfc7749a9a9"
edit in Cargo.lock at line 268

[20.1038908]

[164.862]

"crossbeam-epoch",
"crossbeam-utils",
edit in Cargo.lock at line 273

[164.877]

[164.877]

name = "crossbeam-epoch"
version = "0.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2584f639eb95fea8c798496315b297cf81b9b58b6d30ab066a75455333cf4b12"
dependencies = [
"cfg-if 1.0.0",
"crossbeam-utils",
"lazy_static",
"memoffset",
"scopeguard",
]

[[package]]
edit in Cargo.lock at line 933

[20.818]

[20.818]

"crossbeam-deque",
"crossbeam-utils",
replacement in Cargo.lock at line 945

[20.1055747]→[20.9113:9122](∅→∅)

"rand",

[20.1055747]

[20.1055756]

"rand 0.8.3",
edit in Cargo.lock at line 955

[20.1055861]

[20.1055861]

"twox-hash",
edit in Cargo.lock at line 1049

[20.1416]

[20.1058161]

]

[[package]]
name = "memoffset"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "157b4208e3059a8f9e78d559edc658e13df41410cb3ae03979c83130067fdd87"
dependencies = [
"autocfg",
replacement in Cargo.lock at line 1305

[20.1067]→[20.9123:9132](∅→∅)

"rand",

[20.1067]

[20.1064359]

"rand 0.8.3",
edit in Cargo.lock at line 1434

[20.1068089]

[20.156089]

version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
dependencies = [
"getrandom 0.1.16",
"libc",
"rand_chacha 0.2.2",
"rand_core 0.5.1",
"rand_hc 0.2.0",
]

[[package]]
name = "rand"
replacement in Cargo.lock at line 1452

[20.1068290]→[20.9231:9247](∅→∅)

"rand_chacha",

[20.1068290]

[20.156187]

"rand_chacha 0.3.0",
replacement in Cargo.lock at line 1454

[20.156207]→[20.9248:9260](∅→∅),[20.4511]→[20.9248:9260](∅→∅)

"rand_hc",

[20.156207]

[20.1068332]

"rand_hc 0.3.0",
]

[[package]]
name = "rand_chacha"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
dependencies = [
"ppv-lite86",
"rand_core 0.5.1",
edit in Cargo.lock at line 1497

[20.1428]

[20.1428]

version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
dependencies = [
"rand_core 0.5.1",
]

[[package]]
name = "rand_hc"
replacement in Cargo.lock at line 1655

[20.1072132]→[18.920:938](∅→∅)

version = "1.1.7"

[20.1072132]

[20.1072151]

version = "1.2.0"
replacement in Cargo.lock at line 1657

[20.1072216]→[18.939:1017](∅→∅)

checksum = "f12d87cf615fd1b3858cfc2fcfa9236f4ebc2063be62b194c45e9ae1c959e3ec"

[20.1072216]

[20.1072294]

checksum = "d822992da34989ceda221b7cc3f99381da3130c8e90f393054b0ea4e80617265"
replacement in Cargo.lock at line 1671

[20.157079]→[20.543:561](∅→∅)

version = "1.1.1"

[20.157079]

[20.157097]

version = "1.2.4"
replacement in Cargo.lock at line 1673

[20.157162]→[20.562:640](∅→∅)

checksum = "119a9d41931450b40302711633902f7da0635b686af167b6ed30bbd7e2440dc4"

[20.157162]

[20.157240]

checksum = "c15b6118bc265955b685bee694a1f04c70dfb65344411495d88e716a2cd74a3b"
edit in Cargo.lock at line 1793

[20.1075404]

[20.1075404]

name = "static_assertions"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"

[[package]]
replacement in Cargo.lock at line 1840

[20.1076514]→[20.9943:9952](∅→∅)

"rand",

[20.1076514]

[20.158160]

"rand 0.8.3",
replacement in Cargo.lock at line 1947

[20.1078612]→[20.688:707](∅→∅)

version = "0.20.2"

[20.1078612]

[20.1078631]

version = "0.20.3"
replacement in Cargo.lock at line 1949

[20.1078696]→[20.708:786](∅→∅)

checksum = "3235ac21ae190820d5ba0c333e58324cb7edf79f1c463a8c914d88051e31de56"

[20.1078696]

[20.1078774]

checksum = "32214c32e2327f5a7775879390b944396f23ae28f5f2a71bd2f6352dc6d10215"
edit in Cargo.lock at line 2103

[20.1082536]

[20.1082536]

name = "twox-hash"
version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "04f8ab788026715fa63b31960869617cba39117e520eb415b0139543e325ab59"
dependencies = [
"cfg-if 0.1.10",
"rand 0.7.3",
"static_assertions",
]

[[package]]