OpenRadioss 2025.1.11
OpenRadioss project
Loading...
Searching...
No Matches
VE_Mumps.h File Reference
#include <stddef.h>
#include <libvhcall.h>
#include <libgen.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

Go to the source code of this file.

Macros

#define NECVH_MAX_LIBNAME   2048
#define mumps_abort

Functions

void VE_Mumps_ana_h (int TOTEL, bool COMPUTE_PERM, int N, int64_t IWLEN, int64_t *PE, int64_t *PFREE, int *LEN, int *IW, int *NV, int *ELEN, int *LAST, int *NCMPA, int *DEGREE, int *HEAD, int *NEXT, int *W, int *PARENT)
void VE_Mumps_symqamd (int THRESH, int *NDENSE, int N, int TOTEL, int64_t IWLEN, int64_t *PE, int64_t *PFREE, int *LEN, int *IW, int *NV, int *ELEN, int *LAST, int *NCMPA, int *DEGREE, int *HEAD, int *NEXT, int *W, int *PERM, int *LISTVAR_SCHUR, int SIZE_SCHUR, int AGG6, int *PARENT)
void VE_Mumps_wrap_ginp94 (int N, int64_t *IPE, int *IW, int64_t LIW8, int *PERM, int *SizeOfBlocks, int KEEP60, int *LISTVAR_SCHUR, int SIZE_SCHUR, int *COLCOUNT, int *PARENT, int *PORDER, int *IWTMP1, int *IWTMP2, int *IWTMP3, int *IWTMP4, int *IWTMP5, int *INFO)

Macro Definition Documentation

◆ mumps_abort

#define mumps_abort ( void)
Value:
mumps_abort_

Definition at line 26 of file VE_Mumps.h.

◆ NECVH_MAX_LIBNAME

#define NECVH_MAX_LIBNAME   2048

Definition at line 22 of file VE_Mumps.h.

Function Documentation

◆ VE_Mumps_ana_h()

void VE_Mumps_ana_h ( int TOTEL,
bool COMPUTE_PERM,
int N,
int64_t IWLEN,
int64_t * PE,
int64_t * PFREE,
int * LEN,
int * IW,
int * NV,
int * ELEN,
int * LAST,
int * NCMPA,
int * DEGREE,
int * HEAD,
int * NEXT,
int * W,
int * PARENT )

Definition at line 15 of file VE_Mumps_ana_h.c.

