[fio.git] / tools / genfio

#!/bin/bash
#
#  Copyright (C) 2013 eNovance SAS <licensing@enovance.com>
#  Author: Erwan Velu  <erwan@enovance.com>
#
#  The license below covers all files distributed with fio unless otherwise
#  noted in the file itself.
#
#  This program is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License version 2 as
#  published by the Free Software Foundation.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

BLK_SIZE=
BLOCK_SIZE=4k
SEQ=-1
TEMPLATE=$(mktemp "${TMPDIR:-${TEMP:-/tmp}}/template.fio.XXXXXX") || exit $?
trap 'rm -f "$TEMPLATE"' EXIT
OUTFILE=
DISKS=
PRINTABLE_DISKS=
RUNTIME=300
ETA=0
MODES="write,randwrite,read,randread"
SHORT_HOSTNAME=
CACHED_IO="FALSE"
PREFIX=""
PREFIX_FILENAME=""
IODEPTH=1

show_help() {
	PROG=$(basename $0)
	echo "usage of $PROG:"
	cat << EOF
-h				: Show this help & exit
-c				: Enable cached-based IOs
					Disabled by default
-a				: Run sequential test then parallel one
					Disabled by default
-s				: Run sequential test (default value)
					one test after another then one disk after another
					Disabled by default
-p				: Run parallel test
					one test after another but all disks at the same time
					Enabled by default
-D iodepth			: Run with the specified iodepth
					Default is $IODEPTH
-d disk1[,disk2,disk3,..]	: Run the tests on the selected disks
					Separated each disk with a comma
-z filesize                     : Specify the working file size, if you are passing filepaths to -d
                                        Disabled by default
-r seconds			: Time in seconds per benchmark
					0 means till the end of the device
					Default is $RUNTIME seconds
-b blocksize[,blocksize1, ...]  : The blocksizes to test under fio format (4k, 1m, ...)
					Separated each blocksize with a comma
					Default is $BLOCK_SIZE
-m mode1,[mode2,mode3, ...]     : Define the fio IO profile to use like read, write, randread, randwrite
					Default is "$MODES"
-x prefix			: Add a prefix to the fio filename
					Useful to let a context associated with the file
					If the prefix features a / (slash), prefix will be considered as a directory
-A cmd_to_run			: System command to run after each job (exec_postrun in fio)
-B cmd_to_run			: System command to run before each job (exec_prerun in fio)

Example:

$PROG -d /dev/sdb,/dev/sdc,/dev/sdd,/dev/sde -a -b 4k,128k,1m -r 100 -a -x dellr720-day2/

	Will generate an fio file that will run
		- a sequential bench on /dev/sdb /dev/sdc /dev/sdd /dev/sde for block size = 4k with write,randwrite,read,randread tests
			ETA ~ 4 tests * 4 disks * 100 seconds
		- a sequential bench on /dev/sdb /dev/sdc /dev/sdd /dev/sde for block size = 128k with write,randwrite,read,randread tests
			ETA ~ 4 tests * 4 disks * 100 seconds
		- a sequential bench on /dev/sdb /dev/sdc /dev/sdd /dev/sde for block size = 1m with write,randwrite,read,randread tests
			ETA ~ 4 tests * 4 disks * 100 seconds
		- a parallel bench on /dev/sdb /dev/sdc /dev/sdd /dev/sde for block size = 4k with write,randwrite,read,randread tests
			ETA ~ 4 tests * 100 seconds
		- a parallel bench on /dev/sdb /dev/sdc /dev/sdd /dev/sde for block size = 128k with write,randwrite,read,randread tests
			ETA ~ 4 tests * 100 seconds
		- a parallel bench on /dev/sdb /dev/sdc /dev/sdd /dev/sde for block size = 1m with write,randwrite,read,randread tests
			ETA ~ 4 tests * 100 seconds

Generating dellr720-day2/localhost-4k,128k,1m-all-write,randwrite,read,randread-sdb,sdc,sdd,sde.fio
Estimated Time = 6000 seconds : 1 hour 40 minutes
EOF
}

finish_template() {
echo "iodepth=$IODEPTH" >> $TEMPLATE

if [ "$RUNTIME" != "0" ]; then
	echo "runtime=$RUNTIME" >> $TEMPLATE
	echo "time_based" >> $TEMPLATE
fi

if [ "$CACHED_IO" = "FALSE" ]; then
	echo "direct=1" >> $TEMPLATE
fi
}


diskname_to_printable() {
COUNT=0
for disk in $(echo $@ | tr "," " "); do
	R=$(basename $disk | sed 's|/|_|g')
	COUNT=$(($COUNT + 1))
	if [ $COUNT -eq 1 ]; then
		P="$R"
	else
		P="$P,$R"
	fi
done
echo $P
}

gen_template() {
cat >$TEMPLATE << EOF
[global]
ioengine=libaio
invalidate=1
ramp_time=5
EOF
}

gen_seq_suite() {
TYPE=$1
disk=$2
PRINTABLE_DISK=$(diskname_to_printable $disk)
cat >> $OUTFILE << EOF
[$TYPE-$PRINTABLE_DISK-$BLK_SIZE-seq]
stonewall
bs=$BLK_SIZE
filename=$disk
rw=$TYPE
write_bw_log=${PREFIX_FILENAME}$SHORT_HOSTNAME-$BLK_SIZE-$PRINTABLE_DISK-$TYPE-seq.results
write_iops_log=${PREFIX_FILENAME}$SHORT_HOSTNAME-$BLK_SIZE-$PRINTABLE_DISK-$TYPE-seq.results
EOF
ETA=$(($ETA + $RUNTIME))
}

gen_seq_fio() {
for disk in $(echo $DISKS | tr "," " "); do
	for mode in $(echo $MODES | tr "," " "); do
		gen_seq_suite "$mode" "$disk"
	done
done
}


gen_para_suite() {
TYPE=$1
NEED_WALL=$2
D=0
for disk in $(echo $DISKS | tr "," " "); do
    PRINTABLE_DISK=$(diskname_to_printable $disk)
    cat >> $OUTFILE << EOF
[$TYPE-$PRINTABLE_DISK-$BLK_SIZE-para]
bs=$BLK_SIZE
EOF

if [ "$D" = 0 ]; then
    echo "stonewall" >> $OUTFILE
    D=1
fi

cat >> $OUTFILE << EOF
filename=$disk
rw=$TYPE
write_bw_log=${PREFIX_FILENAME}$SHORT_HOSTNAME-$BLK_SIZE-$PRINTABLE_DISK-$TYPE-para.results
write_iops_log=${PREFIX_FILENAME}$SHORT_HOSTNAME-$BLK_SIZE-$PRINTABLE_DISK-$TYPE-para.results
EOF
done

ETA=$(($ETA + $RUNTIME))
echo >> $OUTFILE
}

gen_para_fio() {
for mode in $(echo $MODES | tr "," " "); do
	gen_para_suite "$mode"
done
}

gen_fio() {
case $SEQ in
	2)
		gen_seq_fio
		gen_para_fio
	;;
	1)
		gen_seq_fio
	;;
	0)
		gen_para_fio
	;;
esac
}

parse_cmdline() {
while getopts "hacpsd:b:r:m:x:z:D:A:B:" opt; do
  case $opt in
    h)
	show_help
	exit 0
	;;
    b)
	BLOCK_SIZE=$OPTARG
	;;
    c)
	CACHED_IO="TRUE"
	;;
    s)
	if [ "$SEQ" = "-1" ]; then
		SEQ=1
	fi
      ;;
    x)
	PREFIX=$OPTARG
	echo "$PREFIX" | grep -q "/"
	if [ "$?" -eq 0 ]; then
		mkdir -p $PREFIX
		# No need to keep the prefix for the log files
		# we do have a directory for that
		PREFIX_FILENAME=""
	else
		# We need to keep the prefix for the log files
		PREFIX_FILENAME=$PREFIX
	fi
	;;
    r)
	RUNTIME=$OPTARG
      ;;
    p)
	if [ "$SEQ" = "-1" ]; then
		SEQ=0
	fi
      ;;
    m)
        MODES=$OPTARG;
      ;;
    d)
 	DISKS=$OPTARG
	PRINTABLE_DISKS=$(diskname_to_printable "$DISKS")
      ;;
    D)
	IODEPTH=$OPTARG
      ;;
    a)
	SEQ=2
      ;;
    B)
	echo "exec_prerun=$OPTARG" >> $TEMPLATE
      ;;
    A)
	echo "exec_postrun=$OPTARG" >> $TEMPLATE
      ;;
    z)
	FSIZE=$OPTARG
	echo "size=$FSIZE" >> $TEMPLATE
      ;;
    \?)
      echo "Invalid option: -$OPTARG" >&2
      ;;
  esac
