← Back to branch summary

~ubuntu-branches/ubuntu/utopic/adios/utopic

« back to all changes in this revision

Viewing changes to src/core/common_read.c

  • Committer: Package Import Robot
  • Author(s): Alastair McKinstry
  • Date: 2013-12-09 15:21:31 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20131209152131-jtd4fpmdv3xnunnm
Tags: 1.5.0-1
* New upstream.
* Standards-Version: 3.9.5
* Include latest config.{sub,guess} 
* New watch file.
* Create libadios-bin for binaries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/common_read.c
 
1
/* 
 
2
 * ADIOS is freely available under the terms of the BSD license described
 
3
 * in the COPYING file in the top level directory of this source distribution.
 
4
 *
 
5
 * Copyright (c) 2008 - 2009.  UT-BATTELLE, LLC. All rights reserved.
 
6
 */
 
7
 
 
8
#include <stdio.h>
 
9
#include <stdlib.h>
 
10
#include <string.h>
 
11
#include <errno.h>
 
12
#include "public/adios_error.h"
 
13
#include "core/adios_logger.h"
 
14
#include "core/common_read.h"
 
15
#include "core/adios_read_hooks.h"
 
16
#include "core/futils.h"
 
17
#include "core/bp_utils.h" // struct namelists_struct
 
18
#define BYTE_ALIGN 8
 
19
 
 
20
#ifdef DMALLOC
 
21
#include "dmalloc.h"
 
22
#endif
 
23
 
 
24
 
 
25
/* Note: MATLAB reloads the mex64 files each time, so all static variables get the original value.
 
26
   Therefore static variables cannot be used to pass info between two Matlab/ADIOS calls */
 
27
static struct adios_read_hooks_struct * adios_read_hooks = 0;
 
28
 
 
29
struct common_read_internals_struct {
 
30
    enum ADIOS_READ_METHOD method;
 
31
    struct adios_read_hooks_struct * read_hooks; /* Save adios_read_hooks for each fopen for Matlab */
 
32
    
 
33
    /* Group view information *//* Actual method provides the group names */
 
34
    int     ngroups;
 
35
    char ** group_namelist;
 
36
    int   * nvars_per_group;     /* # of variables per each group */
 
37
    int   * nattrs_per_group;    /* # of attributes per each group */
 
38
    int     group_in_view;       /* 0..ngroups-1: selected group in view,
 
39
                                  -1: all groups */
 
40
    int     group_varid_offset;  /* offset of var IDs from specific group to full list
 
41
                                    if a selected group is in view */
 
42
    int     group_attrid_offset;
 
43
    int     full_nvars;          /* fp->nvars to save here for a group view */
 
44
    char ** full_varnamelist;    /* fp->var_namelist to save here if one group is viewed */
 
45
    int     full_nattrs;         /* fp->nvars to save here for a group view */
 
46
    char ** full_attrnamelist;   /* fp->attr_namelist to save here if one group is viewed */
 
47
};
 
48
 
 
49
 
 
50
int common_read_init_method (enum ADIOS_READ_METHOD method,
 
51
                             MPI_Comm comm,
 
52
                             const char * parameters)
 
53
{
 
54
    PairStruct *params, *p, *prev_p;
 
55
    int verbose_level, removeit, save;
 
56
    int retval; 
 
57
    char *end;
 
58
 
 
59
    adios_errno = err_no_error;
 
60
    if ((int)method < 0 || (int)method >= ADIOS_READ_METHOD_COUNT) {
 
61
        adios_error (err_invalid_read_method, 
 
62
            "Invalid read method (=%d) passed to adios_read_init_method().\n", (int)method);
 
63
        return err_invalid_read_method;
 
64
    } 
 
65
    // init the adios_read_hooks_struct if not yet initialized  
 
66
    adios_read_hooks_init (&adios_read_hooks); 
 
67
 
 
68
    // process common parameters here
 
69
    params = text_to_name_value_pairs (parameters);
 
70
    p = params;
 
71
    prev_p = NULL;
 
72
    while (p) {
 
73
        removeit = 0;
 
74
        if (!strcasecmp (p->name, "verbose")) 
 
75
        {
 
76
            if (p->value) {
 
77
                errno = 0;
 
78
                verbose_level = strtol(p->value, &end, 10);
 
79
                if (errno || (end != 0 && *end != '\0')) {
 
80
                    log_error ("Invalid 'verbose' parameter passed to read init function: '%s'\n", p->value);
 
81
                    verbose_level = 1; // print errors only
 
82
                }
 
83
            } else {
 
84
                verbose_level = 3;  // info level
 
85
            }
 
86
            adios_verbose_level = verbose_level;
 
87
            removeit = 1;
 
88
        }
 
89
        else if (!strcasecmp (p->name, "quiet")) 
 
90
        {
 
91
            adios_verbose_level = 0; //don't print errors
 
92
            removeit = 1;
 
93
        }
 
94
        else if (!strcasecmp (p->name, "logfile")) 
 
95
        {
 
96
            if (p->value) {
 
97
                adios_logger_open (p->value, -1);
 
98
            }
 
99
            removeit = 1;
 
100
        }
 
101
        else if (!strcasecmp (p->name, "abort_on_error")) 
 
102
        {
 
103
            adios_abort_on_error = 1;
 
104
            save = adios_verbose_level;
 
105
            adios_verbose_level = 2;
 
106
            log_warn ("ADIOS is set to abort on error\n");
 
107
            adios_verbose_level = save;
 
108
            removeit = 1;
 
109
        }
 
110
        if (removeit) {
 
111
            if (p == params) {
 
112
                // remove head
 
113
                p = p->next;
 
114
                params->next = NULL;
 
115
                free_name_value_pairs (params);
 
116
                params = p;
 
117
            } else {
 
118
                // remove from middle of the list
 
119
                prev_p->next = p->next;
 
120
                p->next = NULL;
 
121
                free_name_value_pairs (p);
 
122
                p = prev_p->next;
 
123
            }
 
124
        } else {
 
125
            prev_p = p;
 
126
            p = p->next;
 
127
        }
 
128
    }
 
129
 
 
130
    // call method specific init 
 
131
    retval = adios_read_hooks[method].adios_init_method_fn (comm, params);
 
132
    free_name_value_pairs (params);
 
133
    return retval;
 
134
}
 
