darshan-mpiio-logutils.c 20.5 KB
Newer Older
Philip Carns's avatar
Philip Carns committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 * Copyright (C) 2015 University of Chicago.
 * See COPYRIGHT notice in top-level directory.
 *
 */

#define _GNU_SOURCE
#include "darshan-util-config.h"
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <unistd.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

20
#include "darshan-logutils.h"
Philip Carns's avatar
Philip Carns committed
21

22 23 24 25 26 27 28 29 30 31 32
/* counter name strings for the MPI-IO module */
#define X(a) #a,
char *mpiio_counter_names[] = {
    MPIIO_COUNTERS
};

char *mpiio_f_counter_names[] = {
    MPIIO_F_COUNTERS
};
#undef X

33
static int darshan_log_get_mpiio_file(darshan_fd fd, void** mpiio_buf_p);
34
static int darshan_log_put_mpiio_file(darshan_fd fd, void* mpiio_buf, int ver);
35
static void darshan_log_print_mpiio_file(void *file_rec,
36
    char *file_name, char *mnt_pt, char *fs_type, int ver);
37
static void darshan_log_print_mpiio_description(void);
38 39
static void darshan_log_print_mpiio_file_diff(void *file_rec1, char *file_name1,
    void *file_rec2, char *file_name2);
40
static void darshan_log_agg_mpiio_files(void *rec, void *agg_rec, int init_flag);
41

42 43 44
struct darshan_mod_logutil_funcs mpiio_logutils =
{
    .log_get_record = &darshan_log_get_mpiio_file,
45
    .log_put_record = &darshan_log_put_mpiio_file,
46
    .log_print_record = &darshan_log_print_mpiio_file,
47
    .log_print_description = &darshan_log_print_mpiio_description,
48
    .log_print_diff = &darshan_log_print_mpiio_file_diff,
49
    .log_agg_records = &darshan_log_agg_mpiio_files
50 51
};

52
static int darshan_log_get_mpiio_file(darshan_fd fd, void** mpiio_buf_p)
Philip Carns's avatar
Philip Carns committed
53
{
54
    struct darshan_mpiio_file *file = *((struct darshan_mpiio_file **)mpiio_buf_p);
Philip Carns's avatar
Philip Carns committed
55
    int i;
56
    int ret;
Philip Carns's avatar
Philip Carns committed
57

58 59 60 61 62 63 64 65 66 67 68
    if(fd->mod_map[DARSHAN_MPIIO_MOD].len == 0)
        return(0);

    if(*mpiio_buf_p == NULL)
    {
        file = malloc(sizeof(*file));
        if(!file)
            return(-1);
    }

    ret = darshan_log_get_mod(fd, DARSHAN_MPIIO_MOD, file,
69
        sizeof(struct darshan_mpiio_file));
70 71 72 73 74 75 76 77 78

    if(*mpiio_buf_p == NULL)
    {
        if(ret == sizeof(struct darshan_mpiio_file))
            *mpiio_buf_p = file;
        else
            free(file);
    }

79
    if(ret < 0)
80
        return(-1);
81 82 83
    else if(ret < sizeof(struct darshan_mpiio_file))
        return(0);
    else
Philip Carns's avatar
Philip Carns committed
84
    {
85
        /* if the read was successful, do any necessary byte-swapping */
86 87
        if(fd->swap_flag)
        {
88 89
            DARSHAN_BSWAP64(&(file->base_rec.id));
            DARSHAN_BSWAP64(&(file->base_rec.rank));
90 91 92 93 94 95 96
            for(i=0; i<MPIIO_NUM_INDICES; i++)
                DARSHAN_BSWAP64(&file->counters[i]);
            for(i=0; i<MPIIO_F_NUM_INDICES; i++)
                DARSHAN_BSWAP64(&file->fcounters[i]);
        }

        return(1);
Philip Carns's avatar
Philip Carns committed
97
    }
98
}
Philip Carns's avatar
Philip Carns committed
99

100
static int darshan_log_put_mpiio_file(darshan_fd fd, void* mpiio_buf, int ver)
101 102 103 104
{
    struct darshan_mpiio_file *file = (struct darshan_mpiio_file *)mpiio_buf;
    int ret;

105
    ret = darshan_log_put_mod(fd, DARSHAN_MPIIO_MOD, file,
106
        sizeof(struct darshan_mpiio_file), DARSHAN_MPIIO_VER);
107 108
    if(ret < 0)
        return(-1);
109 110

    return(0);
Philip Carns's avatar
Philip Carns committed
111 112
}

