1/* This is part of the netCDF package.
2   Copyright 2005 University Corporation for Atmospheric Research/Unidata
3   See COPYRIGHT file for conditions of use.
4
5   Test netcdf-4 variables.
6   $Id: tst_chunks.c,v 1.3 2010/01/21 16:00:18 ed Exp $
7*/
8
9#include <nc_tests.h>
10#include "err_macros.h"
11
12#define FILE_NAME "tst_chunks.nc"
13#define NDIMS1 1
14#define D_SMALL "small_dim"
15#define D_SMALL_LEN 16
16#define D_MEDIUM "medium_dim"
17#define D_MEDIUM_LEN 65546
18#define D_LARGE "large_dim"
19#define D_LARGE_LEN 1048586
20#define V_SMALL "small_var"
21#define V_MEDIUM "medium_var"
22#define V_LARGE "large_var"
23
24int
25main(int argc, char **argv)
26{
27
28   printf("\n*** Testing netcdf-4 variable chunking.\n");
29   printf("**** testing that fixed vars with filter end up being chunked, with good sizes...");
30   {
31
32      int ncid;
33      int nvarsndimsngattsunlimdimid;
34      int contig;
35      int ndims_innatts_indimids_in;
36      int small_dimidmedium_dimidlarge_dimid;
37      int small_varidmedium_varidlarge_varid;
38      char var_name_in[NC_MAX_NAME + 1];
39      size_t chunksize_in[NDIMS1];
40      nc_type xtype_in;
41
42      /* Create a netcdf-4 file with three dimensions. */
43      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
44      if (nc_def_dim(ncidD_SMALLD_SMALL_LEN, &small_dimid)) ERR;
45      if (nc_def_dim(ncidD_MEDIUMD_MEDIUM_LEN, &medium_dimid)) ERR;
46      if (nc_def_dim(ncidD_LARGED_LARGE_LEN, &large_dimid)) ERR;
47
48      /* Add three vars, with filters to force chunking. */
49      if (nc_def_var(ncidV_SMALLNC_INT64NDIMS1, &small_dimid, &small_varid)) ERR;
50      if (nc_def_var_deflate(ncidsmall_varid, 0, 1, 4)) ERR;
51      if (nc_def_var(ncidV_MEDIUMNC_INT64NDIMS1, &medium_dimid, &medium_varid)) ERR;
52      if (nc_def_var_deflate(ncidmedium_varid, 1, 0, 0)) ERR;
53      if (nc_def_var(ncidV_LARGENC_INT64NDIMS1, &large_dimid, &large_varid)) ERR;
54      if (nc_def_var_fletcher32(ncidlarge_varid, 1)) ERR;
55      if (nc_close(ncid)) ERR;
56
57      /* Open the file and check. */
58      if (nc_open(FILE_NAMENC_WRITE, &ncid)) ERR;
59      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
60      if (nvars != 3 || ndims != 3 || ngatts != 0 || unlimdimid != -1) ERR;
61      if (nc_inq_var(ncid, 0, var_name_in, &xtype_in, &ndims_in, &dimids_in, &natts_in)) ERR;
62      if (strcmp(var_name_inV_SMALL) || xtype_in != NC_INT64 || ndims_in != 1 ||
63   natts_in != 0) ERR;
64
65      /* Make sure chunking sizes are what we expect. */
66      if (nc_inq_var_chunking(ncidsmall_varid, &contigchunksize_in)) ERR;
67      if (contig || chunksize_in[0] != D_SMALL_LENERR;
68      if (nc_inq_var_chunking(ncidmedium_varid, &contigchunksize_in)) ERR;
69      if (contig || chunksize_in[0] * sizeof(long long) > DEFAULT_CHUNK_SIZEERR;
70      if (nc_inq_var_chunking(ncidlarge_varid, &contigchunksize_in)) ERR;
71      if (contig || chunksize_in[0] * sizeof(long long) > DEFAULT_CHUNK_SIZEERR;
72
73      if (nc_close(ncid)) ERR;
74   }
75   SUMMARIZE_ERR;
76   printf("**** testing default chunksizes...");
77   {
78      int nvarsndimsngattsunlimdimid;
79      int contig;
80#define NUM_DIM 4
81#define NUM_TYPE 2
82      int ncid;
83      int dim_len[NUM_DIM] = {NC_UNLIMITED, 100, 1000, 2000};
84      size_t chunksize_in[NUM_DIM];
85      int type_id[NUM_TYPE] = {NC_BYTENC_INT};
86      int dimid[NUM_DIM], varid[NUM_TYPE];
87      char dim_name[NC_MAX_NAME + 1], var_name[NC_MAX_NAME + 1];
88      int dt;
89
90      /* Create a netcdf-4 file with NUM_DIM dimensions. */
91      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
92      for (d = 0; d < NUM_DIMd++)
93      {
94  sprintf(dim_name, "dim_%d", dim_len[d]);
95#ifdef PRINT_DEFAULT_CHUNKSIZE_TABLE
96  printf("creating dim %s\n", dim_name);
97#endif
98  if (nc_def_dim(nciddim_namedim_len[d], &dimid[d])) ERR;
99      }
100
101      for (t = 0; t < NUM_TYPEt++)
102      {
103  sprintf(var_name, "var_%d", type_id[t]);
104  if (nc_def_var(ncidvar_nametype_id[t], NUM_DIMdimid, &varid[t])) ERR;
105  if (nc_inq_var_chunking(ncidvarid[t], &contigchunksize_in)) ERR;
106#ifdef PRINT_DEFAULT_CHUNKSIZE_TABLE
107  printf("chunksizes for %d x %d x %d x %d var: %d x %d x %d x %d (=%d)\n",
108 dim_len[0], dim_len[1], dim_len[2], dim_len[3],
109 (int)chunksize_in[0], (int)chunksize_in[1], (int)chunksize_in[2],
110 (int)chunksize_in[3],
111 (int)(chunksize_in[0] * chunksize_in[1] * chunksize_in[2] * chunksize_in[3]));
112#endif
113      }
114
115      if (nc_close(ncid)) ERR;
116
117      /* Open the file and check. */
118      if (nc_open(FILE_NAMENC_WRITE, &ncid)) ERR;
119      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
120      if (nvars != NUM_TYPE || ndims != NUM_DIM || ngatts != 0 || unlimdimid != 0) ERR;
121
122      for (t = 0; t < NUM_TYPEt++)
123      {
124  sprintf(var_name, "var_%d", type_id[t]);
125  if (nc_inq_var_chunking(ncidvarid[t], &contigchunksize_in)) ERR;
126  if (contigERR;
127#ifdef PRINT_DEFAULT_CHUNKSIZE_TABLE
128  printf("chunksizes for %d x %d x %d x %d var: %d x %d x %d x %d (=%d)\n",
129 dim_len[0], dim_len[1], dim_len[2], dim_len[3],
130 (int)chunksize_in[0], (int)chunksize_in[1], (int)chunksize_in[2],
131 (int)chunksize_in[3],
132 (int)(chunksize_in[0] * chunksize_in[1] * chunksize_in[2] * chunksize_in[3]));
133#endif
134      }
135
136      if (nc_close(ncid)) ERR;
137   }
138   SUMMARIZE_ERR;
139   printf("**** testing that chunking works on classic mode files...");
140   {
141#define D_SMALL_LEN2 66
142      int ncid;
143      int nvarsndimsngattsunlimdimid;
144      int contig;
145      int ndims_innatts_indimids_in;
146      int small_dimidmedium_dimidlarge_dimid;
147      int small_varidmedium_varidlarge_varid;
148      char var_name_in[NC_MAX_NAME + 1];
149      size_t chunks[1], chunksize_in;
150      nc_type xtype_in;
151
152      /* Create a netcdf-4 file with three dimensions. */
153      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
154      if (nc_def_dim(ncidD_SMALLD_SMALL_LEN2, &small_dimid)) ERR;
155      if (nc_def_dim(ncidD_MEDIUMD_MEDIUM_LEN, &medium_dimid)) ERR;
156      if (nc_def_dim(ncidD_LARGED_LARGE_LEN, &large_dimid)) ERR;
157
158      /* Add three vars. */
159      if (nc_def_var(ncidV_SMALLNC_INT64NDIMS1, &small_dimid, &small_varid)) ERR;
160      if (nc_def_var_chunking(ncidsmall_varid, 1, NULL)) ERR;
161
162      if (nc_def_var(ncidV_MEDIUMNC_INT64NDIMS1, &medium_dimid, &medium_varid)) ERR;
163      chunks[0] = D_MEDIUM_LEN / 100;
164      if (nc_def_var_chunking(ncidmedium_varid, 0, chunks)) ERR;
165      if (nc_def_var_deflate(ncidmedium_varid, 1, 0, 0)) ERR;
166
167      if (nc_def_var(ncidV_LARGENC_INT64NDIMS1, &large_dimid, &large_varid)) ERR;
168      chunks[0] = D_LARGE_LEN / 1000;
169      if (nc_def_var_chunking(ncidlarge_varid, 0, chunks)) ERR;
170      if (nc_def_var_fletcher32(ncidlarge_varid, 1)) ERR;
171      if (nc_close(ncid)) ERR;
172
173      /* Open the file and check. */
174      if (nc_open(FILE_NAMENC_WRITE, &ncid)) ERR;
175      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
176      if (nvars != 3 || ndims != 3 || ngatts != 0 || unlimdimid != -1) ERR;
177      if (nc_inq_var(ncid, 0, var_name_in, &xtype_in, &ndims_in, &dimids_in, &natts_in)) ERR;
178      if (strcmp(var_name_inV_SMALL) || xtype_in != NC_INT64 || ndims_in != 1 ||
179   natts_in != 0) ERR;
180
181      /* Make sure chunking settings are what we expect. */
182      if (nc_inq_var_chunking(ncidsmall_varid, &contig, &chunksize_in)) ERR;
183      if (!contigERR;
184      if (nc_inq_var_chunking(ncidmedium_varid, &contig, &chunksize_in)) ERR;
185      if (contig || chunksize_in != D_MEDIUM_LEN / 100) ERR;
186      if (nc_inq_var_chunking(ncidlarge_varid, &contig, &chunksize_in)) ERR;
187      if (contig || chunksize_in != D_LARGE_LEN / 1000) ERR;
188
189      if (nc_close(ncid)) ERR;
190   }
191   SUMMARIZE_ERR;
192   printf("**** testing many chunking and contiguous variables...");
193   {
194#define NDIMS_3 3
195#define NUM_PLANS 30
196#define D_SNEAKINESS "sneakiness"
197#define D_SNEAKINESS_LEN 5
198#define D_CLEVERNESS "clevernesss"
199#define D_CLEVERNESS_LEN 3
200#define D_EFFECTIVENESS "effectiveness"
201#define D_EFFECTIVENESS_LEN 2
202
203      int nciddimids[NDIMS_3], varid[NUM_PLANS];
204      size_t chunksize[NDIMS_3] = {D_SNEAKINESS_LEND_CLEVERNESS_LEN,
205    D_EFFECTIVENESS_LEN};
206      char plan_name[NC_MAX_NAME + 1];
207      int contig;
208      size_t chunksize_in[NDIMS_3];
209      int ij;
210
211      /* Create a netcdf-4 file with three dimensions. */
212      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
213      if (nc_def_dim(ncidD_SNEAKINESSD_SNEAKINESS_LEN, &dimids[0])) ERR;
214      if (nc_def_dim(ncidD_CLEVERNESSD_CLEVERNESS_LEN, &dimids[1])) ERR;
215      if (nc_def_dim(ncidD_EFFECTIVENESSD_EFFECTIVENESS_LEN, &dimids[2])) ERR;
216
217      /* Oh that tricky Cardinal Richelieu, he had many plans! */
218      for (i = 0; i < NUM_PLANSi++)
219      {
220  sprintf(plan_name, "Richelieu_sneaky_plan_%d", i);
221  if (nc_def_var(ncidplan_namei % (NC_STRING - 1) + 1, NDIMS_3,
222 dimids, &varid[i])) ERR;
223  if (i % 2 && nc_def_var_chunking(ncidvarid[i], 0, chunksize)) ERR;
224      }
225
226      /* Check the chunking. */
227      for (i = 0; i < NUM_PLANSi++)
228      {
229  if (nc_inq_var_chunking(ncidvarid[i], &contigchunksize_in)) ERR;
230  if (i % 2)
231  {
232     for (j = 0; j < NDIMS_3j++)
233        if (chunksize_in[j] != chunksize[j]) ERR;
234  }
235  else
236     if (!contigERR;
237      }
238      if (nc_close(ncid)) ERR;
239
240      /* Open the file and check. */
241      if (nc_open(FILE_NAMENC_WRITE, &ncid)) ERR;
242      /* Check the chunking. */
243      for (i = 0; i < NUM_PLANSi++)
244      {
245  if (nc_inq_var_chunking(ncidvarid[i], &contigchunksize_in)) ERR;
246  if (i % 2)
247  {
248     for (j = 0; j < NDIMS_3j++)
249        if (chunksize_in[j] != chunksize[j]) ERR;
250  }
251  else
252     if (!contigERR;
253      }
254      if (nc_close(ncid)) ERR;
255   }
256   SUMMARIZE_ERR;
257   printf("**** testing that too large chunksizes fail...");
258   {
259#define D_SMALL_LEN2 66
260      int stat = NC_NOERR;
261      int ncid;
262      int nvarsndimsngattsunlimdimid;
263      int contig;
264      int ndims_innatts_indimids_in;
265      int small_dimidmedium_dimidlarge_dimid;
266      int small_varid;
267      char var_name_in[NC_MAX_NAME + 1];
268      size_t chunks[1], chunksize_in;
269      nc_type xtype_in;
270
271      /* Create a netcdf-4 file with three dimensions. */
272      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
273      if (nc_def_dim(ncidD_SMALLD_SMALL_LEN2, &small_dimid)) ERR;
274
275      /* Add one var. */
276      if (nc_def_var(ncidV_SMALLNC_INT64NDIMS1, &small_dimid, &small_varid)) ERR;
277
278      /* Attempt to set too large chunksizes */
279      chunks[0] = D_SMALL_LEN2 + 1;
280      stat = nc_def_var_chunking(ncidsmall_varidNC_CHUNKEDchunks);
281      if(stat != NC_EBADCHUNK) {
282 printf("Return code is '%s', expected NC_BADCHUNK",nc_strerror(stat));
283 ERR;
284      }
285      /* try agains with proper chunksize */
286      chunks[0] = D_SMALL_LEN2;
287      stat = nc_def_var_chunking(ncidsmall_varidNC_CHUNKEDchunks);
288      if(stat != NC_NOERR) {
289 printf("Return code is '%s', expected NC_NOERR",nc_strerror(stat));
290 ERR;
291      }
292      if (nc_abort(ncid)) ERR;
293   }
294   SUMMARIZE_ERR;
295   FINAL_RESULTS;
296}


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