darshan-stdio.c 39.1 KB
Newer Older
1 2 3 4 5 6
/*
 * Copyright (C) 2015 University of Chicago.
 * See COPYRIGHT notice in top-level directory.
 *
 */

7 8
/* TODO list (general) for this module:
 * - add stdio page to darshan-job-summary
Philip Carns's avatar
Philip Carns committed
9 10
 * - update darshan-parser to include stdio information in any relevant 
 *   performance estimate / summary modes
11 12
 * - figure out what to do about posix module compatibility
 *   - remove stdio counters in POSIX or keep and set to -1?
Philip Carns's avatar
Philip Carns committed
13 14 15 16 17
 *   - affected counters in posix module:
 *     - POSIX_FOPENS
 *     - POSIX_FREADS
 *     - POSIX_FWRITES
 *     - POSIX_FSEEKS
18 19
 */

Philip Carns's avatar
Philip Carns committed
20 21 22 23 24
/* catalog of stdio functions instrumented by this module
 *
 * functions for opening streams
 * --------------
 * FILE    *fdopen(int, const char *);                      DONE
Philip Carns's avatar
Philip Carns committed
25
 * FILE    *fopen(const char *, const char *);              DONE
Philip Carns's avatar
Philip Carns committed
26
 * FILE    *fopen64(const char *, const char *);            DONE
Philip Carns's avatar
Philip Carns committed
27
 * FILE    *freopen(const char *, const char *, FILE *);    DONE
Philip Carns's avatar
Philip Carns committed
28
 * FILE    *freopen64(const char *, const char *, FILE *);  DONE
Philip Carns's avatar
Philip Carns committed
29 30 31 32 33 34 35
 *
 * functions for closing streams
 * --------------
 * int      fclose(FILE *);                                 DONE
 *
 * functions for flushing streams
 * --------------
Philip Carns's avatar
Philip Carns committed
36
 * int      fflush(FILE *);                                 DONE
Philip Carns's avatar
Philip Carns committed
37 38 39
 *
 * functions for reading data
 * --------------
Philip Carns's avatar
Philip Carns committed
40
 * int      fgetc(FILE *);                                  DONE
Philip Carns's avatar
Philip Carns committed
41
 * char    *fgets(char *, int, FILE *);                     DONE
Philip Carns's avatar
Philip Carns committed
42
 * size_t   fread(void *, size_t, size_t, FILE *);          DONE
43 44
 * int      fscanf(FILE *, const char *, ...);              DONE
 * int      vfscanf(FILE *, const char *, va_list);         DONE
Philip Carns's avatar
Philip Carns committed
45
 * int      getc(FILE *);                                   DONE
Philip Carns's avatar
Philip Carns committed
46
 * int      getw(FILE *);                                   DONE
Philip Carns's avatar
Philip Carns committed
47 48 49
 *
 * functions for writing data
 * --------------
Philip Carns's avatar
Philip Carns committed
50 51
 * int      fprintf(FILE *, const char *, ...);             DONE
 * int      vfprintf(FILE *, const char *, va_list);        DONE
Philip Carns's avatar
Philip Carns committed
52
 * int      fputc(int, FILE *);                             DONE
Philip Carns's avatar
Philip Carns committed
53
 * int      fputs(const char *, FILE *);                    DONE
Philip Carns's avatar
Philip Carns committed
54
 * size_t   fwrite(const void *, size_t, size_t, FILE *);   DONE
Philip Carns's avatar
Philip Carns committed
55
 * int      putc(int, FILE *);                              DONE
Philip Carns's avatar
Philip Carns committed
56
 * int      putw(int, FILE *);                              DONE
Philip Carns's avatar
Philip Carns committed
57 58 59 60
 *
 * functions for changing file position
 * --------------
 * int      fseek(FILE *, long int, int);                   DONE
61
 * int      fseeko(FILE *, off_t, int);                     DONE
Philip Carns's avatar
Philip Carns committed
62
 * int      fseeko64(FILE *, off_t, int);                   DONE
63 64
 * int      fsetpos(FILE *, const fpos_t *);                DONE
 * int      fsetpos64(FILE *, const fpos_t *);              DONE
Philip Carns's avatar
Philip Carns committed
65
 * void     rewind(FILE *);                                 DONE
66
 *
67 68 69 70 71
 * Omissions: 
 *   - _unlocked() variants of the various flush, read, and write
 *     functions.  There are many of these, but they are not available on all
 *     systems and the man page advises not to use them.
 *   - ungetc()
Philip Carns's avatar
Philip Carns committed
72 73
 */

74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
#define _XOPEN_SOURCE 500
#define _GNU_SOURCE

#include "darshan-runtime-config.h"
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdarg.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/uio.h>
#include <sys/mman.h>
#include <search.h>
#include <assert.h>
#include <libgen.h>
#include <pthread.h>

#include "darshan.h"
#include "darshan-dynamic.h"

DARSHAN_FORWARD_DECL(fopen, FILE*, (const char *path, const char *mode));
DARSHAN_FORWARD_DECL(fopen64, FILE*, (const char *path, const char *mode));
Philip Carns's avatar
Philip Carns committed
100
DARSHAN_FORWARD_DECL(fdopen, FILE*, (int fd, const char *mode));
Philip Carns's avatar
Philip Carns committed
101
DARSHAN_FORWARD_DECL(freopen, FILE*, (const char *path, const char *mode, FILE *stream));
Philip Carns's avatar
Philip Carns committed
102
DARSHAN_FORWARD_DECL(freopen64, FILE*, (const char *path, const char *mode, FILE *stream));
103
DARSHAN_FORWARD_DECL(fclose, int, (FILE *fp));
Philip Carns's avatar
Philip Carns committed
104
DARSHAN_FORWARD_DECL(fflush, int, (FILE *fp));
105
DARSHAN_FORWARD_DECL(fwrite, size_t, (const void *ptr, size_t size, size_t nmemb, FILE *stream));
Philip Carns's avatar
Philip Carns committed
106
DARSHAN_FORWARD_DECL(fputc, int, (int c, FILE *stream));
Philip Carns's avatar
Philip Carns committed
107
DARSHAN_FORWARD_DECL(putw, int, (int w, FILE *stream));
Philip Carns's avatar
Philip Carns committed
108
DARSHAN_FORWARD_DECL(fputs, int, (const char *s, FILE *stream));
Philip Carns's avatar
Philip Carns committed
109 110
DARSHAN_FORWARD_DECL(fprintf, int, (FILE *stream, const char *format, ...));
DARSHAN_FORWARD_DECL(vfprintf, int, (FILE *stream, const char *format, va_list));
111
DARSHAN_FORWARD_DECL(fread, size_t, (void *ptr, size_t size, size_t nmemb, FILE *stream));
Philip Carns's avatar
Philip Carns committed
112
DARSHAN_FORWARD_DECL(fgetc, int, (FILE *stream));
Philip Carns's avatar
Philip Carns committed
113
DARSHAN_FORWARD_DECL(getw, int, (FILE *stream));
Philip Carns's avatar
Philip Carns committed
114
DARSHAN_FORWARD_DECL(_IO_getc, int, (FILE *stream));
Philip Carns's avatar
Philip Carns committed
115
DARSHAN_FORWARD_DECL(_IO_putc, int, (int, FILE *stream));
116
DARSHAN_FORWARD_DECL(fscanf, int, (FILE *stream, const char *format, ...));
Philip Carns's avatar
Philip Carns committed
117
DARSHAN_FORWARD_DECL(__isoc99_fscanf, int, (FILE *stream, const char *format, ...));
118
DARSHAN_FORWARD_DECL(vfscanf, int, (FILE *stream, const char *format, va_list ap));
Philip Carns's avatar
Philip Carns committed
119
DARSHAN_FORWARD_DECL(fgets, char*, (char *s, int size, FILE *stream));
120
DARSHAN_FORWARD_DECL(fseek, int, (FILE *stream, long offset, int whence));
Philip Carns's avatar
Philip Carns committed
121
DARSHAN_FORWARD_DECL(fseeko, int, (FILE *stream, off_t offset, int whence));
Philip Carns's avatar
Philip Carns committed
122
DARSHAN_FORWARD_DECL(fseeko64, int, (FILE *stream, off_t offset, int whence));
123
DARSHAN_FORWARD_DECL(fsetpos, int, (FILE *stream, const fpos_t *pos));
124
DARSHAN_FORWARD_DECL(fsetpos64, int, (FILE *stream, const fpos64_t *pos));
Philip Carns's avatar
Philip Carns committed
125
DARSHAN_FORWARD_DECL(rewind, void, (FILE *stream));
126

