darshan-posix.c 53.1 KB
Newer Older
1
2
3
4
5
/*
 *  (C) 2009 by Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 */

6
#include "darshan-runtime-config.h"
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#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>
21
#include <libgen.h>
22
#include <limits.h>
Philip Carns's avatar
Philip Carns committed
23
#include <aio.h>
24
25
#define __USE_GNU
#include <pthread.h>
26
27
28

#include "darshan.h"

29
#ifndef HAVE_OFF64_T
30
31
32
typedef int64_t off64_t;
#endif

33
34
extern char* __progname_full;

35
#ifdef DARSHAN_PRELOAD
36
37
38
#define __USE_GNU
#include <dlfcn.h>
#include <stdlib.h>
39

40
41
42
43
44
#define DARSHAN_FORWARD_DECL(name,ret,args) \
  ret (*__real_ ## name)args = NULL;

#define DARSHAN_DECL(__name) __name

45
46
47
48
49
50
51
52
53
54
55
56
57
#define DARSHAN_MPI_CALL(func) __real_ ## func

#define MAP_OR_FAIL(func) \
    if (!(__real_ ## func)) \
    { \
        __real_ ## func = dlsym(RTLD_NEXT, #func); \
        if(!(__real_ ## func)) { \
           fprintf(stderr, "Darshan failed to map symbol: %s\n", #func); \
           exit(1); \
       } \
    }


58
extern double (*__real_PMPI_Wtime)(void);
59

60
61
62
63
64
65
66
#else

#define DARSHAN_FORWARD_DECL(name,ret,args) \
  extern ret __real_ ## name args;

#define DARSHAN_DECL(__name) __wrap_ ## __name

67
68
69
70
#define MAP_OR_FAIL(func)

#define DARSHAN_MPI_CALL(func) func

71
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
100
101
102
103
104
#endif

DARSHAN_FORWARD_DECL(creat, int, (const char* path, mode_t mode));
DARSHAN_FORWARD_DECL(creat64, int, (const char* path, mode_t mode));
DARSHAN_FORWARD_DECL(open, int, (const char *path, int flags, ...));
DARSHAN_FORWARD_DECL(open64, int, (const char *path, int flags, ...));
DARSHAN_FORWARD_DECL(close, int, (int fd));
DARSHAN_FORWARD_DECL(write, ssize_t, (int fd, const void *buf, size_t count));
DARSHAN_FORWARD_DECL(read, ssize_t, (int fd, void *buf, size_t count));
DARSHAN_FORWARD_DECL(lseek, off_t, (int fd, off_t offset, int whence));
DARSHAN_FORWARD_DECL(lseek64, off64_t, (int fd, off64_t offset, int whence));
DARSHAN_FORWARD_DECL(pread, ssize_t, (int fd, void *buf, size_t count, off_t offset));
DARSHAN_FORWARD_DECL(pread64, ssize_t, (int fd, void *buf, size_t count, off64_t offset));
DARSHAN_FORWARD_DECL(pwrite, ssize_t, (int fd, const void *buf, size_t count, off_t offset));
DARSHAN_FORWARD_DECL(pwrite64, ssize_t, (int fd, const void *buf, size_t count, off64_t offset
));
DARSHAN_FORWARD_DECL(readv, ssize_t, (int fd, const struct iovec *iov, int iovcnt));
DARSHAN_FORWARD_DECL(writev, ssize_t, (int fd, const struct iovec *iov, int iovcnt));
DARSHAN_FORWARD_DECL(__fxstat, int, (int vers, int fd, struct stat *buf));
DARSHAN_FORWARD_DECL(__fxstat64, int, (int vers, int fd, struct stat64 *buf));
DARSHAN_FORWARD_DECL(__lxstat, int, (int vers, const char* path, struct stat *buf));
DARSHAN_FORWARD_DECL(__lxstat64, int, (int vers, const char* path, struct stat64 *buf));
DARSHAN_FORWARD_DECL(__xstat, int, (int vers, const char* path, struct stat *buf));
DARSHAN_FORWARD_DECL(__xstat64, int, (int vers, const char* path, struct stat64 *buf));
DARSHAN_FORWARD_DECL(mmap, void*, (void *addr, size_t length, int prot, int flags, int fd, off_t offset));
DARSHAN_FORWARD_DECL(mmap64, void*, (void *addr, size_t length, int prot, int flags, int fd, off64_t offset));
DARSHAN_FORWARD_DECL(fopen, FILE*, (const char *path, const char *mode));
DARSHAN_FORWARD_DECL(fopen64, FILE*, (const char *path, const char *mode));
DARSHAN_FORWARD_DECL(fclose, int, (FILE *fp));
DARSHAN_FORWARD_DECL(fread, size_t, (void *ptr, size_t size, size_t nmemb, FILE *stream));
DARSHAN_FORWARD_DECL(fwrite, size_t, (const void *ptr, size_t size, size_t nmemb, FILE *stream));
DARSHAN_FORWARD_DECL(fseek, int, (FILE *stream, long offset, int whence));
DARSHAN_FORWARD_DECL(fsync, int, (int fd));
DARSHAN_FORWARD_DECL(fdatasync, int, (int fd));
Philip Carns's avatar
Philip Carns committed
105
106
107
108
109
110
111
112
DARSHAN_FORWARD_DECL(aio_read, int, (struct aiocb *aiocbp));
DARSHAN_FORWARD_DECL(aio_read64, int, (struct aiocb *aiocbp));
DARSHAN_FORWARD_DECL(aio_write, int, (struct aiocb *aiocbp));
DARSHAN_FORWARD_DECL(aio_write64, int, (struct aiocb *aiocbp));
DARSHAN_FORWARD_DECL(lio_listio, int, (int mode, struct aiocb *const aiocb_list[], int nitems, struct sigevent *sevp));
DARSHAN_FORWARD_DECL(lio_listio64, int, (int mode, struct aiocb *const aiocb_list[], int nitems, struct sigevent *sevp));
DARSHAN_FORWARD_DECL(aio_return, ssize_t, (struct aiocb *aiocbp));
DARSHAN_FORWARD_DECL(aio_return64, ssize_t, (struct aiocb *aiocbp));
113

114
pthread_mutex_t cp_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
115
116
struct darshan_job_runtime* darshan_global_job = NULL;
static int my_rank = -1;
117
static struct stat64 cp_stat_buf;
118
static int darshan_mem_alignment = 1;
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

/* these are paths that we will not trace */
static char* exclusions[] = {
"/etc/",
"/dev/",
"/usr/",
"/bin/",
"/boot/",
"/lib/",
"/opt/",
"/sbin/",
"/sys/",
"/proc/",
NULL
};

135
136
static double posix_wtime(void);

137
138
static void cp_access_counter(struct darshan_file_runtime* file, ssize_t size,     enum cp_counter_type type);

139
140
141
142
143
144
145
146
static struct darshan_file_ref* ref_by_handle(
    const void* handle,
    int handle_sz,
    enum darshan_handle_type handle_type);

static struct darshan_file_runtime* darshan_file_by_fd(int fd);
static void darshan_file_close_fd(int fd);
static struct darshan_file_runtime* darshan_file_by_name_setfd(const char* name, int fd);
147
static char* clean_path(const char* path);
148

Philip Carns's avatar
Philip Carns committed
149
#define CP_RECORD_WRITE(__ret, __fd, __count, __pwrite_flag, __pwrite_offset, __aligned, __stream_flag, __tm1, __tm2) do{ \
150
    size_t stride; \
Philip Carns's avatar
Philip Carns committed
151
    int64_t this_offset; \
152
153
    int64_t file_alignment; \
    struct darshan_file_runtime* file; \
154
    double __elapsed = __tm2-__tm1; \
155
156
157
    if(__ret < 0) break; \
    file = darshan_file_by_fd(__fd); \
    if(!file) break; \
Philip Carns's avatar
Philip Carns committed
158
159
160
161
    if(__pwrite_flag) \
        this_offset = __pwrite_offset; \
    else \
        this_offset = file->offset; \
162
    file_alignment = CP_VALUE(file, CP_FILE_ALIGNMENT); \
Philip Carns's avatar
Philip Carns committed
163
    if(this_offset > file->last_byte_written) \
164
        CP_INC(file, CP_SEQ_WRITES, 1); \
Philip Carns's avatar
Philip Carns committed
165
    if(this_offset == (file->last_byte_written + 1)) \
166
        CP_INC(file, CP_CONSEC_WRITES, 1); \
Philip Carns's avatar
Philip Carns committed
167
    if(this_offset > 0 && this_offset > file->last_byte_written \
168
        && file->last_byte_written != 0) \
Philip Carns's avatar
Philip Carns committed
169
        stride = this_offset - file->last_byte_written - 1; \
170
171
    else \
        stride = 0; \
Philip Carns's avatar
Philip Carns committed
172
173
174
    file->last_byte_written = this_offset + __ret - 1; \
    file->offset = this_offset + __ret; \
    CP_MAX(file, CP_MAX_BYTE_WRITTEN, (this_offset + __ret -1)); \
175
176
177
178
179
180
181
182
183
    CP_INC(file, CP_BYTES_WRITTEN, __ret); \
    if(__stream_flag) \
        CP_INC(file, CP_POSIX_FWRITES, 1); \
    else \
        CP_INC(file, CP_POSIX_WRITES, 1); \
    CP_BUCKET_INC(file, CP_SIZE_WRITE_0_100, __ret); \
    cp_access_counter(file, stride, CP_COUNTER_STRIDE); \
    if(!__aligned) \
        CP_INC(file, CP_MEM_NOT_ALIGNED, 1); \
Philip Carns's avatar
Philip Carns committed
184
    if(file_alignment > 0 && (this_offset % file_alignment) != 0) \
185
186
187
188
189
        CP_INC(file, CP_FILE_NOT_ALIGNED, 1); \
    cp_access_counter(file, __ret, CP_COUNTER_ACCESS); \
    if(file->last_io_type == CP_READ) \
        CP_INC(file, CP_RW_SWITCHES, 1); \
    file->last_io_type = CP_WRITE; \
190
    CP_F_INC_NO_OVERLAP(file, __tm1, __tm2, file->last_posix_write_end, CP_F_POSIX_WRITE_TIME); \
191
192
193
    if(CP_F_VALUE(file, CP_F_WRITE_START_TIMESTAMP) == 0) \
        CP_F_SET(file, CP_F_WRITE_START_TIMESTAMP, __tm1); \
    CP_F_SET(file, CP_F_WRITE_END_TIMESTAMP, __tm2); \
194
195
196
    if(CP_F_VALUE(file, CP_F_MAX_WRITE_TIME) < __elapsed){ \
        CP_F_SET(file, CP_F_MAX_WRITE_TIME, __elapsed); \
        CP_SET(file, CP_MAX_WRITE_TIME_SIZE, __ret); } \
197
198
} while(0)

199
#define CP_RECORD_READ(__ret, __fd, __count, __pread_flag, __pread_offset, __aligned, __stream_flag, __tm1, __tm2) do{ \
200
    size_t stride; \
201
    int64_t this_offset; \
202
203
    struct darshan_file_runtime* file; \
    int64_t file_alignment; \
204
    double __elapsed = __tm2-__tm1; \
205
206
207
    if(__ret < 0) break; \
    file = darshan_file_by_fd(__fd); \
    if(!file) break; \
208
209
210
211
    if(__pread_flag)\
        this_offset = __pread_offset; \
    else \
        this_offset = file->offset; \
212
    file_alignment = CP_VALUE(file, CP_FILE_ALIGNMENT); \
213
    if(this_offset > file->last_byte_read) \
214
        CP_INC(file, CP_SEQ_READS, 1); \
215
    if(this_offset == (file->last_byte_read + 1)) \
216
        CP_INC(file, CP_CONSEC_READS, 1); \
217
    if(this_offset > 0 && this_offset > file->last_byte_read \
218
        && file->last_byte_read != 0) \
219
        stride = this_offset - file->last_byte_read - 1; \
220
221
    else \
        stride = 0; \
222
223
224
    file->last_byte_read = this_offset + __ret - 1; \
    CP_MAX(file, CP_MAX_BYTE_READ, (this_offset + __ret -1)); \
    file->offset = this_offset + __ret; \
225
226
227
228
229
230
231
232
233
    CP_INC(file, CP_BYTES_READ, __ret); \
    if(__stream_flag)\
        CP_INC(file, CP_POSIX_FREADS, 1); \
    else\
        CP_INC(file, CP_POSIX_READS, 1); \
    CP_BUCKET_INC(file, CP_SIZE_READ_0_100, __ret); \
    cp_access_counter(file, stride, CP_COUNTER_STRIDE); \
    if(!__aligned) \
        CP_INC(file, CP_MEM_NOT_ALIGNED, 1); \
Philip Carns's avatar
Philip Carns committed
234
    if(file_alignment > 0 && (this_offset % file_alignment) != 0) \
235
236
237
238
239
        CP_INC(file, CP_FILE_NOT_ALIGNED, 1); \
    cp_access_counter(file, __ret, CP_COUNTER_ACCESS); \
    if(file->last_io_type == CP_WRITE) \
        CP_INC(file, CP_RW_SWITCHES, 1); \
    file->last_io_type = CP_READ; \
240
    CP_F_INC_NO_OVERLAP(file, __tm1, __tm2, file->last_posix_read_end, CP_F_POSIX_READ_TIME); \
241
242
243
    if(CP_F_VALUE(file, CP_F_READ_START_TIMESTAMP) == 0) \
        CP_F_SET(file, CP_F_READ_START_TIMESTAMP, __tm1); \
    CP_F_SET(file, CP_F_READ_END_TIMESTAMP, __tm2); \
244
245
246
    if(CP_F_VALUE(file, CP_F_MAX_READ_TIME) < __elapsed){ \
        CP_F_SET(file, CP_F_MAX_READ_TIME, __elapsed); \
        CP_SET(file, CP_MAX_READ_TIME_SIZE, __ret); } \
247
248
} while(0)

249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
#define CP_LOOKUP_RECORD_STAT(__path, __statbuf, __tm1, __tm2) do { \
    char* exclude; \
    int tmp_index = 0; \
    struct darshan_file_runtime* file; \
    while((exclude = exclusions[tmp_index])) { \
        if(!(strncmp(exclude, __path, strlen(exclude)))) \
            break; \
        tmp_index++; \
    } \
    if(exclude) break; \
    file = darshan_file_by_name(__path); \
    if (file) \
    { \
        CP_RECORD_STAT(file, __statbuf, __tm1, __tm2); \
    } \
} while(0)

    
267
#define CP_RECORD_STAT(__file, __statbuf, __tm1, __tm2) do { \
268
    if(!CP_VALUE((__file), CP_POSIX_STATS) && !CP_VALUE((__file), CP_POSIX_OPENS)){ \
269
270
271
272
        CP_SET((__file), CP_FILE_ALIGNMENT, (__statbuf)->st_blksize); \
        CP_SET((__file), CP_SIZE_AT_OPEN, (__statbuf)->st_size); \
    }\
    (__file)->log_file->rank = my_rank; \
273
    CP_F_INC_NO_OVERLAP(file, __tm1, __tm2, file->last_posix_meta_end, CP_F_POSIX_META_TIME); \
274
275
276
    CP_INC(__file, CP_POSIX_STATS, 1); \
} while(0)

Philip Carns's avatar
Philip Carns committed
277
#ifdef __CP_STAT_AT_OPEN
278
#define CP_STAT_FILE(_f, _p, _r) do { \
279
    if(!CP_VALUE((_f), CP_POSIX_STATS) && !CP_VALUE((_f), CP_POSIX_OPENS)){ \
280
        if(fstat64(_r, &cp_stat_buf) == 0) { \
Philip Carns's avatar
Philip Carns committed
281
282
283
284
285
286
            CP_SET(_f, CP_FILE_ALIGNMENT, cp_stat_buf.st_blksize); \
            CP_SET(_f, CP_SIZE_AT_OPEN, cp_stat_buf.st_size); \
        }\
    }\
}while(0)
#else
287
#define CP_STAT_FILE(_f, _p, _r) do { }while(0)
Philip Carns's avatar
Philip Carns committed
288
289
#endif

