ect1.batch

##
#
# SCE-L4S ECT(1) Tests
#
# Evidence in support of using ECT(1) as an output signal for high fidelity
# congestion control
#
# Pete Heist
# Jonathan Morton
#
# Scenarios:
# s1-oneflow: Single flow test
# s2-twoflow: Two flow competition
# s3-bottleneck-shift: Shift bottleneck to RFC-3168 and back
# s4-capacity-reduction: Capacity reduction, 50-40Mbit and 50-5Mbit
# s5-burstiness: WiFi burstiness simulated with netem slotting
# s6-jitter: Typical Internet path jitter simulated with netem
#

#
# Global settings
#
[Batch::global]
abstract = yes
output_path = ${batch_title}/${batch_name}
output_data_file = ${output_path}/${data_filename}
socket_stats = yes
length = 60
step_size = 0.05
commands = clear, setup, teardown, process
repetitions = 1
pause = 5
extended_metadata = yes
debug_error = no
debug_log = no
ip_version = 4
for_net = net_ns
# standard endpoint hooks, with tcp_metrics, tcpdump and scetrace
endpoint_hooks = \
	cli \
		\"tcp_metrics\; \
		run_tcpdump right\; \
		run_scetrace ${output_path}\; \
		compress ${output_path}\" \
	srv \
		\"tcp_metrics\; \
		run_tcpdump left\"
# endpoint hooks without pcaps
#endpoint_hooks = \
#	cli \
#		\"tcp_metrics\" \
#	srv \
#		\"tcp_metrics\"
# standard middlebox setup hooks for root qdiscs
midbox_hooks_root = \
	mid \
		\"qdisc bidir root ${qdisc_args}\; \
		qdisc bidir ingress root ${netem_args}\"
# standard middlebox setup hooks for htb child qdiscs
midbox_hooks_htb = \
	mid \
		\"qdisc bidir htb ${bandwidth} ${qdisc_args}\; \
		qdisc bidir ingress root ${netem_args}\"
# setup hooks (inheriting batches must define midbox_hooks)
setup_hooks = ${endpoint_hooks} ${midbox_hooks}


#
# SCE settings
#
[Batch::sce]
abstract = yes
arch = sce
hosts_phys = ts1
# default midbox_hooks for SCE use root qdiscs
midbox_hooks = ${midbox_hooks_root}


#
# L4S settings
#
[Batch::l4s]
abstract = yes
arch = l4s
hosts_phys = ts2
# default midbox_hooks for L4S use child qdiscs of htb
midbox_hooks = ${midbox_hooks_htb}

#
# Common settings
#

# net args (unused as we use only ns in this batch)
[Arg::net_phys]
net = phys
hosts = ${hosts_phys}

[Arg::net_ns]
net = ns
# hosts must match NS_SRV_IP in fl_global.sh
hosts = 10.9.9.2

# Commands
[Command::clear]
exec = ./fl flent_clear ${arch} ${net}
type = pre
essential = yes

[Command::setup]
exec = ./fl flent_setup ${arch} ${net} "${output_data_file}" ${setup_hooks}
type = pre
essential = yes

[Command::teardown]
exec = ./fl flent_teardown ${arch} ${net} "${output_data_file}" ${setup_hooks}
type = post

[Command::process]
exec = ./fl flent_process ${arch} ${net} "${output_data_file}" ${setup_hooks}
type = post


#############################################################################
#
# Scenario 1- Single Flow
#
[Batch::s1-oneflow]
abstract = yes
test_name = tcp_1up
for_bandwidth = s1_bw_5Mbit, s1_bw_50Mbit, s1_bw_250Mbit
for_rtts = s1_lowrtt, s1_medrtt, s1_highrtt
title = net:${net} cc:${cc} qdisc:${qdisc} bandwidth:${bandwidth} rtt:${rtt}
filename_extra = ${net}-${cc}-${qdisc}-${bandwidth}-${rtt}
test_parameters = cc_algo=${cc};

