Yet Another eXchange Tool 0.11.4
Loading...
Searching...
No Matches
xt_idxlist_collection.c
Go to the documentation of this file.
1
12/*
13 * Keywords:
14 * Maintainer: Jörg Behrens <behrens@dkrz.de>
15 * Moritz Hanke <hanke@dkrz.de>
16 * Thomas Jahns <jahns@dkrz.de>
17 * URL: https://dkrz-sw.gitlab-pages.dkrz.de/yaxt/
18 *
19 * Redistribution and use in source and binary forms, with or without
20 * modification, are permitted provided that the following conditions are
21 * met:
22 *
23 * Redistributions of source code must retain the above copyright notice,
24 * this list of conditions and the following disclaimer.
25 *
26 * Redistributions in binary form must reproduce the above copyright
27 * notice, this list of conditions and the following disclaimer in the
28 * documentation and/or other materials provided with the distribution.
29 *
30 * Neither the name of the DKRZ GmbH nor the names of its contributors
31 * may be used to endorse or promote products derived from this software
32 * without specific prior written permission.
33 *
34 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
35 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
36 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
37 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
38 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
39 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
40 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
41 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
42 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
43 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
44 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
45 */
46#ifdef HAVE_CONFIG_H
47#include <config.h>
48#endif
49
50#include <stdlib.h>
51#include <stdio.h>
52#include <assert.h>
53#include <string.h>
54
55#include "mpi.h"
56
57#include "xt/xt_core.h"
58#include "xt/xt_idxlist.h"
59#include "xt_idxlist_internal.h"
62#include "xt/xt_idxempty.h"
63#include "xt/xt_config.h"
64#include "xt_config_internal.h"
65#include "xt_idxvec_internal.h"
66#include "xt/xt_idxstripes.h"
68#include "xt/xt_mpi.h"
69#include "xt_idxlist_unpack.h"
70#include "xt_stripe_util.h"
71#include "core/core.h"
72#include "core/ppm_xfuncs.h"
73#include "ensure_array_size.h"
74
75static const char filename[] = "xt_idxlist_collection.c";
76
77static void
79
80static size_t
82
83static void
84idxlist_collection_pack(Xt_idxlist data, void *buffer, int buffer_size,
85 int *position, MPI_Comm comm);
86
87static Xt_idxlist
89
90static Xt_idxlist
92
93static void
95
96static const Xt_int *
98
99static int
101
102static void
104 struct Xt_stripe *restrict stripes,
105 size_t num_stripes_alloc);
106
107static int
109 Xt_int * index);
110
111static int
113 int * position);
114
115static int
117 int * position, int offset);
118
119static Xt_int
121
122static Xt_int
124
125static int
127
130 .get_pack_size = idxlist_collection_get_pack_size,
133 .sorted_copy = idxlist_collection_sorted_copy,
134 .get_indices = idxlist_collection_get_indices,
135 .get_indices_const = idxlist_collection_get_indices_const,
136 .get_num_index_stripes = idxlist_collection_get_num_index_stripes,
137 .get_index_stripes = idxlist_collection_get_index_stripes,
138 .get_index_at_position = idxlist_collection_get_index_at_position,
139 .get_indices_at_positions = NULL,
140 .get_position_of_index = idxlist_collection_get_position_of_index,
141 .get_positions_of_indices = NULL,
142 .get_position_of_index_off = idxlist_collection_get_position_of_index_off,
143 .get_positions_of_indices_off = NULL,
144 .get_min_index = idxlist_collection_get_min_index,
145 .get_max_index = idxlist_collection_get_max_index,
146 .get_sorting = idxlist_collection_get_sorting,
147 .get_bounding_box = NULL,
148 .idxlist_pack_code = COLLECTION,
149};
150
152
163
165xt_idxlist_collection_new(Xt_idxlist *idxlists, int num_idxlists) {
166 // ensure that yaxt is initialized
167 assert(xt_initialized());
168
169 /* todo: find collections in idxlists and prevent hierarchical
170 * copy, flatten list instead */
171 Xt_idxlist result;
172 size_t num_non_empty_idxlists = 0, first_non_empty_idxlist = (size_t)-1;
173 for (int i = 0; i < num_idxlists; ++i) {
174 int num_indices_of_list = xt_idxlist_get_num_indices(idxlists[i]);
175 if (first_non_empty_idxlist == (size_t)-1 && num_indices_of_list > 0)
176 first_non_empty_idxlist = (size_t)i;
177 num_non_empty_idxlists +=
178 (idxlists[i]->vtable == &idxlist_collection_vtable)
179 ? (size_t)((Xt_idxlist_collection)idxlists[i])->num_idxlists
180 : (size_t)(num_indices_of_list > 0);
181 }
182 if (num_non_empty_idxlists > 1)
183 {
184 long long num_indices
185 = xt_idxlist_get_num_indices(idxlists[first_non_empty_idxlist]);
186 Xt_int min = xt_idxlist_get_min_index(idxlists[first_non_empty_idxlist]),
187 max = xt_idxlist_get_max_index(idxlists[first_non_empty_idxlist]),
188 prev_max = max;
189 unsigned ntrans_dn = 0, ntrans_up = 0,
190 nsort_asc = 0, nsort_dsc = 0;
191 switch (xt_idxlist_get_sorting(idxlists[first_non_empty_idxlist])) {
192 case 1:
193 ++nsort_asc;
194 break;
195 case -1:
196 ++nsort_dsc;
197 break;
198 case 0:
199 break;
200# if HAVE_DECL___BUILTIN_UNREACHABLE
201 default:
202 __builtin_unreachable();
203# endif
204 }
205 for (int i = (int)first_non_empty_idxlist+1; i < num_idxlists; ++i) {
206 int num_indices_of_list = xt_idxlist_get_num_indices(idxlists[i]);
207 if (num_indices_of_list > 0) {
208 Xt_int tmp_min, tmp_max;
209 if ((tmp_min = xt_idxlist_get_min_index(idxlists[i])) < min)
210 min = tmp_min;
211 if ((tmp_max = xt_idxlist_get_max_index(idxlists[i])) > max)
212 max = tmp_max;
213 ntrans_dn += (tmp_min < prev_max);
214 ntrans_up += (tmp_min > prev_max);
215 prev_max = tmp_max;
216 int sort = xt_idxlist_get_sorting(idxlists[i]);
217 switch (sort) {
218 case 1:
219 ++nsort_asc;
220 break;
221 case -1:
222 ++nsort_dsc;
223 break;
224 case 0:
225 break;
226# if HAVE_DECL___BUILTIN_UNREACHABLE
227 default:
228 __builtin_unreachable();
229# endif
230 }
231 num_indices += num_indices_of_list;
232 }
233 }
234 assert(num_indices <= INT_MAX);
235 if (min != max) {
236 Xt_idxlist_collection collectionlist
237 = xmalloc(sizeof (*collectionlist)
238 + num_non_empty_idxlists
239 * sizeof (collectionlist->idxlists[0]));
240
241 collectionlist->num_idxlists = (int)num_non_empty_idxlists;
242 collectionlist->index_array_cache = NULL;
243
244 for (size_t i = first_non_empty_idxlist, j = 0;
245 i < (size_t)num_idxlists; ++i) {
246 if (idxlists[i]->vtable == &idxlist_collection_vtable) {
247 Xt_idxlist_collection comp_collection
248 = (Xt_idxlist_collection)idxlists[i];
249 size_t num_comp_idxlists
250 = (size_t)comp_collection->num_idxlists;
251 Xt_idxlist *comp_lists = comp_collection->idxlists;
252 for (size_t k = 0; k < num_comp_idxlists; ++k)
253 collectionlist->idxlists[j+k] = xt_idxlist_copy(comp_lists[k]);
254 j += num_comp_idxlists;
255 } else if (xt_idxlist_get_num_indices(idxlists[i]) > 0)
256 collectionlist->idxlists[j++] = xt_idxlist_copy(idxlists[i]);
257 }
259 (int)num_indices);
260 collectionlist->flags = XT_SORT_FLAGS(ntrans_up + nsort_asc,
261 ntrans_dn + nsort_dsc) & sort_mask;
262 result = (Xt_idxlist)collectionlist;
263 } else /* min == max => all values identical */ {
264 result =
266 .start = min, .stride = 0, .nstrides = (int)num_indices }, 1);
267 }
268 }
269 else if (num_non_empty_idxlists == 1)
270 result = xt_idxlist_copy(idxlists[first_non_empty_idxlist]);
271 else /* num_idxlists == 0 */
272 result = xt_idxempty_new();
273 return result;
274}
275
276static void
278
279 Xt_idxlist_collection collectionlist = (Xt_idxlist_collection)data;
280
281 int num_lists = collectionlist->num_idxlists;
282 for (int i = 0; i < num_lists; ++i)
283 xt_idxlist_delete(collectionlist->idxlists[i]);
284
285 free(collectionlist->index_array_cache);
286 free(collectionlist);
287}
288
289static size_t
291
292 Xt_idxlist_collection collectionlist = (Xt_idxlist_collection)data;
293
294 int size_header, num_lists = collectionlist->num_idxlists;
295 size_t size_idxlists = 0;
296
297 xt_mpi_call(MPI_Pack_size(2, MPI_INT, comm, &size_header), comm);
298
299 for (int i = 0; i < num_lists; ++i)
300 size_idxlists
301 += xt_idxlist_get_pack_size(collectionlist->idxlists[i], comm);
302
303 return (size_t)size_header + size_idxlists;
304}
305
306static void
307idxlist_collection_pack(Xt_idxlist data, void *buffer, int buffer_size,
308 int *position, MPI_Comm comm) {
309
310 Xt_idxlist_collection collectionlist = (Xt_idxlist_collection)data;
311 int num_lists = collectionlist->num_idxlists;
312 int header[2] = { COLLECTION, num_lists };
313
314 xt_mpi_call(MPI_Pack(header, 2, MPI_INT, buffer,
315 buffer_size, position, comm), comm);
316
317 for (int i = 0; i < num_lists; ++i)
318 xt_idxlist_pack(collectionlist->idxlists[i], buffer, buffer_size,
319 position, comm);
320}
321
323xt_idxlist_collection_unpack(void *buffer, int buffer_size, int *position,
324 MPI_Comm comm) {
325
326 int num_lists;
327 xt_mpi_call(MPI_Unpack(buffer, buffer_size, position,
328 &num_lists, 1, MPI_INT, comm), comm);
329
330 Xt_idxlist_collection collectionlist
331 = xmalloc(sizeof (*collectionlist)
332 + (size_t)num_lists * sizeof (collectionlist->idxlists[0]));
333
334 collectionlist->index_array_cache = NULL;
335 collectionlist->num_idxlists = num_lists;
336
337 long long num_indices = 0;
338 for (int i = 0; i < num_lists; ++i) {
339 collectionlist->idxlists[i] = xt_idxlist_unpack(buffer, buffer_size,
340 position, comm);
341 num_indices += xt_idxlist_get_num_indices(collectionlist->idxlists[i]);
342 }
343
344 assert(num_indices <= INT_MAX);
346 (int)num_indices);
347 return (Xt_idxlist)collectionlist;
348}
349
352 Xt_idxlist XT_UNUSED(idxlist_dst),
353 Xt_config XT_UNUSED(config)) {
354
355 return NULL;
356}
357
358static Xt_idxlist
360
361 Xt_idxlist_collection collectionlist = (Xt_idxlist_collection)idxlist;
362
363 return xt_idxlist_collection_new(collectionlist->idxlists,
364 collectionlist->num_idxlists);
365}
366
368{
370 int pos;
371};
372
373static int
374range_list_cmp(const void *a, const void *b)
375{
376 const struct range_list_sort *ra = a, *rb = b;
377 int ret;
378 if (ra->min != rb->min) {
379 ret = (ra->min > rb->min) - (ra->min < rb->min);
380 } else {
381 ret = (ra->max > rb->max) - (ra->max < rb->max);
382 }
383 return ret;
384}
385
389};
390
391static Xt_idxlist
393 struct range_list_sort *list_sorter,
394 Xt_config config)
395{
396 /* accumulate stripes into this buffer */
397 struct Xt_stripe *stripes_accum = NULL;
398 size_t stripes_accum_array_size = 0;
399 size_t num_accum_stripes;
400 const Xt_idxlist *unsorted_idxlists = collectionlist->idxlists;
401 {
402 int num_accum_stripes_;
403 xt_idxlist_get_index_stripes(unsorted_idxlists[list_sorter[0].pos], &stripes_accum,
404 &num_accum_stripes_);
405 num_accum_stripes = (size_t)num_accum_stripes_;
406 }
407 size_t num_idxlists = (size_t)collectionlist->num_idxlists;
408 struct Xt_stripe *stripe_buf = NULL; size_t stripe_buf_size = 0;
409 /* obtain stripes, locally mostly sorted if reasonably available */
410 for (size_t i = 1; i < num_idxlists; ++i) {
411 Xt_idxlist component_list, unsorted_list
412 = unsorted_idxlists[list_sorter[i].pos];
413 Xt_int *sorted_indices = NULL;
414 switch (unsorted_list->vtable->idxlist_pack_code) {
415 case EMPTY: /* xt_idxempty should not usually be part
416 * of a collection, but better safe
417 * than sorry, I guess */
418 Xt_abort(Xt_default_comm, "internal error", filename, __LINE__);
419 /* these are either too expensive or pointless to sort, just
420 * use their ranges as is */
421 case COLLECTION:
422 case STRIPES:
423 component_list = unsorted_list;
424 break;
425 case VECTOR:
426 {
427 struct Xt_config_ derived_config = *config;
428 derived_config.flags |= xt_force_nosort;
429 size_t num_indices
430 = (size_t)xt_idxlist_get_num_indices(unsorted_list);
431 const Xt_int *indices
432 = xt_idxvec_get_sorted_vector(unsorted_list, &derived_config);
433 if (!indices) {
434 const Xt_int *vector
435 = xt_idxlist_get_indices_const(unsorted_list);
436 indices = sorted_indices
437 = xmalloc(num_indices * sizeof (*sorted_indices));
438 for (size_t j = 0; j < num_indices; ++j)
439 sorted_indices[j] = vector[j];
440 config->sort_funcs->sort_xt_int(sorted_indices, num_indices);
441 }
442 component_list
443 = xt_idxvec_prealloc_new(indices, (int)num_indices);
444 }
445 break;
446 default:
447 component_list
448 = xt_idxlist_sorted_copy_custom(unsorted_list, config);
449 }
450 size_t num_stripes
451 = (size_t)(xt_idxlist_get_num_index_stripes(component_list));
452 if (num_stripes > stripe_buf_size) {
453 stripe_buf = xrealloc(stripe_buf, num_stripes * sizeof (stripe_buf[0]));
454 stripe_buf_size = num_stripes;
455 }
457 stripe_buf, stripe_buf_size);
458 if (component_list != unsorted_list) {
459 xt_idxlist_delete(component_list);
460 free(sorted_indices);
461 }
462 ENSURE_ARRAY_SIZE(stripes_accum, stripes_accum_array_size,
463 num_accum_stripes + (size_t)stripe_buf_size);
464
465 num_accum_stripes
466 += xt_stripes_merge_copy((size_t)stripe_buf_size,
467 stripes_accum + num_accum_stripes,
468 stripe_buf,
469 num_accum_stripes > 0);
470
471 }
472 /* sort/shuffle the entirety of stripes */
473 free(stripe_buf);
474 Xt_idxlist sorted_copy
475 = xt_idxstripes_sort_new((size_t)num_accum_stripes, stripes_accum, config);
476 free(stripes_accum);
477 return sorted_copy;
478}
479
480
481static Xt_idxlist
483
484 Xt_idxlist_collection collectionlist = (Xt_idxlist_collection)idxlist;
485 size_t num_idxlists = (size_t)collectionlist->num_idxlists;
486 Xt_int prev_max = XT_INT_MIN;
487 Xt_idxlist *idxlists = collectionlist->idxlists;
488 struct range_list_sort *list_sorter;
489 Xt_idxlist_collection sorted_collection
490 = xmalloc(sizeof (*sorted_collection)
491 + num_idxlists * sizeof(sorted_collection->idxlists[0])
492 + num_idxlists * sizeof (struct range_list_sort));
493 sorted_collection->num_idxlists = (int)num_idxlists;
494 sorted_collection->index_array_cache = NULL;
495 list_sorter
496 = (struct range_list_sort *)(sorted_collection->idxlists+num_idxlists);
497 Xt_idxlist result;
498 bool component_overlap = false;
499 for (size_t i = 0; i < num_idxlists; ++i) {
500 Xt_int min = list_sorter[i].min = xt_idxlist_get_min_index(idxlists[i]);
501 component_overlap |= (min < prev_max);
502 prev_max = list_sorter[i].max = xt_idxlist_get_max_index(idxlists[i]);
503 list_sorter[i].pos = (int)i;
504 }
505 if (component_overlap) {
506 /* individual lists not sorted or even overlapping each other */
507 /* 1. sort the lists according to minimal element */
508 qsort(list_sorter, num_idxlists, sizeof (*list_sorter),
510 /* 2. re-check overlap after sorting */
511 prev_max = XT_INT_MIN;
512 component_overlap = false;
513 for (size_t i = 0; i < num_idxlists; ++i) {
514 Xt_int min = list_sorter[i].min;
515 component_overlap |= (min < prev_max);
516 prev_max = list_sorter[i].max;
517 }
518 }
519 if (!component_overlap) {
520 /* the component lists are in a sequence either naturally or
521 * after sorting without problematic overlaps, a concatenation of
522 * their sorted copies is all that's needed. */
523 Xt_idxlist *sorted_lists = sorted_collection->idxlists;
524 for (size_t i = 0; i < num_idxlists; ++i)
525 sorted_lists[i]
526 /* list_sorter[i].pos will be an identity map if the lists
527 * were already sorted */
528 = xt_idxlist_sorted_copy_custom(idxlists[list_sorter[i].pos],
529 config);
530 sorted_collection
531 = xrealloc(sorted_collection, sizeof (*sorted_collection)
532 + num_idxlists * sizeof(sorted_collection->idxlists[0]));
534 xt_idxlist_get_num_indices(idxlist));
535 result = (Xt_idxlist)sorted_collection;
536 } else {
537 /* components overlap in a way that cannot be resolved by sorting
538 * only the lists, need to create stripes and sort those */
539 result = coll_get_sorted_stripes(collectionlist, list_sorter, config);
540 free(sorted_collection);
541 }
542 return result;
543}
544
545static void
547
548 Xt_idxlist_collection collectionlist = (Xt_idxlist_collection)idxlist;
550 int offlist = 0, num_lists = collectionlist->num_idxlists;
551
552 for (int i = 0; i < num_lists; ++i) {
553
554 xt_idxlist_get_indices(collectionlist->idxlists[i], indices+offlist);
555 offlist += xt_idxlist_get_num_indices(collectionlist->idxlists[i]);
556 }
557}
558
559static const Xt_int *
561
562 Xt_idxlist_collection collection = (Xt_idxlist_collection)idxlist;
563
564 if (collection->index_array_cache) return collection->index_array_cache;
565
566 unsigned num_indices = (unsigned)xt_idxlist_get_num_indices(idxlist);
567
568 Xt_int *tmp_index_array
569 = xmalloc(num_indices * sizeof (collection->index_array_cache[0]));
570
571 idxlist_collection_get_indices(idxlist, tmp_index_array);
572
573 collection->index_array_cache = tmp_index_array;
574
575 return collection->index_array_cache;
576}
577
578static int
580{
581 Xt_idxlist_collection collectionlist = (Xt_idxlist_collection)idxlist;
582 int num_lists = collectionlist->num_idxlists;
583 size_t num_stripes = 0;
584 for (int i = 0; i < num_lists; ++i)
585 num_stripes
586 += (size_t)xt_idxlist_get_num_index_stripes(collectionlist->idxlists[i]);
587 assert(num_stripes <= INT_MAX);
588 return (int)num_stripes;
589}
590
591static void
593 struct Xt_stripe *restrict stripes,
594 size_t num_stripes_alloc) {
595
596 Xt_idxlist_collection collectionlist = (Xt_idxlist_collection)idxlist;
597
598 size_t num_stripes = 0;
599
600 size_t num_lists = (size_t)(collectionlist->num_idxlists);
601 Xt_idxlist *idxlists = collectionlist->idxlists;
602 for (size_t i = 0; i < num_lists; ++i) {
603 size_t num_stripes_of_list
604 = (size_t)(xt_idxlist_get_num_index_stripes(idxlists[i]));
605 assert(num_stripes_alloc - num_stripes >= num_stripes_of_list);
606 xt_idxlist_get_index_stripes_keep_buf(idxlists[i], stripes + num_stripes,
607 num_stripes_alloc - num_stripes);
608 num_stripes += num_stripes_of_list;
609 }
610}
611
612static int
614 Xt_int * index) {
615
616 Xt_idxlist_collection collectionlist = (Xt_idxlist_collection)idxlist;
617 int num_lists = collectionlist->num_idxlists;
618
619 for (int i = 0; i < num_lists; ++i) {
620 int n = xt_idxlist_get_num_indices(collectionlist->idxlists[i]);
621 if (position >= n)
622 position -= n;
623 else {
624 return xt_idxlist_get_index_at_position(collectionlist->idxlists[i],
625 position, index);
626 }
627 }
628 return 1;
629
630}
631
632static int
634 int * position, int offset) {
635
636 Xt_idxlist_collection collectionlist = (Xt_idxlist_collection)idxlist;
637
638 int curr_num_indices = 0;
639
640 int idxlist_offsets = 0;
641
642 assert(offset >= 0);
643
644 int i = 0, num_lists = collectionlist->num_idxlists;
645
646 do {
647 idxlist_offsets += curr_num_indices;
648 curr_num_indices = xt_idxlist_get_num_indices(collectionlist->idxlists[i]);
649 } while (idxlist_offsets + curr_num_indices <= offset && ++i < num_lists);
650
651 offset -= idxlist_offsets;
652
653 for (;i < num_lists; ++i)
654 if (!xt_idxlist_get_position_of_index_off(collectionlist->idxlists[i],
655 index, position, offset)) {
656 *position += idxlist_offsets;
657 return 0;
658 } else {
659 idxlist_offsets
660 += xt_idxlist_get_num_indices(collectionlist->idxlists[i]);
661 offset = 0;
662 }
663
664 return 1;
665}
666
667static int
669 int * position) {
670
672 position, 0);
673}
674
675static Xt_int
677
678 Xt_idxlist_collection collectionlist = (Xt_idxlist_collection)idxlist;
679
680 size_t num_lists = (size_t)collectionlist->num_idxlists;
681 assert(collectionlist->num_idxlists > 0);
682
683 Xt_int tmp_min, min = XT_INT_MAX;
684
685 for (size_t i = 0; i < num_lists; ++i)
686 if ((tmp_min = xt_idxlist_get_min_index(collectionlist->idxlists[i])) < min)
687 min = tmp_min;
688
689 return min;
690}
691
692static Xt_int
694
695 Xt_idxlist_collection collectionlist = (Xt_idxlist_collection)idxlist;
696
697 size_t num_lists = (size_t)collectionlist->num_idxlists;
698 assert(collectionlist->num_idxlists > 0);
699
700 Xt_int tmp_max, max = XT_INT_MIN;
701
702 for (size_t i = 0; i < num_lists; ++i)
703 if ((tmp_max = xt_idxlist_get_max_index(collectionlist->idxlists[i])) > max)
704 max = tmp_max;
705
706 return max;
707}
708
709static int
711{
712 unsigned sort_flags = (((Xt_idxlist_collection)idxlist)->flags) & sort_mask;
713 return (int)sort_flags-(sort_flags < 3);
714}
715
716
717/*
718 * Local Variables:
719 * c-basic-offset: 2
720 * coding: utf-8
721 * indent-tabs-mode: nil
722 * show-trailing-whitespace: t
723 * require-trailing-newline: t
724 * End:
725 */
int MPI_Comm
Definition core.h:64
#define XT_UNUSED(x)
Definition core.h:84
#define ENSURE_ARRAY_SIZE(arrayp, curr_array_size, req_size)
add versions of standard API functions not returning on error
#define xrealloc(ptr, size)
Definition ppm_xfuncs.h:71
#define xmalloc(size)
Definition ppm_xfuncs.h:70
const struct Xt_sort_algo_funcptr * sort_funcs
const struct xt_idxlist_vtable * vtable
void(* sort_xt_int)(Xt_int *a, size_t n)
struct Xt_stripe * stripes
opaque configuration object for settings where the default needs to be overridden
implementation of configuration object
@ xt_force_nosort
base definitions header file
#define XT_INT_MIN
Definition xt_core.h:78
#define XT_INT_MAX
Definition xt_core.h:77
int xt_initialized(void)
XT_INT Xt_int
Definition xt_core.h:72
struct Xt_idxlist_ * Xt_idxlist
Definition xt_core.h:84
static struct xt_gpu_vtable vtable
Definition xt_gpu.c:75
Xt_idxlist xt_idxempty_new(void)
void xt_idxlist_get_index_stripes_keep_buf(Xt_idxlist idxlist, struct Xt_stripe *stripes, size_t num_stripes_alloc)
Definition xt_idxlist.c:147
index list declaration
Xt_idxlist xt_idxlist_unpack(void *buffer, int buffer_size, int *position, MPI_Comm comm)
Xt_int xt_idxlist_get_min_index(Xt_idxlist idxlist)
Definition xt_idxlist.c:349
const Xt_int * xt_idxlist_get_indices_const(Xt_idxlist idxlist)
Definition xt_idxlist.c:119
int xt_idxlist_get_index_at_position(Xt_idxlist idxlist, int position, Xt_int *index)
Definition xt_idxlist.c:176
Xt_int xt_idxlist_get_max_index(Xt_idxlist idxlist)
Definition xt_idxlist.c:354
void xt_idxlist_get_indices(Xt_idxlist idxlist, Xt_int *indices)
Definition xt_idxlist.c:113
int xt_idxlist_get_num_index_stripes(Xt_idxlist idxlist)
Definition xt_idxlist.c:129
int xt_idxlist_get_position_of_index_off(Xt_idxlist idxlist, Xt_int index, int *position, int offset)
Definition xt_idxlist.c:306
Xt_idxlist xt_idxlist_sorted_copy_custom(Xt_idxlist idxlist, Xt_config config)
Definition xt_idxlist.c:104
void xt_idxlist_pack(Xt_idxlist idxlist, void *buffer, int buffer_size, int *position, MPI_Comm comm)
Definition xt_idxlist.c:86
size_t xt_idxlist_get_pack_size(Xt_idxlist idxlist, MPI_Comm comm)
Definition xt_idxlist.c:80
void xt_idxlist_get_index_stripes(Xt_idxlist idxlist, struct Xt_stripe **stripes, int *num_stripes)
Definition xt_idxlist.c:135
Xt_idxlist xt_idxlist_copy(Xt_idxlist idxlist)
Definition xt_idxlist.c:94
int xt_idxlist_get_sorting(Xt_idxlist idxlist)
Definition xt_idxlist.c:359
void xt_idxlist_delete(Xt_idxlist idxlist)
Definition xt_idxlist.c:75
Xt_idxlist xt_idxlist_collection_unpack(void *buffer, int buffer_size, int *position, MPI_Comm comm)
static void idxlist_collection_get_indices(Xt_idxlist idxlist, Xt_int *indices)
static const char filename[]
static int idxlist_collection_get_position_of_index_off(Xt_idxlist idxlist, Xt_int index, int *position, int offset)
static int idxlist_collection_get_position_of_index(Xt_idxlist idxlist, Xt_int index, int *position)
static void idxlist_collection_delete(Xt_idxlist data)
static Xt_idxlist idxlist_collection_sorted_copy(Xt_idxlist idxlist, Xt_config config)
struct Xt_idxlist_collection_ * Xt_idxlist_collection
static Xt_idxlist idxlist_collection_copy(Xt_idxlist idxlist)
static int idxlist_collection_get_num_index_stripes(Xt_idxlist idxlist)
static int idxlist_collection_get_sorting(Xt_idxlist idxlist)
static Xt_int idxlist_collection_get_max_index(Xt_idxlist idxlist)
static int range_list_cmp(const void *a, const void *b)
static size_t idxlist_collection_get_pack_size(Xt_idxlist data, MPI_Comm comm)
static Xt_int idxlist_collection_get_min_index(Xt_idxlist idxlist)
static const struct xt_idxlist_vtable idxlist_collection_vtable
static Xt_idxlist coll_get_sorted_stripes(Xt_idxlist_collection collectionlist, struct range_list_sort *list_sorter, Xt_config config)
static int idxlist_collection_get_index_at_position(Xt_idxlist idxlist, int position, Xt_int *index)
static void idxlist_collection_pack(Xt_idxlist data, void *buffer, int buffer_size, int *position, MPI_Comm comm)
Xt_idxlist xt_idxlist_collection_get_intersection(Xt_idxlist XT_UNUSED(idxlist_src), Xt_idxlist XT_UNUSED(idxlist_dst), Xt_config XT_UNUSED(config))
static void idxlist_collection_get_index_stripes(Xt_idxlist idxlist, struct Xt_stripe *restrict stripes, size_t num_stripes_alloc)
static const Xt_int * idxlist_collection_get_indices_const(Xt_idxlist idxlist)
Xt_idxlist xt_idxlist_collection_new(Xt_idxlist *idxlists, int num_idxlists)
Provide non-public declarations common to all index lists.
#define xt_idxlist_get_num_indices(idxlist)
static void Xt_idxlist_init(Xt_idxlist idxlist, const struct xt_idxlist_vtable *vtable, int num_indices)
@ VECTOR
@ EMPTY
@ STRIPES
@ COLLECTION
Xt_idxlist xt_idxstripes_sort_new(size_t num_src_stripes, const struct Xt_stripe src_stripes[], Xt_config config)
Xt_idxlist xt_idxstripes_new(struct Xt_stripe const *stripes, int num_stripes)
Xt_idxlist xt_idxvec_prealloc_new(const Xt_int *idxvec, int num_indices)
Definition xt_idxvec.c:308
PPM_DSO_INTERNAL const Xt_int * xt_idxvec_get_sorted_vector(Xt_idxlist idxvec, Xt_config config)
Definition xt_idxvec.c:566
utility routines for MPI
#define xt_mpi_call(call, comm)
Definition xt_mpi.h:68
size_t xt_stripes_merge_copy(size_t num_stripes, struct Xt_stripe *stripes_dst, const struct Xt_stripe *stripes_src, bool lookback)
Definition xt_stripe.c:163
#define XT_SORT_FLAGS(ntrans_up, ntrans_dn)
@ sort_mask