1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2 * Copyright by the Board of Trustees of the University of Illinois.         *
3 * All rights reserved.                                                      *
4 *                                                                           *
5 * This file is part of HDF5.  The full HDF5 copyright notice, including     *
6 * terms governing use, modification, and redistribution, is contained in    *
7 * the files COPYING and Copyright.html.  COPYING can be found at the root   *
8 * of the source code distribution tree; Copyright.html can be found at the  *
9 * root level of an installed copy of the electronic HDF5 document set and   *
10 * is linked from the top-level documents page.  It can also be found at     *
11 * http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html.  If you do not have     *
12 * access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
13 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
14
15
16/*
17 * Main driver of the Parallel NetCDF4 tests
18 *
19 */
20
21#include <nc_tests.h>
22#include "err_macros.h"
23#define FILE_NAME "tst_parallel3.nc"
24
25/*2,3,4 dimensional test, the first dimension is unlimited, time.
26 */
27
28#define NDIMS1 2
29#define NDIMS2 4
30#define DIMSIZE /*4 */ 768*2
31#define DIMSIZE2 4
32#define DIMSIZE3 4
33#define TIMELEN 1
34
35/*BIGFILE, >2G, >4G, >8G file
36  big file is created but no actually data is written
37  Dimensional size is defined inside the function
38*/
39
40#define ATTRNAME1 "valid_range"
41#define ATTRNAME2 "scale_factor"
42#define ATTRNAME3 "title"
43
44/* The number of processors should be a good number for the
45   dimension to be divided evenly, the best set of number of processor
46   should be 2 power n. However, for NetCDF4 tests, the following numbers
47   are generally treated as good numbers:
48   1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256
49
50   The maximum number of processor is 256.*/
51
52int test_pio(int);
53int test_pio_attr(int);
54int test_pio_big(int);
55int test_pio_hyper(int);
56int test_pio_extend(int);
57
58char* getenv_all(MPI_Comm comm, int root, const char* name);
59int facc_type;
60int facc_type_open;
61char file_name[NC_MAX_NAME + 1];
62
63int main(int argc, char **argv)
64{
65   int mpi_sizempi_rank; /* mpi variables */
66   int i;
67   int NUMP[16] ={1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256};
68   int size_flag = 0;
69
70   /* Un-buffer the stdout and stderr */
71   setbuf(stderrNULL);
72   setbuf(stdoutNULL);
73
74   MPI_Init(&argc, &argv);
75   MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
76   MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
77
78   if (mpi_rank == 0)
79      printf("\n*** Testing more advanced parallel access.\n");
80
81   for (i = 0; i < 16; i++){
82      if(mpi_size == NUMP[i])
83      {
84  size_flag = 1;
85  break;
86      }
87   }
88   if(!size_flag){
89      printf("mpi_size is wrong\n");
90      printf(" The number of processor must be chosen from\n");
91      printf(" 1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256 \n");
92      return -1;
93   }
94
95   facc_type = NC_NETCDF4|NC_MPIIO;
96   facc_type_open = NC_MPIIO;
97
98   /* Create file name. */
99   sprintf(file_name, "%s/%s", TEMP_LARGEFILE_NAME);
100
101   /* Test NetCDF4 with MPI-IO driver */
102   if (mpi_rank == 0)
103      printf("*** Testing parallel IO for raw-data with MPI-IO (driver)...");
104   if(test_pio(NC_INDEPENDENT)!=0) ERR;
105   if(test_pio(NC_COLLECTIVE)!=0) ERR;
106   if (mpi_rank == 0)
107      SUMMARIZE_ERR;
108
109   if (mpi_rank == 0)
110      printf("*** Testing parallel IO for meta-data with MPI-IO (driver)...");
111   if(test_pio_attr(NC_INDEPENDENT)!=0) ERR;
112   if(test_pio_attr(NC_COLLECTIVE)!=0) ERR;
113   if (mpi_rank == 0)
114      SUMMARIZE_ERR;
115
116   if (mpi_rank == 0)
117      printf("*** Testing parallel IO for different hyperslab selections with MPI-IO (driver)...");
118   if(test_pio_hyper(NC_INDEPENDENT)!=0)ERR;
119   if(test_pio_hyper(NC_COLLECTIVE)!=0) ERR;
120   if (mpi_rank == 0)
121      SUMMARIZE_ERR;
122
123   if (mpi_rank == 0)
124      printf("*** Testing parallel IO for extending variables with MPI-IO (driver)...");
125   if(test_pio_extend(NC_COLLECTIVE)!=0) ERR;
126   if (mpi_rank == 0)
127      SUMMARIZE_ERR;
128
129/* Note: When the MPI-POSIX VFD is not compiled in to HDF5, the NC_MPIPOSIX
130 *      flag will be aliased to the NC_MPIIO flag within the library, and
131 *      therefore this test will exercise the aliasing, with the MPI-IO VFD,
132 *      under that configuration. -QAK
133 */
134   if (mpi_rank == 0)
135      printf("*** Testing parallel IO for raw-data with MPIPOSIX-IO (driver)...");
136   facc_type = NC_NETCDF4|NC_MPIPOSIX;
137   facc_type_open = NC_MPIPOSIX;
138   if(test_pio(NC_INDEPENDENT)!=0) ERR;
139   if(test_pio(NC_COLLECTIVE)!=0) ERR;
140   if (mpi_rank == 0)
141      SUMMARIZE_ERR;
142
143   if (mpi_rank == 0)
144      printf("*** Testing parallel IO for meta-data with MPIPOSIX-IO (driver)...");
145   if(test_pio_attr(NC_INDEPENDENT)!=0) ERR;
146   if(test_pio_attr(NC_COLLECTIVE)!=0) ERR;
147   if (mpi_rank == 0)
148      SUMMARIZE_ERR;
149
150   if (mpi_rank == 0)
151      printf("*** Testing parallel IO for different hyperslab selections "
152      "with MPIPOSIX-IO (driver)...");
153   if(test_pio_hyper(NC_INDEPENDENT)!=0)ERR;
154   if(test_pio_hyper(NC_COLLECTIVE)!=0) ERR;
155   if (mpi_rank == 0)
156      SUMMARIZE_ERR;
157
158   if (mpi_rank == 0)
159      printf("*** Testing parallel IO for extending variables with MPIPOSIX-IO (driver)...");
160   if(test_pio_extend(NC_COLLECTIVE)!=0) ERR;
161   if (mpi_rank == 0)
162      SUMMARIZE_ERR;
163
164/*     if(!getenv_all(MPI_COMM_WORLD,0,"NETCDF4_NOCLEANUP")) */
165   remove(file_name);
166   MPI_Finalize();
167
168   if (mpi_rank == 0)
169      FINAL_RESULTS;
170   return 0;
171}
172
173/* Both read and write will be tested */
174int test_pio(int flag)
175{
176   /* MPI stuff. */
177   int mpi_sizempi_rank;
178   MPI_Comm comm = MPI_COMM_WORLD;
179   MPI_Info info = MPI_INFO_NULL;
180
181   /* Netcdf-4 stuff. */
182   int ncid;
183   int nvid,uvid;
184   int rvid;
185   unsigned m,k,j,i;
186
187   /* two dimensional integer data test */
188   int dimids[NDIMS1];
189   size_t start[NDIMS1];
190   size_t count[NDIMS1];
191
192   int *data;
193   int *tempdata;
194   int *rdata;
195   int *temprdata;
196
197   /* four dimensional integer data test,
198      time dimension is unlimited.*/
199   int  dimuids[NDIMS2];
200   size_t ustart[NDIMS2];
201   size_t ucount[NDIMS2];
202
203   int *udata;
204   int *tempudata;
205   int *rudata;
206   int *temprudata;
207
208   /* Initialize MPI. */
209   MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
210   MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
211
212   /* Create a parallel netcdf-4 file. */
213   if (nc_create_par(file_namefacc_typecomminfo, &ncid)) ERR;
214
215   /* The first case is two dimensional variables, no unlimited dimension */
216
217   /* Create two dimensions. */
218   if (nc_def_dim(ncid, "d1", DIMSIZE2dimids)) ERR;
219   if (nc_def_dim(ncid, "d2", DIMSIZE, &dimids[1])) ERR;
220
221   /* Create one var. */
222   if (nc_def_var(ncid, "v1", NC_INTNDIMS1dimids, &nvid)) ERR;
223
224   if (nc_enddef(ncid)) ERR;
225
226   /* Set up slab for this process. */
227   start[0] = 0;
228   start[1] = mpi_rank * DIMSIZE/mpi_size;
229   count[0] = DIMSIZE2;
230   count[1] = DIMSIZE/mpi_size;
231
232   /* start parallel netcdf4 */
233   if (nc_var_par_access(ncidnvidflag)) ERR;
234
235   if (!(data = malloc(sizeof(int)*count[1]*count[0]))) ERR;
236   tempdata = data;
237   for (j = 0; j < count[0]; j++){
238      for (i = 0; i < count[1]; i++)
239      {
240  *tempdata = mpi_rank * (j + 1);
241  tempdata++;
242      }
243   }
244
245   /* Write two dimensional integer data */
246   if (nc_put_vara_int(ncidnvidstartcountdata)) ERR;
247   free(data);
248
249   /* Case 2: create four dimensional integer data,
250      one dimension is unlimited. */
251
252   /* Create four dimensions. */
253   if (nc_def_dim(ncid, "ud1", NC_UNLIMITEDdimuids)) ERR;
254   if (nc_def_dim(ncid, "ud2", DIMSIZE3, &dimuids[1])) ERR;
255   if (nc_def_dim(ncid, "ud3", DIMSIZE2, &dimuids[2])) ERR;
256   if (nc_def_dim(ncid, "ud4", DIMSIZE, &dimuids[3])) ERR;
257
258   /* Create one var. */
259   if (nc_def_var(ncid, "uv1", NC_INTNDIMS2dimuids, &uvid)) ERR;
260
261   if (nc_enddef(ncid)) ERR;
262
263   /* Set up selection parameters */
264   ustart[0] = 0;
265   ustart[1] = 0;
266   ustart[2] = 0;
267   ustart[3] = DIMSIZE*mpi_rank/mpi_size;
268   ucount[0] = TIMELEN;
269   ucount[1] = DIMSIZE3;
270   ucount[2] = DIMSIZE2;
271   ucount[3] = DIMSIZE/mpi_size;
272
273   /* Access parallel */
274   if (nc_var_par_access(nciduvidflag)) ERR;
275
276   /* Create phony data. */
277   if (!(udata = malloc(ucount[0]*ucount[1]*ucount[2]*ucount[3]*sizeof(int)))) ERR;
278   tempudata = udata;
279   for( m=0; m<ucount[0];m++)
280      for( k=0; k<ucount[1];k++)
281  for (j=0; j<ucount[2];j++)
282     for (i=0; i<ucount[3]; i++)
283     {
284        *tempudata = (1+mpi_rank)*2*(j+1)*(k+1)*(m+1);
285        tempudata++;
286     }
287
288   /* Write slabs of phoney data. */
289   if (NC_INDEPENDENT == flag) {
290       int res;
291       res = nc_put_vara_int(nciduvidustartucountudata);
292       if(res != NC_ECANTEXTENDERR;
293   }
294   else {
295       if (nc_put_vara_int(nciduvidustartucountudata)) ERR;
296   }
297   free(udata);
298
299   /* Close the netcdf file. */
300   if (nc_close(ncid)) ERR;
301
302   if (nc_open_par(file_namefacc_type_opencomminfo, &ncid)) ERR;
303
304   /* Case 1: read two-dimensional variables, no unlimited dimension */
305   /* Set up slab for this process. */
306   start[0] = 0;
307   start[1] = mpi_rank * DIMSIZE/mpi_size;
308   count[0] = DIMSIZE2;
309   count[1] = DIMSIZE/mpi_size;
310
311   if (nc_inq_varid(ncid, "v1", &rvid)) ERR;
312
313   if (nc_var_par_access(ncidrvidflag)) ERR;
314
315   if (!(rdata = malloc(sizeof(int)*count[1]*count[0]))) ERR;
316   if (nc_get_vara_int(ncidrvidstartcountrdata)) ERR;
317
318   temprdata = rdata;
319   for (j=0; j<count[0];j++){
320      for (i=0; i<count[1]; i++){
321  if(*temprdata != mpi_rank*(j+1))
322  {
323     ERR_RET;
324     break;
325  }
326  temprdata++;
327      }
328   }
329   free(rdata);
330
331   /* Case 2: read four dimensional data, one dimension is unlimited. */
332
333   /* set up selection parameters */
334   ustart[0] = 0;
335   ustart[1] = 0;
336   ustart[2] = 0;
337   ustart[3] = DIMSIZE*mpi_rank/mpi_size;
338   ucount[0] = TIMELEN;
339   ucount[1] = DIMSIZE3;
340   ucount[2] = DIMSIZE2;
341   ucount[3] = DIMSIZE/mpi_size;
342
343   /* Inquiry the data */
344   /* (NOTE: This variable isn't written out, when access is independent) */
345   if (NC_INDEPENDENT != flag) {
346       if (nc_inq_varid(ncid, "uv1", &rvid)) ERR;
347
348       /* Access the parallel */
349       if (nc_var_par_access(ncidrvidflag)) ERR;
350
351       if (!(rudata = malloc(ucount[0]*ucount[1]*ucount[2]*ucount[3]*sizeof(int)))) ERR;
352       temprudata = rudata;
353
354       /* Read data */
355       if (nc_get_vara_int(ncidrvidustartucountrudata)) ERR;
356
357       for(m = 0; m < ucount[0]; m++)
358          for(k = 0; k < ucount[1]; k++)
359             for(j = 0; j < ucount[2]; j++)
360                for(i = 0; i < ucount[3]; i++)
361                {
362                   if(*temprudata != (1+mpi_rank)*2*(j+1)*(k+1)*(m+1))
363                      ERR_RET;
364                   temprudata++;
365                }
366
367       free(rudata);
368   }
369
370   /* Close the netcdf file. */
371   if (nc_close(ncid)) ERR;
372
373   return 0;
374}
375
376
377/* Attributes: both read and write will be tested for parallel NetCDF*/
378
379int test_pio_attr(int flag)
380{
381   /* MPI stuff. */
382   int mpi_sizempi_rank;
383   MPI_Comm comm = MPI_COMM_WORLD;
384   MPI_Info info = MPI_INFO_NULL;
385
386   /* Netcdf-4 stuff. */
387   int ncid;
388   int nvid;
389   int ji;
390
391   double rh_range[2];
392   static char title[] = "parallel attr to netCDF";
393   nc_type    st_type,vr_type;
394   size_t     vr_len,st_len;
395   size_t     orivr_len;
396   double *vr_val;
397   char   *st_val;
398
399   /* two dimensional integer data*/
400   int dimids[NDIMS1];
401   size_t start[NDIMS1];
402   size_t count[NDIMS1];
403   int *data;
404   int *tempdata;
405
406   /* Initialize MPI. */
407   MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
408   MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
409
410   /* Create a parallel netcdf-4 file. */
411/*    nc_set_log_level(NC_TURN_OFF_LOGGING); */
412   /*    nc_set_log_level(3);*/
413
414   if (nc_create_par(file_namefacc_typecomminfo, &ncid)) ERR;
415
416   /* Create a 2-D variable so that an attribute can be added. */
417   if (nc_def_dim(ncid, "d1", DIMSIZE2dimids)) ERR;
418   if (nc_def_dim(ncid, "d2", DIMSIZE, &dimids[1])) ERR;
419
420   /* Create one var. */
421   if (nc_def_var(ncid, "v1", NC_INTNDIMS1dimids, &nvid)) ERR;
422
423   orivr_len = 2;
424   rh_range[0] = 1.0;
425   rh_range[1] = 1000.0;
426
427   /* Write attributes of a variable */
428
429   if (nc_put_att_double (ncidnvid, "valid_range", NC_DOUBLE,
430   orivr_lenrh_range)) ERR;
431
432   if (nc_put_att_text (ncidnvid, "title", strlen(title),
433 title)) ERR;
434
435   /* Write global attributes */
436   if (nc_put_att_double (ncidNC_GLOBAL, "g_valid_range", NC_DOUBLE,
437   orivr_lenrh_range)) ERR;
438   if (nc_put_att_text (ncidNC_GLOBAL, "g_title", strlen(title), title)) ERR;
439
440   if (nc_enddef(ncid)) ERR;
441
442   /* Set up slab for this process. */
443   start[0] = 0;
444   start[1] = mpi_rank * DIMSIZE/mpi_size;
445   count[0] = DIMSIZE2;
446   count[1] = DIMSIZE/mpi_size;
447
448   /* Access parallel */
449   if (nc_var_par_access(ncidnvidflag)) ERR;
450
451   /* Allocating data */
452   data      = malloc(sizeof(int)*count[1]*count[0]);
453   tempdata  = data;
454   for(j = 0; j < count[0]; j++)
455      for (i = 0; i < count[1]; i++)
456      {
457  *tempdata = mpi_rank * (j + 1);
458  tempdata++;
459      }
460
461   if (nc_put_vara_int(ncidnvidstartcountdata)) ERR;
462   free(data);
463
464   /* Close the netcdf file. */
465if (nc_close(ncid)) ERR;
466
467   /* Read attributes */
468if (nc_open_par(file_namefacc_type_opencomminfo, &ncid)) ERR;
469
470   /* Set up slab for this process. */
471   start[0] = 0;
472   start[1] = mpi_rank * DIMSIZE/mpi_size;
473   count[0] = DIMSIZE2;
474   count[1] = DIMSIZE/mpi_size;
475
476   /* Inquiry variable */
477   if (nc_inq_varid(ncid, "v1", &nvid)) ERR;
478
479   /* Access parallel */
480   if (nc_var_par_access(ncidnvidflag)) ERR;
481
482   /* Inquiry attribute */
483   if (nc_inq_att (ncidnvid, "valid_range", &vr_type, &vr_len)) ERR;
484
485   /* check stuff */
486   if(vr_type != NC_DOUBLE || vr_len != orivr_lenERR;
487
488   vr_val = (double *) malloc(vr_len * sizeof(double));
489
490   /* Get variable attribute values */
491   if (nc_get_att_double(ncidnvid, "valid_range", vr_val)) ERR;
492
493   /* Check variable attribute value */
494   for(i = 0; i < vr_leni++)
495      if (vr_val[i] != rh_range[i])
496  ERR_RET;
497   free(vr_val);
498
499   /* Inquiry global attribute */
500   if (nc_inq_att (ncidNC_GLOBAL, "g_valid_range", &vr_type, &vr_len)) ERR;
501
502   /* Check stuff. */
503   if(vr_type != NC_DOUBLE || vr_len != orivr_lenERR;
504
505   /* Obtain global attribute value */
506   vr_val = (double *) malloc(vr_len * sizeof(double));
507   if (nc_get_att_double(ncidNC_GLOBAL, "g_valid_range", vr_val)) ERR;
508
509   /* Check global attribute value */
510   for(i = 0; i < vr_leni++)
511      if (vr_val[i] != rh_range[i]) ERR_RET;
512   free(vr_val);
513
514   /* Inquiry string attribute of a variable */
515   if (nc_inq_att (ncidnvid, "title", &st_type, &st_len)) ERR;
516
517   /* check string attribute length */
518   if(st_len != strlen(title)) ERR_RET;
519
520   /* Check string attribute type */
521   if(st_type != NC_CHARERR_RET;
522
523   /* Allocate meory for string attribute */
524   st_val = (char *) malloc(st_len * (sizeof(char)));
525
526   /* Obtain variable string attribute value */
527   if (nc_get_att_text(ncidnvid,"title", st_val)) ERR;
528
529   /*check string value */
530   if(strncmp(st_val,title,st_len)) {
531      free(st_val);
532      ERR_RET;
533   }
534   free(st_val);
535
536   /*Inquiry global attribute */
537   if (nc_inq_att (ncidNC_GLOBAL, "g_title", &st_type, &st_len)) ERR;
538
539   /* check attribute length*/
540   if(st_len != strlen(title)) ERR_RET;
541
542   /*check attribute type*/
543   if(st_type != NC_CHARERR_RET;
544
545   /* obtain global string attribute value */
546   st_val = (char*)malloc(st_len*sizeof(char));
547   if (nc_get_att_text(ncidNC_GLOBAL,"g_title", st_val)) ERR;
548
549   /* check attribute value */
550   if(strncmp(st_val,title,st_len)){
551      free(st_val);
552      ERR_RET;
553   }
554   free(st_val);
555
556   /* Close the netcdf file. */
557   if (nc_close(ncid)) ERR;
558
559   return 0;
560}
561
562/* test different hyperslab settings */
563int test_pio_hyper(int flag){
564
565   /* MPI stuff. */
566   int mpi_sizempi_rank;
567   int res = NC_NOERR;
568   MPI_Comm comm = MPI_COMM_WORLD;
569   MPI_Info info = MPI_INFO_NULL;
570
571   /* Netcdf-4 stuff. */
572   int ncid;
573   int nvid;
574   int rvid;
575   int ji;
576
577   /* two dimensional integer data test */
578   int dimids[NDIMS1];
579   size_t start[NDIMS1], count[NDIMS1];
580   int *data;
581   int *tempdata;
582   int *rdata;
583   int *temprdata;
584   int count_atom;
585
586
587   /* Initialize MPI. */
588   MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
589   MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
590
591   if(mpi_size == 1) return 0;
592
593   /* Create a parallel netcdf-4 file. */
594/*      nc_set_log_level(NC_TURN_OFF_LOGGING); */
595/*      nc_set_log_level(4);*/
596
597   if (nc_create_par(file_namefacc_typecomminfo, &ncid)) ERR;
598
599   /* The case is two dimensional variables, no unlimited dimension */
600
601   /* Create two dimensions. */
602   if (nc_def_dim(ncid, "d1", DIMSIZE2dimids)) ERR;
603   if (nc_def_dim(ncid, "d2", DIMSIZE, &dimids[1])) ERR;
604
605   /* Create one var. */
606   if (nc_def_var(ncid, "v1", NC_INTNDIMS1dimids, &nvid)) ERR;
607
608   if (nc_enddef(ncid)) ERR;
609
610
611   /* hyperslab illustration for 3-processor case
612
613      --------
614      |aaaacccc|
615      |aaaacccc|
616      |bbbb    |
617      |bbbb    |
618      --------
619   */
620
621   /* odd number of processors should be treated differently */
622   if(mpi_size%2 != 0) {
623
624      count_atom = DIMSIZE*2/(mpi_size+1);
625      if(mpi_rank <= mpi_size/2) {
626         start[0] = 0;
627         start[1] = mpi_rank*count_atom;
628         count[0] = DIMSIZE2/2;
629         count[1] = count_atom;
630      }
631      else {
632         start[0] = DIMSIZE2/2;
633         start[1] = (mpi_rank-mpi_size/2-1)*count_atom;
634         count[0] = DIMSIZE2/2;
635         count[1] = count_atom;
636      }
637   }
638   else  {
639
640      count_atom = DIMSIZE*2/mpi_size;
641      if(mpi_rank < mpi_size/2) {
642         start[0] = 0;
643         start[1] = mpi_rank*count_atom;
644         count[0] = DIMSIZE2/2;
645         count[1] = count_atom;
646      }
647      else {
648         start[0] = DIMSIZE2/2;
649         start[1] = (mpi_rank-mpi_size/2)*count_atom;
650         count[0] = DIMSIZE2/2;
651         count[1] = count_atom;
652      }
653   }
654
655   if (nc_var_par_access(ncidnvidflag)) ERR;
656   data      = malloc(sizeof(int)*count[1]*count[0]);
657   tempdata  = data;
658   for (j=0; j<count[0];j++){
659      for (i=0; i<count[1]; i++){
660  *tempdata = mpi_rank*(j+1);
661  tempdata ++;
662      }
663   }
664
665
666   if (nc_put_vara_int(ncidnvidstartcountdata)) ERR;
667   free(data);
668
669   /* Close the netcdf file. */
670   if (nc_close(ncid)) ERR;
671
672   if (nc_open_par(file_namefacc_type_opencomminfo, &ncid)) ERR;
673
674   /* Inquiry the variable */
675   if (nc_inq_varid(ncid, "v1", &rvid)) ERR;
676
677   if (nc_var_par_access(ncidrvidflag)) ERR;
678
679   rdata      = malloc(sizeof(int)*count[1]*count[0]);
680   /* Read the data with the same slab settings */
681   if (nc_get_vara_int(ncidrvidstartcountrdata)) ERR;
682
683   temprdata = rdata;
684   for (j=0; j<count[0];j++){
685      for (i=0; i<count[1]; i++){
686  if(*temprdata != mpi_rank*(j+1))
687  {
688     res = -1;
689     break;
690  }
691  temprdata++;
692      }
693   }
694
695   free(rdata);
696   if(res == -1) ERR_RET;
697
698   /* Close the netcdf file. */
699   if (nc_close(ncid)) ERR;
700
701   return 0;
702}
703
704/* test extending variables */
705int test_pio_extend(int flag){
706    int rankprocs;
707    int ncFile;
708    int ncDimPart;
709    int ncDimVrtx;
710    int ncVarVrtx;
711    int dimsVrtx[2];
712    size_t start[2];
713    size_t count[2];
714    int vertices[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
715
716    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
717    MPI_Comm_size(MPI_COMM_WORLD, &procs);
718
719    /* Create netcdf file */
720    if (nc_create_par("test.nc", NC_NETCDF4 | NC_MPIIOMPI_COMM_WORLDMPI_INFO_NULL, &ncFile)) ERR;
721
722    /* Create netcdf dimensions */
723    if (nc_def_dim(ncFile, "partitions", procs, &ncDimPart)) ERR;
724    if (nc_def_dim(ncFile, "vertices", NC_UNLIMITED, &ncDimVrtx)) ERR;
725
726    /* Create netcdf variables */
727    dimsVrtx[0] = ncDimPart;
728    dimsVrtx[1] = ncDimVrtx;
729    if (nc_def_var(ncFile, "vertex", NC_INT, 2, dimsVrtx, &ncVarVrtx)) ERR;
730
731    /* Start writing data */
732    if (nc_enddef(ncFile)) ERR;
733
734    /* Set access mode */
735    if (nc_var_par_access(ncFilencVarVrtxflag)) ERR;
736
737    /* Write vertices */
738    start[0] = rank;
739    start[1] = 0;
740    count[0] = 1;
741    count[1] = rank;
742    if (nc_put_vara_int(ncFilencVarVrtxstartcountvertices)) ERR;
743
744    /* Close netcdf file */
745    if (nc_close(ncFile)) ERR;
746
747   return 0;
748}
749
750/*-------------------------------------------------------------------------
751 * Function: getenv_all
752 *
753 * Purpose: Used to get the environment that the root MPI task has.
754 *  name specifies which environment variable to look for
755 *  val is the string to which the value of that environment
756 *  variable will be copied.
757 *
758 *  NOTE: The pointer returned by this function is only
759 *  valid until the next call to getenv_all and the data
760 *  stored there must be copied somewhere else before any
761 *  further calls to getenv_all take place.
762 *
763 * Return: pointer to a string containing the value of the environment variable
764 *  NULL if the varialbe doesn't exist in task 'root's environment.
765 *
766 * Programmer: Leon Arber
767 *              4/4/05
768 *
769 * Modifications:
770 *
771 *-------------------------------------------------------------------------
772 */
773
774char* getenv_all(MPI_Comm comm, int root, const char* name)
775{
776   int nID;
777   int len = -1;
778   static char* env = NULL;
779
780   assert(name);
781
782   MPI_Comm_rank(comm, &nID);
783
784   /* The root task does the getenv call
785    * and sends the result to the other tasks */
786   if(nID == root)
787   {
788      env = getenv(name);
789      if(env)
790      {
791  len = strlen(env);
792  MPI_Bcast(&len, 1, MPI_INTrootcomm);
793  MPI_Bcast(envlenMPI_CHARrootcomm);
794      }
795      /* len -1 indicates that the variable was not in the environment */
796      else
797  MPI_Bcast(&len, 1, MPI_INTrootcomm);
798   }
799   else
800   {
801      MPI_Bcast(&len, 1, MPI_INTrootcomm);
802      if(len >= 0)
803      {
804  if(env == NULL)
805     env = (char*) malloc(len+1);
806  else if(strlen(env) < len)
807     env = (char*) realloc(envlen+1);
808
809  MPI_Bcast(envlenMPI_CHARrootcomm);
810  env[len] = '\0';
811      }
812      else
813      {
814  if(env)
815     free(env);
816  env = NULL;
817      }
818   }
819
820   MPI_Barrier(comm);
821
822   return env;
823}


HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017 | Polyhedron Solutions - INTERNAL USE | COMMERCIAL (Any O/S) SN 4AKIed