# S1 SCE
[Batch::sce-s1-oneflow]
inherits = global, sce, s1-oneflow
cc = cubic-sce
marking = 0x10
qdisc = twin_codel_af
qdisc_args = twin_codel_af bandwidth ${bandwidth} sce-thresh 4

# S1 L4S
[Batch::l4s-s1-oneflow]
inherits = global, l4s, s1-oneflow
cc = prague
marking = 0
qdisc = dualpi2
qdisc_args = dualpi2

# S1 common
[Arg::s1_bw_1Mbit]
bandwidth = 1Mbit

[Arg::s1_bw_5Mbit]
bandwidth = 5Mbit

[Arg::s1_bw_10Mbit]
bandwidth = 10Mbit

[Arg::s1_bw_25Mbit]
bandwidth = 25Mbit

[Arg::s1_bw_40Mbit]
bandwidth = 40Mbit

[Arg::s1_bw_50Mbit]
bandwidth = 50Mbit

[Arg::s1_bw_250Mbit]
bandwidth = 250Mbit

[Arg::s1_lowrtt]
rtt = 20ms
length = 30
netem_args = netem delay 10ms limit 1000000
test_parameters = cc_algo=${cc}; \
	marking=${marking}

[Arg::s1_medrtt]
rtt = 80ms
length = 60
netem_args = netem delay 40ms limit 1000000

[Arg::s1_highrtt]
rtt = 160ms
length = 150
netem_args = netem delay 80ms limit 1000000


#############################################################################
#
# Scenario 2- Two Flows
#
[Batch::s2-twoflow]
abstract = yes
inherits = global
test_name = tcp_2up
for_rtts = s2_lowrtt, s2_medrtt, s2_highrtt
filename_extra = ${net}-${vs}-${qdisc}-${rtt}
bandwidth = 50Mbit
title = net:${net} vs:${vs} qdisc:${qdisc} bandwidth:${bandwidth} rtt:${rtt}
markings = 0,0

# S2 SCE
[Batch::sce-s2-twoflow]
inherits = global, sce, s2-twoflow
for_vs = s2_cubic-vs-cubic-sce
#for_qdisc = s2_twin_codel_af, s2_lfq_cobalt, s2_pfifo_1000, \
#	s2_pfifo_50, s2_codel1q, s2_codel1q_40ms, s2_codel1q_20ms,
#	s2_red_150000, s2_red_400000, s2_pie, s2_pie_noecn, s2_pie_100p_5ms, \
#	s2_pie_100p_20ms, s2_pie_1000p_20ms
for_qdisc = s2_codel1q_20ms

[Arg::s2_cubic-vs-cubic-sce]
vs = cubic-vs-cubic-sce
cc_algos = cubic,cubic-sce
markings = 0,0x10

[Arg::s2_twin_codel_af]
qdisc = twin_codel_af
qdisc_args = twin_codel_af bandwidth ${bandwidth} sce-thresh 4

[Arg::s2_lfq_cobalt]
qdisc = lfq_cobalt
qdisc_args = lfq_cobalt bandwidth ${bandwidth} sce-thresh 8

# S2 L4S
[Batch::l4s-s2-twoflow]
inherits = global, l4s, s2-twoflow
for_vs = s2_cubic-vs-prague
#for_qdisc = s2_dualpi2, s2_pfifo_1000, s2_pfifo_50, \
#	s2_codel1q, s2_codel1q_40ms, s2_codel1q_20ms, s2_red_150000, \
#	s2_red_400000, s2_pie, s2_pie_noecn, s2_pie_100p_5ms, s2_pie_100p_20ms, \
#	s2_pie_1000p_20ms
for_qdisc = s2_codel1q_20ms

[Arg::s2_cubic-vs-prague]
vs = cubic-vs-prague
cc_algos = cubic,prague

[Arg::s2_dualpi2]
qdisc = dualpi2
qdisc_args = dualpi2

# S2 common
[Arg::s2_pfifo_1000]
qdisc = pfifo(1000)
qdisc_args = pfifo limit 1000
midbox_hooks = ${midbox_hooks_htb}

