[Darshan-commits] [Darshan] branch, dev-modular, updated. darshan-2.3.1-112-ge0eb27b
Service Account
git at mcs.anl.gov
Tue Jul 14 18:53:20 CDT 2015
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, dev-modular has been updated
via e0eb27be2b7827593b442e104af8b45cb585e876 (commit)
via d2776592214b92e72cac8c3903823271ef541ba8 (commit)
from 53fa81e8bd7449c9caf48f78fb64e55829b9aa1d (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit e0eb27be2b7827593b442e104af8b45cb585e876
Author: Shane Snyder <ssnyder at mcs.anl.gov>
Date: Tue Jul 14 18:52:41 2015 -0500
xmacro posix/mpiio counters to maintain ordering
commit d2776592214b92e72cac8c3903823271ef541ba8
Author: Shane Snyder <ssnyder at mcs.anl.gov>
Date: Tue Jul 14 18:52:10 2015 -0500
more mpiio counters
-----------------------------------------------------------------------
Summary of changes:
darshan-mpiio-log-format.h | 182 ++++++++++++++++----------
darshan-posix-log-format.h | 235 +++++++++++++++++++-------------
darshan-runtime/darshan.h | 6 +
darshan-runtime/lib/darshan-mpiio.c | 24 +++-
darshan-runtime/lib/darshan-posix.c | 16 +--
darshan-util/darshan-mpiio-logutils.c | 11 ++
darshan-util/darshan-mpiio-logutils.h | 15 ++
darshan-util/darshan-mpiio-parser.c | 56 +-------
darshan-util/darshan-posix-logutils.c | 11 ++
darshan-util/darshan-posix-logutils.h | 15 ++
darshan-util/darshan-posix-parser.c | 175 +-----------------------
11 files changed, 348 insertions(+), 398 deletions(-)
Diff of changes:
diff --git a/darshan-mpiio-log-format.h b/darshan-mpiio-log-format.h
index 193f86d..53e0f9e 100644
--- a/darshan-mpiio-log-format.h
+++ b/darshan-mpiio-log-format.h
@@ -9,84 +9,126 @@
#include "darshan-log-format.h"
+/* TODO: slowest/fastest rank (f)counters */
+/* TODO: access size and extent common counters? */
+
+#define MPIIO_COUNTERS \
+ /* count of MPI independent opens */\
+ X(MPIIO_INDEP_OPENS) \
+ /* count of MPI collective opens */\
+ X(MPIIO_COLL_OPENS) \
+ /* count of MPI independent reads */\
+ X(MPIIO_INDEP_READS) \
+ /* count of MPI independent writes */\
+ X(MPIIO_INDEP_WRITES) \
+ /* count of MPI collective reads */\
+ X(MPIIO_COLL_READS) \
+ /* count of MPI collective writes */\
+ X(MPIIO_COLL_WRITES) \
+ /* count of MPI split collective reads */\
+ X(MPIIO_SPLIT_READS) \
+ /* count of MPI split collective writes */\
+ X(MPIIO_SPLIT_WRITES) \
+ /* count of MPI nonblocking reads */\
+ X(MPIIO_NB_READS) \
+ /* count of MPI nonblocking writes */\
+ X(MPIIO_NB_WRITES) \
+ /* count of MPI file syncs */\
+ X(MPIIO_SYNCS) \
+ /* count of MPI hints used */\
+ X(MPIIO_HINTS) \
+ /* count of MPI set view calls */\
+ X(MPIIO_VIEWS) \
+ /* total bytes read at MPI-IO layer */\
+ X(MPIIO_BYTES_READ) \
+ /* total bytes written at MPI-IO layer */\
+ X(MPIIO_BYTES_WRITTEN) \
+ /* number of times switching between MPI read and write */\
+ X(MPIIO_RW_SWITCHES) \
+ /* sizes of the maximum read/write operations */\
+ X(MPIIO_MAX_READ_TIME_SIZE) \
+ X(MPIIO_MAX_WRITE_TIME_SIZE) \
+ /* buckets for MPI read size ranges */\
+ X(MPIIO_SIZE_READ_AGG_0_100) \
+ X(MPIIO_SIZE_READ_AGG_100_1K) \
+ X(MPIIO_SIZE_READ_AGG_1K_10K) \
+ X(MPIIO_SIZE_READ_AGG_10K_100K) \
+ X(MPIIO_SIZE_READ_AGG_100K_1M) \
+ X(MPIIO_SIZE_READ_AGG_1M_4M) \
+ X(MPIIO_SIZE_READ_AGG_4M_10M) \
+ X(MPIIO_SIZE_READ_AGG_10M_100M) \
+ X(MPIIO_SIZE_READ_AGG_100M_1G) \
+ X(MPIIO_SIZE_READ_AGG_1G_PLUS) \
+ /* buckets for MPI write size ranges */\
+ X(MPIIO_SIZE_WRITE_AGG_0_100) \
+ X(MPIIO_SIZE_WRITE_AGG_100_1K) \
+ X(MPIIO_SIZE_WRITE_AGG_1K_10K) \
+ X(MPIIO_SIZE_WRITE_AGG_10K_100K) \
+ X(MPIIO_SIZE_WRITE_AGG_100K_1M) \
+ X(MPIIO_SIZE_WRITE_AGG_1M_4M) \
+ X(MPIIO_SIZE_WRITE_AGG_4M_10M) \
+ X(MPIIO_SIZE_WRITE_AGG_10M_100M) \
+ X(MPIIO_SIZE_WRITE_AGG_100M_1G) \
+ X(MPIIO_SIZE_WRITE_AGG_1G_PLUS) \
+ /* rank and number of bytes moved for fastest/slowest ranks */\
+ X(MPIIO_FASTEST_RANK) \
+ X(MPIIO_FASTEST_RANK_BYTES) \
+ X(MPIIO_SLOWEST_RANK) \
+ X(MPIIO_SLOWEST_RANK_BYTES) \
+ /* end of counters */\
+ X(MPIIO_NUM_INDICES)
+
+#define MPIIO_F_COUNTERS \
+ /* timestamp of first open */\
+ X(MPIIO_F_OPEN_TIMESTAMP) \
+ /* timestamp of first read */\
+ X(MPIIO_F_READ_START_TIMESTAMP) \
+ /* timestamp of first write */\
+ X(MPIIO_F_WRITE_START_TIMESTAMP) \
+ /* timestamp of last read */\
+ X(MPIIO_F_READ_END_TIMESTAMP) \
+ /* timestamp of last write */\
+ X(MPIIO_F_WRITE_END_TIMESTAMP) \
+ /* timestamp of last close */\
+ X(MPIIO_F_CLOSE_TIMESTAMP) \
+ /* cumulative MPI-IO read time */\
+ X(MPIIO_F_READ_TIME) \
+ /* cumulative MPI-IO write time */\
+ X(MPIIO_F_WRITE_TIME) \
+ /* cumulative MPI-IO meta time */\
+ X(MPIIO_F_META_TIME) \
+ /* maximum MPI-IO read duration */\
+ X(MPIIO_F_MAX_READ_TIME) \
+ /* maximum MPI-IO write duration */\
+ X(MPIIO_F_MAX_WRITE_TIME) \
+ /* total i/o and meta time for fastest/slowest ranks */\
+ X(MPIIO_F_FASTEST_RANK_TIME) \
+ X(MPIIO_F_SLOWEST_RANK_TIME) \
+ /* end of counters*/\
+ X(MPIIO_F_NUM_INDICES)
+
+#define X(a) a,
+/* integer statistics for MPI-IO file records */
enum darshan_mpiio_indices
{
- MPIIO_INDEP_OPENS, /* count of MPI independent opens */
- MPIIO_COLL_OPENS, /* count of MPI collective opens */
- MPIIO_INDEP_READS, /* count of MPI independent reads */
- MPIIO_INDEP_WRITES, /* count of MPI independent writes */
- MPIIO_COLL_READS, /* count of MPI collective reads */
- MPIIO_COLL_WRITES, /* count of MPI collective writes */
- MPIIO_SPLIT_READS, /* count of MPI split collective reads */
- MPIIO_SPLIT_WRITES, /* count of MPI split collective writes */
- MPIIO_NB_READS, /* count of MPI nonblocking reads */
- MPIIO_NB_WRITES, /* count of MPI nonblocking writes */
- MPIIO_SYNCS, /* count of MPI file syncs */
- MPIIO_HINTS, /* count of MPI hints used */
- MPIIO_VIEWS, /* count of MPI set view calls */
- /* buckets */
- MPIIO_SIZE_READ_AGG_0_100, /* count of MPI read size ranges */
- MPIIO_SIZE_READ_AGG_100_1K,
- MPIIO_SIZE_READ_AGG_1K_10K,
- MPIIO_SIZE_READ_AGG_10K_100K,
- MPIIO_SIZE_READ_AGG_100K_1M,
- MPIIO_SIZE_READ_AGG_1M_4M,
- MPIIO_SIZE_READ_AGG_4M_10M,
- MPIIO_SIZE_READ_AGG_10M_100M,
- MPIIO_SIZE_READ_AGG_100M_1G,
- MPIIO_SIZE_READ_AGG_1G_PLUS,
- /* buckets */
- MPIIO_SIZE_WRITE_AGG_0_100, /* count of MPI write size ranges */
- MPIIO_SIZE_WRITE_AGG_100_1K,
- MPIIO_SIZE_WRITE_AGG_1K_10K,
- MPIIO_SIZE_WRITE_AGG_10K_100K,
- MPIIO_SIZE_WRITE_AGG_100K_1M,
- MPIIO_SIZE_WRITE_AGG_1M_4M,
- MPIIO_SIZE_WRITE_AGG_4M_10M,
- MPIIO_SIZE_WRITE_AGG_10M_100M,
- MPIIO_SIZE_WRITE_AGG_100M_1G,
- MPIIO_SIZE_WRITE_AGG_1G_PLUS,
- /* buckets */
- MPIIO_EXTENT_READ_0_100, /* count of MPI read extent ranges */
- MPIIO_EXTENT_READ_100_1K,
- MPIIO_EXTENT_READ_1K_10K,
- MPIIO_EXTENT_READ_10K_100K,
- MPIIO_EXTENT_READ_100K_1M,
- MPIIO_EXTENT_READ_1M_4M,
- MPIIO_EXTENT_READ_4M_10M,
- MPIIO_EXTENT_READ_10M_100M,
- MPIIO_EXTENT_READ_100M_1G,
- MPIIO_EXTENT_READ_1G_PLUS,
- /* buckets */
- MPIIO_EXTENT_WRITE_0_100, /* count of MPI write extent ranges */
- MPIIO_EXTENT_WRITE_100_1K,
- MPIIO_EXTENT_WRITE_1K_10K,
- MPIIO_EXTENT_WRITE_10K_100K,
- MPIIO_EXTENT_WRITE_100K_1M,
- MPIIO_EXTENT_WRITE_1M_4M,
- MPIIO_EXTENT_WRITE_4M_10M,
- MPIIO_EXTENT_WRITE_10M_100M,
- MPIIO_EXTENT_WRITE_100M_1G,
- MPIIO_EXTENT_WRITE_1G_PLUS,
-
- MPIIO_NUM_INDICES,
+ MPIIO_COUNTERS
};
+/* floating point statistics for MPI-IO file records */
enum darshan_mpiio_f_indices
{
- MPIIO_F_OPEN_TIMESTAMP,
- MPIIO_F_READ_START_TIMESTAMP,
- MPIIO_F_WRITE_START_TIMESTAMP,
- MPIIO_F_READ_END_TIMESTAMP,
- MPIIO_F_WRITE_END_TIMESTAMP,
- MPIIO_F_CLOSE_TIMESTAMP,
- MPIIO_F_READ_TIME,
- MPIIO_F_WRITE_TIME,
- MPIIO_F_META_TIME,
-
- MPIIO_F_NUM_INDICES,
+ MPIIO_F_COUNTERS
};
+#undef X
+/* file record structure for MPI-IO files. a record is created and stored for
+ * every MPI-IO file opened by the original application. For the MPI-IO module,
+ * the record includes:
+ * - a corresponding record identifier (created by hashing the file path)
+ * - the rank of the process which opened the file (-1 for shared files)
+ * - integer file I/O statistics (open, read/write counts, etc)
+ * - floating point I/O statistics (timestamps, cumulative timers, etc.)
+ */
struct darshan_mpiio_file
{
darshan_record_id f_id;
diff --git a/darshan-posix-log-format.h b/darshan-posix-log-format.h
index b3c5f20..35457dc 100644
--- a/darshan-posix-log-format.h
+++ b/darshan-posix-log-format.h
@@ -8,112 +8,155 @@
#include "darshan-log-format.h"
-/* TODO: X macro this stuff so counter indices and string names don't diverge */
+/* TODO we need to be able to run more reduction operations to get
+ * time and byte variances for shared files. currently, darshan-core
+ * just runs a single reduction, which is used to reduce all other
+ * shared record fields. (VARIANCE_RANK_TIME, VARIANCE_RANK_BYTES) */
+#define POSIX_COUNTERS \
+ /* count of posix opens */\
+ X(POSIX_OPENS) \
+ /* count of posix reads */\
+ X(POSIX_READS) \
+ /* count of posix writes */\
+ X(POSIX_WRITES) \
+ /* count of posix seeks */\
+ X(POSIX_SEEKS) \
+ /* count of posix stat/lstat/fstats */\
+ X(POSIX_STATS) \
+ /* count of posix mmaps */\
+ X(POSIX_MMAPS) \
+ /* count of posix fopens */\
+ X(POSIX_FOPENS) \
+ /* count of posix freads */\
+ X(POSIX_FREADS) \
+ /* count of posix fwrites */\
+ X(POSIX_FWRITES) \
+ /* count of posix fseeks */\
+ X(POSIX_FSEEKS) \
+ /* count of posix fsyncs */\
+ X(POSIX_FSYNCS) \
+ /* count of posix fdatasyncs */\
+ X(POSIX_FDSYNCS) \
+ /* mode of file */\
+ X(POSIX_MODE) \
+ /* total bytes read */\
+ X(POSIX_BYTES_READ) \
+ /* total bytes written */\
+ X(POSIX_BYTES_WRITTEN) \
+ /* highest offset byte read */\
+ X(POSIX_MAX_BYTE_READ) \
+ /* highest offset byte written */\
+ X(POSIX_MAX_BYTE_WRITTEN) \
+ /* count of consecutive reads */\
+ X(POSIX_CONSEC_READS) \
+ /* count of consecutive writes */\
+ X(POSIX_CONSEC_WRITES) \
+ /* count of sequential reads */\
+ X(POSIX_SEQ_READS) \
+ /* count of sequential writes */\
+ X(POSIX_SEQ_WRITES) \
+ /* number of times switched between read and write */\
+ X(POSIX_RW_SWITCHES) \
+ /* count of accesses not mem aligned */\
+ X(POSIX_MEM_NOT_ALIGNED) \
+ /* mem alignment in bytes */\
+ X(POSIX_MEM_ALIGNMENT) \
+ /* count of accesses not file aligned */\
+ X(POSIX_FILE_NOT_ALIGNED) \
+ /* file alignment in bytes */\
+ X(POSIX_FILE_ALIGNMENT) \
+ X(POSIX_MAX_READ_TIME_SIZE) \
+ X(POSIX_MAX_WRITE_TIME_SIZE) \
+ /* buckets for POSIX read size ranges */\
+ X(POSIX_SIZE_READ_0_100) \
+ X(POSIX_SIZE_READ_100_1K) \
+ X(POSIX_SIZE_READ_1K_10K) \
+ X(POSIX_SIZE_READ_10K_100K) \
+ X(POSIX_SIZE_READ_100K_1M) \
+ X(POSIX_SIZE_READ_1M_4M) \
+ X(POSIX_SIZE_READ_4M_10M) \
+ X(POSIX_SIZE_READ_10M_100M) \
+ X(POSIX_SIZE_READ_100M_1G) \
+ X(POSIX_SIZE_READ_1G_PLUS) \
+ /* buckets for POSIX write size ranges */\
+ X(POSIX_SIZE_WRITE_0_100) \
+ X(POSIX_SIZE_WRITE_100_1K) \
+ X(POSIX_SIZE_WRITE_1K_10K) \
+ X(POSIX_SIZE_WRITE_10K_100K) \
+ X(POSIX_SIZE_WRITE_100K_1M) \
+ X(POSIX_SIZE_WRITE_1M_4M) \
+ X(POSIX_SIZE_WRITE_4M_10M) \
+ X(POSIX_SIZE_WRITE_10M_100M) \
+ X(POSIX_SIZE_WRITE_100M_1G) \
+ X(POSIX_SIZE_WRITE_1G_PLUS) \
+ /* the four most frequently appearing strides */\
+ X(POSIX_STRIDE1_STRIDE) \
+ X(POSIX_STRIDE2_STRIDE) \
+ X(POSIX_STRIDE3_STRIDE) \
+ X(POSIX_STRIDE4_STRIDE) \
+ /* count of each of the most frequent strides */\
+ X(POSIX_STRIDE1_COUNT) \
+ X(POSIX_STRIDE2_COUNT) \
+ X(POSIX_STRIDE3_COUNT) \
+ X(POSIX_STRIDE4_COUNT) \
+ /* the four most frequently appearing access sizes */\
+ X(POSIX_ACCESS1_ACCESS) \
+ X(POSIX_ACCESS2_ACCESS) \
+ X(POSIX_ACCESS3_ACCESS) \
+ X(POSIX_ACCESS4_ACCESS) \
+ /* count of each of the most frequent access sizes */\
+ X(POSIX_ACCESS1_COUNT) \
+ X(POSIX_ACCESS2_COUNT) \
+ X(POSIX_ACCESS3_COUNT) \
+ X(POSIX_ACCESS4_COUNT) \
+ X(POSIX_FASTEST_RANK) \
+ X(POSIX_FASTEST_RANK_BYTES) \
+ X(POSIX_SLOWEST_RANK) \
+ X(POSIX_SLOWEST_RANK_BYTES) \
+ /* end of counters */\
+ X(POSIX_NUM_INDICES)
+
+#define POSIX_F_COUNTERS \
+ /* timestamp of first open */\
+ X(POSIX_F_OPEN_TIMESTAMP) \
+ /* timestamp of first read */\
+ X(POSIX_F_READ_START_TIMESTAMP) \
+ /* timestamp of first write */\
+ X(POSIX_F_WRITE_START_TIMESTAMP) \
+ /* timestamp of last read */\
+ X(POSIX_F_READ_END_TIMESTAMP) \
+ /* timestamp of last write */\
+ X(POSIX_F_WRITE_END_TIMESTAMP) \
+ /* timestamp of last close */\
+ X(POSIX_F_CLOSE_TIMESTAMP) \
+ /* cumulative posix read time */\
+ X(POSIX_F_READ_TIME) \
+ /* cumulative posix write time */\
+ X(POSIX_F_WRITE_TIME) \
+ /* cumulative posix meta time */\
+ X(POSIX_F_META_TIME) \
+ X(POSIX_F_MAX_READ_TIME) \
+ X(POSIX_F_MAX_WRITE_TIME) \
+ /* total i/o and meta time consumed for fastest/slowest ranks */\
+ X(POSIX_F_FASTEST_RANK_TIME) \
+ X(POSIX_F_SLOWEST_RANK_TIME) \
+ /* end of counters */\
+ X(POSIX_F_NUM_INDICES)
+
+#define X(a) a,
/* integer statistics for POSIX file records */
enum darshan_posix_indices
{
- POSIX_OPENS, /* count of posix opens */
- POSIX_READS, /* count of posix reads */
- POSIX_WRITES, /* count of posix writes */
- POSIX_SEEKS, /* count of posix seeks */
- POSIX_STATS, /* count of posix stat/lstat/fstats */
- POSIX_MMAPS, /* count of posix mmaps */
- POSIX_FOPENS, /* count of posix fopens */
- POSIX_FREADS, /* count of posix freads */
- POSIX_FWRITES, /* count of posix fwrites */
- POSIX_FSEEKS, /* count of posix fseeks */
- POSIX_FSYNCS, /* count of posix fsyncs */
- POSIX_FDSYNCS, /* count of posix fdatasyncs */
- POSIX_MODE, /* mode of file */
- POSIX_BYTES_READ, /* total bytes read */
- POSIX_BYTES_WRITTEN, /* total bytes written */
- POSIX_MAX_BYTE_READ, /* highest offset byte read */
- POSIX_MAX_BYTE_WRITTEN, /* highest offset byte written */
- POSIX_CONSEC_READS, /* count of consecutive reads */
- POSIX_CONSEC_WRITES, /* count of consecutive writes */
- POSIX_SEQ_READS, /* count of sequential reads */
- POSIX_SEQ_WRITES, /* count of sequential writes */
- POSIX_RW_SWITCHES, /* number of times switched between read and write */
- POSIX_MEM_NOT_ALIGNED, /* count of accesses not mem aligned */
- POSIX_MEM_ALIGNMENT, /* mem alignment in bytes */
- POSIX_FILE_NOT_ALIGNED, /* count of accesses not file aligned */
- POSIX_FILE_ALIGNMENT, /* file alignment in bytes */
- POSIX_MAX_READ_TIME_SIZE,
- POSIX_MAX_WRITE_TIME_SIZE,
- /* buckets */
- POSIX_SIZE_READ_0_100, /* count of posix read size ranges */
- POSIX_SIZE_READ_100_1K,
- POSIX_SIZE_READ_1K_10K,
- POSIX_SIZE_READ_10K_100K,
- POSIX_SIZE_READ_100K_1M,
- POSIX_SIZE_READ_1M_4M,
- POSIX_SIZE_READ_4M_10M,
- POSIX_SIZE_READ_10M_100M,
- POSIX_SIZE_READ_100M_1G,
- POSIX_SIZE_READ_1G_PLUS,
- /* buckets */
- POSIX_SIZE_WRITE_0_100, /* count of posix write size ranges */
- POSIX_SIZE_WRITE_100_1K,
- POSIX_SIZE_WRITE_1K_10K,
- POSIX_SIZE_WRITE_10K_100K,
- POSIX_SIZE_WRITE_100K_1M,
- POSIX_SIZE_WRITE_1M_4M,
- POSIX_SIZE_WRITE_4M_10M,
- POSIX_SIZE_WRITE_10M_100M,
- POSIX_SIZE_WRITE_100M_1G,
- POSIX_SIZE_WRITE_1G_PLUS,
- /* stride/access counters */
- POSIX_STRIDE1_STRIDE, /* the four most frequently appearing strides */
- POSIX_STRIDE2_STRIDE,
- POSIX_STRIDE3_STRIDE,
- POSIX_STRIDE4_STRIDE,
- POSIX_STRIDE1_COUNT, /* count of each of the most frequent strides */
- POSIX_STRIDE2_COUNT,
- POSIX_STRIDE3_COUNT,
- POSIX_STRIDE4_COUNT,
- POSIX_ACCESS1_ACCESS, /* the four most frequently appearing access sizes */
- POSIX_ACCESS2_ACCESS,
- POSIX_ACCESS3_ACCESS,
- POSIX_ACCESS4_ACCESS,
- POSIX_ACCESS1_COUNT, /* count of each of the most frequent access sizes */
- POSIX_ACCESS2_COUNT,
- POSIX_ACCESS3_COUNT,
- POSIX_ACCESS4_COUNT,
- POSIX_FASTEST_RANK,
- POSIX_FASTEST_RANK_BYTES,
- POSIX_SLOWEST_RANK,
- POSIX_SLOWEST_RANK_BYTES,
-
- POSIX_NUM_INDICES,
+ POSIX_COUNTERS
};
/* floating point statistics for POSIX file records */
enum darshan_posix_f_indices
{
- POSIX_F_OPEN_TIMESTAMP = 0, /* timestamp of first open */
- POSIX_F_READ_START_TIMESTAMP, /* timestamp of first read */
- POSIX_F_WRITE_START_TIMESTAMP, /* timestamp of first write */
- POSIX_F_READ_END_TIMESTAMP, /* timestamp of last read */
- POSIX_F_WRITE_END_TIMESTAMP, /* timestamp of last write */
- POSIX_F_CLOSE_TIMESTAMP, /* timestamp of last close */
- POSIX_F_READ_TIME, /* cumulative posix read time */
- POSIX_F_WRITE_TIME, /* cumulative posix write time */
- POSIX_F_META_TIME, /* cumulative posix meta time */
- POSIX_F_MAX_READ_TIME,
- POSIX_F_MAX_WRITE_TIME,
- /* Total I/O and meta time consumed by fastest and slowest ranks */
- POSIX_F_FASTEST_RANK_TIME,
- POSIX_F_SLOWEST_RANK_TIME,
- /* TODO we need to be able to run more reduction operations to get
- * time and byte variances for shared files. currently, darshan-core
- * just runs a single reduction, which is used to reduce all other
- * shared record fields. */
- //F_VARIANCE_RANK_TIME,
- //F_VARIANCE_RANK_BYTES,
-
- POSIX_F_NUM_INDICES,
+ POSIX_F_COUNTERS
};
+#undef X
/* file record structure for POSIX files. a record is created and stored for
* every POSIX file opened by the original application. For the POSIX module,
diff --git a/darshan-runtime/darshan.h b/darshan-runtime/darshan.h
index 47fbb37..13bad59 100644
--- a/darshan-runtime/darshan.h
+++ b/darshan-runtime/darshan.h
@@ -172,6 +172,12 @@ struct darshan_module_funcs
);
};
+enum darshan_io_type
+{
+ DARSHAN_IO_READ = 1,
+ DARSHAN_IO_WRITE = 2,
+};
+
/* paths that darshan will not trace */
extern char* darshan_path_exclusions[]; /* defined in lib/darshan-core.c */
diff --git a/darshan-runtime/lib/darshan-mpiio.c b/darshan-runtime/lib/darshan-mpiio.c
index 9fd4246..8fd7f13 100644
--- a/darshan-runtime/lib/darshan-mpiio.c
+++ b/darshan-runtime/lib/darshan-mpiio.c
@@ -56,6 +56,7 @@
struct mpiio_file_runtime
{
struct darshan_mpiio_file* file_record;
+ enum darshan_io_type last_io_type;
double last_meta_end;
double last_read_end;
double last_write_end;
@@ -136,41 +137,52 @@ static void mpiio_shutdown(void);
#define MPIIO_RECORD_READ(__ret, __fh, __count, __datatype, __counter, __tm1, __tm2) do { \
struct mpiio_file_runtime* file; \
int size = 0; \
- MPI_Aint extent = 0; \
+ double __elapsed = __tm2-__tm1; \
if(__ret != MPI_SUCCESS) break; \
file = mpiio_file_by_fh(__fh); \
if(!file) break; \
DARSHAN_MPI_CALL(PMPI_Type_size)(__datatype, &size); \
size = size * __count; \
- DARSHAN_MPI_CALL(PMPI_Type_extent)(__datatype, &extent); \
DARSHAN_BUCKET_INC(file->file_record, MPIIO_SIZE_READ_AGG_0_100, size); \
- DARSHAN_BUCKET_INC(file->file_record, MPIIO_EXTENT_READ_0_100, extent); \
+ DARSHAN_COUNTER_INC(file->file_record, MPIIO_BYTES_READ, size); \
DARSHAN_COUNTER_INC(file->file_record, __counter, 1); \
+ if(file->last_io_type == DARSHAN_IO_WRITE) \
+ DARSHAN_COUNTER_INC(file->file_record, MPIIO_RW_SWITCHES, 1); \
+ file->last_io_type = DARSHAN_IO_READ; \
DARSHAN_COUNTER_F_INC_NO_OVERLAP(file->file_record, __tm1, __tm2, \
file->last_read_end, MPIIO_F_READ_TIME); \
if(DARSHAN_COUNTER_F_VALUE(file->file_record, MPIIO_F_READ_START_TIMESTAMP) == 0) \
DARSHAN_COUNTER_F_SET(file->file_record, MPIIO_F_READ_START_TIMESTAMP, __tm1); \
DARSHAN_COUNTER_F_SET(file->file_record, MPIIO_F_READ_END_TIMESTAMP, __tm2); \
+ if(DARSHAN_COUNTER_F_VALUE(file->file_record, MPIIO_F_MAX_READ_TIME) < __elapsed) { \
+ DARSHAN_COUNTER_F_SET(file->file_record, MPIIO_F_MAX_READ_TIME, __elapsed); \
+ DARSHAN_COUNTER_SET(file->file_record, MPIIO_MAX_READ_TIME_SIZE, size); } \
} while(0)
#define MPIIO_RECORD_WRITE(__ret, __fh, __count, __datatype, __counter, __tm1, __tm2) do { \
struct mpiio_file_runtime* file; \
int size = 0; \
- MPI_Aint extent = 0; \
+ double __elapsed = __tm2-__tm1; \
+ if(__ret != MPI_SUCCESS) break; \
if(__ret != MPI_SUCCESS) break; \
file = mpiio_file_by_fh(__fh); \
if(!file) break; \
DARSHAN_MPI_CALL(PMPI_Type_size)(__datatype, &size); \
size = size * __count; \
- DARSHAN_MPI_CALL(PMPI_Type_extent)(__datatype, &extent); \
DARSHAN_BUCKET_INC(file->file_record, MPIIO_SIZE_WRITE_AGG_0_100, size); \
- DARSHAN_BUCKET_INC(file->file_record, MPIIO_EXTENT_WRITE_0_100, extent); \
+ DARSHAN_COUNTER_INC(file->file_record, MPIIO_BYTES_WRITTEN, size); \
DARSHAN_COUNTER_INC(file->file_record, __counter, 1); \
+ if(file->last_io_type == DARSHAN_IO_READ) \
+ DARSHAN_COUNTER_INC(file->file_record, MPIIO_RW_SWITCHES, 1); \
+ file->last_io_type = DARSHAN_IO_WRITE; \
DARSHAN_COUNTER_F_INC_NO_OVERLAP(file->file_record, __tm1, __tm2, \
file->last_write_end, MPIIO_F_WRITE_TIME); \
if(DARSHAN_COUNTER_F_VALUE(file->file_record, MPIIO_F_WRITE_START_TIMESTAMP) == 0) \
DARSHAN_COUNTER_F_SET(file->file_record, MPIIO_F_WRITE_START_TIMESTAMP, __tm1); \
DARSHAN_COUNTER_F_SET(file->file_record, MPIIO_F_WRITE_END_TIMESTAMP, __tm2); \
+ if(DARSHAN_COUNTER_F_VALUE(file->file_record, MPIIO_F_MAX_WRITE_TIME) < __elapsed) { \
+ DARSHAN_COUNTER_F_SET(file->file_record, MPIIO_F_MAX_WRITE_TIME, __elapsed); \
+ DARSHAN_COUNTER_SET(file->file_record, MPIIO_MAX_WRITE_TIME_SIZE, size); } \
} while(0)
/**********************************************************
diff --git a/darshan-runtime/lib/darshan-posix.c b/darshan-runtime/lib/darshan-posix.c
index 4d295bd..3646a30 100644
--- a/darshan-runtime/lib/darshan-posix.c
+++ b/darshan-runtime/lib/darshan-posix.c
@@ -96,12 +96,6 @@ DARSHAN_FORWARD_DECL(lio_listio64, int, (int mode, struct aiocb64 *const aiocb_l
*/
#define POSIX_MAX_ACCESS_COUNT_RUNTIME 32
-enum posix_io_type
-{
- POSIX_READ = 1,
- POSIX_WRITE = 2,
-};
-
enum posix_counter_type
{
POSIX_COUNTER_ACCESS,
@@ -151,7 +145,7 @@ struct posix_file_runtime
int64_t offset;
int64_t last_byte_read;
int64_t last_byte_written;
- enum posix_io_type last_io_type;
+ enum darshan_io_type last_io_type;
double last_meta_end;
double last_read_end;
double last_write_end;
@@ -336,9 +330,9 @@ static void posix_shutdown(void);
file_alignment = DARSHAN_COUNTER_VALUE(file->file_record, POSIX_FILE_ALIGNMENT); \
if(file_alignment > 0 && (this_offset % file_alignment) != 0) \
DARSHAN_COUNTER_INC(file->file_record, POSIX_FILE_NOT_ALIGNED, 1); \
- if(file->last_io_type == POSIX_WRITE) \
+ if(file->last_io_type == DARSHAN_IO_WRITE) \
DARSHAN_COUNTER_INC(file->file_record, POSIX_RW_SWITCHES, 1); \
- file->last_io_type = POSIX_READ; \
+ file->last_io_type = DARSHAN_IO_READ; \
DARSHAN_COUNTER_F_INC_NO_OVERLAP(file->file_record, __tm1, __tm2, file->last_read_end, POSIX_F_READ_TIME); \
if(DARSHAN_COUNTER_F_VALUE(file->file_record, POSIX_F_READ_START_TIMESTAMP) == 0) \
DARSHAN_COUNTER_F_SET(file->file_record, POSIX_F_READ_START_TIMESTAMP, __tm1); \
@@ -386,9 +380,9 @@ static void posix_shutdown(void);
file_alignment = DARSHAN_COUNTER_VALUE(file->file_record, POSIX_FILE_ALIGNMENT); \
if(file_alignment > 0 && (this_offset % file_alignment) != 0) \
DARSHAN_COUNTER_INC(file->file_record, POSIX_FILE_NOT_ALIGNED, 1); \
- if(file->last_io_type == POSIX_READ) \
+ if(file->last_io_type == DARSHAN_IO_READ) \
DARSHAN_COUNTER_INC(file->file_record, POSIX_RW_SWITCHES, 1); \
- file->last_io_type = POSIX_WRITE; \
+ file->last_io_type = DARSHAN_IO_WRITE; \
DARSHAN_COUNTER_F_INC_NO_OVERLAP(file->file_record, __tm1, __tm2, file->last_write_end, POSIX_F_WRITE_TIME); \
if(DARSHAN_COUNTER_F_VALUE(file->file_record, POSIX_F_WRITE_START_TIMESTAMP) == 0) \
DARSHAN_COUNTER_F_SET(file->file_record, POSIX_F_WRITE_START_TIMESTAMP, __tm1); \
diff --git a/darshan-util/darshan-mpiio-logutils.c b/darshan-util/darshan-mpiio-logutils.c
index 9b4c537..d86697b 100644
--- a/darshan-util/darshan-mpiio-logutils.c
+++ b/darshan-util/darshan-mpiio-logutils.c
@@ -19,6 +19,17 @@
#include "darshan-mpiio-logutils.h"
+/* counter name strings for the MPI-IO module */
+#define X(a) #a,
+char *mpiio_counter_names[] = {
+ MPIIO_COUNTERS
+};
+
+char *mpiio_f_counter_names[] = {
+ MPIIO_F_COUNTERS
+};
+#undef X
+
int darshan_log_get_mpiio_file(darshan_fd fd, struct darshan_mpiio_file *file)
{
int i;
diff --git a/darshan-util/darshan-mpiio-logutils.h b/darshan-util/darshan-mpiio-logutils.h
index 965225f..5c210bc 100644
--- a/darshan-util/darshan-mpiio-logutils.h
+++ b/darshan-util/darshan-mpiio-logutils.h
@@ -10,6 +10,21 @@
#include "darshan-logutils.h"
#include "darshan-mpiio-log-format.h"
+extern char *mpiio_counter_names[];
+extern char *mpiio_f_counter_names[];
+
int darshan_log_get_mpiio_file(darshan_fd fd, struct darshan_mpiio_file *file);
+#define MPIIO_COUNTER_PRINT(__file_rec, __counter) do { \
+ printf("%" PRId64 "\t%" PRIu64 "\t%s\t%" PRId64 "\n", \
+ (__file_rec)->rank, (__file_rec)->f_id, mpiio_counter_names[__counter], \
+ (__file_rec)->counters[__counter]); \
+} while(0)
+
+#define MPIIO_F_COUNTER_PRINT(__file_rec, __counter) do { \
+ printf("%" PRId64 "\t%" PRIu64 "\t%s\t%f\n", \
+ (__file_rec)->rank, (__file_rec)->f_id, mpiio_f_counter_names[__counter], \
+ (__file_rec)->fcounters[__counter]); \
+} while(0)
+
#endif
diff --git a/darshan-util/darshan-mpiio-parser.c b/darshan-util/darshan-mpiio-parser.c
index 3d09fda..c7db9fa 100644
--- a/darshan-util/darshan-mpiio-parser.c
+++ b/darshan-util/darshan-mpiio-parser.c
@@ -151,8 +151,6 @@ int main(int argc, char **argv)
/* end TODO */
/*******************************************/
- printf("\n*** FILE RECORD DATA ***\n");
-
ret = darshan_log_get_mpiio_file(fd, &next_file);
if(ret < 0)
{
@@ -168,58 +166,20 @@ int main(int argc, char **argv)
}
/* loop over each stored MPIIO file record and print counters */
- i = 1;
do
{
/* get the pathname for this record */
HASH_FIND(hlink, rec_hash, &next_file.f_id, sizeof(darshan_record_id), ref);
assert(ref);
- printf("\tRecord %d: id=%"PRIu64" (path=%s, rank=%"PRId64")\n",
- i, next_file.f_id, ref->rec.name, next_file.rank);
- /* TODO: does it make sense to put these in a header or something?
- * Down side of listing them here is ordering dependency between enum
- * in header and names here.
- */
- printf(
- "\t\tMPIIO_INDEP_OPENS:\t%"PRIu64"\n"
- "\t\tMPIIO_COLL_OPENS:\t%"PRIu64"\n"
- "\t\tMPIIO_INDEP_READS:\t%"PRIu64"\n"
- "\t\tMPIIO_INDEP_WRITES:\t%"PRIu64"\n"
- "\t\tMPIIO_COLL_READS:\t%"PRIu64"\n"
- "\t\tMPIIO_COLL_WRITES:\t%"PRIu64"\n"
- "\t\tMPIIO_SPLIT_READS:\t%"PRIu64"\n"
- "\t\tMPIIO_SPLIT_WRITES:\t%"PRIu64"\n"
- "\t\tMPIIO_NB_READS:\t%"PRIu64"\n"
- "\t\tMPIIO_NB_WRITES:\t%"PRIu64"\n"
- "\t\tMPIIO_SYNCS:\t%"PRIu64"\n"
- "\t\tMPIIO_HINTS:\t%"PRIu64"\n"
- "\t\tMPIIO_VIEWS:\t%"PRIu64"\n"
- "\t\tMPIIO_F_OPEN_TIMESTAMP:\t%lf\n"
- "\t\tMPIIO_F_CLOSE_TIMESTAMP:\t%lf\n"
- "\t\tMPIIO_F_READ_TIME:\t%lf\n"
- "\t\tMPIIO_F_WRITE_TIME:\t%lf\n"
- "\t\tMPIIO_F_META_TIME:\t%lf\n",
- next_file.counters[MPIIO_INDEP_OPENS],
- next_file.counters[MPIIO_COLL_OPENS],
- next_file.counters[MPIIO_INDEP_READS],
- next_file.counters[MPIIO_INDEP_WRITES],
- next_file.counters[MPIIO_COLL_READS],
- next_file.counters[MPIIO_COLL_WRITES],
- next_file.counters[MPIIO_SPLIT_READS],
- next_file.counters[MPIIO_SPLIT_WRITES],
- next_file.counters[MPIIO_NB_READS],
- next_file.counters[MPIIO_NB_WRITES],
- next_file.counters[MPIIO_SYNCS],
- next_file.counters[MPIIO_HINTS],
- next_file.counters[MPIIO_VIEWS],
- next_file.fcounters[MPIIO_F_OPEN_TIMESTAMP],
- next_file.fcounters[MPIIO_F_CLOSE_TIMESTAMP],
- next_file.fcounters[MPIIO_F_READ_TIME],
- next_file.fcounters[MPIIO_F_WRITE_TIME],
- next_file.fcounters[MPIIO_F_META_TIME]);
-
- i++;
+ for(i=0; i<MPIIO_NUM_INDICES; i++)
+ {
+ MPIIO_COUNTER_PRINT(&next_file, i);
+ }
+ for(i=0; i<MPIIO_F_NUM_INDICES; i++)
+ {
+ MPIIO_F_COUNTER_PRINT(&next_file, i);
+ }
} while((ret = darshan_log_get_mpiio_file(fd, &next_file)) == 1);
/* free mount info */
diff --git a/darshan-util/darshan-posix-logutils.c b/darshan-util/darshan-posix-logutils.c
index 51ba78d..279a5ba 100644
--- a/darshan-util/darshan-posix-logutils.c
+++ b/darshan-util/darshan-posix-logutils.c
@@ -19,6 +19,17 @@
#include "darshan-posix-logutils.h"
+/* counter name strings for the POSIX module */
+#define X(a) #a,
+char *posix_counter_names[] = {
+ POSIX_COUNTERS
+};
+
+char *posix_f_counter_names[] = {
+ POSIX_F_COUNTERS
+};
+#undef X
+
int darshan_log_get_posix_file(darshan_fd fd, struct darshan_posix_file *file)
{
int i;
diff --git a/darshan-util/darshan-posix-logutils.h b/darshan-util/darshan-posix-logutils.h
index 59b307e..345e79e 100644
--- a/darshan-util/darshan-posix-logutils.h
+++ b/darshan-util/darshan-posix-logutils.h
@@ -10,6 +10,21 @@
#include "darshan-logutils.h"
#include "darshan-posix-log-format.h"
+extern char *posix_counter_names[];
+extern char *posix_f_counter_names[];
+
int darshan_log_get_posix_file(darshan_fd fd, struct darshan_posix_file *file);
+#define POSIX_COUNTER_PRINT(__file_rec, __counter) do { \
+ printf("%" PRId64 "\t%" PRIu64 "\t%s\t%" PRId64 "\n", \
+ (__file_rec)->rank, (__file_rec)->f_id, posix_counter_names[__counter], \
+ (__file_rec)->counters[__counter]); \
+} while(0)
+
+#define POSIX_F_COUNTER_PRINT(__file_rec, __counter) do { \
+ printf("%" PRId64 "\t%" PRIu64 "\t%s\t%f\n", \
+ (__file_rec)->rank, (__file_rec)->f_id, posix_f_counter_names[__counter], \
+ (__file_rec)->fcounters[__counter]); \
+} while(0)
+
#endif
diff --git a/darshan-util/darshan-posix-parser.c b/darshan-util/darshan-posix-parser.c
index 9c9dbd0..6a1100f 100644
--- a/darshan-util/darshan-posix-parser.c
+++ b/darshan-util/darshan-posix-parser.c
@@ -160,180 +160,21 @@ int main(int argc, char **argv)
}
/* loop over each stored POSIX file record and print counters */
- i = 1;
do
{
/* get the pathname for this record */
HASH_FIND(hlink, rec_hash, &next_file.f_id, sizeof(darshan_record_id), ref);
assert(ref);
- printf("\tRecord %d: id=%"PRIu64" (path=%s, rank=%"PRId64")\n",
- i, next_file.f_id, ref->rec.name, next_file.rank);
- printf(
- "\t\tPOSIX_OPENS:\t%"PRIu64"\n"
- "\t\tPOSIX_READS:\t%"PRIu64"\n"
- "\t\tPOSIX_WRITES:\t%"PRIu64"\n"
- "\t\tPOSIX_SEEKS:\t%"PRIu64"\n"
- "\t\tPOSIX_STATS:\t%"PRIu64"\n"
- "\t\tPOSIX_MMAPS:\t%"PRIu64"\n"
- "\t\tPOSIX_FOPENS:\t%"PRIu64"\n"
- "\t\tPOSIX_FREADS:\t%"PRIu64"\n"
- "\t\tPOSIX_FWRITES:\t%"PRIu64"\n"
- "\t\tPOSIX_FSEEKS:\t%"PRIu64"\n"
- "\t\tPOSIX_FSYNCS:\t%"PRIu64"\n"
- "\t\tPOSIX_FDSYNCS:\t%"PRIu64"\n"
- "\t\tPOSIX_MODE:\t%"PRIu64"\n"
- "\t\tPOSIX_BYTES_READ:\t%"PRIu64"\n"
- "\t\tPOSIX_BYTES_WRITTEN:\t%"PRIu64"\n"
- "\t\tPOSIX_MAX_BYTE_READ:\t%"PRIu64"\n"
- "\t\tPOSIX_MAX_BYTE_WRITTEN:\t%"PRIu64"\n"
- "\t\tPOSIX_CONSEC_READS:\t%"PRIu64"\n"
- "\t\tPOSIX_CONSEC_WRITES:\t%"PRIu64"\n"
- "\t\tPOSIX_SEQ_READS:\t%"PRIu64"\n"
- "\t\tPOSIX_SEQ_WRITES:\t%"PRIu64"\n"
- "\t\tPOSIX_RW_SWITCHES:\t%"PRIu64"\n"
- "\t\tPOSIX_MEM_NOT_ALIGNED:\t%"PRIu64"\n"
- "\t\tPOSIX_MEM_ALIGNMENT:\t%"PRIu64"\n"
- "\t\tPOSIX_FILE_NOT_ALIGNED:\t%"PRIu64"\n"
- "\t\tPOSIX_FILE_ALIGNMENT:\t%"PRIu64"\n"
- "\t\tPOSIX_MAX_READ_TIME_SIZE:\t%"PRIu64"\n"
- "\t\tPOSIX_MAX_WRITE_TIME_SIZE:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_READ_0_100:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_READ_100_1K:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_READ_1K_10K:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_READ_10K_100K:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_READ_100K_1M:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_READ_1M_4M:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_READ_4M_10M:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_READ_10M_100M:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_READ_100M_1G:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_READ_1G_PLUS:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_WRITE_0_100:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_WRITE_100_1K:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_WRITE_1K_10K:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_WRITE_10K_100K:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_WRITE_100K_1M:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_WRITE_1M_4M:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_WRITE_4M_10M:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_WRITE_10M_100M:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_WRITE_100M_1G:\t%"PRIu64"\n"
- "\t\tPOSIX_SIZE_WRITE_1G_PLUS:\t%"PRIu64"\n"
- "\t\tPOSIX_STRIDE1_STRIDE:\t%"PRIu64"\n"
- "\t\tPOSIX_STRIDE2_STRIDE:\t%"PRIu64"\n"
- "\t\tPOSIX_STRIDE3_STRIDE:\t%"PRIu64"\n"
- "\t\tPOSIX_STRIDE4_STRIDE:\t%"PRIu64"\n"
- "\t\tPOSIX_STRIDE1_COUNT:\t%"PRIu64"\n"
- "\t\tPOSIX_STRIDE2_COUNT:\t%"PRIu64"\n"
- "\t\tPOSIX_STRIDE3_COUNT:\t%"PRIu64"\n"
- "\t\tPOSIX_STRIDE4_COUNT:\t%"PRIu64"\n"
- "\t\tPOSIX_ACCESS1_ACCESS:\t%"PRIu64"\n"
- "\t\tPOSIX_ACCESS2_ACCESS:\t%"PRIu64"\n"
- "\t\tPOSIX_ACCESS3_ACCESS:\t%"PRIu64"\n"
- "\t\tPOSIX_ACCESS4_ACCESS:\t%"PRIu64"\n"
- "\t\tPOSIX_ACCESS1_COUNT:\t%"PRIu64"\n"
- "\t\tPOSIX_ACCESS2_COUNT:\t%"PRIu64"\n"
- "\t\tPOSIX_ACCESS3_COUNT:\t%"PRIu64"\n"
- "\t\tPOSIX_ACCESS4_COUNT:\t%"PRIu64"\n"
- "\t\tPOSIX_FASTEST_RANK:\t%"PRIu64"\n"
- "\t\tPOSIX_FASTEST_RANK_BYTES:\t%"PRIu64"\n"
- "\t\tPOSIX_SLOWEST_RANK:\t%"PRIu64"\n"
- "\t\tPOSIX_SLOWEST_RANK_BYTES:\t%"PRIu64"\n"
- "\t\tPOSIX_F_OPEN_TIMESTAMP:\t%lf\n"
- "\t\tPOSIX_F_READ_START_TIMESTAMP:\t%lf\n"
- "\t\tPOSIX_F_WRITE_START_TIMESTAMP:\t%lf\n"
- "\t\tPOSIX_F_READ_END_TIMESTAMP:\t%lf\n"
- "\t\tPOSIX_F_WRITE_END_TIMESTAMP:\t%lf\n"
- "\t\tPOSIX_F_CLOSE_TIMESTAMP:\t%lf\n"
- "\t\tPOSIX_F_READ_TIME:\t%lf\n"
- "\t\tPOSIX_F_WRITE_TIME:\t%lf\n"
- "\t\tPOSIX_F_META_TIME:\t%lf\n"
- "\t\tPOSIX_F_MAX_READ_TIME:\t%lf\n"
- "\t\tPOSIX_F_MAX_WRITE_TIME:\t%lf\n"
- "\t\tPOSIX_F_FASTEST_RANK_TIME:\t%lf\n"
- "\t\tPOSIX_F_SLOWEST_RANK_TIME:\t%lf\n",
- next_file.counters[POSIX_OPENS],
- next_file.counters[POSIX_READS],
- next_file.counters[POSIX_WRITES],
- next_file.counters[POSIX_SEEKS],
- next_file.counters[POSIX_STATS],
- next_file.counters[POSIX_MMAPS],
- next_file.counters[POSIX_FOPENS],
- next_file.counters[POSIX_FREADS],
- next_file.counters[POSIX_FWRITES],
- next_file.counters[POSIX_FSEEKS],
- next_file.counters[POSIX_FSYNCS],
- next_file.counters[POSIX_FDSYNCS],
- next_file.counters[POSIX_MODE],
- next_file.counters[POSIX_BYTES_READ],
- next_file.counters[POSIX_BYTES_WRITTEN],
- next_file.counters[POSIX_MAX_BYTE_READ],
- next_file.counters[POSIX_MAX_BYTE_WRITTEN],
- next_file.counters[POSIX_CONSEC_READS],
- next_file.counters[POSIX_CONSEC_WRITES],
- next_file.counters[POSIX_SEQ_READS],
- next_file.counters[POSIX_SEQ_WRITES],
- next_file.counters[POSIX_RW_SWITCHES],
- next_file.counters[POSIX_MEM_NOT_ALIGNED],
- next_file.counters[POSIX_MEM_ALIGNMENT],
- next_file.counters[POSIX_FILE_NOT_ALIGNED],
- next_file.counters[POSIX_FILE_ALIGNMENT],
- next_file.counters[POSIX_MAX_READ_TIME_SIZE],
- next_file.counters[POSIX_MAX_WRITE_TIME_SIZE],
- next_file.counters[POSIX_SIZE_READ_0_100],
- next_file.counters[POSIX_SIZE_READ_100_1K],
- next_file.counters[POSIX_SIZE_READ_1K_10K],
- next_file.counters[POSIX_SIZE_READ_10K_100K],
- next_file.counters[POSIX_SIZE_READ_100K_1M],
- next_file.counters[POSIX_SIZE_READ_1M_4M],
- next_file.counters[POSIX_SIZE_READ_4M_10M],
- next_file.counters[POSIX_SIZE_READ_10M_100M],
- next_file.counters[POSIX_SIZE_READ_100M_1G],
- next_file.counters[POSIX_SIZE_READ_1G_PLUS],
- next_file.counters[POSIX_SIZE_WRITE_0_100],
- next_file.counters[POSIX_SIZE_WRITE_100_1K],
- next_file.counters[POSIX_SIZE_WRITE_1K_10K],
- next_file.counters[POSIX_SIZE_WRITE_10K_100K],
- next_file.counters[POSIX_SIZE_WRITE_100K_1M],
- next_file.counters[POSIX_SIZE_WRITE_1M_4M],
- next_file.counters[POSIX_SIZE_WRITE_4M_10M],
- next_file.counters[POSIX_SIZE_WRITE_10M_100M],
- next_file.counters[POSIX_SIZE_WRITE_100M_1G],
- next_file.counters[POSIX_SIZE_WRITE_1G_PLUS],
- next_file.counters[POSIX_STRIDE1_STRIDE],
- next_file.counters[POSIX_STRIDE2_STRIDE],
- next_file.counters[POSIX_STRIDE3_STRIDE],
- next_file.counters[POSIX_STRIDE4_STRIDE],
- next_file.counters[POSIX_STRIDE1_COUNT],
- next_file.counters[POSIX_STRIDE2_COUNT],
- next_file.counters[POSIX_STRIDE3_COUNT],
- next_file.counters[POSIX_STRIDE4_COUNT],
- next_file.counters[POSIX_ACCESS1_ACCESS],
- next_file.counters[POSIX_ACCESS2_ACCESS],
- next_file.counters[POSIX_ACCESS3_ACCESS],
- next_file.counters[POSIX_ACCESS4_ACCESS],
- next_file.counters[POSIX_ACCESS1_COUNT],
- next_file.counters[POSIX_ACCESS2_COUNT],
- next_file.counters[POSIX_ACCESS3_COUNT],
- next_file.counters[POSIX_ACCESS4_COUNT],
- next_file.counters[POSIX_FASTEST_RANK],
- next_file.counters[POSIX_FASTEST_RANK_BYTES],
- next_file.counters[POSIX_SLOWEST_RANK],
- next_file.counters[POSIX_SLOWEST_RANK_BYTES],
- next_file.fcounters[POSIX_F_OPEN_TIMESTAMP],
- next_file.fcounters[POSIX_F_READ_START_TIMESTAMP],
- next_file.fcounters[POSIX_F_WRITE_START_TIMESTAMP],
- next_file.fcounters[POSIX_F_READ_END_TIMESTAMP],
- next_file.fcounters[POSIX_F_WRITE_END_TIMESTAMP],
- next_file.fcounters[POSIX_F_CLOSE_TIMESTAMP],
- next_file.fcounters[POSIX_F_READ_TIME],
- next_file.fcounters[POSIX_F_WRITE_TIME],
- next_file.fcounters[POSIX_F_META_TIME],
- next_file.fcounters[POSIX_F_MAX_READ_TIME],
- next_file.fcounters[POSIX_F_MAX_WRITE_TIME],
- next_file.fcounters[POSIX_F_FASTEST_RANK_TIME],
- next_file.fcounters[POSIX_F_SLOWEST_RANK_TIME]);
+ for(i=0; i<POSIX_NUM_INDICES; i++)
+ {
+ POSIX_COUNTER_PRINT(&next_file, i);
+ }
+ for(i=0; i<POSIX_F_NUM_INDICES; i++)
+ {
+ POSIX_F_COUNTER_PRINT(&next_file, i);
+ }
- i++;
} while((ret = darshan_log_get_posix_file(fd, &next_file)) == 1);
/* free mount info */
hooks/post-receive
--
More information about the Darshan-commits
mailing list