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
    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");

    return;
}

171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
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
186
                file1->base_rec.rank, file1->base_rec.id, mpiio_counter_names[i],
187 188 189 190 191 192 193
                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
194
                file2->base_rec.rank, file2->base_rec.id, mpiio_counter_names[i],
195 196 197 198 199 200
                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
201
                file1->base_rec.rank, file1->base_rec.id, mpiio_counter_names[i],
202 203 204
                file1->counters[i], file_name1, "", "");
            printf("+ ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_MPIIO_MOD],
Shane Snyder's avatar
Shane Snyder committed
205
                file2->base_rec.rank, file2->base_rec.id, mpiio_counter_names[i],
206 207 208 209 210 211 212 213 214 215
                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
216
                file1->base_rec.rank, file1->base_rec.id, mpiio_f_counter_names[i],
217 218 219 220 221 222 223
                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
224
                file2->base_rec.rank, file2->base_rec.id, mpiio_f_counter_names[i],
225 226 227 228 229 230
                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
231
                file1->base_rec.rank, file1->base_rec.id, mpiio_f_counter_names[i],
232 233 234
                file1->fcounters[i], file_name1, "", "");
            printf("+ ");
            DARSHAN_F_COUNTER_PRINT(darshan_module_names[DARSHAN_MPIIO_MOD],
Shane Snyder's avatar
Shane Snyder committed
235
                file2->base_rec.rank, file2->base_rec.id, mpiio_f_counter_names[i],
236 237 238
                file2->fcounters[i], file_name2, "", "");
        }
    }
239 240 241 242

    return;
}

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

251 252
static void darshan_log_agg_mpiio_files(void *rec, void *agg_rec, int init_flag)
{
253 254
    struct darshan_mpiio_file *mpi_rec = (struct darshan_mpiio_file *)rec;
    struct darshan_mpiio_file *agg_mpi_rec = (struct darshan_mpiio_file *)agg_rec;
255
    int i, j, k;
256 257 258 259
    int total_count;
    int64_t tmp_val[4];
    int64_t tmp_cnt[4];
    int tmp_ndx;
260
    double old_M;
261 262 263
    double mpi_time = mpi_rec->fcounters[MPIIO_F_READ_TIME] +
        mpi_rec->fcounters[MPIIO_F_WRITE_TIME] +
        mpi_rec->fcounters[MPIIO_F_META_TIME];
264 265 266 267 268 269
    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));
270 271 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

    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;
326 327
            case MPIIO_ACCESS1_ACCESS:
                /* increment common value counters */
328 329 330
                if(mpi_rec->counters[i] == 0) break;

                /* first, collapse duplicates */
331 332 333 334 335 336 337
                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];
338 339 340 341 342 343 344 345 346 347 348 349
                            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));

350
                    if(mpi_rec->counters[j] == 0) break;
351 352 353 354 355 356
                    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];
357 358
                            break;
                        }
359 360 361 362 363 364 365 366
                    }
                    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])))
367
                        {
368 369 370
                            tmp_val[tmp_ndx] = agg_mpi_rec->counters[i + k];
                            tmp_cnt[tmp_ndx] = agg_mpi_rec->counters[i + k + 4];
                            tmp_ndx++;
371
                        }
372
                        else break;
373
                    }
374 375 376 377 378 379 380
                    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)
381
                    {
382 383 384 385 386 387 388
                        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++;
389
                    }
390 391
                    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));
392 393 394 395 396 397 398 399 400 401 402
                }
                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;
403 404 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
            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:
456 457 458 459 460 461 462 463 464 465
                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;
                }

466 467 468
                if(mpi_time < agg_mpi_rec->fcounters[MPIIO_F_FASTEST_RANK_TIME])
                {
                    agg_mpi_rec->counters[MPIIO_FASTEST_RANK] = mpi_rec->base_rec.rank;
469
                    agg_mpi_rec->counters[MPIIO_FASTEST_RANK_BYTES] = mpi_bytes;
470 471 472 473
                    agg_mpi_rec->fcounters[MPIIO_F_FASTEST_RANK_TIME] = mpi_time;
                }
                break;
            case MPIIO_F_SLOWEST_RANK_TIME:
474 475 476 477 478 479 480 481 482 483
                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;
                }

484 485 486
                if(mpi_time > agg_mpi_rec->fcounters[MPIIO_F_SLOWEST_RANK_TIME])
                {
                    agg_mpi_rec->counters[MPIIO_SLOWEST_RANK] = mpi_rec->base_rec.rank;
487
                    agg_mpi_rec->counters[MPIIO_SLOWEST_RANK_BYTES] = mpi_bytes;
488 489 490
                    agg_mpi_rec->fcounters[MPIIO_F_SLOWEST_RANK_TIME] = mpi_time;
                }
                break;
491 492 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
            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;
529 530 531 532 533 534
            default:
                agg_mpi_rec->fcounters[i] = -1;
                break;
        }
    }

535 536
    return;
}
537

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