[Arg::s2_pfifo_50]
qdisc = pfifo(50)
qdisc_args = pfifo limit 50
midbox_hooks = ${midbox_hooks_htb}

[Arg::s2_codel1q]
qdisc = codel1q
qdisc_args = fq_codel flows 1 ecn
midbox_hooks = ${midbox_hooks_htb}

[Arg::s2_codel1q_40ms]
qdisc = codel1q(40ms)
qdisc_args = fq_codel flows 1 target 3ms interval 40ms ecn
midbox_hooks = ${midbox_hooks_htb}

[Arg::s2_codel1q_20ms]
qdisc = codel1q(20ms)
qdisc_args = fq_codel flows 1 target 1ms interval 20ms ecn
midbox_hooks = ${midbox_hooks_htb}

[Arg::s2_red_400000]
qdisc = red(400000)
qdisc_args = red limit 400000 avpkt 1000 adaptive bandwidth ${bandwidth} ecn
midbox_hooks = ${midbox_hooks_htb}

[Arg::s2_red_150000]
qdisc = red(150000)
qdisc_args = red limit 150000 avpkt 1000 adaptive bandwidth ${bandwidth} ecn
midbox_hooks = ${midbox_hooks_htb}
length = 180

[Arg::s2_pie]
qdisc = pie
qdisc_args = pie ecn
midbox_hooks = ${midbox_hooks_htb}

[Arg::s2_pie_noecn]
qdisc = pie(noecn)
qdisc_args = pie noecn
midbox_hooks = ${midbox_hooks_htb}

[Arg::s2_pie_100p_5ms]
qdisc = pie(100p/5ms)
qdisc_args = pie limit 100 target 5ms tupdate 32ms alpha 2 beta 20 ecn
midbox_hooks = ${midbox_hooks_htb}

[Arg::s2_pie_100p_20ms]
qdisc = pie(100p/20ms)
qdisc_args = pie limit 100 target 20ms tupdate 32ms alpha 2 beta 20 ecn
midbox_hooks = ${midbox_hooks_htb}

[Arg::s2_pie_1000p_20ms]
qdisc = pie(1000p/20ms)
qdisc_args = pie limit 1000 target 20ms tupdate 32ms alpha 2 beta 20 ecn
midbox_hooks = ${midbox_hooks_htb}

[Arg::s2_lowrtt]
rtt = 20ms
length = 40
netem_args = netem delay 10ms limit 1000000
test_parameters = stream_delays="0,10"; \
	cc_algos=${cc_algos}; \
	markings=${markings}

[Arg::s2_medrtt]
rtt = 80ms
length = 60
netem_args = netem delay 40ms limit 1000000
test_parameters = stream_delays="0,10"; \
	cc_algos=${cc_algos}; \
	markings="0,0"

[Arg::s2_highrtt]
rtt = 160ms
length = 180
netem_args = netem delay 80ms limit 1000000
test_parameters = stream_delays="0,10"; \
	cc_algos=${cc_algos}; \
	markings="0,0"


#############################################################################
#
# Scenario 3- Bottleneck Shift
#
[Batch::s3-bottleneck-shift]
abstract = yes
inherits = global
test_name = tcp_1up
for_rtts = s3_lowrtt, s3_medrtt
bandwidth = 50Mbit
filename_extra = ${net}-${cc}-${bandwidth}-${rtt}
title = net:${net} cc:${cc} qdisc:${qdisc} qdisc1:${qdisc1} bandwidth:${bandwidth} rtt:${rtt}
test_parameters = cc_algo=${cc};

# S3 SCE
[Batch::sce-s3-bottleneck-shift]
inherits = global, sce, s3-bottleneck-shift
cc = cubic-sce
qdisc = cake
qdisc_args = cake bandwidth ${bandwidth} sce
qdisc1 = pie(noecn)
qdisc1_args = pie noecn
midbox_hooks = \
	mid \
		\"qdisc bidir root ${qdisc_args}\; \
		qdisc bidir after ${delay1} htb ${bandwidth} ${qdisc1_args}\; \
		qdisc bidir after ${delay2} root ${qdisc_args}\; \
		qdisc bidir ingress root ${netem_args}\"