135
 
 
136
 
 
137
int common_read_finalize_method(enum ADIOS_READ_METHOD method)
 
138
{
 
139
    adios_errno = err_no_error;
 
140
    if ((int)method < 0 || (int)method >= ADIOS_READ_METHOD_COUNT) {
 
141
        adios_error (err_invalid_read_method, 
 
142
            "Invalid read method (=%d) passed to adios_read_finalize_method().\n", (int)method);
 
143
        return err_invalid_read_method;
 
144
    } 
 
145
 
 
146
    return adios_read_hooks[method].adios_finalize_method_fn ();
 
147
}
 
148
 
 
149
 
 
150
ADIOS_FILE * common_read_open (const char * fname, 
 
151
                               enum ADIOS_READ_METHOD method, 
 
152
                               MPI_Comm comm, 
 
153
                               enum ADIOS_LOCKMODE lock_mode, 
 
154
                               float timeout_sec)
 
155
{
 
156
    ADIOS_FILE * fp;
 
157
    struct common_read_internals_struct * internals; 
 
158
 
 
159
    if ((int)method < 0 || (int)method >= ADIOS_READ_METHOD_COUNT) {
 
160
        adios_error (err_invalid_read_method, 
 
161
            "Invalid read method (=%d) passed to adios_read_open().\n", (int)method);
 
162
        return NULL;
 
163
    } 
 
164
 
 
165
    adios_errno = err_no_error;
 
166
    internals = (struct common_read_internals_struct *) 
 
167
                    calloc(1,sizeof(struct common_read_internals_struct));
 
168
    // init the adios_read_hooks_struct if not yet initialized 
 
169
    adios_read_hooks_init (&adios_read_hooks); 
 
170
 
 
171
    internals->method = method;
 
172
    internals->read_hooks = adios_read_hooks;
 
173
 
 
174
    fp = adios_read_hooks[internals->method].adios_open_fn (fname, comm, lock_mode, timeout_sec);
 
175
 
 
176
    // save the method and group information in fp->internal_data
 
177
    if (fp){
 
178
        adios_read_hooks[internals->method].adios_get_groupinfo_fn (fp, &internals->ngroups, 
 
179
                &internals->group_namelist, &internals->nvars_per_group, &internals->nattrs_per_group);
 
180
        internals->group_in_view = -1;
 
181
        internals->group_varid_offset = 0;
 
182
        internals->group_attrid_offset = 0;
 
183
        fp->internal_data = (void *)internals;
 
184
    } else {
 
185
        free (internals);
 
186
    }
 
187
    return fp;
 
188
}
 
189
 
 
190
 
 
191
ADIOS_FILE * common_read_open_file (const char * fname, 
 
192
                                    enum ADIOS_READ_METHOD method,
 
193
                                    MPI_Comm comm)
 
194
{
 
195
    ADIOS_FILE * fp;
 
196
    struct common_read_internals_struct * internals; 
 
197
 
 
198
    if ((int)method < 0 || (int)method >= ADIOS_READ_METHOD_COUNT) {
 
199
        adios_error (err_invalid_read_method, 
 
200
            "Invalid read method (=%d) passed to adios_read_open_file().\n", (int)method);
 
201
        return NULL;
 
202
    } 
 
203
 
 
204
    adios_errno = err_no_error;
 
205
    internals = (struct common_read_internals_struct *) 
 
206
                    calloc(1,sizeof(struct common_read_internals_struct));
 
207
    // init the adios_read_hooks_struct if not yet initialized 
 
208
    adios_read_hooks_init (&adios_read_hooks); 
 
209
 
 
210
    internals->method = method;
 
211
    internals->read_hooks = adios_read_hooks;
 
212
 
 
213
    fp = adios_read_hooks[internals->method].adios_open_file_fn (fname, comm);
 
214
 
 
215
    // save the method and group information in fp->internal_data
 
216
    if (fp){
 
217
        adios_read_hooks[internals->method].adios_get_groupinfo_fn (fp, &internals->ngroups, 
 
218
                &internals->group_namelist, &internals->nvars_per_group, &internals->nattrs_per_group);
 
219
        internals->group_in_view = -1;
 
220
        internals->group_varid_offset = 0;
 
221
        internals->group_attrid_offset = 0;
 
222
        fp->internal_data = (void *)internals;
 
223
    } else {
 
224
        free (internals);
 
225
    }
 
226
    return fp;
 
227
}
 
