Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
add MPICH3 rma tests (15 out of 88 should be passing now)
[simgrid.git] / teshsuite / smpi / mpich3-test / rma / lockcontention3.c
1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
2 /*
3  *  (C) 2012 by Argonne National Laboratory.
4  *      See COPYRIGHT in top-level directory.
5  */
6 #include "mpi.h" 
7 #include "stdio.h"
8 #include "stdlib.h"
9 #include "mpitest.h"
10 #include <assert.h>
11 #include <string.h>
12
13 #define LAST_TEST 14
14 #define RMA_SIZE  2048
15 #define OFFSET_1  7
16 #define OFFSET_2  83
17 #define OFFSET_3  157
18
19 #define PUT_VAL 0xdcba97
20 #define ACC_VAL 10771134
21
22 /* 
23  * Additional tests for lock contention.  These are designed to exercise
24  * some of the optimizations within MPICH, but all are valid MPI programs.
25  * Tests structure includes
26  *    lock local (must happen at this time since application can use load
27  *                store after the lock)
28  *    send message to partner
29  *                                  receive message
30  *                                  send ack
31  *    receive ack
32  *    Provide a delay so that
33  *      the partner will see the
34  *      conflict
35  *                                  partner executes:
36  *                                  lock         // Note: this may block
37  *                                     rma operations (see below)
38  *                                  unlock
39  *    
40  *    unlock                        send back to partner
41  *    receive from partner 
42  *    check for correct data
43  *
44  * The delay may be implemented as a ring of message communication; this
45  * is likely to automatically scale the time to what is needed
46  */
47
48 /* Define a datatype to be used with */
49 int stride    = 11;
50 int veccount  = 7;
51 MPI_Datatype  vectype;
52 /* Define long RMA ops size */
53 int longcount = 512;
54 int medcount  = 127;
55 int mednum    = 4;
56
57 void RMATest( int i, MPI_Win win, int master, int *srcbuf, int srcbufsize, int *getbuf, int getbufsize );
58 int  RMACheck( int i, int *buf, MPI_Aint bufsize );
59 int  RMACheckGet( int i, MPI_Win win, int *getbuf, MPI_Aint getsize);
60 void RMATestInit( int i, int *buf, MPI_Aint bufsize );
61
62 int main( int argc, char *argv[] )
63 {
64     int      errs = 0;
65     MPI_Win  win;
66     int  *rmabuffer=0, *getbuf=0;
67     MPI_Aint bufsize=0, getbufsize=0;
68     int      master, partner, next, wrank, wsize, i;
69     int      ntest = LAST_TEST;
70     int *srcbuf;
71
72     MTest_Init( &argc, &argv );
73
74     /* Determine who is responsible for each part of the test */
75     MPI_Comm_rank( MPI_COMM_WORLD, &wrank );
76     MPI_Comm_size( MPI_COMM_WORLD, &wsize );
77     if (wsize < 3) {
78         fprintf( stderr, "This test requires at least 3 processes\n" );
79         MPI_Abort( MPI_COMM_WORLD, 1 );
80     }
81
82     master  = 0;
83     partner = 1;
84     next = wrank + 1;
85     if (next == partner) next++;
86     if (next >= wsize) {
87         next = 0;
88         if (next == partner) next++;
89     }
90
91     /* Determine the last test to run (by default, run them all) */
92     for (i=1; i<argc; i++) {
93         if (strcmp( "-ntest", argv[i] ) == 0) { 
94             i++;
95             if (i < argc) {
96                 ntest = atoi( argv[i] );
97             }
98             else {
99                 fprintf( stderr, "Missing value for -ntest\n" );
100                 MPI_Abort( MPI_COMM_WORLD, 1 );
101             }
102         }
103     }
104
105     MPI_Type_vector( veccount, 1, stride, MPI_INT, &vectype );
106     MPI_Type_commit( &vectype );
107
108     /* Create the RMA window */
109     bufsize = 0;
110     if (wrank == master) {
111         bufsize = RMA_SIZE;
112         MPI_Alloc_mem( bufsize*sizeof(int), MPI_INFO_NULL, &rmabuffer );
113     }
114     else if (wrank == partner) {
115         getbufsize = RMA_SIZE;
116         getbuf = (int *)malloc( getbufsize*sizeof(int) );
117         if (!getbuf) {
118             fprintf( stderr, "Unable to allocated %d bytes for getbuf\n", 
119                     (int)getbufsize );
120             MPI_Abort( MPI_COMM_WORLD, 1 );
121         }
122     }
123     srcbuf = malloc(RMA_SIZE*sizeof(*srcbuf));
124     assert(srcbuf);
125
126     MPI_Win_create( rmabuffer, bufsize, sizeof(int), MPI_INFO_NULL,
127                     MPI_COMM_WORLD, &win );
128     
129     /* Run a sequence of tests */
130     for (i=0; i<=ntest; i++) {
131         if (wrank == master) {
132             MTestPrintfMsg( 0, "Test %d\n", i );
133             /* Because this lock is local, it must return only when the
134              lock is acquired */
135             MPI_Win_lock( MPI_LOCK_EXCLUSIVE, 0, master, win );
136             RMATestInit( i, rmabuffer, bufsize );
137             MPI_Send( MPI_BOTTOM, 0, MPI_INT, partner, i, MPI_COMM_WORLD );
138             MPI_Send( MPI_BOTTOM, 0, MPI_INT, next, i, MPI_COMM_WORLD );
139             MPI_Recv( MPI_BOTTOM, 0, MPI_INT, MPI_ANY_SOURCE, i, 
140                       MPI_COMM_WORLD, MPI_STATUS_IGNORE );
141             MPI_Win_unlock( master, win );
142             MPI_Recv( MPI_BOTTOM, 0, MPI_INT, partner, i, MPI_COMM_WORLD, 
143                       MPI_STATUS_IGNORE );
144             errs += RMACheck( i, rmabuffer, bufsize );
145         }
146         else if (wrank == partner) {
147             MPI_Recv( MPI_BOTTOM, 0, MPI_INT, master, i, MPI_COMM_WORLD,
148                       MPI_STATUS_IGNORE );
149             MPI_Win_lock( MPI_LOCK_EXCLUSIVE, 0, master, win );
150             RMATest( i, win, master, srcbuf, RMA_SIZE, getbuf, getbufsize );
151             MPI_Win_unlock( master, win );
152             errs += RMACheckGet( i, win, getbuf, getbufsize );
153             MPI_Send( MPI_BOTTOM, 0, MPI_INT, master, i, MPI_COMM_WORLD );
154         }
155         else {
156             MPI_Recv( MPI_BOTTOM, 0, MPI_INT, MPI_ANY_SOURCE, i, 
157                       MPI_COMM_WORLD, MPI_STATUS_IGNORE );
158             MPI_Send( MPI_BOTTOM, 0, MPI_INT, next, i, MPI_COMM_WORLD );
159         }
160     }
161
162     if (rmabuffer) {
163         MPI_Free_mem( rmabuffer );
164     }
165     if (getbuf) {
166         free( getbuf );
167     }
168     MPI_Win_free( &win );
169     MPI_Type_free( &vectype );
170
171     MTest_Finalize( errs );
172     MPI_Finalize();
173     return MTestReturnValue( errs );
174 }
175
176 /* Perform the tests.
177  *
178  * The srcbuf must be passed in because the buffer must remain valid
179  * until the subsequent unlock call. */
180 void RMATest( int i, MPI_Win win, int master, int *srcbuf, int srcbufsize, int *getbuf, int getbufsize )
181 {
182     int j, k;
183     int *source = srcbuf;
184     assert(srcbufsize == RMA_SIZE);
185
186     for (j=0; j<srcbufsize; j++) source[j] = -j;
187
188     switch (i) {
189     case 0: /* Single short put (1 word at OFFSET_1) */
190         source[0] = PUT_VAL;
191         MPI_Put( source, 1, MPI_INT, master, OFFSET_1, 1, MPI_INT, win );
192         break;
193     case 1: /* Single short accumulate (1 word of value 17 at OFFSET_2) */
194         source[0] = ACC_VAL;
195         MPI_Accumulate( source, 1, MPI_INT, master, 
196                         OFFSET_2, 1, MPI_INT, MPI_SUM, win );
197         break;
198     case 2: /* Single short get (1 word at OFFSET_3) */
199         getbuf[0] = -1;
200         MPI_Get( getbuf, 1, MPI_INT, master, OFFSET_3, 1, MPI_INT, win );
201         break;
202     case 3: /* Datatype single put (strided put) */
203         for (j=0; j<veccount; j++) {
204             source[j*stride] = PUT_VAL + j;
205         }
206         MPI_Put( source, 1, vectype, master, OFFSET_1, 1, vectype, win );
207         break;
208     case 4: /* Datatype single accumulate (strided acc) */
209         for (j=0; j<veccount; j++) {
210             source[j*stride] = ACC_VAL + j;
211         }
212         MPI_Accumulate( source, 1, vectype, master, 
213                         OFFSET_2, 1, vectype, MPI_SUM, win );
214         break;
215     case 5: /* Datatype single get (strided get) */
216         for (j=0; j<veccount; j++) {
217             getbuf[j] = -j;
218         }
219         MPI_Get( getbuf, 1, vectype, master,
220                  OFFSET_3, 1, vectype, win );
221         break;
222     case 6: /* a few small puts (like strided put, but 1 word at a time) */
223         for (j=0; j<veccount; j++) {
224             source[j*stride] = PUT_VAL + j;
225         }
226         for (j=0; j<veccount; j++) {
227             MPI_Put( source + j*stride, 1, MPI_INT, master, 
228                      OFFSET_1+j*stride, 1, MPI_INT, win );
229         }
230         break;
231     case 7: /* a few small accumulates (like strided acc, but 1 word at a time )*/
232         for (j=0; j<veccount; j++) {
233             source[j*stride] = ACC_VAL + j;
234         }
235         for (j=0; j<veccount; j++) {
236             MPI_Accumulate( source + j*stride, 1, MPI_INT, master, 
237                             OFFSET_2+j*stride, 1, MPI_INT, MPI_SUM, win );
238         }
239         break;
240     case 8: /* a few small gets (like strided get, but 1 word at a time) */
241         for (j=0; j<veccount; j++) {
242             getbuf[j*stride] = -j;
243         }
244         for (j=0; j<veccount; j++) {
245             MPI_Get( getbuf + j*stride, 1, MPI_INT, master, 
246                      OFFSET_3+j*stride, 1, MPI_INT, win );
247         }
248         break;
249     case 9: /* Single long put (OFFSET_1) */
250         for (j=0; j<longcount; j++) source[j] = j;
251         MPI_Put( source, longcount, MPI_INT, master,
252                  OFFSET_1, longcount, MPI_INT, win ); 
253         break;
254     case 10: /* Single long accumulate (OFFSET_2) */
255         for (j=0; j<longcount; j++) source[j] = j;
256         MPI_Accumulate( source, longcount, MPI_INT, master, 
257                         OFFSET_2, longcount, MPI_INT, MPI_SUM, win );
258         break;
259     case 11: /* Single long get (OFFSET_3) */
260         for (j=0; j<longcount; j++) getbuf[j] = -j;
261         MPI_Get( getbuf, longcount, MPI_INT, master,
262                  OFFSET_3, longcount, MPI_INT, win ); 
263         break;
264     case 12: /* a few long puts (start at OFFSET_1, medcount ) */
265         for (j=0; j<mednum; j++) {
266             for (k=0; k<medcount; k++) {
267                 source[j*medcount+k] = j*2*medcount+k;
268             }
269             MPI_Put( source + j*medcount, medcount, MPI_INT, master,
270                      OFFSET_1 + j*2*medcount, medcount, MPI_INT, win );
271         }
272         break;
273     case 13: /* a few long accumulates (start at OFFSET_2, medcount) */
274         for (j=0; j<mednum; j++) {
275             for (k=0; k<medcount; k++) {
276                 source[j*medcount+k] = ACC_VAL + j*2*medcount+k;
277             }
278             MPI_Accumulate( source + j*medcount, medcount, MPI_INT, master,
279                             OFFSET_2 + j*2*medcount, medcount, MPI_INT, 
280                             MPI_SUM, win );
281         }
282         break;
283     case 14: /* a few long gets (start at OFFSET_3, medcount) */
284         for (j=0; j<mednum; j++) {
285             for (k=0; k<medcount; k++) {
286                 getbuf[j*medcount+k] = -(j*medcount+k);
287             }
288             MPI_Get( getbuf + j*medcount, medcount, MPI_INT, master,
289                             OFFSET_3 + j*2*medcount, medcount, MPI_INT, win );
290         }
291         break;
292     }
293 }
294
295 int RMACheck( int i, int *buf, MPI_Aint bufsize )
296 {
297     int j, k;
298     int errs = 0;
299
300     switch (i) {
301     case 0: /* Single short put (1 word at OFFSET_1) */
302         if (buf[OFFSET_1] != PUT_VAL) {
303             errs++;
304             printf( "case 0: value is %d should be %d\n", 
305                     buf[OFFSET_1], PUT_VAL );
306         }
307         break;
308     case 1: /* Single short accumulate (1 word of value 17 at OFFSET_2) */
309         if (buf[OFFSET_2] != ACC_VAL + OFFSET_2) {
310             errs++;
311             printf( "case 1: value is %d should be %d\n", 
312                     buf[OFFSET_2], ACC_VAL + OFFSET_2 );
313         }
314         break;
315     case 2: /* Single short get (1 word at OFFSET_3) */
316         /* See RMACheckGet */
317         break;
318     case 3: /* Datatype single put (strided put) */
319     case 6: /* a few small puts (like strided put, but 1 word at a time) */
320         /* FIXME: The conditional and increment are reversed below.  This looks
321          * like a bug, and currently prevents the following test from running. */
322         for (j=0; j++; j<veccount) {
323             if (buf[j*stride] != PUT_VAL + j) {
324                 errs++;
325                 printf( "case %d: value is %d should be %d\n", i,
326                         buf[j*stride], PUT_VAL+j );
327             }
328         }
329         break;
330     case 4: /* Datatype single accumulate (strided acc) */
331     case 7: /* a few small accumulates (like strided acc, but 1 word at a time )*/
332         /* FIXME: The conditional and increment are reversed below.  This looks
333          * like a bug, and currently prevents the following test from running. */
334         for (j=0; j++; j<veccount) {
335             if (buf[j*stride] != ACC_VAL + j + OFFSET_2 + j*stride) {
336                 errs++;
337                 printf( "case %d: value is %d should be %d\n", i,
338                         buf[j*stride], ACC_VAL+j+OFFSET_2+j*stride );
339             }
340         }
341         break;
342     case 5: /* Datatype single get (strided get) */
343     case 8: /* a few small gets (like strided get, but 1 word at a time) */
344         /* See RMACheckGet */
345         break;
346     case 9: /* Single long put (OFFSET_1) */
347         for (j=0; j<longcount; j++) {
348             if (buf[OFFSET_1+j] != j) {
349                 errs++;
350                 printf( "case 9: value is %d should be %d\n",
351                         buf[OFFSET_1+j], OFFSET_1 + j );
352             }
353         }
354         break;
355     case 10: /* Single long accumulate (OFFSET_2) */
356         for (j=0; j<longcount; j++) {
357             if (buf[OFFSET_2+j] != OFFSET_2 + j + j) {
358                 errs++;
359                 printf( "case 10: value is %d should be %d\n", 
360                         buf[OFFSET_2+j], OFFSET_2 + j + j );
361             }
362         }
363         break;
364     case 11: /* Single long get (OFFSET_3) */
365         /* See RMACheckGet */
366         break;
367     case 12: /* a few long puts (start at OFFSET_1, medcount ) */
368         for (j=0; j<mednum; j++) {
369             for (k=0; k<medcount; k++) {
370                 if (buf[OFFSET_1 + j*2*medcount + k] != 
371                     j*2*medcount+k ) {
372                     errs++;
373                     printf( "case 12: value is %d should be %d\n", 
374                             buf[OFFSET_1+j*2*medcount + k], j*2*medcount + k );
375                 }
376             }
377         }
378         break;
379     case 13: /* a few long accumulates (start at OFFSET_2, medcount) */
380         for (j=0; j<mednum; j++) {
381             for (k=0; k<medcount; k++) {
382                 if (buf[OFFSET_2 + j*2*medcount + k] != 
383                     OFFSET_2 + 2*j*2*medcount+2*k + ACC_VAL ) {
384                     errs++;
385                     printf( "case 13: value is %d should be %d\n", 
386                             buf[OFFSET_2+j*2*medcount + k], 
387                             OFFSET_2 + 2*j*2*medcount + k +ACC_VAL);
388                 }
389             }
390         }
391         break;
392     case 14: /* a few long gets (start at OFFSET_3, medcount) */
393         /* See RMACheckGet */
394         break;
395     default:
396         fprintf( stderr, "Unrecognized case %d\n", i );
397         errs++;
398         break;
399     }
400     return errs;
401 }
402
403 int RMACheckGet( int i, MPI_Win win, int *getbuf, MPI_Aint getsize)
404 {
405     int errs = 0;
406     int j, k;
407
408     /* */
409     switch (i) {
410     case 0: /* Single short put (1 word at OFFSET_1) */
411         break;
412     case 1: /* Single short accumulate (1 word of value 17 at OFFSET_2) */
413         break;
414     case 2: /* Single short get (1 word at OFFSET_3) */
415         if (getbuf[0] != OFFSET_3) {
416             errs++;
417             printf( "case 2: value is %d should be %d\n", 
418                     getbuf[0], OFFSET_3 );
419         }
420         break;
421     case 3: /* Datatype single put (strided put) */
422         break;
423     case 4: /* Datatype single accumulate (strided acc) */
424         break;
425     case 5: /* Datatype single get (strided get) */
426     case 8: /* a few small gets (like strided get, but 1 word at a time) */
427         for (j=0; j<veccount; j++) {
428             if (getbuf[j*stride] != OFFSET_3 + j*stride) {
429                 errs++;
430                 printf( "case %d: value is %d should be %d\n", i,
431                         getbuf[j*stride], OFFSET_3 + j*stride );
432             }
433         }
434         
435         break;
436     case 6: /* a few small puts (like strided put, but 1 word at a time) */
437         break;
438     case 7: /* a few small accumulates (like strided acc, but 1 word at a time )*/
439         break;
440     case 9: /* Single long put (OFFSET_1) */
441         break;
442     case 10: /* Single long accumulate (OFFSET_2) */
443         break;
444     case 11: /* Single long get (OFFSET_3) */
445         for (j=0; j<longcount; j++) {
446             if (getbuf[j] != OFFSET_3 + j) {
447                 errs++;
448                 printf( "case 11: value is %d should be %d\n",
449                         getbuf[j], OFFSET_3 + j );
450             }
451         }
452         break;
453     case 12: /* a few long puts (start at OFFSET_1, medcount ) */
454         break;
455     case 13: /* a few long accumulates (start at OFFSET_2, medcount) */
456         break;
457     case 14: /* a few long gets (start at OFFSET_3, medcount) */
458         for (j=0; j<mednum; j++) {
459             for (k=0; k<medcount; k++) {
460                 if (getbuf[j*medcount + k] != 
461                     OFFSET_3 + j*2*medcount+k ) {
462                     errs++;
463                     printf( "case 14: buf[%d] value is %d should be %d\n", 
464                             j*medcount + k,
465                             getbuf[j*medcount + k], 
466                             OFFSET_3 + j*2*medcount + k );
467                 }
468             }
469         }
470         break;
471     default:
472         fprintf( stderr, "Unrecognized case %d\n", i );
473         errs++;
474         break;
475     }
476     return errs;
477 }
478
479
480 void RMATestInit( int i, int *buf, MPI_Aint bufsize )
481 {
482     int j;
483     for (j=0; j<bufsize; j++) {
484         buf[j] = j;
485     }
486 }
487