290
291
292
293
294
295
296
297
298
299
300
#define CP_RECORD_OPEN(__ret, __path, __mode, __stream_flag, __tm1, __tm2) do { \
    struct darshan_file_runtime* file; \
    char* exclude; \
    int tmp_index = 0; \
    if(__ret < 0) break; \
    while((exclude = exclusions[tmp_index])) { \
        if(!(strncmp(exclude, __path, strlen(exclude)))) \
            break; \
        tmp_index++; \
    } \
    if(exclude) break; \
301
    file = darshan_file_by_name_setfd(__path, __ret); \
302
    if(!file) break; \
303
    CP_STAT_FILE(file, __path, __ret); \
304
305
306
307
308
309
310
311
312
313
314
    file->log_file->rank = my_rank; \
    if(__mode) \
        CP_SET(file, CP_MODE, __mode); \
    file->offset = 0; \
    file->last_byte_written = 0; \
    file->last_byte_read = 0; \
    if(__stream_flag)\
        CP_INC(file, CP_POSIX_FOPENS, 1); \
    else \
        CP_INC(file, CP_POSIX_OPENS, 1); \
    if(CP_F_VALUE(file, CP_F_OPEN_TIMESTAMP) == 0) \
315
        CP_F_SET(file, CP_F_OPEN_TIMESTAMP, posix_wtime()); \