228
 
 
229
int common_read_close (ADIOS_FILE *fp) 
 
230
{
 
231
    struct common_read_internals_struct * internals;
 
232
    int retval;
 
233
 
 
234
    adios_errno = err_no_error;
 
235
    if (fp) {
 
236
        internals = (struct common_read_internals_struct *) fp->internal_data;
 
237
        if (internals->group_in_view != -1) {
 
238
            // reset from group view before calling the real close
 
239
            common_read_group_view (fp, -1);
 
240
        }
 
241
        retval = internals->read_hooks[internals->method].adios_close_fn (fp);
 
242
        free_namelist (internals->group_namelist, internals->ngroups);
 
243
        free (internals->nvars_per_group);
 
244
        free (internals->nattrs_per_group);
 
245
        free (internals);
 
246
    } else {
 
247
        adios_error ( err_invalid_file_pointer, "Invalid file pointer at adios_read_close()\n");
 
248
        retval = err_invalid_file_pointer;
 
249
    }
 
250
    return retval;
 
251
}
 
252
 
 
253
void common_read_reset_dimension_order (const ADIOS_FILE *fp, int is_fortran)
 
254
{
 
255
    struct common_read_internals_struct * internals;
 
256
 
 
257
    adios_errno = err_no_error;
 
258
    if (fp) {
 
259
        internals = (struct common_read_internals_struct *) fp->internal_data;
 
260
        internals->read_hooks[internals->method].adios_reset_dimension_order_fn (fp, is_fortran);
 
261
    } else {
 
262
        adios_error ( err_invalid_file_pointer, "Invalid file pointer at adios_reset_dimension_order()\n");
 
263
    }
 
264
}
 
265
 
 
266
 
 
267
int common_read_advance_step (ADIOS_FILE *fp, int last, float timeout_sec)
 
268
{
 
269
    struct common_read_internals_struct * internals;
 
270
    int retval;
 
271
    
 
272
    adios_errno = err_no_error;
 
273
    if (fp) {
 
274
        internals = (struct common_read_internals_struct *) fp->internal_data;
 
275
        retval = internals->read_hooks[internals->method].adios_advance_step_fn (fp, last, timeout_sec);
 
276
        if (!retval) {
 
277
            /* Update group information too */
 
278
            adios_read_hooks[internals->method].adios_get_groupinfo_fn (fp, &internals->ngroups, 
 
279
                    &internals->group_namelist, &internals->nvars_per_group, &internals->nattrs_per_group);
 
280
            if (internals->group_in_view > -1) {
 
281
                /* if we have a group view, we need to update the presented list again */
 
282
                /* advance_step updated fp->nvars, nattrs, var_namelist, attr_namelist */
 
283
                int groupid = internals->group_in_view;
 
284
                internals->group_in_view = -1; // we have the full view at this moment 
 
285
                common_read_group_view (fp, groupid);
 
286
            }
 
287
        }
 
288
    } else {
 
289
        adios_error ( err_invalid_file_pointer, "Invalid file pointer at adios_advance_step()\n");
 
290
        retval = err_invalid_file_pointer;
 
291
    }
 
292
    return retval;
 
293
}
 
294
 
 
295
 
 
296
void common_read_release_step (ADIOS_FILE *fp) 
 
297
{
 
298
    struct common_read_internals_struct * internals;
 
299
 
 
300
    adios_errno = err_no_error;
 
301
    if (fp) {
 
302
        internals = (struct common_read_internals_struct *) fp->internal_data;
 
303
        internals->read_hooks[internals->method].adios_release_step_fn (fp);
 
304
    } else {
 
305
        adios_error ( err_invalid_file_pointer, "Invalid file pointer at adios_reset_dimension_order()\n");
 
306
    }
 
307
}
 
308
 
 
309
 
 
310
static int common_read_find_name (int n, char ** namelist, const char *name, int role)
 
311
{
 
312
    /** Find a string name in a list of names and return the index. 
 
313
        Search should work with starting / characters and without.
 
314
        Create adios error and return -1 if name is null or
 
315
          if name is not found in the list.
 
316
        role = 0 for variable search, 1 for attribute search
 
317
     */
 
318
    int id, nstartpos=0, sstartpos;
 
319
    char ** s = namelist;
 
320
    char *rolename[2] = { "variable", "attribute" };
 
321
    enum ADIOS_ERRCODES roleerror[2] = { err_invalid_varname, err_invalid_attrname };
 
322
 
 
323
    if (!name) {
 
324
        adios_error (roleerror[role!=0], "Null pointer passed as %s name!\n", rolename[role!=0]);
 
325
        return -1;
 
326
    }
 
327
 
 
328
    // find names with or without beginning /
 
329
    if (*name == '/') nstartpos = 1;
 
330
 
 
331
    for (id=0; id < n; id++) {
 
332
        if (*s[0] == '/') sstartpos = 1;
 
333
        else sstartpos = 0;
 
334
        //DBG_PRINTF("     check %s, startpos=%d\n", *s, sstartpos);
 
335
        if (!strcmp (*s+sstartpos, name+nstartpos))
 
336
            break; // found this name
 
337
        s++;
 
338
    }
 
339
 
 
340
    if (id == n) {
 
341
        adios_error (roleerror[role!=0], "%s '%s' is not found! One "
 
342
                "possible error is to set the view to a specific group and "
 
343
                "then try to read a %s of another group. In this case, "
 
344
                "reset the group view with adios_group_view(fp,-1).\n", 
 
345
                rolename[role!=0], name, rolename[role!=0]);
 
346
        return -1;
 
347
    }
 
348
    return id;
 
349
}
 
