← Back to branch summary

~ubuntu-branches/ubuntu/vivid/adios/vivid-proposed

« back to all changes in this revision

Viewing changes to utils/bpdiff/bpdiff.c

  • Committer: Package Import Robot
  • Author(s): Alastair McKinstry
  • Date: 2014-06-16 23:06:38 UTC
  • mfrom: (15.1.8 sid)
  • Revision ID: package-import@ubuntu.com-20140616230638-cxryhot6b8ge32l6
Tags: 1.7.0-1
* New upstream release.
* Add adios.pc pkgconfig file. adios_config now uses this.

Show diffs side-by-side

added added

removed removed

Lines of Context:
utils/bpdiff/bpdiff.c
24
24
#include <errno.h>
25
25
#include "mpi.h"
26
26
#include "utils.h"
 
27
#include "decompose.h"
27
28
#include "adios.h"
28
29
#include "adios_read.h"
29
30
#include "adios_error.h"
47
48
static const int max_read_buffer_size  = 1024*1024*1024;
48
49
static const int max_write_buffer_size = 1024*1024*1024;
49
50
 
50
 
static int timeout_sec = 0; // will stop if no data found for this time (-1: never stop)
51
 
 
52
 
 
53
51
// Global variables
54
52
int         rank, numproc;
55
53
MPI_Comm    comm; 
146
144
 
147
145
    if (adios_errno == err_file_not_found) 
148
146
    {
149
 
        print ("rank %d: File not found: %s\n", adios_errmsg());
 
147
        print ("rank %d: File not found: %s\n", rank, adios_errmsg());
150
148
        retval = adios_errno;
151
149
    } 
152
150
    else if (f1 == NULL) {
189
187
 
190
188
int process_metadata()
191
189
{
192
 
    int retval = 0;
193
190
    int i, j;
194
 
    char gdims[256], ldims[256], offs[256];
195
191
    ADIOS_VARINFO *v1, *v2; // shortcut pointer
196
192
 
197
193
 
198
194
    varinfo1 = (VarInfo *) malloc (sizeof(VarInfo) * f1->nvars);
199
195
    if (!varinfo1) {
200
 
        print("ERROR: rank %d cannot allocate %lu bytes\n", rank, sizeof(VarInfo)*f1->nvars);
 
196
        print("ERROR: rank %d cannot allocate %zu bytes\n", rank, sizeof(VarInfo)*f1->nvars);
201
197
        return 1;
202
198
    }
203
199
    varinfo2 = (VarInfo *) malloc (sizeof(VarInfo) * f2->nvars);
204
200
    if (!varinfo2) {
205
 
        print("ERROR: rank %d cannot allocate %lu bytes\n", rank, sizeof(VarInfo)*f2->nvars);
 
201
        print("ERROR: rank %d cannot allocate %zu bytes\n", rank, sizeof(VarInfo)*f2->nvars);
206
202
        return 1;
207
203
    }
208
204
 
316
312
                varinfo1[i].count, varinfo1[i].start, &sum_count1);
317
313
      decompose (numproc, rank, v2->ndim, v2->dims, decomp_values,
318
314
                varinfo2[cross_ref].count, varinfo2[cross_ref].start, &sum_count2);
319
 
      //for(x=0; x<v1->ndim; x++) print("%d %d %d %d %d %d %d\n",rank, varinfo1[i].count[x], varinfo1[i].start[x], sum_count1,\
320
 
       //                                                              varinfo2[cross_ref].start[x], varinfo2[cross_ref].count[x], sum_count2);
 
315
      /*for(x=0; x<v1->ndim; x++) print("%d %d %d %d %d %d %d\n",rank, varinfo1[i].count[x], varinfo1[i].start[x], sum_count1,\
 
316
                                                                     varinfo2[cross_ref].start[x], varinfo2[cross_ref].count[x], sum_count2); */
321
317
 
322
318
      //read from files
323
319
      uint64_t size = adios_type_size (v1->type, v1->value);
336
332
      adios_perform_reads (f2, 1);   
337
333
 
338
334
      int sum_count = MIN(sum_count1, sum_count2);
339
 
            int ret = compare_data(f1->var_namelist[i], readbuf1, readbuf2, sum_count, v1->type);
 
335
      int ret = compare_data(f1->var_namelist[i], readbuf1, readbuf2, sum_count, v1->type);
340
336
      int allret;
341
337
      MPI_Reduce(&ret, &allret, 1, MPI_INT, MPI_SUM, 0, comm);
342
338
      if(allret > 0){
356
352
      adios_selection_delete(sel2);
357
353
    }
358
354
  }//for
