Diff between worktree and index

gix-features/src/parallel/in_parallel.rs

@@ -34,6 +34,76 @@ pub fn build_thread() -> std::thread::Builder {
     std::thread::Builder::new()
 }
 
+/// Read items from `input` and `consume` them in multiple threads,
+/// whose output output is collected by a `reducer`. Its task is to
+/// aggregate these outputs into the final result returned by this function with the benefit of not having to be thread-safe.
+///
+/// * if `thread_limit` is `Some`, the given amount of threads will be used. If `None`, all logical cores will be used.
+/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be based to `consume`
+/// * `consume(Item, &mut State) -> Output` produces an output given an input obtained by `input` along with mutable state initially
+///   created by `new_thread_state(…)`.
+/// * For `reducer`, see the [`Reduce`] trait
+pub fn in_parallel_chunks<'a, I, S, O, R>(
+    input: &'a mut [I],
+    chunk_size: usize,
+    thread_limit: Option<usize>,
+    new_thread_state: impl Fn(usize) -> S + Send + Clone,
+    consume: impl Fn(&'a mut I, &mut S) -> Option<O> + Send + Clone,
+    mut reducer: R,
+) -> Result<<R as Reduce>::Output, <R as Reduce>::Error>
+where
+    R: Reduce<Input = O>,
+    I: Send,
+    O: Send,
+{
+    let num_threads = num_threads(thread_limit);
+    std::thread::scope(move |s| {
+        let receive_result = {
+            let (send_input, receive_input) = crossbeam_channel::bounded::<&mut [I]>(num_threads);
+            let (send_result, receive_result) = crossbeam_channel::bounded::<O>(num_threads);
+            for thread_id in 0..num_threads {
+                std::thread::Builder::new()
+                    .name(format!("gitoxide.in_parallel.produce.{thread_id}"))
+                    .spawn_scoped(s, {
+                        let send_result = send_result.clone();
+                        let receive_input = receive_input.clone();
+                        let new_thread_state = new_thread_state.clone();
+                        let consume = consume.clone();
+                        move || {
+                            let mut state = new_thread_state(thread_id);
+                            for chunk in receive_input {
+                                for item in chunk {
+                                    if let Some(output) = consume(item, &mut state) {
+                                        if send_result.send(output).is_err() {
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    })
+                    .expect("valid name");
+            }
+            std::thread::Builder::new()
+                .name("gitoxide.in_parallel.feed".into())
+                .spawn_scoped(s, move || {
+                    for chunk in input.chunks_mut(chunk_size) {
+                        if send_input.send(chunk).is_err() {
+                            break;
+                        }
+                    }
+                })
+                .expect("valid name");
+            receive_result
+        };
+
+        for item in receive_result {
+            drop(reducer.feed(item)?);
+        }
+        reducer.finalize()
+    })
+}
+
 /// Read items from `input` and `consume` them in multiple threads,
 /// whose output output is collected by a `reducer`. Its task is to
 /// aggregate these outputs into the final result returned by this function with the benefit of not having to be thread-safe.

gix-features/src/parallel/mod.rs

@@ -35,11 +35,11 @@
 #[cfg(feature = "parallel")]
 mod in_parallel;
 #[cfg(feature = "parallel")]
-pub use in_parallel::{build_thread, in_parallel, in_parallel_with_slice, join, threads};
+pub use in_parallel::{build_thread, in_parallel, in_parallel_chunks, in_parallel_with_slice, join, threads};
 
 mod serial;
 #[cfg(not(feature = "parallel"))]
-pub use serial::{build_thread, in_parallel, in_parallel_with_slice, join, threads};
+pub use serial::{build_thread, in_parallel, in_parallel_chunks, in_parallel_with_slice, join, threads};
 
 mod in_order;
 pub use in_order::{InOrderIter, SequenceId};
@@ -128,6 +128,53 @@ pub fn num_threads(thread_limit: Option<usize>) -> usize {
         .unwrap_or(logical_cores)
 }
 
+/// Run [`in_parallel()`] only if the given `condition()` returns true when eagerly evaluated.
+///
+/// For parameters, see the documentation of [`in_parallel()`]
+#[cfg(feature = "parallel")]
+pub fn in_parallel_chunks_if<'a, I, S, O, R>(
+    condition: impl FnOnce() -> bool,
+    input: &'a mut [I],
+    chunk_size: usize,
+    thread_limit: Option<usize>,
+    new_thread_state: impl Fn(usize) -> S + Send + Clone,
+    consume: impl Fn(&'a mut I, &mut S) -> Option<O> + Send + Clone,
+    reducer: R,
+) -> Result<<R as Reduce>::Output, <R as Reduce>::Error>
+where
+    R: Reduce<Input = O>,
+    I: Send,
+    O: Send,
+{
+    if num_threads(thread_limit) > 1 && condition() {
+        in_parallel_chunks(input, chunk_size, thread_limit, new_thread_state, consume, reducer)
+    } else {
+        serial::in_parallel_chunks(input, chunk_size, thread_limit, new_thread_state, consume, reducer)
+    }
+}
+
+/// Run [`in_parallel()`] only if the given `condition()` returns true when eagerly evaluated.
+///
+/// For parameters, see the documentation of [`in_parallel()`]
+///
+/// Note that the non-parallel version is equivalent to [`in_parallel()`].
+#[cfg(not(feature = "parallel"))]
+pub fn in_parallel_chunks_if<'a, I, S, O, R>(
+    _condition: impl FnOnce() -> bool,
+    input: &'a mut [I],
+    chunk_size: usize,
+    thread_limit: Option<usize>,
+    new_thread_state: impl Fn(usize) -> S + Send + Clone,
+    consume: impl Fn(&'a mut I, &mut S) -> Option<O> + Send + Clone,
+    reducer: R,
+) -> Result<<R as Reduce>::Output, <R as Reduce>::Error>
+where
+    R: Reduce<Input = O>,
+    I: Send,
+    O: Send,
+{
+    serial::in_parallel_chunks(input, chunk_size, thread_limit, new_thread_state, consume, reducer)
+}
 /// Run [`in_parallel()`] only if the given `condition()` returns true when eagerly evaluated.
 ///
 /// For parameters, see the documentation of [`in_parallel()`]

gix-features/src/parallel/serial.rs

@@ -133,3 +133,35 @@ where
     }
     reducer.finalize()
 }
+
+/// Read items from `input` and `consume` them in a single thread, producing an output to be collected by a `reducer`,
+/// whose task is to aggregate these outputs into the final result returned by this function.
+///
+/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be based to `consume`
+/// * `consume(Item, &mut State) -> Output` produces an output given an input along with mutable state.
+/// * For `reducer`, see the [`Reduce`] trait
+/// * if `thread_limit` has no effect as everything is run on the main thread, but is present to keep the signature
+///   similar to the parallel version.
+///
+/// **This serial version performing all calculations on the current thread.**
+pub fn in_parallel_chunks<'a, I, S, O, R>(
+    input: &'a mut [I],
+    _chunk_size: usize,
+    _thread_limit: Option<usize>,
+    new_thread_state: impl Fn(usize) -> S + Send + Clone,
+    consume: impl Fn(&'a mut I, &mut S) -> Option<O> + Send + Clone,
+    mut reducer: R,
+) -> Result<<R as Reduce>::Output, <R as Reduce>::Error>
+where
+    R: Reduce<Input = O>,
+    I: Send,
+    O: Send,
+{
+    let mut state = new_thread_state(0);
+    for item in input {
+        if let Some(res) = consume(item, &mut state) {
+            drop(reducer.feed(res)?);
+        }
+    }
+    reducer.finalize()
+}

gix-hash/src/object_id.rs

@@ -127,6 +127,12 @@ impl ObjectId {
         }
     }
 
+    /// Returns true if this hash is equal to an empty blob
+    #[inline]
+    pub fn is_empty_blob(&self) -> bool {
+        self == &Self::empty_blob(self.kind())
+    }
+
     /// Returns an Digest representing a hash with whose memory is zeroed.
     #[inline]
     pub const fn null(kind: crate::Kind) -> ObjectId {

gix-index/src/access/mod.rs

@@ -1,6 +1,7 @@
 use std::cmp::Ordering;
 
 use bstr::{BStr, ByteSlice, ByteVec};
+use filetime::FileTime;
 
 use crate::{entry, extension, Entry, PathStorage, State, Version};
 
@@ -15,6 +16,20 @@ impl State {
         self.version
     }
 
+    /// Returns time at which the state was created, indicating its freshness compared to other files on disk.
+    pub fn timestamp(&self) -> FileTime {
+        self.timestamp
+    }
+
+    /// Updates the timestamp of this state, indicating its freshness compared
+    /// to other files on disk. Be careful about using this as setting a
+    /// timestamp without correctly updating the index **will cause (file
+    /// system) race conditions** see racy-git.txt (in the git documentation)
+    /// for more details.
+    pub fn set_timestamp(&mut self, timestamp: FileTime) {
+        self.timestamp = timestamp
+    }
+
     /// Return the kind of hashes used in this instance.
     pub fn object_hash(&self) -> gix_hash::Kind {
         self.object_hash

gix-index/src/decode/entries.rs

@@ -142,11 +142,11 @@ fn load_one<'a>(
     Some((
         Entry {
             stat: entry::Stat {
-                ctime: entry::Time {
+                ctime: entry::stat::Time {
                     secs: ctime_secs,
                     nsecs: ctime_nsecs,
                 },
-                mtime: entry::Time {
+                mtime: entry::stat::Time {
                     secs: mtime_secs,
                     nsecs: mtime_nsecs,
                 },

gix-index/src/decode/mod.rs

@@ -302,11 +302,11 @@ pub(crate) fn stat(data: &[u8]) -> Option<(entry::Stat, &[u8])> {
     let (size, data) = read_u32(data)?;
     Some((
         entry::Stat {
-            mtime: entry::Time {
+            mtime: entry::stat::Time {
                 secs: ctime_secs,
                 nsecs: ctime_nsecs,
             },
-            ctime: entry::Time {
+            ctime: entry::stat::Time {
                 secs: mtime_secs,
                 nsecs: mtime_nsecs,
             },

gix-index/src/entry/mod.rs

@@ -1,33 +1,48 @@
 /// The stage of an entry, one of 0 = base, 1 = ours, 2 = theirs
 pub type Stage = u32;
 
-mod mode;
-pub use mode::Mode;
+///
+pub mod mode;
 
 mod flags;
 pub(crate) use flags::at_rest;
 pub use flags::Flags;
 
+///
+pub mod stat;
 mod write;
 
-/// The time component in a [`Stat`] struct.
-#[derive(Debug, Default, PartialEq, Eq, Hash, Ord, PartialOrd, Clone, Copy)]
-#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
-pub struct Time {
-    /// The amount of seconds elapsed since EPOCH
-    pub secs: u32,
-    /// The amount of nanoseconds elapsed in the current second, ranging from 0 to 999.999.999 .
-    pub nsecs: u32,
+use bitflags::bitflags;
+
+// TODO: we essentially treat this as an enum withj the only exception being
+// that `FILE_EXECUTABLE.contains(FILE)` works might want to turn this into an
+// enum proper
+bitflags! {
+    /// The kind of file of an entry.
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct Mode: u32 {
+        /// directory (only used for sparse checkouts), equivalent to a tree, which is _excluded_ from the index via
+        /// cone-mode.
+        const DIR = 0o040000;
+        /// regular file
+        const FILE = 0o100644;
+        /// regular file, executable
+        const FILE_EXECUTABLE = 0o100755;
+        /// Symbolic link
+        const SYMLINK = 0o120000;
+        /// A git commit for submodules
+        const COMMIT = 0o160000;
+    }
 }
 
 /// An entry's filesystem stat information.
 #[derive(Debug, Default, PartialEq, Eq, Hash, Ord, PartialOrd, Clone, Copy)]
 #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub struct Stat {
     /// Modification time
-    pub mtime: Time,
+    pub mtime: stat::Time,
     /// Creation time
-    pub ctime: Time,
+    pub ctime: stat::Time,
     /// Device number
     pub dev: u32,
     /// Inode number
@@ -64,29 +79,11 @@ mod access {
 }
 
 mod _impls {
-    use std::{cmp::Ordering, ops::Add, time::SystemTime};
+    use std::cmp::Ordering;
 
     use bstr::BStr;
 
-    use crate::{entry::Time, Entry, State};
-
-    impl From<SystemTime> for Time {
-        fn from(s: SystemTime) -> Self {
-            let d = s
-                .duration_since(std::time::UNIX_EPOCH)
-                .expect("system time is not before unix epoch!");
-            Time {
-                secs: d.as_secs() as u32,
-                nsecs: d.subsec_nanos(),
-            }
-        }
-    }
-
-    impl From<Time> for SystemTime {
-        fn from(s: Time) -> Self {
-            std::time::UNIX_EPOCH.add(std::time::Duration::new(s.secs.into(), s.nsecs))
-        }
-    }
+    use crate::{Entry, State};
 
     impl Entry {
         /// Compare one entry to another by their path, by comparing only their common path portion byte by byte, then resorting to