← Back to branch summary

~ubuntu-branches/ubuntu/raring/simgrid/raring

« back to all changes in this revision

Viewing changes to teshsuite/smpi/mpich-test/env/errhand.c

  • Committer: Package Import Robot
  • Author(s): Martin Quinson
  • Date: 2013-01-31 00:24:51 UTC
  • mfrom: (10.1.6 sid)
  • Revision ID: package-import@ubuntu.com-20130131002451-krejhf7w7h24lpsc
Tags: 3.9~rc1-1
* New upstream release: the "Grasgory" release. Major changes:
  - Gras was completely removed from this version.
  - Documentation reorganization to ease browsing it.
  - New default value for the TCP_gamma parameter: 4MiB

Show diffs side-by-side

added added

removed removed

Lines of Context:
teshsuite/smpi/mpich-test/env/errhand.c
 
1
#include <stdio.h>
 
2
#include "mpi.h"
 
3
#include "test.h"
 
4
 
 
5
int verbose = 0;
 
6
int global_errors = 0;
 
7
int Test_errorhandling (void);
 
8
/* This is complicated by the fact that not all systems correctly 
 
9
   implement stdargs (for the ...) declarations).  MPICH uses USE_STDARG
 
10
   as the choice here, instead of the cases 
 
11
 if defined(__STDC__) || defined(__cplusplus) || defined(HAVE_PROTOTYPES) 
 
12
 */
 
13
#if defined(USE_STDARG)
 
14
void handler_a( MPI_Comm *, int *, ...);
 
15
void handler_b( MPI_Comm *, int *, ...);
 
16
void error_handler(MPI_Comm *, int *, ...);
 
17
#else
 
18
void handler_a ( MPI_Comm *, int * );
 
19
void handler_b ( MPI_Comm *, int * );
 
20
void error_handler ( MPI_Comm *, int * );
 
21
#endif
 
22
 
 
23
/* 
 
24
   Test the error handers (based on a Fortran test program)
 
25
 */
 
26
int main( int argc, char **argv )
 
27
{
 
28
    MPI_Init( &argc, &argv );
 
29
 
 
30
    Test_errorhandling();
 
31
 
 
32
    Test_Waitforall( );
 
33
    MPI_Finalize();
 
34
    return 0;
 
35
}
 
36
 
 
37
static int a_errors, b_errors;
 
38
 
 
39
int Test_errorhandling( void )
 