316
    CP_F_INC_NO_OVERLAP(file, __tm1, __tm2, file->last_posix_meta_end, CP_F_POSIX_META_TIME); \
317
318
} while (0)

319
int DARSHAN_DECL(close)(int fd)
320
321
322
323
324
325
{
    struct darshan_file_runtime* file;
    int tmp_fd = fd;
    double tm1, tm2;
    int ret;

326
327
    MAP_OR_FAIL(close);

328
329
330
331
332
333
334
335
336
337
    tm1 = darshan_wtime();
    ret = __real_close(fd);
    tm2 = darshan_wtime();

    CP_LOCK();
    file = darshan_file_by_fd(tmp_fd);
    if(file)
    {
        file->last_byte_written = 0;
        file->last_byte_read = 0;
338
        CP_F_SET(file, CP_F_CLOSE_TIMESTAMP, posix_wtime());
339
        CP_F_INC_NO_OVERLAP(file, tm1, tm2, file->last_posix_meta_end, CP_F_POSIX_META_TIME);
340
        darshan_file_close_fd(tmp_fd);
341
342
343
344
345
346
    }
    CP_UNLOCK();

    return(ret);
}

347
int DARSHAN_DECL(fclose)(FILE *fp)
348
349
350
351
352
353
{
    struct darshan_file_runtime* file;
    int tmp_fd = fileno(fp);
    double tm1, tm2;
    int ret;

354
355
    MAP_OR_FAIL(fclose);

356
357
358
359
360
361
362
363
364
365
    tm1 = darshan_wtime();
    ret = __real_fclose(fp);
    tm2 = darshan_wtime();
    
    CP_LOCK();
    file = darshan_file_by_fd(tmp_fd);
    if(file)
    {
        file->last_byte_written = 0;
        file->last_byte_read = 0;
366
        CP_F_SET(file, CP_F_CLOSE_TIMESTAMP, posix_wtime());
367
        CP_F_INC_NO_OVERLAP(file, tm1, tm2, file->last_posix_meta_end, CP_F_POSIX_META_TIME);
368
        darshan_file_close_fd(tmp_fd);
369
370
371
372
373
374
375
    }
    CP_UNLOCK();

    return(ret);
}


376
int DARSHAN_DECL(fsync)(int fd)
377
378
379
380
381
{
    int ret;
    struct darshan_file_runtime* file;
    double tm1, tm2;

382
383
    MAP_OR_FAIL(fsync);

384
385
386
387
388
389
390
391
392
393
394
    tm1 = darshan_wtime();
    ret = __real_fsync(fd);
    tm2 = darshan_wtime();

    if(ret < 0)
        return(ret);

    CP_LOCK();
    file = darshan_file_by_fd(fd);
    if(file)
    {
395
        CP_F_INC_NO_OVERLAP(file, tm1, tm2, file->last_posix_write_end, CP_F_POSIX_WRITE_TIME); \
396
397
398
399
400
401
402
        CP_INC(file, CP_POSIX_FSYNCS, 1);
    }
    CP_UNLOCK();

    return(ret);
}

403
int DARSHAN_DECL(fdatasync)(int fd)
404
405
406
407
408
{
    int ret;
    struct darshan_file_runtime* file;
    double tm1, tm2;

409
410
    MAP_OR_FAIL(fdatasync);

411
412
413
414
415
416
417
418
419
420
    tm1 = darshan_wtime();
    ret = __real_fdatasync(fd);
    tm2 = darshan_wtime();
    if(ret < 0)
        return(ret);

    CP_LOCK();
    file = darshan_file_by_fd(fd);
    if(file)
    {
421
        CP_F_INC_NO_OVERLAP(file, tm1, tm2, file->last_posix_write_end, CP_F_POSIX_WRITE_TIME); \
422
423
424
425
426
427
428
429
        CP_INC(file, CP_POSIX_FDSYNCS, 1);
    }
    CP_UNLOCK();

    return(ret);
}