127 128
/* structure to track stdio stats at runtime */
struct stdio_file_record_ref
129
{
130
    struct darshan_stdio_file* file_rec;
131 132 133 134 135 136 137 138 139 140 141 142
    int64_t offset;
    double last_meta_end;
    double last_read_end;
    double last_write_end;
};

/* The stdio_runtime structure maintains necessary state for storing
 * STDIO file records and for coordinating with darshan-core at 
 * shutdown time.
 */
struct stdio_runtime
{
143 144 145
    void *rec_id_hash;
    void *stream_hash;
    int file_rec_count;
146 147 148 149 150 151 152 153 154
};

static struct stdio_runtime *stdio_runtime = NULL;
static pthread_mutex_t stdio_runtime_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
static int instrumentation_disabled = 0;
static int darshan_mem_alignment = 1;
static int my_rank = -1;

static void stdio_runtime_initialize(void);
155 156 157 158 159 160
static void stdio_shutdown(
    MPI_Comm mod_comm,
    darshan_record_id *shared_recs,
    int shared_rec_count,
    void **stdio_buf,
    int *stdio_buf_sz);
161 162
static void stdio_record_reduction_op(void* infile_v, void* inoutfile_v,
    int *len, MPI_Datatype *datatype);
163 164 165
static void stdio_shared_record_variance(
    MPI_Comm mod_comm, struct darshan_stdio_file *inrec_array,
    struct darshan_stdio_file *outrec_array, int shared_rec_count);
166 167 168
static struct stdio_file_record_ref *stdio_track_new_file_record(
    darshan_record_id rec_id, const char *path);
static void stdio_cleanup_runtime();
169 170 171 172

#define STDIO_LOCK() pthread_mutex_lock(&stdio_runtime_mutex)
#define STDIO_UNLOCK() pthread_mutex_unlock(&stdio_runtime_mutex)

173 174 175 176 177 178 179 180 181 182 183 184 185
#define STDIO_PRE_RECORD() do { \
    STDIO_LOCK(); \
    if(!stdio_runtime && !instrumentation_disabled) stdio_runtime_initialize(); \
    if(!stdio_runtime) { \
        STDIO_UNLOCK(); \
        return(ret); \
    } \
} while(0)

#define STDIO_POST_RECORD() do { \
    STDIO_UNLOCK(); \
} while(0)

186
#define STDIO_RECORD_OPEN(__ret, __path, __tm1, __tm2) do { \
187 188 189
    darshan_record_id rec_id; \
    struct stdio_file_record_ref* rec_ref; \
    char *newpath; \
190
    if(__ret == NULL) break; \
191 192 193 194 195
    newpath = darshan_clean_file_path(__path); \
    if(!newpath) newpath = (char*)__path; \
    if(darshan_core_excluded_path(newpath)) { \
        if(newpath != (char*)__path) free(newpath); \
        break; \
196
    } \
197
    rec_id = darshan_core_gen_record_id(newpath); \
Philip Carns's avatar
Philip Carns committed
198
    rec_ref = darshan_lookup_record_ref(stdio_runtime->rec_id_hash, &rec_id, sizeof(rec_id)); \
199 200 201 202 203 204 205 206 207 208 209 210 211 212
    if(!rec_ref) rec_ref = stdio_track_new_file_record(rec_id, newpath); \
    if(!rec_ref) { \
        if(newpath != (char*)__path) free(newpath); \
        break; \
    } \
    rec_ref->offset = 0; \
    rec_ref->file_rec->counters[STDIO_OPENS] += 1; \
    if(rec_ref->file_rec->fcounters[STDIO_F_OPEN_START_TIMESTAMP] == 0 || \
     rec_ref->file_rec->fcounters[STDIO_F_OPEN_START_TIMESTAMP] > __tm1) \
        rec_ref->file_rec->fcounters[STDIO_F_OPEN_START_TIMESTAMP] = __tm1; \
    rec_ref->file_rec->fcounters[STDIO_F_OPEN_END_TIMESTAMP] = __tm2; \
    DARSHAN_TIMER_INC_NO_OVERLAP(rec_ref->file_rec->fcounters[STDIO_F_META_TIME], __tm1, __tm2, rec_ref->last_meta_end); \
    darshan_add_record_ref(&(stdio_runtime->stream_hash), &(__ret), sizeof(__ret), rec_ref); \
    if(newpath != (char*)__path) free(newpath); \
213 214 215
} while(0)


216
#define STDIO_RECORD_READ(__fp, __bytes,  __tm1, __tm2) do{ \
217
    struct stdio_file_record_ref* rec_ref; \
218
    int64_t this_offset; \
Philip Carns's avatar
Philip Carns committed
219
    rec_ref = darshan_lookup_record_ref(stdio_runtime->stream_hash, &(__fp), sizeof(__fp)); \
220 221 222 223 224 225 226 227 228 229 230 231
    if(!rec_ref) break; \
    this_offset = rec_ref->offset; \
    rec_ref->offset = this_offset + __bytes; \
    if(rec_ref->file_rec->counters[STDIO_MAX_BYTE_READ] < (this_offset + __bytes - 1)) \
        rec_ref->file_rec->counters[STDIO_MAX_BYTE_READ] = (this_offset + __bytes - 1); \
    rec_ref->file_rec->counters[STDIO_BYTES_READ] += __bytes; \
    rec_ref->file_rec->counters[STDIO_READS] += 1; \
    if(rec_ref->file_rec->fcounters[STDIO_F_READ_START_TIMESTAMP] == 0 || \
     rec_ref->file_rec->fcounters[STDIO_F_READ_START_TIMESTAMP] > __tm1) \
        rec_ref->file_rec->fcounters[STDIO_F_READ_START_TIMESTAMP] = __tm1; \
    rec_ref->file_rec->fcounters[STDIO_F_READ_END_TIMESTAMP] = __tm2; \
    DARSHAN_TIMER_INC_NO_OVERLAP(rec_ref->file_rec->fcounters[STDIO_F_READ_TIME], __tm1, __tm2, rec_ref->last_write_end); \
