Update Eigen to commit:b6849f675d4237398c4a3ae806ddaf4ca461ed01

CHANGELOG
=========
b6849f675 - Change the midpoint chosen in Eigen::ForkJoinScheduler.
1b2e84e55 - Fix minor typos in `ForkJoin.h`
872c179f5 - Fix UTF-8 encoding errors introduced by #1801

PiperOrigin-RevId: 721553862
Change-Id: I44149f69a94bfdc8b3df291521bdf3effc69878e

Eigen/src/SparseCholesky/SimplicialCholesky_impl.h

diff --git a/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h b/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h
index 0288bd9..26cd38e 100644
--- a/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h
+++ b/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h
@@ -127,7 +127,7 @@
   // Adapted from:
   // Joseph W. Liu. (1986).
   // A compact row storage scheme for Cholesky factors using elimination trees.
-  // ACM Trans. Math. Softw. 12, 2 (June 1986), 127–148. https://doi.org/10.1145/6497.6499
+  // ACM Trans. Math. Softw. 12, 2 (June 1986), 127-148. https://doi.org/10.1145/6497.6499
 
   // Computes the elimination forest of the lower adjacency matrix, a compact representation of the sparse L factor.
   // The L factor may contain multiple elimination trees if a column contains only its diagonal element.
@@ -197,7 +197,7 @@
   // Adapted from:
   // Gilbert, J. R., Ng, E., & Peyton, B. W. (1994).
   // An efficient algorithm to compute row and column counts for sparse Cholesky factorization.
-  // SIAM Journal on Matrix Analysis and Applications, 15(4), 1075–1091.
+  // SIAM Journal on Matrix Analysis and Applications, 15(4), 1075-1091.
 
   // Computes the non-zero pattern of the L factor.
   static void calc_colcount(const StorageIndex size, const StorageIndex* hadjOuter, const StorageIndex* hadjInner,

Eigen/src/ThreadPool/ForkJoin.h

diff --git a/Eigen/src/ThreadPool/ForkJoin.h b/Eigen/src/ThreadPool/ForkJoin.h
index 46dac49..d6ea4dd 100644
--- a/Eigen/src/ThreadPool/ForkJoin.h
+++ b/Eigen/src/ThreadPool/ForkJoin.h
@@ -16,14 +16,14 @@
 namespace Eigen {
 
 // ForkJoinScheduler provides implementations of various non-blocking ParallelFor algorithms for unary
-// and binary parallel tasks. More specfically, the implementations follow the binary tree-based
+// and binary parallel tasks. More specifically, the implementations follow the binary tree-based
 // algorithm from the following paper:
 //
 //   Lea, D. (2000, June). A java fork/join framework. *In Proceedings of the
 //   ACM 2000 conference on Java Grande* (pp. 36-43).
 //
 // For a given binary task function `f(i,j)` and integers `num_threads`, `granularity`, `start`, and `end`,
-// the implemented parallel for algorithm schedules and excutes at most `num_threads` of the functions
+// the implemented parallel for algorithm schedules and executes at most `num_threads` of the functions
 // from the following set in parallel (either synchronously or asynchronously):
 //
 //   f(start,start+s_1), f(start+s_1,start+s_2), ..., f(start+s_n,end)
@@ -126,13 +126,9 @@
       // `granularity` are powers of two. Since modern processors usually implement (2^x)-way
       // set-associative caches, we minimize the number of cache misses by choosing midpoints that are not
       // powers of two (to avoid having two addresses in the main memory pointing to the same point in the
-      // cache). More specifically, we restrict the set of candidate midpoints to:
-      //
-      //   P := {start, start + granularity, start + 2*granularity, ..., end},
-      //
-      // and choose the entry in `P` at (roughly) the 9/16 mark.
+      // cache). More specifically, we choose the midpoint at (roughly) the 9/16 mark.
       const int size = end - start;
-      const int mid = start + Eigen::numext::div_ceil(9 * (size + 1) / 16, granularity) * granularity;
+      const int mid = start + 9 * (size + 1) / 16;
       ForkJoinScheduler::ForkJoin(
           [start, mid, granularity, &do_func, &done, thread_pool]() {
             RunParallelForAsync(start, mid, granularity, do_func, done, thread_pool);