# S3 L4S
[Batch::l4s-s3-bottleneck-shift]
inherits = global, l4s, s3-bottleneck-shift
cc = prague
qdisc = dualpi2
qdisc_args = dualpi2
qdisc1 = pie(noecn)
qdisc1_args = pie noecn
midbox_hooks = \
	mid \
		\"qdisc bidir htb ${bandwidth} ${qdisc_args}\; \
		qdisc bidir after ${delay1} htb ${bandwidth} ${qdisc1_args}\; \
		qdisc bidir after ${delay2} htb ${bandwidth} ${qdisc_args}\; \
		qdisc bidir ingress root ${netem_args}\"

# S3 common
[Arg::s3_lowrtt]
rtt = 20ms
length = 60
delay1 = 20
delay2 = 40
netem_args = netem delay 10ms limit 1000000

[Arg::s3_medrtt]
rtt = 80ms
length = 180
delay1 = 60
delay2 = 120
netem_args = netem delay 40ms limit 1000000


#############################################################################
#
# Scenario 4- Capacity Reduction
#
[Batch::s4-capacity-reduction]
abstract = yes
inherits = global
test_name = tcp_1up
for_rtts = s4_lowrtt, s4_medrtt
for_bandwidth1 = s4_bandwidth1_40mbit, s4_bandwidth1_5mbit
bandwidth = 50Mbit
filename_extra = ${net}-${cc}-${bandwidth}-${bandwidth1}-${rtt}
title = net:${net} cc:${cc} qdisc:${qdisc} bandwidth:${bandwidth} bandwidth1:${bandwidth1} rtt:${rtt}
test_parameters = cc_algo=${cc};

# S4 SCE
[Batch::sce-s4-capacity-reduction]
inherits = global, sce, s4-capacity-reduction
cc = reno-sce
qdisc = twin_codel_af
qdisc_args = twin_codel_af bandwidth ${bandwidth} sce-thresh 4
qdisc1_args = twin_codel_af bandwidth ${bandwidth1} sce-thresh 4
midbox_hooks = \
	mid \
		\"qdisc bidir root ${qdisc_args}\; \
		qdisc bidir after ${delay1} root ${qdisc1_args}\; \
		qdisc bidir after ${delay2} root ${qdisc_args}\; \
		qdisc bidir ingress root ${netem_args}\"

# S4 L4S
[Batch::l4s-s4-capacity-reduction]
inherits = global, l4s, s4-capacity-reduction
cc = prague
qdisc = dualpi2
qdisc_args = dualpi2
midbox_hooks = \
	mid \
		\"qdisc bidir htb ${bandwidth} ${qdisc_args}\; \
		qdisc bidir after ${delay1} htb ${bandwidth1}\; \
		qdisc bidir after ${delay2} htb ${bandwidth}\; \
		qdisc bidir ingress root ${netem_args}\"

# S4 common
[Arg::s4_bandwidth1_40mbit]
bandwidth1 = 40mbit

[Arg::s4_bandwidth1_5mbit]
bandwidth1 = 5mbit

[Arg::s4_lowrtt]
rtt = 20ms
length = 60
delay1 = 20
delay2 = 40
netem_args = netem delay 10ms limit 1000000

[Arg::s4_medrtt]
rtt = 80ms
length = 120
delay1 = 40
delay2 = 80
netem_args = netem delay 40ms limit 1000000


#############################################################################
#
# Scenario 5- Burstiness
#
[Batch::s5-burstiness]
abstract = yes
inherits = global
test_name = tcp_1up
for_rtts = s5_lowrtt, s5_medrtt
bandwidth = 50Mbit
filename_extra = ${net}-${cc}-${qdisc}-${bandwidth}-${rtt}
title = net:${net} cc:${cc} qdisc:${qdisc} bandwidth:${bandwidth} rtt:${rtt}
test_parameters = cc_algo=${cc};
# reference: https://www.spinics.net/lists/netdev/msg520068.html
netem_wifi_args = netem delay 200us slot 800us 10ms packets 42 limit 512