350
 
 
351
 
 
352
ADIOS_VARINFO * common_read_inq_var (const ADIOS_FILE *fp, const char * varname) 
 
353
{
 
354
    struct common_read_internals_struct * internals;
 
355
    ADIOS_VARINFO * retval;
 
356
    
 
357
    adios_errno = err_no_error;
 
358
    if (fp) {
 
359
        internals = (struct common_read_internals_struct *) fp->internal_data;
 
360
        int varid = common_read_find_name (fp->nvars, fp->var_namelist, varname, 0);
 
361
        if (varid >= 0) {
 
362
            retval = common_read_inq_var_byid (fp, varid);
 
363
        } else {
 
364
            retval = NULL;
 
365
        }
 
366
    } else {
 
367
        adios_error (err_invalid_file_pointer, "Null pointer passed as file to adios_inq_var()\n");
 
368
        retval = NULL;
 
369
    }
 
370
    return retval;
 
371
}
 
372
 
 
373
 
 
374
ADIOS_VARINFO * common_read_inq_var_byid (const ADIOS_FILE *fp, int varid)
 
375
{
 
376
    struct common_read_internals_struct * internals;
 
377
    ADIOS_VARINFO * retval;
 
378
    
 
379
    adios_errno = err_no_error;
 
380
    if (fp) {
 
381
        if (varid >= 0 && varid < fp->nvars) {
 
382
            internals = (struct common_read_internals_struct *) fp->internal_data;
 
383
            /* Translate varid to varid in global varlist if a selected group is in view */ 
 
384
            retval = internals->read_hooks[internals->method].adios_inq_var_byid_fn 
 
385
                                            (fp, varid+internals->group_varid_offset);
 
386
            if (retval) {
 
387
                /* Translate real varid to the group varid presented to the user */
 
388
                retval->varid = varid;
 
389
            }
 
390
        } else {
 
391
            adios_error (err_invalid_varid, 
 
392
                         "Variable ID %d is not valid adios_inq_var_byid(). "
 
393
                         "Available 0..%d\n", varid, fp->nvars-1);
 
394
            retval = NULL;
 
395
        }
 
396
    } else {
 
397
        adios_error (err_invalid_file_pointer, "Null pointer passed as file to adios_inq_var_byid()\n");
 
398
        retval = NULL;
 
399
    }
 
400
    return retval;
 
401
}
 
402
 
 
403
 
 
404
int common_read_inq_var_stat (const ADIOS_FILE *fp, ADIOS_VARINFO * varinfo,
 
405
                             int per_step_stat, int per_block_stat)
 
406
{
 
407
    struct common_read_internals_struct * internals;
 
408
    int retval;
 
409
    int group_varid;
 
410
    
 
411
    adios_errno = err_no_error;
 
412
    if (fp) {
 
413
        internals = (struct common_read_internals_struct *) fp->internal_data;
 
414
        if (varinfo) {
 
415
            /* Translate group varid presented to the user to the real varid */
 
416
            group_varid = varinfo->varid;
 
417
            varinfo->varid = varinfo->varid + internals->group_varid_offset;
 
418
        }
 
419
        retval = internals->read_hooks[internals->method].adios_inq_var_stat_fn (fp, varinfo, per_step_stat, per_block_stat);
 
420
        /* Translate back real varid to the group varid presented to the user */
 
421
        varinfo->varid = group_varid;
 
422
    } else {
 
423
        adios_error (err_invalid_file_pointer, "Null pointer passed as file to adios_inq_var_stat()\n");
 
424
        retval = err_invalid_file_pointer;
 
425
    }
 
426
    return retval;
 
427
}
 
428
 
 
429
int common_read_inq_var_blockinfo (const ADIOS_FILE *fp, ADIOS_VARINFO * varinfo)
 
430
{
 
431
    struct common_read_internals_struct * internals;
 
432
    int retval;
 
433
    int group_varid;
 
434
    
 
435
    adios_errno = err_no_error;
 
436
    if (fp) {
 
437
        internals = (struct common_read_internals_struct *) fp->internal_data;
 
438
        if (varinfo) {
 
439
            /* Translate group varid presented to the user to the real varid */
 
440
            group_varid = varinfo->varid;
 
441
            varinfo->varid = varinfo->varid + internals->group_varid_offset;
 
442
        }
 
443
        retval = internals->read_hooks[internals->method].adios_inq_var_blockinfo_fn (fp, varinfo);
 
444
        /* Translate back real varid to the group varid presented to the user */
 
445
        varinfo->varid = group_varid;
 
446
    } else {
 
447
        adios_error (err_invalid_file_pointer, "Null pointer passed as file to adios_inq_var_blockinfo()\n");
 
448
        retval = err_invalid_file_pointer;
 
449
    }
 
450
    return retval;
 
451
}
 