232 233
} while(0)

Philip Carns's avatar
Philip Carns committed
234
#define STDIO_RECORD_WRITE(__fp, __bytes,  __tm1, __tm2, __fflush_flag) do{ \
235
    struct stdio_file_record_ref* rec_ref; \
236
    int64_t this_offset; \
Philip Carns's avatar
Philip Carns committed
237
    rec_ref = darshan_lookup_record_ref(stdio_runtime->stream_hash, &(__fp), sizeof(__fp)); \
238 239 240 241 242 243
    if(!rec_ref) break; \
    this_offset = rec_ref->offset; \
    rec_ref->offset = this_offset + __bytes; \
    if(rec_ref->file_rec->counters[STDIO_MAX_BYTE_WRITTEN] < (this_offset + __bytes - 1)) \
        rec_ref->file_rec->counters[STDIO_MAX_BYTE_WRITTEN] = (this_offset + __bytes - 1); \
    rec_ref->file_rec->counters[STDIO_BYTES_WRITTEN] += __bytes; \
Philip Carns's avatar
Philip Carns committed
244
    if(__fflush_flag) \
245
        rec_ref->file_rec->counters[STDIO_FLUSHES] += 1; \
Philip Carns's avatar
Philip Carns committed
246
    else \
247 248 249 250 251 252
        rec_ref->file_rec->counters[STDIO_WRITES] += 1; \
    if(rec_ref->file_rec->fcounters[STDIO_F_WRITE_START_TIMESTAMP] == 0 || \
     rec_ref->file_rec->fcounters[STDIO_F_WRITE_START_TIMESTAMP] > __tm1) \
        rec_ref->file_rec->fcounters[STDIO_F_WRITE_START_TIMESTAMP] = __tm1; \
    rec_ref->file_rec->fcounters[STDIO_F_WRITE_END_TIMESTAMP] = __tm2; \
    DARSHAN_TIMER_INC_NO_OVERLAP(rec_ref->file_rec->fcounters[STDIO_F_WRITE_TIME], __tm1, __tm2, rec_ref->last_write_end); \
253
} while(0)
254

Philip Carns's avatar
Philip Carns committed
255
FILE* DARSHAN_DECL(fopen)(const char *path, const char *mode)
Philip Carns's avatar
Philip Carns committed
256 257 258 259
{
    FILE* ret;
    double tm1, tm2;

Philip Carns's avatar
Philip Carns committed
260
    MAP_OR_FAIL(fopen);
Philip Carns's avatar
Philip Carns committed
261 262

    tm1 = darshan_core_wtime();
Philip Carns's avatar
Philip Carns committed
263
    ret = __real_fopen(path, mode);
Philip Carns's avatar
Philip Carns committed
264 265
    tm2 = darshan_core_wtime();

266
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
267
    STDIO_RECORD_OPEN(ret, path, tm1, tm2);
268
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
269 270 271 272

    return(ret);
}

Philip Carns's avatar
Philip Carns committed
273
FILE* DARSHAN_DECL(fopen64)(const char *path, const char *mode)
274 275
{
    FILE* ret;
276
    double tm1, tm2;
277 278 279

    MAP_OR_FAIL(fopen);

280
    tm1 = darshan_core_wtime();
Philip Carns's avatar
Philip Carns committed
281
    ret = __real_fopen64(path, mode);
282 283
    tm2 = darshan_core_wtime();

284
    STDIO_PRE_RECORD();
285
    STDIO_RECORD_OPEN(ret, path, tm1, tm2);
286
    STDIO_POST_RECORD();
287 288 289 290

    return(ret);
}

Philip Carns's avatar
Philip Carns committed
291
FILE* DARSHAN_DECL(fdopen)(int fd, const char *mode)
292 293
{
    FILE* ret;
Philip Carns's avatar
Philip Carns committed
294
    double tm1, tm2;
295

Philip Carns's avatar
Philip Carns committed
296
    MAP_OR_FAIL(fdopen);
297

Philip Carns's avatar
Philip Carns committed
298
    tm1 = darshan_core_wtime();
Philip Carns's avatar
Philip Carns committed
299 300 301
    ret = __real_fdopen(fd, mode);
    tm2 = darshan_core_wtime();

302
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
303
    STDIO_RECORD_OPEN(ret, "UNKNOWN-FDOPEN", tm1, tm2);
304
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
305 306 307 308 309 310 311 312 313 314 315 316 317

    return(ret);
}

FILE* DARSHAN_DECL(freopen)(const char *path, const char *mode, FILE *stream)
{
    FILE* ret;
    double tm1, tm2;

    MAP_OR_FAIL(freopen);

    tm1 = darshan_core_wtime();
    ret = __real_freopen(path, mode, stream);
Philip Carns's avatar
Philip Carns committed
318 319
    tm2 = darshan_core_wtime();

320
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
321
    STDIO_RECORD_OPEN(ret, path, tm1, tm2);
322
    STDIO_POST_RECORD();
323 324 325 326

    return(ret);
}

Philip Carns's avatar
Philip Carns committed
327 328 329 330 331 332 333 334 335 336 337
FILE* DARSHAN_DECL(freopen64)(const char *path, const char *mode, FILE *stream)
{
    FILE* ret;
    double tm1, tm2;

    MAP_OR_FAIL(freopen64);

    tm1 = darshan_core_wtime();
    ret = __real_freopen64(path, mode, stream);
    tm2 = darshan_core_wtime();

338
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
339
    STDIO_RECORD_OPEN(ret, path, tm1, tm2);
340
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
341 342 343 344 345

    return(ret);
}


Philip Carns's avatar
Philip Carns committed
346 347 348 349 350 351 352 353 354 355 356
int DARSHAN_DECL(fflush)(FILE *fp)
{
    double tm1, tm2;
    int ret;

    MAP_OR_FAIL(fflush);

    tm1 = darshan_core_wtime();
    ret = __real_fflush(fp);
    tm2 = darshan_core_wtime();

357
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
358 359
    if(ret >= 0)
        STDIO_RECORD_WRITE(fp, 0, tm1, tm2, 1);
360
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
361 362 363 364

    return(ret);
}

365 366 367 368
int DARSHAN_DECL(fclose)(FILE *fp)
{
    double tm1, tm2;
    int ret;
369
    struct stdio_file_record_ref *rec_ref;
370 371 372 373 374 375 376

    MAP_OR_FAIL(fclose);

    tm1 = darshan_core_wtime();
    ret = __real_fclose(fp);
    tm2 = darshan_core_wtime();

377 378 379
    STDIO_PRE_RECORD();
    rec_ref = darshan_lookup_record_ref(stdio_runtime->stream_hash, &fp, sizeof(fp));
    if(rec_ref)
380
    {
381 382 383 384
        if(rec_ref->file_rec->fcounters[STDIO_F_CLOSE_START_TIMESTAMP] == 0 ||
         rec_ref->file_rec->fcounters[STDIO_F_CLOSE_START_TIMESTAMP] > tm1)
           rec_ref->file_rec->fcounters[STDIO_F_CLOSE_START_TIMESTAMP] = tm1;
        rec_ref->file_rec->fcounters[STDIO_F_CLOSE_END_TIMESTAMP] = tm2;
385
        DARSHAN_TIMER_INC_NO_OVERLAP(
386 387 388
            rec_ref->file_rec->fcounters[STDIO_F_META_TIME],
            tm1, tm2, rec_ref->last_meta_end);
        darshan_delete_record_ref(&(stdio_runtime->stream_hash), &fp, sizeof(fp));
389
    }
390
    STDIO_POST_RECORD();
391 392 393 394

    return(ret);
}