430
void* DARSHAN_DECL(mmap64)(void *addr, size_t length, int prot, int flags,
431
432
433
434
435
    int fd, off64_t offset)
{
    void* ret;
    struct darshan_file_runtime* file;

436
437
    MAP_OR_FAIL(mmap64);

438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
    ret = __real_mmap64(addr, length, prot, flags, fd, offset);
    if(ret == MAP_FAILED)
        return(ret);

    CP_LOCK();
    file = darshan_file_by_fd(fd);
    if(file)
    {
        CP_INC(file, CP_POSIX_MMAPS, 1);
    }
    CP_UNLOCK();

    return(ret);
}


454
void* DARSHAN_DECL(mmap)(void *addr, size_t length, int prot, int flags,
455
456
457
458
459
    int fd, off_t offset)
{
    void* ret;
    struct darshan_file_runtime* file;

460
461
    MAP_OR_FAIL(mmap);

462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
    ret = __real_mmap(addr, length, prot, flags, fd, offset);
    if(ret == MAP_FAILED)
        return(ret);

    CP_LOCK();
    file = darshan_file_by_fd(fd);
    if(file)
    {
        CP_INC(file, CP_POSIX_MMAPS, 1);
    }
    CP_UNLOCK();

    return(ret);
}

477
int DARSHAN_DECL(creat)(const char* path, mode_t mode)
478
479
480
481
{
    int ret;
    double tm1, tm2;

482
483
    MAP_OR_FAIL(creat);

484
485
486
487
488
489
490
491
492
493
494
    tm1 = darshan_wtime();
    ret = __real_creat(path, mode);
    tm2 = darshan_wtime();

    CP_LOCK();
    CP_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
    CP_UNLOCK();

    return(ret);
}

495
int DARSHAN_DECL(creat64)(const char* path, mode_t mode)
496
497
498
499
{
    int ret;
    double tm1, tm2;

500
501
    MAP_OR_FAIL(creat64);

502
503
504
505
506
507
508
509
510
511
512
    tm1 = darshan_wtime();
    ret = __real_creat64(path, mode);
    tm2 = darshan_wtime();

    CP_LOCK();
    CP_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
    CP_UNLOCK();

    return(ret);
}

513
int DARSHAN_DECL(open64)(const char* path, int flags, ...)
514
515
516
517
518
{
    int mode = 0;
    int ret;
    double tm1, tm2;

519
520
    MAP_OR_FAIL(open64);

521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
    if (flags & O_CREAT) 
    {
        va_list arg;
        va_start(arg, flags);
        mode = va_arg(arg, int);
        va_end(arg);

        tm1 = darshan_wtime();
        ret = __real_open64(path, flags, mode);
        tm2 = darshan_wtime();
    }
    else
    {
        tm1 = darshan_wtime();
        ret = __real_open64(path, flags);
        tm2 = darshan_wtime();
    }

    CP_LOCK();
    CP_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
    CP_UNLOCK();

    return(ret);
}

546
int DARSHAN_DECL(open)(const char *path, int flags, ...)
547
548
549
550
551
{
    int mode = 0;
    int ret;
    double tm1, tm2;

552
553
    MAP_OR_FAIL(open);

554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
    if (flags & O_CREAT) 
    {
        va_list arg;
        va_start(arg, flags);
        mode = va_arg(arg, int);
        va_end(arg);

        tm1 = darshan_wtime();
        ret = __real_open(path, flags, mode);
        tm2 = darshan_wtime();
    }
    else
    {
        tm1 = darshan_wtime();
        ret = __real_open(path, flags);
        tm2 = darshan_wtime();
    }

    CP_LOCK();
    CP_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
    CP_UNLOCK();

    return(ret);
}

579
FILE* DARSHAN_DECL(fopen64)(const char *path, const char *mode)
580
581
582
583
584
{
    FILE* ret;
    int fd;
    double tm1, tm2;

585
586
    MAP_OR_FAIL(fopen64);

587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
    tm1 = darshan_wtime();
    ret = __real_fopen64(path, mode);
    tm2 = darshan_wtime();
    if(ret == 0)
        fd = -1;
    else
        fd = fileno(ret);

    CP_LOCK();
    CP_RECORD_OPEN(fd, path, 0, 1, tm1, tm2);
    CP_UNLOCK();

    return(ret);
}

602
FILE* DARSHAN_DECL(fopen)(const char *path, const char *mode)
603
604
605
606
607
{
    FILE* ret;
    int fd;
    double tm1, tm2;

608
609
    MAP_OR_FAIL(fopen);

610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
    tm1 = darshan_wtime();
    ret = __real_fopen(path, mode);
    tm2 = darshan_wtime();
    if(ret == 0)
        fd = -1;
    else
        fd = fileno(ret);

    CP_LOCK();
    CP_RECORD_OPEN(fd, path, 0, 1, tm1, tm2);
    CP_UNLOCK();

    return(ret);
}

625
int DARSHAN_DECL(__xstat64)(int vers, const char *path, struct stat64 *buf)
626
627
628
629
{
    int ret;
    double tm1, tm2;

630
631
    MAP_OR_FAIL(__xstat64);

632
633
634
635
636
637
638
    tm1 = darshan_wtime();
    ret = __real___xstat64(vers, path, buf);
    tm2 = darshan_wtime();
    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

    CP_LOCK();
639
    CP_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
640
641
642
643
644
    CP_UNLOCK();

    return(ret);
}

645
int DARSHAN_DECL(__lxstat64)(int vers, const char *path, struct stat64 *buf)
646
647
648
649
{
    int ret;
    double tm1, tm2;

650
651
    MAP_OR_FAIL(__lxstat64);

652
653
654
655
656
657
658
    tm1 = darshan_wtime();
    ret = __real___lxstat64(vers, path, buf);
    tm2 = darshan_wtime();
    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

    CP_LOCK();
659
    CP_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
660
661
662
663
664
    CP_UNLOCK();

    return(ret);
}

665
int DARSHAN_DECL(__fxstat64)(int vers, int fd, struct stat64 *buf)
666
667
668
669
670
{
    int ret;
    struct darshan_file_runtime* file;
    double tm1, tm2;

671
672
    MAP_OR_FAIL(__fxstat64);

673
674
675
676
677
678
679
680
681
682
683
684
685
686
    tm1 = darshan_wtime();
    ret = __real___fxstat64(vers, fd, buf);
    tm2 = darshan_wtime();
    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

    /* skip logging if this was triggered internally */
    if(buf == &cp_stat_buf)
        return(ret);

    CP_LOCK();
    file = darshan_file_by_fd(fd);
    if(file)
    {
687
        CP_RECORD_STAT(file, buf, tm1, tm2);
688
689
690
691
692
693
694
    }
    CP_UNLOCK();

    return(ret);
}


