|
7 | 7 | * Copyright (c) 2013 Cisco Systems, Inc. All rights reserved. |
8 | 8 | * Copyright (c) 2017 Research Organization for Information Science |
9 | 9 | * and Technology (RIST). All rights reserved. |
| 10 | + * Copyright (c) 2020 IBM Corporation. All rights reserved. |
10 | 11 | * $COPYRIGHT$ |
11 | 12 | * |
12 | 13 | * Additional copyrights may follow |
|
22 | 23 |
|
23 | 24 | BEGIN_C_DECLS |
24 | 25 |
|
25 | | -typedef int32_t (*conversion_fct_t)( opal_convertor_t* pConvertor, uint32_t count, |
26 | | - const void* from, size_t from_len, ptrdiff_t from_extent, |
27 | | - void* to, size_t to_length, ptrdiff_t to_extent, |
28 | | - ptrdiff_t *advance ); |
| 26 | +#define COPY_TO_VECTOR 1 |
| 27 | +#define COPY_FROM_VECTOR 2 |
| 28 | +typedef size_t (*conversion_fct_t)( opal_convertor_t* pConvertor, int mode, |
| 29 | + char* vector_buf, |
| 30 | + size_t vector_len, |
| 31 | + size_t nblocks, |
| 32 | + size_t count_per_block, |
| 33 | + size_t extent_between_blocks, |
| 34 | + size_t vector_element_size, |
| 35 | + int vector_is_bigendian, |
| 36 | + char* packed_buf, |
| 37 | + size_t packed_len, |
| 38 | + size_t packed_element_size, |
| 39 | + int packed_is_bigendian, |
| 40 | + size_t *elements_done ); |
| 41 | + |
| 42 | +typedef struct { |
| 43 | + char *buf; // where to write next data |
| 44 | + size_t count_per_block; |
| 45 | + size_t extent_between_blocks; |
| 46 | + size_t element_size; |
| 47 | + size_t i; |
| 48 | + size_t j; |
| 49 | + size_t elements_done; |
| 50 | + size_t max_elements; |
| 51 | +} vector_iteration_state_t; |
| 52 | + |
| 53 | +#define VECTOR_INIT(buf_, \ |
| 54 | + len_, \ |
| 55 | + nblocks_, \ |
| 56 | + count_per_block_, \ |
| 57 | + extent_between_blocks_, \ |
| 58 | + element_size_, \ |
| 59 | + elements_already_done_, \ |
| 60 | + max_elements_) \ |
| 61 | +do { \ |
| 62 | + vec.buf = buf_; \ |
| 63 | + vec.count_per_block = count_per_block_; \ |
| 64 | + vec.extent_between_blocks = extent_between_blocks_; \ |
| 65 | + vec.element_size = element_size_; \ |
| 66 | + vec.i = 0; \ |
| 67 | + vec.j = 0; \ |
| 68 | + vec.elements_done = 0; \ |
| 69 | + \ |
| 70 | + /* vec.max_elements is the min of several factors: */ \ |
| 71 | + /* 1. what will fit in vec.buf based on its vec.len */ \ |
| 72 | + /* 2. nblocks * count_per_block */ \ |
| 73 | + /* 3. what is specified as max_elements to the macro */ \ |
| 74 | + /* for computing what will fit in vec.buf base on its len: */ \ |
| 75 | + /* number of complete blocks : vector_len / extent_between_blocks */ \ |
| 76 | + /* bytes left for the next block : vector_len % extent_between_blocks */ \ |
| 77 | + vec.max_elements = ((len_) / (extent_between_blocks_)) * (count_per_block_) \ |
| 78 | + + ((len_) % (extent_between_blocks_)) / (element_size_); \ |
| 79 | + if ((nblocks_) * (count_per_block_) < vec.max_elements) { \ |
| 80 | + vec.max_elements = (nblocks_) * (count_per_block_); \ |
| 81 | + } \ |
| 82 | + if ((max_elements_) < vec.max_elements) { \ |
| 83 | + vec.max_elements = (max_elements_); \ |
| 84 | + } \ |
| 85 | + \ |
| 86 | + if (elements_already_done_ != 0) { \ |
| 87 | + vec.i = elements_already_done_ / count_per_block_; \ |
| 88 | + vec.j = elements_already_done_ % count_per_block_; \ |
| 89 | + vec.buf += (vec.i * extent_between_blocks_ + vec.j * element_size_); \ |
| 90 | + vec.elements_done = elements_already_done_; \ |
| 91 | + } \ |
| 92 | +} while (0); |
| 93 | + |
| 94 | +#define VECTOR_GET_NEXT_CONTIG_BLOCK(elements_for_this_block) \ |
| 95 | +do { \ |
| 96 | + elements_for_this_block = vec.count_per_block - vec.j; \ |
| 97 | +/*printf("elements done so far: %d, j=%d\n", vec.elements_done, vec.j);*/ \ |
| 98 | + if (vec.elements_done + elements_for_this_block > vec.max_elements) { \ |
| 99 | + elements_for_this_block = vec.max_elements - vec.elements_done; \ |
| 100 | + } \ |
| 101 | +} while (0); |
| 102 | + |
| 103 | +#define VECTOR_UPDATE(elements_for_this_block) \ |
| 104 | +do { \ |
| 105 | + if (elements_for_this_block == vec.count_per_block) { \ |
| 106 | + vec.buf += vec.extent_between_blocks; \ |
| 107 | + } else { \ |
| 108 | + vec.j += elements_for_this_block; \ |
| 109 | + vec.buf += (elements_for_this_block * vec.element_size); \ |
| 110 | + if (vec.j == vec.count_per_block) { \ |
| 111 | + vec.j = 0; \ |
| 112 | + vec.buf -= (vec.count_per_block * vec.element_size); \ |
| 113 | + vec.buf += vec.extent_between_blocks; \ |
| 114 | + } \ |
| 115 | + } \ |
| 116 | + vec.elements_done += elements_for_this_block; \ |
| 117 | +} while (0); |
29 | 118 |
|
30 | 119 | typedef struct opal_convertor_master_t { |
31 | 120 | struct opal_convertor_master_t* next; |
|
0 commit comments