113
static void darshan_log_print_mpiio_file(void *file_rec, char *file_name,
114
    char *mnt_pt, char *fs_type, int ver)
115 116 117 118 119 120 121 122
{
    int i;
    struct darshan_mpiio_file *mpiio_file_rec =
        (struct darshan_mpiio_file *)file_rec;

    for(i=0; i<MPIIO_NUM_INDICES; i++)
    {
        DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_MPIIO_MOD],
123 124 125
            mpiio_file_rec->base_rec.rank, mpiio_file_rec->base_rec.id,
            mpiio_counter_names[i], mpiio_file_rec->counters[i],
            file_name, mnt_pt, fs_type);
126 127 128 129 130
    }

    for(i=0; i<MPIIO_F_NUM_INDICES; i++)
    {
        DARSHAN_F_COUNTER_PRINT(darshan_module_names[DARSHAN_MPIIO_MOD],
131 132 133
            mpiio_file_rec->base_rec.rank, mpiio_file_rec->base_rec.id,
            mpiio_f_counter_names[i], mpiio_file_rec->fcounters[i],
            file_name, mnt_pt, fs_type);
134 135 136 137 138
    }

    return;
}

139
static void darshan_log_print_mpiio_description()
140
{
141
    printf("\n# description of MPIIO counters:\n");
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
    printf("#   MPIIO_INDEP_*: MPI independent operation counts.\n");
    printf("#   MPIIO_COLL_*: MPI collective operation counts.\n");
    printf("#   MPIIO_SPLIT_*: MPI split collective operation counts.\n");
    printf("#   MPIIO_NB_*: MPI non blocking operation counts.\n");
    printf("#   READS,WRITES,and OPENS are types of operations.\n");
    printf("#   MPIIO_SYNCS: MPI file sync operation counts.\n");
    printf("#   MPIIO_HINTS: number of times MPI hints were used.\n");
    printf("#   MPIIO_VIEWS: number of times MPI file views were used.\n");
    printf("#   MPIIO_MODE: MPI-IO access mode that file was opened with.\n");
    printf("#   MPIIO_BYTES_*: total bytes read and written at MPI-IO layer.\n");
    printf("#   MPIIO_RW_SWITCHES: number of times access alternated between read and write.\n");
    printf("#   MPIIO_MAX_*_TIME_SIZE: size of the slowest read and write operations.\n");
    printf("#   MPIIO_SIZE_*_AGG_*: histogram of MPI datatype total sizes for read and write operations.\n");
    printf("#   MPIIO_ACCESS*_ACCESS: the four most common total access sizes.\n");
    printf("#   MPIIO_ACCESS*_COUNT: count of the four most common total access sizes.\n");
    printf("#   MPIIO_*_RANK: rank of the processes that were the fastest and slowest at I/O (for shared files).\n");
    printf("#   MPIIO_*_RANK_BYTES: total bytes transferred at MPI-IO layer by the fastest and slowest ranks (for shared files).\n");
    printf("#   MPIIO_F_OPEN_TIMESTAMP: timestamp of first open.\n");
    printf("#   MPIIO_F_*_START_TIMESTAMP: timestamp of first MPI-IO read/write.\n");
    printf("#   MPIIO_F_*_END_TIMESTAMP: timestamp of last MPI-IO read/write.\n");
    printf("#   MPIIO_F_CLOSE_TIMESTAMP: timestamp of last close.\n");
    printf("#   MPIIO_F_READ/WRITE/META_TIME: cumulative time spent in MPI-IO read, write, or metadata operations.\n");
    printf("#   MPIIO_F_MAX_*_TIME: duration of the slowest MPI-IO read and write operations.\n");
    printf("#   MPIIO_F_*_RANK_TIME: fastest and slowest I/O time for a single rank (for shared files).\n");
    printf("#   MPIIO_F_VARIANCE_RANK_*: variance of total I/O time and bytes moved for all ranks (for shared files).\n");

    DARSHAN_PRINT_HEADER();

    return;
}

