Check in Darshan IOF module runtime code

1. Modify configure and Makefile to compile and build IOF module.
2. Develop code to initialize and finalize IOF module.
3. Waiting for IOF APIs to obtain IOF striping information.
Signed-off-by: Cong Xu <congxu@localhost.localdomain>

darshan-iof-log-format.h

+/*
+ * Copyright (C) 2015 University of Chicago.
+ * See COPYRIGHT notice in top-level directory.
+ *
+ * Copyright (C) 2017 Intel Corporation
+ */
+
+#ifndef __DARSHAN_IOF_LOG_FORMAT_H
+#define __DARSHAN_IOF_LOG_FORMAT_H
+
+/* NOTE -- redefining the size of IONSS_ID will require changing the
+ * DARSHAN_BSWAP macro used in darshan-util/darshan-iof-logutils.c
+ * as well
+ */
+typedef int64_t IONSS_ID;
+
+/* current IOF log format version */
+#define DARSHAN_IOF_VER 1
+
+#define IOF_COUNTERS \
+    /* number of IONSSs for file system */\
+    X(IOF_IONSS) \
+    /* number of MDTs for file system */\
+    X(IOF_MDTS) \
+    /* index of first IONSS for file */\
+    X(IOF_STRIPE_OFFSET) \
+    /* bytes per stripe for file */\
+    X(IOF_STRIPE_SIZE) \
+    /* number of stripes (IONSSs) for file */\
+    X(IOF_STRIPE_WIDTH) \
+    /* end of counters */\
+    X(IOF_NUM_INDICES)
+
+#define X(a) a,
+/* integer statistics for IOF file records */
+enum darshan_iof_indices
+{
+    IOF_COUNTERS
+};
+#undef X
+
+/* record structure for the IOF module. a record is created and stored for
+ * every file opened that belongs to a IOF file system. This 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 (stripe size, width, # of IONSSs, etc.)
+ */
+struct darshan_iof_record
+{
+    struct darshan_base_record base_rec;
+    int64_t counters[IOF_NUM_INDICES];
+    IONSS_ID ionss_ids[1];
+};
+
+/*
+ *  helper function to calculate the size of a record
+ */
+#define IOF_RECORD_SIZE( ionss ) ( sizeof(struct darshan_iof_record) + sizeof(IONSS_ID) * (ionss - 1) )
+
+#endif /* __DARSHAN_IOF_LOG_FORMAT_H */

darshan-log-format.h

@@ -119,6 +119,8 @@ struct darshan_base_record
 #include "darshan-stdio-log-format.h"
 /* DXT */
 #include "darshan-dxt-log-format.h"
+/* IOF */
+#include "darshan-iof-log-format.h"
 
 /* X-macro for keeping module ordering consistent */
 /* NOTE: first val used to define module enum values, 
@@ -141,7 +143,10 @@ struct darshan_base_record
     X(DARSHAN_STDIO_MOD,    "STDIO",    DARSHAN_STDIO_VER,      &stdio_logutils) \
     /* DXT */ \
     X(DXT_POSIX_MOD,       "DXT_POSIX",  DXT_POSIX_VER,         &dxt_posix_logutils) \