452
 
 
453
#define MYFREE(p) {free(p); p=NULL;}
 
454
void common_read_free_varinfo (ADIOS_VARINFO *vp)
 
455
{
 
456
    int i;
 
457
    if (vp) {
 
458
        if (vp->blockinfo) {
 
459
            ADIOS_VARBLOCK *bp = vp->blockinfo;
 
460
            for (i=0; i<vp->sum_nblocks; i++) {
 
461
                if (bp->start) MYFREE (bp->start);
 
462
                if (bp->count) MYFREE (bp->count);
 
463
                bp++;
 
464
            }
 
465
            MYFREE(vp->blockinfo);
 
466
        }
 
467
 
 
468
        if (vp->statistics) {
 
469
            ADIOS_VARSTAT *sp = vp->statistics;
 
470
            if (sp->min && sp->min != vp->value)   MYFREE(sp->min);
 
471
            if (sp->max && sp->max != vp->value)   MYFREE(sp->max);
 
472
            if (sp->avg && sp->avg != vp->value)   MYFREE(sp->avg);
 
473
            if (sp->std_dev)                       MYFREE(sp->std_dev);
 
474
 
 
475
            if (sp->steps) {
 
476
                if (sp->steps->mins)        MYFREE(sp->steps->mins);
 
477
                if (sp->steps->maxs)        MYFREE(sp->steps->maxs);
 
478
                if (sp->steps->avgs)        MYFREE(sp->steps->avgs);
 
479
                if (sp->steps->std_devs)    MYFREE(sp->steps->std_devs);
 
480
                MYFREE(sp->steps);
 
481
            }
 
482
 
 
483
            if (sp->blocks) {
 
484
                if (sp->blocks->mins)        MYFREE(sp->blocks->mins);
 
485
                if (sp->blocks->maxs)        MYFREE(sp->blocks->maxs);
 
486
                if (sp->blocks->avgs)        MYFREE(sp->blocks->avgs);
 
487
                if (sp->blocks->std_devs)    MYFREE(sp->blocks->std_devs);
 
488
                MYFREE(sp->blocks);
 
489
            }
 
490
 
 
491
            if (sp->histogram) {
 
492
                if (sp->histogram->breaks)        MYFREE(sp->histogram->breaks);
 
493
                if (sp->histogram->frequencies)   MYFREE(sp->histogram->frequencies);
 
494
                if (sp->histogram->gfrequencies)  MYFREE(sp->histogram->gfrequencies);
 
495
                MYFREE(sp->histogram);
 
496
            }
 
497
 
 
498
            MYFREE(vp->statistics);
 
499
        }
 
500
 
 
501
        if (vp->dims)    MYFREE(vp->dims);
 
502
        if (vp->value)   MYFREE(vp->value);
 
503
        if (vp->nblocks) MYFREE(vp->nblocks);
 
504
 
 
505
        free(vp);
 
506
    }
 
507
}
 
508
 
 
509
 
 
510
int common_read_schedule_read (const ADIOS_FILE      * fp,
 
511
                               const ADIOS_SELECTION * sel,
 
512
                               const char            * varname,
 
513
                               int                     from_steps,
 
514
                               int                     nsteps,
 
515
                               void                  * data)
 
516
 
 
517
{
 
518
    struct common_read_internals_struct * internals;
 
519
    int retval;
 
520
    
 
521
    adios_errno = err_no_error;
 
522
    if (fp) {
 
523
        internals = (struct common_read_internals_struct *) fp->internal_data;
 
524
        int varid = common_read_find_name (fp->nvars, fp->var_namelist, varname, 0);
 
525
        if (varid >= 0) {
 
526
            retval = common_read_schedule_read_byid (fp, sel, varid, from_steps, nsteps, data);
 
527
        } else {
 
528
            retval = adios_errno; // adios_errno was set in common_read_find_name
 
529
        }
 
530
    } else {
 
531
        adios_error (err_invalid_file_pointer, "Null pointer passed as file to adios_schedule_read()\n");
 
532
        retval = err_invalid_file_pointer;
 
533
    }
 
534
    return retval;
 
535
}
 
536
 
 
537
 
 
538
int common_read_schedule_read_byid (const ADIOS_FILE      * fp,
 
539
        const ADIOS_SELECTION * sel,
 
540
        int                     varid,
 
541
        int                     from_steps,
 
542
        int                     nsteps,
 
543
        void                  * data)
 
544
 
 
545
{
 
546
    struct common_read_internals_struct * internals;
 
547
    int retval;
 
548
    
 
549
    adios_errno = err_no_error;
 
550
    if (fp) {
 
551
        if (varid >=0 && varid < fp->nvars) {
 
552
            internals = (struct common_read_internals_struct *) fp->internal_data;
 
553
            retval = internals->read_hooks[internals->method].adios_schedule_read_byid_fn (fp, sel, varid+internals->group_varid_offset, from_steps, nsteps, data);
 
554
        } else {
 
555
            adios_error (err_invalid_varid, 
 
556
                         "Variable ID %d is not valid in adios_schedule_read_byid(). "
 
557
                         "Available 0..%d\n", varid, fp->nvars-1);
 
558
            retval = err_invalid_varid;
 
559
        }
 
560
    } else {
 
561
        adios_error (err_invalid_file_pointer, "Null pointer passed as file to adios_schedule_read_byid()\n");
 
562
        retval = err_invalid_file_pointer;
 
563
    }
 
564
    return retval;
 
565
}
 
