sort: immediately compare whole lines if they parse as numbers

 Numeric sort can be relatively slow on inputs that are wholly or
 mostly numbers. This is more clear when comparing with the speed of
 GeneralNumeric.

 This change parses whole lines as f64 and stores that info in
 `LineData`. This is faster than doing the parsing two lines at
 a time in `compare_by()`.

 # Benchmarks

 ```
 # mimalloc = "0.1.44"
 # snmalloc-rs = { version = "0.3.8", features = ["native-cpu", "lto"] }
 shuf -i 1-1000000 -n 1000000 > shuffled.txt
 hyperfine --warmup=4 -r10 '<sort_cmd> -n /tmp/shuffled.txt'
 ```

 ## Before

 `default_release`
 ```
 Benchmark 1: /tmp/before_coreutils_defaults sort -n /tmp/shuffled.txt
   Time (mean ± σ):     363.2 ms ±  10.2 ms    [User: 1906.8 ms, System: 15.9 ms]
   Range (min … max):   350.3 ms … 380.8 ms    10 runs
 ```

 `codegen-units=1` `-C target-cpu=native`
 ```
 Benchmark 1: /tmp/before_coreutils_native sort -n /tmp/shuffled.txt
   Time (mean ± σ):     357.9 ms ±   9.8 ms    [User: 1892.2 ms, System: 18.5 ms]
   Range (min … max):   343.9 ms … 375.8 ms    10 runs
 ```

 `codegen-units=1` `-C target-cpu=native`, `global_allocator=mimalloc`
 ```
 Benchmark 1: /tmp/before_coreutils_native_mimalloc sort -n /tmp/shuffled.txt
   Time (mean ± σ):     342.5 ms ±   5.8 ms    [User: 1810.1 ms, System: 19.9 ms]
   Range (min … max):   332.1 ms … 351.3 ms    10 runs
 ```

 `-C target-cpu=native`, `global_allocator=snmalloc`
 ```
 Benchmark 1: /tmp/before_coreutils_native_snmalloc sort -n /tmp/shuffled.txt
   Time (mean ± σ):     339.1 ms ±   7.5 ms    [User: 1809.9 ms, System: 14.1 ms]
   Range (min … max):   332.3 ms … 351.7 ms    10 runs
 ```

 ## After

 `default_release`
 ```
 Benchmark 1: /tmp/fixed_coreutils_defaults sort -n /tmp/shuffled.txt
   Time (mean ± σ):     173.2 ms ±   5.0 ms    [User: 535.1 ms, System: 19.3 ms]
   Range (min … max):   168.1 ms … 182.6 ms    10 runs
 ```

 `codegen-units=1` `-C target-cpu=native`
 ```
 Benchmark 1: /tmp/fixed_coreutils_native sort -n /tmp/shuffled.txt
   Time (mean ± σ):     172.3 ms ±   3.8 ms    [User: 535.3 ms, System: 19.9 ms]
   Range (min … max):   166.2 ms … 179.7 ms    10 runs
 ```

 `codegen-units=1` `-C target-cpu=native`, `global_allocator=mimalloc`
 ```
 Benchmark 1: /tmp/fixed_coreutils_native_mimalloc sort -n /tmp/shuffled.txt
   Time (mean ± σ):     168.6 ms ±   2.0 ms    [User: 529.3 ms, System: 19.7 ms]
   Range (min … max):   164.2 ms … 171.4 ms    10 runs
 ```

 `codegen-units=1` `-C target-cpu=native`, `global_allocator=snmalloc`
 ```
 Benchmark 1: /tmp/fixed_coreutils_native_snmalloc sort -n /tmp/shuffled.txt
   Time (mean ± σ):     165.8 ms ±   3.5 ms    [User: 528.6 ms, System: 11.7 ms]
   Range (min … max):   162.1 ms … 173.7 ms    10 runs
 ```

 ## GNU

 `gcc` `-march=x86-64 -mtune=generic -O2 ...` (Arch package)
 ```
 Benchmark 1: sort -n /tmp/shuffled.txt
  Time (mean ± σ):     197.8 ms ±   3.4 ms    [User: 891.4 ms, System: 22.3 ms]
  Range (min … max):   193.5 ms … 202.7 ms    10 runs
 ```

 `clang` `-march=native -O3 -pipe -fstack-protector-strong -fno-plt`
 ```
 Benchmark 1: /tmp/arch_coreutils/pkg-llvm/coreutils/usr/bin/sort -n /tmp/readme.txt
  Time (mean ± σ):     189.7 ms ±   7.5 ms    [User: 825.8 ms, System: 19.9 ms]
  Range (min … max):   182.4 ms … 209.1 ms    10 runs
 ```

 `gcc` `-march=native -O3 -pipe -fstack-protector-strong -fno-plt`
 ```
 Benchmark 1: /tmp/arch_coreutils/pkg/coreutils/usr/bin/sort -n /tmp/shuffled.txt
  Time (mean ± σ):     182.8 ms ±   5.9 ms    [User: 807.3 ms, System: 22.6 ms]
  Range (min … max):   173.6 ms … 194.8 ms    10 runs
 ```

 ## `sort -g` Numbers for comparison

 ### GNU

 `gcc` `-march=x86-64 -mtune=generic -O2 ...` (Arch package)
 ```
 Benchmark 1: sort -g /tmp/shuffled.txt
   Time (mean ± σ):     713.8 ms ±  14.5 ms    [User: 3943.0 ms, System: 36.0 ms]
   Range (min … max):   687.3 ms … 737.3 ms    10 runs
 ```

 `clang` `-march=native -O3 -pipe -fstack-protector-strong -fno-plt`
 ```
 Benchmark 1: /tmp/arch_coreutils/pkg-llvm/coreutils/usr/bin/sort -g /tmp/shuffled.txt
   Time (mean ± σ):     694.7 ms ±  15.0 ms    [User: 3798.5 ms, System: 43.2 ms]
   Range (min … max):   668.0 ms … 712.8 ms    10 runs
 ```

 `gcc` `-march=native -O3 -pipe -fstack-protector-strong -fno-plt`
 ```
 Benchmark 1: /tmp/arch_coreutils/pkg/coreutils/usr/bin/sort -g /tmp/shuffled.txt
   Time (mean ± σ):     693.9 ms ±   9.8 ms    [User: 3810.0 ms, System: 38.7 ms]
   Range (min … max):   676.5 ms … 709.6 ms    10 runs
 ```

 ### uutils

 `default_release`
 ```
 Benchmark 1: /tmp/fixed_coreutils_defaults sort -g /tmp/shuffled.txt
   Time (mean ± σ):     256.5 ms ±   5.4 ms    [User: 945.8 ms, System: 15.7 ms]
   Range (min … max):   248.7 ms … 266.4 ms    10 runs
 ```

 `codegen-units=1` `-C target-cpu=native`
 ```
 Benchmark 1: /tmp/fixed_coreutils_native sort -g /tmp/shuffled.txt
   Time (mean ± σ):     255.8 ms ±   5.0 ms    [User: 952.6 ms, System: 15.9 ms]
   Range (min … max):   249.2 ms … 263.7 ms    10 runs
 ```

 `codegen-units=1` `-C target-cpu=native`, `global_allocator=mimalloc`
 ```
 Benchmark 1: /tmp/fixed_coreutils_native_mimalloc sort -g /tmp/shuffled.txt
   Time (mean ± σ):     245.1 ms ±   7.4 ms    [User: 926.3 ms, System: 18.7 ms]
   Range (min … max):   236.1 ms … 258.0 ms    10 runs
 ```

 `codegen-units=1` `-C target-cpu=native`, `global_allocator=snmalloc`
 ```
 Benchmark 1: /tmp/fixed_coreutils_native_snmalloc sort -g /tmp/shuffled.txt
   Time (mean ± σ):     240.3 ms ±   6.2 ms    [User: 922.7 ms, System: 11.2 ms]
   Range (min … max):   230.3 ms … 249.2 ms    10 runs
 ```

