This source file includes following definitions.
- opal_pack_homogeneous_contig_function
- opal_pack_homogeneous_contig_with_gaps_function
- opal_generic_simple_pack_function
- pack_predefined_heterogeneous
- opal_pack_general_function
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 #include "opal_config.h"
25
26 #include <stddef.h>
27
28 #include "opal/datatype/opal_convertor_internal.h"
29 #include "opal/datatype/opal_datatype_internal.h"
30
31 #if OPAL_ENABLE_DEBUG
32 #include "opal/util/output.h"
33
34 #define DO_DEBUG(INST) if( opal_pack_debug ) { INST }
35 #else
36 #define DO_DEBUG(INST)
37 #endif
38
39 #include "opal/datatype/opal_datatype_checksum.h"
40 #include "opal/datatype/opal_datatype_pack.h"
41 #include "opal/datatype/opal_datatype_prototypes.h"
42
43 #if defined(CHECKSUM)
44 #define opal_pack_homogeneous_contig_function opal_pack_homogeneous_contig_checksum
45 #define opal_pack_homogeneous_contig_with_gaps_function opal_pack_homogeneous_contig_with_gaps_checksum
46 #define opal_generic_simple_pack_function opal_generic_simple_pack_checksum
47 #define opal_pack_general_function opal_pack_general_checksum
48 #else
49 #define opal_pack_homogeneous_contig_function opal_pack_homogeneous_contig
50 #define opal_pack_homogeneous_contig_with_gaps_function opal_pack_homogeneous_contig_with_gaps
51 #define opal_generic_simple_pack_function opal_generic_simple_pack
52 #define opal_pack_general_function opal_pack_general
53 #endif
54
55
56 #define IOVEC_MEM_LIMIT 8192
57
58
59
60
61 int32_t
62 opal_pack_homogeneous_contig_function( opal_convertor_t* pConv,
63 struct iovec* iov,
64 uint32_t* out_size,
65 size_t* max_data )
66 {
67 dt_stack_t* pStack = pConv->pStack;
68 unsigned char *source_base = NULL;
69 uint32_t iov_count;
70 size_t length = pConv->local_size - pConv->bConverted, initial_amount = pConv->bConverted;
71 ptrdiff_t initial_displ = pConv->use_desc->desc[pConv->use_desc->used].end_loop.first_elem_disp;
72
73 source_base = (pConv->pBaseBuf + initial_displ + pStack[0].disp + pStack[1].disp);
74
75
76
77
78 for( iov_count = 0; iov_count < (*out_size); iov_count++ ) {
79 if( 0 == length ) break;
80 if( (size_t)iov[iov_count].iov_len > length )
81 iov[iov_count].iov_len = length;
82 if( iov[iov_count].iov_base == NULL ) {
83 iov[iov_count].iov_base = (IOVBASE_TYPE *) source_base;
84 COMPUTE_CSUM( iov[iov_count].iov_base, iov[iov_count].iov_len, pConv );
85 } else {
86
87 OPAL_DATATYPE_SAFEGUARD_POINTER( source_base, iov[iov_count].iov_len,
88 pConv->pBaseBuf, pConv->pDesc, pConv->count );
89 MEMCPY_CSUM( iov[iov_count].iov_base, source_base, iov[iov_count].iov_len, pConv );
90 }
91 length -= iov[iov_count].iov_len;
92 pConv->bConverted += iov[iov_count].iov_len;
93 pStack[0].disp += iov[iov_count].iov_len;
94 source_base += iov[iov_count].iov_len;
95 }
96
97
98 *max_data = pConv->bConverted - initial_amount;
99 *out_size = iov_count;
100 if( pConv->bConverted == pConv->local_size ) {
101 pConv->flags |= CONVERTOR_COMPLETED;
102 return 1;
103 }
104 return 0;
105 }
106
107
108 int32_t
109 opal_pack_homogeneous_contig_with_gaps_function( opal_convertor_t* pConv,
110 struct iovec* iov,
111 uint32_t* out_size,
112 size_t* max_data )
113 {
114 const opal_datatype_t* pData = pConv->pDesc;
115 dt_stack_t* stack = pConv->pStack;
116 unsigned char *user_memory, *packed_buffer;
117 uint32_t iov_count, index;
118 size_t i;
119 size_t bConverted, remaining, length, initial_bytes_converted = pConv->bConverted;
120 ptrdiff_t extent= pData->ub - pData->lb;
121 ptrdiff_t initial_displ = pConv->use_desc->desc[pConv->use_desc->used].end_loop.first_elem_disp;
122
123 assert( (pData->flags & OPAL_DATATYPE_FLAG_CONTIGUOUS) && ((ptrdiff_t)pData->size != extent) );
124 DO_DEBUG( opal_output( 0, "pack_homogeneous_contig( pBaseBuf %p, iov_count %d )\n",
125 (void*)pConv->pBaseBuf, *out_size ); );
126 if( stack[1].type != opal_datatype_uint1.id ) {
127 stack[1].count *= opal_datatype_basicDatatypes[stack[1].type]->size;
128 stack[1].type = opal_datatype_uint1.id;
129 }
130
131
132
133
134 for( iov_count = 0; iov_count < (*out_size); iov_count++ ) {
135
136 remaining = pConv->local_size - pConv->bConverted;
137 if( 0 == remaining ) break;
138 if( remaining > iov[iov_count].iov_len )
139 remaining = iov[iov_count].iov_len;
140 packed_buffer = (unsigned char *)iov[iov_count].iov_base;
141 bConverted = remaining;
142 user_memory = pConv->pBaseBuf + initial_displ + stack[0].disp + stack[1].disp;
143 i = pConv->count - stack[0].count;
144 assert(i == (pConv->bConverted / pData->size));
145
146 if( packed_buffer == NULL ) {
147
148
149
150
151 if( stack->count < (size_t)((*out_size) - iov_count) ) {
152 stack[1].count = pData->size - (pConv->bConverted % pData->size);
153 for( index = iov_count; i < pConv->count; i++, index++ ) {
154 iov[index].iov_base = (IOVBASE_TYPE *) user_memory;
155 iov[index].iov_len = stack[1].count;
156 stack[0].disp += extent;
157 pConv->bConverted += stack[1].count;
158 stack[1].disp = 0;
159 stack[1].count = pData->size;
160 user_memory = pConv->pBaseBuf + initial_displ + stack[0].disp;
161 COMPUTE_CSUM( iov[index].iov_base, iov[index].iov_len, pConv );
162 }
163 *out_size = iov_count + index;
164 *max_data = (pConv->bConverted - initial_bytes_converted);
165 pConv->flags |= CONVERTOR_COMPLETED;
166 return 1;
167 }
168
169 if( pData->size >= IOVEC_MEM_LIMIT ) {
170
171
172
173 for( index = iov_count; (i < pConv->count) && (index < (*out_size));
174 i++, index++ ) {
175 if( remaining < pData->size ) {
176 iov[index].iov_base = (IOVBASE_TYPE *) user_memory;
177 iov[index].iov_len = remaining;
178 remaining = 0;
179 COMPUTE_CSUM( iov[index].iov_base, iov[index].iov_len, pConv );
180 break;
181 } else {
182 iov[index].iov_base = (IOVBASE_TYPE *) user_memory;
183 iov[index].iov_len = pData->size;
184 user_memory += extent;
185 COMPUTE_CSUM( iov[index].iov_base, (size_t)iov[index].iov_len, pConv );
186 }
187 remaining -= iov[index].iov_len;
188 pConv->bConverted += iov[index].iov_len;
189 }
190 *out_size = index;
191 *max_data = (pConv->bConverted - initial_bytes_converted);
192 if( pConv->bConverted == pConv->local_size ) {
193 pConv->flags |= CONVERTOR_COMPLETED;
194 return 1;
195 }
196 return 0;
197 }
198 }
199
200 {
201 DO_DEBUG( opal_output( 0, "pack_homogeneous_contig( user_memory %p, packed_buffer %p length %lu\n",
202 (void*)user_memory, (void*)packed_buffer, (unsigned long)remaining ); );
203
204 length = (0 == pConv->stack_pos ? 0 : stack[1].count);
205
206 if( (0 != length) && (length <= remaining)) {
207
208 OPAL_DATATYPE_SAFEGUARD_POINTER( user_memory, length, pConv->pBaseBuf,
209 pData, pConv->count );
210 DO_DEBUG( opal_output( 0, "2. pack dest %p src %p length %lu\n",
211 (void*)user_memory, (void*)packed_buffer, (unsigned long)length ); );
212 MEMCPY_CSUM( packed_buffer, user_memory, length, pConv );
213 packed_buffer += length;
214 user_memory += (extent - pData->size + length);
215 remaining -= length;
216 stack[1].count -= length;
217 if( 0 == stack[1].count) {
218 stack[0].count--;
219 stack[0].disp += extent;
220 if( 0 != stack[0].count ) {
221 stack[1].count = pData->size;
222 stack[1].disp = 0;
223 }
224 }
225 }
226 for( i = 0; pData->size <= remaining; i++ ) {
227 OPAL_DATATYPE_SAFEGUARD_POINTER( user_memory, pData->size, pConv->pBaseBuf,
228 pData, pConv->count );
229 DO_DEBUG( opal_output( 0, "3. pack dest %p src %p length %lu\n",
230 (void*)user_memory, (void*)packed_buffer, (unsigned long)pData->size ); );
231 MEMCPY_CSUM( packed_buffer, user_memory, pData->size, pConv );
232 packed_buffer += pData->size;
233 user_memory += extent;
234 remaining -= pData->size;
235 }
236 stack[0].count -= i;
237 stack[0].disp += (i * extent);
238 stack[1].disp += remaining;
239
240 if( 0 != remaining ) {
241 OPAL_DATATYPE_SAFEGUARD_POINTER( user_memory, remaining, pConv->pBaseBuf,
242 pData, pConv->count );
243 DO_DEBUG( opal_output( 0, "4. pack dest %p src %p length %lu\n",
244 (void*)user_memory, (void*)packed_buffer, (unsigned long)remaining ); );
245 MEMCPY_CSUM( packed_buffer, user_memory, remaining, pConv );
246 user_memory += remaining;
247 stack[1].count -= remaining;
248 }
249 if( 0 == stack[1].count ) {
250 stack[1].count = pData->size;
251 stack[1].disp = 0;
252 }
253 }
254 pConv->bConverted += bConverted;
255 }
256 *out_size = iov_count;
257 *max_data = (pConv->bConverted - initial_bytes_converted);
258 if( pConv->bConverted == pConv->local_size ) {
259 pConv->flags |= CONVERTOR_COMPLETED;
260 return 1;
261 }
262 return 0;
263 }
264
265
266
267
268
269
270
271
272
273
274
275 int32_t
276 opal_generic_simple_pack_function( opal_convertor_t* pConvertor,
277 struct iovec* iov, uint32_t* out_size,
278 size_t* max_data )
279 {
280 dt_stack_t* pStack;
281 uint32_t pos_desc;
282 size_t count_desc;
283 size_t total_packed = 0;
284 dt_elem_desc_t* description;
285 dt_elem_desc_t* pElem;
286 const opal_datatype_t *pData = pConvertor->pDesc;
287 unsigned char *conv_ptr, *iov_ptr;
288 size_t iov_len_local;
289 uint32_t iov_count;
290
291 DO_DEBUG( opal_output( 0, "opal_convertor_generic_simple_pack( %p:%p, {%p, %lu}, %d )\n",
292 (void*)pConvertor, (void*)pConvertor->pBaseBuf,
293 (void*)iov[0].iov_base, (unsigned long)iov[0].iov_len, *out_size ); );
294
295 description = pConvertor->use_desc->desc;
296
297
298
299
300
301 pStack = pConvertor->pStack + pConvertor->stack_pos;
302 pos_desc = pStack->index;
303 conv_ptr = pConvertor->pBaseBuf + pStack->disp;
304 count_desc = pStack->count;
305 pStack--;
306 pConvertor->stack_pos--;
307 pElem = &(description[pos_desc]);
308
309 DO_DEBUG( opal_output( 0, "pack start pos_desc %d count_desc %" PRIsize_t " disp %ld\n"
310 "stack_pos %d pos_desc %d count_desc %" PRIsize_t " disp %ld\n",
311 pos_desc, count_desc, (long)(conv_ptr - pConvertor->pBaseBuf),
312 pConvertor->stack_pos, pStack->index, pStack->count, pStack->disp ); );
313
314 for( iov_count = 0; iov_count < (*out_size); iov_count++ ) {
315 iov_ptr = (unsigned char *) iov[iov_count].iov_base;
316 iov_len_local = iov[iov_count].iov_len;
317 while( 1 ) {
318 while( pElem->elem.common.flags & OPAL_DATATYPE_FLAG_DATA ) {
319
320 PACK_PREDEFINED_DATATYPE( pConvertor, pElem, count_desc,
321 conv_ptr, iov_ptr, iov_len_local );
322 if( 0 == count_desc ) {
323 conv_ptr = pConvertor->pBaseBuf + pStack->disp;
324 pos_desc++;
325 UPDATE_INTERNAL_COUNTERS( description, pos_desc, pElem, count_desc );
326 continue;
327 }
328 goto complete_loop;
329 }
330 if( OPAL_DATATYPE_END_LOOP == pElem->elem.common.type ) {
331 DO_DEBUG( opal_output( 0, "pack end_loop count %" PRIsize_t " stack_pos %d"
332 " pos_desc %d disp %ld space %lu\n",
333 pStack->count, pConvertor->stack_pos,
334 pos_desc, pStack->disp, (unsigned long)iov_len_local ); );
335 if( --(pStack->count) == 0 ) {
336 if( 0 == pConvertor->stack_pos ) {
337
338 *out_size = iov_count;
339 goto complete_loop;
340 }
341 pConvertor->stack_pos--;
342 pStack--;
343 pos_desc++;
344 } else {
345 pos_desc = pStack->index + 1;
346 if( pStack->index == -1 ) {
347 pStack->disp += (pData->ub - pData->lb);
348 } else {
349 assert( OPAL_DATATYPE_LOOP == description[pStack->index].loop.common.type );
350 pStack->disp += description[pStack->index].loop.extent;
351 }
352 }
353 conv_ptr = pConvertor->pBaseBuf + pStack->disp;
354 UPDATE_INTERNAL_COUNTERS( description, pos_desc, pElem, count_desc );
355 DO_DEBUG( opal_output( 0, "pack new_loop count %" PRIsize_t " stack_pos %d pos_desc %d count_desc %" PRIsize_t " disp %ld space %lu\n",
356 pStack->count, pConvertor->stack_pos, pos_desc,
357 count_desc, pStack->disp, (unsigned long)iov_len_local ); );
358 }
359 if( OPAL_DATATYPE_LOOP == pElem->elem.common.type ) {
360 ptrdiff_t local_disp = (ptrdiff_t)conv_ptr;
361 if( pElem->loop.common.flags & OPAL_DATATYPE_FLAG_CONTIGUOUS ) {
362 PACK_CONTIGUOUS_LOOP( pConvertor, pElem, count_desc,
363 conv_ptr, iov_ptr, iov_len_local );
364 if( 0 == count_desc ) {
365 pos_desc += pElem->loop.items + 1;
366 goto update_loop_description;
367 }
368
369 }
370 local_disp = (ptrdiff_t)conv_ptr - local_disp;
371 PUSH_STACK( pStack, pConvertor->stack_pos, pos_desc, OPAL_DATATYPE_LOOP, count_desc,
372 pStack->disp + local_disp);
373 pos_desc++;
374 update_loop_description:
375 conv_ptr = pConvertor->pBaseBuf + pStack->disp;
376 UPDATE_INTERNAL_COUNTERS( description, pos_desc, pElem, count_desc );
377 DDT_DUMP_STACK( pConvertor->pStack, pConvertor->stack_pos, pElem, "advance loop" );
378 }
379 }
380 complete_loop:
381 iov[iov_count].iov_len -= iov_len_local;
382 total_packed += iov[iov_count].iov_len;
383 }
384 *max_data = total_packed;
385 pConvertor->bConverted += total_packed;
386 *out_size = iov_count;
387 if( pConvertor->bConverted == pConvertor->local_size ) {
388 pConvertor->flags |= CONVERTOR_COMPLETED;
389 return 1;
390 }
391
392 PUSH_STACK( pStack, pConvertor->stack_pos, pos_desc, pElem->elem.common.type, count_desc,
393 conv_ptr - pConvertor->pBaseBuf );
394 DO_DEBUG( opal_output( 0, "pack save stack stack_pos %d pos_desc %d count_desc %" PRIsize_t " disp %ld\n",
395 pConvertor->stack_pos, pStack->index, pStack->count, pStack->disp ); );
396 return 0;
397 }
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412 static inline void
413 pack_predefined_heterogeneous( opal_convertor_t* CONVERTOR,
414 const dt_elem_desc_t* ELEM,
415 size_t* COUNT,
416 unsigned char** SOURCE,
417 unsigned char** DESTINATION,
418 size_t* SPACE )
419 {
420 const opal_convertor_master_t* master = (CONVERTOR)->master;
421 const ddt_elem_desc_t* _elem = &((ELEM)->elem);
422 unsigned char* _source = (*SOURCE) + _elem->disp;
423 ptrdiff_t advance;
424 size_t _count = *(COUNT);
425 size_t _r_blength;
426
427 _r_blength = master->remote_sizes[_elem->common.type];
428 if( (_count * _r_blength) > *(SPACE) ) {
429 _count = (*(SPACE) / _r_blength);
430 if( 0 == _count ) return;
431 }
432
433 OPAL_DATATYPE_SAFEGUARD_POINTER( _source, (_count * _elem->extent), (CONVERTOR)->pBaseBuf,
434 (CONVERTOR)->pDesc, (CONVERTOR)->count );
435 DO_DEBUG( opal_output( 0, "pack [l %s r %s] memcpy( %p, %p, %lu ) => space %lu\n",
436 ((ptrdiff_t)(opal_datatype_basicDatatypes[_elem->common.type]->size) == _elem->extent) ? "cont" : "----",
437 ((ptrdiff_t)_r_blength == _elem->extent) ? "cont" : "----",
438 (void*)*(DESTINATION), (void*)_source, (unsigned long)_r_blength,
439 (unsigned long)(*(SPACE)) ); );
440 master->pFunctions[_elem->common.type]( CONVERTOR, _count,
441 _source, *SPACE, _elem->extent,
442 *DESTINATION, *SPACE, _r_blength,
443 &advance );
444 _r_blength *= _count;
445 *(SOURCE) += _count * _elem->extent;
446 *(DESTINATION) += _r_blength;
447 *(SPACE) -= _r_blength;
448 *(COUNT) -= _count;
449 }
450
451 int32_t
452 opal_pack_general_function( opal_convertor_t* pConvertor,
453 struct iovec* iov, uint32_t* out_size,
454 size_t* max_data )
455 {
456 dt_stack_t* pStack;
457 uint32_t pos_desc;
458 size_t count_desc;
459 size_t total_packed = 0;
460 dt_elem_desc_t* description;
461 dt_elem_desc_t* pElem;
462 const opal_datatype_t *pData = pConvertor->pDesc;
463 unsigned char *conv_ptr, *iov_ptr;
464 size_t iov_len_local;
465 uint32_t iov_count;
466
467 DO_DEBUG( opal_output( 0, "opal_convertor_general_pack( %p:%p, {%p, %lu}, %d )\n",
468 (void*)pConvertor, (void*)pConvertor->pBaseBuf,
469 (void*)iov[0].iov_base, (unsigned long)iov[0].iov_len, *out_size ); );
470
471 description = pConvertor->use_desc->desc;
472
473
474
475
476
477 pStack = pConvertor->pStack + pConvertor->stack_pos;
478 pos_desc = pStack->index;
479 conv_ptr = pConvertor->pBaseBuf + pStack->disp;
480 count_desc = pStack->count;
481 pStack--;
482 pConvertor->stack_pos--;
483 pElem = &(description[pos_desc]);
484
485 DO_DEBUG( opal_output( 0, "pack start pos_desc %d count_desc %" PRIsize_t " disp %ld\n"
486 "stack_pos %d pos_desc %d count_desc %" PRIsize_t " disp %ld\n",
487 pos_desc, count_desc, (long)(conv_ptr - pConvertor->pBaseBuf),
488 pConvertor->stack_pos, pStack->index, pStack->count, pStack->disp ); );
489
490 for( iov_count = 0; iov_count < (*out_size); iov_count++ ) {
491 iov_ptr = (unsigned char *) iov[iov_count].iov_base;
492 iov_len_local = iov[iov_count].iov_len;
493 while( 1 ) {
494 while( pElem->elem.common.flags & OPAL_DATATYPE_FLAG_DATA ) {
495
496 DO_DEBUG( opal_output( 0, "pack (%p:%ld, %" PRIsize_t ", %ld) -> (%p, %ld) type %s\n",
497 (void*)pConvertor->pBaseBuf, conv_ptr + pElem->elem.disp - pConvertor->pBaseBuf,
498 count_desc, description[pos_desc].elem.extent,
499 (void*)iov_ptr, iov_len_local,
500 opal_datatype_basicDatatypes[pElem->elem.common.type]->name ); );
501
502 pack_predefined_heterogeneous( pConvertor, pElem, &count_desc,
503 &conv_ptr, &iov_ptr, &iov_len_local);
504 #if 0
505 PACK_PREDEFINED_DATATYPE( pConvertor, pElem, count_desc,
506 conv_ptr, iov_ptr, iov_len_local );
507 #endif
508 if( 0 == count_desc ) {
509 conv_ptr = pConvertor->pBaseBuf + pStack->disp;
510 pos_desc++;
511 UPDATE_INTERNAL_COUNTERS( description, pos_desc, pElem, count_desc );
512 continue;
513 }
514 goto complete_loop;
515 }
516 if( OPAL_DATATYPE_END_LOOP == pElem->elem.common.type ) {
517 DO_DEBUG( opal_output( 0, "pack end_loop count %" PRIsize_t " stack_pos %d"
518 " pos_desc %d disp %ld space %lu\n",
519 pStack->count, pConvertor->stack_pos,
520 pos_desc, pStack->disp, (unsigned long)iov_len_local ); );
521 if( --(pStack->count) == 0 ) {
522 if( 0 == pConvertor->stack_pos ) {
523
524
525
526 *out_size = iov_count;
527 goto complete_loop;
528 }
529 pConvertor->stack_pos--;
530 pStack--;
531 pos_desc++;
532 } else {
533 pos_desc = pStack->index + 1;
534 if( pStack->index == -1 ) {
535 pStack->disp += (pData->ub - pData->lb);
536 } else {
537 assert( OPAL_DATATYPE_LOOP == description[pStack->index].loop.common.type );
538 pStack->disp += description[pStack->index].loop.extent;
539 }
540 }
541 conv_ptr = pConvertor->pBaseBuf + pStack->disp;
542 UPDATE_INTERNAL_COUNTERS( description, pos_desc, pElem, count_desc );
543 DO_DEBUG( opal_output( 0, "pack new_loop count %" PRIsize_t " stack_pos %d pos_desc %d count_desc %" PRIsize_t " disp %ld space %lu\n",
544 pStack->count, pConvertor->stack_pos, pos_desc,
545 count_desc, pStack->disp, (unsigned long)iov_len_local ); );
546 }
547 if( OPAL_DATATYPE_LOOP == pElem->elem.common.type ) {
548 ptrdiff_t local_disp = (ptrdiff_t)conv_ptr;
549 #if 0
550 if( pElem->loop.common.flags & OPAL_DATATYPE_FLAG_CONTIGUOUS ) {
551 PACK_CONTIGUOUS_LOOP( pConvertor, pElem, count_desc,
552 conv_ptr, iov_ptr, iov_len_local );
553 if( 0 == count_desc ) {
554 pos_desc += pElem->loop.items + 1;
555 goto update_loop_description;
556 }
557
558 }
559 #endif
560 local_disp = (ptrdiff_t)conv_ptr - local_disp;
561 PUSH_STACK( pStack, pConvertor->stack_pos, pos_desc, OPAL_DATATYPE_LOOP, count_desc,
562 pStack->disp + local_disp);
563 pos_desc++;
564 #if 0
565 update_loop_description:
566 #endif
567 conv_ptr = pConvertor->pBaseBuf + pStack->disp;
568 UPDATE_INTERNAL_COUNTERS( description, pos_desc, pElem, count_desc );
569 DDT_DUMP_STACK( pConvertor->pStack, pConvertor->stack_pos, pElem, "advance loop" );
570 continue;
571 }
572 }
573 complete_loop:
574 iov[iov_count].iov_len -= iov_len_local;
575 total_packed += iov[iov_count].iov_len;
576 }
577 *max_data = total_packed;
578 pConvertor->bConverted += total_packed;
579 *out_size = iov_count;
580 if( pConvertor->bConverted == pConvertor->local_size ) {
581 pConvertor->flags |= CONVERTOR_COMPLETED;
582 return 1;
583 }
584
585 PUSH_STACK( pStack, pConvertor->stack_pos, pos_desc, pElem->elem.common.type, count_desc,
586 conv_ptr - pConvertor->pBaseBuf );
587 DO_DEBUG( opal_output( 0, "pack save stack stack_pos %d pos_desc %d count_desc %" PRIsize_t" disp %ld\n",
588 pConvertor->stack_pos, pStack->index, pStack->count, pStack->disp ); );
589 return 0;
590 }