[Darshan-commits] [Git][darshan/darshan][mmap-dev] 2 commits: add variable-length definition of name records
Shane Snyder
xgitlab at cels.anl.gov
Thu May 26 12:54:03 CDT 2016
Shane Snyder pushed to branch mmap-dev at darshan / darshan
Commits:
d6dad7f3 by Shane Snyder at 2016-05-26T12:29:34-05:00
add variable-length definition of name records
also some code clean up to change references of record hash
to name hash to be more clear about what it is actually storing.
- - - - -
999ee9c8 by Shane Snyder at 2016-05-26T12:53:05-05:00
darshan-util edits for var. length name records
- - - - -
17 changed files:
- darshan-log-format.h
- darshan-runtime/darshan-core.h
- darshan-runtime/lib/darshan-core.c
- darshan-util/Makefile.in
- darshan-util/darshan-analyzer.c
- darshan-util/darshan-bgq-logutils.c
- darshan-util/darshan-convert.c
- darshan-util/darshan-diff.c
- darshan-util/darshan-hdf5-logutils.c
- darshan-util/darshan-logutils.c
- darshan-util/darshan-logutils.h
- darshan-util/darshan-merge.c
- darshan-util/darshan-mpiio-logutils.c
- darshan-util/darshan-null-logutils.c
- darshan-util/darshan-parser.c
- darshan-util/darshan-pnetcdf-logutils.c
- darshan-util/darshan-posix-logutils.c
Changes:
=====================================
darshan-log-format.h
=====================================
--- a/darshan-log-format.h
+++ b/darshan-log-format.h
@@ -69,7 +69,7 @@ struct darshan_header
int64_t magic_nr;
unsigned char comp_type;
uint32_t partial_flag;
- struct darshan_log_map rec_map;
+ struct darshan_log_map name_map;
struct darshan_log_map mod_map[DARSHAN_MAX_MODS];
uint32_t mod_ver[DARSHAN_MAX_MODS];
};
@@ -86,6 +86,14 @@ struct darshan_job
char metadata[DARSHAN_JOB_METADATA_LEN];
};
+/* record to store name->darshan_id mapping for each registered record */
+struct darshan_name_record
+{
+ darshan_record_id id;
+ char name[1];
+};
+
+/* base record definition that can be used by modules */
struct darshan_base_record
{
darshan_record_id id;
=====================================
darshan-runtime/darshan-core.h
=====================================
--- a/darshan-runtime/darshan-core.h
+++ b/darshan-runtime/darshan-core.h
@@ -43,12 +43,27 @@
/* default path for storing mmap log files is '/tmp' */
#define DARSHAN_DEF_MMAP_LOG_PATH "/tmp"
-/* default record buf can store 2048 records of size 100 bytes */
-#define DARSHAN_RECORD_BUF_SIZE (2048 * 100)
+/* default name record buf can store 2048 records of size 100 bytes */
+#define DARSHAN_NAME_RECORD_BUF_SIZE (2048 * 100)
/* Default runtime compression buffer size */
#define DARSHAN_COMP_BUF_SIZE DARSHAN_MOD_MEM_MAX
+/* structure to track registered modules */
+struct darshan_core_module
+{
+ struct darshan_module_funcs mod_funcs;
+ int mem_avail;
+};
+
+struct darshan_core_name_record_ref
+{
+ struct darshan_name_record *name_record;
+ uint64_t mod_flags;
+ uint64_t global_mod_flags;
+ UT_hash_handle hlink;
+};
+
/* in memory structure to keep up with job level data */
struct darshan_core_runtime
{
@@ -56,35 +71,21 @@ struct darshan_core_runtime
struct darshan_header *log_hdr_p;
struct darshan_job *log_job_p;
char *log_exemnt_p;
- void *log_rec_p;
+ void *log_name_p;
void *log_mod_p;
/* darshan-core internal data structures */
- struct darshan_core_record_ref *rec_hash;
- int rec_hash_cnt;
struct darshan_core_module* mod_array[DARSHAN_MAX_MODS];
int mod_mem_used;
- char *comp_buf;
+ struct darshan_core_name_record_ref *name_hash;
+ int name_hash_cnt;
double wtime_offset;
+ char *comp_buf;
#ifdef __DARSHAN_ENABLE_MMAP_LOGS
char mmap_log_name[PATH_MAX];
#endif
};
-struct darshan_core_module
-{
- struct darshan_module_funcs mod_funcs;
- int mem_avail;
-};
-
-struct darshan_core_record_ref
-{
- void *rec_p; /* id & name buffer */
- uint64_t mod_flags;
- uint64_t global_mod_flags;
- UT_hash_handle hlink;
-};
-
void darshan_core_initialize(int argc, char **argv);
void darshan_core_shutdown(void);
=====================================
darshan-runtime/lib/darshan-core.c
=====================================
--- a/darshan-runtime/lib/darshan-core.c
+++ b/darshan-runtime/lib/darshan-core.c
@@ -93,9 +93,9 @@ static void darshan_log_record_hints_and_ver(
struct darshan_core_runtime* core);
static void darshan_get_exe_and_mounts(
struct darshan_core_runtime *core, int argc, char **argv);
-static void darshan_add_record_hashref(
+static void darshan_add_name_record_ref(
struct darshan_core_runtime *core, char *name,
- darshan_record_id id, struct darshan_core_record_ref **ref);
+ darshan_record_id id, struct darshan_core_name_record_ref **ref);
static int darshan_block_size_from_path(
const char *path);
static void darshan_get_user_name(
@@ -110,7 +110,7 @@ static int darshan_log_open_all(
static int darshan_deflate_buffer(
void **pointers, int *lengths, int count, char *comp_buf,
int *comp_buf_length);
-static int darshan_log_write_record_hash(
+static int darshan_log_write_name_record_hash(
MPI_File log_fh, struct darshan_core_runtime *core,
uint64_t *inout_off);
static int darshan_log_append_all(
@@ -208,11 +208,11 @@ void darshan_core_initialize(int argc, char **argv)
init_core->log_hdr_p = malloc(sizeof(struct darshan_header));
init_core->log_job_p = malloc(sizeof(struct darshan_job));
init_core->log_exemnt_p = malloc(DARSHAN_EXE_LEN+1);
- init_core->log_rec_p = malloc(DARSHAN_RECORD_BUF_SIZE);
+ init_core->log_name_p = malloc(DARSHAN_NAME_RECORD_BUF_SIZE);
init_core->log_mod_p = malloc(DARSHAN_MOD_MEM_MAX);
if(!(init_core->log_hdr_p) || !(init_core->log_job_p) ||
- !(init_core->log_exemnt_p) || !(init_core->log_rec_p) ||
+ !(init_core->log_exemnt_p) || !(init_core->log_name_p) ||
!(init_core->log_mod_p))
{
free(init_core);
@@ -222,7 +222,7 @@ void darshan_core_initialize(int argc, char **argv)
memset(init_core->log_hdr_p, 0, sizeof(struct darshan_header));
memset(init_core->log_job_p, 0, sizeof(struct darshan_job));
memset(init_core->log_exemnt_p, 0, DARSHAN_EXE_LEN+1);
- memset(init_core->log_rec_p, 0, DARSHAN_RECORD_BUF_SIZE);
+ memset(init_core->log_name_p, 0, DARSHAN_NAME_RECORD_BUF_SIZE);
memset(init_core->log_mod_p, 0, DARSHAN_MOD_MEM_MAX);
#else
/* if mmap logs are enabled, we need to initialize the mmap region
@@ -233,7 +233,7 @@ void darshan_core_initialize(int argc, char **argv)
assert(sys_page_size > 0);
mmap_size = sizeof(struct darshan_header) + DARSHAN_JOB_RECORD_SIZE +
- + DARSHAN_RECORD_BUF_SIZE + DARSHAN_MOD_MEM_MAX;
+ + DARSHAN_NAME_RECORD_BUF_SIZE + DARSHAN_MOD_MEM_MAX;
if(mmap_size % sys_page_size)
mmap_size = ((mmap_size / sys_page_size) + 1) * sys_page_size;
@@ -298,14 +298,14 @@ void darshan_core_initialize(int argc, char **argv)
((char *)init_core->log_hdr_p + sizeof(struct darshan_header));
init_core->log_exemnt_p = (char *)
((char *)init_core->log_job_p + sizeof(struct darshan_job));
- init_core->log_rec_p = (void *)
+ init_core->log_name_p = (void *)
((char *)init_core->log_exemnt_p + DARSHAN_EXE_LEN + 1);
init_core->log_mod_p = (void *)
- ((char *)init_core->log_rec_p + DARSHAN_RECORD_BUF_SIZE);
+ ((char *)init_core->log_name_p + DARSHAN_NAME_RECORD_BUF_SIZE);
/* set header fields needed for the mmap log mechanism */
init_core->log_hdr_p->comp_type = DARSHAN_NO_COMP;
- init_core->log_hdr_p->rec_map.off =
+ init_core->log_hdr_p->name_map.off =
sizeof(struct darshan_header) + DARSHAN_JOB_RECORD_SIZE;
#endif
@@ -564,9 +564,9 @@ void darshan_core_shutdown()
if(internal_timing_flag)
rec1 = DARSHAN_MPI_CALL(PMPI_Wtime)();
/* write the record name->id hash to the log file */
- out_header.rec_map.off = gz_fp;
- ret = darshan_log_write_record_hash(log_fh, final_core, &gz_fp);
- out_header.rec_map.len = gz_fp - out_header.rec_map.off;
+ out_header.name_map.off = gz_fp;
+ ret = darshan_log_write_name_record_hash(log_fh, final_core, &gz_fp);
+ out_header.name_map.len = gz_fp - out_header.name_map.off;
/* error out if unable to write record hash */
DARSHAN_MPI_CALL(PMPI_Allreduce)(&ret, &all_ret, 1, MPI_INT,
@@ -601,7 +601,7 @@ void darshan_core_shutdown()
for(i = 0; i < DARSHAN_MAX_MODS; i++)
{
struct darshan_core_module* this_mod = final_core->mod_array[i];
- struct darshan_core_record_ref *ref = NULL;
+ struct darshan_core_name_record_ref *ref = NULL;
int mod_shared_rec_cnt = 0;
void* mod_buf = NULL;
int mod_buf_sz = 0;
@@ -624,7 +624,7 @@ void darshan_core_shutdown()
memset(mod_shared_recs, 0, shared_rec_cnt * sizeof(darshan_record_id));
for(j = 0; j < shared_rec_cnt; j++)
{
- HASH_FIND(hlink, final_core->rec_hash, &shared_recs[j],
+ HASH_FIND(hlink, final_core->name_hash, &shared_recs[j],
sizeof(darshan_record_id), ref);
assert(ref);
if(DARSHAN_MOD_FLAG_ISSET(ref->global_mod_flags, i))
@@ -1219,14 +1219,12 @@ static void darshan_get_logfile_name(char* logfile_name, int jobid, struct tm* s
return;
}
-static void darshan_add_record_hashref(struct darshan_core_runtime *core,
- char *name, darshan_record_id id, struct darshan_core_record_ref **ref)
+static void darshan_add_name_record_ref(struct darshan_core_runtime *core, char *name,
+ darshan_record_id id, struct darshan_core_name_record_ref **ref)
{
int record_size = sizeof(darshan_record_id) + strlen(name) + 1;
- darshan_record_id *id_p;
- char *name_p;
- if((record_size + core->log_hdr_p->rec_map.len) > DARSHAN_RECORD_BUF_SIZE)
+ if((record_size + core->log_hdr_p->name_map.len) > DARSHAN_NAME_RECORD_BUF_SIZE)
return;
*ref = malloc(sizeof(**ref));
@@ -1234,20 +1232,17 @@ static void darshan_add_record_hashref(struct darshan_core_runtime *core,
{
memset(*ref, 0, sizeof(**ref));
- /* serialize the record id and name into the record map buffer */
- id_p = (darshan_record_id *)
- ((char *)core->log_rec_p + core->log_hdr_p->rec_map.len);
- *id_p = id;
- name_p = (char *)id_p + sizeof(darshan_record_id);
- strcpy(name_p, name);
-
- /* save pointer to this record mapping buffer */
- (*ref)->rec_p = id_p;
+ (*ref)->name_record = (struct darshan_name_record *)
+ ((char *)core->log_name_p + core->log_hdr_p->name_map.len);
+ memset((*ref)->name_record, 0, record_size);
+ (*ref)->name_record->id = id;
+ strcpy((*ref)->name_record->name, name);
/* add the record to the hash table */
- HASH_ADD_KEYPTR(hlink, core->rec_hash, id_p, sizeof(darshan_record_id), (*ref));
- core->rec_hash_cnt++;
- core->log_hdr_p->rec_map.len += record_size;
+ HASH_ADD(hlink, core->name_hash, name_record->id,
+ sizeof(darshan_record_id), (*ref));
+ core->name_hash_cnt++;
+ core->log_hdr_p->name_map.len += record_size;
}
return;
@@ -1257,8 +1252,8 @@ static void darshan_get_shared_records(struct darshan_core_runtime *core,
darshan_record_id **shared_recs, int *shared_rec_cnt)
{
int i, j;
- int tmp_cnt = core->rec_hash_cnt;
- struct darshan_core_record_ref *tmp, *ref;
+ int tmp_cnt = core->name_hash_cnt;
+ struct darshan_core_name_record_ref *tmp, *ref;
darshan_record_id *id_array;
uint64_t *mod_flags;
uint64_t *global_mod_flags;
@@ -1281,10 +1276,9 @@ static void darshan_get_shared_records(struct darshan_core_runtime *core,
if(my_rank == 0)
{
i = 0;
- HASH_ITER(hlink, core->rec_hash, ref, tmp)
+ HASH_ITER(hlink, core->name_hash, ref, tmp)
{
- /* dereference the record pointer to get corresponding id */
- id_array[i++] = *(darshan_record_id *)ref->rec_p;
+ id_array[i++] = ref->name_record->id;
}
}
@@ -1295,7 +1289,7 @@ static void darshan_get_shared_records(struct darshan_core_runtime *core,
/* everyone looks to see if they opened the same records as root */
for(i=0; i<tmp_cnt; i++)
{
- HASH_FIND(hlink, core->rec_hash, &id_array[i], sizeof(darshan_record_id), ref);
+ HASH_FIND(hlink, core->name_hash, &id_array[i], sizeof(darshan_record_id), ref);
if(ref)
{
/* we opened that record too, save the mod_flags */
@@ -1320,7 +1314,7 @@ static void darshan_get_shared_records(struct darshan_core_runtime *core,
* accessed this module. we need this info to support shared
* file reductions
*/
- HASH_FIND(hlink, core->rec_hash, &id_array[i], sizeof(darshan_record_id), ref);
+ HASH_FIND(hlink, core->name_hash, &id_array[i], sizeof(darshan_record_id), ref);
assert(ref);
ref->global_mod_flags = global_mod_flags[i];
}
@@ -1483,14 +1477,14 @@ static int darshan_deflate_buffer(void **pointers, int *lengths, int count,
/* NOTE: the map written to file may contain duplicate id->name entries if a
* record is opened by multiple ranks, but not all ranks
*/
-static int darshan_log_write_record_hash(MPI_File log_fh, struct darshan_core_runtime *core,
- uint64_t *inout_off)
+static int darshan_log_write_name_record_hash(MPI_File log_fh,
+ struct darshan_core_runtime *core, uint64_t *inout_off)
{
- struct darshan_core_record_ref *ref, *tmp;
+ struct darshan_core_name_record_ref *ref, *tmp;
int ret;
/* serialize the record hash into a buffer for writing */
- HASH_ITER(hlink, core->rec_hash, ref, tmp)
+ HASH_ITER(hlink, core->name_hash, ref, tmp)
{
/* to avoid duplicate records, only rank 0 will write shared records */
if(my_rank > 0 && ref->global_mod_flags)
@@ -1500,8 +1494,8 @@ static int darshan_log_write_record_hash(MPI_File log_fh, struct darshan_core_ru
}
/* collectively write out the record hash to the darshan log */
- ret = darshan_log_append_all(log_fh, core, core->log_rec_p,
- core->log_hdr_p->rec_map.len, inout_off);
+ ret = darshan_log_append_all(log_fh, core, core->log_name_p,
+ core->log_hdr_p->name_map.len, inout_off);
return(ret);
}
@@ -1581,12 +1575,12 @@ static int darshan_log_append_all(MPI_File log_fh, struct darshan_core_runtime *
/* free darshan core data structures to shutdown */
static void darshan_core_cleanup(struct darshan_core_runtime* core)
{
- struct darshan_core_record_ref *tmp, *ref;
+ struct darshan_core_name_record_ref *tmp, *ref;
int i;
- HASH_ITER(hlink, core->rec_hash, ref, tmp)
+ HASH_ITER(hlink, core->name_hash, ref, tmp)
{
- HASH_DELETE(hlink, core->rec_hash, ref);
+ HASH_DELETE(hlink, core->name_hash, ref);
free(ref);
}
@@ -1603,7 +1597,7 @@ static void darshan_core_cleanup(struct darshan_core_runtime* core)
free(core->log_hdr_p);
free(core->log_job_p);
free(core->log_exemnt_p);
- free(core->log_rec_p);
+ free(core->log_name_p);
free(core->log_mod_p);
#endif
@@ -1686,7 +1680,7 @@ void darshan_core_register_module(
void darshan_core_unregister_module(
darshan_module_id mod_id)
{
- struct darshan_core_record_ref *ref, *tmp;
+ struct darshan_core_name_record_ref *ref, *tmp;
if(!darshan_core)
return;
@@ -1694,14 +1688,14 @@ void darshan_core_unregister_module(
DARSHAN_CORE_LOCK();
/* iterate all records and disassociate this module from them */
- HASH_ITER(hlink, darshan_core->rec_hash, ref, tmp)
+ HASH_ITER(hlink, darshan_core->name_hash, ref, tmp)
{
/* disassociate this module from the given record id */
DARSHAN_MOD_FLAG_UNSET(ref->mod_flags, mod_id);
if(!(ref->mod_flags))
{
/* if no other modules are associated with this rec, delete it */
- HASH_DELETE(hlink, darshan_core->rec_hash, ref);
+ HASH_DELETE(hlink, darshan_core->name_hash, ref);
}
}
@@ -1739,7 +1733,7 @@ int darshan_core_register_record(
int rec_size,
int *file_alignment)
{
- struct darshan_core_record_ref *ref;
+ struct darshan_core_name_record_ref *ref;
int mod_oom = 0;
if(!darshan_core)
@@ -1752,14 +1746,14 @@ int darshan_core_register_record(
mod_oom = 1;
/* check to see if we've already stored the id->name mapping for this record */
- HASH_FIND(hlink, darshan_core->rec_hash, &rec_id, sizeof(darshan_record_id), ref);
+ HASH_FIND(hlink, darshan_core->name_hash, &rec_id, sizeof(darshan_record_id), ref);
if(!ref && !mod_oom)
{
/* no mapping already exists, but this module has memory available for
* storing the record being registered, so we create a new id->name
* mapping to correspond to the record
*/
- darshan_add_record_hashref(darshan_core, name, rec_id, &ref);
+ darshan_add_name_record_ref(darshan_core, name, rec_id, &ref);
}
if(!ref)
=====================================
darshan-util/Makefile.in
=====================================
--- a/darshan-util/Makefile.in
+++ b/darshan-util/Makefile.in
@@ -159,7 +159,7 @@ endif
clean::
- rm -f *.o *.po *.a *.so darshan-analyzer darshan-convert darshan-parser darshan-merge jenkins-hash-gen
+ rm -f *.o *.po *.a *.so darshan-analyzer darshan-convert darshan-diff darshan-parser darshan-merge jenkins-hash-gen
distclean:: clean
rm -f darshan-runtime-config.h aclocal.m4 autom4te.cache/* config.status config.log Makefile util/bin/darshan-job-summary.pl
=====================================
darshan-util/darshan-analyzer.c
=====================================
--- a/darshan-util/darshan-analyzer.c
+++ b/darshan-util/darshan-analyzer.c
@@ -52,10 +52,10 @@ int process_log(const char *fname, double *io_ratio, int *used_mpio, int *used_p
return -1;
}
- ret = darshan_log_getjob(file, &job);
+ ret = darshan_log_get_job(file, &job);
if (ret < 0)
{
- fprintf(stderr, "darshan_log_getjob() failed on file %s.\n", fname);
+ fprintf(stderr, "darshan_log_get_job() failed on file %s.\n", fname);
darshan_log_close(file);
return -1;
}
=====================================
darshan-util/darshan-bgq-logutils.c
=====================================
--- a/darshan-util/darshan-bgq-logutils.c
+++ b/darshan-util/darshan-bgq-logutils.c
@@ -55,7 +55,7 @@ static int darshan_log_get_bgq_rec(darshan_fd fd, void* bgq_buf)
int i;
int ret;
- ret = darshan_log_getmod(fd, DARSHAN_BGQ_MOD, bgq_buf,
+ ret = darshan_log_get_mod(fd, DARSHAN_BGQ_MOD, bgq_buf,
sizeof(struct darshan_bgq_record));
if(ret < 0)
return(-1);
@@ -84,7 +84,7 @@ static int darshan_log_put_bgq_rec(darshan_fd fd, void* bgq_buf, int ver)
struct darshan_bgq_record *rec = (struct darshan_bgq_record *)bgq_buf;
int ret;
- ret = darshan_log_putmod(fd, DARSHAN_BGQ_MOD, rec,
+ ret = darshan_log_put_mod(fd, DARSHAN_BGQ_MOD, rec,
sizeof(struct darshan_bgq_record), ver);
if(ret < 0)
return(-1);
=====================================
darshan-util/darshan-convert.c
=====================================
--- a/darshan-util/darshan-convert.c
+++ b/darshan-util/darshan-convert.c
@@ -140,21 +140,25 @@ void obfuscate_exe(int key, char *exe)
return;
}
-void obfuscate_filenames(int key, struct darshan_record_ref *rec_hash)
+void obfuscate_filenames(int key, struct darshan_name_record_ref *name_hash)
{
- struct darshan_record_ref *ref, *tmp;
+ struct darshan_name_record_ref *ref, *tmp;
uint32_t hashed;
char tmp_string[128] = {0};
+ darshan_record_id tmp_id;
- HASH_ITER(hlink, rec_hash, ref, tmp)
+ HASH_ITER(hlink, name_hash, ref, tmp)
{
- hashed = darshan_hashlittle(ref->name, strlen(ref->name), key);
+ tmp_id = ref->name_record->id;
+ hashed = darshan_hashlittle(ref->name_record->name,
+ strlen(ref->name_record->name), key);
sprintf(tmp_string, "%u", hashed);
- free(ref->name);
- ref->name = malloc(strlen(tmp_string) + 1);
- assert(ref->name);
- memcpy(ref->name, tmp_string, strlen(tmp_string));
- ref->name[strlen(tmp_string)] = '\0';
+ free(ref->name_record);
+ ref->name_record = malloc(sizeof(struct darshan_name_record) +
+ strlen(tmp_string));
+ assert(ref->name_record);
+ ref->name_record->id = tmp_id;
+ strcpy(ref->name_record->name, tmp_string);
}
return;
@@ -202,16 +206,17 @@ void add_annotation (char *annotation,
return;
}
-static void remove_hash_recs(struct darshan_record_ref **rec_hash, darshan_record_id hash)
+static void remove_hash_recs(struct darshan_name_record_ref **name_hash,
+ darshan_record_id hash)
{
- struct darshan_record_ref *ref, *tmp;
+ struct darshan_name_record_ref *ref, *tmp;
- HASH_ITER(hlink, *rec_hash, ref, tmp)
+ HASH_ITER(hlink, *name_hash, ref, tmp)
{
- if(ref->id != hash)
+ if(ref->name_record->id != hash)
{
- HASH_DELETE(hlink, *rec_hash, ref);
- free(ref->name);
+ HASH_DELETE(hlink, *name_hash, ref);
+ free(ref->name_record);
free(ref);
}
}
@@ -232,8 +237,8 @@ int main(int argc, char **argv)
int mount_count;
char** mnt_pts;
char** fs_types;
- struct darshan_record_ref *rec_hash = NULL;
- struct darshan_record_ref *ref, *tmp;
+ struct darshan_name_record_ref *name_hash = NULL;
+ struct darshan_name_record_ref *ref, *tmp;
char mod_buf[DEF_MOD_BUF_SIZE];
enum darshan_comp_type comp_type;
int bzip2;
@@ -259,7 +264,7 @@ int main(int argc, char **argv)
}
/* read job info */
- ret = darshan_log_getjob(infile, &job);
+ ret = darshan_log_get_job(infile, &job);
if(ret < 0)
{
darshan_log_close(infile);
@@ -272,7 +277,7 @@ int main(int argc, char **argv)
if (obfuscate) obfuscate_job(key, &job);
if (annotation) add_annotation(annotation, &job);
- ret = darshan_log_putjob(outfile, &job);
+ ret = darshan_log_put_job(outfile, &job);
if (ret < 0)
{
darshan_log_close(infile);
@@ -280,7 +285,7 @@ int main(int argc, char **argv)
return(-1);
}
- ret = darshan_log_getexe(infile, tmp_string);
+ ret = darshan_log_get_exe(infile, tmp_string);
if(ret < 0)
{
darshan_log_close(infile);
@@ -291,7 +296,7 @@ int main(int argc, char **argv)
if (obfuscate) obfuscate_exe(key, tmp_string);
- ret = darshan_log_putexe(outfile, tmp_string);
+ ret = darshan_log_put_exe(outfile, tmp_string);
if(ret < 0)
{
darshan_log_close(infile);
@@ -299,7 +304,7 @@ int main(int argc, char **argv)
return(-1);
}
- ret = darshan_log_getmounts(infile, &mnt_pts, &fs_types, &mount_count);
+ ret = darshan_log_get_mounts(infile, &mnt_pts, &fs_types, &mount_count);
if(ret < 0)
{
darshan_log_close(infile);
@@ -308,7 +313,7 @@ int main(int argc, char **argv)
return(-1);
}
- ret = darshan_log_putmounts(outfile, mnt_pts, fs_types, mount_count);
+ ret = darshan_log_put_mounts(outfile, mnt_pts, fs_types, mount_count);
if(ret < 0)
{
darshan_log_close(infile);
@@ -316,7 +321,7 @@ int main(int argc, char **argv)
return(-1);
}
- ret = darshan_log_gethash(infile, &rec_hash);
+ ret = darshan_log_get_namehash(infile, &name_hash);
if(ret < 0)
{
darshan_log_close(infile);
@@ -328,10 +333,10 @@ int main(int argc, char **argv)
/* NOTE: obfuscating filepaths breaks the ability to map files
* to the corresponding FS & mount info maintained by darshan
*/
- if(obfuscate) obfuscate_filenames(key, rec_hash);
- if(hash) remove_hash_recs(&rec_hash, hash);
+ if(obfuscate) obfuscate_filenames(key, name_hash);
+ if(hash) remove_hash_recs(&name_hash, hash);
- ret = darshan_log_puthash(outfile, rec_hash);
+ ret = darshan_log_put_namehash(outfile, name_hash);
if(ret < 0)
{
darshan_log_close(infile);
@@ -402,10 +407,10 @@ int main(int argc, char **argv)
free(fs_types);
}
- HASH_ITER(hlink, rec_hash, ref, tmp)
+ HASH_ITER(hlink, name_hash, ref, tmp)
{
- HASH_DELETE(hlink, rec_hash, ref);
- free(ref->name);
+ HASH_DELETE(hlink, name_hash, ref);
+ free(ref->name_record);
free(ref);
}
=====================================
darshan-util/darshan-diff.c
=====================================
--- a/darshan-util/darshan-diff.c
+++ b/darshan-util/darshan-diff.c
@@ -53,8 +53,8 @@ int main(int argc, char *argv[])
darshan_fd file1, file2;
struct darshan_job job1, job2;
char exe1[4096], exe2[4096];
- struct darshan_record_ref *name_hash1 = NULL, *name_hash2 = NULL;
- struct darshan_record_ref *name_ref1, *name_ref2;
+ struct darshan_name_record_ref *name_hash1 = NULL, *name_hash2 = NULL;
+ struct darshan_name_record_ref *name_ref1, *name_ref2;
struct darshan_file_record_ref *rec_hash1 = NULL, *rec_hash2 = NULL;
struct darshan_file_record_ref *rec_ref1, *rec_ref2, *rec_tmp;
struct darshan_mod_record_ref *mod_rec1, *mod_rec2;
@@ -89,7 +89,7 @@ int main(int argc, char *argv[])
}
/* get job data for each log file */
- ret = darshan_log_getjob(file1, &job1);
+ ret = darshan_log_get_job(file1, &job1);
if(ret < 0)
{
darshan_log_close(file1);
@@ -98,7 +98,7 @@ int main(int argc, char *argv[])
return(-1);
}
- ret = darshan_log_getjob(file2, &job2);
+ ret = darshan_log_get_job(file2, &job2);
if(ret < 0)
{
darshan_log_close(file1);
@@ -108,7 +108,7 @@ int main(int argc, char *argv[])
}
/* get exe string for each log file */
- ret = darshan_log_getexe(file1, exe1);
+ ret = darshan_log_get_exe(file1, exe1);
if(ret < 0)
{
darshan_log_close(file1);
@@ -117,7 +117,7 @@ int main(int argc, char *argv[])
return(-1);
}
- ret = darshan_log_getexe(file2, exe2);
+ ret = darshan_log_get_exe(file2, exe2);
if(ret < 0)
{
darshan_log_close(file1);
@@ -144,7 +144,7 @@ int main(int argc, char *argv[])
(int64_t)(job2.end_time - job2.start_time + 1));
/* get hash of record ids to file names for each log */
- ret = darshan_log_gethash(file1, &name_hash1);
+ ret = darshan_log_get_namehash(file1, &name_hash1);
if(ret < 0)
{
darshan_log_close(file1);
@@ -153,7 +153,7 @@ int main(int argc, char *argv[])
return(-1);
}
- ret = darshan_log_gethash(file2, &name_hash2);
+ ret = darshan_log_get_namehash(file2, &name_hash2);
if(ret < 0)
{
darshan_log_close(file1);
@@ -246,14 +246,14 @@ int main(int argc, char *argv[])
HASH_FIND(hlink, name_hash1, &(base_rec1->id),
sizeof(darshan_record_id), name_ref1);
assert(name_ref1);
- file_name1 = name_ref1->name;
+ file_name1 = name_ref1->name_record->name;
}
if(mod_buf2)
{
HASH_FIND(hlink, name_hash2, &(base_rec2->id),
sizeof(darshan_record_id), name_ref2);
assert(name_ref2);
- file_name2 = name_ref2->name;
+ file_name2 = name_ref2->name_record->name;
}
mod_logutils[i]->log_print_diff(mod_buf1, file_name1, mod_buf2, file_name2);
@@ -314,7 +314,7 @@ int main(int argc, char *argv[])
HASH_FIND(hlink, name_hash2, &(base_rec2->id),
sizeof(darshan_record_id), name_ref2);
assert(name_ref2);
- file_name2 = name_ref2->name;
+ file_name2 = name_ref2->name_record->name;
mod_logutils[i]->log_print_diff(NULL, NULL, mod_rec2->mod_dat, file_name2);
@@ -340,13 +340,13 @@ int main(int argc, char *argv[])
HASH_ITER(hlink, name_hash1, name_ref1, name_ref2)
{
HASH_DELETE(hlink, name_hash1, name_ref1);
- free(name_ref1->name);
+ free(name_ref1->name_record);
free(name_ref1);
}
HASH_ITER(hlink, name_hash2, name_ref2, name_ref1)
{
HASH_DELETE(hlink, name_hash2, name_ref2);
- free(name_ref2->name);
+ free(name_ref2->name_record);
free(name_ref2);
}
=====================================
darshan-util/darshan-hdf5-logutils.c
=====================================
--- a/darshan-util/darshan-hdf5-logutils.c
+++ b/darshan-util/darshan-hdf5-logutils.c
@@ -55,7 +55,7 @@ static int darshan_log_get_hdf5_file(darshan_fd fd, void* hdf5_buf)
int i;
int ret;
- ret = darshan_log_getmod(fd, DARSHAN_HDF5_MOD, hdf5_buf,
+ ret = darshan_log_get_mod(fd, DARSHAN_HDF5_MOD, hdf5_buf,
sizeof(struct darshan_hdf5_file));
if(ret < 0)
return(-1);
@@ -84,7 +84,7 @@ static int darshan_log_put_hdf5_file(darshan_fd fd, void* hdf5_buf, int ver)
struct darshan_hdf5_file *file = (struct darshan_hdf5_file *)hdf5_buf;
int ret;
- ret = darshan_log_putmod(fd, DARSHAN_HDF5_MOD, file,
+ ret = darshan_log_put_mod(fd, DARSHAN_HDF5_MOD, file,
sizeof(struct darshan_hdf5_file), ver);
if(ret < 0)
return(-1);
=====================================
darshan-util/darshan-logutils.c
=====================================
--- a/darshan-util/darshan-logutils.c
+++ b/darshan-util/darshan-logutils.c
@@ -27,7 +27,7 @@
*/
#define DARSHAN_HEADER_REGION_ID (-3)
#define DARSHAN_JOB_REGION_ID (-2)
-#define DARSHAN_REC_MAP_REGION_ID (-1)
+#define DARSHAN_NAME_MAP_REGION_ID (-1)
struct darshan_dz_state
{
@@ -66,8 +66,8 @@ struct darshan_fd_int_state
struct darshan_dz_state dz;
};
-static int darshan_log_getheader(darshan_fd fd);
-static int darshan_log_putheader(darshan_fd fd);
+static int darshan_log_get_header(darshan_fd fd);
+static int darshan_log_put_header(darshan_fd fd);
static int darshan_log_seek(darshan_fd fd, off_t offset);
static int darshan_log_read(darshan_fd fd, void *buf, int len);
static int darshan_log_write(darshan_fd fd, void *buf, int len);
@@ -136,7 +136,7 @@ darshan_fd darshan_log_open(const char *name)
strncpy(tmp_fd->state->logfile_path, name, PATH_MAX);
/* read the header from the log file to init fd data structures */
- ret = darshan_log_getheader(tmp_fd);
+ ret = darshan_log_get_header(tmp_fd);
if(ret < 0)
{
fprintf(stderr, "Error: failed to read darshan log file header.\n");
@@ -229,13 +229,13 @@ darshan_fd darshan_log_create(const char *name, enum darshan_comp_type comp_type
return(tmp_fd);
}
-/* darshan_log_getjob()
+/* darshan_log_get_job()
*
* read job level metadata from the darshan log file
*
* returns 0 on success, -1 on failure
*/
-int darshan_log_getjob(darshan_fd fd, struct darshan_job *job)
+int darshan_log_get_job(darshan_fd fd, struct darshan_job *job)
{
struct darshan_fd_int_state *state = fd->state;
char job_buf[DARSHAN_JOB_RECORD_SIZE] = {0};
@@ -275,13 +275,13 @@ int darshan_log_getjob(darshan_fd fd, struct darshan_job *job)
return(0);
}
-/* darshan_log_putjob()
+/* darshan_log_put_job()
*
* write job level metadata to darshan log file
*
* returns 0 on success, -1 on failure
*/
-int darshan_log_putjob(darshan_fd fd, struct darshan_job *job)
+int darshan_log_put_job(darshan_fd fd, struct darshan_job *job)
{
struct darshan_fd_int_state *state = fd->state;
struct darshan_job job_copy;
@@ -316,13 +316,13 @@ int darshan_log_putjob(darshan_fd fd, struct darshan_job *job)
return(0);
}
-/* darshan_log_getexe()
+/* darshan_log_get_exe()
*
* reads the application exe name from darshan log file
*
* returns 0 on success, -1 on failure
*/
-int darshan_log_getexe(darshan_fd fd, char *buf)
+int darshan_log_get_exe(darshan_fd fd, char *buf)
{
struct darshan_fd_int_state *state = fd->state;
char *newline;
@@ -334,7 +334,7 @@ int darshan_log_getexe(darshan_fd fd, char *buf)
if(!(state->exe_mnt_data))
{
struct darshan_job job;
- ret = darshan_log_getjob(fd, &job);
+ ret = darshan_log_get_job(fd, &job);
if(ret < 0 || !(state->exe_mnt_data))
return(-1);
@@ -350,7 +350,7 @@ int darshan_log_getexe(darshan_fd fd, char *buf)
return (0);
}
-/* darshan_log_putexe()
+/* darshan_log_put_exe()
*
* wrties the application exe name to darshan log file
* NOTE: this needs to be called immediately following put_job as it
@@ -359,7 +359,7 @@ int darshan_log_getexe(darshan_fd fd, char *buf)
*
* returns 0 on success, -1 on failure
*/
-int darshan_log_putexe(darshan_fd fd, char *buf)
+int darshan_log_put_exe(darshan_fd fd, char *buf)
{
struct darshan_fd_int_state *state = fd->state;
int len = strlen(buf);
@@ -378,7 +378,7 @@ int darshan_log_putexe(darshan_fd fd, char *buf)
return(0);
}
-/* darshan_log_getmounts()
+/* darshan_log_get_mounts()
*
* retrieves mount table information from the log. Note that mnt_pts and
* fs_types are arrays that will be allocated by the function and must be
@@ -386,7 +386,7 @@ int darshan_log_putexe(darshan_fd fd, char *buf)
*
* returns 0 on success, -1 on failure
*/
-int darshan_log_getmounts(darshan_fd fd, char*** mnt_pts,
+int darshan_log_get_mounts(darshan_fd fd, char*** mnt_pts,
char*** fs_types, int* count)
{
struct darshan_fd_int_state *state = fd->state;
@@ -400,7 +400,7 @@ int darshan_log_getmounts(darshan_fd fd, char*** mnt_pts,
if(!(state->exe_mnt_data))
{
struct darshan_job job;
- ret = darshan_log_getjob(fd, &job);
+ ret = darshan_log_get_job(fd, &job);
if(ret < 0 || !(state->exe_mnt_data))
return(-1);
@@ -453,7 +453,7 @@ int darshan_log_getmounts(darshan_fd fd, char*** mnt_pts,
return(0);
}
-/* darshan_log_putmounts()
+/* darshan_log_put_mounts()
*
* writes mount information to the darshan log file
* NOTE: this function call should follow immediately after the call
@@ -462,7 +462,7 @@ int darshan_log_getmounts(darshan_fd fd, char*** mnt_pts,
*
* returns 0 on success, -1 on failure
*/
-int darshan_log_putmounts(darshan_fd fd, char** mnt_pts, char** fs_types, int count)
+int darshan_log_put_mounts(darshan_fd fd, char** mnt_pts, char** fs_types, int count)
{
struct darshan_fd_int_state *state = fd->state;
int i;
@@ -496,122 +496,112 @@ int darshan_log_putmounts(darshan_fd fd, char** mnt_pts, char** fs_types, int co
return(0);
}
-/* darshan_log_gethash()
+/* darshan_log_get_namehash()
*
- * read the hash of records from the darshan log file
+ * read the hash of name records from the darshan log file
*
* returns 0 on success, -1 on failure
*/
-int darshan_log_gethash(darshan_fd fd, struct darshan_record_ref **hash)
+int darshan_log_get_namehash(darshan_fd fd, struct darshan_name_record_ref **hash)
{
struct darshan_fd_int_state *state = fd->state;
- char *hash_buf;
- int hash_buf_sz;
- char *buf_ptr;
- darshan_record_id *rec_id_ptr;
- char *path_ptr;
+ char *name_rec_buf;
char *tmp_p;
- struct darshan_record_ref *ref;
+ int name_rec_buf_sz;
int read;
int read_req_sz;
+ struct darshan_name_record_ref *ref;
+ struct darshan_name_record *name_rec;
int buf_rem = 0;
+ int rec_len;
assert(state);
- /* just return if there is no record mapping data */
- if(fd->rec_map.len == 0)
+ /* just return if there is no name record mapping data */
+ if(fd->name_map.len == 0)
{
*hash = NULL;
return(0);
}
- /* default to hash buffer twice as big as default compression buf */
- hash_buf = malloc(DARSHAN_DEF_COMP_BUF_SZ * 2);
- if(!hash_buf)
+ /* default to buffer twice as big as default compression buf */
+ name_rec_buf_sz = DARSHAN_DEF_COMP_BUF_SZ * 2;
+ name_rec_buf = malloc(name_rec_buf_sz);
+ if(!name_rec_buf)
return(-1);
- memset(hash_buf, 0, DARSHAN_DEF_COMP_BUF_SZ * 2);
- hash_buf_sz = DARSHAN_DEF_COMP_BUF_SZ * 2;
+ memset(name_rec_buf, 0, name_rec_buf_sz);
do
{
- /* read chunks of the darshan record id -> file name mapping from log file,
+ /* read chunks of the darshan record id -> name mapping from log file,
* constructing a hash table in the process
*/
- read_req_sz = hash_buf_sz - buf_rem;
- read = darshan_log_dzread(fd, DARSHAN_REC_MAP_REGION_ID,
- hash_buf + buf_rem, read_req_sz);
+ read_req_sz = name_rec_buf_sz - buf_rem;
+ read = darshan_log_dzread(fd, DARSHAN_NAME_MAP_REGION_ID,
+ name_rec_buf + buf_rem, read_req_sz);
if(read < 0)
{
- fprintf(stderr, "Error: failed to read record hash from darshan log file.\n");
- free(hash_buf);
+ fprintf(stderr, "Error: failed to read name hash from darshan log file.\n");
+ free(name_rec_buf);
return(-1);
}
+ buf_rem += read;
- /* work through the hash buffer -- deserialize the mapping data and
+ /* work through the name record buffer -- deserialize the mapping data and
* add to the output hash table
* NOTE: these mapping pairs are variable in length, so we have to be able
* to handle incomplete mappings temporarily here
*/
- buf_ptr = hash_buf;
- buf_rem += read;
- while(buf_rem > (sizeof(darshan_record_id) + 1))
+ name_rec = (struct darshan_name_record *)name_rec_buf;
+ while(buf_rem > sizeof(darshan_record_id) + 1)
{
- tmp_p = buf_ptr + sizeof(darshan_record_id);
- while(tmp_p < (buf_ptr + buf_rem))
+ if(strnlen(name_rec->name, buf_rem - sizeof(darshan_record_id)) ==
+ (buf_rem - sizeof(darshan_record_id)))
{
- /* look for terminating null character for record name */
- if(*tmp_p == '\0')
- break;
- tmp_p++;
- }
- if(*tmp_p != '\0')
+ /* if this record name's terminating null character is not
+ * present, we need to read more of the buffer before continuing
+ */
break;
-
- /* get pointers for each field of this darshan record */
- /* NOTE: darshan record hash serialization method:
- * ... darshan_record_id | path '\0' ...
- */
- rec_id_ptr = (darshan_record_id *)buf_ptr;
- buf_ptr += sizeof(darshan_record_id);
- path_ptr = (char *)buf_ptr;
+ }
if(fd->swap_flag)
{
/* we need to sort out endianness issues before deserializing */
- DARSHAN_BSWAP64(rec_id_ptr);
+ DARSHAN_BSWAP64(&(name_rec->id));
}
- HASH_FIND(hlink, *hash, rec_id_ptr, sizeof(darshan_record_id), ref);
+ HASH_FIND(hlink, *hash, &(name_rec->id), sizeof(darshan_record_id), ref);
if(!ref)
{
+ rec_len = sizeof(darshan_record_id) + strlen(name_rec->name) + 1;
ref = malloc(sizeof(*ref));
if(!ref)
{
- free(hash_buf);
+ free(name_rec_buf);
return(-1);
}
- ref->name = malloc(strlen(path_ptr) + 1);
- if(!ref->name)
+ ref->name_record = malloc(rec_len);
+ if(!ref->name_record)
{
free(ref);
- free(hash_buf);
+ free(name_rec_buf);
return(-1);
}
- /* set the fields for this record */
- ref->id = *rec_id_ptr;
- strcpy(ref->name, path_ptr);
+ /* copy the name record over from the hash buffer */
+ memcpy(ref->name_record, name_rec, rec_len);
/* add this record to the hash */
- HASH_ADD(hlink, *hash, id, sizeof(darshan_record_id), ref);
+ HASH_ADD(hlink, *hash, name_record->id, sizeof(darshan_record_id), ref);
}
- buf_ptr += strlen(path_ptr) + 1;
- buf_rem -= (sizeof(darshan_record_id) + strlen(path_ptr) + 1);
+ tmp_p = (char *)name_rec + rec_len;
+ name_rec = (struct darshan_name_record *)tmp_p;
+ buf_rem -= rec_len;
}
/* copy any leftover data to beginning of buffer to parse next */
- memcpy(hash_buf, buf_ptr, buf_rem);
+ memcpy(name_rec_buf, name_rec, buf_rem);
/* we keep reading until we get a short read informing us we have
* read all of the record hash
@@ -619,74 +609,64 @@ int darshan_log_gethash(darshan_fd fd, struct darshan_record_ref **hash)
} while(read == read_req_sz);
assert(buf_rem == 0);
- free(hash_buf);
+ free(name_rec_buf);
return(0);
}
-/* darshan_log_puthash()
+/* darshan_log_put_namehash()
*
- * writes the hash table of records to the darshan log file
+ * writes the hash table of name records to the darshan log file
* NOTE: this function call should follow immediately after the call
* to darshan_log_putmounts(), as it assumes the darshan log file pointer
* is pointing to the offset immediately following the mount information
*
* returns 0 on success, -1 on failure
*/
-int darshan_log_puthash(darshan_fd fd, struct darshan_record_ref *hash)
+int darshan_log_put_namehash(darshan_fd fd, struct darshan_name_record_ref *hash)
{
struct darshan_fd_int_state *state = fd->state;
- char *hash_buf;
- int hash_buf_sz;
- struct darshan_record_ref *ref, *tmp;
- char *buf_ptr;
+ struct darshan_name_record_ref *ref, *tmp;
+ struct darshan_name_record_ref *name_rec;
+ int name_rec_len;
int wrote;
assert(state);
/* allocate memory for largest possible hash record */
- hash_buf_sz = sizeof(darshan_record_id) + PATH_MAX + 1;
- hash_buf = malloc(hash_buf_sz);
- if(!hash_buf)
+ name_rec = malloc(sizeof(struct darshan_name_record) + PATH_MAX);
+ if(!name_rec)
return(-1);
- memset(hash_buf, 0, hash_buf_sz);
+ memset(name_rec, 0, sizeof(struct darshan_name_record) + PATH_MAX);
/* individually serialize each hash record and write to log file */
HASH_ITER(hlink, hash, ref, tmp)
{
- buf_ptr = hash_buf;
-
- /* the hash buffer has space to serialize this record
- * NOTE: darshan record hash serialization method:
- * ... darshan_record_id | path '\0' ...
- */
- *((darshan_record_id *)buf_ptr) = ref->id;
- buf_ptr += sizeof(darshan_record_id);
- strcpy(buf_ptr, ref->name);
- buf_ptr += strlen(ref->name) + 1;
+ name_rec_len = sizeof(struct darshan_name_record) + strlen(ref->name_record->name);
+ memcpy(name_rec, ref->name_record, name_rec_len);
/* write this hash entry to log file */
- wrote = darshan_log_dzwrite(fd, DARSHAN_REC_MAP_REGION_ID,
- hash_buf, (buf_ptr - hash_buf));
- if(wrote != (buf_ptr - hash_buf))
+ wrote = darshan_log_dzwrite(fd, DARSHAN_NAME_MAP_REGION_ID,
+ name_rec, name_rec_len);
+ if(wrote != name_rec_len)
{
state->err = -1;
- fprintf(stderr, "Error: failed to write record hash to darshan log file.\n");
- free(hash_buf);
+ fprintf(stderr, "Error: failed to write name hash to darshan log file.\n");
+ free(name_rec);
return(-1);
}
}
- free(hash_buf);
+ free(name_rec);
return(0);
}
-/* darshan_log_getmod()
+/* darshan_log_get_mod()
*
* get a chunk of module data from the darshan log file
*
* returns number of bytes read on success, -1 on failure
*/
-int darshan_log_getmod(darshan_fd fd, darshan_module_id mod_id,
+int darshan_log_get_mod(darshan_fd fd, darshan_module_id mod_id,
void *mod_buf, int mod_buf_sz)
{
struct darshan_fd_int_state *state = fd->state;
@@ -716,7 +696,7 @@ int darshan_log_getmod(darshan_fd fd, darshan_module_id mod_id,
return(ret);
}
-/* darshan_log_putmod()
+/* darshan_log_put_mod()
*
* write a chunk of module data to the darshan log file
* NOTE: this function call should be called directly after the
@@ -728,7 +708,7 @@ int darshan_log_getmod(darshan_fd fd, darshan_module_id mod_id,
*
* returns number of bytes written on success, -1 on failure
*/
-int darshan_log_putmod(darshan_fd fd, darshan_module_id mod_id,
+int darshan_log_put_mod(darshan_fd fd, darshan_module_id mod_id,
void *mod_buf, int mod_buf_sz, int ver)
{
struct darshan_fd_int_state *state = fd->state;
@@ -798,7 +778,7 @@ void darshan_log_close(darshan_fd fd)
/* if no errors flushing, write the log header before closing */
if(state->err != -1)
{
- ret = darshan_log_putheader(fd);
+ ret = darshan_log_put_header(fd);
if(ret < 0)
state->err = -1;
}
@@ -830,7 +810,7 @@ void darshan_log_close(darshan_fd fd)
*
* returns 0 on success, -1 on failure
*/
-static int darshan_log_getheader(darshan_fd fd)
+static int darshan_log_get_header(darshan_fd fd)
{
struct darshan_header header;
int i;
@@ -889,8 +869,8 @@ static int darshan_log_getheader(darshan_fd fd)
fd->swap_flag = 1;
/* swap the log map variables in the header */
- DARSHAN_BSWAP64(&(header.rec_map.off));
- DARSHAN_BSWAP64(&(header.rec_map.len));
+ DARSHAN_BSWAP64(&(header.name_map.off));
+ DARSHAN_BSWAP64(&(header.name_map.len));
for(i = 0; i < DARSHAN_MAX_MODS; i++)
{
DARSHAN_BSWAP64(&(header.mod_map[i].off));
@@ -911,12 +891,12 @@ static int darshan_log_getheader(darshan_fd fd)
memcpy(fd->mod_ver, header.mod_ver, DARSHAN_MAX_MODS * sizeof(uint32_t));
/* save the mapping of data within log file to this file descriptor */
- memcpy(&fd->rec_map, &(header.rec_map), sizeof(struct darshan_log_map));
+ memcpy(&fd->name_map, &(header.name_map), sizeof(struct darshan_log_map));
memcpy(&fd->mod_map, &(header.mod_map), DARSHAN_MAX_MODS * sizeof(struct darshan_log_map));
/* there may be nothing following the job data, so safety check map */
fd->job_map.off = sizeof(struct darshan_header);
- if(fd->rec_map.off == 0)
+ if(fd->name_map.off == 0)
{
for(i = 0; i < DARSHAN_MAX_MODS; i++)
{
@@ -940,7 +920,7 @@ static int darshan_log_getheader(darshan_fd fd)
}
else
{
- fd->job_map.len = fd->rec_map.off - fd->job_map.off;
+ fd->job_map.len = fd->name_map.off - fd->job_map.off;
}
return(0);
@@ -950,7 +930,7 @@ static int darshan_log_getheader(darshan_fd fd)
*
* returns 0 on success, -1 on failure
*/
-static int darshan_log_putheader(darshan_fd fd)
+static int darshan_log_put_header(darshan_fd fd)
{
struct darshan_header header;
int ret;
@@ -967,7 +947,7 @@ static int darshan_log_putheader(darshan_fd fd)
header.magic_nr = DARSHAN_MAGIC_NR;
header.comp_type = fd->comp_type;
header.partial_flag = fd->partial_flag;
- memcpy(&header.rec_map, &fd->rec_map, sizeof(struct darshan_log_map));
+ memcpy(&header.name_map, &fd->name_map, sizeof(struct darshan_log_map));
memcpy(header.mod_map, fd->mod_map, DARSHAN_MAX_MODS * sizeof(struct darshan_log_map));
memcpy(header.mod_ver, fd->mod_ver, DARSHAN_MAX_MODS * sizeof(uint32_t));
@@ -1200,8 +1180,8 @@ static int darshan_log_dzread(darshan_fd fd, int region_id, void *buf, int len)
if(region_id == DARSHAN_JOB_REGION_ID)
map = fd->job_map;
- else if(region_id == DARSHAN_REC_MAP_REGION_ID)
- map = fd->rec_map;
+ else if(region_id == DARSHAN_NAME_MAP_REGION_ID)
+ map = fd->name_map;
else
map = fd->mod_map[region_id];
@@ -1249,8 +1229,8 @@ static int darshan_log_dzwrite(darshan_fd fd, int region_id, void *buf, int len)
if(region_id == DARSHAN_JOB_REGION_ID)
map_p = &(fd->job_map);
- else if(region_id == DARSHAN_REC_MAP_REGION_ID)
- map_p = &(fd->rec_map);
+ else if(region_id == DARSHAN_NAME_MAP_REGION_ID)
+ map_p = &(fd->name_map);
else
map_p = &(fd->mod_map[region_id]);
@@ -1404,8 +1384,8 @@ static int darshan_log_libz_flush(darshan_fd fd, int region_id)
if(region_id == DARSHAN_JOB_REGION_ID)
map_p = &(fd->job_map);
- else if(region_id == DARSHAN_REC_MAP_REGION_ID)
- map_p = &(fd->rec_map);
+ else if(region_id == DARSHAN_NAME_MAP_REGION_ID)
+ map_p = &(fd->name_map);
else
map_p = &(fd->mod_map[region_id]);
@@ -1569,8 +1549,8 @@ static int darshan_log_bzip2_flush(darshan_fd fd, int region_id)
if(region_id == DARSHAN_JOB_REGION_ID)
map_p = &(fd->job_map);
- else if(region_id == DARSHAN_REC_MAP_REGION_ID)
- map_p = &(fd->rec_map);
+ else if(region_id == DARSHAN_NAME_MAP_REGION_ID)
+ map_p = &(fd->name_map);
else
map_p = &(fd->mod_map[region_id]);
=====================================
darshan-util/darshan-logutils.h
=====================================
--- a/darshan-util/darshan-logutils.h
+++ b/darshan-util/darshan-logutils.h
@@ -33,7 +33,7 @@ struct darshan_fd_s
enum darshan_comp_type comp_type;
/* log file offset/length maps for each log file region */
struct darshan_log_map job_map;
- struct darshan_log_map rec_map;
+ struct darshan_log_map name_map;
struct darshan_log_map mod_map[DARSHAN_MAX_MODS];
/* module-specific log-format versions contained in log */
uint32_t mod_ver[DARSHAN_MAX_MODS];
@@ -43,10 +43,9 @@ struct darshan_fd_s
};
typedef struct darshan_fd_s* darshan_fd;
-struct darshan_record_ref
+struct darshan_name_record_ref
{
- char *name;
- darshan_record_id id;
+ struct darshan_name_record *name_record;
UT_hash_handle hlink;
};
@@ -119,19 +118,19 @@ extern struct darshan_mod_logutil_funcs *mod_logutils[];
darshan_fd darshan_log_open(const char *name);
darshan_fd darshan_log_create(const char *name, enum darshan_comp_type comp_type,
int partial_flag);
-int darshan_log_getjob(darshan_fd fd, struct darshan_job *job);
-int darshan_log_putjob(darshan_fd fd, struct darshan_job *job);
-int darshan_log_getexe(darshan_fd fd, char *buf);
-int darshan_log_putexe(darshan_fd fd, char *buf);
-int darshan_log_getmounts(darshan_fd fd, char*** mnt_pts,
+int darshan_log_get_job(darshan_fd fd, struct darshan_job *job);
+int darshan_log_put_job(darshan_fd fd, struct darshan_job *job);
+int darshan_log_get_exe(darshan_fd fd, char *buf);
+int darshan_log_put_exe(darshan_fd fd, char *buf);
+int darshan_log_get_mounts(darshan_fd fd, char*** mnt_pts,
char*** fs_types, int* count);
-int darshan_log_putmounts(darshan_fd fd, char** mnt_pts,
+int darshan_log_put_mounts(darshan_fd fd, char** mnt_pts,
char** fs_types, int count);
-int darshan_log_gethash(darshan_fd fd, struct darshan_record_ref **hash);
-int darshan_log_puthash(darshan_fd fd, struct darshan_record_ref *hash);
-int darshan_log_getmod(darshan_fd fd, darshan_module_id mod_id,
+int darshan_log_get_namehash(darshan_fd fd, struct darshan_name_record_ref **hash);
+int darshan_log_put_namehash(darshan_fd fd, struct darshan_name_record_ref *hash);
+int darshan_log_get_mod(darshan_fd fd, darshan_module_id mod_id,
void *mod_buf, int mod_buf_sz);
-int darshan_log_putmod(darshan_fd fd, darshan_module_id mod_id,
+int darshan_log_put_mod(darshan_fd fd, darshan_module_id mod_id,
void *mod_buf, int mod_buf_sz, int ver);
void darshan_log_close(darshan_fd file);
=====================================
darshan-util/darshan-merge.c
=====================================
--- a/darshan-util/darshan-merge.c
+++ b/darshan-util/darshan-merge.c
@@ -192,9 +192,9 @@ int main(int argc, char *argv[])
char **merge_mnt_pts;
char **merge_fs_types;
int merge_mnt_count = 0;
- struct darshan_record_ref *in_hash = NULL;
- struct darshan_record_ref *merge_hash = NULL;
- struct darshan_record_ref *ref, *tmp, *found;
+ struct darshan_name_record_ref *in_hash = NULL;
+ struct darshan_name_record_ref *merge_hash = NULL;
+ struct darshan_name_record_ref *ref, *tmp, *found;
struct darshan_shared_record_ref *shared_rec_hash = NULL;
struct darshan_shared_record_ref *sref, *stmp;
struct darshan_base_record *base_rec;
@@ -225,7 +225,7 @@ int main(int argc, char *argv[])
}
/* read job-level metadata from the input file */
- ret = darshan_log_getjob(in_fd, &in_job);
+ ret = darshan_log_get_job(in_fd, &in_job);
if(ret < 0)
{
fprintf(stderr,
@@ -254,7 +254,7 @@ int main(int argc, char *argv[])
/* get job data, exe, & mounts directly from the first input log */
memcpy(&merge_job, &in_job, sizeof(struct darshan_job));
- ret = darshan_log_getexe(in_fd, merge_exe);
+ ret = darshan_log_get_exe(in_fd, merge_exe);
if(ret < 0)
{
fprintf(stderr,
@@ -264,7 +264,7 @@ int main(int argc, char *argv[])
return(-1);
}
- ret = darshan_log_getmounts(in_fd, &merge_mnt_pts,
+ ret = darshan_log_get_mounts(in_fd, &merge_mnt_pts,
&merge_fs_types, &merge_mnt_count);
if(ret < 0)
{
@@ -285,7 +285,7 @@ int main(int argc, char *argv[])
}
/* read the hash of ids->names for the input log */
- ret = darshan_log_gethash(in_fd, &in_hash);
+ ret = darshan_log_get_namehash(in_fd, &in_hash);
if(ret < 0)
{
fprintf(stderr,
@@ -295,17 +295,19 @@ int main(int argc, char *argv[])
return(-1);
}
- /* iterate the input hash, copying over record_id->file_name mappings
+ /* iterate the input hash, copying over record id->name mappings
* that have not already been copied to the output hash
*/
HASH_ITER(hlink, in_hash, ref, tmp)
{
- HASH_FIND(hlink, merge_hash, &(ref->id), sizeof(darshan_record_id), found);
+ HASH_FIND(hlink, merge_hash, &(ref->name_record->id),
+ sizeof(darshan_record_id), found);
if(!found)
{
- HASH_ADD(hlink, merge_hash, id, sizeof(darshan_record_id), ref);
+ HASH_ADD(hlink, merge_hash, name_record->id,
+ sizeof(darshan_record_id), ref);
}
- else if(strcmp(ref->name, found->name))
+ else if(strcmp(ref->name_record->name, found->name_record->name))
{
fprintf(stderr,
"Error: invalid Darshan record table entry.\n");
@@ -330,7 +332,7 @@ int main(int argc, char *argv[])
}
/* write the darshan job info, exe string, and mount data to output file */
- ret = darshan_log_putjob(merge_fd, &merge_job);
+ ret = darshan_log_put_job(merge_fd, &merge_job);
if(ret < 0)
{
fprintf(stderr, "Error: unable to write job data to output darshan log.\n");
@@ -339,7 +341,7 @@ int main(int argc, char *argv[])
return(-1);
}
- ret = darshan_log_putexe(merge_fd, merge_exe);
+ ret = darshan_log_put_exe(merge_fd, merge_exe);
if(ret < 0)
{
fprintf(stderr, "Error: unable to write exe string to output darshan log.\n");
@@ -348,7 +350,7 @@ int main(int argc, char *argv[])
return(-1);
}
- ret = darshan_log_putmounts(merge_fd, merge_mnt_pts, merge_fs_types, merge_mnt_count);
+ ret = darshan_log_put_mounts(merge_fd, merge_mnt_pts, merge_fs_types, merge_mnt_count);
if(ret < 0)
{
fprintf(stderr, "Error: unable to write mount data to output darshan log.\n");
@@ -358,7 +360,7 @@ int main(int argc, char *argv[])
}
/* write the merged table of records to output file */
- ret = darshan_log_puthash(merge_fd, merge_hash);
+ ret = darshan_log_put_namehash(merge_fd, merge_hash);
if(ret < 0)
{
fprintf(stderr, "Error: unable to write record table to output darshan log.\n");
=====================================
darshan-util/darshan-mpiio-logutils.c
=====================================
--- a/darshan-util/darshan-mpiio-logutils.c
+++ b/darshan-util/darshan-mpiio-logutils.c
@@ -55,7 +55,7 @@ static int darshan_log_get_mpiio_file(darshan_fd fd, void* mpiio_buf)
int i;
int ret;
- ret = darshan_log_getmod(fd, DARSHAN_MPIIO_MOD, mpiio_buf,
+ ret = darshan_log_get_mod(fd, DARSHAN_MPIIO_MOD, mpiio_buf,
sizeof(struct darshan_mpiio_file));
if(ret < 0)
return(-1);
@@ -84,7 +84,7 @@ static int darshan_log_put_mpiio_file(darshan_fd fd, void* mpiio_buf, int ver)
struct darshan_mpiio_file *file = (struct darshan_mpiio_file *)mpiio_buf;
int ret;
- ret = darshan_log_putmod(fd, DARSHAN_MPIIO_MOD, file,
+ ret = darshan_log_put_mod(fd, DARSHAN_MPIIO_MOD, file,
sizeof(struct darshan_mpiio_file), ver);
if(ret < 0)
return(-1);
=====================================
darshan-util/darshan-null-logutils.c
=====================================
--- a/darshan-util/darshan-null-logutils.c
+++ b/darshan-util/darshan-null-logutils.c
@@ -67,7 +67,7 @@ static int darshan_log_get_null_record(darshan_fd fd, void* null_buf)
int ret;
/* read a NULL module record from the darshan log file */
- ret = darshan_log_getmod(fd, DARSHAN_NULL_MOD, null_buf,
+ ret = darshan_log_get_mod(fd, DARSHAN_NULL_MOD, null_buf,
sizeof(struct darshan_null_record));
if(ret < 0)
return(-1);
@@ -101,7 +101,7 @@ static int darshan_log_put_null_record(darshan_fd fd, void* null_buf, int ver)
int ret;
/* append NULL record to darshan log file */
- ret = darshan_log_putmod(fd, DARSHAN_NULL_MOD, rec,
+ ret = darshan_log_put_mod(fd, DARSHAN_NULL_MOD, rec,
sizeof(struct darshan_null_record), ver);
if(ret < 0)
return(-1);
=====================================
darshan-util/darshan-parser.c
=====================================
--- a/darshan-util/darshan-parser.c
+++ b/darshan-util/darshan-parser.c
@@ -107,13 +107,13 @@ void posix_accum_file(struct darshan_posix_file *pfile, hash_entry_t *hfile, int
void posix_accum_perf(struct darshan_posix_file *pfile, perf_data_t *pdata);
void posix_calc_file(hash_entry_t *file_hash, file_data_t *fdata);
void posix_print_total_file(struct darshan_posix_file *pfile);
-void posix_file_list(hash_entry_t *file_hash, struct darshan_record_ref *rec_hash, int detail_flag);
+void posix_file_list(hash_entry_t *file_hash, struct darshan_name_record_ref *name_hash, int detail_flag);
void mpiio_accum_file(struct darshan_mpiio_file *mfile, hash_entry_t *hfile, int64_t nprocs);
void mpiio_accum_perf(struct darshan_mpiio_file *mfile, perf_data_t *pdata);
void mpiio_calc_file(hash_entry_t *file_hash, file_data_t *fdata);
void mpiio_print_total_file(struct darshan_mpiio_file *mfile);
-void mpiio_file_list(hash_entry_t *file_hash, struct darshan_record_ref *rec_hash, int detail_flag);
+void mpiio_file_list(hash_entry_t *file_hash, struct darshan_name_record_ref *name_hash, int detail_flag);
void calc_perf(perf_data_t *pdata, int64_t nprocs);
@@ -203,8 +203,8 @@ int main(int argc, char **argv)
char tmp_string[4096] = {0};
darshan_fd fd;
struct darshan_job job;
- struct darshan_record_ref *rec_hash = NULL;
- struct darshan_record_ref *ref, *tmp_ref;
+ struct darshan_name_record_ref *name_hash = NULL;
+ struct darshan_name_record_ref *ref, *tmp_ref;
int mount_count;
char** mnt_pts;
char** fs_types;
@@ -234,7 +234,7 @@ int main(int argc, char **argv)
return(-1);
/* read darshan job info */
- ret = darshan_log_getjob(fd, &job);
+ ret = darshan_log_get_job(fd, &job);
if(ret < 0)
{
darshan_log_close(fd);
@@ -242,7 +242,7 @@ int main(int argc, char **argv)
}
/* get the original command line for this job */
- ret = darshan_log_getexe(fd, tmp_string);
+ ret = darshan_log_get_exe(fd, tmp_string);
if(ret < 0)
{
darshan_log_close(fd);
@@ -250,7 +250,7 @@ int main(int argc, char **argv)
}
/* get the mount information for this log */
- ret = darshan_log_getmounts(fd, &mnt_pts, &fs_types, &mount_count);
+ ret = darshan_log_get_mounts(fd, &mnt_pts, &fs_types, &mount_count);
if(ret < 0)
{
darshan_log_close(fd);
@@ -258,7 +258,7 @@ int main(int argc, char **argv)
}
/* read hash of darshan records */
- ret = darshan_log_gethash(fd, &rec_hash);
+ ret = darshan_log_get_namehash(fd, &name_hash);
if(ret < 0)
{
darshan_log_close(fd);
@@ -317,7 +317,7 @@ int main(int argc, char **argv)
printf("# -------------------------------------------------------\n");
printf("# header: %zu bytes (uncompressed)\n", sizeof(struct darshan_header));
printf("# job data: %zu bytes (compressed)\n", fd->job_map.len);
- printf("# record table: %zu bytes (compressed)\n", fd->rec_map.len);
+ printf("# record table: %zu bytes (compressed)\n", fd->name_map.len);
for(i=0; i<DARSHAN_MAX_MODS; i++)
{
if(fd->mod_map[i].len)
@@ -426,13 +426,13 @@ int main(int argc, char **argv)
base_rec = (struct darshan_base_record *)mod_buf;
/* get the pathname for this record */
- HASH_FIND(hlink, rec_hash, &(base_rec->id), sizeof(darshan_record_id), ref);
+ HASH_FIND(hlink, name_hash, &(base_rec->id), sizeof(darshan_record_id), ref);
assert(ref);
/* get mount point and fs type associated with this record */
for(j=0; j<mount_count; j++)
{
- if(strncmp(mnt_pts[j], ref->name, strlen(mnt_pts[j])) == 0)
+ if(strncmp(mnt_pts[j], ref->name_record->name, strlen(mnt_pts[j])) == 0)
{
mnt_pt = mnt_pts[j];
fs_type = fs_types[j];
@@ -447,7 +447,7 @@ int main(int argc, char **argv)
if(mask & OPTION_BASE)
{
/* print the corresponding module data for this record */
- mod_logutils[i]->log_print_record(mod_buf, ref->name,
+ mod_logutils[i]->log_print_record(mod_buf, ref->name_record->name,
mnt_pt, fs_type, fd->mod_ver[i]);
}
@@ -598,16 +598,16 @@ int main(int argc, char **argv)
if(i == DARSHAN_POSIX_MOD)
{
if(mask & OPTION_FILE_LIST_DETAILED)
- posix_file_list(file_hash, rec_hash, 1);
+ posix_file_list(file_hash, name_hash, 1);
else
- posix_file_list(file_hash, rec_hash, 0);
+ posix_file_list(file_hash, name_hash, 0);
}
else if(i == DARSHAN_MPIIO_MOD)
{
if(mask & OPTION_FILE_LIST_DETAILED)
- mpiio_file_list(file_hash, rec_hash, 1);
+ mpiio_file_list(file_hash, name_hash, 1);
else
- mpiio_file_list(file_hash, rec_hash, 0);
+ mpiio_file_list(file_hash, name_hash, 0);
}
}
@@ -640,10 +640,10 @@ cleanup:
free(pdata.rank_cumul_md_time);
/* free record hash data */
- HASH_ITER(hlink, rec_hash, ref, tmp_ref)
+ HASH_ITER(hlink, name_hash, ref, tmp_ref)
{
- HASH_DELETE(hlink, rec_hash, ref);
- free(ref->name);
+ HASH_DELETE(hlink, name_hash, ref);
+ free(ref->name_record);
free(ref);
}
@@ -1413,13 +1413,13 @@ void mpiio_print_total_file(struct darshan_mpiio_file *mfile)
}
void posix_file_list(hash_entry_t *file_hash,
- struct darshan_record_ref *rec_hash,
+ struct darshan_name_record_ref *name_hash,
int detail_flag)
{
hash_entry_t *curr = NULL;
hash_entry_t *tmp = NULL;
struct darshan_posix_file *file_rec = NULL;
- struct darshan_record_ref *ref = NULL;
+ struct darshan_name_record_ref *ref = NULL;
int i;
/* list of columns:
@@ -1477,12 +1477,12 @@ void posix_file_list(hash_entry_t *file_hash,
file_rec = (struct darshan_posix_file*)curr->rec_dat;
assert(file_rec);
- HASH_FIND(hlink, rec_hash, &(curr->rec_id), sizeof(darshan_record_id), ref);
+ HASH_FIND(hlink, name_hash, &(curr->rec_id), sizeof(darshan_record_id), ref);
assert(ref);
printf("%" PRIu64 "\t%s\t%" PRId64 "\t%f\t%f",
curr->rec_id,
- ref->name,
+ ref->name_record->name,
curr->procs,
curr->slowest_time,
curr->cumul_time/(double)curr->procs);
@@ -1504,13 +1504,13 @@ void posix_file_list(hash_entry_t *file_hash,
}
void mpiio_file_list(hash_entry_t *file_hash,
- struct darshan_record_ref *rec_hash,
+ struct darshan_name_record_ref *name_hash,
int detail_flag)
{
hash_entry_t *curr = NULL;
hash_entry_t *tmp = NULL;
struct darshan_mpiio_file *file_rec = NULL;
- struct darshan_record_ref *ref = NULL;
+ struct darshan_name_record_ref *ref = NULL;
int i;
/* list of columns:
@@ -1571,12 +1571,12 @@ void mpiio_file_list(hash_entry_t *file_hash,
file_rec = (struct darshan_mpiio_file*)curr->rec_dat;
assert(file_rec);
- HASH_FIND(hlink, rec_hash, &(curr->rec_id), sizeof(darshan_record_id), ref);
+ HASH_FIND(hlink, name_hash, &(curr->rec_id), sizeof(darshan_record_id), ref);
assert(ref);
printf("%" PRIu64 "\t%s\t%" PRId64 "\t%f\t%f",
curr->rec_id,
- ref->name,
+ ref->name_record->name,
curr->procs,
curr->slowest_time,
curr->cumul_time/(double)curr->procs);
=====================================
darshan-util/darshan-pnetcdf-logutils.c
=====================================
--- a/darshan-util/darshan-pnetcdf-logutils.c
+++ b/darshan-util/darshan-pnetcdf-logutils.c
@@ -55,7 +55,7 @@ static int darshan_log_get_pnetcdf_file(darshan_fd fd, void* pnetcdf_buf)
int i;
int ret;
- ret = darshan_log_getmod(fd, DARSHAN_PNETCDF_MOD, pnetcdf_buf,
+ ret = darshan_log_get_mod(fd, DARSHAN_PNETCDF_MOD, pnetcdf_buf,
sizeof(struct darshan_pnetcdf_file));
if(ret < 0)
return(-1);
@@ -84,7 +84,7 @@ static int darshan_log_put_pnetcdf_file(darshan_fd fd, void* pnetcdf_buf, int ve
struct darshan_pnetcdf_file *file = (struct darshan_pnetcdf_file *)pnetcdf_buf;
int ret;
- ret = darshan_log_putmod(fd, DARSHAN_PNETCDF_MOD, file,
+ ret = darshan_log_put_mod(fd, DARSHAN_PNETCDF_MOD, file,
sizeof(struct darshan_pnetcdf_file), ver);
if(ret < 0)
return(-1);
=====================================
darshan-util/darshan-posix-logutils.c
=====================================
--- a/darshan-util/darshan-posix-logutils.c
+++ b/darshan-util/darshan-posix-logutils.c
@@ -55,7 +55,7 @@ static int darshan_log_get_posix_file(darshan_fd fd, void* posix_buf)
int i;
int ret;
- ret = darshan_log_getmod(fd, DARSHAN_POSIX_MOD, posix_buf,
+ ret = darshan_log_get_mod(fd, DARSHAN_POSIX_MOD, posix_buf,
sizeof(struct darshan_posix_file));
if(ret < 0)
return(-1);
@@ -84,7 +84,7 @@ static int darshan_log_put_posix_file(darshan_fd fd, void* posix_buf, int ver)
struct darshan_posix_file *file = (struct darshan_posix_file *)posix_buf;
int ret;
- ret = darshan_log_putmod(fd, DARSHAN_POSIX_MOD, file,
+ ret = darshan_log_put_mod(fd, DARSHAN_POSIX_MOD, file,
sizeof(struct darshan_posix_file), ver);
if(ret < 0)
return(-1);
View it on GitLab: https://xgitlab.cels.anl.gov/darshan/darshan/compare/94430f41b6f479bf73c4350a26378a1b04c1db0e...999ee9c886eaff3b6a013badbf1f0eb298f2d116
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.mcs.anl.gov/pipermail/darshan-commits/attachments/20160526/30da4057/attachment-0001.html>
More information about the Darshan-commits
mailing list