395 396 397 398 399 400 401 402 403 404 405
size_t DARSHAN_DECL(fwrite)(const void *ptr, size_t size, size_t nmemb, FILE *stream)
{
    size_t ret;
    double tm1, tm2;

    MAP_OR_FAIL(fwrite);

    tm1 = darshan_core_wtime();
    ret = __real_fwrite(ptr, size, nmemb, stream);
    tm2 = darshan_core_wtime();

406
    STDIO_PRE_RECORD();
407
    if(ret > 0)
Philip Carns's avatar
Philip Carns committed
408
        STDIO_RECORD_WRITE(stream, size*ret, tm1, tm2, 0);
409
    STDIO_POST_RECORD();
410 411 412 413

    return(ret);
}

Philip Carns's avatar
Philip Carns committed
414 415 416 417 418 419 420 421 422 423 424 425

int DARSHAN_DECL(fputc)(int c, FILE *stream)
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(fputc);

    tm1 = darshan_core_wtime();
    ret = __real_fputc(c, stream);
    tm2 = darshan_core_wtime();

426
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
427 428
    if(ret != EOF)
        STDIO_RECORD_WRITE(stream, 1, tm1, tm2, 0);
429
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
430 431 432 433

    return(ret);
}

Philip Carns's avatar
Philip Carns committed
434 435 436 437 438 439 440 441 442 443 444
int DARSHAN_DECL(putw)(int w, FILE *stream)
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(putw);

    tm1 = darshan_core_wtime();
    ret = __real_putw(w, stream);
    tm2 = darshan_core_wtime();

445
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
446 447
    if(ret != EOF)
        STDIO_RECORD_WRITE(stream, sizeof(int), tm1, tm2, 0);
448
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
449 450 451 452 453

    return(ret);
}


Philip Carns's avatar
Philip Carns committed
454 455 456 457 458 459 460 461 462 463 464 465

int DARSHAN_DECL(fputs)(const char *s, FILE *stream)
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(fputs);

    tm1 = darshan_core_wtime();
    ret = __real_fputs(s, stream);
    tm2 = darshan_core_wtime();

466
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
467 468
    if(ret != EOF && ret > 0)
        STDIO_RECORD_WRITE(stream, strlen(s), tm1, tm2, 0);
469
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
470 471 472 473

    return(ret);
}

Philip Carns's avatar
Philip Carns committed
474 475 476 477 478 479 480 481 482 483 484 485 486 487
int DARSHAN_DECL(vfprintf)(FILE *stream, const char *format, va_list ap)
{
    int ret;
    double tm1, tm2;
    long start_off, end_off;

    MAP_OR_FAIL(vfprintf);

    tm1 = darshan_core_wtime();
    start_off = ftell(stream);
    ret = __real_vfprintf(stream, format, ap);
    end_off = ftell(stream);
    tm2 = darshan_core_wtime();

488
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
489 490
    if(ret > 0)
        STDIO_RECORD_WRITE(stream, (end_off-start_off), tm1, tm2, 0);
491
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
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

    return(ret);
}


int DARSHAN_DECL(fprintf)(FILE *stream, const char *format, ...)
{
    int ret;
    double tm1, tm2;
    va_list ap;
    long start_off, end_off;

    MAP_OR_FAIL(vfprintf);

    tm1 = darshan_core_wtime();
    /* NOTE: we intentionally switch to vfprintf here to handle the variable
     * length arguments.
     */
    start_off = ftell(stream);
    va_start(ap, format);
    ret = __real_vfprintf(stream, format, ap);
    va_end(ap);
    end_off = ftell(stream);
    tm2 = darshan_core_wtime();

517
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
518 519
    if(ret > 0)
        STDIO_RECORD_WRITE(stream, (end_off-start_off), tm1, tm2, 0);
520
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
521 522 523 524

    return(ret);
}

525 526 527 528 529 530 531 532 533 534 535
size_t DARSHAN_DECL(fread)(void *ptr, size_t size, size_t nmemb, FILE *stream)
{
    size_t ret;
    double tm1, tm2;

    MAP_OR_FAIL(fread);

    tm1 = darshan_core_wtime();
    ret = __real_fread(ptr, size, nmemb, stream);
    tm2 = darshan_core_wtime();

536
    STDIO_PRE_RECORD();
537 538
    if(ret > 0)
        STDIO_RECORD_READ(stream, size*ret, tm1, tm2);
539
    STDIO_POST_RECORD();
540 541 542 543

    return(ret);
}

544
int DARSHAN_DECL(fgetc)(FILE *stream)
Philip Carns's avatar
Philip Carns committed
545 546 547 548 549 550 551 552 553 554
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(fgetc);

    tm1 = darshan_core_wtime();
    ret = __real_fgetc(stream);
    tm2 = darshan_core_wtime();

555
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
556 557
    if(ret != EOF)
        STDIO_RECORD_READ(stream, 1, tm1, tm2);
558
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
559 560 561 562 563

    return(ret);
}

/* NOTE: stdio.h typically implements getc() as a macro pointing to _IO_getc */
564
int DARSHAN_DECL(_IO_getc)(FILE *stream)
Philip Carns's avatar
Philip Carns committed
565 566 567 568 569 570 571 572 573 574
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(_IO_getc);

    tm1 = darshan_core_wtime();
    ret = __real__IO_getc(stream);
    tm2 = darshan_core_wtime();

575
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
576 577
    if(ret != EOF)
        STDIO_RECORD_READ(stream, 1, tm1, tm2);
578
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
579 580 581 582

    return(ret);
}

Philip Carns's avatar
Philip Carns committed
583
/* NOTE: stdio.h typically implements putc() as a macro pointing to _IO_putc */
584
int DARSHAN_DECL(_IO_putc)(int c, FILE *stream)
Philip Carns's avatar
Philip Carns committed
585 586 587 588 589 590 591 592 593 594
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(_IO_putc);

    tm1 = darshan_core_wtime();
    ret = __real__IO_putc(c, stream);
    tm2 = darshan_core_wtime();

595
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
596 597
    if(ret != EOF)
        STDIO_RECORD_WRITE(stream, 1, tm1, tm2, 0);
598
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
599 600 601

    return(ret);
}
602 603

int DARSHAN_DECL(getw)(FILE *stream)
Philip Carns's avatar
Philip Carns committed
604 605 606 607 608 609 610 611 612 613
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(getw);

    tm1 = darshan_core_wtime();
    ret = __real_getw(stream);
    tm2 = darshan_core_wtime();

614
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
615 616
    if(ret != EOF || ferror(stream) == 0)
        STDIO_RECORD_READ(stream, sizeof(int), tm1, tm2);
617
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
618 619 620 621

    return(ret);
}

Philip Carns's avatar
Philip Carns committed
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
/* NOTE: some glibc versions use __isoc99_fscanf as the underlying symbol
 * rather than fscanf
 */
