This source file includes following definitions.
- ompi_coll_tuned_allreduce_intra_dec_dynamic
- ompi_coll_tuned_alltoall_intra_dec_dynamic
- ompi_coll_tuned_alltoallv_intra_dec_dynamic
- ompi_coll_tuned_barrier_intra_dec_dynamic
- ompi_coll_tuned_bcast_intra_dec_dynamic
- ompi_coll_tuned_reduce_intra_dec_dynamic
- ompi_coll_tuned_reduce_scatter_intra_dec_dynamic
- ompi_coll_tuned_reduce_scatter_block_intra_dec_dynamic
- ompi_coll_tuned_allgather_intra_dec_dynamic
- ompi_coll_tuned_allgatherv_intra_dec_dynamic
- ompi_coll_tuned_gather_intra_dec_dynamic
- ompi_coll_tuned_scatter_intra_dec_dynamic
- ompi_coll_tuned_exscan_intra_dec_dynamic
- ompi_coll_tuned_scan_intra_dec_dynamic
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 #include "ompi_config.h"
23
24 #include "mpi.h"
25 #include "ompi/constants.h"
26 #include "ompi/datatype/ompi_datatype.h"
27 #include "ompi/communicator/communicator.h"
28 #include "ompi/mca/coll/base/base.h"
29 #include "ompi/mca/coll/coll.h"
30 #include "ompi/mca/coll/base/coll_tags.h"
31 #include "coll_tuned.h"
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52 int
53 ompi_coll_tuned_allreduce_intra_dec_dynamic (const void *sbuf, void *rbuf, int count,
54 struct ompi_datatype_t *dtype,
55 struct ompi_op_t *op,
56 struct ompi_communicator_t *comm,
57 mca_coll_base_module_t *module)
58 {
59 mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
60
61 OPAL_OUTPUT((ompi_coll_tuned_stream, "ompi_coll_tuned_allreduce_intra_dec_dynamic"));
62
63
64 if (tuned_module->com_rules[ALLREDUCE]) {
65
66 int alg, faninout, segsize, ignoreme;
67 size_t dsize;
68
69 ompi_datatype_type_size (dtype, &dsize);
70 dsize *= count;
71
72 alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[ALLREDUCE],
73 dsize, &faninout, &segsize, &ignoreme);
74
75 if (alg) {
76
77 return ompi_coll_tuned_allreduce_intra_do_this (sbuf, rbuf, count, dtype, op,
78 comm, module,
79 alg, faninout, segsize);
80 }
81 }
82
83 if (tuned_module->user_forced[ALLREDUCE].algorithm) {
84 return ompi_coll_tuned_allreduce_intra_do_this(sbuf, rbuf, count, dtype, op, comm, module,
85 tuned_module->user_forced[ALLREDUCE].algorithm,
86 tuned_module->user_forced[ALLREDUCE].tree_fanout,
87 tuned_module->user_forced[ALLREDUCE].segsize);
88 }
89 return ompi_coll_tuned_allreduce_intra_dec_fixed (sbuf, rbuf, count, dtype, op,
90 comm, module);
91 }
92
93
94
95
96
97
98
99
100
101 int ompi_coll_tuned_alltoall_intra_dec_dynamic(const void *sbuf, int scount,
102 struct ompi_datatype_t *sdtype,
103 void* rbuf, int rcount,
104 struct ompi_datatype_t *rdtype,
105 struct ompi_communicator_t *comm,
106 mca_coll_base_module_t *module)
107 {
108 mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
109
110 OPAL_OUTPUT((ompi_coll_tuned_stream, "ompi_coll_tuned_alltoall_intra_dec_dynamic"));
111
112
113 if (tuned_module->com_rules[ALLTOALL]) {
114
115 int comsize;
116 int alg, faninout, segsize, max_requests;
117 size_t dsize;
118
119 ompi_datatype_type_size (sdtype, &dsize);
120 comsize = ompi_comm_size(comm);
121 dsize *= (ptrdiff_t)comsize * (ptrdiff_t)scount;
122
123 alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[ALLTOALL],
124 dsize, &faninout, &segsize, &max_requests);
125
126 if (alg) {
127
128 return ompi_coll_tuned_alltoall_intra_do_this (sbuf, scount, sdtype,
129 rbuf, rcount, rdtype,
130 comm, module,
131 alg, faninout, segsize, max_requests);
132 }
133 }
134
135 if (tuned_module->user_forced[ALLTOALL].algorithm) {
136 return ompi_coll_tuned_alltoall_intra_do_this(sbuf, scount, sdtype,
137 rbuf, rcount, rdtype,
138 comm, module,
139 tuned_module->user_forced[ALLTOALL].algorithm,
140 tuned_module->user_forced[ALLTOALL].tree_fanout,
141 tuned_module->user_forced[ALLTOALL].segsize,
142 tuned_module->user_forced[ALLTOALL].max_requests);
143 }
144 return ompi_coll_tuned_alltoall_intra_dec_fixed (sbuf, scount, sdtype,
145 rbuf, rcount, rdtype,
146 comm, module);
147 }
148
149
150
151
152
153
154
155 int ompi_coll_tuned_alltoallv_intra_dec_dynamic(const void *sbuf, const int *scounts, const int *sdisps,
156 struct ompi_datatype_t *sdtype,
157 void* rbuf, const int *rcounts, const int *rdisps,
158 struct ompi_datatype_t *rdtype,
159 struct ompi_communicator_t *comm,
160 mca_coll_base_module_t *module)
161 {
162 mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
163
164 OPAL_OUTPUT((ompi_coll_tuned_stream, "ompi_coll_tuned_alltoallv_intra_dec_dynamic"));
165
166
167
168
169
170
171
172 if (tuned_module->com_rules[ALLTOALLV]) {
173 int alg, faninout, segsize, max_requests;
174
175 alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[ALLTOALLV],
176 0, &faninout, &segsize, &max_requests);
177
178 if (alg) {
179
180 return ompi_coll_tuned_alltoallv_intra_do_this (sbuf, scounts, sdisps, sdtype,
181 rbuf, rcounts, rdisps, rdtype,
182 comm, module,
183 alg);
184 }
185 }
186
187 if (tuned_module->user_forced[ALLTOALLV].algorithm) {
188 return ompi_coll_tuned_alltoallv_intra_do_this(sbuf, scounts, sdisps, sdtype,
189 rbuf, rcounts, rdisps, rdtype,
190 comm, module,
191 tuned_module->user_forced[ALLTOALLV].algorithm);
192 }
193 return ompi_coll_tuned_alltoallv_intra_dec_fixed(sbuf, scounts, sdisps, sdtype,
194 rbuf, rcounts, rdisps, rdtype,
195 comm, module);
196 }
197
198
199
200
201
202
203
204
205 int ompi_coll_tuned_barrier_intra_dec_dynamic(struct ompi_communicator_t *comm,
206 mca_coll_base_module_t *module)
207 {
208 mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
209
210 OPAL_OUTPUT((ompi_coll_tuned_stream,"ompi_coll_tuned_barrier_intra_dec_dynamic"));
211
212
213 if (tuned_module->com_rules[BARRIER]) {
214
215 int alg, faninout, segsize, ignoreme;
216
217 alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[BARRIER],
218 0, &faninout, &segsize, &ignoreme);
219
220 if (alg) {
221
222 return ompi_coll_tuned_barrier_intra_do_this (comm, module,
223 alg, faninout, segsize);
224 }
225 }
226
227 if (tuned_module->user_forced[BARRIER].algorithm) {
228 return ompi_coll_tuned_barrier_intra_do_this(comm, module,
229 tuned_module->user_forced[BARRIER].algorithm,
230 tuned_module->user_forced[BARRIER].tree_fanout,
231 tuned_module->user_forced[BARRIER].segsize);
232 }
233 return ompi_coll_tuned_barrier_intra_dec_fixed (comm, module);
234 }
235
236
237
238
239
240
241
242
243 int ompi_coll_tuned_bcast_intra_dec_dynamic(void *buf, int count,
244 struct ompi_datatype_t *dtype, int root,
245 struct ompi_communicator_t *comm,
246 mca_coll_base_module_t *module)
247 {
248 mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
249
250 OPAL_OUTPUT((ompi_coll_tuned_stream, "coll:tuned:bcast_intra_dec_dynamic"));
251
252
253 if (tuned_module->com_rules[BCAST]) {
254
255 int alg, faninout, segsize, ignoreme;
256 size_t dsize;
257
258 ompi_datatype_type_size (dtype, &dsize);
259 dsize *= count;
260
261 alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[BCAST],
262 dsize, &faninout, &segsize, &ignoreme);
263
264 if (alg) {
265
266 return ompi_coll_tuned_bcast_intra_do_this (buf, count, dtype, root,
267 comm, module,
268 alg, faninout, segsize);
269 }
270 }
271
272
273 if (tuned_module->user_forced[BCAST].algorithm) {
274 return ompi_coll_tuned_bcast_intra_do_this(buf, count, dtype,
275 root, comm, module,
276 tuned_module->user_forced[BCAST].algorithm,
277 tuned_module->user_forced[BCAST].chain_fanout,
278 tuned_module->user_forced[BCAST].segsize);
279 }
280 return ompi_coll_tuned_bcast_intra_dec_fixed (buf, count, dtype, root,
281 comm, module);
282 }
283
284
285
286
287
288
289
290
291
292 int ompi_coll_tuned_reduce_intra_dec_dynamic( const void *sbuf, void *rbuf,
293 int count, struct ompi_datatype_t* dtype,
294 struct ompi_op_t* op, int root,
295 struct ompi_communicator_t* comm,
296 mca_coll_base_module_t *module)
297 {
298 mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
299
300 OPAL_OUTPUT((ompi_coll_tuned_stream, "coll:tuned:reduce_intra_dec_dynamic"));
301
302
303 if (tuned_module->com_rules[REDUCE]) {
304
305
306 int alg, faninout, segsize, max_requests;
307 size_t dsize;
308
309 ompi_datatype_type_size(dtype, &dsize);
310 dsize *= count;
311
312 alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[REDUCE],
313 dsize, &faninout, &segsize, &max_requests);
314
315 if (alg) {
316
317 return ompi_coll_tuned_reduce_intra_do_this (sbuf, rbuf, count, dtype,
318 op, root, comm, module,
319 alg, faninout,
320 segsize, max_requests);
321 }
322 }
323
324 if (tuned_module->user_forced[REDUCE].algorithm) {
325 return ompi_coll_tuned_reduce_intra_do_this(sbuf, rbuf, count, dtype,
326 op, root, comm, module,
327 tuned_module->user_forced[REDUCE].algorithm,
328 tuned_module->user_forced[REDUCE].chain_fanout,
329 tuned_module->user_forced[REDUCE].segsize,
330 tuned_module->user_forced[REDUCE].max_requests);
331 }
332 return ompi_coll_tuned_reduce_intra_dec_fixed (sbuf, rbuf, count, dtype,
333 op, root, comm, module);
334 }
335
336
337
338
339
340
341
342
343
344
345 int ompi_coll_tuned_reduce_scatter_intra_dec_dynamic(const void *sbuf, void *rbuf,
346 const int *rcounts,
347 struct ompi_datatype_t *dtype,
348 struct ompi_op_t *op,
349 struct ompi_communicator_t *comm,
350 mca_coll_base_module_t *module)
351 {
352 mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
353
354 OPAL_OUTPUT((ompi_coll_tuned_stream, "coll:tuned:reduce_scatter_intra_dec_dynamic"));
355
356
357 if (tuned_module->com_rules[REDUCESCATTER]) {
358
359
360 int alg, faninout, segsize, ignoreme, i, count, size;
361 size_t dsize;
362 size = ompi_comm_size(comm);
363 for (i = 0, count = 0; i < size; i++) { count += rcounts[i];}
364 ompi_datatype_type_size (dtype, &dsize);
365 dsize *= count;
366
367 alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[REDUCESCATTER],
368 dsize, &faninout,
369 &segsize, &ignoreme);
370 if (alg) {
371
372 return ompi_coll_tuned_reduce_scatter_intra_do_this (sbuf, rbuf, rcounts, dtype,
373 op, comm, module,
374 alg, faninout, segsize);
375 }
376 }
377
378 if (tuned_module->user_forced[REDUCESCATTER].algorithm) {
379 return ompi_coll_tuned_reduce_scatter_intra_do_this(sbuf, rbuf, rcounts, dtype,
380 op, comm, module,
381 tuned_module->user_forced[REDUCESCATTER].algorithm,
382 tuned_module->user_forced[REDUCESCATTER].chain_fanout,
383 tuned_module->user_forced[REDUCESCATTER].segsize);
384 }
385 return ompi_coll_tuned_reduce_scatter_intra_dec_fixed (sbuf, rbuf, rcounts,
386 dtype, op, comm, module);
387 }
388
389
390
391
392
393
394
395
396
397
398 int ompi_coll_tuned_reduce_scatter_block_intra_dec_dynamic(const void *sbuf, void *rbuf,
399 int rcount,
400 struct ompi_datatype_t *dtype,
401 struct ompi_op_t *op,
402 struct ompi_communicator_t *comm,
403 mca_coll_base_module_t *module)
404 {
405 mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
406
407 OPAL_OUTPUT((ompi_coll_tuned_stream, "coll:tuned:reduce_scatter_block_intra_dec_dynamic"));
408
409
410 if (tuned_module->com_rules[REDUCESCATTERBLOCK]) {
411
412
413 int alg, faninout, segsize, ignoreme, size;
414 size_t dsize;
415 size = ompi_comm_size(comm);
416 ompi_datatype_type_size (dtype, &dsize);
417 dsize *= rcount * size;
418
419 alg = ompi_coll_tuned_get_target_method_params(tuned_module->com_rules[REDUCESCATTERBLOCK],
420 dsize, &faninout,
421 &segsize, &ignoreme);
422 if (alg) {
423
424 return ompi_coll_tuned_reduce_scatter_block_intra_do_this (sbuf, rbuf, rcount, dtype,
425 op, comm, module,
426 alg, faninout, segsize);
427 }
428 }
429
430 if (tuned_module->user_forced[REDUCESCATTERBLOCK].algorithm) {
431 return ompi_coll_tuned_reduce_scatter_block_intra_do_this(sbuf, rbuf, rcount, dtype,
432 op, comm, module,
433 tuned_module->user_forced[REDUCESCATTERBLOCK].algorithm,
434 tuned_module->user_forced[REDUCESCATTERBLOCK].chain_fanout,
435 tuned_module->user_forced[REDUCESCATTERBLOCK].segsize);
436 }
437 return ompi_coll_tuned_reduce_scatter_block_intra_dec_fixed (sbuf, rbuf, rcount,
438 dtype, op, comm, module);
439 }
440
441
442
443
444
445
446
447
448
449
450 int ompi_coll_tuned_allgather_intra_dec_dynamic(const void *sbuf, int scount,
451 struct ompi_datatype_t *sdtype,
452 void* rbuf, int rcount,
453 struct ompi_datatype_t *rdtype,
454 struct ompi_communicator_t *comm,
455 mca_coll_base_module_t *module)
456 {
457 mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
458
459 OPAL_OUTPUT((ompi_coll_tuned_stream,
460 "ompi_coll_tuned_allgather_intra_dec_dynamic"));
461
462 if (tuned_module->com_rules[ALLGATHER]) {
463
464
465 int comsize;
466 int alg, faninout, segsize, ignoreme;
467 size_t dsize;
468
469 ompi_datatype_type_size (sdtype, &dsize);
470 comsize = ompi_comm_size(comm);
471 dsize *= (ptrdiff_t)comsize * (ptrdiff_t)scount;
472
473 alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[ALLGATHER],
474 dsize, &faninout, &segsize, &ignoreme);
475 if (alg) {
476
477
478 return ompi_coll_tuned_allgather_intra_do_this (sbuf, scount, sdtype,
479 rbuf, rcount, rdtype,
480 comm, module,
481 alg, faninout, segsize);
482 }
483 }
484
485
486 if (tuned_module->user_forced[ALLGATHER].algorithm) {
487
488 return ompi_coll_tuned_allgather_intra_do_this(sbuf, scount, sdtype,
489 rbuf, rcount, rdtype,
490 comm, module,
491 tuned_module->user_forced[ALLGATHER].algorithm,
492 tuned_module->user_forced[ALLGATHER].tree_fanout,
493 tuned_module->user_forced[ALLGATHER].segsize);
494 }
495
496
497 return ompi_coll_tuned_allgather_intra_dec_fixed (sbuf, scount, sdtype,
498 rbuf, rcount, rdtype,
499 comm, module);
500 }
501
502
503
504
505
506
507
508
509
510
511 int ompi_coll_tuned_allgatherv_intra_dec_dynamic(const void *sbuf, int scount,
512 struct ompi_datatype_t *sdtype,
513 void* rbuf, const int *rcounts,
514 const int *rdispls,
515 struct ompi_datatype_t *rdtype,
516 struct ompi_communicator_t *comm,
517 mca_coll_base_module_t *module)
518 {
519 mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
520
521 OPAL_OUTPUT((ompi_coll_tuned_stream,
522 "ompi_coll_tuned_allgatherv_intra_dec_dynamic"));
523
524 if (tuned_module->com_rules[ALLGATHERV]) {
525
526
527 int comsize, i;
528 int alg, faninout, segsize, ignoreme;
529 size_t dsize, total_size;
530
531 comsize = ompi_comm_size(comm);
532 ompi_datatype_type_size (sdtype, &dsize);
533 total_size = 0;
534 for (i = 0; i < comsize; i++) { total_size += dsize * rcounts[i]; }
535
536 alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[ALLGATHERV],
537 total_size, &faninout, &segsize, &ignoreme);
538 if (alg) {
539
540
541 return ompi_coll_tuned_allgatherv_intra_do_this (sbuf, scount, sdtype,
542 rbuf, rcounts,
543 rdispls, rdtype,
544 comm, module,
545 alg, faninout, segsize);
546 }
547 }
548
549
550 if (tuned_module->user_forced[ALLGATHERV].algorithm) {
551
552 return ompi_coll_tuned_allgatherv_intra_do_this(sbuf, scount, sdtype,
553 rbuf, rcounts, rdispls, rdtype,
554 comm, module,
555 tuned_module->user_forced[ALLGATHERV].algorithm,
556 tuned_module->user_forced[ALLGATHERV].tree_fanout,
557 tuned_module->user_forced[ALLGATHERV].segsize);
558 }
559
560
561 return ompi_coll_tuned_allgatherv_intra_dec_fixed (sbuf, scount, sdtype,
562 rbuf, rcounts,
563 rdispls, rdtype,
564 comm, module);
565 }
566
567 int ompi_coll_tuned_gather_intra_dec_dynamic(const void *sbuf, int scount,
568 struct ompi_datatype_t *sdtype,
569 void* rbuf, int rcount,
570 struct ompi_datatype_t *rdtype,
571 int root,
572 struct ompi_communicator_t *comm,
573 mca_coll_base_module_t *module)
574 {
575 mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
576
577 OPAL_OUTPUT((ompi_coll_tuned_stream,
578 "ompi_coll_tuned_gather_intra_dec_dynamic"));
579
580
581
582
583 if (tuned_module->com_rules[GATHER]) {
584 int comsize, alg, faninout, segsize, max_requests;
585 size_t dsize;
586
587 comsize = ompi_comm_size(comm);
588 ompi_datatype_type_size (sdtype, &dsize);
589 dsize *= comsize;
590
591 alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[GATHER],
592 dsize, &faninout, &segsize, &max_requests);
593
594 if (alg) {
595
596 return ompi_coll_tuned_gather_intra_do_this (sbuf, scount, sdtype,
597 rbuf, rcount, rdtype,
598 root, comm, module,
599 alg, faninout, segsize);
600 }
601 }
602
603 if (tuned_module->user_forced[GATHER].algorithm) {
604 return ompi_coll_tuned_gather_intra_do_this(sbuf, scount, sdtype,
605 rbuf, rcount, rdtype,
606 root, comm, module,
607 tuned_module->user_forced[GATHER].algorithm,
608 tuned_module->user_forced[GATHER].tree_fanout,
609 tuned_module->user_forced[GATHER].segsize);
610 }
611
612 return ompi_coll_tuned_gather_intra_dec_fixed (sbuf, scount, sdtype,
613 rbuf, rcount, rdtype,
614 root, comm, module);
615 }
616
617 int ompi_coll_tuned_scatter_intra_dec_dynamic(const void *sbuf, int scount,
618 struct ompi_datatype_t *sdtype,
619 void* rbuf, int rcount,
620 struct ompi_datatype_t *rdtype,
621 int root, struct ompi_communicator_t *comm,
622 mca_coll_base_module_t *module)
623 {
624 mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
625
626 OPAL_OUTPUT((ompi_coll_tuned_stream,
627 "ompi_coll_tuned_scatter_intra_dec_dynamic"));
628
629
630
631
632 if (tuned_module->com_rules[SCATTER]) {
633 int comsize, alg, faninout, segsize, max_requests;
634 size_t dsize;
635
636 comsize = ompi_comm_size(comm);
637 ompi_datatype_type_size (sdtype, &dsize);
638 dsize *= comsize;
639
640 alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[SCATTER],
641 dsize, &faninout, &segsize, &max_requests);
642
643 if (alg) {
644
645 return ompi_coll_tuned_scatter_intra_do_this (sbuf, scount, sdtype,
646 rbuf, rcount, rdtype,
647 root, comm, module,
648 alg, faninout, segsize);
649 }
650 }
651
652 if (tuned_module->user_forced[SCATTER].algorithm) {
653 return ompi_coll_tuned_scatter_intra_do_this(sbuf, scount, sdtype,
654 rbuf, rcount, rdtype,
655 root, comm, module,
656 tuned_module->user_forced[SCATTER].algorithm,
657 tuned_module->user_forced[SCATTER].chain_fanout,
658 tuned_module->user_forced[SCATTER].segsize);
659 }
660
661 return ompi_coll_tuned_scatter_intra_dec_fixed (sbuf, scount, sdtype,
662 rbuf, rcount, rdtype,
663 root, comm, module);
664 }
665
666 int ompi_coll_tuned_exscan_intra_dec_dynamic(const void *sbuf, void* rbuf, int count,
667 struct ompi_datatype_t *dtype,
668 struct ompi_op_t *op,
669 struct ompi_communicator_t *comm,
670 mca_coll_base_module_t *module)
671 {
672 mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
673
674 OPAL_OUTPUT((ompi_coll_tuned_stream,
675 "ompi_coll_tuned_exscan_intra_dec_dynamic"));
676
677
678
679
680 if (tuned_module->com_rules[EXSCAN]) {
681 int comsize, alg, faninout, segsize, max_requests;
682 size_t dsize;
683
684 comsize = ompi_comm_size(comm);
685 ompi_datatype_type_size (dtype, &dsize);
686 dsize *= comsize;
687
688 alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[EXSCAN],
689 dsize, &faninout, &segsize, &max_requests);
690
691 if (alg) {
692
693 return ompi_coll_tuned_exscan_intra_do_this (sbuf, rbuf, count, dtype,
694 op, comm, module,
695 alg);
696 }
697 }
698
699 if (tuned_module->user_forced[EXSCAN].algorithm) {
700 return ompi_coll_tuned_exscan_intra_do_this(sbuf, rbuf, count, dtype,
701 op, comm, module,
702 tuned_module->user_forced[EXSCAN].algorithm);
703 }
704
705 return ompi_coll_base_exscan_intra_linear(sbuf, rbuf, count, dtype,
706 op, comm, module);
707 }
708
709 int ompi_coll_tuned_scan_intra_dec_dynamic(const void *sbuf, void* rbuf, int count,
710 struct ompi_datatype_t *dtype,
711 struct ompi_op_t *op,
712 struct ompi_communicator_t *comm,
713 mca_coll_base_module_t *module)
714 {
715 mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
716
717 OPAL_OUTPUT((ompi_coll_tuned_stream,
718 "ompi_coll_tuned_scan_intra_dec_dynamic"));
719
720
721
722
723 if (tuned_module->com_rules[SCAN]) {
724 int comsize, alg, faninout, segsize, max_requests;
725 size_t dsize;
726
727 comsize = ompi_comm_size(comm);
728 ompi_datatype_type_size (dtype, &dsize);
729 dsize *= comsize;
730
731 alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[SCAN],
732 dsize, &faninout, &segsize, &max_requests);
733
734 if (alg) {
735
736 return ompi_coll_tuned_scan_intra_do_this (sbuf, rbuf, count, dtype,
737 op, comm, module,
738 alg);
739 }
740 }
741
742 if (tuned_module->user_forced[SCAN].algorithm) {
743 return ompi_coll_tuned_scan_intra_do_this(sbuf, rbuf, count, dtype,
744 op, comm, module,
745 tuned_module->user_forced[SCAN].algorithm);
746 }
747
748 return ompi_coll_base_scan_intra_linear(sbuf, rbuf, count, dtype,
749 op, comm, module);
750 }