Signed-off-by: Mohammad AlSaleh <CE.Mohammad.AlSaleh@gmail.com>

Author: MoSal

src/uu/sort/src/chunks.rs

@@ -42,6 +42,7 @@ pub struct LineData<'a> {
     pub selections: Vec<&'a str>,
     pub num_infos: Vec<NumInfo>,
     pub parsed_floats: Vec<GeneralF64ParseResult>,
+    pub line_num_floats: Vec<Option<f64>>,
 }
 
 impl Chunk {
@@ -52,6 +53,7 @@ impl Chunk {
             contents.line_data.selections.clear();
             contents.line_data.num_infos.clear();
             contents.line_data.parsed_floats.clear();
+            contents.line_data.line_num_floats.clear();
             let lines = unsafe {
                 // SAFETY: It is safe to (temporarily) transmute to a vector of lines with a longer lifetime,
                 // because the vector is empty.
@@ -73,13 +75,15 @@ impl Chunk {
                 selections,
                 std::mem::take(&mut contents.line_data.num_infos),
                 std::mem::take(&mut contents.line_data.parsed_floats),
+                std::mem::take(&mut contents.line_data.line_num_floats),
             )
         });
         RecycledChunk {
             lines: recycled_contents.0,
             selections: recycled_contents.1,
             num_infos: recycled_contents.2,
             parsed_floats: recycled_contents.3,
+            line_num_floats: recycled_contents.4,
             buffer: self.into_owner(),
         }
     }