173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
static void darshan_log_print_mpiio_file_diff(void *file_rec1, char *file_name1,
    void *file_rec2, char *file_name2)
{
    struct darshan_mpiio_file *file1 = (struct darshan_mpiio_file *)file_rec1;
    struct darshan_mpiio_file *file2 = (struct darshan_mpiio_file *)file_rec2;
    int i;

    /* NOTE: we assume that both input records are the same module format version */

    for(i=0; i<MPIIO_NUM_INDICES; i++)
    {
        if(!file2)
        {
            printf("- ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_MPIIO_MOD],
Shane Snyder's avatar
Shane Snyder committed
188
                file1->base_rec.rank, file1->base_rec.id, mpiio_counter_names[i],
189 190 191 192 193 194 195
                file1->counters[i], file_name1, "", "");

        }
        else if(!file1)
        {
            printf("+ ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_MPIIO_MOD],
Shane Snyder's avatar
Shane Snyder committed
196
                file2->base_rec.rank, file2->base_rec.id, mpiio_counter_names[i],
197 198 199 200 201 202
                file2->counters[i], file_name2, "", "");
        }
        else if(file1->counters[i] != file2->counters[i])
        {
            printf("- ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_MPIIO_MOD],
Shane Snyder's avatar
Shane Snyder committed
203
                file1->base_rec.rank, file1->base_rec.id, mpiio_counter_names[i],
204 205 206
                file1->counters[i], file_name1, "", "");
            printf("+ ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_MPIIO_MOD],
Shane Snyder's avatar
Shane Snyder committed
207
                file2->base_rec.rank, file2->base_rec.id, mpiio_counter_names[i],
208 209 210 211 212 213 214 215 216 217
                file2->counters[i], file_name2, "", "");
        }
    }

    for(i=0; i<MPIIO_F_NUM_INDICES; i++)
    {
        if(!file2)
        {
            printf("- ");
            DARSHAN_F_COUNTER_PRINT(darshan_module_names[DARSHAN_MPIIO_MOD],
Shane Snyder's avatar
Shane Snyder committed
218
                file1->base_rec.rank, file1->base_rec.id, mpiio_f_counter_names[i],
219 220 221 222 223 224 225
                file1->fcounters[i], file_name1, "", "");

        }
        else if(!file1)
        {
            printf("+ ");
            DARSHAN_F_COUNTER_PRINT(darshan_module_names[DARSHAN_MPIIO_MOD],
Shane Snyder's avatar
Shane Snyder committed
226
                file2->base_rec.rank, file2->base_rec.id, mpiio_f_counter_names[i],
227 228 229 230 231 232
                file2->fcounters[i], file_name2, "", "");
        }
        else if(file1->fcounters[i] != file2->fcounters[i])
        {
            printf("- ");
            DARSHAN_F_COUNTER_PRINT(darshan_module_names[DARSHAN_MPIIO_MOD],
Shane Snyder's avatar
Shane Snyder committed
233
                file1->base_rec.rank, file1->base_rec.id, mpiio_f_counter_names[i],
234 235 236
                file1->fcounters[i], file_name1, "", "");
            printf("+ ");
            DARSHAN_F_COUNTER_PRINT(darshan_module_names[DARSHAN_MPIIO_MOD],
Shane Snyder's avatar
Shane Snyder committed
237
                file2->base_rec.rank, file2->base_rec.id, mpiio_f_counter_names[i],
238 239 240
                file2->fcounters[i], file_name2, "", "");
        }
    }
241 242 243 244

    return;
}

245 246 247 248 249 250 251 252
/* simple helper struct for determining time & byte variances */
struct var_t
{
    double n;
    double M;
    double S;
};