# S5 SCE
[Batch::sce-s5-burstiness]
inherits = global, sce, s5-burstiness
cc = cubic-sce
for_qdisc = s5_twin_codel_af, s5_cake
midbox_hooks = \
	mid \
		\"qdisc bidir root ${qdisc_args}\; \
		qdisc bidir ingress-flowid 10:1 \
			ingress root-tree \\\"${netem_args}\\\" \
			\\\"${netem_wifi_args}\\\"\"

[Arg::s5_twin_codel_af]
qdisc = twin_codel_af
qdisc_args = twin_codel_af bandwidth ${bandwidth} sce-thresh 4

[Arg::s5_cake]
qdisc = cake
qdisc_args = cake bandwidth ${bandwidth} sce

# S5 L4S
[Batch::l4s-s5-burstiness]
inherits = global, l4s, s5-burstiness
cc = prague
qdisc = dualpi2
qdisc_args = dualpi2
midbox_hooks = \
	mid \
		\"qdisc bidir htb ${bandwidth} ${qdisc_args}\; \
		qdisc bidir ingress-flowid 10:1 \
			ingress root-tree \\\"${netem_args}\\\" \
			\\\"${netem_wifi_args}\\\"\"

# S5 common
[Arg::s5_lowrtt]
rtt = 20ms
length = 60
netem_args = netem delay 10ms limit 1000000

[Arg::s5_medrtt]
rtt = 80ms
length = 60
netem_args = netem delay 40ms limit 1000000


#############################################################################
#
# Scenario 6- Jitter
#
[Batch::s6-jitter]
abstract = yes
inherits = global
test_name = tcp_1up
for_rtts = s6_medrtt
bandwidth = 50Mbit
filename_extra = ${net}-${cc}-${qdisc}-${bandwidth}-${rtt}-${netem_jitter_args}
title = net:${net} jitter:${jitter_title} cc:${cc} qdisc:${qdisc} bandwidth:${bandwidth} rtt:${rtt}
test_parameters = cc_algo=${cc};
for_netem_jitter_args = s6_jitter1, s6_jitter2, s6_jitter3

# S6 SCE
[Batch::sce-s6-jitter]
inherits = global, sce, s6-jitter
cc = cubic-sce
for_qdisc = s6_twin_codel_af
midbox_hooks = \
	mid \
		\"qdisc bidir root ${qdisc_args}\; \
		qdisc bidir ingress-flowid 10:1 \
			ingress root-tree \\\"${netem_args}\\\" \
			\\\"${netem_jitter_args}\\\"\"

[Arg::s6_twin_codel_af]
qdisc = twin_codel_af
qdisc_args = twin_codel_af bandwidth ${bandwidth} sce-thresh 4

# S6 L4S
[Batch::l4s-s6-jitter]
inherits = global, l4s, s6-jitter
cc = prague
qdisc = dualpi2
qdisc_args = dualpi2
midbox_hooks = \
	mid \
		\"qdisc bidir htb ${bandwidth} ${qdisc_args}\; \
		qdisc bidir ingress-flowid 10:1 \
			ingress root-tree \\\"${netem_args}\\\" \
			\\\"${netem_jitter_args}\\\"\"

# S6 common
[Arg::s6_lowrtt]
rtt = 20ms
length = 60
netem_args = netem delay 10ms limit 1000000

[Arg::s6_medrtt]
rtt = 80ms
length = 60
netem_args = netem delay 40ms limit 1000000

[Arg::s6_jitter1]
netem_jitter_args = netem delay 2ms 1ms 10%
jitter_title = 2+/-1ms

[Arg::s6_jitter2]
netem_jitter_args = netem delay 4ms 2ms 10%
jitter_title = 4+/-2ms

[Arg::s6_jitter3]
netem_jitter_args = netem delay 10ms 5ms 10%
jitter_title = 10+/-5ms