40
{
 
41
    char errstring[MPI_MAX_ERROR_STRING];
 
42
    MPI_Comm dup_comm_world, dummy;
 
43
    MPI_Comm tempcomm;
 
44
    MPI_Errhandler errhandler_a, errhandler_b, errhandler, old_handler;
 
45
    int  err, world_rank, class, resultlen;
 
46
 
 
47
#ifdef FOO
 
48
    logical test_default, test_abort
 
49
#endif
 
50
 
 
51
    MPI_Comm_rank( MPI_COMM_WORLD, &world_rank );
 
52
    MPI_Comm_dup( MPI_COMM_WORLD, &dup_comm_world );
 
53
 
 
54
    if (world_rank == 0 && verbose) {
 
55
        printf( "*** Error Handling ***\n" );
 
56
    }
 
57
 
 
58
/*
 
59
     Exercise save/restore of user error handlers.
 
60
 */
 
61
    a_errors = 0;
 
62
    MPI_Errhandler_create(handler_a, &errhandler_a);
 
63
 
 
64
    MPI_Errhandler_set(dup_comm_world, errhandler_a);
 
65
    MPI_Errhandler_free(&errhandler_a);
 
66
 
 
67
    if (verbose) printf( "create with null group 1\n" );
 
68
    MPI_Comm_create(dup_comm_world, MPI_GROUP_NULL, &dummy);
 
69
    if (a_errors != 1) {
 
70
        Test_Failed( "    error handler A not invoked\n" );
 
71
        global_errors ++;
 
72
    }
 
73
    b_errors = 0;
 
74
    MPI_Errhandler_create(handler_b, &errhandler_b);
 
75
    MPI_Errhandler_get(dup_comm_world, &old_handler);
 
76
    /* The following is needed to preserve an old handler */
 
77
    MPI_Comm_dup( MPI_COMM_SELF, &tempcomm );
 
78
    MPI_Errhandler_set( tempcomm, old_handler );
 
79
    MPI_Errhandler_set(dup_comm_world, errhandler_b);
 
80
    MPI_Errhandler_free(&errhandler_b);
 
81
    if (verbose) printf( "create with null group 2\n" );
 
82
    MPI_Comm_create(dup_comm_world, MPI_GROUP_NULL, &dummy);
 
83
    if (b_errors != 1) {
 
84
        Test_Failed( "    error handler B not invoked\n" );
 
85
        global_errors++;
 
86
    }
 
87
 
 
88
    MPI_Errhandler_set(dup_comm_world, old_handler);
 
89
    MPI_Comm_free( &tempcomm );
 
90
    /* MPI_Errhandler_free(&old_handler); */
 
91
    if (verbose) printf( "create with null group 3\n" );
 
92
    MPI_Comm_create(dup_comm_world, MPI_GROUP_NULL, &dummy);
 
93
    if (a_errors != 2) {
 
94
        Test_Failed( "    error handler A not re-invoked\n" );
 
95
        global_errors++;
 
96
    }
 
97
/*
 
98
      Exercise class & string interrogation.
 
99
 */
 
100
    MPI_Errhandler_set(dup_comm_world, MPI_ERRORS_ARE_FATAL);
 
101
 
 
102
    if (verbose) 
 
103
        printf( "    Three error messages (from two errors) are expected\n\
 
104
which should both show an error class of %d\n", MPI_ERR_GROUP );
 
105
 
 
106
    MPI_Errhandler_set(dup_comm_world, MPI_ERRORS_RETURN);
 
107
    if (verbose) printf( "create with null group 4\n" );
 
108
    err = MPI_Comm_create(dup_comm_world, MPI_GROUP_NULL, &dummy);
 
109
    if (err != MPI_SUCCESS) {
 
110
        MPI_Error_class(err, &class);
 
111
        MPI_Error_string(err, errstring, &resultlen);
 
112
        if (verbose)
 
113
            printf( "(first) %d : %s\n", class, errstring );
 
114
        else if (class != MPI_ERR_GROUP) {
 
115
            Test_Failed( "(first) Class is not MPI_ERR_GROUP\n" );
 
116
            global_errors++;
 
117
        }
 
118
    }
 
119
    else {
 
120
        MPI_Comm_free( &dummy );
 
121
        Test_Failed( "Did not detect error when building communicator\n" );
 
122
        global_errors++;
 
123
    }
 
124
    MPI_Errhandler_create(error_handler, &errhandler);
 
125
    MPI_Errhandler_set(dup_comm_world, errhandler);
 
126
    MPI_Errhandler_free(&errhandler);
 
127
    if (verbose) printf( "create with null group 5\n" );
 
128
    err = MPI_Comm_create(dup_comm_world, MPI_GROUP_NULL, &dummy);
 
129
    if (err != MPI_SUCCESS) {
 
130
        MPI_Error_class(err, &class);
 
131
        MPI_Error_string(err, errstring, &resultlen);
 
132
        if (verbose) 
 
133
            printf( "(second) %d : %s\n", class, errstring );
 
134
        else if (class != MPI_ERR_GROUP) {
 
135
            Test_Failed( "(second) class was not MPI_ERR_GROUP" );
 
136
            global_errors++;
 
137
        }
 
138
    }
 
139
    else {
 
140
        MPI_Comm_free( &dummy );
 
141
        Test_Failed( "Did not detect error in building communicator\n" );
 
142
        global_errors++;
 
143
    }
 
144
    MPI_Errhandler_set(dup_comm_world, MPI_ERRORS_ARE_FATAL);
 
145
 
 
146
#ifdef FOO
 
147
    if (test_default) {
 
148
        printf("Forcing error for default handler...\n");
 
149
        MPI_Comm_create(dup_comm_world, MPI_GROUP_NULL, &dummy);
 
150
    }
 
151
    if (test_abort) {
 
152
        printf( "Calling MPI_Abort...\n" );
 
153
        MPI_Abort(MPI_COMM_WORLD, 123456768);
 
154
    }
 
155
#endif
 
156
 
 
157
    MPI_Comm_free( &dup_comm_world );
 
158
 
 
159
#if 0
 
160
    errs = global_errors;
 
161
    MPI_Allreduce( &errs, &toterrs, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD );
 
162
    if (world_rank == 0) {
 
163
        if (toterrs == 0) 
 
164
            printf( " No Errors\n" );
 
165
        else
 
166
            printf( " Found %d errors\n", toterrs );
 
167
    }
 
168
#endif    
 
169
    return 0;
 
170
}
 
171
 
 
172
 
 
173
/*
 
174
 
 
175
  Trivial error handler.  Note that FORTRAN error handlers can't
 
176
  deal with the varargs stuff the C handlers can.
 
177
 
 
178
 */
 
179
#if defined(USE_STDARG)
 
180
void error_handler(MPI_Comm *comm, int *err, ...)
 
181
#else
 
182
void error_handler(MPI_Comm *comm, int *err)
 
183
#endif
 
184
{
 
185
    int class;
 
186
    int resultlen;
 
187
    char string[MPI_MAX_ERROR_STRING];
 
188
    
 
189
    MPI_Error_class(*err, &class);
 
190
    MPI_Error_string(*err, string, &resultlen);
 
191
    if (verbose) 
 
192
        printf( "(errhandler) %d : %s\n", class, string );
 
193
    else {
 
194
        if (class != MPI_ERR_GROUP) {
 
195
            printf( "(errhandler) class = %d, expected %d (MPI_ERR_GROUP)\n",
 
196
                    class, MPI_ERR_GROUP );
 
197
            printf( "   message %s\n", string );
 
198
            global_errors++;
 
199
        }
 
200
    }
 
201
}
 
202
/* 
 
203
  Error handler A, used for save/restore testing.
 
204
 */
 
205
 
 
206
#if defined(USE_STDARG)
 
207
void handler_a( MPI_Comm *comm, int *err, ...)
 
208
#else
 
209
void handler_a(MPI_Comm *comm, int err)
 
210
#endif
 
211
{
 
212
    int class;
 
213
 
 
214
    MPI_Error_class(*err, &class);
 
215
    if (class != MPI_ERR_GROUP) {
 
216
        printf( "handler_a: incorrect error class %d\n", class );
 
217
    }
 
218
    *err = MPI_SUCCESS;
 
219
    a_errors++;
 
220
}
 
221
 
 
222
/* 
 
223
  Error handler B, used for save/restore testing.
 
224
 */
 
225
 
 
226
#if defined(USE_STDARG)
 
227
void handler_b(MPI_Comm *comm, int *err, ...)
 
228
#else
 
229
void handler_b(comm, err)
 
230
MPI_Comm *comm;
 
231
int      *err;
 
232
#endif
 
233
{
 
234
    int class;
 
235
 
 
236
    MPI_Error_class(*err, &class);
 
237
    if (class != MPI_ERR_GROUP) {
 
238
        printf( "handler_b: incorrect error class %d\n", class );
 
239
    }
 
240
    *err = MPI_SUCCESS;
 
241
    b_errors++;
 
242
}