-    X(DXT_MPIIO_MOD,       "DXT_MPIIO",  DXT_MPIIO_VER,         &dxt_mpiio_logutils)
+    X(DXT_MPIIO_MOD,       "DXT_MPIIO",  DXT_MPIIO_VER,         &dxt_mpiio_logutils) \
+    /* IOF */ \
+    X(DARSHAN_IOF_MOD,      "IOF",      DARSHAN_IOF_VER,        &iof_logutils)
+
 
 /* unique identifiers to distinguish between available darshan modules */
 /* NOTES: - valid ids range from [0...DARSHAN_MAX_MODS-1]

darshan-runtime/Makefile.in

@@ -19,6 +19,7 @@ LD = @LD@
 DISABLE_LDPRELOAD = @DISABLE_LDPRELOAD@
 ENABLE_MMAP_LOGS = @ENABLE_MMAP_LOGS@
 DARSHAN_USE_BGQ = @DARSHAN_USE_BGQ@
+DARSHAN_USE_IOF = @DARSHAN_USE_IOF@
 DARSHAN_USE_LUSTRE = @DARSHAN_USE_LUSTRE@
 DARSHAN_LOG_FORMAT = $(srcdir)/../darshan-log-format.h
 DARSHAN_VERSION = @DARSHAN_VERSION@
@@ -52,6 +53,13 @@ CFLAGS += -DDARSHAN_BGQ
 CFLAGS_SHARED += -DDARSHAN_BGQ
 endif
 
+ifdef DARSHAN_USE_IOF
+DARSHAN_STATIC_MOD_OBJS += lib/darshan-iof.o
+DARSHAN_DYNAMIC_MOD_OBJS += lib/darshan-iof.po
+CFLAGS += -DDARSHAN_IOF
+CFLAGS_SHARED += -DDARSHAN_IOF
+endif
+
 ifdef DARSHAN_USE_LUSTRE
 DARSHAN_STATIC_MOD_OBJS += lib/darshan-lustre.o
 DARSHAN_DYNAMIC_MOD_OBJS += lib/darshan-lustre.po
@@ -122,6 +130,12 @@ lib/darshan-pnetcdf.po: lib/darshan-pnetcdf.c darshan.h darshan-dynamic.h darsha
 lib/darshan-pnetcdf-stubs.o: lib/darshan-pnetcdf-stubs.c darshan.h $(DARSHAN_LOG_FORMAT) | lib
 	$(CC) $(CFLAGS) -c $< -o $@
 
+lib/darshan-iof.o: lib/darshan-iof.c darshan-iof.h darshan.h darshan-common.h $(DARSHAN_LOG_FORMAT) $(srcdir)/../darshan-iof-log-format.h | lib
+	$(CC) $(CFLAGS) -c $< -o $@
+
+lib/darshan-iof.po: lib/darshan-iof.c darshan-iof.h darshan.h darshan-dynamic.h darshan-common.h $(DARSHAN_LOG_FORMAT) $(srcdir)/../darshan-iof-log-format.h | lib
+	$(CC) $(CFLAGS_SHARED) -c $< -o $@
+
 lib/darshan-lustre.o: lib/darshan-lustre.c darshan-lustre.h darshan.h darshan-common.h $(DARSHAN_LOG_FORMAT) $(srcdir)/../darshan-lustre-log-format.h | lib
 	$(CC) $(CFLAGS) -c $< -o $@
 

darshan-runtime/configure

@@ -623,6 +623,7 @@ ac_subst_vars='LTLIBOBJS
 LIBOBJS
 DARSHAN_HDF5_LD_OPTS
 BUILD_HDF5_MODULE
+DARSHAN_USE_IOF
 DARSHAN_USE_LUSTRE
 DARSHAN_USE_BGQ
 MPICH_LIB_OLD
@@ -693,6 +694,7 @@ enable_ld_preload
 enable_cuserid
 enable_group_readable_logs
 enable_bgq_mod
+enable_iof_mod
 enable_lustre_mod
 enable_mmap_logs
 with_mem_align
@@ -1338,6 +1340,7 @@ Optional Features:
   --enable-group-readable-logs
                           Set log files to be group readable
   --disable-bgq-mod       Disables compilation and use of BG/Q module (for BG/Q systems)
+  --disable-iof-mod       Disables compilation and use of the IOF module
   --disable-lustre-mod    Disables compilation and use of the Lustre module
   --enable-mmap-logs      Enables ability to mmap I/O data to log file
   --enable-HDF5-post-1.10
@@ -3598,6 +3601,15 @@ else
 fi
 
 
+# Check whether --enable-iof-mod was given.
+if test "${enable_iof_mod+set}" = set; then :
+  enableval=$enable_iof_mod;
+else
+  enable_iof_mod=check
+
+fi
+
+
 # Check whether --enable-lustre-mod was given.
 if test "${enable_lustre_mod+set}" = set; then :
   enableval=$enable_lustre_mod;
@@ -3759,6 +3771,12 @@ fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
 
+# if IOF module not disabled,
+if test x$enable_iof_mod != xno; then
+    DARSHAN_USE_IOF=1
+fi
+
+
 # if lustre module not disabled, check for needed Lustre module header
 if test x$enable_lustre_mod != xno; then
     ac_fn_c_check_header_mongrel "$LINENO" "lustre/lustre_user.h" "ac_cv_header_lustre_lustre_user_h" "$ac_includes_default"

darshan-runtime/configure.in

@@ -53,6 +53,13 @@ AC_ARG_ENABLE(
     [enable_bgq_mod=check]
 )
 
+AC_ARG_ENABLE(
+    [iof-mod],
+    [  --disable-iof-mod    Disables compilation and use of the IOF module],
+    [],
+    [enable_iof_mod=check]
+)
+
 AC_ARG_ENABLE(
     [lustre-mod],
     [  --disable-lustre-mod    Disables compilation and use of the Lustre module],
@@ -153,6 +160,11 @@ if test x$enable_bgq_mod != xno; then
             []))
 fi
 
+# if IOF module not disabled
+if test x$enable_iof_mod != xno; then
+    DARSHAN_USE_IOF=1,
+fi
+
 # if lustre module not disabled, check for needed Lustre module header
 if test x$enable_lustre_mod != xno; then
     AC_CHECK_HEADER([lustre/lustre_user.h],
@@ -379,6 +391,7 @@ AC_SUBST(ENABLE_MMAP_LOGS)
 AC_SUBST(DARSHAN_VERSION)
 AC_SUBST(MPICH_LIB_OLD)
 AC_SUBST(DARSHAN_USE_BGQ)
+AC_SUBST(DARSHAN_USE_IOF)
 AC_SUBST(DARSHAN_USE_LUSTRE)
 AC_SUBST(BUILD_HDF5_MODULE)
 AC_SUBST(DARSHAN_HDF5_LD_OPTS)

darshan-runtime/darshan-iof.h

+struct iof_record_ref
+{
+    struct darshan_iof_record *record;
+    size_t record_size;
+};
+
+struct iof_runtime
+{
+    int   record_count;         /* number of records stored in record_id_hash */
+    void *record_id_hash;
+    int   record_buffer_size;   /* size of record_buffer in bytes */
+    void *record_buffer;
+    int   record_ref_array_ndx; /* current index into record_ref_array */
+    struct iof_record_ref **record_ref_array;
+};

