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
34b666ac
Commit
34b666ac
authored
Jan 29, 2015
by
Philip Carns
Browse files
stub in subdirs for platforms and test cases
parent
edfe5fab
Changes
4
Hide whitespace changes
Inline
Side-by-side
darshan-test/regression/run-all.sh
View file @
34b666ac
#!/bin/bash
if
[
"$#"
-ne
3
]
;
then
echo
"Usage: run-all.sh <darshan_install_path> <tmp_path> <platform>"
echo
"Example: ./run-all.sh ~/darshan-install /tmp/test ws"
echo
"Usage: run-all.sh <darshan_install_path> <tmp_path> <platform>"
1>&2
echo
"Example: ./run-all.sh ~/darshan-install /tmp/test ws"
1>&2
exit
1
fi
...
...
@@ -13,7 +13,7 @@ export DARSHAN_PLATFORM=$3
# check darshan path
if
[
!
-x
$DARSHAN_PATH
/bin/darshan-parser
]
;
then
echo
"Error:
$DARSHAN_PATH
doesn't contain a valid Darshan install."
echo
"Error:
$DARSHAN_PATH
doesn't contain a valid Darshan install."
1>&2
exit
1
fi
...
...
@@ -23,18 +23,34 @@ if [ ! -d $DARSHAN_TMP ]; then
fi
if
[
!
-d
$DARSHAN_TMP
]
;
then
echo
"Error: unable to find or create
$DARSHAN_TMP
"
echo
"Error: unable to find or create
$DARSHAN_TMP
"
1>&2
exit
1
fi
if
[
!
-w
$DARSHAN_TMP
]
;
then
echo
"Error: unable to write to
$DARSHAN_TMP
"
echo
"Error: unable to write to
$DARSHAN_TMP
"
1>&2
exit
1
fi
# make sure that we have sub-scripts for the specified platform
if
[
!
-d
$DARSHAN_PLATFORM
]
;
then
echo
"Error: unable to find scripts for platform
$DARSHAN_PLATFORM
"
echo
"Error: unable to find scripts for platform
$DARSHAN_PLATFORM
"
1>&2
exit
1
fi
# set up c compiler for this platform
DARSHAN_CC
=
`
$DARSHAN_PLATFORM
/setup-cc.sh
`
if
[
$?
!=
0
]
;
then
exit
1
fi
export
DARSHAN_CC
for
i
in
`
ls
test-cases/
*
.sh
`
;
do
$i
if
[
$?
!=
0
]
;
then
echo
"Error: failed to execute test case
$i
"
exit
1
fi
done
exit
0
darshan-test/regression/test-cases/mpi-io-test.sh
0 → 100755
View file @
34b666ac
#!/bin/bash
$DARSHAN_CC
test-cases/src/mpi-io-test.c
-o
$DARSHAN_TMP
/mpi-io-test
if
[
$?
!=
0
]
;
then
echo
"Error: failed to compile mpi-io-test"
1>&2
exit
1
fi
exit
0
darshan-test/regression/test-cases/src/mpi-io-test.c
0 → 100644
View file @
34b666ac
/*
* (C) 1995-2001 Clemson University and Argonne National Laboratory.
*
* See COPYING in top-level directory.
*/
/* mpi-io-test.c
*
* This is derived from code given to me by Rajeev Thakur. Dunno where
* it originated.
*
* It's purpose is to produce aggregate bandwidth numbers for varying
* block sizes, number of processors, an number of iterations.
*
* This is strictly an MPI program - it is used to test the MPI I/O
* functionality implemented by Romio.
*
* Compiling is usually easiest with something like:
* mpicc -Wall -Wstrict-prototypes mpi-io-test.c -o mpi-io-test
*
* NOTE: This code assumes that all command line arguments make it out to all
* the processes that make up the parallel job, which isn't always the case.
* So if it doesn't work on some platform, that might be why.
*/
#include
<stdio.h>
#include
<stdlib.h>
#include
<fcntl.h>
#include
<unistd.h>
#include
<string.h>
#include
<sys/time.h>
#include
<mpi.h>
#include
<errno.h>
#include
<getopt.h>
/* DEFAULT VALUES FOR OPTIONS */
static
int64_t
opt_block
=
16
*
1024
*
1024
;
static
int
opt_iter
=
1
;
static
int
opt_coll
=
0
;
static
int
opt_correct
=
0
;
static
int
opt_sync
=
0
;
static
int
opt_single
=
0
;
static
int
opt_verbose
=
0
;
static
int
opt_rdonly
=
0
;
static
int
opt_wronly
=
0
;
static
char
opt_file
[
256
]
=
"test.out"
;
static
char
opt_pvfs2tab
[
256
]
=
"notset"
;
static
int
opt_pvfstab_set
=
0
;
/* function prototypes */
static
int
parse_args
(
int
argc
,
char
**
argv
);
static
void
usage
(
void
);
static
void
handle_error
(
int
errcode
,
char
*
str
);
/* global vars */
static
int
mynod
=
0
;
static
int
nprocs
=
1
;
int
main
(
int
argc
,
char
**
argv
)
{
char
*
buf
,
*
tmp
=
NULL
,
*
check
;
int
i
,
j
,
v
,
err
,
sync_err
=
0
,
my_correct
=
1
,
correct
,
myerrno
;
double
stim
,
etim
;
double
write_tim
=
0
;
double
read_tim
=
0
;
double
read_bw
,
write_bw
;
double
max_read_tim
,
max_write_tim
;
double
min_read_tim
,
min_write_tim
;
double
ave_read_tim
,
ave_write_tim
;
double
sum_read_tim
,
sum_write_tim
;
double
sq_write_tim
,
sq_read_tim
;
double
sumsq_write_tim
,
sumsq_read_tim
;
double
var_read_tim
,
var_write_tim
;
int64_t
iter_jump
=
0
;
int64_t
seek_position
=
0
;
MPI_File
fh
;
MPI_Status
status
;
MPI_Comm
comm
;
int
nchars
=
0
;
int
namelen
;
char
processor_name
[
MPI_MAX_PROCESSOR_NAME
];
/* startup MPI and determine the rank of this process */
MPI_Init
(
&
argc
,
&
argv
);
MPI_Comm_size
(
MPI_COMM_WORLD
,
&
nprocs
);
MPI_Comm_rank
(
MPI_COMM_WORLD
,
&
mynod
);
MPI_Get_processor_name
(
processor_name
,
&
namelen
);
/* parse the command line arguments */
parse_args
(
argc
,
argv
);
if
(
opt_verbose
)
fprintf
(
stdout
,
"Process %d of %d is on %s
\n
"
,
mynod
,
nprocs
,
processor_name
);
if
(
mynod
==
0
)
printf
(
"# Using mpi-io calls.
\n
"
);
//sleep(15);
/* kindof a weird hack- if the location of the pvfstab file was
* specified on the command line, then spit out this location into
* the appropriate environment variable: */
if
(
opt_pvfstab_set
)
{
if
((
setenv
(
"PVFS2TAB_FILE"
,
opt_pvfs2tab
,
1
))
<
0
)
{
perror
(
"setenv"
);
goto
die_jar_jar_die
;
}
}
/* this is how much of the file data is covered on each iteration of
* the test. used to help determine the seek offset on each
* iteration */
iter_jump
=
nprocs
*
opt_block
;
/* setup a buffer of data to write */
if
(
!
(
tmp
=
malloc
((
size_t
)
opt_block
+
256
)))
{
perror
(
"malloc"
);
goto
die_jar_jar_die
;
}
buf
=
tmp
+
128
-
(((
long
)
tmp
)
%
128
);
/* align buffer */
/* open the file for writing */
if
(
opt_coll
)
{
comm
=
MPI_COMM_WORLD
;
}
else
{
comm
=
MPI_COMM_SELF
;
}
err
=
MPI_File_open
(
comm
,
opt_file
,
MPI_MODE_CREATE
|
MPI_MODE_RDWR
,
MPI_INFO_NULL
,
&
fh
);
if
(
err
!=
MPI_SUCCESS
)
{
handle_error
(
err
,
"MPI_File_open"
);
goto
die_jar_jar_die
;
}
nchars
=
(
int
)
(
opt_block
/
sizeof
(
char
));
if
(
!
opt_rdonly
)
{
/* now repeat the seek and write operations the number of times
* specified on the command line */
for
(
j
=
0
;
j
<
opt_iter
;
j
++
)
{
/* reading and writing to the same block is cheating, but sometimes
* we want to measure cached performance of file servers */
if
(
opt_single
==
1
)
seek_position
=
0
;
else
/* seek to an appropriate position depending on the iteration
* and rank of the current process */
seek_position
=
(
j
*
iter_jump
)
+
(
mynod
*
opt_block
);
MPI_File_seek
(
fh
,
seek_position
,
MPI_SEEK_SET
);
if
(
opt_correct
)
/* fill in buffer for iteration */
{
for
(
i
=
0
,
v
=
mynod
+
j
,
check
=
buf
;
i
<
opt_block
;
i
++
,
v
++
,
check
++
)
*
check
=
(
char
)
v
;
}
/* discover the starting time of the operation */
MPI_Barrier
(
MPI_COMM_WORLD
);
stim
=
MPI_Wtime
();
/* write out the data */
if
(
opt_coll
)
{
err
=
MPI_File_write_all
(
fh
,
buf
,
nchars
,
MPI_CHAR
,
&
status
);
}
else
{
err
=
MPI_File_write
(
fh
,
buf
,
nchars
,
MPI_CHAR
,
&
status
);
}
if
(
err
){
fprintf
(
stderr
,
"node %d, write error: %s
\n
"
,
mynod
,
strerror
(
errno
));
}
if
(
opt_sync
)
sync_err
=
MPI_File_sync
(
fh
);
if
(
sync_err
)
{
fprintf
(
stderr
,
"node %d, sync error: %s
\n
"
,
mynod
,
strerror
(
errno
));
}
/* discover the ending time of the operation */
etim
=
MPI_Wtime
();
write_tim
+=
(
etim
-
stim
);
/* we are done with this "write" iteration */
}
}
/* ! opt_rdonly */
err
=
MPI_File_close
(
&
fh
);
if
(
err
){
fprintf
(
stderr
,
"node %d, close error after write
\n
"
,
mynod
);
}
/* wait for everyone to synchronize at this point */
MPI_Barrier
(
MPI_COMM_WORLD
);
/* reopen the file to read the data back out */
err
=
MPI_File_open
(
comm
,
opt_file
,
MPI_MODE_CREATE
|
MPI_MODE_RDWR
,
MPI_INFO_NULL
,
&
fh
);
if
(
err
<
0
)
{
fprintf
(
stderr
,
"node %d, open error: %s
\n
"
,
mynod
,
strerror
(
errno
));
goto
die_jar_jar_die
;
}
if
(
!
opt_wronly
)
{
/* we are going to repeat the read operation the number of iterations
* specified */
for
(
j
=
0
;
j
<
opt_iter
;
j
++
)
{
/* reading and writing to the same block is cheating, but sometimes
* we want to measure cached performance of file servers */
if
(
opt_single
==
1
)
{
seek_position
=
0
;
}
else
{
/* seek to an appropriate position depending on the iteration
* and rank of the current process */
seek_position
=
(
j
*
iter_jump
)
+
(
mynod
*
opt_block
);
}
MPI_File_seek
(
fh
,
seek_position
,
MPI_SEEK_SET
);
/* discover the start time */
MPI_Barrier
(
MPI_COMM_WORLD
);
stim
=
MPI_Wtime
();
/* read in the file data */
if
(
opt_coll
)
{
err
=
MPI_File_read_all
(
fh
,
buf
,
nchars
,
MPI_CHAR
,
&
status
);
}
else
{
err
=
MPI_File_read
(
fh
,
buf
,
nchars
,
MPI_CHAR
,
&
status
);
}
myerrno
=
errno
;
/* discover the end time */
etim
=
MPI_Wtime
();
read_tim
+=
(
etim
-
stim
);
if
(
err
<
0
)
{
fprintf
(
stderr
,
"node %d, read error, loc = %lld: %s
\n
"
,
mynod
,
(
long
long
)
mynod
*
opt_block
,
strerror
(
myerrno
));
}
/* if the user wanted to check correctness, compare the write
* buffer to the read buffer */
if
(
opt_correct
)
{
int
badct
=
0
;
for
(
i
=
0
,
v
=
mynod
+
j
,
check
=
buf
;
i
<
opt_block
&&
badct
<
10
;
i
++
,
v
++
,
check
++
)
{
if
(
*
check
!=
(
char
)
v
)
{
my_correct
=
0
;
if
(
badct
<
10
)
{
badct
++
;
fprintf
(
stderr
,
"buf[%d] = %d, should be %d
\n
"
,
i
,
*
check
,
(
char
)
v
);
}
}
}
MPI_Allreduce
(
&
my_correct
,
&
correct
,
1
,
MPI_INT
,
MPI_MIN
,
MPI_COMM_WORLD
);
if
(
badct
==
10
)
fprintf
(
stderr
,
"...
\n
"
);
}
/* we are done with this read iteration */
}
}
/* !opt_wronly */
/* close the file */
err
=
MPI_File_close
(
&
fh
);
if
(
err
)
{
fprintf
(
stderr
,
"node %d, close error after write
\n
"
,
mynod
);
}
/* compute the read and write times */
MPI_Allreduce
(
&
read_tim
,
&
max_read_tim
,
1
,
MPI_DOUBLE
,
MPI_MAX
,
MPI_COMM_WORLD
);
MPI_Allreduce
(
&
read_tim
,
&
min_read_tim
,
1
,
MPI_DOUBLE
,
MPI_MIN
,
MPI_COMM_WORLD
);
MPI_Allreduce
(
&
read_tim
,
&
sum_read_tim
,
1
,
MPI_DOUBLE
,
MPI_SUM
,
MPI_COMM_WORLD
);
/* calculate our part of the summation used for variance */
sq_read_tim
=
read_tim
-
(
sum_read_tim
/
nprocs
);
sq_read_tim
=
sq_read_tim
*
sq_read_tim
;
MPI_Allreduce
(
&
sq_read_tim
,
&
sumsq_read_tim
,
1
,
MPI_DOUBLE
,
MPI_SUM
,
MPI_COMM_WORLD
);
MPI_Allreduce
(
&
write_tim
,
&
max_write_tim
,
1
,
MPI_DOUBLE
,
MPI_MAX
,
MPI_COMM_WORLD
);
MPI_Allreduce
(
&
write_tim
,
&
min_write_tim
,
1
,
MPI_DOUBLE
,
MPI_MIN
,
MPI_COMM_WORLD
);
MPI_Allreduce
(
&
write_tim
,
&
sum_write_tim
,
1
,
MPI_DOUBLE
,
MPI_SUM
,
MPI_COMM_WORLD
);
/* calculate our part of the summation used for variance */
sq_write_tim
=
write_tim
-
(
sum_write_tim
/
nprocs
);
sq_write_tim
=
sq_write_tim
*
sq_write_tim
;
MPI_Allreduce
(
&
sq_write_tim
,
&
sumsq_write_tim
,
1
,
MPI_DOUBLE
,
MPI_SUM
,
MPI_COMM_WORLD
);
/* calculate the average from the sum */
ave_read_tim
=
sum_read_tim
/
nprocs
;
ave_write_tim
=
sum_write_tim
/
nprocs
;
/* and finally compute variance */
if
(
nprocs
>
1
)
{
var_read_tim
=
sumsq_read_tim
/
(
nprocs
-
1
);
var_write_tim
=
sumsq_write_tim
/
(
nprocs
-
1
);
}
else
{
var_read_tim
=
0
;
var_write_tim
=
0
;
}
/* print out the results on one node */
if
(
mynod
==
0
)
{
read_bw
=
(
opt_block
*
nprocs
*
opt_iter
)
/
(
max_read_tim
*
1.0e6
);
write_bw
=
(
opt_block
*
nprocs
*
opt_iter
)
/
(
max_write_tim
*
1.0e6
);
printf
(
"nr_procs = %d, nr_iter = %d, blk_sz = %lld, coll = %d
\n
"
,
nprocs
,
opt_iter
,
(
long
long
)
opt_block
,
opt_coll
);
printf
(
"# total_size = %lld
\n
"
,
(
long
long
)
opt_block
*
nprocs
*
opt_iter
);
printf
(
"# Write: min_t = %f, max_t = %f, mean_t = %f, var_t = %f
\n
"
,
min_write_tim
,
max_write_tim
,
ave_write_tim
,
var_write_tim
);
printf
(
"# Read: min_t = %f, max_t = %f, mean_t = %f, var_t = %f
\n
"
,
min_read_tim
,
max_read_tim
,
ave_read_tim
,
var_read_tim
);
printf
(
"Write bandwidth = %f Mbytes/sec
\n
"
,
write_bw
);
printf
(
"Read bandwidth = %f Mbytes/sec
\n
"
,
read_bw
);
if
(
opt_correct
)
{
printf
(
"Correctness test %s.
\n
"
,
correct
?
"passed"
:
"failed"
);
}
}
die_jar_jar_die:
free
(
tmp
);
MPI_Finalize
();
return
(
0
);
}
static
int
parse_args
(
int
argc
,
char
**
argv
)
{
int
c
;
while
((
c
=
getopt
(
argc
,
argv
,
"b:i:f:p:CcyShvrw"
))
!=
EOF
)
{
switch
(
c
)
{
case
'b'
:
/* block size */
opt_block
=
atoi
(
optarg
);
break
;
case
'i'
:
/* iterations */
opt_iter
=
atoi
(
optarg
);
break
;
case
'f'
:
/* filename */
strncpy
(
opt_file
,
optarg
,
255
);
break
;
case
'p'
:
/* pvfstab file */
strncpy
(
opt_pvfs2tab
,
optarg
,
255
);
opt_pvfstab_set
=
1
;
break
;
case
'c'
:
/* correctness */
opt_correct
=
1
;
break
;
case
'C'
:
/* collective I/O */
opt_coll
=
1
;
break
;
case
'y'
:
/* sYnc */
opt_sync
=
1
;
break
;
case
'S'
:
/* Single region */
opt_single
=
1
;
break
;
case
'v'
:
/* verbose */
opt_verbose
=
1
;
break
;
case
'r'
:
/* read-only */
opt_rdonly
=
1
;
break
;
case
'w'
:
/* write-only */
opt_wronly
=
1
;
break
;
case
'h'
:
if
(
mynod
==
0
)
usage
();
exit
(
0
);
case
'?'
:
/* unknown */
if
(
mynod
==
0
)
usage
();
exit
(
1
);
default:
break
;
}
}
return
(
0
);
}
static
void
usage
(
void
)
{
printf
(
"Usage: mpi-io-test [<OPTIONS>...]
\n
"
);
printf
(
"
\n
<OPTIONS> is one of
\n
"
);
printf
(
" -b block size (in bytes) [default: 16777216]
\n
"
);
printf
(
" -c verify correctness of file data [default: off]
\n
"
);
printf
(
" -C perform operations Collectively [default: off]
\n
"
);
printf
(
" -i iterations [default: 1]
\n
"
);
printf
(
" -f filename [default: /foo/test.out]
\n
"
);
printf
(
" -p path to pvfs2tab file to use [default: notset]
\n
"
);
printf
(
" -S all process write to same Single region of file [default: off]
\n
"
);
printf
(
" -r read-only. do no writes. file must already exist
\n
"
);
printf
(
" -w write-only. do no reads.
\n
"
);
printf
(
" -v be more verbose
\n
"
);
printf
(
" -y sYnc the file after each write [default: off]
\n
"
);
printf
(
" -h print this help
\n
"
);
}
static
void
handle_error
(
int
errcode
,
char
*
str
)
{
char
msg
[
MPI_MAX_ERROR_STRING
];
int
resultlen
;
MPI_Error_string
(
errcode
,
msg
,
&
resultlen
);
fprintf
(
stderr
,
"%s: %s
\n
"
,
str
,
msg
);
MPI_Abort
(
MPI_COMM_WORLD
,
1
);
}
/*
* Local variables:
* c-indent-level: 3
* c-basic-offset: 3
* tab-width: 3
*
* vim: ts=3
* End:
*/
darshan-test/regression/ws/setup-cc.sh
0 → 100755
View file @
34b666ac
#!/bin/bash
# General notes
#######################
# Script to set up the C compiler to use for subsequent test cases. This
# script may load optional modules (as in a Cray PE), set LD_PRELOAD
# variables (as in a dynamically linked environment), or generate mpicc
# wrappers (as in a statically linked environment).
# The script should produce a single string to stdout, which is the command
# line to use for invoking the C compiler
# Notes specific to this platform (ws)
########################
# This particular version of the setup-cc script assumes that mpicc is
# present in the path already, and that the C compiler to use for
# subsequent tests should be generated from this using darshan-gen-cc.pl.
$DARSHAN_PATH
/bin/darshan-gen-cc.pl
`
which mpicc
`
--output
$DARSHAN_TMP
/mpicc
if
[
$?
!=
0
]
;
then
echo
"Error: failed to generate c compiler."
1>&2
exit
1
fi
echo
$DARSHAN_TMP
/mpicc
exit
0
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment