LLVM OpenMP* Runtime Library
kmp_sched.cpp
1 /*
2  * kmp_sched.cpp -- static scheduling -- iteration initialization
3  */
4 
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 //===----------------------------------------------------------------------===//
12 
13 /* Static scheduling initialization.
14 
15  NOTE: team->t.t_nproc is a constant inside of any dispatch loop, however
16  it may change values between parallel regions. __kmp_max_nth
17  is the largest value __kmp_nth may take, 1 is the smallest. */
18 
19 #include "kmp.h"
20 #include "kmp_error.h"
21 #include "kmp_i18n.h"
22 #include "kmp_itt.h"
23 #include "kmp_stats.h"
24 #include "kmp_str.h"
25 
26 #if OMPT_SUPPORT
27 #include "ompt-specific.h"
28 #endif
29 
30 #ifdef KMP_DEBUG
31 //-------------------------------------------------------------------------
32 // template for debug prints specification ( d, u, lld, llu )
33 char const *traits_t<int>::spec = "d";
34 char const *traits_t<unsigned int>::spec = "u";
35 char const *traits_t<long long>::spec = "lld";
36 char const *traits_t<unsigned long long>::spec = "llu";
37 char const *traits_t<long>::spec = "ld";
38 //-------------------------------------------------------------------------
39 #endif
40 
41 #if KMP_STATS_ENABLED
42 #define KMP_STATS_LOOP_END(stat) \
43  { \
44  kmp_int64 t; \
45  kmp_int64 u = (kmp_int64)(*pupper); \
46  kmp_int64 l = (kmp_int64)(*plower); \
47  kmp_int64 i = (kmp_int64)incr; \
48  if (i == 1) { \
49  t = u - l + 1; \
50  } else if (i == -1) { \
51  t = l - u + 1; \
52  } else if (i > 0) { \
53  t = (u - l) / i + 1; \
54  } else { \
55  KMP_DEBUG_ASSERT(i != 0); \
56  t = (l - u) / (-i) + 1; \
57  } \
58  KMP_COUNT_VALUE(stat, t); \
59  KMP_POP_PARTITIONED_TIMER(); \
60  }
61 #else
62 #define KMP_STATS_LOOP_END(stat) /* Nothing */
63 #endif
64 
65 #if USE_ITT_BUILD || defined KMP_DEBUG
66 static ident_t loc_stub = {0, KMP_IDENT_KMPC, 0, 0, ";unknown;unknown;0;0;;"};
67 static inline void check_loc(ident_t *&loc) {
68  if (loc == NULL)
69  loc = &loc_stub; // may need to report location info to ittnotify
70 }
71 #endif
72 
73 template <typename T>
74 static void __kmp_for_static_init(ident_t *loc, kmp_int32 global_tid,
75  kmp_int32 schedtype, kmp_int32 *plastiter,
76  T *plower, T *pupper,
77  typename traits_t<T>::signed_t *pstride,
78  typename traits_t<T>::signed_t incr,
79  typename traits_t<T>::signed_t chunk
80 #if OMPT_SUPPORT && OMPT_OPTIONAL
81  ,
82  void *codeptr
83 #endif
84 ) {
85  KMP_COUNT_BLOCK(OMP_LOOP_STATIC);
86  KMP_PUSH_PARTITIONED_TIMER(OMP_loop_static);
87  KMP_PUSH_PARTITIONED_TIMER(OMP_loop_static_scheduling);
88 
89  // Clear monotonic/nonmonotonic bits (ignore it)
90  schedtype = SCHEDULE_WITHOUT_MODIFIERS(schedtype);
91 
92  typedef typename traits_t<T>::unsigned_t UT;
93  typedef typename traits_t<T>::signed_t ST;
94  /* this all has to be changed back to TID and such.. */
95  kmp_int32 gtid = global_tid;
96  kmp_uint32 tid;
97  kmp_uint32 nth;
98  UT trip_count;
99  kmp_team_t *team;
100  __kmp_assert_valid_gtid(gtid);
101  kmp_info_t *th = __kmp_threads[gtid];
102 
103 #if OMPT_SUPPORT && OMPT_OPTIONAL
104  ompt_team_info_t *team_info = NULL;
105  ompt_task_info_t *task_info = NULL;
106  ompt_work_t ompt_work_type = ompt_work_loop_static;
107 
108  static kmp_int8 warn = 0;
109 
110  if (ompt_enabled.ompt_callback_work || ompt_enabled.ompt_callback_dispatch) {
111  // Only fully initialize variables needed by OMPT if OMPT is enabled.
112  team_info = __ompt_get_teaminfo(0, NULL);
113  task_info = __ompt_get_task_info_object(0);
114  // Determine workshare type
115  if (loc != NULL) {
116  if ((loc->flags & KMP_IDENT_WORK_LOOP) != 0) {
117  ompt_work_type = ompt_work_loop_static;
118  } else if ((loc->flags & KMP_IDENT_WORK_SECTIONS) != 0) {
119  ompt_work_type = ompt_work_sections;
120  } else if ((loc->flags & KMP_IDENT_WORK_DISTRIBUTE) != 0) {
121  ompt_work_type = ompt_work_distribute;
122  } else {
123  kmp_int8 bool_res =
124  KMP_COMPARE_AND_STORE_ACQ8(&warn, (kmp_int8)0, (kmp_int8)1);
125  if (bool_res)
126  KMP_WARNING(OmptOutdatedWorkshare);
127  }
128  KMP_DEBUG_ASSERT(ompt_work_type);
129  }
130  }
131 #endif
132 
133  KMP_DEBUG_ASSERT(plastiter && plower && pupper && pstride);
134  KE_TRACE(10, ("__kmpc_for_static_init called (%d)\n", global_tid));
135 #ifdef KMP_DEBUG
136  {
137  char *buff;
138  // create format specifiers before the debug output
139  buff = __kmp_str_format(
140  "__kmpc_for_static_init: T#%%d sched=%%d liter=%%d iter=(%%%s,"
141  " %%%s, %%%s) incr=%%%s chunk=%%%s signed?<%s>\n",
142  traits_t<T>::spec, traits_t<T>::spec, traits_t<ST>::spec,
143  traits_t<ST>::spec, traits_t<ST>::spec, traits_t<T>::spec);
144  KD_TRACE(100, (buff, global_tid, schedtype, *plastiter, *plower, *pupper,
145  *pstride, incr, chunk));
146  __kmp_str_free(&buff);
147  }
148 #endif
149 
150  if (__kmp_env_consistency_check) {
151  __kmp_push_workshare(global_tid, ct_pdo, loc);
152  if (incr == 0) {
153  __kmp_error_construct(kmp_i18n_msg_CnsLoopIncrZeroProhibited, ct_pdo,
154  loc);
155  }
156  }
157  /* special handling for zero-trip loops */
158  if (incr > 0 ? (*pupper < *plower) : (*plower < *pupper)) {
159  if (plastiter != NULL)
160  *plastiter = FALSE;
161  /* leave pupper and plower set to entire iteration space */
162  *pstride = incr; /* value should never be used */
163 // *plower = *pupper - incr;
164 // let compiler bypass the illegal loop (like for(i=1;i<10;i--))
165 // THE LINE COMMENTED ABOVE CAUSED shape2F/h_tests_1.f TO HAVE A FAILURE
166 // ON A ZERO-TRIP LOOP (lower=1, upper=0,stride=1) - JPH June 23, 2009.
167 #ifdef KMP_DEBUG
168  {
169  char *buff;
170  // create format specifiers before the debug output
171  buff = __kmp_str_format("__kmpc_for_static_init:(ZERO TRIP) liter=%%d "
172  "lower=%%%s upper=%%%s stride = %%%s "
173  "signed?<%s>, loc = %%s\n",
174  traits_t<T>::spec, traits_t<T>::spec,
175  traits_t<ST>::spec, traits_t<T>::spec);
176  check_loc(loc);
177  KD_TRACE(100,
178  (buff, *plastiter, *plower, *pupper, *pstride, loc->psource));
179  __kmp_str_free(&buff);
180  }
181 #endif
182  KE_TRACE(10, ("__kmpc_for_static_init: T#%d return\n", global_tid));
183 
184 #if OMPT_SUPPORT && OMPT_OPTIONAL
185  if (ompt_enabled.ompt_callback_work) {
186  ompt_callbacks.ompt_callback(ompt_callback_work)(
187  ompt_work_type, ompt_scope_begin, &(team_info->parallel_data),
188  &(task_info->task_data), 0, codeptr);
189  }
190 #endif
191  KMP_STATS_LOOP_END(OMP_loop_static_iterations);
192  return;
193  }
194 
195  // Although there are schedule enumerations above kmp_ord_upper which are not
196  // schedules for "distribute", the only ones which are useful are dynamic, so
197  // cannot be seen here, since this codepath is only executed for static
198  // schedules.
199  if (schedtype > kmp_ord_upper) {
200  // we are in DISTRIBUTE construct
201  schedtype += kmp_sch_static -
202  kmp_distribute_static; // AC: convert to usual schedule type
203  if (th->th.th_team->t.t_serialized > 1) {
204  tid = 0;
205  team = th->th.th_team;
206  } else {
207  tid = th->th.th_team->t.t_master_tid;
208  team = th->th.th_team->t.t_parent;
209  }
210  } else {
211  tid = __kmp_tid_from_gtid(global_tid);
212  team = th->th.th_team;
213  }
214 
215  /* determine if "for" loop is an active worksharing construct */
216  if (team->t.t_serialized) {
217  /* serialized parallel, each thread executes whole iteration space */
218  if (plastiter != NULL)
219  *plastiter = TRUE;
220  /* leave pupper and plower set to entire iteration space */
221  *pstride =
222  (incr > 0) ? (*pupper - *plower + 1) : (-(*plower - *pupper + 1));
223 
224 #ifdef KMP_DEBUG
225  {
226  char *buff;
227  // create format specifiers before the debug output
228  buff = __kmp_str_format("__kmpc_for_static_init: (serial) liter=%%d "
229  "lower=%%%s upper=%%%s stride = %%%s\n",
230  traits_t<T>::spec, traits_t<T>::spec,
231  traits_t<ST>::spec);
232  KD_TRACE(100, (buff, *plastiter, *plower, *pupper, *pstride));
233  __kmp_str_free(&buff);
234  }
235 #endif
236  KE_TRACE(10, ("__kmpc_for_static_init: T#%d return\n", global_tid));
237 
238 #if OMPT_SUPPORT && OMPT_OPTIONAL
239  if (ompt_enabled.ompt_callback_work) {
240  ompt_callbacks.ompt_callback(ompt_callback_work)(
241  ompt_work_type, ompt_scope_begin, &(team_info->parallel_data),
242  &(task_info->task_data), *pstride, codeptr);
243  }
244 #endif
245  KMP_STATS_LOOP_END(OMP_loop_static_iterations);
246  return;
247  }
248  nth = team->t.t_nproc;
249  if (nth == 1) {
250  if (plastiter != NULL)
251  *plastiter = TRUE;
252  *pstride =
253  (incr > 0) ? (*pupper - *plower + 1) : (-(*plower - *pupper + 1));
254 #ifdef KMP_DEBUG
255  {
256  char *buff;
257  // create format specifiers before the debug output
258  buff = __kmp_str_format("__kmpc_for_static_init: (serial) liter=%%d "
259  "lower=%%%s upper=%%%s stride = %%%s\n",
260  traits_t<T>::spec, traits_t<T>::spec,
261  traits_t<ST>::spec);
262  KD_TRACE(100, (buff, *plastiter, *plower, *pupper, *pstride));
263  __kmp_str_free(&buff);
264  }
265 #endif
266  KE_TRACE(10, ("__kmpc_for_static_init: T#%d return\n", global_tid));
267 
268 #if OMPT_SUPPORT && OMPT_OPTIONAL
269  if (ompt_enabled.ompt_callback_work) {
270  ompt_callbacks.ompt_callback(ompt_callback_work)(
271  ompt_work_type, ompt_scope_begin, &(team_info->parallel_data),
272  &(task_info->task_data), *pstride, codeptr);
273  }
274 #endif
275  KMP_STATS_LOOP_END(OMP_loop_static_iterations);
276  return;
277  }
278 
279  /* compute trip count */
280  if (incr == 1) {
281  trip_count = *pupper - *plower + 1;
282  } else if (incr == -1) {
283  trip_count = *plower - *pupper + 1;
284  } else if (incr > 0) {
285  // upper-lower can exceed the limit of signed type
286  trip_count = (UT)(*pupper - *plower) / incr + 1;
287  } else {
288  KMP_DEBUG_ASSERT(incr != 0);
289  trip_count = (UT)(*plower - *pupper) / (-incr) + 1;
290  }
291 
292 #if KMP_STATS_ENABLED
293  if (KMP_MASTER_GTID(gtid)) {
294  KMP_COUNT_VALUE(OMP_loop_static_total_iterations, trip_count);
295  }
296 #endif
297 
298  if (__kmp_env_consistency_check) {
299  /* tripcount overflow? */
300  if (trip_count == 0 && *pupper != *plower) {
301  __kmp_error_construct(kmp_i18n_msg_CnsIterationRangeTooLarge, ct_pdo,
302  loc);
303  }
304  }
305 
306  /* compute remaining parameters */
307  switch (schedtype) {
308  case kmp_sch_static: {
309  if (trip_count < nth) {
310  KMP_DEBUG_ASSERT(
311  __kmp_static == kmp_sch_static_greedy ||
312  __kmp_static ==
313  kmp_sch_static_balanced); // Unknown static scheduling type.
314  if (tid < trip_count) {
315  *pupper = *plower = *plower + tid * incr;
316  } else {
317  // set bounds so non-active threads execute no iterations
318  *plower = *pupper + (incr > 0 ? 1 : -1);
319  }
320  if (plastiter != NULL)
321  *plastiter = (tid == trip_count - 1);
322  } else {
323  KMP_DEBUG_ASSERT(nth != 0);
324  if (__kmp_static == kmp_sch_static_balanced) {
325  UT small_chunk = trip_count / nth;
326  UT extras = trip_count % nth;
327  *plower += incr * (tid * small_chunk + (tid < extras ? tid : extras));
328  *pupper = *plower + small_chunk * incr - (tid < extras ? 0 : incr);
329  if (plastiter != NULL)
330  *plastiter = (tid == nth - 1);
331  } else {
332  T big_chunk_inc_count =
333  (trip_count / nth + ((trip_count % nth) ? 1 : 0)) * incr;
334  T old_upper = *pupper;
335 
336  KMP_DEBUG_ASSERT(__kmp_static == kmp_sch_static_greedy);
337  // Unknown static scheduling type.
338 
339  *plower += tid * big_chunk_inc_count;
340  *pupper = *plower + big_chunk_inc_count - incr;
341  if (incr > 0) {
342  if (*pupper < *plower)
343  *pupper = traits_t<T>::max_value;
344  if (plastiter != NULL)
345  *plastiter = *plower <= old_upper && *pupper > old_upper - incr;
346  if (*pupper > old_upper)
347  *pupper = old_upper; // tracker C73258
348  } else {
349  if (*pupper > *plower)
350  *pupper = traits_t<T>::min_value;
351  if (plastiter != NULL)
352  *plastiter = *plower >= old_upper && *pupper < old_upper - incr;
353  if (*pupper < old_upper)
354  *pupper = old_upper; // tracker C73258
355  }
356  }
357  }
358  *pstride = trip_count;
359  break;
360  }
361  case kmp_sch_static_chunked: {
362  ST span;
363  UT nchunks;
364  KMP_DEBUG_ASSERT(chunk != 0);
365  if (chunk < 1)
366  chunk = 1;
367  else if ((UT)chunk > trip_count)
368  chunk = trip_count;
369  nchunks = (trip_count) / (UT)chunk + (trip_count % (UT)chunk ? 1 : 0);
370  span = chunk * incr;
371  if (nchunks < nth) {
372  *pstride = span * nchunks;
373  if (tid < nchunks) {
374  *plower = *plower + (span * tid);
375  *pupper = *plower + span - incr;
376  } else {
377  *plower = *pupper + (incr > 0 ? 1 : -1);
378  }
379  } else {
380  *pstride = span * nth;
381  *plower = *plower + (span * tid);
382  *pupper = *plower + span - incr;
383  }
384  if (plastiter != NULL)
385  *plastiter = (tid == (nchunks - 1) % nth);
386  break;
387  }
388  case kmp_sch_static_balanced_chunked: {
389  T old_upper = *pupper;
390  KMP_DEBUG_ASSERT(nth != 0);
391  // round up to make sure the chunk is enough to cover all iterations
392  UT span = (trip_count + nth - 1) / nth;
393 
394  // perform chunk adjustment
395  chunk = (span + chunk - 1) & ~(chunk - 1);
396 
397  span = chunk * incr;
398  *plower = *plower + (span * tid);
399  *pupper = *plower + span - incr;
400  if (incr > 0) {
401  if (*pupper > old_upper)
402  *pupper = old_upper;
403  } else if (*pupper < old_upper)
404  *pupper = old_upper;
405 
406  if (plastiter != NULL) {
407  KMP_DEBUG_ASSERT(chunk != 0);
408  *plastiter = (tid == ((trip_count - 1) / (UT)chunk));
409  }
410  break;
411  }
412  default:
413  KMP_ASSERT2(0, "__kmpc_for_static_init: unknown scheduling type");
414  break;
415  }
416 
417 #if USE_ITT_BUILD
418  // Report loop metadata
419  if (KMP_MASTER_TID(tid) && __itt_metadata_add_ptr &&
420  __kmp_forkjoin_frames_mode == 3 && th->th.th_teams_microtask == NULL &&
421  team->t.t_active_level == 1) {
422  kmp_uint64 cur_chunk = chunk;
423  check_loc(loc);
424  // Calculate chunk in case it was not specified; it is specified for
425  // kmp_sch_static_chunked
426  if (schedtype == kmp_sch_static) {
427  KMP_DEBUG_ASSERT(nth != 0);
428  cur_chunk = trip_count / nth + ((trip_count % nth) ? 1 : 0);
429  }
430  // 0 - "static" schedule
431  __kmp_itt_metadata_loop(loc, 0, trip_count, cur_chunk);
432  }
433 #endif
434 #ifdef KMP_DEBUG
435  {
436  char *buff;
437  // create format specifiers before the debug output
438  buff = __kmp_str_format("__kmpc_for_static_init: liter=%%d lower=%%%s "
439  "upper=%%%s stride = %%%s signed?<%s>\n",
440  traits_t<T>::spec, traits_t<T>::spec,
441  traits_t<ST>::spec, traits_t<T>::spec);
442  KD_TRACE(100, (buff, *plastiter, *plower, *pupper, *pstride));
443  __kmp_str_free(&buff);
444  }
445 #endif
446  KE_TRACE(10, ("__kmpc_for_static_init: T#%d return\n", global_tid));
447 
448 #if OMPT_SUPPORT && OMPT_OPTIONAL
449  if (ompt_enabled.ompt_callback_work) {
450  ompt_callbacks.ompt_callback(ompt_callback_work)(
451  ompt_work_type, ompt_scope_begin, &(team_info->parallel_data),
452  &(task_info->task_data), trip_count, codeptr);
453  }
454  if (ompt_enabled.ompt_callback_dispatch) {
455  ompt_dispatch_t dispatch_type;
456  ompt_data_t instance = ompt_data_none;
457  ompt_dispatch_chunk_t dispatch_chunk;
458  if (ompt_work_type == ompt_work_sections) {
459  dispatch_type = ompt_dispatch_section;
460  instance.ptr = codeptr;
461  } else {
462  OMPT_GET_DISPATCH_CHUNK(dispatch_chunk, *plower, *pupper, incr);
463  dispatch_type = (ompt_work_type == ompt_work_distribute)
464  ? ompt_dispatch_distribute_chunk
465  : ompt_dispatch_ws_loop_chunk;
466  instance.ptr = &dispatch_chunk;
467  }
468  ompt_callbacks.ompt_callback(ompt_callback_dispatch)(
469  &(team_info->parallel_data), &(task_info->task_data), dispatch_type,
470  instance);
471  }
472 #endif
473 
474  KMP_STATS_LOOP_END(OMP_loop_static_iterations);
475  return;
476 }
477 
478 template <typename T>
479 static void __kmp_dist_for_static_init(ident_t *loc, kmp_int32 gtid,
480  kmp_int32 schedule, kmp_int32 *plastiter,
481  T *plower, T *pupper, T *pupperDist,
482  typename traits_t<T>::signed_t *pstride,
483  typename traits_t<T>::signed_t incr,
484  typename traits_t<T>::signed_t chunk
485 #if OMPT_SUPPORT && OMPT_OPTIONAL
486  ,
487  void *codeptr
488 #endif
489 ) {
490  KMP_COUNT_BLOCK(OMP_DISTRIBUTE);
491  KMP_PUSH_PARTITIONED_TIMER(OMP_distribute);
492  KMP_PUSH_PARTITIONED_TIMER(OMP_distribute_scheduling);
493  typedef typename traits_t<T>::unsigned_t UT;
494  typedef typename traits_t<T>::signed_t ST;
495  kmp_uint32 tid;
496  kmp_uint32 nth;
497  kmp_uint32 team_id;
498  kmp_uint32 nteams;
499  UT trip_count;
500  kmp_team_t *team;
501  kmp_info_t *th;
502 
503  KMP_DEBUG_ASSERT(plastiter && plower && pupper && pupperDist && pstride);
504  KE_TRACE(10, ("__kmpc_dist_for_static_init called (%d)\n", gtid));
505  __kmp_assert_valid_gtid(gtid);
506 #ifdef KMP_DEBUG
507  {
508  char *buff;
509  // create format specifiers before the debug output
510  buff = __kmp_str_format(
511  "__kmpc_dist_for_static_init: T#%%d schedLoop=%%d liter=%%d "
512  "iter=(%%%s, %%%s, %%%s) chunk=%%%s signed?<%s>\n",
513  traits_t<T>::spec, traits_t<T>::spec, traits_t<ST>::spec,
514  traits_t<ST>::spec, traits_t<T>::spec);
515  KD_TRACE(100,
516  (buff, gtid, schedule, *plastiter, *plower, *pupper, incr, chunk));
517  __kmp_str_free(&buff);
518  }
519 #endif
520 
521  if (__kmp_env_consistency_check) {
522  __kmp_push_workshare(gtid, ct_pdo, loc);
523  if (incr == 0) {
524  __kmp_error_construct(kmp_i18n_msg_CnsLoopIncrZeroProhibited, ct_pdo,
525  loc);
526  }
527  if (incr > 0 ? (*pupper < *plower) : (*plower < *pupper)) {
528  // The loop is illegal.
529  // Some zero-trip loops maintained by compiler, e.g.:
530  // for(i=10;i<0;++i) // lower >= upper - run-time check
531  // for(i=0;i>10;--i) // lower <= upper - run-time check
532  // for(i=0;i>10;++i) // incr > 0 - compile-time check
533  // for(i=10;i<0;--i) // incr < 0 - compile-time check
534  // Compiler does not check the following illegal loops:
535  // for(i=0;i<10;i+=incr) // where incr<0
536  // for(i=10;i>0;i-=incr) // where incr<0
537  __kmp_error_construct(kmp_i18n_msg_CnsLoopIncrIllegal, ct_pdo, loc);
538  }
539  }
540  tid = __kmp_tid_from_gtid(gtid);
541  th = __kmp_threads[gtid];
542  nth = th->th.th_team_nproc;
543  team = th->th.th_team;
544  KMP_DEBUG_ASSERT(th->th.th_teams_microtask); // we are in the teams construct
545  // skip optional serialized teams to prevent this from using the wrong teams
546  // information when called after __kmp_serialized_parallel
547  // TODO: make __kmp_serialized_parallel eventually call __kmp_fork_in_teams
548  // to address this edge case
549  while (team->t.t_parent && team->t.t_serialized)
550  team = team->t.t_parent;
551  nteams = th->th.th_teams_size.nteams;
552  team_id = team->t.t_master_tid;
553  KMP_DEBUG_ASSERT(nteams == (kmp_uint32)team->t.t_parent->t.t_nproc);
554 
555  // compute global trip count
556  if (incr == 1) {
557  trip_count = *pupper - *plower + 1;
558  } else if (incr == -1) {
559  trip_count = *plower - *pupper + 1;
560  } else if (incr > 0) {
561  // upper-lower can exceed the limit of signed type
562  trip_count = (UT)(*pupper - *plower) / incr + 1;
563  } else {
564  KMP_DEBUG_ASSERT(incr != 0);
565  trip_count = (UT)(*plower - *pupper) / (-incr) + 1;
566  }
567 
568  *pstride = *pupper - *plower; // just in case (can be unused)
569  if (trip_count <= nteams) {
570  KMP_DEBUG_ASSERT(
571  __kmp_static == kmp_sch_static_greedy ||
572  __kmp_static ==
573  kmp_sch_static_balanced); // Unknown static scheduling type.
574  // only primary threads of some teams get single iteration, other threads
575  // get nothing
576  if (team_id < trip_count && tid == 0) {
577  *pupper = *pupperDist = *plower = *plower + team_id * incr;
578  } else {
579  *pupperDist = *pupper;
580  *plower = *pupper + incr; // compiler should skip loop body
581  }
582  if (plastiter != NULL)
583  *plastiter = (tid == 0 && team_id == trip_count - 1);
584  } else {
585  // Get the team's chunk first (each team gets at most one chunk)
586  KMP_DEBUG_ASSERT(nteams != 0);
587  if (__kmp_static == kmp_sch_static_balanced) {
588  UT chunkD = trip_count / nteams;
589  UT extras = trip_count % nteams;
590  *plower +=
591  incr * (team_id * chunkD + (team_id < extras ? team_id : extras));
592  *pupperDist = *plower + chunkD * incr - (team_id < extras ? 0 : incr);
593  if (plastiter != NULL)
594  *plastiter = (team_id == nteams - 1);
595  } else {
596  T chunk_inc_count =
597  (trip_count / nteams + ((trip_count % nteams) ? 1 : 0)) * incr;
598  T upper = *pupper;
599  KMP_DEBUG_ASSERT(__kmp_static == kmp_sch_static_greedy);
600  // Unknown static scheduling type.
601  *plower += team_id * chunk_inc_count;
602  *pupperDist = *plower + chunk_inc_count - incr;
603  // Check/correct bounds if needed
604  if (incr > 0) {
605  if (*pupperDist < *plower)
606  *pupperDist = traits_t<T>::max_value;
607  if (plastiter != NULL)
608  *plastiter = *plower <= upper && *pupperDist > upper - incr;
609  if (*pupperDist > upper)
610  *pupperDist = upper; // tracker C73258
611  if (*plower > *pupperDist) {
612  *pupper = *pupperDist; // no iterations available for the team
613  goto end;
614  }
615  } else {
616  if (*pupperDist > *plower)
617  *pupperDist = traits_t<T>::min_value;
618  if (plastiter != NULL)
619  *plastiter = *plower >= upper && *pupperDist < upper - incr;
620  if (*pupperDist < upper)
621  *pupperDist = upper; // tracker C73258
622  if (*plower < *pupperDist) {
623  *pupper = *pupperDist; // no iterations available for the team
624  goto end;
625  }
626  }
627  }
628  // Get the parallel loop chunk now (for thread)
629  // compute trip count for team's chunk
630  if (incr == 1) {
631  trip_count = *pupperDist - *plower + 1;
632  } else if (incr == -1) {
633  trip_count = *plower - *pupperDist + 1;
634  } else if (incr > 1) {
635  // upper-lower can exceed the limit of signed type
636  trip_count = (UT)(*pupperDist - *plower) / incr + 1;
637  } else {
638  KMP_DEBUG_ASSERT(incr != 0);
639  trip_count = (UT)(*plower - *pupperDist) / (-incr) + 1;
640  }
641  KMP_DEBUG_ASSERT(trip_count);
642  switch (schedule) {
643  case kmp_sch_static: {
644  if (trip_count <= nth) {
645  KMP_DEBUG_ASSERT(
646  __kmp_static == kmp_sch_static_greedy ||
647  __kmp_static ==
648  kmp_sch_static_balanced); // Unknown static scheduling type.
649  if (tid < trip_count)
650  *pupper = *plower = *plower + tid * incr;
651  else
652  *plower = *pupper + incr; // no iterations available
653  if (plastiter != NULL)
654  if (*plastiter != 0 && !(tid == trip_count - 1))
655  *plastiter = 0;
656  } else {
657  KMP_DEBUG_ASSERT(nth != 0);
658  if (__kmp_static == kmp_sch_static_balanced) {
659  UT chunkL = trip_count / nth;
660  UT extras = trip_count % nth;
661  *plower += incr * (tid * chunkL + (tid < extras ? tid : extras));
662  *pupper = *plower + chunkL * incr - (tid < extras ? 0 : incr);
663  if (plastiter != NULL)
664  if (*plastiter != 0 && !(tid == nth - 1))
665  *plastiter = 0;
666  } else {
667  T chunk_inc_count =
668  (trip_count / nth + ((trip_count % nth) ? 1 : 0)) * incr;
669  T upper = *pupperDist;
670  KMP_DEBUG_ASSERT(__kmp_static == kmp_sch_static_greedy);
671  // Unknown static scheduling type.
672  *plower += tid * chunk_inc_count;
673  *pupper = *plower + chunk_inc_count - incr;
674  if (incr > 0) {
675  if (*pupper < *plower)
676  *pupper = traits_t<T>::max_value;
677  if (plastiter != NULL)
678  if (*plastiter != 0 &&
679  !(*plower <= upper && *pupper > upper - incr))
680  *plastiter = 0;
681  if (*pupper > upper)
682  *pupper = upper; // tracker C73258
683  } else {
684  if (*pupper > *plower)
685  *pupper = traits_t<T>::min_value;
686  if (plastiter != NULL)
687  if (*plastiter != 0 &&
688  !(*plower >= upper && *pupper < upper - incr))
689  *plastiter = 0;
690  if (*pupper < upper)
691  *pupper = upper; // tracker C73258
692  }
693  }
694  }
695  break;
696  }
697  case kmp_sch_static_chunked: {
698  ST span;
699  if (chunk < 1)
700  chunk = 1;
701  span = chunk * incr;
702  *pstride = span * nth;
703  *plower = *plower + (span * tid);
704  *pupper = *plower + span - incr;
705  if (plastiter != NULL) {
706  KMP_DEBUG_ASSERT(chunk != 0);
707  if (*plastiter != 0 && !(tid == ((trip_count - 1) / (UT)chunk) % nth))
708  *plastiter = 0;
709  }
710  break;
711  }
712  default:
713  KMP_ASSERT2(0,
714  "__kmpc_dist_for_static_init: unknown loop scheduling type");
715  break;
716  }
717  }
718 end:;
719 #ifdef KMP_DEBUG
720  {
721  char *buff;
722  // create format specifiers before the debug output
723  buff = __kmp_str_format(
724  "__kmpc_dist_for_static_init: last=%%d lo=%%%s up=%%%s upDist=%%%s "
725  "stride=%%%s signed?<%s>\n",
726  traits_t<T>::spec, traits_t<T>::spec, traits_t<T>::spec,
727  traits_t<ST>::spec, traits_t<T>::spec);
728  KD_TRACE(100, (buff, *plastiter, *plower, *pupper, *pupperDist, *pstride));
729  __kmp_str_free(&buff);
730  }
731 #endif
732  KE_TRACE(10, ("__kmpc_dist_for_static_init: T#%d return\n", gtid));
733 #if OMPT_SUPPORT && OMPT_OPTIONAL
734  if (ompt_enabled.ompt_callback_work || ompt_enabled.ompt_callback_dispatch) {
735  ompt_team_info_t *team_info = __ompt_get_teaminfo(0, NULL);
736  ompt_task_info_t *task_info = __ompt_get_task_info_object(0);
737  if (ompt_enabled.ompt_callback_work) {
738  ompt_callbacks.ompt_callback(ompt_callback_work)(
739  ompt_work_distribute, ompt_scope_begin, &(team_info->parallel_data),
740  &(task_info->task_data), 0, codeptr);
741  }
742  if (ompt_enabled.ompt_callback_dispatch) {
743  ompt_data_t instance = ompt_data_none;
744  ompt_dispatch_chunk_t dispatch_chunk;
745  OMPT_GET_DISPATCH_CHUNK(dispatch_chunk, *plower, *pupperDist, incr);
746  instance.ptr = &dispatch_chunk;
747  ompt_callbacks.ompt_callback(ompt_callback_dispatch)(
748  &(team_info->parallel_data), &(task_info->task_data),
749  ompt_dispatch_distribute_chunk, instance);
750  }
751  }
752 #endif // OMPT_SUPPORT && OMPT_OPTIONAL
753  KMP_STATS_LOOP_END(OMP_distribute_iterations);
754  return;
755 }
756 
757 template <typename T>
758 static void __kmp_team_static_init(ident_t *loc, kmp_int32 gtid,
759  kmp_int32 *p_last, T *p_lb, T *p_ub,
760  typename traits_t<T>::signed_t *p_st,
761  typename traits_t<T>::signed_t incr,
762  typename traits_t<T>::signed_t chunk) {
763  // The routine returns the first chunk distributed to the team and
764  // stride for next chunks calculation.
765  // Last iteration flag set for the team that will execute
766  // the last iteration of the loop.
767  // The routine is called for dist_schedule(static,chunk) only.
768  typedef typename traits_t<T>::unsigned_t UT;
769  typedef typename traits_t<T>::signed_t ST;
770  kmp_uint32 team_id;
771  kmp_uint32 nteams;
772  UT trip_count;
773  T lower;
774  T upper;
775  ST span;
776  kmp_team_t *team;
777  kmp_info_t *th;
778 
779  KMP_DEBUG_ASSERT(p_last && p_lb && p_ub && p_st);
780  KE_TRACE(10, ("__kmp_team_static_init called (%d)\n", gtid));
781  __kmp_assert_valid_gtid(gtid);
782 #ifdef KMP_DEBUG
783  {
784  char *buff;
785  // create format specifiers before the debug output
786  buff = __kmp_str_format("__kmp_team_static_init enter: T#%%d liter=%%d "
787  "iter=(%%%s, %%%s, %%%s) chunk %%%s; signed?<%s>\n",
788  traits_t<T>::spec, traits_t<T>::spec,
789  traits_t<ST>::spec, traits_t<ST>::spec,
790  traits_t<T>::spec);
791  KD_TRACE(100, (buff, gtid, *p_last, *p_lb, *p_ub, *p_st, chunk));
792  __kmp_str_free(&buff);
793  }
794 #endif
795 
796  lower = *p_lb;
797  upper = *p_ub;
798  if (__kmp_env_consistency_check) {
799  if (incr == 0) {
800  __kmp_error_construct(kmp_i18n_msg_CnsLoopIncrZeroProhibited, ct_pdo,
801  loc);
802  }
803  if (incr > 0 ? (upper < lower) : (lower < upper)) {
804  // The loop is illegal.
805  // Some zero-trip loops maintained by compiler, e.g.:
806  // for(i=10;i<0;++i) // lower >= upper - run-time check
807  // for(i=0;i>10;--i) // lower <= upper - run-time check
808  // for(i=0;i>10;++i) // incr > 0 - compile-time check
809  // for(i=10;i<0;--i) // incr < 0 - compile-time check
810  // Compiler does not check the following illegal loops:
811  // for(i=0;i<10;i+=incr) // where incr<0
812  // for(i=10;i>0;i-=incr) // where incr<0
813  __kmp_error_construct(kmp_i18n_msg_CnsLoopIncrIllegal, ct_pdo, loc);
814  }
815  }
816  th = __kmp_threads[gtid];
817  team = th->th.th_team;
818  KMP_DEBUG_ASSERT(th->th.th_teams_microtask); // we are in the teams construct
819  nteams = th->th.th_teams_size.nteams;
820  team_id = team->t.t_master_tid;
821  KMP_DEBUG_ASSERT(nteams == (kmp_uint32)team->t.t_parent->t.t_nproc);
822 
823  // compute trip count
824  if (incr == 1) {
825  trip_count = upper - lower + 1;
826  } else if (incr == -1) {
827  trip_count = lower - upper + 1;
828  } else if (incr > 0) {
829  // upper-lower can exceed the limit of signed type
830  trip_count = (UT)(upper - lower) / incr + 1;
831  } else {
832  KMP_DEBUG_ASSERT(incr != 0);
833  trip_count = (UT)(lower - upper) / (-incr) + 1;
834  }
835  if (chunk < 1)
836  chunk = 1;
837  span = chunk * incr;
838  *p_st = span * nteams;
839  *p_lb = lower + (span * team_id);
840  *p_ub = *p_lb + span - incr;
841  if (p_last != NULL) {
842  KMP_DEBUG_ASSERT(chunk != 0);
843  *p_last = (team_id == ((trip_count - 1) / (UT)chunk) % nteams);
844  }
845  // Correct upper bound if needed
846  if (incr > 0) {
847  if (*p_ub < *p_lb) // overflow?
848  *p_ub = traits_t<T>::max_value;
849  if (*p_ub > upper)
850  *p_ub = upper; // tracker C73258
851  } else { // incr < 0
852  if (*p_ub > *p_lb)
853  *p_ub = traits_t<T>::min_value;
854  if (*p_ub < upper)
855  *p_ub = upper; // tracker C73258
856  }
857 #ifdef KMP_DEBUG
858  {
859  char *buff;
860  // create format specifiers before the debug output
861  buff =
862  __kmp_str_format("__kmp_team_static_init exit: T#%%d team%%u liter=%%d "
863  "iter=(%%%s, %%%s, %%%s) chunk %%%s\n",
864  traits_t<T>::spec, traits_t<T>::spec,
865  traits_t<ST>::spec, traits_t<ST>::spec);
866  KD_TRACE(100, (buff, gtid, team_id, *p_last, *p_lb, *p_ub, *p_st, chunk));
867  __kmp_str_free(&buff);
868  }
869 #endif
870 }
871 
872 //------------------------------------------------------------------------------
873 extern "C" {
895 void __kmpc_for_static_init_4(ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype,
896  kmp_int32 *plastiter, kmp_int32 *plower,
897  kmp_int32 *pupper, kmp_int32 *pstride,
898  kmp_int32 incr, kmp_int32 chunk) {
899  __kmp_for_static_init<kmp_int32>(loc, gtid, schedtype, plastiter, plower,
900  pupper, pstride, incr, chunk
901 #if OMPT_SUPPORT && OMPT_OPTIONAL
902  ,
903  OMPT_GET_RETURN_ADDRESS(0)
904 #endif
905  );
906 }
907 
911 void __kmpc_for_static_init_4u(ident_t *loc, kmp_int32 gtid,
912  kmp_int32 schedtype, kmp_int32 *plastiter,
913  kmp_uint32 *plower, kmp_uint32 *pupper,
914  kmp_int32 *pstride, kmp_int32 incr,
915  kmp_int32 chunk) {
916  __kmp_for_static_init<kmp_uint32>(loc, gtid, schedtype, plastiter, plower,
917  pupper, pstride, incr, chunk
918 #if OMPT_SUPPORT && OMPT_OPTIONAL
919  ,
920  OMPT_GET_RETURN_ADDRESS(0)
921 #endif
922  );
923 }
924 
928 void __kmpc_for_static_init_8(ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype,
929  kmp_int32 *plastiter, kmp_int64 *plower,
930  kmp_int64 *pupper, kmp_int64 *pstride,
931  kmp_int64 incr, kmp_int64 chunk) {
932  __kmp_for_static_init<kmp_int64>(loc, gtid, schedtype, plastiter, plower,
933  pupper, pstride, incr, chunk
934 #if OMPT_SUPPORT && OMPT_OPTIONAL
935  ,
936  OMPT_GET_RETURN_ADDRESS(0)
937 #endif
938  );
939 }
940 
944 void __kmpc_for_static_init_8u(ident_t *loc, kmp_int32 gtid,
945  kmp_int32 schedtype, kmp_int32 *plastiter,
946  kmp_uint64 *plower, kmp_uint64 *pupper,
947  kmp_int64 *pstride, kmp_int64 incr,
948  kmp_int64 chunk) {
949  __kmp_for_static_init<kmp_uint64>(loc, gtid, schedtype, plastiter, plower,
950  pupper, pstride, incr, chunk
951 #if OMPT_SUPPORT && OMPT_OPTIONAL
952  ,
953  OMPT_GET_RETURN_ADDRESS(0)
954 #endif
955  );
956 }
961 #if OMPT_SUPPORT && OMPT_OPTIONAL
962 #define OMPT_CODEPTR_ARG , OMPT_GET_RETURN_ADDRESS(0)
963 #else
964 #define OMPT_CODEPTR_ARG
965 #endif
966 
989 void __kmpc_dist_for_static_init_4(ident_t *loc, kmp_int32 gtid,
990  kmp_int32 schedule, kmp_int32 *plastiter,
991  kmp_int32 *plower, kmp_int32 *pupper,
992  kmp_int32 *pupperD, kmp_int32 *pstride,
993  kmp_int32 incr, kmp_int32 chunk) {
994  __kmp_dist_for_static_init<kmp_int32>(loc, gtid, schedule, plastiter, plower,
995  pupper, pupperD, pstride, incr,
996  chunk OMPT_CODEPTR_ARG);
997 }
998 
1002 void __kmpc_dist_for_static_init_4u(ident_t *loc, kmp_int32 gtid,
1003  kmp_int32 schedule, kmp_int32 *plastiter,
1004  kmp_uint32 *plower, kmp_uint32 *pupper,
1005  kmp_uint32 *pupperD, kmp_int32 *pstride,
1006  kmp_int32 incr, kmp_int32 chunk) {
1007  __kmp_dist_for_static_init<kmp_uint32>(loc, gtid, schedule, plastiter, plower,
1008  pupper, pupperD, pstride, incr,
1009  chunk OMPT_CODEPTR_ARG);
1010 }
1011 
1015 void __kmpc_dist_for_static_init_8(ident_t *loc, kmp_int32 gtid,
1016  kmp_int32 schedule, kmp_int32 *plastiter,
1017  kmp_int64 *plower, kmp_int64 *pupper,
1018  kmp_int64 *pupperD, kmp_int64 *pstride,
1019  kmp_int64 incr, kmp_int64 chunk) {
1020  __kmp_dist_for_static_init<kmp_int64>(loc, gtid, schedule, plastiter, plower,
1021  pupper, pupperD, pstride, incr,
1022  chunk OMPT_CODEPTR_ARG);
1023 }
1024 
1028 void __kmpc_dist_for_static_init_8u(ident_t *loc, kmp_int32 gtid,
1029  kmp_int32 schedule, kmp_int32 *plastiter,
1030  kmp_uint64 *plower, kmp_uint64 *pupper,
1031  kmp_uint64 *pupperD, kmp_int64 *pstride,
1032  kmp_int64 incr, kmp_int64 chunk) {
1033  __kmp_dist_for_static_init<kmp_uint64>(loc, gtid, schedule, plastiter, plower,
1034  pupper, pupperD, pstride, incr,
1035  chunk OMPT_CODEPTR_ARG);
1036 }
1041 //------------------------------------------------------------------------------
1042 // Auxiliary routines for Distribute Parallel Loop construct implementation
1043 // Transfer call to template< type T >
1044 // __kmp_team_static_init( ident_t *loc, int gtid,
1045 // int *p_last, T *lb, T *ub, ST *st, ST incr, ST chunk )
1046 
1067 void __kmpc_team_static_init_4(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
1068  kmp_int32 *p_lb, kmp_int32 *p_ub,
1069  kmp_int32 *p_st, kmp_int32 incr,
1070  kmp_int32 chunk) {
1071  KMP_DEBUG_ASSERT(__kmp_init_serial);
1072  __kmp_team_static_init<kmp_int32>(loc, gtid, p_last, p_lb, p_ub, p_st, incr,
1073  chunk);
1074 }
1075 
1079 void __kmpc_team_static_init_4u(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
1080  kmp_uint32 *p_lb, kmp_uint32 *p_ub,
1081  kmp_int32 *p_st, kmp_int32 incr,
1082  kmp_int32 chunk) {
1083  KMP_DEBUG_ASSERT(__kmp_init_serial);
1084  __kmp_team_static_init<kmp_uint32>(loc, gtid, p_last, p_lb, p_ub, p_st, incr,
1085  chunk);
1086 }
1087 
1091 void __kmpc_team_static_init_8(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
1092  kmp_int64 *p_lb, kmp_int64 *p_ub,
1093  kmp_int64 *p_st, kmp_int64 incr,
1094  kmp_int64 chunk) {
1095  KMP_DEBUG_ASSERT(__kmp_init_serial);
1096  __kmp_team_static_init<kmp_int64>(loc, gtid, p_last, p_lb, p_ub, p_st, incr,
1097  chunk);
1098 }
1099 
1103 void __kmpc_team_static_init_8u(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
1104  kmp_uint64 *p_lb, kmp_uint64 *p_ub,
1105  kmp_int64 *p_st, kmp_int64 incr,
1106  kmp_int64 chunk) {
1107  KMP_DEBUG_ASSERT(__kmp_init_serial);
1108  __kmp_team_static_init<kmp_uint64>(loc, gtid, p_last, p_lb, p_ub, p_st, incr,
1109  chunk);
1110 }
1115 } // extern "C"
@ KMP_IDENT_KMPC
Definition: kmp.h:209
@ KMP_IDENT_WORK_LOOP
Definition: kmp.h:227
@ KMP_IDENT_WORK_SECTIONS
Definition: kmp.h:229
@ KMP_IDENT_WORK_DISTRIBUTE
Definition: kmp.h:231
#define KMP_COUNT_VALUE(name, value)
Adds value to specified timer (name).
Definition: kmp_stats.h:898
#define KMP_COUNT_BLOCK(name)
Increments specified counter (name).
Definition: kmp_stats.h:911
void __kmpc_for_static_init_8(ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype, kmp_int32 *plastiter, kmp_int64 *plower, kmp_int64 *pupper, kmp_int64 *pstride, kmp_int64 incr, kmp_int64 chunk)
Definition: kmp_sched.cpp:928
void __kmpc_dist_for_static_init_8(ident_t *loc, kmp_int32 gtid, kmp_int32 schedule, kmp_int32 *plastiter, kmp_int64 *plower, kmp_int64 *pupper, kmp_int64 *pupperD, kmp_int64 *pstride, kmp_int64 incr, kmp_int64 chunk)
Definition: kmp_sched.cpp:1015
void __kmpc_for_static_init_4u(ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype, kmp_int32 *plastiter, kmp_uint32 *plower, kmp_uint32 *pupper, kmp_int32 *pstride, kmp_int32 incr, kmp_int32 chunk)
Definition: kmp_sched.cpp:911
void __kmpc_team_static_init_8(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last, kmp_int64 *p_lb, kmp_int64 *p_ub, kmp_int64 *p_st, kmp_int64 incr, kmp_int64 chunk)
Definition: kmp_sched.cpp:1091
void __kmpc_dist_for_static_init_4u(ident_t *loc, kmp_int32 gtid, kmp_int32 schedule, kmp_int32 *plastiter, kmp_uint32 *plower, kmp_uint32 *pupper, kmp_uint32 *pupperD, kmp_int32 *pstride, kmp_int32 incr, kmp_int32 chunk)
Definition: kmp_sched.cpp:1002
void __kmpc_team_static_init_8u(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last, kmp_uint64 *p_lb, kmp_uint64 *p_ub, kmp_int64 *p_st, kmp_int64 incr, kmp_int64 chunk)
Definition: kmp_sched.cpp:1103
void __kmpc_for_static_init_8u(ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype, kmp_int32 *plastiter, kmp_uint64 *plower, kmp_uint64 *pupper, kmp_int64 *pstride, kmp_int64 incr, kmp_int64 chunk)
Definition: kmp_sched.cpp:944
void __kmpc_team_static_init_4u(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last, kmp_uint32 *p_lb, kmp_uint32 *p_ub, kmp_int32 *p_st, kmp_int32 incr, kmp_int32 chunk)
Definition: kmp_sched.cpp:1079
void __kmpc_dist_for_static_init_4(ident_t *loc, kmp_int32 gtid, kmp_int32 schedule, kmp_int32 *plastiter, kmp_int32 *plower, kmp_int32 *pupper, kmp_int32 *pupperD, kmp_int32 *pstride, kmp_int32 incr, kmp_int32 chunk)
Definition: kmp_sched.cpp:989
void __kmpc_for_static_init_4(ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype, kmp_int32 *plastiter, kmp_int32 *plower, kmp_int32 *pupper, kmp_int32 *pstride, kmp_int32 incr, kmp_int32 chunk)
Definition: kmp_sched.cpp:895
void __kmpc_team_static_init_4(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last, kmp_int32 *p_lb, kmp_int32 *p_ub, kmp_int32 *p_st, kmp_int32 incr, kmp_int32 chunk)
Definition: kmp_sched.cpp:1067
void __kmpc_dist_for_static_init_8u(ident_t *loc, kmp_int32 gtid, kmp_int32 schedule, kmp_int32 *plastiter, kmp_uint64 *plower, kmp_uint64 *pupper, kmp_uint64 *pupperD, kmp_int64 *pstride, kmp_int64 incr, kmp_int64 chunk)
Definition: kmp_sched.cpp:1028
@ kmp_sch_static
Definition: kmp.h:373
@ kmp_distribute_static
Definition: kmp.h:409
@ kmp_ord_upper
Definition: kmp.h:405
Definition: kmp.h:247
char const * psource
Definition: kmp.h:257
kmp_int32 flags
Definition: kmp.h:249