695
int DARSHAN_DECL(__xstat)(int vers, const char *path, struct stat *buf)
696
697
698
699
{
    int ret;
    double tm1, tm2;

700
701
    MAP_OR_FAIL(__xstat);

702
703
704
705
706
707
708
    tm1 = darshan_wtime();
    ret = __real___xstat(vers, path, buf);
    tm2 = darshan_wtime();
    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

    CP_LOCK();
709
    CP_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
710
711
712
713
714
    CP_UNLOCK();

    return(ret);
}

715
int DARSHAN_DECL(__lxstat)(int vers, const char *path, struct stat *buf)
716
717
718
719
{
    int ret;
    double tm1, tm2;

720
721
    MAP_OR_FAIL(__lxstat);

722
723
724
725
726
727
728
    tm1 = darshan_wtime();
    ret = __real___lxstat(vers, path, buf);
    tm2 = darshan_wtime();
    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

    CP_LOCK();
729
    CP_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
730
731
732
733
734
    CP_UNLOCK();

    return(ret);
}

735
int DARSHAN_DECL(__fxstat)(int vers, int fd, struct stat *buf)
736
737
738
739
740
{
    int ret;
    struct darshan_file_runtime* file;
    double tm1, tm2;

741
742
    MAP_OR_FAIL(__fxstat);

743
744
745
746
747
748
749
    tm1 = darshan_wtime();
    ret = __real___fxstat(vers, fd, buf);
    tm2 = darshan_wtime();
    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

    /* skip logging if this was triggered internally */
750
    if((void*)buf == (void*)&cp_stat_buf)
751
752
753
754
755
756
        return(ret);

    CP_LOCK();
    file = darshan_file_by_fd(fd);
    if(file)
    {
757
        CP_RECORD_STAT(file, buf, tm1, tm2);
758
759
760
761
762
763
    }
    CP_UNLOCK();

    return(ret);
}

764
ssize_t DARSHAN_DECL(pread64)(int fd, void *buf, size_t count, off64_t offset)
765
766
767
768
769
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

770
771
    MAP_OR_FAIL(pread64);

772
    if((unsigned long)buf % darshan_mem_alignment == 0)
773
774
775
776
777
778
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_pread64(fd, buf, count, offset);
    tm2 = darshan_wtime();
    CP_LOCK();
779
    CP_RECORD_READ(ret, fd, count, 1, offset, aligned_flag, 0, tm1, tm2);
780
781
782
783
    CP_UNLOCK();
    return(ret);
}

784
ssize_t DARSHAN_DECL(pread)(int fd, void *buf, size_t count, off_t offset)
785
786
787
788
789
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

790
791
    MAP_OR_FAIL(pread);

792
    if((unsigned long)buf % darshan_mem_alignment == 0)
793
794
795
796
797
798
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_pread(fd, buf, count, offset);
    tm2 = darshan_wtime();
    CP_LOCK();
799
    CP_RECORD_READ(ret, fd, count, 1, offset, aligned_flag, 0, tm1, tm2);
800
801
802
803
804
    CP_UNLOCK();
    return(ret);
}


805
ssize_t DARSHAN_DECL(pwrite)(int fd, const void *buf, size_t count, off_t offset)
806
807
808
809
810
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

811
812
    MAP_OR_FAIL(pwrite);

813
    if((unsigned long)buf % darshan_mem_alignment == 0)
814
815
816
817
818
819
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_pwrite(fd, buf, count, offset);
    tm2 = darshan_wtime();
    CP_LOCK();
Philip Carns's avatar
Philip Carns committed
820
    CP_RECORD_WRITE(ret, fd, count, 1, offset, aligned_flag, 0, tm1, tm2);
821
822
823
824
    CP_UNLOCK();
    return(ret);
}

825
ssize_t DARSHAN_DECL(pwrite64)(int fd, const void *buf, size_t count, off64_t offset)
826
827
828
829
830
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

831
832
    MAP_OR_FAIL(pwrite64);

833
    if((unsigned long)buf % darshan_mem_alignment == 0)
834
835
836
837
838
839
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_pwrite64(fd, buf, count, offset);
    tm2 = darshan_wtime();
    CP_LOCK();
Philip Carns's avatar
Philip Carns committed
840
    CP_RECORD_WRITE(ret, fd, count, 1, offset, aligned_flag, 0, tm1, tm2);
841
842
843
844
    CP_UNLOCK();
    return(ret);
}

845
ssize_t DARSHAN_DECL(readv)(int fd, const struct iovec *iov, int iovcnt)
846
847
848
849
850
851
{
    ssize_t ret;
    int aligned_flag = 1;
    int i;
    double tm1, tm2;

852
853
    MAP_OR_FAIL(readv);

854
855
    for(i=0; i<iovcnt; i++)
    {
856
        if(((unsigned long)iov[i].iov_base % darshan_mem_alignment) != 0)
857
858
859
860
861
862
863
            aligned_flag = 0;
    }

    tm1 = darshan_wtime();
    ret = __real_readv(fd, iov, iovcnt);
    tm2 = darshan_wtime();
    CP_LOCK();
864
    CP_RECORD_READ(ret, fd, count, 0, 0, aligned_flag, 0, tm1, tm2);
865
866
867
868
    CP_UNLOCK();
    return(ret);
}

869
ssize_t DARSHAN_DECL(writev)(int fd, const struct iovec *iov, int iovcnt)
870
871
872
873
874
875
{
    ssize_t ret;
    int aligned_flag = 1;
    int i;
    double tm1, tm2;

876
877
    MAP_OR_FAIL(writev);

878
879
    for(i=0; i<iovcnt; i++)
    {
880
        if(!((unsigned long)iov[i].iov_base % darshan_mem_alignment == 0))
881
882
883
884
885
886
887
            aligned_flag = 0;
    }

    tm1 = darshan_wtime();
    ret = __real_writev(fd, iov, iovcnt);
    tm2 = darshan_wtime();
    CP_LOCK();
Philip Carns's avatar
Philip Carns committed
888
    CP_RECORD_WRITE(ret, fd, count, 0, 0, aligned_flag, 0, tm1, tm2);
889
890
891
892
    CP_UNLOCK();
    return(ret);
}

893
size_t DARSHAN_DECL(fread)(void *ptr, size_t size, size_t nmemb, FILE *stream)
894
895
896
897
898
{
    size_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

899
900
    MAP_OR_FAIL(fread);

901
    if((unsigned long)ptr % darshan_mem_alignment == 0)
902
903
904
905
906
907
908
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_fread(ptr, size, nmemb, stream);
    tm2 = darshan_wtime();
    CP_LOCK();
    if(ret > 0)
909
        CP_RECORD_READ(size*ret, fileno(stream), (size*nmemb), 0, 0, aligned_flag, 1, tm1, tm2);
910
    else
911
        CP_RECORD_READ(ret, fileno(stream), (size*nmemb), 0, 0, aligned_flag, 1, tm1, tm2);
912
913
914
915
    CP_UNLOCK();
    return(ret);
}