566
 
 
567
 
 
568
int common_read_perform_reads (const ADIOS_FILE *fp, int blocking)
 
569
{
 
570
    struct common_read_internals_struct * internals;
 
571
    int retval;
 
572
    
 
573
    adios_errno = err_no_error;
 
574
    if (fp) {
 
575
        internals = (struct common_read_internals_struct *) fp->internal_data;
 
576
        retval = internals->read_hooks[internals->method].adios_perform_reads_fn (fp, blocking);
 
577
    } else {
 
578
        adios_error (err_invalid_file_pointer, "Null pointer passed as file to adios_perform_reads()\n");
 
579
        retval = err_invalid_file_pointer;
 
580
    }
 
581
    return retval;
 
582
}
 
583
 
 
584
 
 
585
int common_read_check_reads (const ADIOS_FILE * fp, ADIOS_VARCHUNK ** chunk)
 
586
{
 
587
    struct common_read_internals_struct * internals;
 
588
    int retval;
 
589
    
 
590
    adios_errno = err_no_error;
 
591
    if (fp) {
 
592
        internals = (struct common_read_internals_struct *) fp->internal_data;
 
593
        retval = internals->read_hooks[internals->method].adios_check_reads_fn (fp, chunk);
 
594
    } else {
 
595
        adios_error (err_invalid_file_pointer, "Null pointer passed as file to adios_check_reads()\n");
 
596
        retval = err_invalid_file_pointer;
 
597
    }
 
598
    return retval;
 
599
}
 
600
 
 
601
 
 
602
void common_read_free_chunk (ADIOS_VARCHUNK *chunk)
 
603
{
 
604
    /** Free the memory of a chunk allocated inside adios_check_reads().
 
605
     * It only frees the ADIOS_VARCHUNK struct and the ADIOS_SELECTION struct
 
606
     * pointed by the chunk. The data pointer should never be freed since
 
607
     * that memory belongs to the reading method.
 
608
     */
 
609
     if (chunk) {
 
610
        if (chunk->sel) {
 
611
            free(chunk->sel);
 
612
            chunk->sel = NULL;
 
613
        }
 
614
        free(chunk);
 
615
     }
 
616
}
 
617
 
 
618
 
 
619
int common_read_get_attr (const ADIOS_FILE * fp, 
 
620
                          const char * attrname, 
 
621
                          enum ADIOS_DATATYPES * type,
 
622
                          int * size, 
 
623
                          void ** data)
 
624
{
 
625
    struct common_read_internals_struct * internals;
 
626
    int retval;
 
627
    
 
628
    adios_errno = err_no_error;
 
629
    if (fp) {
 
630
        internals = (struct common_read_internals_struct *) fp->internal_data;
 
631
        int attrid = common_read_find_name (fp->nattrs, fp->attr_namelist, attrname, 1);
 
632
        if (attrid > -1) {
 
633
            retval = common_read_get_attr_byid (fp, attrid, type, size, data);
 
634
        } else {
 
635
            retval = adios_errno; // adios_errno was set in common_read_find_name
 
636
        }
 
637
    } else {
 
638
        adios_error (err_invalid_file_pointer, "Null pointer passed as file to adios_read_get_attr()\n");
 
639
        retval = err_invalid_file_pointer;
 
640
    }
 
641
    return retval;
 
642
}
 
643
 
 
644
 
 
645
int common_read_get_attr_byid (const ADIOS_FILE * fp, 
 
646
                               int attrid, 
 
647
                               enum ADIOS_DATATYPES * type, 
 
648
                               int * size, 
 
649
                               void ** data)
 
650
{
 
651
    struct common_read_internals_struct * internals;
 
652
    int retval;
 
653
    
 
654
    adios_errno = err_no_error;
 
655
    if (fp) {
 
656
        if (attrid >= 0 && attrid < fp->nattrs) {
 
657
            internals = (struct common_read_internals_struct *) fp->internal_data;
 
658
            retval = internals->read_hooks[internals->method].adios_get_attr_byid_fn (fp, attrid+internals->group_attrid_offset, type, size, data);
 
659
        } else {
 
660
            adios_error (err_invalid_attrid, 
 
661
                         "Attribute ID %d is not valid in adios_get_attr_byid(). "
 
662
                         "Available 0..%d\n", attrid, fp->nattrs-1);
 
663
            retval = err_invalid_attrid;
 
664
        }
 
665
    } else {
 
666
        adios_error (err_invalid_file_pointer, "Null pointer passed as file to adios_read_get_attr_byid()\n");
 
667
        retval = err_invalid_file_pointer;
 
668
    }
 
669
    return retval;
 
670
}
 
671
 
 
672
 
 
673
const char * common_read_type_to_string (enum ADIOS_DATATYPES type)
 
