Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
Sudheer Chunduri
darshan
Commits
13b92a1f
Commit
13b92a1f
authored
Apr 06, 2015
by
Shane Snyder
Browse files
adding posix common access/stride counters
parent
b70229e4
Changes
4
Hide whitespace changes
Inline
Side-by-side
darshan-posix-log-format.h
View file @
13b92a1f
...
...
@@ -39,47 +39,45 @@ enum darshan_posix_indices
POSIX_FILE_ALIGNMENT
,
/* file alignment in bytes */
POSIX_MAX_READ_TIME_SIZE
,
POSIX_MAX_WRITE_TIME_SIZE
,
#if 0
/* buckets */
SIZE_READ_0_100,
/* count of posix read size ranges */
SIZE_READ_100_1K,
SIZE_READ_1K_10K,
SIZE_READ_10K_100K,
SIZE_READ_100K_1M,
SIZE_READ_1M_4M,
SIZE_READ_4M_10M,
SIZE_READ_10M_100M,
SIZE_READ_100M_1G,
SIZE_READ_1G_PLUS,
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 */
SIZE_WRITE_0_100, /* count of posix write size ranges */
SIZE_WRITE_100_1K,
SIZE_WRITE_1K_10K,
SIZE_WRITE_10K_100K,
SIZE_WRITE_100K_1M,
SIZE_WRITE_1M_4M,
SIZE_WRITE_4M_10M,
SIZE_WRITE_10M_100M,
SIZE_WRITE_100M_1G,
SIZE_WRITE_1G_PLUS,
/* counters */
STRIDE1_STRIDE, /* the four most frequently appearing strides */
STRIDE2_STRIDE,
STRIDE3_STRIDE,
STRIDE4_STRIDE,
STRIDE1_COUNT, /* count of each of the most frequent strides */
STRIDE2_COUNT,
STRIDE3_COUNT,
STRIDE4_COUNT,
ACCESS1_ACCESS, /* the four most frequently appearing access sizes */
ACCESS2_ACCESS,
ACCESS3_ACCESS,
ACCESS4_ACCESS,
ACCESS1_COUNT, /* count of each of the most frequent access sizes */
ACCESS2_COUNT,
ACCESS3_COUNT,
ACCESS4_COUNT,
#endif
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
,
...
...
darshan-runtime/darshan.h
View file @
13b92a1f
...
...
@@ -102,6 +102,29 @@
(__rec_p)->counters[__counter] = __value; \
} while(0)
#define DARSHAN_BUCKET_INC(__rec_p, __counter_base, __value) do {\
if(__value < 101) \
(__rec_p)->counters[__counter_base] += 1; \
else if(__value < 1025) \
(__rec_p)->counters[__counter_base+1] += 1; \
else if(__value < 10241) \
(__rec_p)->counters[__counter_base+2] += 1; \
else if(__value < 102401) \
(__rec_p)->counters[__counter_base+3] += 1; \
else if(__value < 1048577) \
(__rec_p)->counters[__counter_base+4] += 1; \
else if(__value < 4194305) \
(__rec_p)->counters[__counter_base+5] += 1; \
else if(__value < 10485761) \
(__rec_p)->counters[__counter_base+6] += 1; \
else if(__value < 104857601) \
(__rec_p)->counters[__counter_base+7] += 1; \
else if(__value < 1073741825) \
(__rec_p)->counters[__counter_base+8] += 1; \
else \
(__rec_p)->counters[__counter_base+9] += 1; \
} while(0)
/* module developers provide the following functions to darshan-core */
struct
darshan_module_funcs
{
...
...
darshan-runtime/lib/darshan-posix.c
View file @
13b92a1f
...
...
@@ -4,6 +4,9 @@
*
*/
#define _XOPEN_SOURCE 500
#define _GNU_SOURCE
#include
"darshan-runtime-config.h"
#include
<stdio.h>
#include
<unistd.h>
...
...
@@ -21,7 +24,6 @@
#include
<assert.h>
#include
<libgen.h>
#include
<aio.h>
#define __USE_GNU
#include
<pthread.h>
#include
"uthash.h"
...
...
@@ -35,6 +37,7 @@ typedef int64_t off64_t;
#define aiocb64 aiocb
#endif
/* TODO: this probably shouldn't be here long term -- MPI symbols mess up LD_PRELOAD */
#ifdef DARSHAN_PRELOAD
extern
double
(
*
__real_PMPI_Comm_rank
)(
MPI_Comm
comm
,
int
*
rank
);
#endif
...
...
@@ -79,19 +82,11 @@ DARSHAN_FORWARD_DECL(fclose, int, (FILE *fp));
/* TODO aio */
/* TODO listio */
static
void
posix_runtime_initialize
(
void
);
static
struct
posix_file_runtime
*
posix_file_by_name
(
const
char
*
name
);
static
struct
posix_file_runtime
*
posix_file_by_name_setfd
(
const
char
*
name
,
int
fd
);
static
struct
posix_file_runtime
*
posix_file_by_fd
(
int
fd
);
static
void
posix_file_close_fd
(
int
fd
);
static
void
posix_disable_instrumentation
(
void
);
static
void
posix_prepare_for_reduction
(
darshan_record_id
*
shared_recs
,
int
*
shared_rec_count
,
void
**
send_buf
,
void
**
recv_buf
,
int
*
rec_size
);
static
void
posix_record_reduction_op
(
void
*
infile_v
,
void
*
inoutfile_v
,
int
*
len
,
MPI_Datatype
*
datatype
);
static
void
posix_get_output_data
(
void
**
buffer
,
int
*
size
);
static
void
posix_shutdown
(
void
);
/* maximum number of access sizes and stride sizes that darshan will track
* per file at runtime; at log time they will be reduced into the 4 most
* frequently occurring ones
*/
#define POSIX_MAX_ACCESS_COUNT_RUNTIME 32
enum
posix_io_type
{
...
...
@@ -99,6 +94,18 @@ enum posix_io_type
POSIX_WRITE
=
2
,
};
enum
posix_counter_type
{
POSIX_COUNTER_ACCESS
,
POSIX_COUNTER_STRIDE
};
struct
posix_access_counter
{
int64_t
size
;
int
freq
;
};
/* The posix_file_runtime structure maintains necessary runtime metadata
* for the POSIX file record (darshan_posix_file structure, defined in
* darshan-posix-log-format.h) pointed to by 'file_record'. This metadata
...
...
@@ -132,6 +139,10 @@ struct posix_file_runtime
double
last_meta_end
;
double
last_read_end
;
double
last_write_end
;
void
*
access_root
;
int
access_count
;
void
*
stride_root
;
int
stride_count
;
UT_hash_handle
hlink
;
};
...
...
@@ -187,9 +198,59 @@ static int instrumentation_disabled = 0;
static
int
my_rank
=
-
1
;
static
int
darshan_mem_alignment
=
1
;
/* global variables for determining 4 most common accesses/strides */
static
struct
posix_file_runtime
*
walker_file
=
NULL
;
static
int
walker_validx
;
static
int
walker_cntidx
;
static
void
posix_runtime_initialize
(
void
);
static
struct
posix_file_runtime
*
posix_file_by_name
(
const
char
*
name
);
static
struct
posix_file_runtime
*
posix_file_by_name_setfd
(
const
char
*
name
,
int
fd
);
static
struct
posix_file_runtime
*
posix_file_by_fd
(
int
fd
);
static
void
posix_file_close_fd
(
int
fd
);
static
void
posix_access_counter
(
struct
posix_file_runtime
*
file
,
ssize_t
size
,
enum
posix_counter_type
type
);
static
void
posix_access_walker
(
const
void
*
nodep
,
const
VISIT
which
,
const
int
depth
);
static
void
posix_walk_file_accesses
(
void
);
static
int
posix_access_compare
(
const
void
*
a_p
,
const
void
*
b_p
);
static
int
posix_file_compare
(
const
void
*
a
,
const
void
*
b
);
static
void
posix_disable_instrumentation
(
void
);
static
void
posix_prepare_for_reduction
(
darshan_record_id
*
shared_recs
,
int
*
shared_rec_count
,
void
**
send_buf
,
void
**
recv_buf
,
int
*
rec_size
);
static
void
posix_record_reduction_op
(
void
*
infile_v
,
void
*
inoutfile_v
,
int
*
len
,
MPI_Datatype
*
datatype
);
static
void
posix_get_output_data
(
void
**
buffer
,
int
*
size
);
static
void
posix_shutdown
(
void
);
#define POSIX_LOCK() pthread_mutex_lock(&posix_runtime_mutex)
#define POSIX_UNLOCK() pthread_mutex_unlock(&posix_runtime_mutex)
#define POSIX_COMMON_COUNTER_INC(__rec_p, __value, __count, __validx, __cntidx) do {\
int i; \
int set = 0; \
int64_t min = DARSHAN_COUNTER_VALUE(__rec_p, __cntidx); \
int min_index = 0; \
if(__value == 0) break; \
for(i=0; i<4; i++) { \
/* increment bucket if already exists */
\
if(DARSHAN_COUNTER_VALUE(__rec_p, __validx + i) == __value) { \
DARSHAN_COUNTER_INC(__rec_p, __cntidx + i, __count); \
set = 1; \
break; \
} \
/* otherwise find the least frequently used bucket */
\
else if(DARSHAN_COUNTER_VALUE(__rec_p, __cntidx + i) < min) { \
min = DARSHAN_COUNTER_VALUE(__rec_p, __cntidx + i); \
min_index = i; \
} \
} \
if(!set && (__count > min)) { \
DARSHAN_COUNTER_SET(__rec_p, __cntidx+min_index, __count); \
DARSHAN_COUNTER_SET(__rec_p, __validx+min_index, __value); \
} \
} while(0)
#define POSIX_RECORD_OPEN(__ret, __path, __mode, __stream_flag, __tm1, __tm2) do { \
struct posix_file_runtime* file; \
char* exclude; \
...
...
@@ -219,7 +280,7 @@ static int darshan_mem_alignment = 1;
} while(0)
#define POSIX_RECORD_READ(__ret, __fd, __pread_flag, __pread_offset, __aligned, __stream_flag, __tm1, __tm2) do{ \
/*
size_t stride;
*/
\
size_t stride; \
int64_t this_offset; \
struct posix_file_runtime* file; \
int64_t file_alignment; \
...
...
@@ -235,11 +296,11 @@ static int darshan_mem_alignment = 1;
DARSHAN_COUNTER_INC(file->file_record, POSIX_SEQ_READS, 1); \
if(this_offset == (file->last_byte_read + 1)) \
DARSHAN_COUNTER_INC(file->file_record, POSIX_CONSEC_READS, 1); \
/*
if(this_offset > 0 && this_offset > file->last_byte_read \
if(this_offset > 0 && this_offset > file->last_byte_read \
&& file->last_byte_read != 0) \
stride = this_offset - file->last_byte_read - 1; \
else \
stride = 0;
*/
\
stride = 0; \
file->last_byte_read = this_offset + __ret - 1; \
file->offset = this_offset + __ret; \
DARSHAN_COUNTER_MAX(file->file_record, POSIX_MAX_BYTE_READ, (this_offset + __ret - 1)); \
...
...
@@ -248,9 +309,9 @@ static int darshan_mem_alignment = 1;
DARSHAN_COUNTER_INC(file->file_record, POSIX_FREADS, 1); \
else\
DARSHAN_COUNTER_INC(file->file_record, POSIX_READS, 1); \
/* CP
_BUCKET_INC(file
, CP
_SIZE_READ_0_100, __ret); \
c
p_access_counter(file, __ret,
C
P_COUNTER_ACCESS); \
c
p_access_counter(file, stride,
C
P_COUNTER_STRIDE);
*/
\
DARSHAN
_BUCKET_INC(file
->file_record, POSIX
_SIZE_READ_0_100, __ret); \
p
osix
_access_counter(file, __ret, P
OSIX
_COUNTER_ACCESS); \
p
osix
_access_counter(file, stride, P
OSIX
_COUNTER_STRIDE); \
if(!__aligned) \
DARSHAN_COUNTER_INC(file->file_record, POSIX_MEM_NOT_ALIGNED, 1); \
file_alignment = DARSHAN_COUNTER_VALUE(file->file_record, POSIX_FILE_ALIGNMENT); \
...
...
@@ -269,7 +330,7 @@ static int darshan_mem_alignment = 1;
} while(0)
#define POSIX_RECORD_WRITE(__ret, __fd, __pwrite_flag, __pwrite_offset, __aligned, __stream_flag, __tm1, __tm2) do{ \
/*
size_t stride;
*/
\
size_t stride; \
int64_t this_offset; \
struct posix_file_runtime* file; \
int64_t file_alignment; \
...
...
@@ -285,11 +346,11 @@ static int darshan_mem_alignment = 1;
DARSHAN_COUNTER_INC(file->file_record, POSIX_SEQ_WRITES, 1); \
if(this_offset == (file->last_byte_written + 1)) \
DARSHAN_COUNTER_INC(file->file_record, POSIX_CONSEC_WRITES, 1); \
/*
if(this_offset > 0 && this_offset > file->last_byte_written \
if(this_offset > 0 && this_offset > file->last_byte_written \
&& file->last_byte_written != 0) \
stride = this_offset - file->last_byte_written - 1; \
else \
stride = 0;
*/
\
stride = 0; \
file->last_byte_written = this_offset + __ret - 1; \
file->offset = this_offset + __ret; \
DARSHAN_COUNTER_MAX(file->file_record, POSIX_MAX_BYTE_WRITTEN, (this_offset + __ret - 1)); \
...
...
@@ -298,9 +359,9 @@ static int darshan_mem_alignment = 1;
DARSHAN_COUNTER_INC(file->file_record, POSIX_FWRITES, 1); \
else \
DARSHAN_COUNTER_INC(file->file_record, POSIX_WRITES, 1); \
/* CP
_BUCKET_INC(file
, CP
_SIZE_WRITE_0_100, __ret); \
c
p_access_counter(file, __ret,
C
P_COUNTER_ACCESS); \
c
p_access_counter(file, stride,
C
P_COUNTER_STRIDE);
*/
\
DARSHAN
_BUCKET_INC(file
->file_record, POSIX
_SIZE_WRITE_0_100, __ret); \
p
osix
_access_counter(file, __ret, P
OSIX
_COUNTER_ACCESS); \
p
osix
_access_counter(file, stride, P
OSIX
_COUNTER_STRIDE); \
if(!__aligned) \
DARSHAN_COUNTER_INC(file->file_record, POSIX_MEM_NOT_ALIGNED, 1); \
file_alignment = DARSHAN_COUNTER_VALUE(file->file_record, POSIX_FILE_ALIGNMENT); \
...
...
@@ -1420,15 +1481,143 @@ static void posix_file_close_fd(int fd)
return
;
}
static
void
posix_access_counter
(
struct
posix_file_runtime
*
file
,
ssize_t
size
,
enum
posix_counter_type
type
)
{
struct
posix_access_counter
*
counter
;
struct
posix_access_counter
*
found
;
void
*
tmp
;
void
**
root
;
int
*
count
;
struct
posix_access_counter
tmp_counter
;
/* don't count sizes or strides of 0 */
if
(
size
==
0
)
return
;
switch
(
type
)
{
case
POSIX_COUNTER_ACCESS
:
root
=
&
file
->
access_root
;
count
=
&
file
->
access_count
;
break
;
case
POSIX_COUNTER_STRIDE
:
root
=
&
file
->
stride_root
;
count
=
&
file
->
stride_count
;
break
;
default:
return
;
}
/* check to see if this size is already recorded */
tmp_counter
.
size
=
size
;
tmp_counter
.
freq
=
1
;
tmp
=
tfind
(
&
tmp_counter
,
root
,
posix_access_compare
);
if
(
tmp
)
{
found
=
*
(
struct
posix_access_counter
**
)
tmp
;
found
->
freq
++
;
return
;
}
/* we can add a new one as long as we haven't hit the limit */
if
(
*
count
<
POSIX_MAX_ACCESS_COUNT_RUNTIME
)
{
counter
=
malloc
(
sizeof
(
*
counter
));
if
(
!
counter
)
{
return
;
}
counter
->
size
=
size
;
counter
->
freq
=
1
;
tmp
=
tsearch
(
counter
,
root
,
posix_access_compare
);
found
=
*
(
struct
posix_access_counter
**
)
tmp
;
/* if we get a new answer out here we are in trouble; this was
* already checked with the tfind()
*/
assert
(
found
==
counter
);
(
*
count
)
++
;
}
return
;
}
static
void
posix_access_walker
(
const
void
*
nodep
,
const
VISIT
which
,
const
int
depth
)
{
struct
posix_access_counter
*
counter
;
switch
(
which
)
{
case
postorder
:
case
leaf
:
counter
=
*
(
struct
posix_access_counter
**
)
nodep
;
POSIX_COMMON_COUNTER_INC
(
walker_file
->
file_record
,
counter
->
size
,
counter
->
freq
,
walker_validx
,
walker_cntidx
);
default:
break
;
}
return
;
};
/* posix_walk_file_accesses()
*
* goes through runtime collections of accesses sizes and chooses the 4 most
* common for logging
*/
static
void
posix_walk_file_accesses
()
{
int
i
;
for
(
i
=
0
;
i
<
posix_runtime
->
file_array_ndx
;
i
++
)
{
/* walk trees for both access sizes and stride sizes to pick 4 most
* common of each
*/
/* NOTE: setting global variables here for cp_access_walker() */
walker_file
=
&
posix_runtime
->
file_runtime_array
[
i
];
walker_validx
=
POSIX_ACCESS1_ACCESS
;
walker_cntidx
=
POSIX_ACCESS1_COUNT
;
twalk
(
walker_file
->
access_root
,
posix_access_walker
);
tdestroy
(
walker_file
->
access_root
,
free
);
walker_validx
=
POSIX_STRIDE1_STRIDE
;
walker_cntidx
=
POSIX_STRIDE1_COUNT
;
twalk
(
walker_file
->
stride_root
,
posix_access_walker
);
tdestroy
(
walker_file
->
stride_root
,
free
);
}
return
;
}
static
int
posix_access_compare
(
const
void
*
a_p
,
const
void
*
b_p
)
{
const
struct
posix_access_counter
*
a
=
a_p
;
const
struct
posix_access_counter
*
b
=
b_p
;
if
(
a
->
size
<
b
->
size
)
return
(
-
1
);
if
(
a
->
size
>
b
->
size
)
return
(
1
);
return
(
0
);
}
/* compare function for sorting file records by descending rank */
static
int
posix_file_compare
(
const
void
*
a
,
const
void
*
b
)
static
int
posix_file_compare
(
const
void
*
a
_p
,
const
void
*
b
_p
)
{
const
struct
darshan_posix_file
*
f_
a
=
a
;
const
struct
darshan_posix_file
*
f_
b
=
b
;
const
struct
darshan_posix_file
*
a
=
a
_p
;
const
struct
darshan_posix_file
*
b
=
b
_p
;
if
(
f_
a
->
rank
<
f_
b
->
rank
)
if
(
a
->
rank
<
b
->
rank
)
return
1
;
if
(
f_
a
->
rank
>
f_
b
->
rank
)
if
(
a
->
rank
>
b
->
rank
)
return
-
1
;
return
0
;
...
...
@@ -1443,6 +1632,9 @@ static void posix_disable_instrumentation()
assert
(
posix_runtime
);
POSIX_LOCK
();
posix_walk_file_accesses
();
instrumentation_disabled
=
1
;
POSIX_UNLOCK
();
...
...
@@ -1535,8 +1727,7 @@ static void posix_record_reduction_op(
struct
darshan_posix_file
tmp_file
;
struct
darshan_posix_file
*
infile
=
infile_v
;
struct
darshan_posix_file
*
inoutfile
=
inoutfile_v
;
int
i
;
int
j
;
int
i
,
j
,
k
;
assert
(
posix_runtime
);
...
...
@@ -1587,6 +1778,70 @@ static void posix_record_reduction_op(
inoutfile
->
counters
[
j
];
}
/* skip POSIX_MAX_*_TIME_SIZE; handled in floating point section */
for
(
j
=
POSIX_SIZE_READ_0_100
;
j
<=
POSIX_SIZE_WRITE_1G_PLUS
;
j
++
)
{
tmp_file
.
counters
[
j
]
=
infile
->
counters
[
j
]
+
inoutfile
->
counters
[
j
];
}
/* first collapse any duplicates */
for
(
j
=
POSIX_STRIDE1_STRIDE
;
j
<=
POSIX_STRIDE4_STRIDE
;
j
++
)
{
for
(
k
=
POSIX_STRIDE1_STRIDE
;
k
<=
POSIX_STRIDE4_STRIDE
;
k
++
)
{
if
(
infile
->
counters
[
j
]
==
inoutfile
->
counters
[
k
])
{
infile
->
counters
[
j
+
4
]
+=
inoutfile
->
counters
[
k
+
4
];
inoutfile
->
counters
[
k
]
=
0
;
inoutfile
->
counters
[
k
+
4
]
=
0
;
}
}
}
/* first set */
for
(
j
=
POSIX_STRIDE1_STRIDE
;
j
<=
POSIX_STRIDE4_STRIDE
;
j
++
)
{
POSIX_COMMON_COUNTER_INC
(
&
tmp_file
,
infile
->
counters
[
j
],
infile
->
counters
[
j
+
4
],
POSIX_STRIDE1_STRIDE
,
POSIX_STRIDE1_COUNT
);
}
/* second set */
for
(
j
=
POSIX_STRIDE1_STRIDE
;
j
<=
POSIX_STRIDE4_STRIDE
;
j
++
)
{
POSIX_COMMON_COUNTER_INC
(
&
tmp_file
,
inoutfile
->
counters
[
j
],
inoutfile
->
counters
[
j
+
4
],
POSIX_STRIDE1_STRIDE
,
POSIX_STRIDE1_COUNT
);
}
/* same for access counts */
/* first collapse any duplicates */
for
(
j
=
POSIX_ACCESS1_ACCESS
;
j
<=
POSIX_ACCESS4_ACCESS
;
j
++
)
{
for
(
k
=
POSIX_ACCESS1_ACCESS
;
k
<=
POSIX_ACCESS4_ACCESS
;
k
++
)
{
if
(
infile
->
counters
[
j
]
==
inoutfile
->
counters
[
k
])
{
infile
->
counters
[
j
+
4
]
+=
inoutfile
->
counters
[
k
+
4
];
inoutfile
->
counters
[
k
]
=
0
;
inoutfile
->
counters
[
k
+
4
]
=
0
;
}
}
}
/* first set */
for
(
j
=
POSIX_ACCESS1_ACCESS
;
j
<=
POSIX_ACCESS4_ACCESS
;
j
++
)
{
POSIX_COMMON_COUNTER_INC
(
&
tmp_file
,
infile
->
counters
[
j
],
infile
->
counters
[
j
+
4
],
POSIX_ACCESS1_ACCESS
,
POSIX_ACCESS1_COUNT
);
}
/* second set */
for
(
j
=
POSIX_ACCESS1_ACCESS
;
j
<=
POSIX_ACCESS4_ACCESS
;
j
++
)
{
POSIX_COMMON_COUNTER_INC
(
&
tmp_file
,
inoutfile
->
counters
[
j
],
inoutfile
->
counters
[
j
+
4
],
POSIX_ACCESS1_ACCESS
,
POSIX_ACCESS1_COUNT
);
}
/* min non-zero (if available) value */
for
(
j
=
POSIX_F_OPEN_TIMESTAMP
;
j
<=
POSIX_F_WRITE_START_TIMESTAMP
;
j
++
)
{
...
...
darshan-util/darshan-posix-parser.c
View file @
13b92a1f
...
...
@@ -198,6 +198,42 @@ int main(int argc, char **argv)
"
\t\t
POSIX_FILE_ALIGNMENT:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_MAX_READ_TIME_SIZE:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_MAX_WRITE_TIME_SIZE:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_READ_0_100:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_READ_100_1K:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_READ_1K_10K:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_READ_10K_100K:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_READ_100K_1M:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_READ_1M_4M:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_READ_4M_10M:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_READ_10M_100M:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_READ_100M_1G:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_READ_1G_PLUS:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_WRITE_0_100:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_WRITE_100_1K:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_WRITE_1K_10K:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_WRITE_10K_100K:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_WRITE_100K_1M:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_WRITE_1M_4M:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_WRITE_4M_10M:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_WRITE_10M_100M:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_WRITE_100M_1G:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SIZE_WRITE_1G_PLUS:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_STRIDE1_STRIDE:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_STRIDE2_STRIDE:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_STRIDE3_STRIDE:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_STRIDE4_STRIDE:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_STRIDE1_COUNT:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_STRIDE2_COUNT:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_STRIDE3_COUNT:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_STRIDE4_COUNT:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_ACCESS1_ACCESS:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_ACCESS2_ACCESS:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_ACCESS3_ACCESS:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_ACCESS4_ACCESS:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_ACCESS1_COUNT:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_ACCESS2_COUNT:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_ACCESS3_COUNT:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_ACCESS4_COUNT:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_FASTEST_RANK:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_FASTEST_RANK_BYTES:
\t
%"
PRIu64
"
\n
"
"
\t\t
POSIX_SLOWEST_RANK:
\t
%"
PRIu64
"
\n
"
...
...
@@ -243,6 +279,42 @@ int main(int argc, char **argv)
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
],