916
ssize_t DARSHAN_DECL(read)(int fd, void *buf, size_t count)
917
918
919
920
921
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

922
923
    MAP_OR_FAIL(read);

924
    if((unsigned long)buf % darshan_mem_alignment == 0)
925
926
927
928
929
930
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_read(fd, buf, count);
    tm2 = darshan_wtime();
    CP_LOCK();
931
    CP_RECORD_READ(ret, fd, count, 0, 0, aligned_flag, 0, tm1, tm2);
932
933
934
935
    CP_UNLOCK();
    return(ret);
}

936
ssize_t DARSHAN_DECL(write)(int fd, const void *buf, size_t count)
937
938
939
940
941
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

942
943
    MAP_OR_FAIL(write);

944
    if((unsigned long)buf % darshan_mem_alignment == 0)
945
946
947
948
949
950
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_write(fd, buf, count);
    tm2 = darshan_wtime();
    CP_LOCK();
Philip Carns's avatar
Philip Carns committed
951
    CP_RECORD_WRITE(ret, fd, count, 0, 0, aligned_flag, 0, tm1, tm2);
952
953
954
955
    CP_UNLOCK();
    return(ret);
}

956
size_t DARSHAN_DECL(fwrite)(const void *ptr, size_t size, size_t nmemb, FILE *stream)
957
958
959
960
961
{
    size_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

962
963
    MAP_OR_FAIL(fwrite);

964
    if((unsigned long)ptr % darshan_mem_alignment == 0)
965
966
967
968
969
970
971
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_fwrite(ptr, size, nmemb, stream);
    tm2 = darshan_wtime();
    CP_LOCK();
    if(ret > 0)
Philip Carns's avatar
Philip Carns committed
972
        CP_RECORD_WRITE(size*ret, fileno(stream), (size*nmemb), 0, 0, aligned_flag, 1, tm1, tm2);
973
    else
Philip Carns's avatar
Philip Carns committed
974
        CP_RECORD_WRITE(ret, fileno(stream), 0, 0, 0, aligned_flag, 1, tm1, tm2);
975
976
977
978
    CP_UNLOCK();
    return(ret);
}

979
off64_t DARSHAN_DECL(lseek64)(int fd, off64_t offset, int whence)
980
{
Philip Carns's avatar
Philip Carns committed
981
    off64_t ret;
982
983
984
    struct darshan_file_runtime* file;
    double tm1, tm2;

985
986
    MAP_OR_FAIL(lseek64);

987
988
989
990
991
992
993
994
995
996
    tm1 = darshan_wtime();
    ret = __real_lseek64(fd, offset, whence);
    tm2 = darshan_wtime();
    if(ret >= 0)
    {
        CP_LOCK();
        file = darshan_file_by_fd(fd);
        if(file)
        {
            file->offset = ret;
997
            CP_F_INC_NO_OVERLAP(file, tm1, tm2, file->last_posix_meta_end, CP_F_POSIX_META_TIME);
998
999
1000
1001
1002
1003
1004
            CP_INC(file, CP_POSIX_SEEKS, 1);
        }
        CP_UNLOCK();
    }
    return(ret);
}

1005
off_t DARSHAN_DECL(lseek)(int fd, off_t offset, int whence)
1006
1007
1008
1009
1010
{
    off_t ret;
    struct darshan_file_runtime* file;
    double tm1, tm2;

1011
1012
    MAP_OR_FAIL(lseek);

1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
    tm1 = darshan_wtime();
    ret = __real_lseek(fd, offset, whence);
    tm2 = darshan_wtime();
    if(ret >= 0)
    {
        CP_LOCK();
        file = darshan_file_by_fd(fd);
        if(file)
        {
            file->offset = ret;
1023
            CP_F_INC_NO_OVERLAP(file, tm1, tm2, file->last_posix_meta_end, CP_F_POSIX_META_TIME);
1024
1025
1026
1027
1028
1029
1030
            CP_INC(file, CP_POSIX_SEEKS, 1);
        }
        CP_UNLOCK();
    }
    return(ret);
}

Philip Carns's avatar
Philip Carns committed
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
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
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
ssize_t DARSHAN_DECL(aio_return64)(struct aiocb *aiocbp)
{
    int ret;

    MAP_OR_FAIL(aio_return64);

    printf("TESTING: wrapped aio_return64()\n");

    ret = __real_aio_return64(aiocbp);

    return(ret);
}

ssize_t DARSHAN_DECL(aio_return)(struct aiocb *aiocbp)
{
    int ret;

    MAP_OR_FAIL(aio_return);

    printf("TESTING: wrapped aio_return()\n");

    ret = __real_aio_return(aiocbp);

    return(ret);
}

int DARSHAN_DECL(lio_listio)(int mode, struct aiocb *const aiocb_list[],
    int nitems, struct sigevent *sevp)
{
    int ret;

    MAP_OR_FAIL(lio_listio);

    printf("TESTING: wrapped lio_listio()\n");

    ret = __real_lio_listio(mode, aiocb_list, nitems, sevp);

    return(ret);
}

int DARSHAN_DECL(lio_listio64)(int mode, struct aiocb *const aiocb_list[],
    int nitems, struct sigevent *sevp)
{
    int ret;

    MAP_OR_FAIL(lio_listio64);

    printf("TESTING: wrapped lio_listio64()\n");

    ret = __real_lio_listio64(mode, aiocb_list, nitems, sevp);

    return(ret);
}

int DARSHAN_DECL(aio_write64)(struct aiocb *aiocbp)
{
    int ret;

    MAP_OR_FAIL(aio_write64);

    printf("TESTING: wrapped aio_write64()\n");

    ret = __real_aio_write64(aiocbp);

    return(ret);
}

int DARSHAN_DECL(aio_write)(struct aiocb *aiocbp)
{
    int ret;

    MAP_OR_FAIL(aio_write);

    printf("TESTING: wrapped aio_write()\n");

    ret = __real_aio_write(aiocbp);

    return(ret);
}

int DARSHAN_DECL(aio_read64)(struct aiocb *aiocbp)
{
    int ret;

    MAP_OR_FAIL(aio_read64);

    printf("TESTING: wrapped aio_read64()\n");

    ret = __real_aio_read64(aiocbp);

    return(ret);
}

int DARSHAN_DECL(aio_read)(struct aiocb *aiocbp)
{
    int ret;

    MAP_OR_FAIL(aio_read);

    printf("TESTING: wrapped aio_read()\n");

    ret = __real_aio_read(aiocbp);

    return(ret);
}


1138
int DARSHAN_DECL(fseek)(FILE *stream, long offset, int whence)
1139
1140
1141
1142
1143
{
    int ret;
    struct darshan_file_runtime* file;
    double tm1, tm2;

1144
1145
    MAP_OR_FAIL(fseek);

1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
    tm1 = darshan_wtime();
    ret = __real_fseek(stream, offset, whence);
    tm2 = darshan_wtime();
    if(ret >= 0)
    {
        CP_LOCK();
        file = darshan_file_by_fd(fileno(stream));
        if(file)
        {
            file->offset = ret;
1156
            CP_F_INC_NO_OVERLAP(file, tm1, tm2, file->last_posix_meta_end, CP_F_POSIX_META_TIME);
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
            CP_INC(file, CP_POSIX_FSEEKS, 1);
        }
        CP_UNLOCK();
    }
    return(ret);
}

