| blob | f1bf04901dc7b711ddf00e4b2ee59e9d0aa7eb11 |
1 /*
2 * kmp_collapse.cpp -- loop collapse feature
3 */
5 //===----------------------------------------------------------------------===//
6 //
7 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
8 // See https://llvm.org/LICENSE.txt for license information.
9 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
10 //
11 //===----------------------------------------------------------------------===//
21 #if OMPT_SUPPORT
23 #endif
25 // OMPTODO: different style of comments (see kmp_sched)
26 // OMPTODO: OMPT/OMPD
28 // avoid inadevertently using a library based abs
31 }
35 //----------------------------------------------------------------------------
36 // Common functions for working with rectangular and non-rectangular loops
37 //----------------------------------------------------------------------------
41 }
48 // (8 bytes x 4 nested loops)
51 pT pTAlloc;
57 }
58 }
62 }
63 }
66 };
68 //----------Loop canonicalization---------------------------------------------
70 // For loop nest (any shape):
71 // convert != to < or >;
72 // switch from using < or > to <= or >=.
73 // "bounds" array has to be allocated per thread.
74 // All other internal functions will work only with canonicalized loops.
83 loc);
84 }
85 }
88 // We can convert this to < or >, depends on the sign of the step:
93 }
94 }
97 // Note: ub0 can be unsigned. Should be Ok to hit overflow here,
98 // because ub0 + ub1*j should be still positive (otherwise loop was not
99 // well formed)
105 }
106 }
108 // Canonicalize loop nest. original_bounds_nest is an array of length n.
111 kmp_index_t n) {
119 loc,
124 loc,
129 loc,
134 loc,
139 }
140 }
141 }
143 //----------Calculating trip count on one level-------------------------------
145 // Calculate trip count on this loop level.
146 // We do this either for a rectangular loop nest,
147 // or after an adjustment bringing the loops to a parallelepiped shape.
148 // This number should not depend on the value of outer IV
149 // even if the formular has lb1 and ub1.
150 // Note: for non-rectangular loops don't use span for this, it's too big.
158 // Note: after this we don't need to calculate inner loops,
159 // but that should be an edge case:
162 // ub - lb may exceed signed type range; we need to cast to
163 // kmp_loop_nest_iv_t anyway
168 }
171 // Note: after this we don't need to calculate inner loops,
172 // but that should be an edge case:
175 // lb - ub may exceed signed type range; we need to cast to
176 // kmp_loop_nest_iv_t anyway
181 }
184 }
186 }
188 // Calculate trip count on this loop level.
212 }
215 }
217 //----------Trim original iv according to its type----------------------------
219 // Trim original iv according to its type.
220 // Return kmp_uint64 value which can be easily used in all internal calculations
221 // And can be statically cast back to original type in user code.
252 }
255 }
257 //----------Compare two IVs (remember they have a type)-----------------------
260 kmp_uint64 original_iv2) {
298 }
301 }
303 //----------Calculate original iv on one level--------------------------------
305 // Return true if the point fits into upper bounds on this level,
306 // false otherwise
310 kmp_index_t ind) {
319 // The calculated point is outside of loop upper boundary:
321 }
324 }
326 // Calculate one iv corresponding to iteration on the level ind.
327 // Return true if it fits into lower-upper bounds on this level
328 // (if not, we need to re-calculate)
339 // we moved to the next iteration on one of outer loops, should start
340 // with the lower bound here:
345 }
347 // Now trim original iv according to its type:
354 }
355 }
367 checkBounds);
373 checkBounds);
379 checkBounds);
385 checkBounds);
390 }
391 }
393 //----------Calculate original iv on one level for rectangular loop nest------
395 // Calculate one iv corresponding to iteration on the level ind.
396 // Return true if it fits into lower-upper bounds on this level
397 // (if not, we need to re-calculate)
402 kmp_index_t ind) {
406 kmp_uint64 temp =
411 // Now trim original iv according to its type:
413 }
418 kmp_index_t ind) {
443 }
444 }
446 //----------------------------------------------------------------------------
447 // Rectangular loop nest
448 //----------------------------------------------------------------------------
450 //----------Canonicalize loop nest and calculate trip count-------------------
452 // Canonicalize loop nest and calculate overall trip count.
453 // "bounds_nest" has to be allocated per thread.
454 // API will modify original bounds_nest array to bring it to a canonical form
455 // (only <= and >=, no !=, <, >). If the original loop nest was already in a
456 // canonical form there will be no changes to bounds in bounds_nest array
457 // (only trip counts will be calculated).
458 // Returns trip count of overall space.
462 kmp_index_t n) {
473 }
476 }
478 //----------Calculate old induction variables---------------------------------
480 // Calculate old induction variables corresponding to overall new_iv.
481 // Note: original IV will be returned as if it had kmp_uint64 type,
482 // will have to be converted to original type in user code.
483 // Note: trip counts should be already calculated by
484 // __kmpc_process_loop_nest_rectang.
485 // OMPTODO: special case 2, 3 nested loops: either do different
486 // interface without array or possibly template this over n
491 kmp_index_t n) {
495 // First, calc corresponding iteration in every original loop:
500 // should be optimized to OPDIVREM:
506 }
513 }
514 }
516 //----------------------------------------------------------------------------
517 // Non-rectangular loop nest
518 //----------------------------------------------------------------------------
520 //----------Calculate maximum possible span of iv values on one level---------
522 // Calculate span for IV on this loop level for "<=" case.
523 // Note: it's for <= on this loop nest level, so lower bound should be smallest
524 // value, upper bound should be the biggest value. If the loop won't execute,
525 // 'smallest' may be bigger than 'biggest', but we'd better not switch them
526 // around.
533 // typedef typename traits_t<T>::signed_t ST;
535 // typedef typename big_span_t span_t;
541 // This dimention depends on one of previous ones; can't be the outermost
542 // one.
547 // OMPTODO: assert that T is compatible with loop variable type on
548 // 'previous' loop
550 {
551 span_t bound_candidate1 =
553 span_t bound_candidate2 =
559 }
560 }
562 {
563 // We can't adjust the upper bound with respect to step, because
564 // lower bound might be off after adjustments
566 span_t bound_candidate1 =
568 span_t bound_candidate2 =
574 }
575 }
577 // Rectangular:
580 }
582 // Here it's safe to reduce the space to the multiply of step.
583 // OMPTODO: check if the formular is correct.
584 // Also check if it would be safe to do this if we didn't adjust left side.
587 }
588 }
590 // Calculate span for IV on this loop level for ">=" case.
597 // typedef typename traits_t<T>::signed_t ST;
599 // typedef typename big_span_t span_t;
605 // This dimention depends on one of previous ones; can't be the outermost
606 // one.
611 // OMPTODO: assert that T is compatible with loop variable type on
612 // 'previous' loop
614 {
615 span_t bound_candidate1 =
617 span_t bound_candidate2 =
623 }
624 }
626 {
627 // We can't adjust the upper bound with respect to step, because
628 // lower bound might be off after adjustments
630 span_t bound_candidate1 =
632 span_t bound_candidate2 =
638 }
639 }
642 // Rectangular:
645 }
647 // Here it's safe to reduce the space to the multiply of step.
648 // OMPTODO: check if the formular is correct.
649 // Also check if it would be safe to do this if we didn't adjust left side.
652 }
653 }
655 // Calculate maximum possible span for IV on this loop level.
666 }
667 }
669 //----------All initial processing of the loop nest---------------------------
671 // Calculate new bounds for this loop level.
672 // To be able to work with the nest we need to get it to a parallelepiped shape.
673 // We need to stay in the original range of values, so that there will be no
674 // overflow, for that we'll adjust both upper and lower bounds as needed.
683 // Already parallel, no need to adjust:
692 // With this shape we can adjust to a rectangle:
696 // get upper and lower bounds to be parallel
697 // with values in the old range.
698 // Note: abs didn't work here.
704 }
705 }
707 // Now need to adjust lb0, ub0, otherwise in some cases space will shrink.
708 // The idea here that for this IV we are now getting the same span
709 // irrespective of the previous IV value.
717 // The length is good on outer_iv biggest number,
718 // can use it to find where to move the lower bound:
722 // e.g. it was 0?? (same below)
724 // still need to move lower bound:
727 }
731 // The length is good on outer_iv biggest number,
732 // can use it to find where to move upper bound:
737 // still need to move upper bound:
740 }
750 }
759 }
760 }
761 }
762 }
764 // Do all processing for one canonicalized loop in the nest
765 // (assuming that outer loops already were processed):
774 }
776 // Non-rectangular loop nest, canonicalized to use <= or >=.
777 // Process loop nest to have a parallelepiped shape,
778 // calculate biggest spans for IV's on all levels and calculate overall trip
779 // count. "bounds_nest" has to be allocated per thread.
780 // Returns overall trip count (for adjusted space).
813 }
815 }
818 }
820 //----------Calculate iterations (in the original or updated space)-----------
822 // Calculate number of iterations in original or updated space resulting in
823 // original_ivs[ind] (only on this level, non-negative)
824 // (not counting initial iteration)
826 kmp_loop_nest_iv_t
829 kmp_index_t ind) {
834 iterations =
844 }
847 }
849 // Calculate number of iterations in the original or updated space resulting in
850 // original_ivs[ind] (only on this level, non-negative)
853 kmp_index_t ind) {
875 }
876 }
878 //----------Calculate new iv corresponding to original ivs--------------------
880 // We got a point in the original loop nest.
881 // Take updated bounds and calculate what new_iv will correspond to this point.
882 // When we are getting original IVs from new_iv, we have to adjust to fit into
883 // original loops bounds. Getting new_iv for the adjusted original IVs will help
884 // with making more chunks non-empty.
885 kmp_loop_nest_iv_t
888 kmp_index_t n) {
897 }
900 }
902 //----------Calculate original ivs for provided iterations--------------------
904 // Calculate original IVs for provided iterations, assuming iterations are
905 // calculated in the original space.
906 // Loop nest is in canonical form (with <= / >=).
920 // The calculated iv value is too big (or too small for >=):
922 // Space is empty:
925 // Go to next iteration on the outer loop:
931 }
933 }
934 }
936 }
939 }
941 //----------Calculate original ivs for the beginning of the loop nest---------
943 // Calculate IVs for the beginning of the loop nest.
944 // Note: lower bounds of all loops may not work -
945 // if on some of the iterations of the outer loops inner loops are empty.
946 // Loop nest is in canonical form (with <= / >=).
948 kmp_index_t n,
951 // Iterations in the original space, multiplied by step:
956 }
958 // Now calculate the point:
963 }
965 //----------Calculate next point in the original loop space-------------------
967 // From current set of original IVs calculate next point.
968 // Return false if there is no next point in the loop bounds.
972 // Iterations in the original space, multiplied by step (so can be negative):
974 // First, calc corresponding iteration in every original loop:
978 }
982 }
984 // Next add one step to the iterations on the inner-most level, and see if we
985 // need to move up the nest:
993 }
995 //----------Calculate chunk end in the original loop space--------------------
997 // For one level calculate old induction variable corresponding to overall
998 // new_iv for the chunk end.
999 // Return true if it fits into upper bound on this level
1000 // (if not, we need to re-calculate)
1009 // typedef std::conditional<std::is_signed<T>::value, kmp_int64, kmp_uint64>
1010 // big_span_t;
1012 // OMPTODO: is it good enough, or do we need ST or do we need big_span_t?
1018 // we moved to the next iteration on one of outer loops, may as well use
1019 // the lower bound here:
1022 // Start in expanded space, but:
1023 // - we need to hit original space lower bound, so need to account for
1024 // that
1025 // - we have to go into original space, even if that means adding more
1026 // iterations than was planned
1027 // - we have to go past (or equal to) previous point (which is the chunk
1028 // starting point)
1034 // In case of >= it's negative:
1038 step;
1047 // Too small (or too big), didn't reach the original lower bound. Use
1048 // heuristic:
1050 }
1058 // On all previous levels start of the chunk is same as the end, need to
1059 // be really careful here:
1064 // End of the chunk can't be smaller (for >= bigger) than it's start.
1065 // Use heuristic:
1067 }
1068 }
1069 }
1077 // Too big (or too small for >=).
1079 }
1082 }
1084 // For one level calculate old induction variable corresponding to overall
1085 // new_iv for the chunk end.
1099 /*in/out*/
1107 /*in/out*/
1115 /*in/out*/
1123 /*in/out*/
1130 }
1131 }
1133 // Calculate old induction variables corresponding to overall new_iv for the
1134 // chunk end. If due to space extension we are getting old IVs outside of the
1135 // boundaries, bring them into the boundaries. Need to do this in the runtime,
1136 // esp. on the lower bounds side. When getting result need to make sure that the
1137 // new chunk starts at next position to old chunk, not overlaps with it (this is
1138 // done elsewhere), and need to make sure end of the chunk is further than the
1139 // beginning of the chunk. We don't need an exact ending point here, just
1140 // something more-or-less close to the desired chunk length, bigger is fine
1141 // (smaller would be fine, but we risk going into infinite loop, so do smaller
1142 // only at the very end of the space). result: false if could not find the
1143 // ending point in the original loop space. In this case the caller can use
1144 // original upper bounds as the end of the chunk. Chunk won't be empty, because
1145 // it'll have at least the starting point, which is by construction in the
1146 // original space.
1153 // Iterations in the expanded space:
1155 // First, calc corresponding iteration in every modified loop:
1160 // should be optimized to OPDIVREM:
1166 }
1172 // Next calculate the point, but in original loop nest.
1183 // Too big (or too small for >=).
1185 // Need to reduce to the end.
1188 // Go to next iteration on outer loop:
1193 // We've changed the number of iterations here,
1194 // can't be same anymore:
1196 }
1199 }
1201 }
1202 }
1212 }
1214 }
1217 }
1219 //----------Calculate upper bounds for the last chunk-------------------------
1221 // Calculate one upper bound for the end.
1225 kmp_index_t ind) {
1231 }
1260 }
1261 }
1263 // Calculate upper bounds for the last loop iteration. Just use original upper
1264 // bounds (adjusted when canonicalized to use <= / >=). No need to check that
1265 // this point is in the original space (it's likely not)
1272 }
1273 }
1275 /**************************************************************************
1276 * Identify nested loop structure - loops come in the canonical form
1277 * Lower triangle matrix: i = 0; i <= N; i++ {0,0}:{N,0}
1278 * j = 0; j <= 0/-1+1*i; j++ {0,0}:{0/-1,1}
1279 * Upper Triangle matrix
1280 * i = 0; i <= N; i++ {0,0}:{N,0}
1281 * j = 0+1*i; j <= N; j++ {0,1}:{N,0}
1282 * ************************************************************************/
1283 nested_loop_type_t
1286 // only 2-level nested loops are supported
1289 }
1290 // loops must be canonical
1294 // check outer loop bounds: for triangular need to be {0,0}:{N,0}
1305 }
1306 // check inner bounds to determine triangle type
1315 // lower triangle loop inner bounds need to be {0,0}:{0/-1,1}
1319 }
1320 // upper triangle loop inner bounds need to be {0,1}:{N,0}
1324 }
1326 }
1328 /**************************************************************************
1329 * SQRT Approximation: https://math.mit.edu/~stevenj/18.335/newton-sqrt.pdf
1330 * Start point is x so the result is always > sqrt(x)
1331 * The method has uniform convergence, PRECISION is set to 0.1
1332 * ************************************************************************/
1333 #define level_of_precision 0.1
1342 }
1344 /**************************************************************************
1345 * Handle lower triangle matrix in the canonical form
1346 * i = 0; i <= N; i++ {0,0}:{N,0}
1347 * j = 0; j <= 0/-1 + 1*i; j++ {0,0}:{0/-1,1}
1348 * ************************************************************************/
1356 // transfer loop types from the original loop to the chunks
1359 }
1360 // cleanup iv variables
1367 // calculate the chunk's lower and upper bounds
1368 // the total number of iterations in the loop is the sum of the arithmetic
1369 // progression from the outer lower to outer upper bound (inclusive since the
1370 // loop is canonical) note that less_than inner loops (inner_ub0 = -1)
1371 // effectively make the progression 1-based making N = (outer_ub0 - inner_lb0
1372 // + 1) -> N - 1
1375 // the current thread's number of iterations:
1376 // each thread gets an equal number of iterations: total number of iterations
1377 // divided by the number of threads plus, if there's a remainder,
1378 // the first threads with the number up to the remainder get an additional
1379 // iteration each to cover it
1380 kmp_uint64 iter_current =
1382 // cumulative number of iterations executed by all the previous threads:
1383 // threads with the tid below the remainder will have (iter_total/nth+1)
1384 // elements, and so will all threads before them so the cumulative number of
1385 // iterations executed by the all previous will be the current thread's number
1386 // of iterations multiplied by the number of previous threads which is equal
1387 // to the current thread's tid; threads with the number equal or above the
1388 // remainder will have (iter_total/nth) elements so the cumulative number of
1389 // iterations previously executed is its number of iterations multipled by the
1390 // number of previous threads which is again equal to the current thread's tid
1391 // PLUS all the remainder iterations that will have been executed by the
1392 // previous threads
1393 kmp_uint64 iter_before_current =
1395 // cumulative number of iterations executed with the current thread is
1396 // the cumulative number executed before it plus its own
1398 // calculate the outer loop lower bound (lbo) which is the max outer iv value
1399 // that gives the number of iterations that is equal or just below the total
1400 // number of iterations executed by the previous threads, for less_than
1401 // (1-based) inner loops (inner_ub0 == -1) it will be i.e.
1402 // lbo*(lbo-1)/2<=iter_before_current => lbo^2-lbo-2*iter_before_current<=0
1403 // for less_than_equal (0-based) inner loops (inner_ub == 0) it will be:
1404 // i.e. lbo*(lbo+1)/2<=iter_before_current =>
1405 // lbo^2+lbo-2*iter_before_current<=0 both cases can be handled similarily
1406 // using a parameter to control the equation sign
1408 kmp_uint64 lower_bound_outer =
1411 inner_adjustment) /
1413 inner_adjustment;
1414 // calculate the inner loop lower bound which is the remaining number of
1415 // iterations required to hit the total number of iterations executed by the
1416 // previous threads giving the starting point of this thread
1417 kmp_uint64 lower_bound_inner =
1418 iter_before_current -
1420 // calculate the outer loop upper bound using the same approach as for the
1421 // inner bound except using the total number of iterations executed with the
1422 // current thread
1423 kmp_uint64 upper_bound_outer =
1426 inner_adjustment) /
1428 inner_adjustment;
1429 // calculate the inner loop upper bound which is the remaining number of
1430 // iterations required to hit the total number of iterations executed after
1431 // the current thread giving the starting point of the next thread
1432 kmp_uint64 upper_bound_inner =
1433 iter_with_current -
1435 // adjust the upper bounds down by 1 element to point at the last iteration of
1436 // the current thread the first iteration of the next thread
1438 // {n,0} => {n-1,n-1}
1442 // {n,m} => {n,m-1} (m!=0)
1444 }
1446 // assign the values, zeroing out lb1 and ub1 values since the iteration space
1447 // is now one-dimensional
1457 #if 0
1461 #endif
1462 }
1464 /**************************************************************************
1465 * Handle upper triangle matrix in the canonical form
1466 * i = 0; i <= N; i++ {0,0}:{N,0}
1467 * j = 0+1*i; j <= N; j++ {0,1}:{N,0}
1468 * ************************************************************************/
1476 // transfer loop types from the original loop to the chunks
1479 }
1480 // cleanup iv variables
1487 // calculate the chunk's lower and upper bounds
1488 // the total number of iterations in the loop is the sum of the arithmetic
1489 // progression from the outer lower to outer upper bound (inclusive since the
1490 // loop is canonical) note that less_than inner loops (inner_ub0 = -1)
1491 // effectively make the progression 1-based making N = (outer_ub0 - inner_lb0
1492 // + 1) -> N - 1
1495 // the current thread's number of iterations:
1496 // each thread gets an equal number of iterations: total number of iterations
1497 // divided by the number of threads plus, if there's a remainder,
1498 // the first threads with the number up to the remainder get an additional
1499 // iteration each to cover it
1500 kmp_uint64 iter_current =
1502 // cumulative number of iterations executed by all the previous threads:
1503 // threads with the tid below the remainder will have (iter_total/nth+1)
1504 // elements, and so will all threads before them so the cumulative number of
1505 // iterations executed by the all previous will be the current thread's number
1506 // of iterations multiplied by the number of previous threads which is equal
1507 // to the current thread's tid; threads with the number equal or above the
1508 // remainder will have (iter_total/nth) elements so the cumulative number of
1509 // iterations previously executed is its number of iterations multipled by the
1510 // number of previous threads which is again equal to the current thread's tid
1511 // PLUS all the remainder iterations that will have been executed by the
1512 // previous threads
1513 kmp_uint64 iter_before_current =
1515 // cumulative number of iterations executed with the current thread is
1516 // the cumulative number executed before it plus its own
1518 // calculate the outer loop lower bound (lbo) which is the max outer iv value
1519 // that gives the number of iterations that is equal or just below the total
1520 // number of iterations executed by the previous threads:
1521 // lbo*(lbo+1)/2<=iter_before_current =>
1522 // lbo^2+lbo-2*iter_before_current<=0
1523 kmp_uint64 lower_bound_outer =
1525 // calculate the inner loop lower bound which is the remaining number of
1526 // iterations required to hit the total number of iterations executed by the
1527 // previous threads giving the starting point of this thread
1528 kmp_uint64 lower_bound_inner =
1530 // calculate the outer loop upper bound using the same approach as for the
1531 // inner bound except using the total number of iterations executed with the
1532 // current thread
1533 kmp_uint64 upper_bound_outer =
1535 // calculate the inner loop upper bound which is the remaining number of
1536 // iterations required to hit the total number of iterations executed after
1537 // the current thread giving the starting point of the next thread
1538 kmp_uint64 upper_bound_inner =
1540 // adjust the upper bounds down by 1 element to point at the last iteration of
1541 // the current thread the first iteration of the next thread
1543 // {n,0} => {n-1,n-1}
1547 // {n,m} => {n,m-1} (m!=0)
1549 }
1551 // assign the values, zeroing out lb1 and ub1 values since the iteration space
1552 // is now one-dimensional
1562 #if 0
1566 #endif
1567 }
1568 //----------Init API for non-rectangular loops--------------------------------
1570 // Init API for collapsed loops (static, no chunks defined).
1571 // "bounds_nest" has to be allocated per thread.
1572 // API will modify original bounds_nest array to bring it to a canonical form
1573 // (only <= and >=, no !=, <, >). If the original loop nest was already in a
1574 // canonical form there will be no changes to bounds in bounds_nest array
1575 // (only trip counts will be calculated). Internally API will expand the space
1576 // to parallelogram/parallelepiped, calculate total, calculate bounds for the
1577 // chunks in terms of the new IV, re-calc them in terms of old IVs (especially
1578 // important on the left side, to hit the lower bounds and not step over), and
1579 // pick the correct chunk for this thread (so it will calculate chunks up to the
1580 // needed one). It could be optimized to calculate just this chunk, potentially
1581 // a bit less well distributed among threads. It is designed to make sure that
1582 // threads will receive predictable chunks, deterministically (so that next nest
1583 // of loops with similar characteristics will get exactly same chunks on same
1584 // threads).
1585 // Current contract: chunk_bounds_nest has only lb0 and ub0,
1586 // lb1 and ub1 are set to 0 and can be ignored. (This may change in the future).
1598 }
1606 }
1608 kmp_loop_nest_iv_t total =
1613 }
1616 // Loop won't execute:
1618 }
1620 // OMPTODO: DISTRIBUTE is not supported yet
1630 // Handle special cases
1631 nested_loop_type_t loop_type =
1635 chunk_bounds_nest);
1639 chunk_bounds_nest);
1641 }
1647 // Loop won't execute:
1649 }
1651 // Not doing this optimization for one thread:
1652 // (1) more to test
1653 // (2) without it current contract that chunk_bounds_nest has only lb0 and
1654 // ub0, lb1 and ub1 are set to 0 and can be ignored.
1655 // if (nth == 1) {
1656 // // One thread:
1657 // // Copy all info from original_bounds_nest, it'll be good enough.
1659 // for (kmp_index_t i = 0; i < n; ++i) {
1660 // chunk_bounds_nest[i] = original_bounds_nest[i];
1661 // }
1663 // if (plastiter != NULL) {
1664 // *plastiter = TRUE;
1665 // }
1666 // return TRUE;
1667 //}
1675 // We could calculate chunk size once, but this is to compensate that the
1676 // original space is not parallelepiped and some threads can be left
1677 // without work:
1689 }
1691 #if defined(KMP_DEBUG)
1693 #endif
1697 }
1701 // Do this one till the end - just in case we miscalculated
1702 // and either too much is left to process or new_iv is a bit too big:
1708 // Note: here we make sure it's past (or equal to) the previous point.
1710 updated_bounds_nest,
1713 // We could not find the ending point, use the original upper bounds:
1718 }
1719 }
1721 #if defined(KMP_DEBUG)
1725 #endif
1728 // We are done, this was last chunk, but no chunk for current thread was
1729 // found:
1731 }
1734 // We found the chunk for this thread, now we need to check if it's the
1735 // last chunk or not:
1741 // no more loop iterations left to process,
1742 // this means that currently found chunk is the last chunk:
1745 }
1746 }
1748 // Fill in chunk bounds:
1757 }
1760 }
1768 // no more loop iterations to process,
1769 // the prevoius chunk was the last chunk
1771 }
1773 // original_ivs_start is next to previous chunk original_ivs_end,
1774 // we need to start new chunk here, so chunks will be one after another
1775 // without any gap or overlap:
1778 }
1781 }