359
 
 
 
355
  return 0;
360
356
}
361
357
 
362
358
int compare_buffer(char * variable_name, void *data1, void *data2, int total, enum ADIOS_DATATYPES adiosvartype){
368
364
  return total_diff;
369
365
}
370
366
 
371
 
int compare_data(char * variable_name, void *data1, void *data2, int item, enum ADIOS_DATATYPES adiosvartype){
 
367
int compare_data(char * variable_name, void *data1, void *data2, int item, enum ADIOS_DATATYPES adiosvartype)
 
368
{
372
369
    int ret = 0;
373
370
    if (data1 == NULL || data2 == NULL) {
374
371
        print("null data");
375
372
        return ret;
376
373
    }
377
 
    
378
 
    
 
374
 
 
375
 
379
376
    // print next data item into vstr
380
377
    switch(adiosvartype) {
381
378
        case adios_unsigned_byte:
382
 
            if(((unsigned char *) data1)[item] !=  ((unsigned char *) data2)[item] )//not identical
383
 
            {
384
 
                    print("%s : %hhu in %s | %hhu in %s\n", variable_name, ((unsigned char *) data1)[item], infilename1, ((unsigned char *) data2)[item], infilename2);
385
 
        ret++;
386
 
            }
 
379
            if(((unsigned char *) data1)[item] !=  ((unsigned char *) data2)[item] )//not identical
 
380
            {
 
381
                print("%s : %hhu in %s | %hhu in %s\n", variable_name, ((unsigned char *) data1)[item], infilename1, ((unsigned char *) data2)[item], infilename2);
 
382
                ret++;
 
383
            }
387
384
            break;
388
385
        case adios_byte:
389
 
            if(((signed char *) data1)[item] != ((signed char *) data2)[item])//not identical
390
 
            {
391
 
                print("%s : %hhd in %s | %hhd in %s\n", variable_name, ((signed char *) data1)[item], infilename1, ((signed char *) data2)[item], infilename2);
392
 
        ret++;
393
 
            }
 
386
            if(((signed char *) data1)[item] != ((signed char *) data2)[item])//not identical
 
387
            {
 
388
                print("%s : %hhd in %s | %hhd in %s\n", variable_name, ((signed char *) data1)[item], infilename1, ((signed char *) data2)[item], infilename2);
 
389
                ret++;
 
390
            }
394
391
            break;
395
392
        case adios_string:
396
 
            if(strcmp(((char *) data1), ((char *) data2))!= 0 )//not identical
397
 
            {
398
 
                print("%s : %s in %s | %s in %s\n", variable_name, ((char *) data1)[item], infilename1, ((char *) data2)[item], infilename2);
399
 
        ret++;
400
 
            }
 
393
            if(strcmp(((char *) data1), ((char *) data2))!= 0 )//not identical
 
394
            {
 
395
                print("%s : %s in %s | %s in %s\n", variable_name, (char *) data1, infilename1, (char *) data2, infilename2);
 
396
                ret++;
 
397
            }
401
398
            break;
402
399
        case adios_unsigned_short:
403
 
            if(((unsigned short*) data1)[item] != ((unsigned short *) data2)[item])//not identical
404
 
            {
405
 
                print("%s : %hu in %s | %hu in %s\n", variable_name, ((unsigned short *) data1)[item], infilename1, ((unsigned short *) data2)[item], infilename2);
406
 
        ret++;
407
 
            }
 
400
            if(((unsigned short*) data1)[item] != ((unsigned short *) data2)[item])//not identical
 
401
            {
 
402
                print("%s : %hu in %s | %hu in %s\n", variable_name, ((unsigned short *) data1)[item], infilename1, ((unsigned short *) data2)[item], infilename2);
 
403
                ret++;
 
404
            }
408
405
            break;
409
406
        case adios_short:
410
 
            if(((signed short*) data1)[item] != ((signed short *) data2)[item])//not identical
411
 
            {
412
 
                print("%s : %hd in %s | %hd in %s\n", variable_name, ((signed short *) data1)[item], infilename1, ((signed short *) data2)[item], infilename2);
413
 
        ret++;
414
 
            }
 
407
            if(((signed short*) data1)[item] != ((signed short *) data2)[item])//not identical
 
408
            {
 
409
                print("%s : %hd in %s | %hd in %s\n", variable_name, ((signed short *) data1)[item], infilename1, ((signed short *) data2)[item], infilename2);
 
410
                ret++;
 
411
            }
415
412
            break;
416
413
        case adios_unsigned_integer:
417
 
            if(((unsigned int*) data1)[item] != ((unsigned int*) data2)[item])//not identical
418
 
            {
419
 
                print("%s : %u in %s | %u in %s\n", variable_name, ((unsigned int*) data1)[item], infilename1, ((unsigned int*) data2)[item], infilename2);
420
 
        ret++;
421
 
            }
 
414
            if(((unsigned int*) data1)[item] != ((unsigned int*) data2)[item])//not identical
 
415
            {
 
416
                print("%s : %u in %s | %u in %s\n", variable_name, ((unsigned int*) data1)[item], infilename1, ((unsigned int*) data2)[item], infilename2);
 
417
                ret++;
 
418
            }
422
419
            break;
423
420
        case adios_integer:
424
 
            if(((signed int*) data1)[item] != ((signed int*) data2)[item] != 0 )//not identical
425
 
            {
426
 
                print("%s : %d in %s | %d in %s\n", variable_name, ((signed int*) data1)[item], infilename1, ((signed int*) data2)[item], infilename2);
427
 
        ret++;
428
 
            }
 
421
            if(((signed int*) data1)[item] != ((signed int*) data2)[item])//not identical
 
422
            {
 
423
                print("%s : %d in %s | %d in %s\n", variable_name, ((signed int*) data1)[item], infilename1, ((signed int*) data2)[item], infilename2);
 
424
                ret++;
 
425
            }
429
426
            break;
430
427
        case adios_unsigned_long:
431
 
            if(((unsigned long long*) data1)[item] != ((unsigned long long*) data2)[item])//not identical
432
 
            {
433
 
                print("%s : %llu in %s | %llu in %s\n", variable_name, ((unsigned long long*) data1)[item], infilename1, ((unsigned long long*) data2)[item], infilename2);
434
 
        ret++;
435
 
            }
 
428
            if(((unsigned long long*) data1)[item] != ((unsigned long long*) data2)[item])//not identical
 
429
            {
 
430
                print("%s : %llu in %s | %llu in %s\n", variable_name, ((unsigned long long*) data1)[item], infilename1, ((unsigned long long*) data2)[item], infilename2);
 
431
                ret++;
 
432
            }
436
433
            break;
437
434
        case adios_long:
438
 
            if(((unsigned long long*) data1)[item] != ((unsigned long long*) data2)[item])//not identical
439
 
            {
440
 
                print("%s : %lld in %s | %lld in %s\n", variable_name, ((signed long long*) data1)[item], infilename1, ((signed long long*) data2)[item], infilename2);
441
 
        ret++;
442
 
            }
 
435
            if(((unsigned long long*) data1)[item] != ((unsigned long long*) data2)[item])//not identical
 
436
            {
 
437
                print("%s : %lld in %s | %lld in %s\n", variable_name, ((signed long long*) data1)[item], infilename1, ((signed long long*) data2)[item], infilename2);
 
438
                ret++;
 
439
            }
443
440
            break;
444
441
        case adios_real:
445
 
            {
446
 
            float a, b;
447
 
            a = ((float *) data1)[item];
448
 
            b = ((float *) data2)[item];
449
 
            if(abs(a-b)> fuzz_factor){
450
 
              print("%s : %g in %s | %g in %s\n", variable_name, a, infilename1, b, infilename2);
451
 
        ret++;
452
 
            }
453
 
            break;
454
 
            }
 
442
            {
 
443
                float a, b;
 
444
                a = ((float *) data1)[item];
 
445
                b = ((float *) data2)[item];
 
446
                if(abs(a-b)> fuzz_factor){
 
447
                    print("%s : %g in %s | %g in %s\n", variable_name, a, infilename1, b, infilename2);
 
448
                    ret++;
 
449
                }
 
450
                break;
 
451
            }
455
452
        case adios_double:
456
 
            {
457
 
            double aa, bb;
458
 
            aa = ((double *) data1)[item];
459
 
            bb = ((double *) data2)[item];
460
 
            if(abs(aa-bb)> fuzz_factor){
461
 
              print("%s : %g in %s | %g in %s\n", variable_name, aa, infilename1, bb, infilename2);
462
 
        ret++;
463
 
            }
464
 
            break;
465
 
            }
 
453
            {
 
454
                double aa, bb;
 
455
                aa = ((double *) data1)[item];
 
456
                bb = ((double *) data2)[item];
 
457
                if(abs(aa-bb)> fuzz_factor){
 
458
                    print("%s : %g in %s | %g in %s\n", variable_name, aa, infilename1, bb, infilename2);
 
459
                    ret++;
 
460
                }
 
461
                break;
 
462
            }
466
463
        case adios_long_double:
467
464
            //fprintf(outf,(f ? format : "%g "), ((double *) data1)[item]);
468
 
        //                fprintf(outf,(f ? format : "????????"));
 
465
            //                fprintf(outf,(f ? format : "????????"));
469
466
            break;
470
467
        case adios_complex:
471
 
            {
472
 
            float a11, a12, b11, b12;
473
 
            a11 = ((float *) data1)[2*item];
474
 
            a12 = ((float *) data1)[2*item+1];
475
 
            b11 = ((float *) data2)[2*item];
476
 
            b12 = ((float *) data2)[2*item+1];
477
 
            if(abs(a11-b11)> fuzz_factor || abs(a12-b12)>fuzz_factor){
478
 
              print("%s : %g i%g in %s | %g i%g in %s\n", variable_name, a11, b11, infilename1, a12, b12, infilename2);
479
 
        ret++;
480
 
            }
481
 
         
482
 
            break;
483
 
            }
 
468
            {
 
469
                float a11, a12, b11, b12;
 
470
                a11 = ((float *) data1)[2*item];
 
471
                a12 = ((float *) data1)[2*item+1];
 
472
                b11 = ((float *) data2)[2*item];
 
473
                b12 = ((float *) data2)[2*item+1];
 
474
                if(abs(a11-b11)> fuzz_factor || abs(a12-b12)>fuzz_factor){
 
475
                    print("%s : %g i%g in %s | %g i%g in %s\n", variable_name, a11, b11, infilename1, a12, b12, infilename2);
 
476
                    ret++;
 
477
                }
 
478
 
 
479
                break;
 
480
            }
484
481
        case adios_double_complex:
485
482
            {
486
 
            double a21, a22, b21, b22;
487
 
            a21 = ((float *) data1)[2*item];
488
 
            a22 = ((float *) data1)[2*item+1];
489
 
            b21 = ((float *) data2)[2*item];
490
 
            b22 = ((float *) data2)[2*item+1];
491
 
            if(abs(a21-b21)> fuzz_factor || abs(a22-b22)>fuzz_factor){
492
 
              print("%s : %g i%g in %s | %g i%g in %s\n", variable_name, a21, b21, infilename1, a22, b22, infilename2);
493
 
        ret++;
494
 
            }
 
483
                double a21, a22, b21, b22;
 
484
                a21 = ((float *) data1)[2*item];
 
485
                a22 = ((float *) data1)[2*item+1];
 
486
                b21 = ((float *) data2)[2*item];
 
487
                b22 = ((float *) data2)[2*item+1];
 
488
                if(abs(a21-b21)> fuzz_factor || abs(a22-b22)>fuzz_factor){
 
489
                    print("%s : %g i%g in %s | %g i%g in %s\n", variable_name, a21, b21, infilename1, a22, b22, infilename2);
 
490
                    ret++;
 
491
                }
 
492
                break;
 
493
            }
 
494
        default:
495
495
            break;
496
 
            }
497
496
    } // end switch
498
497
    return ret;
499
498
}