void darshan_finalize(struct darshan_job_runtime* job)
{
    if(!job)
    {
        return;
    }

    free(job);
}

void darshan_initialize(int argc, char** argv,  int nprocs, int rank)
{
    int i;
    char* disable;
    char* disable_timing;
1179
    char* envstr;
1180
1181
1182
    char* truncate_string = "<TRUNCATED>";
    int truncate_offset;
    int chars_left = 0;
1183
1184
    int ret;
    int tmpval;
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199

    disable = getenv("DARSHAN_DISABLE");
    if(disable)
    {
        /* turn off tracing */
        return;
    }

    disable_timing = getenv("DARSHAN_DISABLE_TIMING");

    if(darshan_global_job != NULL)
    {
        return;
    }

1200
1201
1202
    #if (__CP_MEM_ALIGNMENT < 1)
        #error Darshan must be configured with a positive value for --with-mem-align
    #endif
1203
1204
1205
    envstr = getenv("DARSHAN_MEMALIGN");
    if (envstr)
    {
1206
1207
1208
1209
1210
1211
        ret = sscanf(envstr, "%d", &tmpval);
        /* silently ignore if the env variable is set poorly */
        if(ret == 1 && tmpval > 0)
        {
            darshan_mem_alignment = tmpval;
        }
1212
1213
1214
1215
1216
1217
    }
    else
    {
        darshan_mem_alignment = __CP_MEM_ALIGNMENT;
    }

1218
1219
1220
1221
1222
1223
    /* avoid floating point errors on faulty input */
    if (darshan_mem_alignment < 1)
    {
        darshan_mem_alignment = 1;
    }

1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
    /* allocate structure to track darshan_global_job information */
    darshan_global_job = malloc(sizeof(*darshan_global_job));
    if(!darshan_global_job)
    {
        return;
    }
    memset(darshan_global_job, 0, sizeof(*darshan_global_job));

    if(disable_timing)
    {
        darshan_global_job->flags |= CP_FLAG_NOTIMING;
    }

    /* set up file records */
    for(i=0; i<CP_MAX_FILES; i++)
    {
        darshan_global_job->file_runtime_array[i].log_file = 
            &darshan_global_job->file_array[i];
    }

    strcpy(darshan_global_job->log_job.version_string, CP_VERSION);
1245
    darshan_global_job->log_job.magic_nr = CP_MAGIC_NR;
1246
1247
1248
1249
1250
1251
1252
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
    darshan_global_job->log_job.uid = getuid();
    darshan_global_job->log_job.start_time = time(NULL);
    darshan_global_job->log_job.nprocs = nprocs;
    my_rank = rank;

    /* record exe and arguments */
    for(i=0; i<argc; i++)
    {
        chars_left = CP_EXE_LEN-strlen(darshan_global_job->exe);
        strncat(darshan_global_job->exe, argv[i], chars_left);
        if(i < (argc-1))
        {
            chars_left = CP_EXE_LEN-strlen(darshan_global_job->exe);
            strncat(darshan_global_job->exe, " ", chars_left);
        }
    }

    /* if we don't see any arguments, then use glibc symbol to get
     * program name at least (this happens in fortran)
     */
    if(argc == 0)
    {
        chars_left = CP_EXE_LEN-strlen(darshan_global_job->exe);
        strncat(darshan_global_job->exe, __progname_full, chars_left);
        chars_left = CP_EXE_LEN-strlen(darshan_global_job->exe);
        strncat(darshan_global_job->exe, " <unknown args>", chars_left);
    }

    if(chars_left == 0)
    {
        /* we ran out of room; mark that string was truncated */
        truncate_offset = CP_EXE_LEN - strlen(truncate_string);
        sprintf(&darshan_global_job->exe[truncate_offset], "%s", 
            truncate_string);
    }
1281
1282
1283
1284
1285
1286
1287
1288

    /* collect information about command line and 
     * mounted file systems 
     */
    darshan_global_job->trailing_data = 
        darshan_get_exe_and_mounts(darshan_global_job);

    return;
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
}

/* darshan_condense()
 *
 * collapses all file statistics into a single unified set of counters; used
 * when we have opened too many files to track independently
 */
void darshan_condense(void)
{
    struct darshan_file_runtime* base_file;
    struct darshan_file_runtime* iter_file;
    int i;
    int j;

    if(!darshan_global_job)
        return;

    base_file = &darshan_global_job->file_runtime_array[0];

    /* iterate through files */
    for(j=1; j<darshan_global_job->file_count; j++)
    {
        iter_file = &darshan_global_job->file_runtime_array[j];

        /* iterate through records */
        for(i=0; i<CP_NUM_INDICES; i++)
        {
            switch(i)
            {
                /* NOTE: several fields cease to make sense if the records
                 * have been condensed.  Just let them get summed anyway.
                 */
                /* TODO: double check this */

                /* keep up with global maxes in case they are helpful */
                case CP_MAX_BYTE_READ:
                case CP_MAX_BYTE_WRITTEN:
                    CP_MAX(base_file, i, CP_VALUE(iter_file, i));
                    break;

1329
1330
1331
1332
1333
1334
1335
                /* do nothing with these; they are handled in the floating
                 * point loop 
                 */
                case CP_MAX_WRITE_TIME_SIZE:
                case CP_MAX_READ_TIME_SIZE:
                    break;

1336
1337
                /* pick one */
                case CP_DEVICE:
1338
                case CP_SIZE_AT_OPEN:
1339
1340
1341
                    CP_SET(base_file, i, CP_VALUE(iter_file, i));
                    break;

1342
1343
1344
1345
1346
1347
1348
1349
                /* most records can simply be added */
                default:
                    CP_INC(base_file, i, CP_VALUE(iter_file, i));
                    break;
            }
        }
        for(i=0; i<CP_F_NUM_INDICES; i++)
        {
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
            switch(i)
            {
                case CP_F_MAX_WRITE_TIME:
                    if(CP_F_VALUE(iter_file, i) > CP_F_VALUE(base_file, i))
                    {
                        CP_F_SET(base_file, i, CP_F_VALUE(iter_file, i));
                        CP_SET(base_file, CP_MAX_WRITE_TIME_SIZE, 
                            CP_VALUE(iter_file, CP_MAX_WRITE_TIME_SIZE));
                    }
                    break;
                case CP_F_MAX_READ_TIME:
                    if(CP_F_VALUE(iter_file, i) > CP_F_VALUE(base_file, i))
                    {
                        CP_F_SET(base_file, i, CP_F_VALUE(iter_file, i));
                        CP_SET(base_file, CP_MAX_READ_TIME_SIZE, 
                            CP_VALUE(iter_file, CP_MAX_READ_TIME_SIZE));
                    }
                    break;
                default:
                    CP_F_SET(base_file, i, CP_F_VALUE(iter_file, i) + CP_F_VALUE(base_file, i));
                    break;
            }
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
        }
    }
    
    base_file->log_file->hash = 0;
    
    darshan_global_job->flags |= CP_FLAG_CONDENSED;
    darshan_global_job->file_count = 1;

    /* clear hash tables for safety */
    memset(darshan_global_job->name_table, 0, CP_HASH_SIZE*sizeof(struct darshan_file_runtime*));
1382
    memset(darshan_global_job->handle_table, 0, CP_HASH_SIZE*sizeof(*darshan_global_job->handle_table));
1383
1384
1385
1386
    
    return;
}