@@ -97,6 +101,7 @@ pub struct RecycledChunk {
     selections: Vec<&'static str>,
     num_infos: Vec<NumInfo>,
     parsed_floats: Vec<GeneralF64ParseResult>,
+    line_num_floats: Vec<Option<f64>>,
     buffer: Vec<u8>,
 }
 
@@ -107,6 +112,7 @@ impl RecycledChunk {
             selections: Vec::new(),
             num_infos: Vec::new(),
             parsed_floats: Vec::new(),
+            line_num_floats: Vec::new(),
             buffer: vec![0; capacity],
         }
     }
@@ -149,6 +155,7 @@ pub fn read<T: Read>(
         selections,
         num_infos,
         parsed_floats,
+        line_num_floats,
         mut buffer,
     } = recycled_chunk;
     if buffer.len() < carry_over.len() {
@@ -184,6 +191,7 @@ pub fn read<T: Read>(
                 selections,
                 num_infos,
                 parsed_floats,
+                line_num_floats,
             };
             parse_lines(read, &mut lines, &mut line_data, separator, settings);
             Ok(ChunkContents { lines, line_data })
@@ -207,6 +215,7 @@ fn parse_lines<'a>(
     assert!(line_data.selections.is_empty());
     assert!(line_data.num_infos.is_empty());
     assert!(line_data.parsed_floats.is_empty());
+    assert!(line_data.line_num_floats.is_empty());
     let mut token_buffer = vec![];
     lines.extend(
         read.split(separator as char)

src/uu/sort/src/sort.rs

@@ -460,6 +460,13 @@ impl<'a> Line<'a> {
         if settings.precomputed.needs_tokens {
             tokenize(line, settings.separator, token_buffer);
         }
+        if settings.mode == SortMode::Numeric {
+            // exclude inf, nan, scientific notation
+            let line_num_float =(!line.contains(char::is_alphabetic))
+                .then(|| line.parse::<f64>().ok())
+                .flatten();
+            line_data.line_num_floats.push(line_num_float);
+        }
         for (selector, selection) in settings
             .selectors
             .iter()
@@ -1559,6 +1566,24 @@ fn compare_by<'a>(
     let mut selection_index = 0;
     let mut num_info_index = 0;
     let mut parsed_float_index = 0;
+
+    if let (Some(Some(a_f64)), Some(Some(b_f64))) = (
+        a_line_data.line_num_floats.get(a.index),
+        b_line_data.line_num_floats.get(b.index),
+    ) {
+        // we don't use total_cmp() because it always sorts -0 before 0
+        if let Some(cmp) = a_f64.partial_cmp(b_f64) {
+            // don't trust `Ordering::Equal` if lines are not fully equal
+            if cmp != Ordering::Equal || a.line == b.line {
+                return if global_settings.reverse {
+                    cmp.reverse()
+                } else {
+                    cmp
+                };
+            }
+        }
+    }
+
     for selector in &global_settings.selectors {
         let (a_str, b_str) = if selector.needs_selection {
             let selections = (