int DARSHAN_DECL(__isoc99_fscanf)(FILE *stream, const char *format, ...)
{
    int ret;
    double tm1, tm2;
    va_list ap;
    long start_off, end_off;

    MAP_OR_FAIL(vfscanf);

    tm1 = darshan_core_wtime();
    /* NOTE: we intentionally switch to vfscanf here to handle the variable
     * length arguments.
     */
    start_off = ftell(stream);
    va_start(ap, format);
    ret = __real_vfscanf(stream, format, ap);
    va_end(ap);
    end_off = ftell(stream);
    tm2 = darshan_core_wtime();

645
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
646 647
    if(ret != 0)
        STDIO_RECORD_READ(stream, (end_off-start_off), tm1, tm2);
648
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
649 650 651 652

    return(ret);
}

Philip Carns's avatar
Philip Carns committed
653

654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673
int DARSHAN_DECL(fscanf)(FILE *stream, const char *format, ...)
{
    int ret;
    double tm1, tm2;
    va_list ap;
    long start_off, end_off;

    MAP_OR_FAIL(vfscanf);

    tm1 = darshan_core_wtime();
    /* NOTE: we intentionally switch to vfscanf here to handle the variable
     * length arguments.
     */
    start_off = ftell(stream);
    va_start(ap, format);
    ret = __real_vfscanf(stream, format, ap);
    va_end(ap);
    end_off = ftell(stream);
    tm2 = darshan_core_wtime();

674
    STDIO_PRE_RECORD();
675
    if(ret != 0)
Philip Carns's avatar
Philip Carns committed
676
        STDIO_RECORD_READ(stream, (end_off-start_off), tm1, tm2);
677
    STDIO_POST_RECORD();
678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695

    return(ret);
}

int DARSHAN_DECL(vfscanf)(FILE *stream, const char *format, va_list ap)
{
    int ret;
    double tm1, tm2;
    long start_off, end_off;

    MAP_OR_FAIL(vfscanf);

    tm1 = darshan_core_wtime();
    start_off = ftell(stream);
    ret = __real_vfscanf(stream, format, ap);
    end_off = ftell(stream);
    tm2 = darshan_core_wtime();

696
    STDIO_PRE_RECORD();
697 698
    if(ret != 0)
        STDIO_RECORD_READ(stream, end_off-start_off, tm1, tm2);
699
    STDIO_POST_RECORD();
700 701 702 703 704

    return(ret);
}


Philip Carns's avatar
Philip Carns committed
705 706 707 708 709 710 711 712 713 714 715
char* DARSHAN_DECL(fgets)(char *s, int size, FILE *stream)
{
    char *ret;
    double tm1, tm2;

    MAP_OR_FAIL(fgets);

    tm1 = darshan_core_wtime();
    ret = __real_fgets(s, size, stream);
    tm2 = darshan_core_wtime();

716
    STDIO_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
717 718
    if(ret != NULL)
        STDIO_RECORD_READ(stream, strlen(ret), tm1, tm2);
719
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
720 721 722 723 724

    return(ret);
}


Philip Carns's avatar
Philip Carns committed
725 726 727
void DARSHAN_DECL(rewind)(FILE *stream)
{
    double tm1, tm2;
728
    struct stdio_file_record_ref *rec_ref;
Philip Carns's avatar
Philip Carns committed
729 730 731 732 733 734 735

    MAP_OR_FAIL(rewind);

    tm1 = darshan_core_wtime();
    __real_rewind(stream);
    tm2 = darshan_core_wtime();

736 737 738
    /* NOTE: we don't use STDIO_PRE_RECORD here because there is no return
     * value in this wrapper.
     */
Philip Carns's avatar
Philip Carns committed
739
    STDIO_LOCK();
740 741 742 743 744 745 746 747 748
    if(!stdio_runtime && !instrumentation_disabled) stdio_runtime_initialize();
    if(!stdio_runtime) {
        STDIO_UNLOCK();
        return;
    }

    rec_ref = darshan_lookup_record_ref(stdio_runtime->stream_hash, &stream, sizeof(stream));

    if(rec_ref)
Philip Carns's avatar
Philip Carns committed
749
    {
750
        rec_ref->offset = 0;
Philip Carns's avatar
Philip Carns committed
751
        DARSHAN_TIMER_INC_NO_OVERLAP(
752 753 754
            rec_ref->file_rec->fcounters[STDIO_F_META_TIME],
            tm1, tm2, rec_ref->last_meta_end);
        rec_ref->file_rec->counters[STDIO_SEEKS] += 1;
Philip Carns's avatar
Philip Carns committed
755
    }
756
    STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
757 758 759 760

    return;
}

761 762 763
int DARSHAN_DECL(fseek)(FILE *stream, long offset, int whence)
{
    int ret;
764
    struct stdio_file_record_ref *rec_ref;
765 766 767 768 769 770 771 772 773 774
    double tm1, tm2;

    MAP_OR_FAIL(fseek);

    tm1 = darshan_core_wtime();
    ret = __real_fseek(stream, offset, whence);
    tm2 = darshan_core_wtime();

    if(ret >= 0)
    {
775 776 777
        STDIO_PRE_RECORD();
        rec_ref = darshan_lookup_record_ref(stdio_runtime->stream_hash, &stream, sizeof(stream));
        if(rec_ref)
Philip Carns's avatar
Philip Carns committed
778
        {
779
            rec_ref->offset = ftell(stream);
Philip Carns's avatar
Philip Carns committed
780
            DARSHAN_TIMER_INC_NO_OVERLAP(
781 782 783
                rec_ref->file_rec->fcounters[STDIO_F_META_TIME],
                tm1, tm2, rec_ref->last_meta_end);
            rec_ref->file_rec->counters[STDIO_SEEKS] += 1;
Philip Carns's avatar
Philip Carns committed
784
        }
785
        STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
786 787 788 789 790 791 792 793
    }

    return(ret);
}

int DARSHAN_DECL(fseeko)(FILE *stream, off_t offset, int whence)
{
    int ret;
794
    struct stdio_file_record_ref *rec_ref;
Philip Carns's avatar
Philip Carns committed
795 796 797 798 799 800 801 802 803 804
    double tm1, tm2;

    MAP_OR_FAIL(fseeko);

    tm1 = darshan_core_wtime();
    ret = __real_fseeko(stream, offset, whence);
    tm2 = darshan_core_wtime();

    if(ret >= 0)
    {
805 806 807
        STDIO_PRE_RECORD();
        rec_ref = darshan_lookup_record_ref(stdio_runtime->stream_hash, &stream, sizeof(stream));
        if(rec_ref)
Philip Carns's avatar
Philip Carns committed
808
        {
809
            rec_ref->offset = ftell(stream);
Philip Carns's avatar
Philip Carns committed
810
            DARSHAN_TIMER_INC_NO_OVERLAP(
811 812 813
                rec_ref->file_rec->fcounters[STDIO_F_META_TIME],
                tm1, tm2, rec_ref->last_meta_end);
            rec_ref->file_rec->counters[STDIO_SEEKS] += 1;
Philip Carns's avatar
Philip Carns committed
814
        }
815
        STDIO_POST_RECORD();
Philip Carns's avatar
Philip Carns committed
816 817 818 819 820 821 822 823
    }

    return(ret);
}