1387
static struct darshan_file_runtime* darshan_file_by_name_setfd(const char* name, int fd)
1388
1389
1390
{
    struct darshan_file_runtime* tmp_file;

1391
    tmp_file = darshan_file_by_name_sethandle(name, &fd, sizeof(fd), DARSHAN_FD);
1392
1393
1394
    return(tmp_file);
}

1395
static void darshan_file_close_fd(int fd)
1396
{
1397
1398
1399
    darshan_file_closehandle(&fd, sizeof(fd), DARSHAN_FD);
    return;
}
1400

1401
1402
1403
static struct darshan_file_runtime* darshan_file_by_fd(int fd)
{
    struct darshan_file_runtime* tmp_file;
1404

1405
1406
1407
    tmp_file = darshan_file_by_handle(&fd, sizeof(fd), DARSHAN_FD);
    
    return(tmp_file);
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
}

static int access_comparison(const void* a_p, const void* b_p)
{
    const struct cp_access_counter* a = a_p;
    const struct cp_access_counter* b = b_p;

    if(a->size < b->size)
        return(-1);
    if(a->size > b->size)
        return(1);
    return(0);
}

/* cp_access_counter()
 *
 * records the occurance of a particular access size for a file,
 * current implementation uses glibc red black tree
 */
static void cp_access_counter(struct darshan_file_runtime* file, ssize_t size, enum cp_counter_type type)
{
    struct cp_access_counter* counter;
    struct cp_access_counter* found;
    void* tmp;
    void** root;
    int* count;
    struct cp_access_counter tmp_counter;

    /* don't count sizes or strides of 0 */
    if(size == 0)
        return;
    
    switch(type)
    {
        case CP_COUNTER_ACCESS:
            root = &file->access_root;
            count = &file->access_count;
            break;
        case CP_COUNTER_STRIDE:
            root = &file->stride_root;
            count = &file->stride_count;
            break;
        default:
            return;
    }

    /* check to see if this size is already recorded */
    tmp_counter.size = size;
    tmp_counter.freq = 1;
    tmp = tfind(&tmp_counter, root, access_comparison);
    if(tmp)
    {
        found = *(struct cp_access_counter**)tmp;
        found->freq++;
        return;
    }

    /* we can add a new one as long as we haven't hit the limit */
    if(*count < CP_MAX_ACCESS_COUNT_RUNTIME)
    {
        counter = malloc(sizeof(*counter));
        if(!counter)
        {
            return;
        }

        counter->size = size;
        counter->freq = 1;

        tmp = tsearch(counter, root, access_comparison);
        found = *(struct cp_access_counter**)tmp;
        /* if we get a new answer out here we are in trouble; this was
         * already checked with the tfind()
         */
        assert(found == counter);

        (*count)++;
    }

    return;
}

void darshan_shutdown_bench(int argc, char** argv, int rank, int nprocs)
{
    int* fd_array;
    int64_t* size_array;
    int i;
    int nfiles;
    char path[256];
    int iters;
    
    /* combinations to build:
     * - 1 unique file per proc
     * - 1 shared file per proc
     * - 1024 unique file per proc
     * - 1024 shared per proc
     */

    srand(rank);
    fd_array = malloc(sizeof(int)*CP_MAX_FILES);
    size_array = malloc(sizeof(int64_t)*CP_MAX_ACCESS_COUNT_RUNTIME);

    assert(fd_array&&size_array);

    for(i=0; i<CP_MAX_FILES; i++)
        fd_array[i] = i;
    for(i=0; i<CP_MAX_ACCESS_COUNT_RUNTIME; i++)
        size_array[i] = rand();

    /* clear out existing stuff */
    darshan_walk_file_accesses(darshan_global_job);
    darshan_finalize(darshan_global_job);
    darshan_global_job = NULL;

    /***********************************************************/
    /* reset darshan to start clean */
    darshan_initialize(argc, argv, nprocs, rank);

    /* populate one unique file per proc */
    nfiles = 1;
    iters = 1;
    for(i=0; i<nfiles; i++)
    {
        sprintf(path, "%d-%d", i, rank);
        CP_RECORD_OPEN(fd_array[i], path, 777, 0, 0, 0);
    }

    for(i=0; i<iters; i++)
    {
Philip Carns's avatar
Philip Carns committed
1537
        CP_RECORD_WRITE(size_array[(i/nfiles)%CP_MAX_ACCESS_COUNT_RUNTIME], fd_array[i%nfiles], size_array[(i/nfiles)%CP_MAX_ACCESS_COUNT_RUNTIME], 0, 0, 1, 0, 1, 2);
1538
1539
1540
1541
    }

    if(rank == 0)
        printf("# 1 unique file per proc\n");
1542
    DARSHAN_MPI_CALL(PMPI_Barrier)(MPI_COMM_WORLD);
1543
1544
1545
1546
1547
    darshan_shutdown(1);
    darshan_global_job = NULL;

    /***********************************************************/
    /* reset darshan to start clean */
1548
    sleep(1);
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
    darshan_initialize(argc, argv, nprocs, rank);

    /* populate one shared file per proc */
    nfiles = 1;
    iters = 1;
    for(i=0; i<nfiles; i++)
    {
        sprintf(path, "%d", i);
        CP_RECORD_OPEN(fd_array[i], path, 777, 0, 0, 0);
    }

    for(i=0; i<iters; i++)
    {
Philip Carns's avatar
Philip Carns committed
1562
        CP_RECORD_WRITE(size_array[(i/nfiles)%CP_MAX_ACCESS_COUNT_RUNTIME], fd_array[i%nfiles], size_array[(i/nfiles)%CP_MAX_ACCESS_COUNT_RUNTIME], 0, 0, 1, 0, 1, 2);
1563
1564
1565
1566
    }

    if(rank == 0)
        printf("# 1 shared file across procs\n");
1567
    DARSHAN_MPI_CALL(PMPI_Barrier)(MPI_COMM_WORLD);
1568
1569
1570
1571
1572
    darshan_shutdown(1);
    darshan_global_job = NULL;

    /***********************************************************/
    /* reset darshan to start clean */
1573
    sleep(1);
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
    darshan_initialize(argc, argv, nprocs, rank);

    /* populate 1024 unique file per proc */
    nfiles = 1024;
    iters = 1024;
    for(i=0; i<nfiles; i++)
    {
        sprintf(path, "%d-%d", i, rank);
        CP_RECORD_OPEN(fd_array[i], path, 777, 0, 0, 0);
    }

    for(i=0; i<iters; i++)
    {