done

if [ "$SEQ" = "-1" ]; then
	SEQ=0
fi

SHORT_HOSTNAME=$(hostname -s)
case $SEQ in
	2)
		OUTFILE=${PREFIX}$SHORT_HOSTNAME-$BLOCK_SIZE-all-$MODES-$PRINTABLE_DISKS.fio
	;;

	1)
		OUTFILE=${PREFIX}$SHORT_HOSTNAME-$BLOCK_SIZE-sequential-$MODES-$PRINTABLE_DISKS.fio
	;;
	0)
		OUTFILE=${PREFIX}$SHORT_HOSTNAME-$BLOCK_SIZE-parallel-$MODES-$PRINTABLE_DISKS.fio
	;;
esac

if [ -z "$DISKS" ]; then
	echo "Missing DISKS !"
	echo "Please read the help !"
	show_help
	exit 1
fi

}

check_mode_order() {
FOUND_WRITE="NO"
CAUSE="You are reading data before writing them          "

# If no write occurs, let's show a different message
echo $MODES | grep -q "write"
if [ "$?" -ne 0 ]; then
	CAUSE="You are reading data while never wrote them before"
fi

for mode in $(echo $MODES | tr "," " "); do
	echo $mode | grep -q write
	if [ "$?" -eq 0 ]; then
		FOUND_WRITE="YES"
	fi
	echo $mode | grep -q "read"
	if [ "$?" -eq 0 ]; then
		if [ "$FOUND_WRITE" = "NO" ]; then
			echo "###############################################################"
			echo "# Warning : $CAUSE#"
			echo "# On some storage devices, this could lead to invalid results #"
			echo "#                                                             #"
			echo "# Press Ctrl-C to adjust pattern order if you have doubts     #"
			echo "# Or Wait 5 seconds before the file will be created           #"
			echo "###############################################################"
			sleep 5
			# No need to try showing the message more than one time
			return
		fi
	fi
done
}


########## MAIN
gen_template
parse_cmdline "$@"
finish_template
check_mode_order

echo "Generating $OUTFILE"
cp -f $TEMPLATE $OUTFILE
echo >> $OUTFILE

for BLK_SIZE in $(echo $BLOCK_SIZE | tr "," " "); do
	gen_fio
done
ETA_H=$(($ETA / 3600))
ETA_M=$((($ETA - ($ETA_H*3600)) / 60))
if [ "$ETA" = "0" ]; then
	echo "Cannot estimate ETA as RUNTIME=0"
else
	echo "Estimated Time = $ETA seconds : $ETA_H hour $ETA_M minutes"