int DARSHAN_DECL(fseeko64)(FILE *stream, off_t offset, int whence)
{
    int ret;
824
    struct stdio_file_record_ref *rec_ref;
Philip Carns's avatar
Philip Carns committed
825 826 827 828 829 830 831 832 833 834
    double tm1, tm2;

    MAP_OR_FAIL(fseeko64);

    tm1 = darshan_core_wtime();
    ret = __real_fseeko64(stream, offset, whence);
    tm2 = darshan_core_wtime();

    if(ret >= 0)
    {
835 836 837
        STDIO_PRE_RECORD();
        rec_ref = darshan_lookup_record_ref(stdio_runtime->stream_hash, &stream, sizeof(stream));
        if(rec_ref)
838
        {
839
            rec_ref->offset = ftell(stream);
840
            DARSHAN_TIMER_INC_NO_OVERLAP(
841 842 843
                rec_ref->file_rec->fcounters[STDIO_F_META_TIME],
                tm1, tm2, rec_ref->last_meta_end);
            rec_ref->file_rec->counters[STDIO_SEEKS] += 1;
844
        }
845
        STDIO_POST_RECORD();
846 847 848 849 850
    }

    return(ret);
}

851 852 853
int DARSHAN_DECL(fsetpos)(FILE *stream, const fpos_t *pos)
{
    int ret;
854
    struct stdio_file_record_ref *rec_ref;
855 856 857 858 859 860 861 862 863 864
    double tm1, tm2;

    MAP_OR_FAIL(fsetpos);

    tm1 = darshan_core_wtime();
    ret = __real_fsetpos(stream, pos);
    tm2 = darshan_core_wtime();

    if(ret >= 0)
    {
865 866 867
        STDIO_PRE_RECORD();
        rec_ref = darshan_lookup_record_ref(stdio_runtime->stream_hash, &stream, sizeof(stream));
        if(rec_ref)
868
        {
869
            rec_ref->offset = ftell(stream);
870
            DARSHAN_TIMER_INC_NO_OVERLAP(
871 872 873
                rec_ref->file_rec->fcounters[STDIO_F_META_TIME],
                tm1, tm2, rec_ref->last_meta_end);
            rec_ref->file_rec->counters[STDIO_SEEKS] += 1;
874
        }
875
        STDIO_POST_RECORD();
876 877 878 879 880
    }

    return(ret);
}

881
int DARSHAN_DECL(fsetpos64)(FILE *stream, const fpos64_t *pos)
882 883
{
    int ret;
884
    struct stdio_file_record_ref *rec_ref;
885 886 887 888 889 890 891 892 893 894
    double tm1, tm2;

    MAP_OR_FAIL(fsetpos64);

    tm1 = darshan_core_wtime();
    ret = __real_fsetpos64(stream, pos);
    tm2 = darshan_core_wtime();

    if(ret >= 0)
    {
895 896 897
        STDIO_PRE_RECORD();
        rec_ref = darshan_lookup_record_ref(stdio_runtime->stream_hash, &stream, sizeof(stream));
        if(rec_ref)
898
        {
899
            rec_ref->offset = ftell(stream);
900
            DARSHAN_TIMER_INC_NO_OVERLAP(
901 902 903
                rec_ref->file_rec->fcounters[STDIO_F_META_TIME],
                tm1, tm2, rec_ref->last_meta_end);
            rec_ref->file_rec->counters[STDIO_SEEKS] += 1;
904
        }
905
        STDIO_POST_RECORD();
906 907 908 909 910 911
    }

    return(ret);
}


912 913 914 915 916 917 918
/**********************************************************
 * Internal functions for manipulating STDIO module state *
 **********************************************************/

/* initialize internal STDIO module data structures and register with darshan-core */
static void stdio_runtime_initialize()
{
919 920 921 922
    int stdio_buf_size;

    /* try to store default number of records for this module */
    stdio_buf_size = DARSHAN_DEF_MOD_REC_COUNT * sizeof(struct darshan_stdio_file);
923 924 925 926 927 928 929 930

    /* don't do anything if already initialized or instrumenation is disabled */
    if(stdio_runtime || instrumentation_disabled)
        return;

    /* register the stdio module with darshan core */
    darshan_core_register_module(
        DARSHAN_STDIO_MOD,
931 932
        &stdio_shutdown,
        &stdio_buf_size,
933
        &my_rank,
934 935
        &darshan_mem_alignment);

936 937 938 939
    /* return if darshan-core does not provide enough module memory */
    if(stdio_buf_size < sizeof(struct darshan_stdio_file))
    {
        darshan_core_unregister_module(DARSHAN_POSIX_MOD);
940
        return;
941
    }
942 943 944 945

    stdio_runtime = malloc(sizeof(*stdio_runtime));
    if(!stdio_runtime)
    {
946
        darshan_core_unregister_module(DARSHAN_STDIO_MOD);
947 948
        return;
    }
949
    memset(stdio_runtime, 0, sizeof(*stdio_runtime));
950 951
}

952 953 954
/************************************************************************
 * Functions exported by this module for coordinating with darshan-core *
 ************************************************************************/
955

956 957
static void stdio_record_reduction_op(void* infile_v, void* inoutfile_v,
    int *len, MPI_Datatype *datatype)
