Commit 29cc3cd6 authored by Shane Snyder's avatar Shane Snyder

further refactoring of darshan code base

parent f9e5a24e
......@@ -30,215 +30,6 @@
/* max length of exe string within job record (not counting '\0') */
#define CP_EXE_LEN (CP_JOB_RECORD_SIZE - sizeof(struct darshan_job) - 1)
/* size (in bytes) of each file record */
#define CP_FILE_RECORD_SIZE (sizeof(struct darshan_file))
/* max length of name suffix string within file record (not counting '\0') */
#define CP_NAME_SUFFIX_LEN 15
/* per file statistics */
enum darshan_indices
{
CP_INDEP_OPENS = 0, /* count of MPI independent opens */
CP_COLL_OPENS, /* count of MPI collective opens */
CP_INDEP_READS, /* count of independent MPI reads */
CP_INDEP_WRITES, /* count of independent MPI writes */
CP_COLL_READS, /* count of collective MPI reads */
CP_COLL_WRITES, /* count of collective MPI writes */
CP_SPLIT_READS, /* count of split collective MPI reads */
CP_SPLIT_WRITES, /* count of split collective MPI writes */
CP_NB_READS, /* count of nonblocking MPI reads */
CP_NB_WRITES, /* count of nonblocking MPI writes */
CP_SYNCS,
CP_POSIX_READS, /* count of posix reads */
CP_POSIX_WRITES, /* count of posix writes */
CP_POSIX_OPENS, /* count of posix opens */
CP_POSIX_SEEKS, /* count of posix seeks */
CP_POSIX_STATS, /* count of posix stat/lstat/fstats */
CP_POSIX_MMAPS, /* count of posix mmaps */
CP_POSIX_FREADS,
CP_POSIX_FWRITES,
CP_POSIX_FOPENS,
CP_POSIX_FSEEKS,
CP_POSIX_FSYNCS,
CP_POSIX_FDSYNCS,
/* pnetcdf stuff */
CP_INDEP_NC_OPENS,
CP_COLL_NC_OPENS,
/* HDF5 stuff */
CP_HDF5_OPENS,
/* type categories */
CP_COMBINER_NAMED, /* count of each MPI datatype category */
CP_COMBINER_DUP,
CP_COMBINER_CONTIGUOUS,
CP_COMBINER_VECTOR,
CP_COMBINER_HVECTOR_INTEGER,
CP_COMBINER_HVECTOR,
CP_COMBINER_INDEXED,
CP_COMBINER_HINDEXED_INTEGER,
CP_COMBINER_HINDEXED,
CP_COMBINER_INDEXED_BLOCK,
CP_COMBINER_STRUCT_INTEGER,
CP_COMBINER_STRUCT,
CP_COMBINER_SUBARRAY,
CP_COMBINER_DARRAY,
CP_COMBINER_F90_REAL,
CP_COMBINER_F90_COMPLEX,
CP_COMBINER_F90_INTEGER,
CP_COMBINER_RESIZED,
CP_HINTS, /* count of MPI hints used */
CP_VIEWS, /* count of MPI set view calls */
CP_MODE, /* mode of file */
CP_BYTES_READ, /* total bytes read */
CP_BYTES_WRITTEN, /* total bytes written */
CP_MAX_BYTE_READ, /* highest offset byte read */
CP_MAX_BYTE_WRITTEN, /* highest offset byte written */
CP_CONSEC_READS, /* count of consecutive reads */
CP_CONSEC_WRITES, /* count of consecutive writes */
CP_SEQ_READS, /* count of sequential reads */
CP_SEQ_WRITES, /* count of sequential writes */
CP_RW_SWITCHES, /* number of times switched between read and write */
CP_MEM_NOT_ALIGNED, /* count of accesses not mem aligned */
CP_MEM_ALIGNMENT, /* mem alignment in bytes */
CP_FILE_NOT_ALIGNED, /* count of accesses not file aligned */
CP_FILE_ALIGNMENT, /* file alignment in bytes */
CP_MAX_READ_TIME_SIZE,
CP_MAX_WRITE_TIME_SIZE,
/* buckets */
CP_SIZE_READ_0_100, /* count of posix read size ranges */
CP_SIZE_READ_100_1K,
CP_SIZE_READ_1K_10K,
CP_SIZE_READ_10K_100K,
CP_SIZE_READ_100K_1M,
CP_SIZE_READ_1M_4M,
CP_SIZE_READ_4M_10M,
CP_SIZE_READ_10M_100M,
CP_SIZE_READ_100M_1G,
CP_SIZE_READ_1G_PLUS,
/* buckets */
CP_SIZE_WRITE_0_100, /* count of posix write size ranges */
CP_SIZE_WRITE_100_1K,
CP_SIZE_WRITE_1K_10K,
CP_SIZE_WRITE_10K_100K,
CP_SIZE_WRITE_100K_1M,
CP_SIZE_WRITE_1M_4M,
CP_SIZE_WRITE_4M_10M,
CP_SIZE_WRITE_10M_100M,
CP_SIZE_WRITE_100M_1G,
CP_SIZE_WRITE_1G_PLUS,
/* buckets */
CP_SIZE_READ_AGG_0_100, /* count of MPI read size ranges */
CP_SIZE_READ_AGG_100_1K,
CP_SIZE_READ_AGG_1K_10K,
CP_SIZE_READ_AGG_10K_100K,
CP_SIZE_READ_AGG_100K_1M,
CP_SIZE_READ_AGG_1M_4M,
CP_SIZE_READ_AGG_4M_10M,
CP_SIZE_READ_AGG_10M_100M,
CP_SIZE_READ_AGG_100M_1G,
CP_SIZE_READ_AGG_1G_PLUS,
/* buckets */
CP_SIZE_WRITE_AGG_0_100, /* count of MPI write size ranges */
CP_SIZE_WRITE_AGG_100_1K,
CP_SIZE_WRITE_AGG_1K_10K,
CP_SIZE_WRITE_AGG_10K_100K,
CP_SIZE_WRITE_AGG_100K_1M,
CP_SIZE_WRITE_AGG_1M_4M,
CP_SIZE_WRITE_AGG_4M_10M,
CP_SIZE_WRITE_AGG_10M_100M,
CP_SIZE_WRITE_AGG_100M_1G,
CP_SIZE_WRITE_AGG_1G_PLUS,
/* buckets */
CP_EXTENT_READ_0_100, /* count of MPI read extent ranges */
CP_EXTENT_READ_100_1K,
CP_EXTENT_READ_1K_10K,
CP_EXTENT_READ_10K_100K,
CP_EXTENT_READ_100K_1M,
CP_EXTENT_READ_1M_4M,
CP_EXTENT_READ_4M_10M,
CP_EXTENT_READ_10M_100M,
CP_EXTENT_READ_100M_1G,
CP_EXTENT_READ_1G_PLUS,
/* buckets */
CP_EXTENT_WRITE_0_100, /* count of MPI write extent ranges */
CP_EXTENT_WRITE_100_1K,
CP_EXTENT_WRITE_1K_10K,
CP_EXTENT_WRITE_10K_100K,
CP_EXTENT_WRITE_100K_1M,
CP_EXTENT_WRITE_1M_4M,
CP_EXTENT_WRITE_4M_10M,
CP_EXTENT_WRITE_10M_100M,
CP_EXTENT_WRITE_100M_1G,
CP_EXTENT_WRITE_1G_PLUS,
/* counters */
CP_STRIDE1_STRIDE, /* the four most frequently appearing strides */
CP_STRIDE2_STRIDE,
CP_STRIDE3_STRIDE,
CP_STRIDE4_STRIDE,
CP_STRIDE1_COUNT, /* count of each of the most frequent strides */
CP_STRIDE2_COUNT,
CP_STRIDE3_COUNT,
CP_STRIDE4_COUNT,
CP_ACCESS1_ACCESS, /* the four most frequently appearing access sizes */
CP_ACCESS2_ACCESS,
CP_ACCESS3_ACCESS,
CP_ACCESS4_ACCESS,
CP_ACCESS1_COUNT, /* count of each of the most frequent access sizes */
CP_ACCESS2_COUNT,
CP_ACCESS3_COUNT,
CP_ACCESS4_COUNT,
CP_DEVICE, /* device id reported by stat */
CP_SIZE_AT_OPEN,
CP_FASTEST_RANK,
CP_FASTEST_RANK_BYTES,
CP_SLOWEST_RANK,
CP_SLOWEST_RANK_BYTES,
CP_NUM_INDICES,
};
/* floating point statistics */
enum f_darshan_indices
{
/* NOTE: adjust cp_normalize_timestamps() function if any TIMESTAMPS are
* added or modified in this list
*/
CP_F_OPEN_TIMESTAMP = 0, /* timestamp of first open */
CP_F_READ_START_TIMESTAMP, /* timestamp of first read */
CP_F_WRITE_START_TIMESTAMP, /* timestamp of first write */
CP_F_CLOSE_TIMESTAMP, /* timestamp of last close */
CP_F_READ_END_TIMESTAMP, /* timestamp of last read */
CP_F_WRITE_END_TIMESTAMP, /* timestamp of last write */
CP_F_POSIX_READ_TIME, /* cumulative posix read time */
CP_F_POSIX_WRITE_TIME, /* cumulative posix write time */
CP_F_POSIX_META_TIME, /* cumulative posix meta time */
CP_F_MPI_META_TIME, /* cumulative mpi-io meta time */
CP_F_MPI_READ_TIME, /* cumulative mpi-io read time */
CP_F_MPI_WRITE_TIME, /* cumulative mpi-io write time */
CP_F_MAX_READ_TIME,
CP_F_MAX_WRITE_TIME,
/* Total I/O and meta time consumed by fastest and slowest ranks,
* reported in either MPI or POSIX time depending on how the file
* was accessed.
*/
CP_F_FASTEST_RANK_TIME,
CP_F_SLOWEST_RANK_TIME,
CP_F_VARIANCE_RANK_TIME,
CP_F_VARIANCE_RANK_BYTES,
CP_F_NUM_INDICES,
};
/* statistics for any kind of file */
struct darshan_file
{
uint64_t hash;
int64_t rank;
char name_suffix[CP_NAME_SUFFIX_LEN+1];
int64_t counters[CP_NUM_INDICES];
double fcounters[CP_F_NUM_INDICES];
};
/* statistics for the job as a whole */
#define DARSHAN_JOB_METADATA_LEN 1024 /* including null terminator! */
struct darshan_job
......
......@@ -114,3 +114,4 @@ API:
TODO NOTES:
- why are darshan mutexes recursive?
- how do we allow modules to specify there necessary linker/wrapper flags
- configurable amount of max runtime memory
......@@ -37,6 +37,9 @@ lib::
lib/darshan-core.o: lib/darshan-core.c darshan-core.h $(DARSHAN_LOG_FORMAT) | lib
$(CC) $(CFLAGS) -c $< -o $@
lib/darshan-common.o: lib/darshan-common.c darshan.h | lib
$(CC) $(CFLAGS) -c $< -o $@
#lib/darshan-mpi-io.o: lib/darshan-mpi-io.c darshan.h darshan-dynamic.h $(DARSHAN_LOG_FORMAT) | lib
# $(CC) $(CFLAGS) -c $< -o $@
......@@ -88,7 +91,7 @@ lib/lookup8.o: lib/lookup8.c
#%.i: %.c
# $(CC) -E $(CFLAGS) -c $< -o $@
lib/libdarshan-core.a: lib/darshan-core.o lib/lookup3.o lib/lookup8.o lib/darshan-posix.o
lib/libdarshan-core.a: lib/darshan-core.o lib/darshan-common.o lib/lookup3.o lib/lookup8.o lib/darshan-posix.o
ar rcs $@ $^
#lib/libdarshan-mpi-io.a: lib/darshan-mpi-io.o lib/darshan-mpi-init-finalize.o lib/darshan-pnetcdf.o lib/darshan-hdf5.o
......
......@@ -12,8 +12,6 @@
#include "darshan.h"
#define DARSHAN_MPI_CALL(func) func
/* calculation of compression buffer size (defaults to 50% of the maximum
* memory that Darshan is allowed to consume on a process)
*/
......
......@@ -12,6 +12,8 @@
#include <mpi.h>
#include "darshan-log-format.h"
#define DARSHAN_MPI_CALL(func) func
typedef uint64_t darshan_file_id;
struct darshan_module_funcs
......@@ -33,4 +35,8 @@ void darshan_core_lookup_id(
double darshan_core_wtime(void);
char* darshan_clean_file_path(const char* path);
double darshan_wtime(void);
#endif /* __DARSHAN_H */
......@@ -278,8 +278,8 @@ static void darshan_get_exe_and_mounts_root(char* trailing_data, int space_left)
"nfsd",
"none",
"rpc_pipefs",
"hugetlbfs",
"cgroup",
"hugetlbfs",
"cgroup",
NULL
};
......@@ -383,6 +383,7 @@ void darshan_core_register_module(
struct darshan_core_module *tmp;
struct darshan_core_module *new_mod;
*runtime_mem_limit = 0;
if (!darshan_global_job)
return;
......@@ -426,7 +427,19 @@ void darshan_core_lookup_id(
int printable_flag,
darshan_file_id *id)
{
darshan_file_id tmp_id;
if (!darshan_global_job)
return;
/* TODO: what do you do with printable flag? */
/* hash the input name to get a unique id for this record */
tmp_id = darshan_hash(name, len, 0);
/* TODO: how to store the filename to hash mapping? */
*id = tmp_id;
return;
}
......
......@@ -40,56 +40,139 @@ typedef int64_t off64_t;
#define MAP_OR_FAIL(func)
#define DARSHAN_MPI_CALL(func) func
/* TODO: where do these file record structs go? (some needed for darshan-util) */
/* TODO: DARSHAN_* OR CP_* */
#define POSIX_MOD_NAME "POSIX"
enum darshan_posix_indices
{
CP_POSIX_READS, /* count of posix reads */
CP_POSIX_WRITES, /* count of posix writes */
CP_POSIX_OPENS, /* count of posix opens */
CP_POSIX_SEEKS, /* count of posix seeks */
CP_POSIX_STATS, /* count of posix stat/lstat/fstats */
CP_POSIX_MMAPS, /* count of posix mmaps */
CP_POSIX_FREADS,
CP_POSIX_FWRITES,
CP_POSIX_FOPENS,
CP_POSIX_FSEEKS,
CP_POSIX_FSYNCS,
CP_POSIX_FDSYNCS,
CP_MODE, /* mode of file */
CP_BYTES_READ, /* total bytes read */
CP_BYTES_WRITTEN, /* total bytes written */
CP_MAX_BYTE_READ, /* highest offset byte read */
CP_MAX_BYTE_WRITTEN, /* highest offset byte written */
CP_CONSEC_READS, /* count of consecutive reads */
CP_CONSEC_WRITES, /* count of consecutive writes */
CP_SEQ_READS, /* count of sequential reads */
CP_SEQ_WRITES, /* count of sequential writes */
CP_RW_SWITCHES, /* number of times switched between read and write */
CP_MEM_NOT_ALIGNED, /* count of accesses not mem aligned */
CP_MEM_ALIGNMENT, /* mem alignment in bytes */
CP_FILE_NOT_ALIGNED, /* count of accesses not file aligned */
CP_FILE_ALIGNMENT, /* file alignment in bytes */
CP_MAX_READ_TIME_SIZE,
CP_MAX_WRITE_TIME_SIZE,
/* buckets */
CP_SIZE_READ_0_100, /* count of posix read size ranges */
CP_SIZE_READ_100_1K,
CP_SIZE_READ_1K_10K,
CP_SIZE_READ_10K_100K,
CP_SIZE_READ_100K_1M,
CP_SIZE_READ_1M_4M,
CP_SIZE_READ_4M_10M,
CP_SIZE_READ_10M_100M,
CP_SIZE_READ_100M_1G,
CP_SIZE_READ_1G_PLUS,
/* buckets */
CP_SIZE_WRITE_0_100, /* count of posix write size ranges */
CP_SIZE_WRITE_100_1K,
CP_SIZE_WRITE_1K_10K,
CP_SIZE_WRITE_10K_100K,
CP_SIZE_WRITE_100K_1M,
CP_SIZE_WRITE_1M_4M,
CP_SIZE_WRITE_4M_10M,
CP_SIZE_WRITE_10M_100M,
CP_SIZE_WRITE_100M_1G,
CP_SIZE_WRITE_1G_PLUS,
/* counters */
CP_STRIDE1_STRIDE, /* the four most frequently appearing strides */
CP_STRIDE2_STRIDE,
CP_STRIDE3_STRIDE,
CP_STRIDE4_STRIDE,
CP_STRIDE1_COUNT, /* count of each of the most frequent strides */
CP_STRIDE2_COUNT,
CP_STRIDE3_COUNT,
CP_STRIDE4_COUNT,
CP_ACCESS1_ACCESS, /* the four most frequently appearing access sizes */
CP_ACCESS2_ACCESS,
CP_ACCESS3_ACCESS,
CP_ACCESS4_ACCESS,
CP_ACCESS1_COUNT, /* count of each of the most frequent access sizes */
CP_ACCESS2_COUNT,
CP_ACCESS3_COUNT,
CP_ACCESS4_COUNT,
CP_DEVICE, /* device id reported by stat */
CP_SIZE_AT_OPEN,
CP_FASTEST_RANK,
CP_FASTEST_RANK_BYTES,
CP_SLOWEST_RANK,
CP_SLOWEST_RANK_BYTES,
CP_NUM_INDICES,
};
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));
DARSHAN_FORWARD_DECL(aio_read, int, (struct aiocb *aiocbp));
DARSHAN_FORWARD_DECL(aio_read64, int, (struct aiocb64 *aiocbp));
DARSHAN_FORWARD_DECL(aio_write, int, (struct aiocb *aiocbp));
DARSHAN_FORWARD_DECL(aio_write64, int, (struct aiocb64 *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 aiocb64 *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 aiocb64 *aiocbp));
/* floating point statistics */
enum f_darshan_posix_indices
{
/* NOTE: adjust cp_normalize_timestamps() function if any TIMESTAMPS are
* added or modified in this list
*/
CP_F_OPEN_TIMESTAMP = 0, /* timestamp of first open */
CP_F_READ_START_TIMESTAMP, /* timestamp of first read */
CP_F_WRITE_START_TIMESTAMP, /* timestamp of first write */
CP_F_CLOSE_TIMESTAMP, /* timestamp of last close */
CP_F_READ_END_TIMESTAMP, /* timestamp of last read */
CP_F_WRITE_END_TIMESTAMP, /* timestamp of last write */
CP_F_POSIX_READ_TIME, /* cumulative posix read time */
CP_F_POSIX_WRITE_TIME, /* cumulative posix write time */
CP_F_POSIX_META_TIME, /* cumulative posix meta time */
CP_F_MAX_READ_TIME,
CP_F_MAX_WRITE_TIME,
/* Total I/O and meta time consumed by fastest and slowest ranks,
* reported in either MPI or POSIX time depending on how the file
* was accessed.
*/
CP_F_FASTEST_RANK_TIME,
CP_F_SLOWEST_RANK_TIME,
CP_F_VARIANCE_RANK_TIME,
CP_F_VARIANCE_RANK_BYTES,
CP_F_NUM_INDICES,
};
struct darshan_posix_file
{
int64_t counters[CP_NUM_INDICES];
double fcounters[CP_F_NUM_INDICES];
};
struct darshan_posix_runtime_file
{
struct darshan_posix_file file_record;
};
/* struct to track information about aio operations in flight */
struct darshan_aio_tracker
struct darshan_posix_runtime
{
double tm1;
void *aiocbp;
struct darshan_aio_tracker* next;
struct darshan_posix_file_runtime *file_array;
int file_array_sz;
};
static pthread_mutex_t posix_runtime_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
static struct darshan_posix_runtime *posix_runtime = NULL;
/* these are paths that we will not trace */
static char* exclusions[] = {
"/etc/",
......@@ -107,168 +190,33 @@ NULL
static int darshan_mem_alignment = 1;
static int posix_mod_initialized = 0;
static pthread_mutex_t posix_mod_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
DARSHAN_FORWARD_DECL(open, int, (const char *path, int flags, ...));
//DARSHAN_FORWARD_DECL(close, int, (int fd));
static void posix_runtime_initialize(void);
static double posix_wtime(void);
static void posix_runtime_finalize(void);
static void posix_prepare_for_shutdown(void);
static void posix_get_output_data(void **buffer, int size);
#define POSIX_LOCK() pthread_mutex_lock(&posix_mod_mutex)
#define POSIX_UNLOCK() pthread_mutex_unlock(&posix_mod_mutex)
#if 0
static void cp_access_counter(struct darshan_file_runtime* file, ssize_t size, enum cp_counter_type type);
static void darshan_aio_tracker_add(int fd, void *aiocbp);
static struct darshan_aio_tracker* darshan_aio_tracker_del(int fd, void *aiocbp);
#endif
#if 0
#define CP_RECORD_WRITE(__ret, __fd, __count, __pwrite_flag, __pwrite_offset, __aligned, __stream_flag, __tm1, __tm2) do{ \
size_t stride; \
int64_t this_offset; \
int64_t file_alignment; \
struct darshan_file_runtime* file; \
double __elapsed = __tm2-__tm1; \
if(__ret < 0) break; \
file = darshan_file_by_fd(__fd); \
if(!file) break; \
if(__pwrite_flag) \
this_offset = __pwrite_offset; \
else \
this_offset = file->offset; \
file_alignment = CP_VALUE(file, CP_FILE_ALIGNMENT); \
if(this_offset > file->last_byte_written) \
CP_INC(file, CP_SEQ_WRITES, 1); \
if(this_offset == (file->last_byte_written + 1)) \
CP_INC(file, CP_CONSEC_WRITES, 1); \
if(this_offset > 0 && this_offset > file->last_byte_written \
&& file->last_byte_written != 0) \
stride = this_offset - file->last_byte_written - 1; \
else \
stride = 0; \
file->last_byte_written = this_offset + __ret - 1; \
file->offset = this_offset + __ret; \
CP_MAX(file, CP_MAX_BYTE_WRITTEN, (this_offset + __ret -1)); \
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); \
if(file_alignment > 0 && (this_offset % file_alignment) != 0) \
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; \
CP_F_INC_NO_OVERLAP(file, __tm1, __tm2, file->last_posix_write_end, CP_F_POSIX_WRITE_TIME); \
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); \
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); } \
} while(0)
#define CP_RECORD_READ(__ret, __fd, __count, __pread_flag, __pread_offset, __aligned, __stream_flag, __tm1, __tm2) do{ \
size_t stride; \
int64_t this_offset; \
struct darshan_file_runtime* file; \
int64_t file_alignment; \
double __elapsed = __tm2-__tm1; \
if(__ret < 0) break; \
file = darshan_file_by_fd(__fd); \
if(!file) break; \
if(__pread_flag)\
this_offset = __pread_offset; \
else \
this_offset = file->offset; \
file_alignment = CP_VALUE(file, CP_FILE_ALIGNMENT); \
if(this_offset > file->last_byte_read) \
CP_INC(file, CP_SEQ_READS, 1); \
if(this_offset == (file->last_byte_read + 1)) \
CP_INC(file, CP_CONSEC_READS, 1); \
if(this_offset > 0 && this_offset > file->last_byte_read \
&& file->last_byte_read != 0) \
stride = this_offset - file->last_byte_read - 1; \
else \
stride = 0; \
file->last_byte_read = this_offset + __ret - 1; \
CP_MAX(file, CP_MAX_BYTE_READ, (this_offset + __ret -1)); \
file->offset = this_offset + __ret; \
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); \
if(file_alignment > 0 && (this_offset % file_alignment) != 0) \
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; \
CP_F_INC_NO_OVERLAP(file, __tm1, __tm2, file->last_posix_read_end, CP_F_POSIX_READ_TIME); \
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); \
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); } \
} while(0)
#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)
#define CP_RECORD_STAT(__file, __statbuf, __tm1, __tm2) do { \
if(!CP_VALUE((__file), CP_POSIX_STATS) && !CP_VALUE((__file), CP_POSIX_OPENS)){ \
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; \
CP_F_INC_NO_OVERLAP(file, __tm1, __tm2, file->last_posix_meta_end, CP_F_POSIX_META_TIME); \
CP_INC(__file, CP_POSIX_STATS, 1); \
} while(0)
#define POSIX_LOCK() pthread_mutex_lock(&posix_runtime_mutex)
#define POSIX_UNLOCK() pthread_mutex_unlock(&posix_runtime_mutex)
#ifdef __CP_STAT_AT_OPEN
#define CP_STAT_FILE(_f, _p, _r) do { \
if(!CP_VALUE((_f), CP_POSIX_STATS) && !CP_VALUE((_f), CP_POSIX_OPENS)){ \
#ifdef __DARSHAN_STAT_AT_OPEN
#define DARSHAN_STAT_FILE(_f, _p, _r) do { \
if(!DARSHAN_VALUE((_f), DARSHAN_POSIX_STATS) && !DARSHAN_VALUE((_f), DARSHAN_POSIX_OPENS)){ \
if(fstat64(_r, &cp_stat_buf) == 0) { \
CP_SET(_f, CP_FILE_ALIGNMENT, cp_stat_buf.st_blksize); \
CP_SET(_f, CP_SIZE_AT_OPEN, cp_stat_buf.st_size); \
DARSHAN_SET(_f, DARSHAN_FILE_ALIGNMENT, cp_stat_buf.st_blksize); \
DARSHAN_SET(_f, DARSHAN_SIZE_AT_OPEN, cp_stat_buf.st_size); \
}\
}\
}while(0)
#else
#define CP_STAT_FILE(_f, _p, _r) do { }while(0)
#define DARSHAN_STAT_FILE(_f, _p, _r) do { }while(0)
#endif
#define CP_RECORD_OPEN(__ret, __path, __mode, __stream_flag, __tm1, __tm2) do { \
struct darshan_file_runtime* file; \
#define POSIX_RECORD_OPEN(__ret, __path, __mode, __stream_flag, __tm1, __tm2) do { \
struct darshan_posix_runtime_file* file; \
char* exclude; \
int tmp_index = 0; \
if(__ret < 0) break; \
......@@ -278,25 +226,25 @@ static struct darshan_aio_tracker* darshan_aio_tracker_del(int fd, void *aiocbp)
tmp_index++; \
} \
if(exclude) break; \
file = darshan_file_by_name_setfd(__path, __ret); \
if(!file) break; \
CP_STAT_FILE(file, __path, __ret); \
file = *************darshan_file_by_name_setfd(__path, __ret); \
if(!file_rec) break; \
DARSHAN_STAT_FILE(file, __path, __ret); \
file->log_file->rank = my_rank; \
if(__mode) \
CP_SET(file, CP_MODE, __mode); \
DARSHAN_SET(file, DARSHAN_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); \
DARSHAN_INC(file, DARSHAN_POSIX_FOPENS, 1); \
else \
CP_INC(file, CP_POSIX_OPENS, 1); \
if(CP_F_VALUE(file, CP_F_OPEN_TIMESTAMP) == 0) \
CP_F_SET(file, CP_F_OPEN_TIMESTAMP, __tm1); \
CP_F_INC_NO_OVERLAP(file, __tm1, __tm2, file->last_posix_meta_end, CP_F_POSIX_META_TIME); \
DARSHAN_INC(file, DARSHAN_POSIX_OPENS, 1); \
if(DARSHAN_F_VALUE(file, DARSHAN_F_OPEN_TIMESTAMP) == 0) \
DARSHAN_F_SET(file, DARSHAN_F_OPEN_TIMESTAMP, __tm1); \
DARSHAN_F_INC_NO_OVERLAP(file, __tm1, __tm2, file->last_posix_meta_end, DARSHAN_F_POSIX_META_TIME); \
} while (0)
#endif
#if 0
int DARSHAN_DECL(close)(int fd)
{
struct darshan_file_runtime* file;
......@@ -313,222 +261,20 @@ int DARSHAN_DECL(close)(int fd)
POSIX_LOCK();
posix_runtime_initialize();
#if 0
file = darshan_file_by_fd(tmp_fd);
if(file)
{
file->last_byte_written = 0;
file->last_byte_read = 0;
CP_F_SET(file, CP_F_CLOSE_TIMESTAMP, posix_wtime());
CP_F_INC_NO_OVERLAP(file, tm1, tm2, file->last_posix_meta_end, CP_F_POSIX_META_TIME);
DARSHAN_F_SET(file, DARSHAN_F_CLOSE_TIMESTAMP, posix_wtime());