← Back to branch summary

~ubuntu-branches/debian/stretch/adios/stretch

« back to all changes in this revision

Viewing changes to src/write/adios_posix.c

  • Committer: Package Import Robot
  • Author(s): Alastair McKinstry
  • Date: 2014-06-16 23:06:38 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20140616230638-5a0z7ylxx8i0edrg
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:
src/write/adios_posix.c
110
110
{
111
111
    char * subfile_name;
112
112
    char * mdfile_name;
113
 
    int rank;
114
113
    char * name_with_rank, rank_string[16];
115
114
    struct adios_POSIX_data_struct * p = (struct adios_POSIX_data_struct *)
116
115
                                                          method->method_data;
382
381
                switch (version & ADIOS_VERSION_NUM_MASK)
383
382
                {
384
383
                    case 1:
 
384
                    case 2:
385
385
                        // read the old stuff and set the base offset
386
386
                        adios_posix_read_index_offsets (&p->b);
387
387
                        adios_parse_index_offsets_v1 (&p->b);
469
469
        if (s != fd->bytes_written)
470
470
        {
471
471
            fprintf (stderr, "POSIX method tried to write %llu, "
472
 
                             "only wrote %llu\n"
 
472
                             "only wrote %lld\n"
473
473
                    ,fd->bytes_written
474
 
                    ,s
 
474
                    ,(int64_t)s
475
475
                    );
476
476
        }
477
477
        fd->base_offset += s;
533
533
        if (s != fd->bytes_written)
534
534
        {
535
535
            fprintf (stderr, "POSIX method tried to write %llu, "
536
 
                             "only wrote %llu\n"
 
536
                             "only wrote %lld\n"
537
537
                    ,fd->bytes_written
538
 
                    ,s
 
538
                    ,(int64_t)s
539
539
                    );
540
540
        }
541
541
        fd->base_offset += s;
545
545
 
546
546
        // write payload
547
547
        adios_write_var_payload_v1 (fd, v);
548
 
        uint64_t var_size = adios_get_var_size (v, fd->group, v->data);
 
548
        uint64_t var_size = adios_get_var_size (v, v->data);
549
549
        if (fd->base_offset + var_size > fd->pg_start_in_file + fd->write_size_bytes)
550
550
            fprintf (stderr, "adios_posix_write exceeds pg bound. File is corrupted. "
551
551
                             "Need to enlarge group size. \n"); 
552
552
 
553
553
        int32_t to_write;
554
554
        uint64_t bytes_written = 0;
555
 
        if (var_size > INT32_MAX)
 
555
        if (var_size > MAX_MPIWRITE_SIZE)
556
556
        {
557
 
            to_write = INT32_MAX;
 
557
            to_write = MAX_MPIWRITE_SIZE;
558
558
        }
559
559
        else
560
560
        {
568
568
            STOP_TIMER (ADIOS_TIMER_POSIX_IO);
569
569
            if (var_size > bytes_written)
570
570
            {
571
 
                if (var_size - bytes_written > INT32_MAX)
 
571
                if (var_size - bytes_written > MAX_MPIWRITE_SIZE)
572
572
                {
573
 
                    to_write = INT32_MAX;
 
573
                    to_write = MAX_MPIWRITE_SIZE;
574
574
                }
575
575
                else
576
576
                {
586
586
        if (s != var_size)
587
587
        {
588
588
            fprintf (stderr, "POSIX method tried to write %llu, "
589
 
                             "only wrote %llu\n"
 
589
                             "only wrote %lld\n"
590
590
                    ,var_size
591
 
                    ,s
 
591
                    ,(int64_t)s
592
592
                    );
593
593
        }
594
594
        fd->base_offset += s;
689
689
            fprintf (stderr, "adios_posix_write exceeds pg bound. File is corrupted. "
690
690
                             "Need to enlarge group size. \n");
691
691
 
692
 
        if (fd->bytes_written > INT32_MAX)
 
692
        if (fd->bytes_written > MAX_MPIWRITE_SIZE)
693
693
        {
694
 
            to_write = INT32_MAX;
 
694
            to_write = MAX_MPIWRITE_SIZE;
695
695
        }
696
696
        else
697
697
        {
704
704
            bytes_written += to_write;
705
705
            if (fd->bytes_written > bytes_written)
706
706
            {
707
 
                if (fd->bytes_written - bytes_written > INT32_MAX)
 
707
                if (fd->bytes_written - bytes_written > MAX_MPIWRITE_SIZE)
708
708
                {
709
 
                    to_write = INT32_MAX;
 
709
                    to_write = MAX_MPIWRITE_SIZE;
710
710
                }
711
711
                else
712
712
                {
733
733
                                                          method->method_data;
734
734
    struct adios_var_struct * v = fd->group->vars;
735
735
 
736
 
    struct adios_parse_buffer_struct data;
737
 
 
738
 
    data.vars = v;
739
 
    data.buffer = 0;
740
 
    data.buffer_len = 0;
741
 
 
742
736
    uint32_t version = 0;
743
737
 
744
738
    adios_posix_read_version (&p->b);
745
739
    adios_parse_version (&p->b, &version);
 
740
    version &= ADIOS_VERSION_NUM_MASK;
746
741
 
747
 
    switch (version & ADIOS_VERSION_NUM_MASK)
 
742
    switch (version)
748
743
    {
749
744
        case 1:
 
745
        case 2:
750
746
        {
751
747
            struct adios_index_struct_v1 * index = adios_alloc_index_v1(0); // no hashtables
752
748
            struct adios_index_process_group_struct_v1 * pg_root = index->pg_root;
850
846
        }
851
847
 
852
848
        default:
853
 
            fprintf (stderr, "POSIX read: file version unknown: %u\n"
854
 
                    ,version
855
 
                    );
 
849
            fprintf (stderr, "POSIX read: file version unknown: %u\n", version);
856
850
            return;
857
851
    }
858
852
 
894
888
                if (s != fd->vars_start)
895
889
                {
896
890
                    fprintf (stderr, "POSIX method tried to write %llu, "
897
 
                                     "only wrote %llu\n"
 
891
                                     "only wrote %lld\n"
898
892
                            ,fd->vars_start
899
 
                            ,s
 
893
                            ,(int64_t)s
900
894
                            );
901
895
                }
902
896
                fd->offset = 0;
925
919
                        if (s != fd->bytes_written)
926
920
                        {
927
921
                            fprintf (stderr, "POSIX method tried to write %llu, "
928
 
                                    "only wrote %llu\n"
 
922
                                    "only wrote %lld\n"
929
923
                                    ,fd->bytes_written
930
 
                                    ,s
 
924
                                    ,(int64_t)s
931
925
                                    );
932
926
                        }
933
927
                        fd->base_offset += s;
952
946
                if (s != p->vars_header_size)
953
947
                {
954
948
                    fprintf (stderr, "POSIX method tried to write %llu, "
955
 
                                     "only wrote %llu\n"
 
949
                                     "only wrote %lld\n"
956
950
                            ,p->vars_header_size
957
 
                            ,s
 
951
                            ,(int64_t)s
958
952
                            );
959
953
                }
960
954
                fd->offset = 0;
1068
1062
                    if (s != global_index_buffer_offset)
1069
1063
                    {
1070
1064
                        fprintf (stderr, "POSIX method tried to write %llu, "
1071
 
                                         "only wrote %llu\n"
 
1065
                                         "only wrote %lld\n"
1072
1066
                                         ,fd->bytes_written
1073
 
                                         ,s
 
1067
                                         ,(int64_t)s
1074
1068
                                );
1075
1069
                    }
1076
1070
 
1119
1113
                if (s != fd->vars_start)
1120
1114
                {
1121
1115
                    fprintf (stderr, "POSIX method tried to write %llu, "
1122
 
                                     "only wrote %llu\n"
 
1116
                                     "only wrote %lld\n"
1123
1117
                            ,fd->vars_start
1124
 
                            ,s
 
1118
                            ,(int64_t)s
1125
1119
                            );
1126
1120
                }
1127
1121
                fd->offset = 0;
1147
1141
                        if (s != fd->bytes_written)
1148
1142
                        {
1149
1143
                            fprintf (stderr, "POSIX method tried to write %llu, "
1150
 
                                    "only wrote %llu\n"
 
1144
                                    "only wrote %lld\n"
1151
1145
                                    ,fd->bytes_written
1152
 
                                    ,s
 
1146
                                    ,(int64_t)s
1153
1147
                                    );
1154
1148
                        }
1155
1149
                        fd->base_offset += s;
1174
1168
                if (s != p->vars_header_size)
1175
1169
                {
1176
1170
                    fprintf (stderr, "POSIX method tried to write %llu, "
1177
 
                                     "only wrote %llu\n"
 
1171
                                     "only wrote %lld\n"
1178
1172
                            ,p->vars_header_size
1179
 
                            ,s
 
1173
                            ,(int64_t)s
1180
1174
                            );
1181
1175
                }
1182
1176
                fd->offset = 0;
1291
1285
                    if (s != global_index_buffer_offset)
1292
1286
                    {
1293
1287
                        fprintf (stderr, "POSIX method tried to write %llu, "
1294
 
                                         "only wrote %llu, Mode: a\n"
 
1288
                                         "only wrote %lld, Mode: a\n"
1295
1289
                                         ,global_index_buffer_offset
1296
 
                                         ,s
 
1290
                                         ,(int64_t)s
1297
1291
                                );
1298
1292
                    }
1299
1293