958
{
959 960 961 962
    struct darshan_stdio_file tmp_file;
    struct darshan_stdio_file *infile = infile_v;
    struct darshan_stdio_file *inoutfile = inoutfile_v;
    int i, j;
963

964
    assert(stdio_runtime);
965

966
    for(i=0; i<*len; i++)
967
    {
968 969 970
        memset(&tmp_file, 0, sizeof(struct darshan_stdio_file));
        tmp_file.base_rec.id = infile->base_rec.id;
        tmp_file.base_rec.rank = -1;
971

972 973 974 975 976 977 978 979 980 981 982 983 984 985
        /* sum */
        for(j=STDIO_OPENS; j<=STDIO_BYTES_READ; j++)
        {
            tmp_file.counters[j] = infile->counters[j] + inoutfile->counters[j];
        }
        
        /* max */
        for(j=STDIO_MAX_BYTE_READ; j<=STDIO_MAX_BYTE_WRITTEN; j++)
        {
            if(infile->counters[j] > inoutfile->counters[j])
                tmp_file.counters[j] = infile->counters[j];
            else
                tmp_file.counters[j] = inoutfile->counters[j];
        }
986

987 988 989 990 991
        /* sum */
        for(j=STDIO_F_META_TIME; j<=STDIO_F_READ_TIME; j++)
        {
            tmp_file.fcounters[j] = infile->fcounters[j] + inoutfile->fcounters[j];
        }
992

993 994 995 996 997 998 999 1000 1001
        /* min non-zero (if available) value */
        for(j=STDIO_F_OPEN_START_TIMESTAMP; j<=STDIO_F_READ_START_TIMESTAMP; j++)
        {
            if((infile->fcounters[j] < inoutfile->fcounters[j] &&
               infile->fcounters[j] > 0) || inoutfile->fcounters[j] == 0) 
                tmp_file.fcounters[j] = infile->fcounters[j];
            else
                tmp_file.fcounters[j] = inoutfile->fcounters[j];
        }
1002

1003 1004 1005 1006 1007 1008 1009 1010
        /* max */
        for(j=STDIO_F_OPEN_END_TIMESTAMP; j<=STDIO_F_READ_END_TIMESTAMP; j++)
        {
            if(infile->fcounters[j] > inoutfile->fcounters[j])
                tmp_file.fcounters[j] = infile->fcounters[j];
            else
                tmp_file.fcounters[j] = inoutfile->fcounters[j];
        }
1011

1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
        /* min (zeroes are ok here; some procs don't do I/O) */
        if(infile->fcounters[STDIO_F_FASTEST_RANK_TIME] <
           inoutfile->fcounters[STDIO_F_FASTEST_RANK_TIME])
        {
            tmp_file.counters[STDIO_FASTEST_RANK] =
                infile->counters[STDIO_FASTEST_RANK];
            tmp_file.counters[STDIO_FASTEST_RANK_BYTES] =
                infile->counters[STDIO_FASTEST_RANK_BYTES];
            tmp_file.fcounters[STDIO_F_FASTEST_RANK_TIME] =
                infile->fcounters[STDIO_F_FASTEST_RANK_TIME];
        }
        else
        {
            tmp_file.counters[STDIO_FASTEST_RANK] =
                inoutfile->counters[STDIO_FASTEST_RANK];
            tmp_file.counters[STDIO_FASTEST_RANK_BYTES] =
                inoutfile->counters[STDIO_FASTEST_RANK_BYTES];
            tmp_file.fcounters[STDIO_F_FASTEST_RANK_TIME] =
                inoutfile->fcounters[STDIO_F_FASTEST_RANK_TIME];
        }

        /* max */
        if(infile->fcounters[STDIO_F_SLOWEST_RANK_TIME] >
           inoutfile->fcounters[STDIO_F_SLOWEST_RANK_TIME])
        {
            tmp_file.counters[STDIO_SLOWEST_RANK] =
                infile->counters[STDIO_SLOWEST_RANK];
            tmp_file.counters[STDIO_SLOWEST_RANK_BYTES] =
                infile->counters[STDIO_SLOWEST_RANK_BYTES];
            tmp_file.fcounters[STDIO_F_SLOWEST_RANK_TIME] =
                infile->fcounters[STDIO_F_SLOWEST_RANK_TIME];
        }
        else
        {
            tmp_file.counters[STDIO_SLOWEST_RANK] =
                inoutfile->counters[STDIO_SLOWEST_RANK];
            tmp_file.counters[STDIO_SLOWEST_RANK_BYTES] =
                inoutfile->counters[STDIO_SLOWEST_RANK_BYTES];
            tmp_file.fcounters[STDIO_F_SLOWEST_RANK_TIME] =
                inoutfile->fcounters[STDIO_F_SLOWEST_RANK_TIME];
        }

1054 1055 1056 1057
        /* update pointers */
        *inoutfile = tmp_file;
        inoutfile++;
        infile++;
1058 1059 1060 1061 1062
    }

    return;
}

1063
static void stdio_shutdown(
1064 1065 1066 1067 1068 1069
    MPI_Comm mod_comm,
    darshan_record_id *shared_recs,
    int shared_rec_count,
    void **stdio_buf,
    int *stdio_buf_sz)
{
1070 1071
    struct stdio_file_record_ref *rec_ref;
    struct darshan_stdio_file *stdio_rec_buf = *(struct darshan_stdio_file **)stdio_buf;
1072
    int i;
1073 1074
    struct darshan_stdio_file *red_send_buf = NULL;
    struct darshan_stdio_file *red_recv_buf = NULL;
1075 1076
    MPI_Datatype red_type;
    MPI_Op red_op;
1077
    int stdio_rec_count;
1078
    double stdio_time;
1079

1080
    STDIO_LOCK();
1081
    assert(stdio_runtime);
1082
    stdio_rec_count = stdio_runtime->file_rec_count;
1083

1084 1085 1086 1087 1088 1089 1090 1091 1092
    /* if there are globally shared files, do a shared file reduction */
    /* NOTE: the shared file reduction is also skipped if the 
     * DARSHAN_DISABLE_SHARED_REDUCTION environment variable is set.
     */
    if(shared_rec_count && !getenv("DARSHAN_DISABLE_SHARED_REDUCTION"))
    {
        /* necessary initialization of shared records */
        for(i = 0; i < shared_rec_count; i++)
        {
1093 1094 1095
            rec_ref = darshan_lookup_record_ref(stdio_runtime->rec_id_hash,
                &shared_recs[i], sizeof(darshan_record_id));
            assert(rec_ref);
1096

1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
            stdio_time =
                rec_ref->file_rec->fcounters[STDIO_F_READ_TIME] +
                rec_ref->file_rec->fcounters[STDIO_F_WRITE_TIME] +
                rec_ref->file_rec->fcounters[STDIO_F_META_TIME];

            /* initialize fastest/slowest info prior to the reduction */
            rec_ref->file_rec->counters[STDIO_FASTEST_RANK] =
                rec_ref->file_rec->base_rec.rank;
            rec_ref->file_rec->counters[STDIO_FASTEST_RANK_BYTES] =
                rec_ref->file_rec->counters[STDIO_BYTES_READ] +
                rec_ref->file_rec->counters[STDIO_BYTES_WRITTEN];
            rec_ref->file_rec->fcounters[STDIO_F_FASTEST_RANK_TIME] =
                stdio_time;

            /* until reduction occurs, we assume that this rank is both
             * the fastest and slowest. It is up to the reduction operator
             * to find the true min and max.
             */
            rec_ref->file_rec->counters[STDIO_SLOWEST_RANK] =
                rec_ref->file_rec->counters[STDIO_FASTEST_RANK];
            rec_ref->file_rec->counters[STDIO_SLOWEST_RANK_BYTES] =
                rec_ref->file_rec->counters[STDIO_FASTEST_RANK_BYTES];
            rec_ref->file_rec->fcounters[STDIO_F_SLOWEST_RANK_TIME] =
                rec_ref->file_rec->fcounters[STDIO_F_FASTEST_RANK_TIME];

1122
            rec_ref->file_rec->base_rec.rank = -1;
1123 1124 1125 1126 1127 1128
        }

        /* sort the array of files descending by rank so that we get all of the 
         * shared files (marked by rank -1) in a contiguous portion at end 
         * of the array
         */
1129
        darshan_record_sort(stdio_rec_buf, stdio_rec_count, sizeof(struct darshan_stdio_file));
1130 1131

        /* make *send_buf point to the shared files at the end of sorted array */
1132
        red_send_buf = &(stdio_rec_buf[stdio_rec_count-shared_rec_count]);
1133 1134 1135 1136

        /* allocate memory for the reduction output on rank 0 */
        if(my_rank == 0)
        {
1137
            red_recv_buf = malloc(shared_rec_count * sizeof(struct darshan_stdio_file));
1138 1139 1140 1141 1142 1143 1144 1145 1146
            if(!red_recv_buf)
            {
                return;
            }
        }

        /* construct a datatype for a STDIO file record.  This is serving no purpose
         * except to make sure we can do a reduction on proper boundaries
         */
1147
        DARSHAN_MPI_CALL(PMPI_Type_contiguous)(sizeof(struct darshan_stdio_file),
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
            MPI_BYTE, &red_type);
        DARSHAN_MPI_CALL(PMPI_Type_commit)(&red_type);

        /* register a STDIO file record reduction operator */
        DARSHAN_MPI_CALL(PMPI_Op_create)(stdio_record_reduction_op, 1, &red_op);

        /* reduce shared STDIO file records */
        DARSHAN_MPI_CALL(PMPI_Reduce)(red_send_buf, red_recv_buf,
            shared_rec_count, red_type, red_op, 0, mod_comm);

1158 1159 1160 1161
        /* get the time and byte variances for shared files */
        stdio_shared_record_variance(mod_comm, red_send_buf, red_recv_buf,
            shared_rec_count);

1162 1163 1164
        /* clean up reduction state */
        if(my_rank == 0)
        {
1165 1166 1167
            int tmp_ndx = stdio_rec_count - shared_rec_count;
            memcpy(&(stdio_rec_buf[tmp_ndx]), red_recv_buf,
                shared_rec_count * sizeof(struct darshan_stdio_file));
1168 1169 1170 1171
            free(red_recv_buf);
        }
        else
        {
1172
            stdio_rec_count -= shared_rec_count;
1173 1174 1175 1176 1177 1178
        }

        DARSHAN_MPI_CALL(PMPI_Type_free)(&red_type);
        DARSHAN_MPI_CALL(PMPI_Op_free)(&red_op);
    }

1179 1180
    /* update output buffer size to account for shared file reduction */
    *stdio_buf_sz = stdio_rec_count * sizeof(struct darshan_stdio_file);
1181

1182 1183
    /* shutdown internal structures used for instrumenting */
    stdio_cleanup_runtime();
1184

1185 1186
    /* disable further instrumentation */
    instrumentation_disabled = 1;
1187

1188 1189 1190
    STDIO_UNLOCK();
    
    return;
1191 1192
}

