[mlir] Expose `updateBoundsForCyclicDistribution` in Linalg/Utils.h.

[gysit]

looks good!

mlir/include/mlir/Dialect/Linalg/Utils/Utils.h

struct LinalgLoopDistributionOptions {
   /// Specification of how to distribute the `scf.parallel` loops that are
   /// generated. As the `scf.parallel` loop is generated, the elements of this
   /// vector is used (from left to right) and the specified distribution is
   /// applied. If the vector is less than the number of `scf.parallel` loops
   /// generated, then no distribution is applied.
   SmallVector<DistributionMethod, 0> distributionMethod = {};
 };
 
+/// Update the `lb`, `ub` and `step` to get per processor `lb`, `ub` and `step`.
+void updateBoundsForCyclicDistribution(OpBuilder &builder, Location loc,
+                                       Value procId, Value nprocs, Value &lb,
+                                       Value &ub, Value &step);
+
 //===----------------------------------------------------------------------===//
 // Generic op region utilities
 //===----------------------------------------------------------------------===//
 
 /// A struct containing common matchers over linalg op's region.
 struct RegionMatcher {
   enum class BinaryOpKind {
     IAdd,

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

void GenerateLoopNest<AffineForOp>::doit(
   auto bodyBuilderWithoutIterArgsFn = [&](ValueRange ivs) {
     bodyBuilderFn(ivs, {});
   };
   edsc::affineLoopNestBuilder(lbs, ubs, constantSteps,
                               bodyBuilderWithoutIterArgsFn);
 }
 
 /// Update the `lb`, `ub` and `step` to get per processor `lb`, `ub` and `step`.
-static void updateBoundsForCyclicDistribution(OpBuilder &builder, Location loc,
-                                              Value procId, Value nprocs,
-                                              Value &lb, Value &ub,
-                                              Value &step) {
+void updateBoundsForCyclicDistribution(OpBuilder &builder, Location loc,
+                                       Value procId, Value nprocs, Value &lb,
+                                       Value &ub, Value &step) {
   using edsc::op::operator+;
   using edsc::op::operator*;
   lb = lb + (procId * step);
   step = nprocs * step;
 }
 
 /// Generates a loop nest consisting of scf.parallel and scf.for, depending
 /// on the `iteratorTypes.` Consecutive parallel loops create a single