 |
Mesh Oriented datABase
(version 5.5.1)
An array-based unstructured mesh library
|
|
Mesh Oriented datABase
(version 5.5.1)
An array-based unstructured mesh library
|
#include "mhdf.h"#include "util.h"#include "status.h"#include <assert.h>#include <stdlib.h>#include <string.h>#include <H5Tpublic.h>#include <H5Dpublic.h>#include <H5Ppublic.h>
Include dependency graph for file-desc.c:Go to the source code of this file.
Macros | |
| #define | FIX_OFFSET(TYPE, FIELD) |
Functions | |
| static struct mhdf_FileDesc * | alloc_file_desc (mhdf_Status *status) |
| static void * | realloc_data (struct mhdf_FileDesc **data, size_t append_bytes, mhdf_Status *status, int alignment) |
| void | mhdf_fixFileDesc (struct mhdf_FileDesc *copy_ptr, const struct mhdf_FileDesc *orig_addr) |
| Fix nested pointers for copied/moved FileDesc struct. More... | |
| static struct mhdf_FileDesc * | get_elem_desc (mhdf_FileHandle file_handle, struct mhdf_FileDesc *result, const char *elem_handle, int idx, mhdf_Status *status) |
| static unsigned | get_file_id_size (hid_t file_id_type, mhdf_Status *status) |
| static struct mhdf_FileDesc * | get_tag_desc (mhdf_FileHandle file_handle, struct mhdf_FileDesc *result, const char *name, int idx, hid_t type, mhdf_Status *status) |
| static void | free_string_list (char **list, int count) |
| struct mhdf_FileDesc * | mhdf_getFileSummary (mhdf_FileHandle file_handle, hid_t file_id_type, mhdf_Status *status, int extraSetInfo) |
| Get summary of data tables contained within file. More... | |
Variables | |
| static char | buffer [512] |
| #define FIX_OFFSET | ( | TYPE, | |
| FIELD | |||
| ) |
if( copy_ptr->FIELD != NULL ) \
copy_ptr->FIELD = (TYPE)( ( (char*)( copy_ptr->FIELD ) - (char*)orig_addr ) + (char*)copy_ptr )
Definition at line 73 of file file-desc.c.
|
static |
Definition at line 15 of file file-desc.c.
16 {
17 struct mhdf_FileDesc* result;
18 /* allocate a little short of a page */
19 result = (struct mhdf_FileDesc*)mhdf_malloc( 4000, status );
20 if( mhdf_isError( status ) ) return 0;
21
22 memset( result, 0, sizeof( struct mhdf_FileDesc ) );
23 result->total_size = 4000;
24 result->offset = ( (unsigned char*)result ) + sizeof( struct mhdf_FileDesc );
25 return result;
26 }
References mhdf_isError(), mhdf_malloc(), mhdf_FileDesc::offset, and mhdf_FileDesc::total_size.
Referenced by mhdf_getFileSummary().
|
static |
Definition at line 377 of file file-desc.c.
378 {
379 int i;
380 for( i = 0; i < count; ++i )
381 free( list[i] );
382 free( list );
383 }
Referenced by mhdf_getFileSummary().
|
static |
Definition at line 120 of file file-desc.c.
125 {
126 hid_t id_pair[2];
127 int poly;
128 void* ptr;
129 long junk;
130
131 ptr = realloc_data( &result, strlen( elem_handle ) + 1, status, sizeof( char ) );
132 if( !ptr ) return NULL;
133 strcpy( ptr, elem_handle );
134 result->elems[idx].handle = ptr;
135
136 mhdf_getElemTypeName( file_handle, elem_handle, buffer, sizeof( buffer ), status );
137 if( mhdf_isError( status ) )
138 {
139 free( result );
140 return NULL;
141 }
142
143 ptr = realloc_data( &result, strlen( buffer ) + 1, status, sizeof( char ) );
144 if( !ptr ) return NULL;
145 strcpy( ptr, buffer );
146 result->elems[idx].type = ptr;
147
148 poly = mhdf_isPolyElement( file_handle, elem_handle, status );
149 if( mhdf_isError( status ) )
150 {
151 free( result );
152 return NULL;
153 }
154
155 if( !poly )
156 {
157 id_pair[0] = mhdf_openConnectivity( file_handle, elem_handle, &result->elems[idx].desc.vals_per_ent,
158 &result->elems[idx].desc.count, &result->elems[idx].desc.start_id, status );
159 if( id_pair[0] < 0 )
160 {
161 free( result );
162 return NULL;
163 }
164 mhdf_closeData( file_handle, id_pair[0], status );
165 }
166 else
167 {
168 result->elems[idx].desc.vals_per_ent = -1;
169 mhdf_openPolyConnectivity( file_handle, elem_handle, &result->elems[idx].desc.count, &junk,
170 &result->elems[idx].desc.start_id, id_pair, status );
171 if( id_pair[0] < 0 )
172 {
173 free( result );
174 return NULL;
175 }
176 mhdf_closeData( file_handle, id_pair[0], status );
177 mhdf_closeData( file_handle, id_pair[1], status );
178 }
179
180 result->elems[idx].desc.dense_tag_indices = NULL;
181 result->elems[idx].desc.num_dense_tags = 0;
182 result->elems[idx].have_adj = mhdf_haveAdjacency( file_handle, result->elems[idx].handle, status );
183 if( mhdf_isError( status ) )
184 {
185 free( result );
186 return 0;
187 }
188
189 return result;
190 }
References buffer, mhdf_EntDesc::count, mhdf_EntDesc::dense_tag_indices, mhdf_ElemDesc::desc, mhdf_FileDesc::elems, mhdf_ElemDesc::handle, mhdf_ElemDesc::have_adj, mhdf_closeData(), mhdf_getElemTypeName(), mhdf_haveAdjacency(), mhdf_isError(), mhdf_isPolyElement(), mhdf_openConnectivity(), mhdf_openPolyConnectivity(), mhdf_EntDesc::num_dense_tags, realloc_data(), mhdf_EntDesc::start_id, mhdf_ElemDesc::type, and mhdf_EntDesc::vals_per_ent.
Referenced by mhdf_getFileSummary().
|
static |
Definition at line 192 of file file-desc.c.
193 {
194 if( H5Tget_class( file_id_type ) != H5T_INTEGER )
195 {
196 mhdf_setFail( status, "Invalid handle or type class for file ID type." );
197 return 0;
198 }
199
200 return H5Tget_size( file_id_type );
201 }
References mhdf_setFail().
Referenced by get_tag_desc().
|
static |
Definition at line 203 of file file-desc.c.
209 {
210 void* ptr;
211 int have_default, have_global;
212 int valsize, size, close_type = 0;
213 hsize_t array_len;
214
215 ptr = realloc_data( &result, strlen( name ) + 1, status, sizeof( char ) );
216 if( NULL == ptr ) return NULL;
217 strcpy( ptr, name );
218 result->tags[idx].name = ptr;
219
220 mhdf_getTagInfo( file_handle, name, &result->tags[idx].type, &result->tags[idx].size, &result->tags[idx].storage,
221 &have_default, &have_global, &result->tags[idx].have_sparse, status );
222 if( mhdf_isError( status ) )
223 {
224 free( result );
225 return NULL;
226 }
227
228 /* For variable length tags, have_default and have_global will
229 contain the size of the respective values. For fixed-length
230 tags, they are either zero or one. Simplify later code by
231 making them contain the size for both cases. */
232 valsize = result->tags[idx].size;
233 if( result->tags[idx].size >= 0 )
234 {
235 if( have_default ) have_default = valsize;
236 if( have_global ) have_global = valsize;
237 }
238
239 result->tags[idx].default_value = NULL;
240 result->tags[idx].default_value_size = have_default;
241 result->tags[idx].global_value = NULL;
242 result->tags[idx].global_value_size = have_global;
243
244 switch( result->tags[idx].type )
245 {
246 case mhdf_OPAQUE:
247 type = 0;
248 break;
249 case mhdf_BOOLEAN:
250 type = H5T_NATIVE_UCHAR;
251 break;
252 case mhdf_INTEGER:
253 type = H5T_NATIVE_INT;
254 have_default *= sizeof( int );
255 have_global *= sizeof( int );
256 valsize *= sizeof( int );
257 break;
258 case mhdf_FLOAT:
259 type = H5T_NATIVE_DOUBLE;
260 have_default *= sizeof( double );
261 have_global *= sizeof( double );
262 valsize *= sizeof( double );
263 break;
264 case mhdf_BITFIELD:
265 have_default = ( have_default + 7 ) / 8;
266 have_global = ( have_global + 7 ) / 8;
267 valsize = ( valsize + 7 ) / 8;
268 switch( valsize )
269 {
270 case 1:
271 type = H5Tcopy( H5T_NATIVE_B8 );
272 break;
273 case 2:
274 type = H5Tcopy( H5T_NATIVE_B16 );
275 break;
276 case 3:
277 case 4:
278 valsize += 4 - valsize; // to avoid fallthrough warning
279 type = H5Tcopy( H5T_NATIVE_B32 );
280 break;
281 case 5:
282 case 6:
283 case 7:
284 case 8:
285 valsize += 8 - valsize; // to avoid fallthrough warning
286 type = H5Tcopy( H5T_NATIVE_B64 );
287 break;
288 default:
289 free( result );
290 mhdf_setFail( status, "Cannot create a bit tag larger than 64-bits. %d bits requested.\n",
291 (int)valsize );
292 return NULL;
293 }
294 close_type = 1;
295 break;
296 case mhdf_ENTITY_ID:
297 if( 0 == type ) type = H5T_NATIVE_ULONG;
298 size = get_file_id_size( type, status );
299 if( !size )
300 {
301 free( result );
302 return NULL;
303 }
304 have_default *= size;
305 have_global *= size;
306 valsize *= size;
307 break;
308 default:
309 mhdf_setFail( status, "Unknown mhdf_TagDataType value (%d) for tag (\"%s\")", (int)result->tags[idx].type,
310 name );
311 free( result );
312 return NULL;
313 }
314 result->tags[idx].bytes = valsize;
315
316 if( result->tags[idx].type != mhdf_OPAQUE && result->tags[idx].type != mhdf_BITFIELD && result->tags[idx].size > 1 )
317 {
318 close_type = 1;
319 array_len = result->tags[idx].size;
320 #if defined( H5Tarray_create_vers ) && H5Tarray_create_vers > 1
321 type = H5Tarray_create2( type, 1, &array_len );
322 #else
323 type = H5Tarray_create( type, 1, &array_len, 0 );
324 #endif
325 if( type < 0 )
326 {
327 mhdf_setFail( status, "H5Tarray_create failed for tag (\"%s\")", name );
328 free( result );
329 return NULL;
330 }
331 }
332
333 if( have_default || have_global )
334 {
335 if( have_default )
336 {
337 ptr = realloc_data( &result, have_default, status, sizeof( int ) );
338 if( NULL == ptr )
339 {
340 if( close_type )
341 {
342 H5Tclose( type );
343 }
344 return NULL;
345 }
346 result->tags[idx].default_value = ptr;
347 }
348 if( have_global )
349 {
350 ptr = realloc_data( &result, have_global, status, sizeof( int ) );
351 if( NULL == ptr )
352 {
353 if( close_type )
354 {
355 H5Tclose( type );
356 }
357 return NULL;
358 }
359 result->tags[idx].global_value = ptr;
360 }
361 mhdf_getTagValues( file_handle, name, type, result->tags[idx].default_value, result->tags[idx].global_value,
362 status );
363 if( close_type )
364 {
365 H5Tclose( type );
366 }
367 if( mhdf_isError( status ) )
368 {
369 free( result );
370 return NULL;
371 }
372 }
373
374 return result;
375 }
References mhdf_TagDesc::bytes, mhdf_TagDesc::default_value, mhdf_TagDesc::default_value_size, get_file_id_size(), mhdf_TagDesc::global_value, mhdf_TagDesc::global_value_size, mhdf_TagDesc::have_sparse, mhdf_BITFIELD, mhdf_BOOLEAN, mhdf_ENTITY_ID, mhdf_FLOAT, mhdf_getTagInfo(), mhdf_getTagValues(), mhdf_INTEGER, mhdf_isError(), mhdf_OPAQUE, mhdf_setFail(), mhdf_TagDesc::name, realloc_data(), mhdf_TagDesc::size, size, mhdf_TagDesc::storage, mhdf_FileDesc::tags, and mhdf_TagDesc::type.
Referenced by mhdf_getFileSummary().
| void mhdf_fixFileDesc | ( | struct mhdf_FileDesc * | copy_ptr, |
| const struct mhdf_FileDesc * | orig_addr | ||
| ) |
Fix nested pointers for copied/moved FileDesc struct.
This is a utility method to facility copying/moving/communicating struct FileDesc instances. The structure and all data it references are allocated in a single contiguous block of memory of size FileDesc::total_size. As such, the struct can be copied with a single memcpy, packed into a single network packet, communicated with a single MPI call, etc. However, the pointers contained within the struct will not be valid in the copied instance (they will still point into the original instance.) Given a pointer to the copied struct and the address of the original struct, this function will updated all contained pointers.
Definition at line 77 of file file-desc.c.
78 {
79 int i;
80
81 API_BEGIN;
82 FIX_OFFSET( int*, nodes.dense_tag_indices );
83 FIX_OFFSET( int*, sets.dense_tag_indices );
84 FIX_OFFSET( struct mhdf_ElemDesc*, elems );
85 FIX_OFFSET( struct mhdf_TagDesc*, tags );
86
87 FIX_OFFSET( int*, numEntSets );
88 FIX_OFFSET( int**, defTagsEntSets );
89 FIX_OFFSET( int**, defTagsVals );
90
91 for( i = 0; i < 5; i++ )
92 {
93 if( copy_ptr->defTagsEntSets ) FIX_OFFSET( int*, defTagsEntSets[i] );
94 if( copy_ptr->defTagsVals ) FIX_OFFSET( int*, defTagsVals[i] );
95 }
96
97 if( copy_ptr->elems != NULL )
98 {
99 for( i = 0; i < copy_ptr->num_elem_desc; ++i )
100 {
101 FIX_OFFSET( const char*, elems[i].handle );
102 FIX_OFFSET( const char*, elems[i].type );
103 FIX_OFFSET( int*, elems[i].desc.dense_tag_indices );
104 }
105 }
106
107 if( copy_ptr->tags != NULL )
108 {
109 for( i = 0; i < copy_ptr->num_tag_desc; ++i )
110 {
111 FIX_OFFSET( const char*, tags[i].name );
112 FIX_OFFSET( void*, tags[i].default_value );
113 FIX_OFFSET( void*, tags[i].global_value );
114 FIX_OFFSET( int*, tags[i].dense_elem_indices );
115 }
116 }
117 API_END;
118 }
References API_BEGIN, API_END, mhdf_FileDesc::defTagsEntSets, mhdf_FileDesc::defTagsVals, mhdf_EntDesc::dense_tag_indices, mhdf_FileDesc::elems, FIX_OFFSET, mhdf_FileDesc::nodes, mhdf_FileDesc::num_elem_desc, mhdf_FileDesc::num_tag_desc, mhdf_FileDesc::numEntSets, mhdf_FileDesc::sets, and mhdf_FileDesc::tags.
Referenced by realloc_data(), and moab::ReadHDF5::set_up_read().
| struct mhdf_FileDesc* mhdf_getFileSummary | ( | mhdf_FileHandle | file_handle, |
| hid_t | file_id_type, | ||
| mhdf_Status * | status, | ||
| int | extraSetInfo | ||
| ) |
Get summary of data tables contained within file.
Returned struct, including all pointed-to data, is allocated in a single contiguous block of memory with a size equal to 'total_size'. Caller is responsible for freeing the returned struct FileDesc pointer (and only that pointer, not pointers nexted within the struct!). Caller may copy (e.g. MPI_BCast) entire struct as one contiguous block, assuming all nested pointers in the copy are updated to the correct relative offset from the beginning of the struct.
Definition at line 385 of file file-desc.c.
389 {
390 struct mhdf_FileDesc* result;
391 hid_t table_id;
392 int i, i1, numtags, j, k, size, *indices, have, num_tag_names = 0;
393 unsigned int ui;
394 void* ptr;
395 char **elem_handles = 0, **tag_names = 0;
396 unsigned char *array, *matrix;
397 const char* pname[5] = { "PARALLEL_PARTITION", "MATERIAL_SET", "NEUMANN_SET", "DIRICHLET_SET", "GEOM_DIMENSION" };
398
399 long* id_list;
400 struct mhdf_TagDesc* tag_desc;
401 long int nval, junk;
402 hid_t table[3];
403 hid_t data_type;
404
405 API_BEGIN;
406
407 mhdf_setOkay( status );
408 result = alloc_file_desc( status );
409 if( NULL == result ) return NULL;
410
411 /* get node info */
412 have = mhdf_haveNodes( file_handle, status );
413 if( mhdf_isError( status ) )
414 {
415 free( result );
416 return NULL;
417 }
418 if( have )
419 {
420 table_id = mhdf_openNodeCoords( file_handle, &result->nodes.count, &result->nodes.vals_per_ent,
421 &result->nodes.start_id, status );
422 if( table_id < 0 )
423 {
424 free( result );
425 return NULL;
426 }
427 mhdf_closeData( file_handle, table_id, status );
428 }
429 else
430 {
431 result->nodes.count = 0;
432 result->nodes.vals_per_ent = 0;
433 result->nodes.start_id = 0;
434 }
435
436 /* get set info */
437 result->sets.vals_per_ent = -1;
438 have = mhdf_haveSets( file_handle, &result->have_set_contents, &result->have_set_children,
439 &result->have_set_parents, status );
440 if( mhdf_isError( status ) )
441 {
442 free( result );
443 return NULL;
444 }
445 if( have )
446 {
447 table_id = mhdf_openSetMeta( file_handle, &result->sets.count, &result->sets.start_id, status );
448 if( table_id < 0 )
449 {
450 free( result );
451 return NULL;
452 }
453 mhdf_closeData( file_handle, table_id, status );
454 }
455 else
456 {
457 result->sets.count = 0;
458 result->sets.start_id = 0;
459 }
460
461 /* get element list */
462 elem_handles = mhdf_getElemHandles( file_handle, &ui, status );
463 if( elem_handles == NULL )
464 {
465 free( result );
466 return NULL;
467 }
468 result->num_elem_desc = ui;
469
470 /* allocate array of element descriptors */
471 size = result->num_elem_desc * sizeof( struct mhdf_ElemDesc );
472 ptr = realloc_data( &result, size, status, sizeof( char* ) );
473 if( NULL == ptr )
474 {
475 free( elem_handles );
476 return NULL;
477 }
478 memset( ptr, 0, size );
479 result->elems = ptr;
480
481 /* Initialize each element descriptor */
482 for( i = 0; i < result->num_elem_desc; ++i )
483 {
484 result = get_elem_desc( file_handle, result, elem_handles[i], i, status );
485 if( NULL == result )
486 {
487 free( elem_handles );
488 return NULL;
489 }
490 }
491
492 /* get tag list */
493 tag_names = mhdf_getTagNames( file_handle, &num_tag_names, status );
494 if( mhdf_isError( status ) )
495 {
496 free( elem_handles );
497 free( result );
498 return NULL;
499 }
500
501 /* allocate array of tag descriptors */
502 size = num_tag_names * sizeof( struct mhdf_TagDesc );
503 ptr = realloc_data( &result, size, status, sizeof( char* ) );
504 if( NULL == ptr )
505 {
506 free( elem_handles );
507 free_string_list( tag_names, result->num_tag_desc );
508 return NULL;
509 }
510 memset( ptr, 0, size );
511 result->tags = ptr;
512 result->num_tag_desc = num_tag_names;
513 memset( result->tags, 0, size );
514
515 /* Initialize each tag descriptor */
516 for( i = 0; i < result->num_tag_desc; ++i )
517 {
518 result = get_tag_desc( file_handle, result, tag_names[i], i, file_id_type, status );
519 if( NULL == result )
520 {
521 free( elem_handles );
522 free_string_list( tag_names, num_tag_names );
523 return NULL;
524 }
525 }
526
527 /* Determine which dense tags are present */
528
529 size = ( 2 + result->num_elem_desc ) * result->num_tag_desc;
530 array = mhdf_malloc( size, status );
531 if( NULL == array )
532 {
533 free( elem_handles );
534 free_string_list( tag_names, num_tag_names );
535 free( result );
536 return NULL;
537 }
538 memset( array, 0, size );
539 matrix = array + ( 2 * result->num_tag_desc );
540
541 for( j = 0; j < result->num_tag_desc; ++j )
542 {
543 if( mhdf_haveDenseTag( file_handle, tag_names[j], mhdf_node_type_handle(), status ) )
544 matrix[-1 * result->num_tag_desc + j] = 1;
545 if( mhdf_haveDenseTag( file_handle, tag_names[j], mhdf_set_type_handle(), status ) )
546 matrix[-2 * result->num_tag_desc + j] = 1;
547 for( i = 0; i < result->num_elem_desc; ++i )
548 if( mhdf_haveDenseTag( file_handle, tag_names[j], elem_handles[i], status ) )
549 matrix[i * result->num_tag_desc + j] = 1;
550 }
551 free( elem_handles );
552 free_string_list( tag_names, result->num_tag_desc );
553
554 /* Populate dense tag lists for element types */
555 for( i = -2; i < result->num_elem_desc; ++i )
556 {
557 size = 0;
558 for( j = 0; j < result->num_tag_desc; ++j )
559 size += matrix[i * result->num_tag_desc + j];
560 if( !size )
561 {
562 indices = NULL;
563 }
564 else
565 {
566 indices = realloc_data( &result, size * sizeof( int ), status, sizeof( int ) );
567 if( NULL == indices )
568 {
569 free( array );
570 return NULL;
571 }
572
573 k = 0;
574 for( j = 0; j < result->num_tag_desc; ++j )
575 if( matrix[i * result->num_tag_desc + j] ) indices[k++] = j;
576 assert( k == size );
577 }
578
579 if( i == -2 )
580 {
581 result->sets.dense_tag_indices = indices;
582 result->sets.num_dense_tags = size;
583 }
584 else if( i == -1 )
585 {
586 result->nodes.dense_tag_indices = indices;
587 result->nodes.num_dense_tags = size;
588 }
589 else
590 {
591 result->elems[i].desc.dense_tag_indices = indices;
592 result->elems[i].desc.num_dense_tags = size;
593 }
594 }
595
596 /* Populate dense tag lists for each tag */
597 for( j = 0; j < result->num_tag_desc; ++j )
598 {
599 size = 0;
600 for( i = -2; i < result->num_elem_desc; ++i )
601 size += matrix[i * result->num_tag_desc + j];
602 if( !size )
603 {
604 indices = 0;
605 }
606 else
607 {
608 indices = realloc_data( &result, size * sizeof( int ), status, sizeof( int ) );
609 if( NULL == ptr )
610 {
611 free( array );
612 return NULL;
613 }
614
615 k = 0;
616 for( i = -2; i < result->num_elem_desc; ++i )
617 if( matrix[i * result->num_tag_desc + j] ) indices[k++] = i;
618 assert( k == size );
619 }
620
621 result->tags[j].num_dense_indices = size;
622 result->tags[j].dense_elem_indices = indices;
623 }
624
625 if( extraSetInfo )
626 {
627 /* open the table for parallel partitions, material sets, neumann sets,
628 * dirichlet sets
629 * to determine number of parts, etc
630 * this is needed for iMOAB and VisIt plugin */
631 const int NPRIMARY_SETS = 5;
632 ptr = realloc_data( &result, NPRIMARY_SETS * sizeof( int ), status, sizeof( int ) );
633 if( NULL == ptr || mhdf_isError( status ) )
634 {
635 free( array );
636 return NULL;
637 }
638 result->numEntSets = ptr;
639 for( i = 0; i < NPRIMARY_SETS; ++i )
640 result->numEntSets[i] = 0;
641
642 ptr = realloc_data( &result, NPRIMARY_SETS * sizeof( int* ), status, sizeof( int* ) );
643 if( NULL == ptr || mhdf_isError( status ) )
644 {
645 free( array );
646 return NULL;
647 }
648 result->defTagsEntSets = ptr;
649
650 ptr = realloc_data( &result, NPRIMARY_SETS * sizeof( int* ), status, sizeof( int* ) );
651 if( NULL == ptr || mhdf_isError( status ) )
652 {
653 free( array );
654 return NULL;
655 }
656 result->defTagsVals = ptr;
657 numtags = result->num_tag_desc;
658
659 for( i = 0; i < numtags; i++ )
660 {
661 tag_desc = &( result->tags[i] );
662 for( k = 0; k < NPRIMARY_SETS; k++ ) /* number of default tags to consider */
663 {
664 if( strcmp( pname[k], tag_desc->name ) == 0 )
665 {
666 if( tag_desc->have_sparse )
667 {
668 mhdf_openSparseTagData( file_handle, pname[k], &nval, &junk, table, status );
669 if( mhdf_isError( status ) )
670 {
671 free( array );
672 return NULL;
673 }
674 /* for sparse tags, read */
675 result->numEntSets[k] = nval;
676 if( nval <= 0 ) continue; /* do not do anything */
677
678 ptr = realloc_data( &result, nval * sizeof( int ), status, sizeof( int ) );
679 if( NULL == ptr || mhdf_isError( status ) )
680 {
681 free( array );
682 return NULL;
683 }
684 memset( ptr, 0, nval * sizeof( int ) );
685 result->defTagsEntSets[k] = ptr;
686 tag_desc = &( result->tags[i] );
687
688 ptr = realloc_data( &result, nval * sizeof( int ), status, sizeof( int ) );
689 if( NULL == ptr || mhdf_isError( status ) )
690 {
691 free( array );
692 return NULL;
693 }
694 memset( ptr, 0, nval * sizeof( int ) );
695 result->defTagsVals[k] = ptr;
696 tag_desc = &( result->tags[i] ); /* this is because the tag might point to
697 something else*/
698
699 /* make room for the long array type
700 is it long or something else? */
701 id_list = mhdf_malloc( nval * sizeof( long ), status );
702 /* fill the id with values, then convert to int type (-set start)
703
704 mhdf_read_data( table_id, offset, count, int_type, id_list, H5P_DEFAULT,
705 status );*/
706
707 data_type = H5Dget_type( table[0] );
708
709 mhdf_read_data( table[0], 0, nval, data_type, id_list, H5P_DEFAULT, status );
710 if( mhdf_isError( status ) )
711 {
712 free( array );
713 return NULL;
714 }
715 H5Tclose( data_type );
716
717 for( i1 = 0; i1 < nval; i1++ )
718 result->defTagsEntSets[k][i1] = (int)( id_list[i1] - result->sets.start_id + 1 );
719 /* now read values, integer type */
720 data_type = H5Dget_type( table[1] );
721 mhdf_read_data( table[1], 0, nval, data_type, result->defTagsVals[k], H5P_DEFAULT, status );
722 if( mhdf_isError( status ) )
723 {
724 free( array );
725 return NULL;
726 }
727 H5Tclose( data_type );
728 mhdf_closeData( file_handle, table[0], status );
729 if( mhdf_isError( status ) )
730 {
731 free( array );
732 return NULL;
733 }
734 mhdf_closeData( file_handle, table[1], status );
735 if( mhdf_isError( status ) )
736 {
737 free( array );
738 return NULL;
739 }
740 free( id_list );
741 }
742 else if( 0 == k || 1 == k )
743 { /* parallel partition or material sets should still work if dense
744 could be dense tags on sets */
745 if( !mhdf_haveDenseTag( file_handle, pname[k], mhdf_set_type_handle(), status ) ) continue;
746 table[0] =
747 mhdf_openDenseTagData( file_handle, pname[k], mhdf_set_type_handle(), &nval, status );
748 if( mhdf_isError( status ) )
749 {
750 continue; /* do not error out if not a dense tag either */
751 }
752 result->numEntSets[k] = nval;
753 if( nval <= 0 ) continue; /* do not do anything */
754
755 /*
756 * if dense parallel partition or material set, we know what to expect
757 */
758 result->numEntSets[k] = nval; /* k could be 0 or 1 */
759 if( nval <= 0 ) continue; /* do not do anything */
760
761 ptr = realloc_data( &result, nval * sizeof( int ), status, sizeof( int ) );
762 if( NULL == ptr || mhdf_isError( status ) )
763 {
764 free( array );
765 return NULL;
766 }
767 memset( ptr, 0, nval * sizeof( int ) );
768 result->defTagsEntSets[k] = ptr;
769 tag_desc = &( result->tags[i] );
770
771 ptr = realloc_data( &result, nval * sizeof( int ), status, sizeof( int ) );
772 if( NULL == ptr || mhdf_isError( status ) )
773 {
774 free( array );
775 return NULL;
776 }
777 memset( ptr, 0, nval * sizeof( int ) );
778 result->defTagsVals[k] = ptr;
779 tag_desc = &( result->tags[i] ); /* this is because the tag might point to
780 something else*/
781
782 for( i1 = 0; i1 < nval; i1++ )
783 {
784 result->defTagsEntSets[k][i1] = i1 + 1;
785 /*result -> defTagsVals[k][i1] = i1; we know how the partition looks
786 * like */
787 }
788 /* fill in the data with the dense tag values
789 because dense, sets will be in order
790
791 we know it has to be integer */
792 mhdf_readTagValues( table[0], 0, nval, H5T_NATIVE_INT, result->defTagsVals[k], status );
793 if( mhdf_isError( status ) )
794 {
795 free( array );
796 return NULL;
797 }
798 mhdf_closeData( file_handle, table[0], status );
799 if( mhdf_isError( status ) )
800 {
801 free( array );
802 return NULL;
803 }
804 }
805 }
806 }
807 }
808 }
809 /* Compact memory and return */
810 free( array );
811 result->total_size = result->offset - (unsigned char*)result;
812
813 API_END;
814 return result;
815 }
References alloc_file_desc(), API_BEGIN, API_END, mhdf_EntDesc::count, mhdf_FileDesc::defTagsEntSets, mhdf_FileDesc::defTagsVals, mhdf_TagDesc::dense_elem_indices, mhdf_EntDesc::dense_tag_indices, mhdf_ElemDesc::desc, mhdf_FileDesc::elems, free_string_list(), get_elem_desc(), get_tag_desc(), mhdf_FileDesc::have_set_children, mhdf_FileDesc::have_set_contents, mhdf_FileDesc::have_set_parents, mhdf_TagDesc::have_sparse, mhdf_closeData(), mhdf_getElemHandles(), mhdf_getTagNames(), mhdf_haveDenseTag(), mhdf_haveNodes(), mhdf_haveSets(), mhdf_isError(), mhdf_malloc(), mhdf_node_type_handle(), mhdf_openDenseTagData(), mhdf_openNodeCoords(), mhdf_openSetMeta(), mhdf_openSparseTagData(), mhdf_read_data(), mhdf_readTagValues(), mhdf_set_type_handle(), mhdf_setOkay(), mhdf_TagDesc::name, mhdf_FileDesc::nodes, mhdf_TagDesc::num_dense_indices, mhdf_EntDesc::num_dense_tags, mhdf_FileDesc::num_elem_desc, mhdf_FileDesc::num_tag_desc, mhdf_FileDesc::numEntSets, mhdf_FileDesc::offset, realloc_data(), mhdf_FileDesc::sets, size, mhdf_EntDesc::start_id, mhdf_FileDesc::tags, mhdf_FileDesc::total_size, and mhdf_EntDesc::vals_per_ent.
Referenced by iMOAB_ReadHeaderInfo(), main(), and moab::ReadHDF5::set_up_read().
|
static |
Definition at line 28 of file file-desc.c.
29 {
30 void* result_ptr;
31 struct mhdf_FileDesc* const input_ptr = *data;
32 unsigned char* mem_ptr = (unsigned char*)input_ptr;
33
34 size_t new_size, occupied_size = input_ptr->offset - mem_ptr;
35
36 size_t append_bytes_padded = append_bytes + alignment - 1;
37 /* if the end of the allocated space is before the end of the required space */
38 if( mem_ptr + input_ptr->total_size < input_ptr->offset + append_bytes_padded )
39 {
40 if( append_bytes_padded < input_ptr->total_size )
41 new_size = 2 * input_ptr->total_size;
42 else
43 new_size = input_ptr->total_size + append_bytes_padded;
44 *data = (struct mhdf_FileDesc*)mhdf_realloc( *data, new_size, status );
45 if( mhdf_isError( status ) ) return 0;
46
47 /* if realloc moved us to a different location in memory,
48 * we need to update all of the internal pointers to
49 * new locations relative to the start of the struct */
50 if( *data != input_ptr )
51 {
52 mhdf_fixFileDesc( *data, input_ptr );
53 mem_ptr = (unsigned char*)( *data );
54 ( *data )->offset = mem_ptr + occupied_size;
55 }
56 ( *data )->total_size = new_size;
57 }
58
59 result_ptr = ( *data )->offset;
60 /* need to make this return pointer aligned */
61 uintptr_t addr = (uintptr_t)( ( *data )->offset );
62 int pad = addr % alignment;
63 if( pad > 0 )
64 {
65 ( *data )->offset += ( alignment - pad );
66 result_ptr = ( *data )->offset;
67 }
68 /*printf("new address %p \n", result_ptr);*/
69 ( *data )->offset += append_bytes;
70 return result_ptr;
71 }
References mhdf_fixFileDesc(), mhdf_isError(), mhdf_realloc(), mhdf_FileDesc::offset, and mhdf_FileDesc::total_size.
Referenced by get_elem_desc(), get_tag_desc(), and mhdf_getFileSummary().
|
static |
Definition at line 13 of file file-desc.c.
Referenced by moab::WriteHDF5Parallel::append_serial_tag_data(), moab::WriteHDF5Parallel::check_serial_tag_data(), check_valid_adjacencies(), check_valid_elem_conn(), check_valid_poly_conn(), moab::convert_to_ranged_ids(), file_exists(), get_elem_desc(), moab::ReadHDF5::get_tagged_entities(), moab::INT_IO_ERROR(), moab::mem_to_string(), mhdf_getElemHandles(), mhdf_getElemName(), mhdf_getElemTypeName(), mhdf_name_to_path_cat(), mhdf_name_to_path_copy(), moab::mpi_err_str(), moab::WriteHDF5::ExportSet::name(), moab::WriteHDF5Parallel::pack_set(), print_iGeom_error(), print_iMesh_error(), moab::print_range(), moab::DebugOutput::print_real(), moab::ErrorOutput::print_real(), moab::ReadHDF5Dataset::read(), moab::ReadHDF5::read_adjacencies(), moab::ReadHDF5::read_elems(), moab::ReadHDF5::read_node_adj_elems(), moab::ReadHDF5::read_nodes(), moab::ReadHDF5VarLen::read_offsets(), moab::ReadHDF5::read_poly(), moab::ReadHDF5::read_set_data(), moab::ReadHDF5::read_tag_values_partial(), moab::ReadHDF5::read_var_len_tag(), moab::ParCommGraph::receive_mesh(), moab::ParCommGraph::receive_tag_values(), moab::ReorderTool::reorder_tag_data(), moab::ReadHDF5::search_tag_values(), moab::ParCommGraph::send_graph_partition(), moab::ParCommGraph::send_mesh_parts(), moab::ParCommGraph::send_tag_values(), moab::ReadHDF5::store_file_ids(), moab::ReadHDF5::store_sets_file_ids(), string_tag_value(), moab::DebugOutput::tprint_real(), moab::WriteHDF5Parallel::unpack_set(), moab::WriteHDF5::write_adjacencies(), moab::WriteHDF5::write_elems(), moab::WriteHDF5::write_nodes(), moab::WriteHDF5::write_set_data(), moab::WriteHDF5::write_sets(), and moab::WriteHDF5::write_var_len_data().
1.9.1.