1193 1194
static struct stdio_file_record_ref *stdio_track_new_file_record(
    darshan_record_id rec_id, const char *path)
1195
{
1196 1197 1198
    struct darshan_stdio_file *file_rec = NULL;
    struct stdio_file_record_ref *rec_ref = NULL;
    int ret;
1199

1200 1201 1202 1203
    rec_ref = malloc(sizeof(*rec_ref));
    if(!rec_ref)
        return(NULL);
    memset(rec_ref, 0, sizeof(*rec_ref));
1204

1205 1206 1207 1208
    /* add a reference to this file record based on record id */
    ret = darshan_add_record_ref(&(stdio_runtime->rec_id_hash), &rec_id,
        sizeof(darshan_record_id), rec_ref);
    if(ret == 0)
1209
    {
1210 1211 1212
        free(rec_ref);
        return(NULL);
    }
1213

1214 1215 1216 1217 1218 1219
    /* register the actual file record with darshan-core so it is persisted
     * in the log file
     */
    file_rec = darshan_core_register_record(
        rec_id,
        path,
Philip Carns's avatar
Philip Carns committed
1220
        DARSHAN_STDIO_MOD,
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
        sizeof(struct darshan_stdio_file),
        NULL);

    if(!file_rec)
    {
        darshan_delete_record_ref(&(stdio_runtime->rec_id_hash),
            &rec_id, sizeof(darshan_record_id));
        free(rec_ref);
        return(NULL);
    }
1231

1232 1233 1234 1235 1236
    /* registering this file record was successful, so initialize some fields */
    file_rec->base_rec.id = rec_id;
    file_rec->base_rec.rank = my_rank;
    rec_ref->file_rec = file_rec;
    stdio_runtime->file_rec_count++;
1237

1238
    return(rec_ref);
1239 1240 1241

}

1242
static void stdio_cleanup_runtime()
1243
{
1244 1245
    darshan_clear_record_refs(&(stdio_runtime->stream_hash), 0);
    darshan_clear_record_refs(&(stdio_runtime->rec_id_hash), 1);
1246 1247 1248

    free(stdio_runtime);
    stdio_runtime = NULL;
1249

1250 1251 1252
    return;
}

1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335
static void stdio_shared_record_variance(MPI_Comm mod_comm,
    struct darshan_stdio_file *inrec_array, struct darshan_stdio_file *outrec_array,
    int shared_rec_count)
{
    MPI_Datatype var_dt;
    MPI_Op var_op;
    int i;
    struct darshan_variance_dt *var_send_buf = NULL;
    struct darshan_variance_dt *var_recv_buf = NULL;

    DARSHAN_MPI_CALL(PMPI_Type_contiguous)(sizeof(struct darshan_variance_dt),
        MPI_BYTE, &var_dt);
    DARSHAN_MPI_CALL(PMPI_Type_commit)(&var_dt);

    DARSHAN_MPI_CALL(PMPI_Op_create)(darshan_variance_reduce, 1, &var_op);

    var_send_buf = malloc(shared_rec_count * sizeof(struct darshan_variance_dt));
    if(!var_send_buf)
        return;

    if(my_rank == 0)
    {
        var_recv_buf = malloc(shared_rec_count * sizeof(struct darshan_variance_dt));

        if(!var_recv_buf)
            return;
    }

    /* get total i/o time variances for shared records */

    for(i=0; i<shared_rec_count; i++)
    {
        var_send_buf[i].n = 1;
        var_send_buf[i].S = 0;
        var_send_buf[i].T = inrec_array[i].fcounters[STDIO_F_READ_TIME] +
                            inrec_array[i].fcounters[STDIO_F_WRITE_TIME] +
                            inrec_array[i].fcounters[STDIO_F_META_TIME];
    }

    DARSHAN_MPI_CALL(PMPI_Reduce)(var_send_buf, var_recv_buf, shared_rec_count,
        var_dt, var_op, 0, mod_comm);

    if(my_rank == 0)
    {
        for(i=0; i<shared_rec_count; i++)
        {
            outrec_array[i].fcounters[STDIO_F_VARIANCE_RANK_TIME] =
                (var_recv_buf[i].S / var_recv_buf[i].n);
        }
    }

    /* get total bytes moved variances for shared records */

    for(i=0; i<shared_rec_count; i++)
    {
        var_send_buf[i].n = 1;
        var_send_buf[i].S = 0;
        var_send_buf[i].T = (double)
                            inrec_array[i].counters[STDIO_BYTES_READ] +
                            inrec_array[i].counters[STDIO_BYTES_WRITTEN];
    }

    DARSHAN_MPI_CALL(PMPI_Reduce)(var_send_buf, var_recv_buf, shared_rec_count,
        var_dt, var_op, 0, mod_comm);

    if(my_rank == 0)
    {
        for(i=0; i<shared_rec_count; i++)
        {
            outrec_array[i].fcounters[STDIO_F_VARIANCE_RANK_BYTES] =
                (var_recv_buf[i].S / var_recv_buf[i].n);
        }
    }

    DARSHAN_MPI_CALL(PMPI_Type_free)(&var_dt);
    DARSHAN_MPI_CALL(PMPI_Op_free)(&var_op);
    free(var_send_buf);
    free(var_recv_buf);

    return;
}


1336 1337 1338 1339 1340 1341 1342 1343
/*
 * Local variables:
 *  c-indent-level: 4
 *  c-basic-offset: 4
 * End:
 *
 * vim: ts=8 sts=4 sw=4 expandtab
 */