674
{
 
675
    switch (type)
 
676
    {
 
677
        case adios_unsigned_byte:    return "unsigned byte";
 
678
        case adios_unsigned_short:   return "unsigned short";
 
679
        case adios_unsigned_integer: return "unsigned integer";
 
680
        case adios_unsigned_long:    return "unsigned long long";
 
681
 
 
682
        case adios_byte:             return "byte";
 
683
        case adios_short:            return "short";
 
684
        case adios_integer:          return "integer";
 
685
        case adios_long:             return "long long";
 
686
 
 
687
        case adios_real:             return "real";
 
688
        case adios_double:           return "double";
 
689
        case adios_long_double:      return "long double";
 
690
 
 
691
        case adios_string:           return "string";
 
692
        case adios_complex:          return "complex";
 
693
        case adios_double_complex:   return "double complex";
 
694
 
 
695
        default:
 
696
        {
 
697
            static char buf [50];
 
698
            sprintf (buf, "(unknown: %d)", type);
 
699
            return buf;
 
700
        }
 
701
    }
 
702
}
 
703
 
 
704
 
 
705
int common_read_type_size(enum ADIOS_DATATYPES type, void *data)
 
706
{
 
707
    return bp_get_type_size(type, data);
 
708
}
 
709
 
 
710
 
 
711
int common_read_get_grouplist (const ADIOS_FILE  *fp, char ***group_namelist)
 
712
{
 
713
    struct common_read_internals_struct * internals;
 
714
    int retval;
 
715
    
 
716
    adios_errno = err_no_error;
 
717
    if (fp) {
 
718
        internals = (struct common_read_internals_struct *) fp->internal_data;
 
719
        retval = internals->ngroups;
 
720
        *group_namelist = internals->group_namelist;
 
721
    } else {
 
722
        adios_error (err_invalid_file_pointer, "Null pointer passed as file to adios_get_grouplist()\n");
 
723
        retval = err_invalid_file_pointer;
 
724
    }
 
725
    return retval;
 
726
}
 
727
 
 
728
/** Select a subset of variables and attributes to present in ADIOS_FILE struct.
 
729
    ADIOS_FILE-> nvars, nattrs, var_namelist, attr_namelist will contain
 
730
    only a subset of all variables and attributes.
 
731
    internals-> full_* stores the complete lists for reset or change of group
 
732
 */
 
733
int common_read_group_view (ADIOS_FILE  *fp, int groupid)
 
734
{
 
735
    struct common_read_internals_struct * internals;
 
736
    int retval, i;
 
737
    
 
738
    adios_errno = err_no_error;
 
739
    if (fp) {
 
740
        internals = (struct common_read_internals_struct *) fp->internal_data;
 
741
        if (groupid >= 0 && groupid < internals->ngroups) {
 
742
            /* 1. save complete list if first done */
 
743
            if (internals->group_in_view == -1) {
 
744
                internals->full_nvars = fp->nvars;
 
745
                internals->full_varnamelist = fp->var_namelist;
 
746
                internals->full_nattrs = fp->nattrs;
 
747
                internals->full_attrnamelist = fp->attr_namelist;
 
748
            }
 
749
            /* Set ID offsets for easier indexing of vars/attrs in other functions */
 
750
            internals->group_varid_offset = 0;
 
751
            internals->group_attrid_offset = 0;
 
752
            for (i=0; i<groupid; i++) {
 
753
                internals->group_varid_offset += internals->nvars_per_group[i];
 
754
                internals->group_attrid_offset += internals->nattrs_per_group[i];
 
755
            }
 
756
            /* Set view to this group */
 
757
            fp->nvars = internals->nvars_per_group[groupid];
 
758
            fp->var_namelist = &(internals->full_varnamelist [internals->group_varid_offset]);
 
759
            fp->nattrs = internals->nattrs_per_group[groupid];
 
760
            fp->attr_namelist = &(internals->full_attrnamelist [internals->group_attrid_offset]);
 
761
            internals->group_in_view = groupid;
 
762
            retval = 0;
 
763
 
 
764
        } else if (groupid == -1) {
 
765
            /* Reset to full view */
 
766
            fp->nvars  = internals->full_nvars;
 
767
            fp->var_namelist  = internals->full_varnamelist;
 
768
            fp->nattrs = internals->full_nattrs;
 
769
            fp->attr_namelist  = internals->full_attrnamelist;
 
770
            internals->group_varid_offset = 0;
 
771
            internals->group_attrid_offset = 0;
 
772
            internals->group_in_view = -1;
 
773
            retval = 0;
 
774
        } else {
 
775
            adios_error (err_invalid_group, "Invalid group ID in adios_group_view()\n");
 
776
            retval = err_invalid_group;
 
777
        }
 
778
    } else {
 
779
        adios_error (err_invalid_file_pointer, "Null pointer passed as file to adios_group_view()\n");
 
780
        retval = err_invalid_file_pointer;
 
781
    }
 
782
    return retval;
 
783
}
 
784
 
 
785
/* internal function to support version 1 time-dimension reads
 
786
   called from adios_read_v1.c and adiosf_read_v1.c 
 
787
*/
 
788
int common_read_is_var_timed (const ADIOS_FILE *fp, int varid)
 
789
{
 
790
    struct common_read_internals_struct * internals;
 
791
    int retval;
 
792
    
 
793
    adios_errno = err_no_error;
 
794
    if (fp) {
 
795
        internals = (struct common_read_internals_struct *) fp->internal_data;
 
796
        retval = internals->read_hooks[internals->method].adios_is_var_timed_fn (fp, varid+internals->group_varid_offset);
 
797
    } else {
 
798
        adios_error (err_invalid_file_pointer, "Null pointer passed as file to common_read_is_var_timed()\n");
 
799
        retval = err_invalid_file_pointer;
 
800
    }
 
801
    return retval;
 
802
}
 