darshan-runtime/lib/darshan-core.c

@@ -90,6 +90,13 @@ void (*mod_static_init_fns[])(void) =
     NULL
 };
 
+#ifdef DARSHAN_IOF
+/* XXX need to use extern to get IOF module's instrumentation function
+ * since modules have no way of providing this to darshan-core
+ */
+extern void darshan_instrument_iof_file(const char *filepath, int fd);
+#endif
+
 #ifdef DARSHAN_LUSTRE
 /* XXX need to use extern to get Lustre module's instrumentation function
  * since modules have no way of providing this to darshan-core
@@ -1015,6 +1022,10 @@ static void add_entry(char* buf, int* space_left, struct mntent* entry)
     }
 #endif
 
+#ifndef FUSE_SUPER_MAGIC
+#define FUSE_SUPER_MAGIC 0x65735546
+#endif
+
     /* store mount information with the job-level metadata in darshan log */
     ret = snprintf(tmp_mnt, 256, "\n%s\t%s",
         entry->mnt_type, entry->mnt_dir);
@@ -2117,6 +2128,16 @@ void darshan_instrument_fs_data(int fs_type, const char *path, int fd)
         return;
     }
 #endif
+
+#ifdef DARSHAN_IOF
+    /* allow iof to generate a record if we configured with iof support */
+    if(fs_type == FUSE_SUPER_MAGIC)
+    {
+        darshan_instrument_iof_file(path, fd);
+        return;
+    }
+#endif
+
     return;
 }
 

darshan-runtime/lib/darshan-iof.c

+/*
+ * Copyright (C) 2015 University of Chicago.
+ * See COPYRIGHT notice in top-level directory.
+ *
+ */
+
+#define _XOPEN_SOURCE 500
+#define _GNU_SOURCE
+
+#include "darshan-runtime-config.h"
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <pthread.h>
+#include <sys/ioctl.h>
+
+#include "darshan.h"
+#include "darshan-dynamic.h"
+#include "darshan-iof.h"
+
+static void iof_runtime_initialize(
+        void);
+static void iof_subtract_shared_rec_size(
+        void *rec_ref_p);
+static void iof_set_rec_ref_pointers(
+        void *rec_ref_p);
+static int iof_record_compare(
+        const void* a_p, const void* b_p);
+int sort_iof_records(
+        void);
+
+static void iof_shutdown(
+        MPI_Comm mod_comm, darshan_record_id *shared_recs,
+        int shared_rec_count, void **iof_buf, int *iof_buf_sz);
+
+struct iof_runtime *iof_runtime = NULL;
+static pthread_mutex_t iof_runtime_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+static int my_rank = -1;
+
+#define IOF_LOCK() pthread_mutex_lock(&iof_runtime_mutex)
+#define IOF_UNLOCK() pthread_mutex_unlock(&iof_runtime_mutex)
+
+void darshan_instrument_iof_file(const char* filepath, int fd)
+{
+    struct iof_record_ref *rec_ref;
+    struct darshan_iof_record *rec;
+    struct darshan_fs_info fs_info;
+    darshan_record_id rec_id;
+    int i;
+    size_t rec_size;
+    int ret;
+
+    IOF_LOCK();
+
+    /* try to init module if not already */
+    if (!iof_runtime) iof_runtime_initialize();
+
+    /* if we aren't initialized, just back out */
+    if (!iof_runtime) {
+        IOF_UNLOCK();
+        return;
+    }
+
+    /* search the hash table for this file record, and initialize if not found */
+    rec_id = darshan_core_gen_record_id(filepath);
+    rec_ref = darshan_lookup_record_ref(iof_runtime->record_id_hash,
+            &rec_id, sizeof(darshan_record_id));
+    if (!rec_ref) {
+
+        /* FIXME */
+        /* We are waiting for IOF APIs to get IOF Stripe Count, Stripe Size,
+         * Stripe Offset etc.
+         * For now we assume:
+         *      stripe_count = 1
+         *      stripe_size = 1MB
+         *      stripe_offset = 0
+         */
+
+        /* allocate and add a new record reference */
+        rec_ref = malloc(sizeof(*rec_ref));
+        if (!rec_ref) {
+            IOF_UNLOCK();
+            return;
+        }
+
+        ret = darshan_add_record_ref(&(iof_runtime->record_id_hash),
+                &rec_id, sizeof(darshan_record_id), rec_ref);
+        if (ret == 0) {
+            free(rec_ref);
+            IOF_UNLOCK();
+            return;
+        }
+
+        rec_size = IOF_RECORD_SIZE(1);
+
+        /* register a Lustre file record with Darshan */
+        fs_info.fs_type = -1;
+        rec = darshan_core_register_record(
+                rec_id,
+                filepath,
+                DARSHAN_IOF_MOD,
+                rec_size,
+                &fs_info);
+
+        /* if NULL, darshan has no more memory for instrumenting */
+        if (rec == NULL) {
+            darshan_delete_record_ref(&(iof_runtime->record_id_hash),
+                    &rec_id, sizeof(darshan_record_id));
+            free(rec_ref);
+            IOF_UNLOCK();
+            return;
+        }
+
+        /* implicit assumption here that none of these counters will change
+         * after the first time a file is opened.  This may not always be
+         * true in the future */
+        if (fs_info.fs_type != -1) {
+            rec->counters[IOF_IONSS] = 1;
+            rec->counters[IOF_MDTS] = 1;
+        } else {
+            rec->counters[IOF_IONSS] = -1;
+            rec->counters[IOF_MDTS] = -1;
+        }
+
+        rec->counters[IOF_STRIPE_SIZE] = 1048576;
+        rec->counters[IOF_STRIPE_WIDTH] = 1;
+        rec->counters[IOF_STRIPE_OFFSET] = 0;
+        for (i = 0; i < 1; i++)
+            rec->ionss_ids[i] = 0;
+
+        rec->base_rec.id = rec_id;
+        rec->base_rec.rank = my_rank;
+        rec_ref->record = rec;
+        rec_ref->record_size = rec_size;
+        iof_runtime->record_count++;
+    }
+
+    IOF_UNLOCK();
+    return;
+}
+
+static void iof_runtime_initialize()
+{
+    int iof_buf_size;
+
+    /* try and store a default number of records for this module, assuming
+     * each file uses 64 IONSSs
+     */
+    iof_buf_size = DARSHAN_DEF_MOD_REC_COUNT * IOF_RECORD_SIZE(64);
+
+    /* register the iof module with darshan-core */
+    darshan_core_register_module(
+            DARSHAN_IOF_MOD,
+            &iof_shutdown,
+            &iof_buf_size,
+            &my_rank,
+            NULL);
+
+    if (iof_buf_size < IOF_RECORD_SIZE(1)) {
+        /* unregister module if we aren't allocated enough space for
+         * the smallest possible record
+         */
+        darshan_core_unregister_module(DARSHAN_IOF_MOD);
+        return;
+    }
+
+    iof_runtime = malloc(sizeof(*iof_runtime));
+    if (!iof_runtime) {
+        darshan_core_unregister_module(DARSHAN_IOF_MOD);
+        return;
+    }
+    memset(iof_runtime, 0, sizeof(*iof_runtime));
+
+    return;
+}
+
+/**************************************************************************
+ * Functions exported by IOF module for coordinating with darshan-core *
+ **************************************************************************/
+
+static void iof_shutdown(
+        MPI_Comm mod_comm,
+        darshan_record_id *shared_recs,
+        int shared_rec_count,
+        void **iof_buf,
+        int *iof_buf_sz)
+{
+    struct iof_record_ref *rec_ref;
+    int i;
+
+    IOF_LOCK();
+    assert(iof_runtime);
+
+    iof_runtime->record_buffer = *iof_buf;
+    iof_runtime->record_buffer_size = *iof_buf_sz;
+
+    /* if there are globally shared files, do a shared file reduction */
+    /* NOTE: the shared file reduction is also skipped if the 
+     * DARSHAN_DISABLE_SHARED_REDUCTION environment variable is set.
+     */
+    if (shared_rec_count && !getenv("DARSHAN_DISABLE_SHARED_REDUCTION"))
+    {
+        /* necessary initialization of shared records */
+        for (i = 0; i < shared_rec_count; i++)
+        {
+            rec_ref = darshan_lookup_record_ref(iof_runtime->record_id_hash,
+                    &shared_recs[i], sizeof(darshan_record_id));
+            assert(rec_ref);
+
+            rec_ref->record->base_rec.rank = -1;
+        }
+
+        /* sort the array of files descending by rank so that we get all of the 
+         * shared files (marked by rank -1) in a contiguous portion at end 
+         * of the array
+         */
+        sort_iof_records();
+
+        /* simply drop all shared records from the end of the record array on
+         * non-root ranks simply by recalculating the size of the buffer
+         */
+        if (my_rank != 0)
+        {
+            darshan_iter_record_refs(iof_runtime->record_id_hash, 
+                    &iof_subtract_shared_rec_size);
+        }
+    }
+
+    /* modify output buffer size to account for any shared records that were removed */
+    *iof_buf_sz = iof_runtime->record_buffer_size;
+
+    /* cleanup data structures */
+    darshan_clear_record_refs(&(iof_runtime->record_id_hash), 1);
+    free(iof_runtime);
+    iof_runtime = NULL;
+
+    IOF_UNLOCK();
+    return;
+}
+
+static void iof_subtract_shared_rec_size(void *rec_ref_p)
+{
+    struct iof_record_ref *l_rec_ref = (struct iof_record_ref *)rec_ref_p;
+
+    if (l_rec_ref->record->base_rec.rank == -1)
+        iof_runtime->record_buffer_size -=
+            IOF_RECORD_SIZE(l_rec_ref->record->counters[IOF_STRIPE_WIDTH]);
+}
+
+static void iof_set_rec_ref_pointers(void *rec_ref_p)
+{
+    iof_runtime->record_ref_array[iof_runtime->record_ref_array_ndx] = rec_ref_p;
+    iof_runtime->record_ref_array_ndx++;
+    return;
+}
+
+/* compare function for sorting file records by descending rank */
+static int iof_record_compare(const void* a_p, const void* b_p)
+{
+    const struct iof_record_ref* a = *((struct iof_record_ref **)a_p);
+    const struct iof_record_ref* b = *((struct iof_record_ref **)b_p);
+
+    if (a->record->base_rec.rank < b->record->base_rec.rank)
+        return 1;
+    if (a->record->base_rec.rank > b->record->base_rec.rank)
+        return -1;
+
+    /* if ( a->record->rank == b->record->rank ) we MUST do a secondary
+     * sort so that the order of qsort is fully deterministic and consistent
+     * across all MPI ranks.  Without a secondary sort, the sort order can
+     * be affected by rank-specific variations (e.g., the order in which
+     * files are first opened).
+     */
+    /* sort by ascending darshan record ids */
+    if (a->record->base_rec.id > b->record->base_rec.id)
+        return 1;
+    if (a->record->base_rec.id < b->record->base_rec.id)
+        return -1;
+
+    return 0;
+}
+
+/*
+ * Sort the record_references and records by MPI rank to facilitate shared redux.
+ * This requires craftiness and additional heap utilization because the records
+ * (but not record_runtimes) have variable size.  Currently has to temporarily
+ * duplicate the entire record_buffer; there is room for more memory-efficient
+ * optimization if this becomes a scalability issue.
+ */
+int sort_iof_records()
+{
+    int i;
+    struct iof_record_ref *rec_ref;
+    char  *new_buf, *p;
+
+    /* Create a new buffer to store an entire replica of record_buffer.  Since
+     * we know the exact size of record_buffer's useful data at this point, we
+     * can allocate the exact amount we need */
+    new_buf = malloc(iof_runtime->record_buffer_size);
+    p = new_buf;
+    if ( !new_buf )
+        return 1;
+
+    /* allocate array of record reference pointers that we want to sort */
+    iof_runtime->record_ref_array = malloc(iof_runtime->record_count *
+            sizeof(*(iof_runtime->record_ref_array)));
+    if (!iof_runtime->record_ref_array)
+    {
+        free(new_buf);
+        return 1;
+    }
+
+    /* build the array of record reference pointers we want to sort */
+    darshan_iter_record_refs(iof_runtime->record_id_hash,
+            &iof_set_rec_ref_pointers);
+
+    /* qsort breaks the hash table, so delete it now to free its memory buffers
+     * and prevent later confusion */
+    darshan_clear_record_refs(&(iof_runtime->record_id_hash), 0);
+
+    /* sort the runtime records, which is has fixed-length elements */
+    qsort(
+            iof_runtime->record_ref_array,
+            iof_runtime->record_count,
+            sizeof(struct iof_record_ref *),
+            iof_record_compare
+         );
+
+    /* rebuild the hash with the qsorted runtime records, and
+     * create reordered record buffer
+     */
+    for (i = 0; i < iof_runtime->record_count; i++) {
+        rec_ref = iof_runtime->record_ref_array[i];
+
+        /* add this record reference back to the hash table */
+        darshan_add_record_ref(&(iof_runtime->record_id_hash),
+                &(rec_ref->record->base_rec.id),
+                sizeof(darshan_record_id), rec_ref);
+
+        memcpy(p, rec_ref->record, rec_ref->record_size);
+        /* fix record pointers within each record reference too - pre-emptively
+         * point them at where they will live in record_buffer after we memcpy
+         * below */
+        rec_ref->record = (struct darshan_iof_record *)
+            ((char*)(iof_runtime->record_buffer) + (p - new_buf));
+        p += rec_ref->record_size;
+    }
+
+    /* copy sorted records back over to IOF's record buffer */
+    memcpy( 
+            iof_runtime->record_buffer, 
+            new_buf, 
+            iof_runtime->record_buffer_size );
+
+    free(new_buf);
+    free(iof_runtime->record_ref_array);
+    return 0;
+}
+
+/*
+ * Local variables:
+ *  c-indent-level: 4
+ *  c-basic-offset: 4