Branch data Line data Source code
1 : : #include "SequenceData.hpp"
2 : : #include "SysUtil.hpp"
3 : : #include "VarLenTag.hpp"
4 : : #include <assert.h>
5 : :
6 : : namespace moab
7 : : {
8 : :
9 : 2951 : SequenceData::~SequenceData()
10 : : {
11 [ + + ]: 6535 : for( int i = -numSequenceData; i <= (int)numTagData; ++i )
12 : 5030 : free( arraySet[i] );
13 : 1505 : free( arraySet - numSequenceData );
14 [ - + ]: 2951 : }
15 : :
16 : 3152 : void* SequenceData::create_data( int index, int bytes_per_ent, const void* initial_value )
17 : : {
18 : 3152 : char* array = (char*)malloc( bytes_per_ent * size() );
19 [ + + ]: 3152 : if( initial_value ) SysUtil::setmem( array, initial_value, bytes_per_ent, size() );
20 : :
21 : 3152 : arraySet[index] = array;
22 : 3152 : return array;
23 : : }
24 : :
25 : 2325 : void* SequenceData::create_sequence_data( int array_num, int bytes_per_ent, const void* initial_value )
26 : : {
27 : 2325 : const int index = -1 - array_num;
28 [ - + ]: 2325 : assert( array_num < numSequenceData );
29 [ - + ]: 2325 : assert( !arraySet[index] );
30 : 2325 : return create_data( index, bytes_per_ent, initial_value );
31 : : }
32 : :
33 : 0 : void* SequenceData::create_custom_data( int array_num, size_t total_bytes )
34 : : {
35 : 0 : const int index = -1 - array_num;
36 [ # # ]: 0 : assert( array_num < numSequenceData );
37 [ # # ]: 0 : assert( !arraySet[index] );
38 : :
39 : 0 : void* array = malloc( total_bytes );
40 : 0 : arraySet[index] = array;
41 : 0 : return array;
42 : : }
43 : :
44 : 362 : SequenceData::AdjacencyDataType* SequenceData::allocate_adjacency_data()
45 : : {
46 [ - + ]: 362 : assert( !arraySet[0] );
47 : 362 : const size_t s = sizeof( AdjacencyDataType* ) * size();
48 : 362 : arraySet[0] = malloc( s );
49 : 362 : memset( arraySet[0], 0, s );
50 : 362 : return reinterpret_cast< AdjacencyDataType* >( arraySet[0] );
51 : : }
52 : :
53 : 812 : void SequenceData::increase_tag_count( unsigned amount )
54 : : {
55 : 812 : void** list = arraySet - numSequenceData;
56 : 812 : const size_t sz = sizeof( void* ) * ( numSequenceData + numTagData + amount + 1 );
57 : 812 : void** new_list = (void**)realloc( list, sz );
58 [ - + ]: 812 : if( !new_list )
59 : : {
60 : 0 : fprintf( stderr, "SequenceData::increase_tag_count(): reallocation of list failed\n" );
61 : : // Note: free(list) will be called in the destructor
62 : 0 : return;
63 : : }
64 : : else
65 : 812 : list = new_list;
66 : 812 : arraySet = list + numSequenceData;
67 : 812 : memset( arraySet + numTagData + 1, 0, sizeof( void* ) * amount );
68 : 812 : numTagData += amount;
69 : : }
70 : :
71 : 827 : void* SequenceData::allocate_tag_array( int tag_num, int bytes_per_ent, const void* default_value )
72 : : {
73 [ + + ]: 827 : if( (unsigned)tag_num >= numTagData ) increase_tag_count( tag_num - numTagData + 1 );
74 : :
75 [ - + ]: 827 : assert( !arraySet[tag_num + 1] );
76 : 827 : return create_data( tag_num + 1, bytes_per_ent, default_value );
77 : : }
78 : :
79 : 6 : SequenceData* SequenceData::subset( EntityHandle start, EntityHandle end, const int* sequence_data_sizes ) const
80 : : {
81 [ + - ]: 6 : return new SequenceData( this, start, end, sequence_data_sizes );
82 : : }
83 : :
84 : 6 : SequenceData::SequenceData( const SequenceData* from, EntityHandle start, EntityHandle end,
85 : : const int* sequence_data_sizes )
86 : 6 : : numSequenceData( from->numSequenceData ), numTagData( from->numTagData ), startHandle( start ), endHandle( end )
87 : : {
88 [ - + ]: 6 : assert( start <= end );
89 [ - + ]: 6 : assert( from != 0 );
90 [ - + ]: 6 : assert( from->start_handle() <= start );
91 [ - + ]: 6 : assert( from->end_handle() >= end );
92 : :
93 : 6 : void** array = (void**)malloc( sizeof( void* ) * ( numSequenceData + numTagData + 1 ) );
94 : 6 : arraySet = array + numSequenceData;
95 : 6 : const size_t offset = start - from->start_handle();
96 : 6 : const size_t count = end - start + 1;
97 : :
98 [ + + ]: 8 : for( int i = 0; i < numSequenceData; ++i )
99 : 2 : copy_data_subset( -1 - i, sequence_data_sizes[i], from->get_sequence_data( i ), offset, count );
100 : 6 : copy_data_subset( 0, sizeof( AdjacencyDataType* ), from->get_adjacency_data(), offset, count );
101 [ - + ]: 6 : for( unsigned i = 1; i <= numTagData; ++i )
102 : 0 : arraySet[i] = 0;
103 : 6 : }
104 : :
105 : 8 : void SequenceData::copy_data_subset( int index, int size_per_ent, const void* source, size_t offset, size_t count )
106 : : {
107 [ + + ]: 8 : if( !source )
108 : 6 : arraySet[index] = 0;
109 : : else
110 : : {
111 : 2 : arraySet[index] = malloc( count * size_per_ent );
112 : 2 : memcpy( arraySet[index], (const char*)source + offset * size_per_ent, count * size_per_ent );
113 : : }
114 : 8 : }
115 : :
116 : 22 : void SequenceData::move_tag_data( SequenceData* destination, const int* tag_sizes, int num_tag_sizes )
117 : : {
118 [ - + ]: 22 : assert( destination->start_handle() >= start_handle() );
119 [ - + ]: 22 : assert( destination->end_handle() <= end_handle() );
120 : 22 : const size_t offset = destination->start_handle() - start_handle();
121 : 22 : const size_t count = destination->size();
122 [ + + ]: 22 : if( destination->numTagData < numTagData ) destination->increase_tag_count( numTagData - destination->numTagData );
123 : :
124 [ + + ]: 33 : for( unsigned i = 1; i <= numTagData; ++i )
125 : : {
126 [ - + ]: 11 : if( !arraySet[i] ) continue;
127 : :
128 [ - + ]: 11 : assert( i <= (unsigned)num_tag_sizes );
129 : : if( num_tag_sizes ) {} // empty line to prevent compiler warning
130 : :
131 : 11 : const int tag_size = tag_sizes[i - 1];
132 [ + - ]: 11 : if( !destination->arraySet[i] ) destination->arraySet[i] = malloc( count * tag_size );
133 : 33 : memcpy( destination->arraySet[i], reinterpret_cast< char* >( arraySet[i] ) + offset * tag_size,
134 : 11 : count * tag_size );
135 : : }
136 : 22 : }
137 : :
138 : 0 : void SequenceData::release_tag_data( const int* tag_sizes, int num_tag_sizes )
139 : : {
140 [ # # ]: 0 : assert( num_tag_sizes >= (int)numTagData );
141 : : if( num_tag_sizes ) {} // empty line to prevent compiler warning
142 [ # # ]: 0 : for( unsigned i = 0; i < numTagData; ++i )
143 : 0 : release_tag_data( i, tag_sizes[i] );
144 : 0 : }
145 : :
146 : 11284 : void SequenceData::release_tag_data( int tag_num, int tag_size )
147 : : {
148 [ + + ]: 11284 : if( (unsigned)tag_num < numTagData )
149 : : {
150 [ + + ][ + + ]: 8080 : if( tag_size == MB_VARIABLE_LENGTH && arraySet[tag_num + 1] )
151 : : {
152 : 10 : VarLenTag* iter = reinterpret_cast< VarLenTag* >( arraySet[tag_num + 1] );
153 : 10 : VarLenTag* const end = iter + size();
154 [ + + ]: 3145846 : for( ; iter != end; ++iter )
155 : 3145836 : iter->clear();
156 : : }
157 : 8080 : free( arraySet[tag_num + 1] );
158 : 8080 : arraySet[tag_num + 1] = 0;
159 : : }
160 : 11284 : }
161 : :
162 : : } // namespace moab
|
