Adding host support for benchmark test (a836a223) · Commits · hpc / gekkofs

ifs/test/benchmark_check.sh

+55 −42

Original line number	Diff line number	Diff line
		@@ -25,7 +25,9 @@ optional arguments:
		--mdtestonly executes only mdtest tests (default both are run)
		--ioronly executes only ior tests (default both are run)
		-v verbose output
		-n mdtest+ior: number of processes used with mpiexec (defaults to 1)
		--hostfile hostfile to give to MPI
		--host comma separated list of hosts to give to MPI
		-n mdtest+ior: number of processes used with mpiexec ${HOSTS} --map-by node (defaults to 1)
		-i mdtest+iornumber of iterations in each experiment (defaults to 3)
		-I mdtest: number of items created per process (defaults to 1000)
		-e mdtest: amount of data to read and write in bytes (defaults to 4 KiB)
		@@ -57,6 +59,7 @@ IOR_NO_RANDOM=false
		IOR_NO_STRIDE=false
		IOR_NO_FPP=false
		IOR_NO_SHARED=false
		HOSTS=""

		POSITIONAL=()
		while [[ $# -gt 0 ]]
		@@ -104,6 +107,16 @@ case ${key} in
		shift # past argument
		shift # past value
		;;
		--hostfile)
		HOSTS="--hostfile $2"
		shift # past argument
		shift # past value
		;;
		--hosts)
		HOSTS="--host $2"
		shift # past argument
		shift # past value
		;;
		--mdtestonly)
		RUN_IOR=false
		shift # past argument
		@@ -211,32 +224,32 @@ echo "Running MDTest: 6 experiments ..."
		echo "#################################################################################"
		echo "## 1. Files in single directory ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${MDTEST_PATH} -z 0 -b 1 -d ${TEST_PATH} -i ${ITER} -I ${ITEMS} -F
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${MDTEST_PATH} -z 0 -b 1 -d ${TEST_PATH} -i ${ITER} -I ${ITEMS} -F
		MDTEST_COUNT=$((MDTEST_COUNT+1))
		echo "#################################################################################"
		echo "## 2. Files in isolated process directory ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${MDTEST_PATH} -z 0 -b 1 -d ${TEST_PATH} -i ${ITER} -I ${ITEMS} -F -u
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${MDTEST_PATH} -z 0 -b 1 -d ${TEST_PATH} -i ${ITER} -I ${ITEMS} -F -u
		MDTEST_COUNT=$((MDTEST_COUNT+1))
		echo "#################################################################################"
		echo "## 3. Files and directories in single directory ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${MDTEST_PATH} -z 0 -b 1 -d ${TEST_PATH} -i ${ITER} -I ${ITEMS}
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${MDTEST_PATH} -z 0 -b 1 -d ${TEST_PATH} -i ${ITER} -I ${ITEMS}
		MDTEST_COUNT=$((MDTEST_COUNT+1))
		echo "#################################################################################"
		echo "## 4. Files and directories in isolated process directory ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${MDTEST_PATH} -z 0 -b 1 -d ${TEST_PATH} -i ${ITER} -I ${ITEMS} -u
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${MDTEST_PATH} -z 0 -b 1 -d ${TEST_PATH} -i ${ITER} -I ${ITEMS} -u
		MDTEST_COUNT=$((MDTEST_COUNT+1))
		echo "#################################################################################"
		echo "## 5. Files in single directory and write and read ${MDTEST_IO} bytes ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${MDTEST_PATH} -z 0 -b 1 -d ${TEST_PATH} -i ${ITER} -I ${ITEMS} -F -w=${MDTEST_IO} -e=${MDTEST_IO}
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${MDTEST_PATH} -z 0 -b 1 -d ${TEST_PATH} -i ${ITER} -I ${ITEMS} -F -w=${MDTEST_IO} -e=${MDTEST_IO}
		MDTEST_COUNT=$((MDTEST_COUNT+1))
		echo "#################################################################################"
		echo "## 6. Files in single directory and write and read ${MDTEST_IO} bytes ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${MDTEST_PATH} -z 0 -b 1 -d ${TEST_PATH} -i ${ITER} -I ${ITEMS} -F -w=${MDTEST_IO} -e=${MDTEST_IO} -N ${MDTEST_STRIDE}
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${MDTEST_PATH} -z 0 -b 1 -d ${TEST_PATH} -i ${ITER} -I ${ITEMS} -F -w=${MDTEST_IO} -e=${MDTEST_IO} -N ${MDTEST_STRIDE}
		MDTEST_COUNT=$((MDTEST_COUNT+1))
		echo "#################################################################################"
		echo "## MDTest finished ##"
		@@ -257,27 +270,27 @@ if [ "${IOR_NO_SEQUENTIAL}" == false ]; then
		echo "#################################################################################"
		echo "## 1. FPP: Sequential I/O transfer size == chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t ${CHUNKSIZE} -x -w -r -F
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t ${CHUNKSIZE} -x -w -r -F
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 2. FPP: Sequential I/O transfer size (4m) > chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 4m -x -w -r -F
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 4m -x -w -r -F
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 3. FPP: Sequential I/O transfer size (128k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 128k -x -w -r -F
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 128k -x -w -r -F
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 4. FPP: Sequential I/O transfer size (4k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 4k -x -w -r -F
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 4k -x -w -r -F
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 5. FPP: Sequential I/O transfer size (1k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 1k -x -w -r -F
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 1k -x -w -r -F
		IOR_COUNT=$((IOR_COUNT+1))
		fi # no sequential
		if [ "${IOR_NO_RANDOM}" == false ]; then
		@@ -285,27 +298,27 @@ if [ "${IOR_NO_RANDOM}" == false ]; then
		echo "#################################################################################"
		echo "## 6. FPP: Random I/O transfer size == chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t ${CHUNKSIZE} -x -w -r -F -z
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t ${CHUNKSIZE} -x -w -r -F -z
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 7. FPP: Random I/O transfer size (4m) > chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 4m -x -w -r -F -z
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 4m -x -w -r -F -z
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 8. FPP: Random I/O transfer size (128k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 128k -x -w -r -F -z
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 128k -x -w -r -F -z
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 9. FPP: Random I/O transfer size (4k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 4k -x -w -r -F -z
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 4k -x -w -r -F -z
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 10. FPP: Random I/O transfer size (1k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 1k -x -w -r -F -z
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 1k -x -w -r -F -z
		IOR_COUNT=$((IOR_COUNT+1))
		fi # no random
		if [ "${IOR_NO_STRIDE}" == false ]; then
		@@ -314,27 +327,27 @@ if [ "${IOR_NO_SEQUENTIAL}" == false ]; then
		echo "#################################################################################"
		echo "## 11. FPP: Sequential strided I/O transfer size == chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t ${CHUNKSIZE} -x -w -r -F -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t ${CHUNKSIZE} -x -w -r -F -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 12. FPP: Sequential strided I/O transfer size (4m) > chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 4m -x -w -r -F -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 4m -x -w -r -F -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 13. FPP: Sequential strided I/O transfer size (128k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 128k -x -w -r -F -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 128k -x -w -r -F -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 14. FPP: Sequential strided I/O transfer size (4k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 4k -x -w -r -F -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 4k -x -w -r -F -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 15. FPP: Sequential strided I/O transfer size (1k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 1k -x -w -r -F -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 1k -x -w -r -F -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		fi # no sequential
		if [ "${IOR_NO_RANDOM}" == false ]; then
		@@ -342,27 +355,27 @@ if [ "${IOR_NO_RANDOM}" == false ]; then
		echo "#################################################################################"
		echo "## 16. FPP: Random strided I/O transfer size == chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t ${CHUNKSIZE} -x -w -r -F -z -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t ${CHUNKSIZE} -x -w -r -F -z -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 17. FPP: Random strided I/O transfer size (4m) > chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 4m -x -w -r -F -z -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 4m -x -w -r -F -z -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 18. FPP: Random strided I/O transfer size (128k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 128k -x -w -r -F -z -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 128k -x -w -r -F -z -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 19. FPP: Random strided I/O transfer size (4k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 4k -x -w -r -F -z -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 4k -x -w -r -F -z -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 20. FPP: Random strided I/O transfer size (1k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 1k -x -w -r -F -z -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 1k -x -w -r -F -z -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		fi # no random
		fi # no stride
		@@ -377,27 +390,27 @@ if [ "${IOR_NO_SEQUENTIAL}" == false ]; then
		echo "#################################################################################"
		echo "## 21. Shared File: Sequential I/O transfer size == chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t ${CHUNKSIZE} -x -w -r
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t ${CHUNKSIZE} -x -w -r
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 22. Shared File: Sequential I/O transfer size (4m) > chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 4m -x -w -r
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 4m -x -w -r
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 23. Shared File: Sequential I/O transfer size (128k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 128k -x -w -r
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 128k -x -w -r
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 24. Shared File: Sequential I/O transfer size (4k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 4k -x -w -r
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 4k -x -w -r
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 25. Shared File: Sequential I/O transfer size (1k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 1k -x -w -r
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 1k -x -w -r
		IOR_COUNT=$((IOR_COUNT+1))
		fi # no sequential
		if [ "${IOR_NO_RANDOM}" == false ]; then
		@@ -405,27 +418,27 @@ if [ "${IOR_NO_RANDOM}" == false ]; then
		echo "#################################################################################"
		echo "## 26. Shared File: Random I/O transfer size == chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t ${CHUNKSIZE} -x -w -r -z
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t ${CHUNKSIZE} -x -w -r -z
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 27. Shared File: Random I/O transfer size (4m) > chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 4m -x -w -r -z
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 4m -x -w -r -z
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 28. Shared File: Random I/O transfer size (128k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 128k -x -w -r -z
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 128k -x -w -r -z
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 29. Shared File: Random I/O transfer size (4k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 4k -x -w -r -z
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 4k -x -w -r -z
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 30. Shared File: Random I/O transfer size (1k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 1k -x -w -r -z
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 1k -x -w -r -z
		IOR_COUNT=$((IOR_COUNT+1))
		fi # no random
		if [ "${IOR_NO_STRIDE}" == false ]; then
		@@ -434,27 +447,27 @@ if [ "${IOR_NO_SEQUENTIAL}" == false ]; then
		echo "#################################################################################"
		echo "## 31. Shared File: Sequential strided I/O transfer size == chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t ${CHUNKSIZE} -x -w -r -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t ${CHUNKSIZE} -x -w -r -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 32. Shared File: Sequential strided I/O transfer size (4m) > chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 4m -x -w -r -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 4m -x -w -r -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 33. Shared File: Sequential strided I/O transfer size (128k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 128k -x -w -r -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b ${IO_SIZE} -t 128k -x -w -r -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 34. Shared File: Sequential strided I/O transfer size (4k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 4k -x -w -r -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 4k -x -w -r -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		echo "#################################################################################"
		echo "## 35. Shared File: Sequential strided I/O transfer size (1k) < chunksize ##"
		echo "#################################################################################"
		mpiexec -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 1k -x -w -r -Z -X 42
		mpiexec ${HOSTS} --map-by node -n ${PROC} -x LD_PRELOAD=${PRELOAD} ${IOR_PATH} -a POSIX -i ${ITER} -o ${TEST_PATH}/iortest -b 4m -t 1k -x -w -r -Z -X 42
		IOR_COUNT=$((IOR_COUNT+1))
		# shared file Random strided doesnt exist in ior
		fi # no sequential