803
 
 
804
void common_read_print_fileinfo (const ADIOS_FILE *fp) 
 
805
{
 
806
    int i;
 
807
    int ngroups;
 
808
    char **group_namelist;
 
809
    ngroups = common_read_get_grouplist (fp, &group_namelist);
 
810
 
 
811
    printf ("---------------------------\n");
 
812
    printf ("     file information\n");
 
813
    printf ("---------------------------\n");
 
814
    printf ("  # of groups:     %d\n"
 
815
            "  # of variables:  %d\n"
 
816
            "  # of attributes: %d\n"
 
817
            "  current step:    %d\n"
 
818
            "  last step:       %d\n",
 
819
            ngroups,
 
820
            fp->nvars,
 
821
            fp->nattrs,
 
822
            fp->current_step,
 
823
            fp->last_step);
 
824
    printf ("---------------------------\n");
 
825
    printf ("     var information\n");
 
826
    printf ("---------------------------\n");
 
827
    printf ("    var id\tname\n");
 
828
    if (fp->var_namelist) {
 
829
        for (i=0; i<fp->nvars; i++)
 
830
            printf("\t%d)\t%s\n", i, fp->var_namelist[i]);
 
831
    }
 
832
    printf ("---------------------------\n");
 
833
    printf ("     attribute information\n");
 
834
    printf ("---------------------------\n");
 
835
    printf ("    attr id\tname\n");
 
836
    if (fp->attr_namelist) {
 
837
        for (i=0; i<fp->nattrs; i++)
 
838
            printf("\t%d)\t%s\n", i, fp->attr_namelist[i]);
 
839
    }
 
840
    printf ("---------------------------\n");
 
841
    printf ("     group information\n");
 
842
    printf ("---------------------------\n");
 
843
    if (group_namelist) {
 
844
        for (i=0; i<ngroups; i++)
 
845
            printf("\t%d)\t%s\n", i, group_namelist[i]);
 
846
    }
 
847
 
 
848
 
 
849
    return;
 
850
}
 
851
 
 
852
 
 
853
/**    SELECTIONS   **/ 
 
854
ADIOS_SELECTION * common_read_selection_boundingbox (int ndim, const uint64_t *start, const uint64_t *count)
 
855
{   
 
856
    adios_errno = err_no_error;
 
857
    ADIOS_SELECTION * sel = (ADIOS_SELECTION *) malloc (sizeof(ADIOS_SELECTION));
 
858
    if (sel) {
 
859
        sel->type = ADIOS_SELECTION_BOUNDINGBOX;
 
860
        sel->u.bb.ndim = ndim;
 
861
        sel->u.bb.start = (uint64_t *)start;
 
862
        sel->u.bb.count = (uint64_t *)count;
 
863
    } else {
 
864
        adios_error(err_no_memory, "Cannot allocate memory for bounding box selection\n");
 
865
    }
 
866
    return sel;
 
867
}
 
868
 
 
869
 
 
870
ADIOS_SELECTION * common_read_selection_points (int ndim, uint64_t npoints, const uint64_t *points)
 
871
{   
 
872
    adios_errno = err_no_error;
 
873
    ADIOS_SELECTION * sel = (ADIOS_SELECTION *) malloc (sizeof(ADIOS_SELECTION));
 
874
    if (sel) {
 
875
        sel->type = ADIOS_SELECTION_POINTS;
 
876
        sel->u.points.ndim = ndim;
 
877
        sel->u.points.npoints = npoints;
 
878
        sel->u.points.points = (uint64_t *) points;
 
879
    } else {
 
880
        adios_error(err_no_memory, "Cannot allocate memory for points selection\n");
 
881
    }
 
882
    return sel;
 
883
}
 
884
 
 
885
ADIOS_SELECTION * common_read_selection_writeblock (int index)
 
886
{   
 
887
    adios_errno = err_no_error;
 
888
    ADIOS_SELECTION * sel = (ADIOS_SELECTION *) malloc (sizeof(ADIOS_SELECTION));
 
889
    if (sel) {
 
890
        sel->type = ADIOS_SELECTION_WRITEBLOCK;
 
891
        sel->u.block.index = index;
 
892
    } else {
 
893
        adios_error(err_no_memory, "Cannot allocate memory for writeblock selection\n");
 
894
    }
 
895
    return sel;
 
896
}
 
897
 
 
898
ADIOS_SELECTION * common_read_selection_auto (char *hints)
 
899
{   
 
900
    adios_errno = err_no_error;
 
901
    ADIOS_SELECTION * sel = (ADIOS_SELECTION *) malloc (sizeof(ADIOS_SELECTION));
 
902
    if (sel) {
 
903
        sel->type = ADIOS_SELECTION_AUTO;
 
904
        sel->u.autosel.hints = hints;
 
905
    } else {
 
906
        adios_error(err_no_memory, "Cannot allocate memory for auto selection\n");
 
907
    }
 
908
    return sel;
 
909
}
 
910
 
 
911
void common_read_selection_delete (ADIOS_SELECTION *sel)
 
912
{
 
913
    free(sel);
 
914
}