perf: search, searchset and replace sort chunks, not the raw data

- as chunks are contiguous, so its unnecessary to sort the raw data after multithreaded operations. Reduces sort from O(n log n) to O(n_chunks log n_chunks)
- as number of chunks is equal to number of CPUs, no need to do parallel sort and just use simple sort

Author: jqnatividad

src/cmd/replace.rs

@@ -313,8 +313,6 @@ impl Args {
         rconfig: &Config,
         replacement: &[u8],
     ) -> CliResult<()> {
-        use rayon::slice::ParallelSliceMut;
-
         let mut rdr = rconfig.reader()?;
         let headers = rdr.byte_headers()?.clone();
         let sel = rconfig.selection(&headers)?;
@@ -379,13 +377,13 @@ impl Args {
         drop(send);
 
         // Collect all results from all chunks
-        let mut all_results: Vec<ReplaceResult> = Vec::with_capacity(idx_count);
+        let mut all_chunks: Vec<Vec<ReplaceResult>> = Vec::with_capacity(nchunks);
         for chunk_results in &recv {
-            all_results.extend(chunk_results);
+            all_chunks.push(chunk_results);
         }
 
-        // Sort by row_number to maintain original order
-        all_results.par_sort_unstable_by_key(|r| r.row_number);
+        // Sort chunks by first row_number to maintain original order
+        all_chunks.sort_unstable_by_key(|chunk| chunk.first().map_or(0, |r| r.row_number));
 
         // Setup writer
         let mut wtr = Config::new(self.flag_output.as_ref()).writer()?;
@@ -400,13 +398,15 @@ impl Args {
         #[cfg(any(feature = "feature_capable", feature = "lite"))]
         let mut _rows_with_matches_ctr: u64 = 0;
 
-        for result in all_results {
-            total_match_ctr += result.match_count;
-            #[cfg(any(feature = "feature_capable", feature = "lite"))]
-            if result.had_match {
-                _rows_with_matches_ctr += 1;
+        for chunk in all_chunks {
+            for result in chunk {
+                total_match_ctr += result.match_count;
+                #[cfg(any(feature = "feature_capable", feature = "lite"))]
+                if result.had_match {
+                    _rows_with_matches_ctr += 1;
+                }
+                wtr.write_byte_record(&result.record)?;
             }
-            wtr.write_byte_record(&result.record)?;
         }
 
         wtr.flush()?;

src/cmd/search.rs

@@ -205,6 +205,8 @@ fn should_collect_preview(
 /// Write a single result record to output
 /// Returns true if the record was written (for match counting)
 #[allow(clippy::too_many_arguments)]
+#[allow(clippy::fn_params_excessive_bools)]
+#[allow(clippy::inline_always)]
 #[inline(always)]
 fn write_result_record(
     record: &mut csv::ByteRecord,
@@ -528,8 +530,6 @@ impl Args {
         pattern: regex::bytes::Regex,
         rconfig: &Config,
     ) -> CliResult<()> {
-        use rayon::slice::ParallelSliceMut;
-
         let mut rdr = rconfig.reader()?;
         let mut headers = rdr.byte_headers()?.clone();
         let sel = rconfig.selection(&headers)?;
@@ -607,17 +607,17 @@ impl Args {
         drop(send);
 
         // Collect all results from all chunks
-        let mut all_results: Vec<SearchResult> = Vec::with_capacity(idx_count);
+        let mut all_chunks: Vec<Vec<SearchResult>> = Vec::with_capacity(nchunks);
         for chunk_results in &recv {
-            all_results.extend(chunk_results);
+            all_chunks.push(chunk_results);
         }
 
-        // Sort by row_number to maintain original order
-        all_results.par_sort_unstable_by_key(|r| r.row_number);
+        // Sort chunks by first row_number to maintain original order
+        all_chunks.sort_unstable_by_key(|chunk| chunk.first().map_or(0, |r| r.row_number));
 
         // Handle --quick mode: find earliest match
         if self.flag_quick {
-            if let Some(first_match) = all_results.iter().find(|r| r.matched) {
+            if let Some(first_match) = all_chunks.iter().flatten().find(|r| r.matched) {
                 if !self.flag_quiet {
                     eprintln!("{}", first_match.row_number);
                 }
@@ -649,29 +649,31 @@ impl Args {
             json_wtr.write_all(b"[")?;
         }
 
-        for result in all_results {
-            let mut record = result.record;
-            let matched = result.matched;
+        for chunk in all_chunks {
+            for result in chunk {
+                let mut record = result.record;
+                let matched = result.matched;
 
-            if matched {
-                match_ctr += 1;
-            }
+                if matched {
+                    match_ctr += 1;
+                }
 
-            // Use helper to write record if needed
-            write_result_record(
-                &mut record,
-                result.row_number,
-                matched,
-                flag_flag,
-                flag_json,
-                flag_no_headers,
-                matches_only,
-                &headers,
-                &mut wtr,
-                &mut json_wtr,
-                &mut is_first,
-                &mut matched_rows,
-            )?;
+                // Use helper to write record if needed
+                write_result_record(
+                    &mut record,
+                    result.row_number,
+                    matched,
+                    flag_flag,
+                    flag_json,
+                    flag_no_headers,
+                    matches_only,
+                    &headers,
+                    &mut wtr,
+                    &mut json_wtr,
+                    &mut is_first,
+                    &mut matched_rows,
+                )?;
+            }
         }
 
         // Use helper to finalize output

src/cmd/searchset.rs

@@ -410,8 +410,6 @@ impl Args {
         rconfig: &Config,
         regex_labels: &[String],
     ) -> CliResult<()> {
-        use rayon::slice::ParallelSliceMut;
-
         let mut rdr = rconfig.reader()?;
         let mut headers = rdr.byte_headers()?.clone();
         let sel = rconfig.selection(&headers)?;
@@ -506,17 +504,17 @@ impl Args {
         drop(send);
 
         // Collect all results from all chunks
-        let mut all_results: Vec<SearchSetResult> = Vec::with_capacity(idx_count);
+        let mut all_chunks: Vec<Vec<SearchSetResult>> = Vec::with_capacity(nchunks);
         for chunk_results in &recv {
-            all_results.extend(chunk_results);
+            all_chunks.push(chunk_results);
         }
 
-        // Sort by row_number to maintain original order
-        all_results.par_sort_unstable_by_key(|r| r.row_number);
+        // Sort chunks by first row_number to maintain original order
+        all_chunks.sort_unstable_by_key(|chunk| chunk.first().map_or(0, |r| r.row_number));
 
         // Handle --quick mode: find earliest match
         if self.flag_quick {
-            if let Some(first_match) = all_results.iter().find(|r| r.matched) {
+            if let Some(first_match) = all_chunks.iter().flatten().find(|r| r.matched) {
                 if !self.flag_quiet {
                     eprintln!("{}", first_match.row_number);
                 }
@@ -546,51 +544,53 @@ impl Args {
         #[allow(unused_assignments)]
         let mut match_list_with_row = String::with_capacity(20);
 
-        for result in all_results {
-            let mut record = result.record;
-            let matched = result.matched;
-            let match_list = result.match_list;
+        for chunk in all_chunks {
+            for result in chunk {
+                let mut record = result.record;
+                let matched = result.matched;
+                let match_list = result.match_list;
 
-            if matched {
-                match_row_ctr += 1;
-            }
+                if matched {
+                    match_row_ctr += 1;
+                }
 
-            if do_match_list {
-                let flag_column = if matched {
-                    itoa::Buffer::new()
-                        .format(result.row_number)
-                        .clone_into(&mut matched_rows);
-                    if self.flag_invert_match {
-                        matched_rows.as_bytes().to_vec()
-                    } else {
-                        total_matches += match_list.len() as u64;
-                        // builds format!("{matched_rows};{match_list}")
-                        // without intermediate Vec allocation
-                        match_list_with_row.clear();
-                        match_list_with_row.push_str(&matched_rows);
-                        match_list_with_row.push(';');
-                        for (idx, i) in match_list.iter().enumerate() {
-                            if idx > 0 {
-                                match_list_with_row.push(',');
+                if do_match_list {
+                    let flag_column = if matched {
+                        itoa::Buffer::new()
+                            .format(result.row_number)
+                            .clone_into(&mut matched_rows);
+                        if self.flag_invert_match {
+                            matched_rows.as_bytes().to_vec()
+                        } else {
+                            total_matches += match_list.len() as u64;
+                            // builds format!("{matched_rows};{match_list}")
+                            // without intermediate Vec allocation
+                            match_list_with_row.clear();
+                            match_list_with_row.push_str(&matched_rows);
+                            match_list_with_row.push(';');
+                            for (idx, i) in match_list.iter().enumerate() {
+                                if idx > 0 {
+                                    match_list_with_row.push(',');
+                                }
+                                match_list_with_row.push_str(&regex_labels[*i - 1]);
                             }
-                            match_list_with_row.push_str(&regex_labels[*i - 1]);
+                            match_list_with_row.as_bytes().to_vec()
                         }
-                        match_list_with_row.as_bytes().to_vec()
-                    }
-                } else {
-                    b"0".to_vec()
-                };
+                    } else {
+                        b"0".to_vec()
+                    };
 
-                if self.flag_flag_matches_only && !matched {
-                    if self.flag_unmatched_output.is_some() {
-                        unmatched_wtr.write_byte_record(&record)?;
+                    if self.flag_flag_matches_only && !matched {
+                        if self.flag_unmatched_output.is_some() {
+                            unmatched_wtr.write_byte_record(&record)?;
+                        }
+                        continue;
                     }
-                    continue;
+                    record.push_field(&flag_column);
+                    wtr.write_byte_record(&record)?;
+                } else if matched {
+                    wtr.write_byte_record(&record)?;
                 }
-                record.push_field(&flag_column);
-                wtr.write_byte_record(&record)?;
-            } else if matched {
-                wtr.write_byte_record(&record)?;
             }
         }