move file operations from b3sum to blake3

3 files changed, 5 insertions, 56 deletions

diff --git a/b3sum/Cargo.lock b/b3sum/Cargo.lock
index d1049af..3c7c737 100644
--- a/b3sum/Cargo.lock
+++ b/b3sum/Cargo.lock
@@ -110,6 +110,7 @@ dependencies = [
  "cc",
  "cfg-if",
  "constant_time_eq",
+ "memmap2",
  "rayon",
 ]
 
diff --git a/b3sum/Cargo.toml b/b3sum/Cargo.toml
index 02c9405..19b617e 100644
--- a/b3sum/Cargo.toml
+++ b/b3sum/Cargo.toml
@@ -15,7 +15,7 @@ pure = ["blake3/pure"]
 
 [dependencies]
 anyhow = "1.0.25"
-blake3 = { version = "1", path = "..", features = ["rayon"] }
+blake3 = { version = "1", path = "..", features = ["file", "rayon"] }
 clap = { version = "4.0.8", features = ["derive", "wrap_help"] }
 hex = "0.4.0"
 memmap2 = "0.7.0"
diff --git a/b3sum/src/main.rs b/b3sum/src/main.rs
index fd35f68..165c579 100644
--- a/b3sum/src/main.rs
+++ b/b3sum/src/main.rs
@@ -182,7 +182,7 @@ impl Input {
         }
         let file = File::open(path)?;
         if !args.no_mmap() {
-            if let Some(mmap) = maybe_memmap_file(&file)? {
+            if let Some(mmap) = blake3::file::maybe_memmap_file(&file)? {
                 return Ok(Self::Mmap(io::Cursor::new(mmap)));
             }
         }
@@ -208,12 +208,12 @@ impl Input {
             // one. We might implement that in the future, but since this is
             // the slow path anyway, it's not high priority.
             Self::File(file) => {
-                copy_wide(file, &mut hasher)?;
+                blake3::copy_wide(file, &mut hasher)?;
             }
             Self::Stdin => {
                 let stdin = io::stdin();
                 let lock = stdin.lock();
-                copy_wide(lock, &mut hasher)?;
+                blake3::copy_wide(lock, &mut hasher)?;
             }
         }
         let mut output_reader = hasher.finalize_xof();
@@ -232,58 +232,6 @@ impl Read for Input {
     }
 }
 
-// A 16 KiB buffer is enough to take advantage of all the SIMD instruction sets
-// that we support, but `std::io::copy` currently uses 8 KiB. Most platforms
-// can support at least 64 KiB, and there's some performance benefit to using
-// bigger reads, so that's what we use here.
-fn copy_wide(mut reader: impl Read, hasher: &mut blake3::Hasher) -> io::Result<u64> {
-    let mut buffer = [0; 65536];
-    let mut total = 0;
-    loop {
-        match reader.read(&mut buffer) {
-            Ok(0) => return Ok(total),
-            Ok(n) => {
-                hasher.update(&buffer[..n]);
-                total += n as u64;
-            }
-            Err(ref e) if e.kind() == io::ErrorKind::Interrupted => continue,
-            Err(e) => return Err(e),
-        }
-    }
-}
-
-// Mmap a file, if it looks like a good idea. Return None in cases where we
-// know mmap will fail, or if the file is short enough that mmapping isn't
-// worth it. However, if we do try to mmap and it fails, return the error.
-fn maybe_memmap_file(file: &File) -> Result<Option<memmap2::Mmap>> {
-    let metadata = file.metadata()?;
-    let file_size = metadata.len();
-    Ok(if !metadata.is_file() {
-        // Not a real file.
-        None
-    } else if file_size > isize::max_value() as u64 {
-        // Too long to safely map.
-        // https://github.com/danburkert/memmap-rs/issues/69
-        None
-    } else if file_size == 0 {
-        // Mapping an empty file currently fails.
-        // https://github.com/danburkert/memmap-rs/issues/72
-        None
-    } else if file_size < 16 * 1024 {
-        // Mapping small files is not worth it.
-        None
-    } else {
-        // Explicitly set the length of the memory map, so that filesystem
-        // changes can't race to violate the invariants we just checked.
-        let map = unsafe {
-            memmap2::MmapOptions::new()
-                .len(file_size as usize)
-                .map(file)?
-        };
-        Some(map)
-    })
-}
-
 fn write_hex_output(mut output: blake3::OutputReader, args: &Args) -> Result<()> {
     // Encoding multiples of the 64 bytes is most efficient.
     // TODO: This computes each output block twice when the --seek argument isn't a multiple of 64.