fi
Commit	Line	Data
	1	#!/bin/bash
	2	#
	3	# Copyright (C) 2013 eNovance SAS <licensing@enovance.com>
	4	# Author: Erwan Velu <erwan@enovance.com>
	5	#
	6	# The license below covers all files distributed with fio unless otherwise
	7	# noted in the file itself.
	8	#
	9	# This program is free software; you can redistribute it and/or modify
	10	# it under the terms of the GNU General Public License version 2 as
	11	# published by the Free Software Foundation.
	12	#
	13	# This program is distributed in the hope that it will be useful,
	14	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	# GNU General Public License for more details.
	17	#
	18	# You should have received a copy of the GNU General Public License
	19	# along with this program; if not, write to the Free Software
	20	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	21
	22	BLK_SIZE=
	23	BLOCK_SIZE=4k
	24	SEQ=-1
	25	TEMPLATE=$(mktemp "${TMPDIR:-${TEMP:-/tmp}}/template.fio.XXXXXX") \|\| exit $?
	26	trap 'rm -f "$TEMPLATE"' EXIT
	27	OUTFILE=
	28	DISKS=
	29	PRINTABLE_DISKS=
	30	RUNTIME=300
	31	ETA=0
	32	MODES="write,randwrite,read,randread"
	33	SHORT_HOSTNAME=
	34	CACHED_IO="FALSE"
	35	PREFIX=""
	36	PREFIX_FILENAME=""
	37	IODEPTH=1
	38
	39	show_help() {
	40	PROG=$(basename $0)
	41	echo "usage of $PROG:"
	42	cat << EOF
	43	-h : Show this help & exit
	44	-c : Enable cached-based IOs
	45	Disabled by default
	46	-a : Run sequential test then parallel one
	47	Disabled by default
	48	-s : Run sequential test (default value)
	49	one test after another then one disk after another
	50	Disabled by default
	51	-p : Run parallel test
	52	one test after another but all disks at the same time
	53	Enabled by default
	54	-D iodepth : Run with the specified iodepth
	55	Default is $IODEPTH
	56	-d disk1[,disk2,disk3,..] : Run the tests on the selected disks
	57	Separated each disk with a comma
	58	-z filesize : Specify the working file size, if you are passing filepaths to -d
	59	Disabled by default
	60	-r seconds : Time in seconds per benchmark
	61	0 means till the end of the device
	62	Default is $RUNTIME seconds
	63	-b blocksize[,blocksize1, ...] : The blocksizes to test under fio format (4k, 1m, ...)
	64	Separated each blocksize with a comma
	65	Default is $BLOCK_SIZE
	66	-m mode1,[mode2,mode3, ...] : Define the fio IO profile to use like read, write, randread, randwrite
	67	Default is "$MODES"
	68	-x prefix : Add a prefix to the fio filename
	69	Useful to let a context associated with the file
	70	If the prefix features a / (slash), prefix will be considered as a directory
	71	-A cmd_to_run : System command to run after each job (exec_postrun in fio)
	72	-B cmd_to_run : System command to run before each job (exec_prerun in fio)
	73
	74	Example:
	75
	76	$PROG -d /dev/sdb,/dev/sdc,/dev/sdd,/dev/sde -a -b 4k,128k,1m -r 100 -a -x dellr720-day2/
	77
	78	Will generate an fio file that will run
	79	- a sequential bench on /dev/sdb /dev/sdc /dev/sdd /dev/sde for block size = 4k with write,randwrite,read,randread tests
	80	ETA ~ 4 tests * 4 disks * 100 seconds
	81	- a sequential bench on /dev/sdb /dev/sdc /dev/sdd /dev/sde for block size = 128k with write,randwrite,read,randread tests
	82	ETA ~ 4 tests * 4 disks * 100 seconds
	83	- a sequential bench on /dev/sdb /dev/sdc /dev/sdd /dev/sde for block size = 1m with write,randwrite,read,randread tests
	84	ETA ~ 4 tests * 4 disks * 100 seconds
	85	- a parallel bench on /dev/sdb /dev/sdc /dev/sdd /dev/sde for block size = 4k with write,randwrite,read,randread tests
	86	ETA ~ 4 tests * 100 seconds
	87	- a parallel bench on /dev/sdb /dev/sdc /dev/sdd /dev/sde for block size = 128k with write,randwrite,read,randread tests
	88	ETA ~ 4 tests * 100 seconds
	89	- a parallel bench on /dev/sdb /dev/sdc /dev/sdd /dev/sde for block size = 1m with write,randwrite,read,randread tests
	90	ETA ~ 4 tests * 100 seconds
	91
	92	Generating dellr720-day2/localhost-4k,128k,1m-all-write,randwrite,read,randread-sdb,sdc,sdd,sde.fio
	93	Estimated Time = 6000 seconds : 1 hour 40 minutes
	94	EOF
	95	}
	96
	97	finish_template() {
	98	echo "iodepth=$IODEPTH" >> $TEMPLATE
	99
	100	if [ "$RUNTIME" != "0" ]; then
	101	echo "runtime=$RUNTIME" >> $TEMPLATE
	102	echo "time_based" >> $TEMPLATE
	103	fi
	104
	105	if [ "$CACHED_IO" = "FALSE" ]; then
	106	echo "direct=1" >> $TEMPLATE
	107	fi
	108	}
	109
	110
	111	diskname_to_printable() {
	112	COUNT=0
	113	for disk in $(echo $@ \| tr "," " "); do
	114	R=$(basename $disk \| sed 's\|/\|_\|g')
	115	COUNT=$(($COUNT + 1))
	116	if [ $COUNT -eq 1 ]; then
	117	P="$R"
	118	else
	119	P="$P,$R"
	120	fi
	121	done
	122	echo $P
	123	}
	124
	125	gen_template() {
	126	cat >$TEMPLATE << EOF
	127	[global]
	128	ioengine=libaio
	129	invalidate=1
	130	ramp_time=5
	131	EOF
	132	}
	133
	134	gen_seq_suite() {
	135	TYPE=$1
	136	disk=$2
	137	PRINTABLE_DISK=$(diskname_to_printable $disk)
	138	cat >> $OUTFILE << EOF
	139	[$TYPE-$PRINTABLE_DISK-$BLK_SIZE-seq]
	140	stonewall
	141	bs=$BLK_SIZE
	142	filename=$disk
	143	rw=$TYPE
	144	write_bw_log=${PREFIX_FILENAME}$SHORT_HOSTNAME-$BLK_SIZE-$PRINTABLE_DISK-$TYPE-seq.results
	145	write_iops_log=${PREFIX_FILENAME}$SHORT_HOSTNAME-$BLK_SIZE-$PRINTABLE_DISK-$TYPE-seq.results
	146	EOF
	147	ETA=$(($ETA + $RUNTIME))
	148	}
	149
	150	gen_seq_fio() {
	151	for disk in $(echo $DISKS \| tr "," " "); do
	152	for mode in $(echo $MODES \| tr "," " "); do
	153	gen_seq_suite "$mode" "$disk"
	154	done
	155	done
	156	}
	157
	158
	159	gen_para_suite() {
	160	TYPE=$1
	161	NEED_WALL=$2
	162	D=0
	163	for disk in $(echo $DISKS \| tr "," " "); do
	164	PRINTABLE_DISK=$(diskname_to_printable $disk)
	165	cat >> $OUTFILE << EOF
	166	[$TYPE-$PRINTABLE_DISK-$BLK_SIZE-para]
	167	bs=$BLK_SIZE
	168	EOF
	169
	170	if [ "$D" = 0 ]; then
	171	echo "stonewall" >> $OUTFILE
	172	D=1
	173	fi
	174
	175	cat >> $OUTFILE << EOF
	176	filename=$disk
	177	rw=$TYPE
	178	write_bw_log=${PREFIX_FILENAME}$SHORT_HOSTNAME-$BLK_SIZE-$PRINTABLE_DISK-$TYPE-para.results
	179	write_iops_log=${PREFIX_FILENAME}$SHORT_HOSTNAME-$BLK_SIZE-$PRINTABLE_DISK-$TYPE-para.results
	180	EOF
	181	done
	182
	183	ETA=$(($ETA + $RUNTIME))
	184	echo >> $OUTFILE
	185	}
	186
	187	gen_para_fio() {
	188	for mode in $(echo $MODES \| tr "," " "); do
	189	gen_para_suite "$mode"
	190	done
	191	}
	192
	193	gen_fio() {
	194	case $SEQ in
	195	2)
	196	gen_seq_fio
	197	gen_para_fio
	198	;;
	199	1)
	200	gen_seq_fio
	201	;;
	202	0)
	203	gen_para_fio
	204	;;
	205	esac
	206	}
	207
	208	parse_cmdline() {
	209	while getopts "hacpsd:b:r:m:x:z:D:A:B:" opt; do
	210	case $opt in
	211	h)
	212	show_help
	213	exit 0
	214	;;
	215	b)
	216	BLOCK_SIZE=$OPTARG
	217	;;
	218	c)
	219	CACHED_IO="TRUE"
	220	;;
	221	s)
	222	if [ "$SEQ" = "-1" ]; then
	223	SEQ=1
	224	fi
	225	;;
	226	x)
	227	PREFIX=$OPTARG
	228	echo "$PREFIX" \| grep -q "/"
	229	if [ "$?" -eq 0 ]; then
	230	mkdir -p $PREFIX
	231	# No need to keep the prefix for the log files
	232	# we do have a directory for that
	233	PREFIX_FILENAME=""
	234	else
	235	# We need to keep the prefix for the log files
	236	PREFIX_FILENAME=$PREFIX
	237	fi
	238	;;
	239	r)
	240	RUNTIME=$OPTARG
	241	;;
	242	p)
	243	if [ "$SEQ" = "-1" ]; then
	244	SEQ=0
	245	fi
	246	;;
	247	m)
	248	MODES=$OPTARG;
	249	;;
	250	d)
	251	DISKS=$OPTARG
	252	PRINTABLE_DISKS=$(diskname_to_printable "$DISKS")
	253	;;
	254	D)
	255	IODEPTH=$OPTARG
	256	;;
	257	a)
	258	SEQ=2
	259	;;
	260	B)
	261	echo "exec_prerun=$OPTARG" >> $TEMPLATE
	262	;;
	263	A)
	264	echo "exec_postrun=$OPTARG" >> $TEMPLATE
	265	;;
	266	z)
	267	FSIZE=$OPTARG
	268	echo "size=$FSIZE" >> $TEMPLATE
	269	;;
	270	\?)
	271	echo "Invalid option: -$OPTARG" >&2
	272	;;
	273	esac
	274	done
	275
	276	if [ "$SEQ" = "-1" ]; then
	277	SEQ=0
	278	fi
	279
	280	SHORT_HOSTNAME=$(hostname -s)
	281	case $SEQ in
	282	2)
	283	OUTFILE=${PREFIX}$SHORT_HOSTNAME-$BLOCK_SIZE-all-$MODES-$PRINTABLE_DISKS.fio
	284	;;
	285
	286	1)
	287	OUTFILE=${PREFIX}$SHORT_HOSTNAME-$BLOCK_SIZE-sequential-$MODES-$PRINTABLE_DISKS.fio
	288	;;
	289	0)
	290	OUTFILE=${PREFIX}$SHORT_HOSTNAME-$BLOCK_SIZE-parallel-$MODES-$PRINTABLE_DISKS.fio
	291	;;
	292	esac
	293
	294	if [ -z "$DISKS" ]; then
	295	echo "Missing DISKS !"
	296	echo "Please read the help !"
	297	show_help
	298	exit 1
	299	fi
	300
	301	}
	302
	303	check_mode_order() {
	304	FOUND_WRITE="NO"
	305	CAUSE="You are reading data before writing them "
	306
	307	# If no write occurs, let's show a different message
	308	echo $MODES \| grep -q "write"
	309	if [ "$?" -ne 0 ]; then
	310	CAUSE="You are reading data while never wrote them before"
	311	fi
	312
	313	for mode in $(echo $MODES \| tr "," " "); do
	314	echo $mode \| grep -q write
	315	if [ "$?" -eq 0 ]; then
	316	FOUND_WRITE="YES"
	317	fi
	318	echo $mode \| grep -q "read"
	319	if [ "$?" -eq 0 ]; then
	320	if [ "$FOUND_WRITE" = "NO" ]; then
	321	echo "###############################################################"
	322	echo "# Warning : $CAUSE#"
	323	echo "# On some storage devices, this could lead to invalid results #"
	324	echo "# #"
	325	echo "# Press Ctrl-C to adjust pattern order if you have doubts #"
	326	echo "# Or Wait 5 seconds before the file will be created #"
	327	echo "###############################################################"
	328	sleep 5
	329	# No need to try showing the message more than one time
	330	return
	331	fi
	332	fi
	333	done
	334	}
	335
	336
	337	########## MAIN
	338	gen_template
	339	parse_cmdline "$@"
	340	finish_template
	341	check_mode_order
	342
	343	echo "Generating $OUTFILE"
	344	cp -f $TEMPLATE $OUTFILE
	345	echo >> $OUTFILE
	346
	347	for BLK_SIZE in $(echo $BLOCK_SIZE \| tr "," " "); do
	348	gen_fio
	349	done
	350	ETA_H=$(($ETA / 3600))
	351	ETA_M=$((($ETA - ($ETA_H*3600)) / 60))
	352	if [ "$ETA" = "0" ]; then
	353	echo "Cannot estimate ETA as RUNTIME=0"
	354	else
	355	echo "Estimated Time = $ETA seconds : $ETA_H hour $ETA_M minutes"
	356	fi