253 254
static void darshan_log_agg_mpiio_files(void *rec, void *agg_rec, int init_flag)
{
255 256
    struct darshan_mpiio_file *mpi_rec = (struct darshan_mpiio_file *)rec;
    struct darshan_mpiio_file *agg_mpi_rec = (struct darshan_mpiio_file *)agg_rec;
257
    int i, j, k;
258 259 260 261
    int total_count;
    int64_t tmp_val[4];
    int64_t tmp_cnt[4];
    int tmp_ndx;
262
    double old_M;
263 264 265
    double mpi_time = mpi_rec->fcounters[MPIIO_F_READ_TIME] +
        mpi_rec->fcounters[MPIIO_F_WRITE_TIME] +
        mpi_rec->fcounters[MPIIO_F_META_TIME];
266 267 268 269 270 271
    double mpi_bytes = (double)mpi_rec->counters[MPIIO_BYTES_READ] +
        mpi_rec->counters[MPIIO_BYTES_WRITTEN];
    struct var_t *var_time_p = (struct var_t *)
        ((char *)rec + sizeof(struct darshan_mpiio_file));
    struct var_t *var_bytes_p = (struct var_t *)
        ((char *)var_time_p + sizeof(struct var_t));
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327

    for(i = 0; i < MPIIO_NUM_INDICES; i++)
    {
        switch(i)
        {
            case MPIIO_INDEP_OPENS:
            case MPIIO_COLL_OPENS:
            case MPIIO_INDEP_READS:
            case MPIIO_INDEP_WRITES:
            case MPIIO_COLL_READS:
            case MPIIO_COLL_WRITES:
            case MPIIO_SPLIT_READS:
            case MPIIO_SPLIT_WRITES:
            case MPIIO_NB_READS:
            case MPIIO_NB_WRITES:
            case MPIIO_SYNCS:
            case MPIIO_HINTS:
            case MPIIO_VIEWS:
            case MPIIO_BYTES_READ:
            case MPIIO_BYTES_WRITTEN:
            case MPIIO_RW_SWITCHES:
            case MPIIO_SIZE_READ_AGG_0_100:
            case MPIIO_SIZE_READ_AGG_100_1K:
            case MPIIO_SIZE_READ_AGG_1K_10K:
            case MPIIO_SIZE_READ_AGG_10K_100K:
            case MPIIO_SIZE_READ_AGG_100K_1M:
            case MPIIO_SIZE_READ_AGG_1M_4M:
            case MPIIO_SIZE_READ_AGG_4M_10M:
            case MPIIO_SIZE_READ_AGG_10M_100M:
            case MPIIO_SIZE_READ_AGG_100M_1G:
            case MPIIO_SIZE_READ_AGG_1G_PLUS:
            case MPIIO_SIZE_WRITE_AGG_0_100:
            case MPIIO_SIZE_WRITE_AGG_100_1K:
            case MPIIO_SIZE_WRITE_AGG_1K_10K:
            case MPIIO_SIZE_WRITE_AGG_10K_100K:
            case MPIIO_SIZE_WRITE_AGG_100K_1M:
            case MPIIO_SIZE_WRITE_AGG_1M_4M:
            case MPIIO_SIZE_WRITE_AGG_4M_10M:
            case MPIIO_SIZE_WRITE_AGG_10M_100M:
            case MPIIO_SIZE_WRITE_AGG_100M_1G:
            case MPIIO_SIZE_WRITE_AGG_1G_PLUS:
                /* sum */
                agg_mpi_rec->counters[i] += mpi_rec->counters[i];
                break;
            case MPIIO_MODE:
                /* just set to the input value */
                agg_mpi_rec->counters[i] = mpi_rec->counters[i];
                break;
            case MPIIO_MAX_READ_TIME_SIZE:
            case MPIIO_MAX_WRITE_TIME_SIZE:
            case MPIIO_FASTEST_RANK:
            case MPIIO_FASTEST_RANK_BYTES:
            case MPIIO_SLOWEST_RANK:
            case MPIIO_SLOWEST_RANK_BYTES:
                /* these are set with the FP counters */
                break;
328 329
            case MPIIO_ACCESS1_ACCESS:
                /* increment common value counters */
330 331 332
                if(mpi_rec->counters[i] == 0) break;

                /* first, collapse duplicates */
333 334 335 336 337 338 339
                for(j = i; j < i + 4; j++)
                {
                    for(k = 0; k < 4; k++)
                    {
                        if(agg_mpi_rec->counters[i + k] == mpi_rec->counters[j])
                        {
                            agg_mpi_rec->counters[i + k + 4] += mpi_rec->counters[j + 4];
340 341 342 343 344 345 346 347 348 349 350 351
                            mpi_rec->counters[j] = mpi_rec->counters[j + 4] = 0;
                        }
                    }
                }

                /* second, add new counters */
                for(j = i; j < i + 4; j++)
                {
                    tmp_ndx = 0;
                    memset(tmp_val, 0, 4 * sizeof(int64_t));
                    memset(tmp_cnt, 0, 4 * sizeof(int64_t));

352
                    if(mpi_rec->counters[j] == 0) break;
353 354 355 356 357 358
                    for(k = 0; k < 4; k++)
                    {
                        if(agg_mpi_rec->counters[i + k] == mpi_rec->counters[j])
                        {
                            total_count = agg_mpi_rec->counters[i + k + 4] +
                                mpi_rec->counters[j + 4];
359 360
                            break;
                        }
361 362 363 364 365 366 367 368
                    }
                    if(k == 4) total_count = mpi_rec->counters[j + 4];

                    for(k = 0; k < 4; k++)
                    {
                        if((agg_mpi_rec->counters[i + k + 4] > total_count) ||
                           ((agg_mpi_rec->counters[i + k + 4] == total_count) &&
                            (agg_mpi_rec->counters[i + k] > mpi_rec->counters[j])))
369
                        {
370 371 372
                            tmp_val[tmp_ndx] = agg_mpi_rec->counters[i + k];
                            tmp_cnt[tmp_ndx] = agg_mpi_rec->counters[i + k + 4];
                            tmp_ndx++;
373
                        }
374
                        else break;
375
                    }
376 377 378 379 380 381 382
                    if(tmp_ndx == 4) break;

                    tmp_val[tmp_ndx] = mpi_rec->counters[j];
                    tmp_cnt[tmp_ndx] = mpi_rec->counters[j + 4];
                    tmp_ndx++;

                    while(tmp_ndx != 4)
383
                    {
384 385 386 387 388 389 390
                        if(agg_mpi_rec->counters[i + k] != mpi_rec->counters[j])
                        {
                            tmp_val[tmp_ndx] = agg_mpi_rec->counters[i + k];
                            tmp_cnt[tmp_ndx] = agg_mpi_rec->counters[i + k + 4];
                            tmp_ndx++;
                        }
                        k++;
391
                    }
392 393
                    memcpy(&(agg_mpi_rec->counters[i]), tmp_val, 4 * sizeof(int64_t));
                    memcpy(&(agg_mpi_rec->counters[i + 4]), tmp_cnt, 4 * sizeof(int64_t));
394 395 396 397 398 399 400 401 402 403 404
                }
                break;
            case MPIIO_ACCESS2_ACCESS:
            case MPIIO_ACCESS3_ACCESS:
            case MPIIO_ACCESS4_ACCESS:
            case MPIIO_ACCESS1_COUNT:
            case MPIIO_ACCESS2_COUNT:
            case MPIIO_ACCESS3_COUNT:
            case MPIIO_ACCESS4_COUNT:
                /* these are set all at once with common counters above */
                break;
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457
            default:
                agg_mpi_rec->counters[i] = -1;
                break;
        }
    }

    for(i = 0; i < MPIIO_F_NUM_INDICES; i++)
    {
        switch(i)
        {
            case MPIIO_F_READ_TIME:
            case MPIIO_F_WRITE_TIME:
            case MPIIO_F_META_TIME:
                /* sum */
                agg_mpi_rec->fcounters[i] += mpi_rec->fcounters[i];
                break;
            case MPIIO_F_OPEN_TIMESTAMP:
            case MPIIO_F_READ_START_TIMESTAMP:
            case MPIIO_F_WRITE_START_TIMESTAMP:
                /* minimum non-zero */
                if((mpi_rec->fcounters[i] > 0)  &&
                    ((agg_mpi_rec->fcounters[i] == 0) ||
                    (mpi_rec->fcounters[i] < agg_mpi_rec->fcounters[i])))
                {
                    agg_mpi_rec->fcounters[i] = mpi_rec->fcounters[i];
                }
                break;
            case MPIIO_F_READ_END_TIMESTAMP:
            case MPIIO_F_WRITE_END_TIMESTAMP:
            case MPIIO_F_CLOSE_TIMESTAMP:
                /* maximum */
                if(mpi_rec->fcounters[i] > agg_mpi_rec->fcounters[i])
                {
                    agg_mpi_rec->fcounters[i] = mpi_rec->fcounters[i];
                }
                break;
            case MPIIO_F_MAX_READ_TIME:
                if(mpi_rec->fcounters[i] > agg_mpi_rec->fcounters[i])
                {
                    agg_mpi_rec->fcounters[i] = mpi_rec->fcounters[i];
                    agg_mpi_rec->counters[MPIIO_MAX_READ_TIME_SIZE] =
                        mpi_rec->counters[MPIIO_MAX_READ_TIME_SIZE];
                }
                break;
            case MPIIO_F_MAX_WRITE_TIME:
                if(mpi_rec->fcounters[i] > agg_mpi_rec->fcounters[i])
                {
                    agg_mpi_rec->fcounters[i] = mpi_rec->fcounters[i];
                    agg_mpi_rec->counters[MPIIO_MAX_WRITE_TIME_SIZE] =
                        mpi_rec->counters[MPIIO_MAX_WRITE_TIME_SIZE];
                }
                break;
            case MPIIO_F_FASTEST_RANK_TIME:
458 459 460 461 462 463 464 465 466 467
                if(init_flag)
                {
                    /* set fastest rank counters according to root rank. these counters
                     * will be determined as the aggregation progresses.
                     */
                    agg_mpi_rec->counters[MPIIO_FASTEST_RANK] = mpi_rec->base_rec.rank;
                    agg_mpi_rec->counters[MPIIO_FASTEST_RANK_BYTES] = mpi_bytes;
                    agg_mpi_rec->fcounters[MPIIO_F_FASTEST_RANK_TIME] = mpi_time;
                }

468 469 470
                if(mpi_time < agg_mpi_rec->fcounters[MPIIO_F_FASTEST_RANK_TIME])
                {
                    agg_mpi_rec->counters[MPIIO_FASTEST_RANK] = mpi_rec->base_rec.rank;
471
                    agg_mpi_rec->counters[MPIIO_FASTEST_RANK_BYTES] = mpi_bytes;
472 473 474 475
                    agg_mpi_rec->fcounters[MPIIO_F_FASTEST_RANK_TIME] = mpi_time;
                }
                break;
            case MPIIO_F_SLOWEST_RANK_TIME:
476 477 478 479 480 481 482 483 484 485
                if(init_flag)
                {
                    /* set slowest rank counters according to root rank. these counters
                     * will be determined as the aggregation progresses.
                     */
                    agg_mpi_rec->counters[MPIIO_SLOWEST_RANK] = mpi_rec->base_rec.rank;
                    agg_mpi_rec->counters[MPIIO_SLOWEST_RANK_BYTES] = mpi_bytes;
                    agg_mpi_rec->fcounters[MPIIO_F_SLOWEST_RANK_TIME] = mpi_time;
                }

486 487 488
                if(mpi_time > agg_mpi_rec->fcounters[MPIIO_F_SLOWEST_RANK_TIME])
                {
                    agg_mpi_rec->counters[MPIIO_SLOWEST_RANK] = mpi_rec->base_rec.rank;
489
                    agg_mpi_rec->counters[MPIIO_SLOWEST_RANK_BYTES] = mpi_bytes;
490 491 492
                    agg_mpi_rec->fcounters[MPIIO_F_SLOWEST_RANK_TIME] = mpi_time;
                }
                break;
493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
            case MPIIO_F_VARIANCE_RANK_TIME:
                if(init_flag)
                {
                    var_time_p->n = 1;
                    var_time_p->M = mpi_time;
                    var_time_p->S = 0;
                }
                else
                {
                    old_M = var_time_p->M;

                    var_time_p->n++;
                    var_time_p->M += (mpi_time - var_time_p->M) / var_time_p->n;
                    var_time_p->S += (mpi_time - var_time_p->M) * (mpi_time - old_M);

                    agg_mpi_rec->fcounters[MPIIO_F_VARIANCE_RANK_TIME] =
                        var_time_p->S / var_time_p->n;
                }
                break;
            case MPIIO_F_VARIANCE_RANK_BYTES:
                if(init_flag)
                {
                    var_bytes_p->n = 1;
                    var_bytes_p->M = mpi_bytes;
                    var_bytes_p->S = 0;
                }
                else
                {
                    old_M = var_bytes_p->M;

                    var_bytes_p->n++;
                    var_bytes_p->M += (mpi_bytes - var_bytes_p->M) / var_bytes_p->n;
                    var_bytes_p->S += (mpi_bytes - var_bytes_p->M) * (mpi_bytes - old_M);

                    agg_mpi_rec->fcounters[MPIIO_F_VARIANCE_RANK_BYTES] =
                        var_bytes_p->S / var_bytes_p->n;
                }
                break;
531 532 533 534 535 536
            default:
                agg_mpi_rec->fcounters[i] = -1;
                break;
        }
    }

537 538
    return;
}
539

Philip Carns's avatar
Philip Carns committed
540 541 542 543 544 545 546 547
/*
 * Local variables:
 *  c-indent-level: 4
 *  c-basic-offset: 4
 * End:
 *
 * vim: ts=8 sts=4 sw=4 expandtab
 */