19{
20 int ret=1;
21 int64_t symid;
22 vhcall_handle handle;
23 vhcall_args *ca;
24 uint64_t retval;
25
26 char * env_metis_lib_name;
27 char metis_lib_name[ NECVH_MAX_LIBNAME ];
28
29 /*
30 * -----------------------------------------------------------------------
31 * Set the library name ( check environment )
32 * -----------------------------------------------------------------------
33 */
34
35 if ( env_metis_lib_name = getenv( "VH_MUMPS_LIBRARY" ) ) {
36 size_t lenv = strlen( env_metis_lib_name );
37 if ( strlen( env_metis_lib_name ) > (size_t)NECVH_MAX_LIBNAME ) {
38 fprintf( stdout , "%s @ %d failed : metis library name too long (%s)\n" , basename(__FILE__) , __LINE__ , env_metis_lib_name );
39 fflush( stdout );
40 (void) mumps_abort();
41 }
42 else {
43 memcpy( ( void * ) metis_lib_name , ( void * ) env_metis_lib_name , lenv * sizeof( char) );
44 metis_lib_name[ lenv ] = '\0';
45 fprintf( stdout , "%s @ %d input library %s\n" , basename(__FILE__) , __LINE__ , metis_lib_name );
46 fflush( stdout );
47 }
48 }
49 else {
50 strcpy( metis_lib_name , "libvh.so" );
51 }
52
53 /*
54 * -----------------------------------------------------------------------
55 * Load VH C library
56 * -----------------------------------------------------------------------
57 */
58
59 handle = vhcall_install( metis_lib_name );
60 if (handle == (vhcall_handle)-1) {
61 perror("vhcall_install");
62 fprintf( stdout , "%s @ %d failed : can't install library %s\n" , basename(__FILE__) , __LINE__ , metis_lib_name );
63 fprintf( stdout , "Please check your LD_LIBRARY_PATH variable\n");
64 fflush( stdout );
65 (void) mumps_abort();
66 }
67
68 /*
69 * -----------------------------------------------------------------------
70 * Find VH C library function
71 * -----------------------------------------------------------------------
72 */
73
74 symid = vhcall_find(handle, "mumps_ana_h_");
75 if ( symid == -1 ) {
76 fprintf( stdout , "%s @ %d failed : can't find symbol MUMPS_ANA_H\n" , basename(__FILE__) , __LINE__ );
77 perror("vhcall_find");
78 fflush( stdout );
79 (void) mumps_abort();
80 }
81
82 /*
83 * -----------------------------------------------------------------------
84 * Allocate arguments object for VH library function
85 * -----------------------------------------------------------------------
86 */
87
88 ca = vhcall_args_alloc();
89 if ( ! ca ) {
90 perror("vhcall_args_alloc");
91 fprintf( stdout , "%s @ %d failed : unable to allocate function's argument list\n" , basename(__FILE__) , __LINE__ );
92 fflush( stdout );
93 (void) mumps_abort();
94 }
95
96 /*
97 * -----------------------------------------------------------------------
98 * Set arguments
99 * -----------------------------------------------------------------------
100 */
101
102 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , 0 , &TOTEL , sizeof( int ) );
103 if ( ret ) {
104 perror("vhcall_args_set_pointer");
105 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
106 fflush( stdout );
107 (void) mumps_abort();
108 }
109
110 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , 1 , &COMPUTE_PERM , sizeof( bool ) );
111 if ( ret ) {
112 perror("vhcall_args_set_pointer");
113 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
114 fflush( stdout );
115 (void) mumps_abort();
116 }
117
118 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , 2 , &N , sizeof( int ) );
119 if ( ret ) {
120 perror("vhcall_args_set_pointer");
121 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
122 fflush( stdout );
123 (void) mumps_abort();
124 }
125
126 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , 3 , &IWLEN , sizeof( int64_t ) );
127 if ( ret ) {
128 perror("vhcall_args_set_pointer");
129 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
130 fflush( stdout );
131 (void) mumps_abort();
132 }
133
134 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT , 4 , PE , N * sizeof( int64_t ) );
135 if ( ret ) {
136 perror("vhcall_args_set_pointer");
137 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
138 fflush( stdout );
139 (void) mumps_abort();
140 }
141
142 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT , 5 , PFREE , sizeof( int64_t ) );
143 if ( ret ) {
144 perror("vhcall_args_set_pointer");
145 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
146 fflush( stdout );
147 (void) mumps_abort();
148 }
149
150 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT , 6 , LEN , N * sizeof( int ) );
151 if ( ret ) {
152 perror("vhcall_args_set_pointer");
153 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
154 fflush( stdout );
155 (void) mumps_abort();
156 }
157
158 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT , 7 , IW , IWLEN * sizeof( int ) );
159 if ( ret ) {
160 perror("vhcall_args_set_pointer");
161 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
162 fflush( stdout );
163 (void) mumps_abort();
164 }
165
166 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT , 8 , NV , N * sizeof( int ) );
167 if ( ret ) {
168 perror("vhcall_args_set_pointer");
169 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
170 fflush( stdout );
171 (void) mumps_abort();
172 }
173
174 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , 9 , ELEN , N * sizeof( int ) );
175 if ( ret ) {
176 perror("vhcall_args_set_pointer");
177 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
178 fflush( stdout );
179 (void) mumps_abort();
180 }
181
182 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT ,10 , LAST , N * sizeof( int ) );
183 if ( ret ) {
184 perror("vhcall_args_set_pointer");
185 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
186 fflush( stdout );
187 (void) mumps_abort();
188 }
189
190 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT ,11 , NCMPA , sizeof( int ) );
191 if ( ret ) {
192 perror("vhcall_args_set_pointer");
193 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
194 fflush( stdout );
195 (void) mumps_abort();
196 }
197
198 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT ,12 , DEGREE , N * sizeof( int ) );
199 if ( ret ) {
200 perror("vhcall_args_set_pointer");
201 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
202 fflush( stdout );
203 (void) mumps_abort();
204 }
205
206 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT ,13 , HEAD , TOTEL * sizeof( int ) );
207 if ( ret ) {
208 perror("vhcall_args_set_pointer");
209 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
210 fflush( stdout );
211 (void) mumps_abort();
212 }
213
214 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT ,14 , NEXT , N * sizeof( int ) );
215 if ( ret ) {
216 perror("vhcall_args_set_pointer");
217 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
218 fflush( stdout );
219 (void) mumps_abort();
220 }
221
222 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT ,15 , W , N * sizeof( int ) );
223 if ( ret ) {
224 perror("vhcall_args_set_pointer");
225 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
226 fflush( stdout );
227 (void) mumps_abort();
228 }
229
230 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT ,16 , PARENT , N * sizeof( int ) );
231 if ( ret ) {
232 perror("vhcall_args_set_pointer");
233 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
234 fflush( stdout );
235 (void) mumps_abort();
236 }
237
238 /*
239 * -----------------------------------------------------------------------
240 * Invoke VH C library function
241 * -----------------------------------------------------------------------
242 */
243
244 ret = vhcall_invoke_with_args( symid , ca , &retval );
245 if ( ret ) {
246 perror("vhcall_invoke_with_args");
247 fprintf( stdout , "%s @ %d failed : unable to invoke the symbol from library\n" , basename(__FILE__) , __LINE__ );
248 fflush( stdout );
249 (void) mumps_abort();
250 }
251
252 /*
253 * -----------------------------------------------------------------------
254 * Free args
255 * -----------------------------------------------------------------------
256 */
257
258 vhcall_args_free( ca );
259
260 /*
261 * -----------------------------------------------------------------------
262 * Uninstall the library
263 * -----------------------------------------------------------------------
264 */
265
266 if ( vhcall_uninstall( handle ) ) {
267 perror("vhcall_uninstall");
268 fprintf( stdout , "cvhmetis_nodend failed : unable to uninstall the library\n" , basename(__FILE__) , __LINE__ );
269 fflush( stdout );
270 (void) mumps_abort();
271 }
272}
mumps_abort
#define mumps_abort
Definition VE_Metis.h:25
NECVH_MAX_LIBNAME
#define NECVH_MAX_LIBNAME
Definition VE_Metis.h:23
handle
void * handle
Definition cpp_python_funct.cpp:67
N
#define N
Definition example_user.c:10

◆ VE_Mumps_symqamd()

void VE_Mumps_symqamd ( int THRESH,
int * NDENSE,
int N,
int TOTEL,
int64_t IWLEN,
int64_t * PE,
int64_t * PFREE,
int * LEN,
int * IW,
int * NV,
int * ELEN,
int * LAST,
int * NCMPA,
int * DEGREE,
int * HEAD,
int * NEXT,
int * W,
int * PERM,
int * LISTVAR_SCHUR,
int SIZE_SCHUR,
int AGG6,
int * PARENT )

Definition at line 15 of file VE_Mumps_symqamd.c.

20{
21 int ret=1,iarg;
22 int64_t symid;
23 vhcall_handle handle;
24 vhcall_args *ca;
25 uint64_t retval;
26
27 char * env_metis_lib_name;
28 char metis_lib_name[ NECVH_MAX_LIBNAME ];
29
30 /*
31 * -----------------------------------------------------------------------
32 * Set the library name ( check environment )
33 * -----------------------------------------------------------------------
34 */
35
36 if ( env_metis_lib_name = getenv( "VH_MUMPS_LIBRARY" ) ) {
37 size_t lenv = strlen( env_metis_lib_name );
38 if ( strlen( env_metis_lib_name ) > (size_t)NECVH_MAX_LIBNAME ) {
39 fprintf( stdout , "%s @ %d failed : metis library name too long (%s)\n" , basename(__FILE__) , __LINE__ , env_metis_lib_name );
40 fflush( stdout );
41 (void) mumps_abort();
42 }
43 else {
44 memcpy( ( void * ) metis_lib_name , ( void * ) env_metis_lib_name , lenv * sizeof( char) );
45 metis_lib_name[ lenv ] = '\0';
46 fprintf( stdout , "%s @ %d input library %s\n" , basename(__FILE__) , __LINE__ , metis_lib_name );
47 fflush( stdout );
48 }
49 }
50 else {
51 strcpy( metis_lib_name , "libvh.so" );
52 }
53
54 /*
55 * -----------------------------------------------------------------------
56 * Load VH C library
57 * -----------------------------------------------------------------------
58 */
59
60 handle = vhcall_install( metis_lib_name );
61 if (handle == (vhcall_handle)-1) {
62 perror("vhcall_install");
63 fprintf( stdout , "%s @ %d failed : can't install library %s\n" , basename(__FILE__) , __LINE__ , metis_lib_name );
64 fprintf( stdout , "Please check your LD_LIBRARY_PATH variable\n");
65 fflush( stdout );
66 (void) mumps_abort();
67 }
68
69 /*
70 * -----------------------------------------------------------------------
71 * Find VH C library function
72 * -----------------------------------------------------------------------
73 */
74
75 symid = vhcall_find(handle, "mumps_symqamd_");
76 if ( symid == -1 ) {
77 fprintf( stdout , "%s @ %d failed : can't find symbol MUMPS_SYMQAMD\n" , basename(__FILE__) , __LINE__ );
78 perror("vhcall_find");
79 fflush( stdout );
80 (void) mumps_abort();
81 }
82
83 /*
84 * -----------------------------------------------------------------------
85 * Allocate arguments object for VH library function
86 * -----------------------------------------------------------------------
87 */
88
89 ca = vhcall_args_alloc();
90 if ( ! ca ) {
91 perror("vhcall_args_alloc");
92 fprintf( stdout , "%s @ %d failed : unable to allocate function's argument list\n" , basename(__FILE__) , __LINE__ );
93 fflush( stdout );
94 (void) mumps_abort();
95 }
96
97 /*
98 * -----------------------------------------------------------------------
99 * Set arguments
100 * -----------------------------------------------------------------------
101 */
102 iarg = 0;
103 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , iarg++ , &THRESH , sizeof( int ) );
104 if ( ret ) {
105 perror("vhcall_args_set_pointer");
106 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
107 fflush( stdout );
108 (void) mumps_abort();
109 }
110
111 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , NDENSE , N * sizeof( int ) );
112 if ( ret ) {
113 perror("vhcall_args_set_pointer");
114 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
115 fflush( stdout );
116 (void) mumps_abort();
117 }
118
119 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , iarg++ , &N , sizeof( int ) );
120 if ( ret ) {
121 perror("vhcall_args_set_pointer");
122 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
123 fflush( stdout );
124 (void) mumps_abort();
125 }
126
127 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , iarg++ , &TOTEL , sizeof( int ) );
128 if ( ret ) {
129 perror("vhcall_args_set_pointer");
130 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
131 fflush( stdout );
132 (void) mumps_abort();
133 }
134
135 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , iarg++ , &IWLEN , sizeof( int64_t ) );
136 if ( ret ) {
137 perror("vhcall_args_set_pointer");
138 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
139 fflush( stdout );
140 (void) mumps_abort();
141 }
142
143 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT , iarg++ , PE , N * sizeof( int64_t ) );
144 if ( ret ) {
145 perror("vhcall_args_set_pointer");
146 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
147 fflush( stdout );
148 (void) mumps_abort();
149 }
150
151 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT , iarg++ , PFREE , sizeof( int64_t ) );
152 if ( ret ) {
153 perror("vhcall_args_set_pointer");
154 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
155 fflush( stdout );
156 (void) mumps_abort();
157 }
158
159 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT , iarg++ , LEN , N * sizeof( int ) );
160 if ( ret ) {
161 perror("vhcall_args_set_pointer");
162 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
163 fflush( stdout );
164 (void) mumps_abort();
165 }
166
167 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT , iarg++ , IW , IWLEN * sizeof( int ) );
168 if ( ret ) {
169 perror("vhcall_args_set_pointer");
170 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
171 fflush( stdout );
172 (void) mumps_abort();
173 }
174
175 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT , iarg++ , NV , N * sizeof( int ) );
176 if ( ret ) {
177 perror("vhcall_args_set_pointer");
178 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
179 fflush( stdout );
180 (void) mumps_abort();
181 }
182
183 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , ELEN , N * sizeof( int ) );
184 if ( ret ) {
185 perror("vhcall_args_set_pointer");
186 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
187 fflush( stdout );
188 (void) mumps_abort();
189 }
190
191 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , LAST , TOTEL * sizeof( int ) );
192 if ( ret ) {
193 perror("vhcall_args_set_pointer");
194 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
195 fflush( stdout );
196 (void) mumps_abort();
197 }
198
199 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , NCMPA , sizeof( int ) );
200 if ( ret ) {
201 perror("vhcall_args_set_pointer");
202 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
203 fflush( stdout );
204 (void) mumps_abort();
205 }
206
207 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , DEGREE , N * sizeof( int ) );
208 if ( ret ) {
209 perror("vhcall_args_set_pointer");
210 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
211 fflush( stdout );
212 (void) mumps_abort();
213 }
214
215 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , HEAD , TOTEL * sizeof( int ) );
216 if ( ret ) {
217 perror("vhcall_args_set_pointer");
218 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
219 fflush( stdout );
220 (void) mumps_abort();
221 }
222
223 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , NEXT , N * sizeof( int ) );
224 if ( ret ) {
225 perror("vhcall_args_set_pointer");
226 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
227 fflush( stdout );
228 (void) mumps_abort();
229 }
230
231 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , W , N * sizeof( int ) );
232 if ( ret ) {
233 perror("vhcall_args_set_pointer");
234 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
235 fflush( stdout );
236 (void) mumps_abort();
237 }
238
239 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT , iarg++ , PERM , N * sizeof( int ) );
240 if ( ret ) {
241 perror("vhcall_args_set_pointer");
242 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
243 fflush( stdout );
244 (void) mumps_abort();
245 }
246
247 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , LISTVAR_SCHUR , ( SIZE_SCHUR ? SIZE_SCHUR : 1 ) * sizeof( int ) );
248 if ( ret ) {
249 perror("vhcall_args_set_pointer");
250 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
251 fflush( stdout );
252 (void) mumps_abort();
253 }
254
255 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT , iarg++ , &SIZE_SCHUR , sizeof( int ) );
256 if ( ret ) {
257 perror("vhcall_args_set_pointer");
258 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
259 fflush( stdout );
260 (void) mumps_abort();
261 }
262
263 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , iarg++ , &AGG6 , sizeof( int ) );
264 if ( ret ) {
265 perror("vhcall_args_set_pointer");
266 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
267 fflush( stdout );
268 (void) mumps_abort();
269 }
270
271 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , PARENT , N * sizeof( int ) );
272 if ( ret ) {
273 perror("vhcall_args_set_pointer");
274 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
275 fflush( stdout );
276 (void) mumps_abort();
277 }
278
279 /*
280 * -----------------------------------------------------------------------
281 * Invoke VH C library function
282 * -----------------------------------------------------------------------
283 */
284
285 ret = vhcall_invoke_with_args( symid , ca , &retval );
286 if ( ret ) {
287 perror("vhcall_invoke_with_args");
288 fprintf( stdout , "%s @ %d failed : unable to invoke the symbol from library\n" , basename(__FILE__) , __LINE__ );
289 fflush( stdout );
290 (void) mumps_abort();
291 }
292
293 /*
294 * -----------------------------------------------------------------------
295 * Free args
296 * -----------------------------------------------------------------------
297 */
298
299 vhcall_args_free( ca );
300
301 /*
302 * -----------------------------------------------------------------------
303 * Uninstall the library
304 * -----------------------------------------------------------------------
305 */
306
307 if ( vhcall_uninstall( handle ) ) {
308 perror("vhcall_uninstall");
309 fprintf( stdout , "cvhmetis_nodend failed : unable to uninstall the library\n" , basename(__FILE__) , __LINE__ );
310 fflush( stdout );
311 (void) mumps_abort();
312 }
313}
PERM
#define PERM
Definition rad2rad_c.c:91

◆ VE_Mumps_wrap_ginp94()

void VE_Mumps_wrap_ginp94 ( int N,
int64_t * IPE,
int * IW,
int64_t LIW8,
int * PERM,
int * SizeOfBlocks,
int KEEP60,
int * LISTVAR_SCHUR,
int SIZE_SCHUR,
int * COLCOUNT,
int * PARENT,
int * PORDER,
int * IWTMP1,
int * IWTMP2,
int * IWTMP3,
int * IWTMP4,
int * IWTMP5,
int * INFO )

Definition at line 15 of file VE_Mumps_wrap_ginp94.c.

19{
20 int ret=1,iarg;
21 int64_t symid;
22 vhcall_handle handle;
23 vhcall_args *ca;
24 uint64_t retval;
25
26 char * env_metis_lib_name;
27 char metis_lib_name[ NECVH_MAX_LIBNAME ];
28
29 /*
30 * -----------------------------------------------------------------------
31 * Set the library name ( check environment )
32 * -----------------------------------------------------------------------
33 */
34
35 if ( env_metis_lib_name = getenv( "VH_MUMPS_LIBRARY" ) ) {
36 size_t lenv = strlen( env_metis_lib_name );
37 if ( strlen( env_metis_lib_name ) > (size_t)NECVH_MAX_LIBNAME ) {
38 fprintf( stdout , "%s @ %d failed : metis library name too long (%s)\n" , basename(__FILE__) , __LINE__ , env_metis_lib_name );
39 fflush( stdout );
40 (void) mumps_abort();
41 }
42 else {
43 memcpy( ( void * ) metis_lib_name , ( void * ) env_metis_lib_name , lenv * sizeof( char) );
44 metis_lib_name[ lenv ] = '\0';
45 fprintf( stdout , "%s @ %d input library %s\n" , basename(__FILE__) , __LINE__ , metis_lib_name );
46 fflush( stdout );
47 }
48 }
49 else {
50 strcpy( metis_lib_name , "libvh.so" );
51 }
52
53 /*
54 * -----------------------------------------------------------------------
55 * Load VH C library
56 * -----------------------------------------------------------------------
57 */
58
59 handle = vhcall_install( metis_lib_name );
60 if (handle == (vhcall_handle)-1) {
61 perror("vhcall_install");
62 fprintf( stdout , "%s @ %d failed : can't install library %s\n" , basename(__FILE__) , __LINE__ , metis_lib_name );
63 fprintf( stdout , "Please check your LD_LIBRARY_PATH variable\n");
64 fflush( stdout );
65 (void) mumps_abort();
66 }
67
68 /*
69 * -----------------------------------------------------------------------
70 * Find VH C library function
71 * -----------------------------------------------------------------------
72 */
73
74 symid = vhcall_find(handle, "mumps_wrap_ginp94_");
75 if ( symid == -1 ) {
76 fprintf( stdout , "%s @ %d failed : can't find symbol MUMPS_WRAP_GINP94\n" , basename(__FILE__) , __LINE__ );
77 perror("vhcall_find");
78 fflush( stdout );
79 (void) mumps_abort();
80 }
81
82 /*
83 * -----------------------------------------------------------------------
84 * Allocate arguments object for VH library function
85 * -----------------------------------------------------------------------
86 */
87
88 ca = vhcall_args_alloc();
89 if ( ! ca ) {
90 perror("vhcall_args_alloc");
91 fprintf( stdout , "%s @ %d failed : unable to allocate function's argument list\n" , basename(__FILE__) , __LINE__ );
92 fflush( stdout );
93 (void) mumps_abort();
94 }
95
96 /*
97 * -----------------------------------------------------------------------
98 * Set arguments
99 * -----------------------------------------------------------------------
100 */
101
102 iarg = 0;
103 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , iarg++ , &N , sizeof( int ) );
104 if ( ret ) {
105 perror("vhcall_args_set_pointer");
106 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
107 fflush( stdout );
108 (void) mumps_abort();
109 }
110
111 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , iarg++ , IPE , ( N + 1 ) * sizeof( int64_t ) );
112 if ( ret ) {
113 perror("vhcall_args_set_pointer");
114 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
115 fflush( stdout );
116 (void) mumps_abort();
117 }
118
119 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , iarg++ , IW , LIW8 * sizeof( int ) );
120 if ( ret ) {
121 perror("vhcall_args_set_pointer");
122 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
123 fflush( stdout );
124 (void) mumps_abort();
125 }
126
127 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , iarg++ , &LIW8 , sizeof( int64_t ) );
128 if ( ret ) {
129 perror("vhcall_args_set_pointer");
130 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
131 fflush( stdout );
132 (void) mumps_abort();
133 }
134
135 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT , iarg++ , PERM , N * sizeof( int ) );
136 if ( ret ) {
137 perror("vhcall_args_set_pointer");
138 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
139 fflush( stdout );
140 (void) mumps_abort();
141 }
142
143 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , iarg++ , SizeOfBlocks , N * sizeof( int ) );
144 if ( ret ) {
145 perror("vhcall_args_set_pointer");
146 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
147 fflush( stdout );
148 (void) mumps_abort();
149 }
150
151 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , iarg++ , &KEEP60 , sizeof( int ) );
152 if ( ret ) {
153 perror("vhcall_args_set_pointer");
154 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
155 fflush( stdout );
156 (void) mumps_abort();
157 }
158
159 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , iarg++ , LISTVAR_SCHUR , SIZE_SCHUR * sizeof( int ) );
160 if ( ret ) {
161 perror("vhcall_args_set_pointer");
162 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
163 fflush( stdout );
164 (void) mumps_abort();
165 }
166
167 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_IN , iarg++ , &SIZE_SCHUR , sizeof( int ) );
168 if ( ret ) {
169 perror("vhcall_args_set_pointer");
170 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
171 fflush( stdout );
172 (void) mumps_abort();
173 }
174
175 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , COLCOUNT , N * sizeof( int ) );
176 if ( ret ) {
177 perror("vhcall_args_set_pointer");
178 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
179 fflush( stdout );
180 (void) mumps_abort();
181 }
182
183 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , PARENT , N * sizeof( int ) );
184 if ( ret ) {
185 perror("vhcall_args_set_pointer");
186 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
187 fflush( stdout );
188 (void) mumps_abort();
189 }
190
191 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , PORDER , N * sizeof( int ) );
192 if ( ret ) {
193 perror("vhcall_args_set_pointer");
194 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
195 fflush( stdout );
196 (void) mumps_abort();
197 }
198
199 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , IWTMP1 , N * sizeof( int ) );
200 if ( ret ) {
201 perror("vhcall_args_set_pointer");
202 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
203 fflush( stdout );
204 (void) mumps_abort();
205 }
206
207 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , IWTMP2 , N * sizeof( int ) );
208 if ( ret ) {
209 perror("vhcall_args_set_pointer");
210 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
211 fflush( stdout );
212 (void) mumps_abort();
213 }
214
215 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , IWTMP3 , N * sizeof( int ) );
216 if ( ret ) {
217 perror("vhcall_args_set_pointer");
218 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
219 fflush( stdout );
220 (void) mumps_abort();
221 }
222
223 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , IWTMP4 , N * sizeof( int ) );
224 if ( ret ) {
225 perror("vhcall_args_set_pointer");
226 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
227 fflush( stdout );
228 (void) mumps_abort();
229 }
230
231 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_OUT , iarg++ , IWTMP5 , N * sizeof( int ) );
232 if ( ret ) {
233 perror("vhcall_args_set_pointer");
234 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
235 fflush( stdout );
236 (void) mumps_abort();
237 }
238
239 ret = vhcall_args_set_pointer( ca , VHCALL_INTENT_INOUT , iarg++ , INFO , 2 * sizeof( int ) );
240 if ( ret ) {
241 perror("vhcall_args_set_pointer");
242 fprintf( stdout , "%s @ %d failed : unable to set argument.\n" , basename(__FILE__) , __LINE__ );
243 fflush( stdout );
244 (void) mumps_abort();
245 }
246
247 /*
248 * -----------------------------------------------------------------------
249 * Invoke VH C library function
250 * -----------------------------------------------------------------------
251 */
252
253 ret = vhcall_invoke_with_args( symid , ca , &retval );
254 if ( ret ) {
255 perror("vhcall_invoke_with_args");
256 fprintf( stdout , "%s @ %d failed : unable to invoke the symbol from library\n" , basename(__FILE__) , __LINE__ );
257 fflush( stdout );
258 (void) mumps_abort();
259 }
260
261 /*
262 * -----------------------------------------------------------------------
263 * Free args
264 * -----------------------------------------------------------------------
265 */
266
267 vhcall_args_free( ca );
268
269 /*
270 * -----------------------------------------------------------------------
271 * Uninstall the library
272 * -----------------------------------------------------------------------
273 */
274
275 if ( vhcall_uninstall( handle ) ) {
276 perror("vhcall_uninstall");
277 fprintf( stdout , "cvhmetis_nodend failed : unable to uninstall the library\n" , basename(__FILE__) , __LINE__ );
278 fflush( stdout );
279 (void) mumps_abort();
280 }
281}