openstack
/
neutron
Code Issues Proposed changes

Merge "Fix the wrong value for QoS rate conversion to bytes/s" into stable/ussuri

This commit is contained in:
Zuul 2020-06-26 10:13:05 +00:00 committed by Gerrit Code Review
parent 02df328097 19f60ce728
commit 7d14278c94
4 changed files with 31 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
neutron/agent/linux/tc_lib.py
View File

@ -345,8 +345,8 @@ def add_tc_qdisc(device, qdisc_type, parent=None, handle=None, latency_ms=None,
qdisc_type=qdisc_type, qdisc_type=qdisc_type,
needed_arguments=['latency_ms', 'max_kbps', 'kernel_hz']) needed_arguments=['latency_ms', 'max_kbps', 'kernel_hz'])
args['burst'] = int( args['burst'] = int(
_get_tbf_burst_value(max_kbps, burst_kb, kernel_hz) * 1024 / 8) _get_tbf_burst_value(max_kbps, burst_kb, kernel_hz) * 1000 / 8)
args['rate'] = int(max_kbps * 1024 / 8) args['rate'] = int(max_kbps * 1000 / 8)
args['latency'] = latency_ms * 1000 args['latency'] = latency_ms * 1000
if parent: if parent:
args['parent'] = rtnl.TC_H_ROOT if parent == 'root' else parent args['parent'] = rtnl.TC_H_ROOT if parent == 'root' else parent
@ -371,10 +371,10 @@ def list_tc_qdiscs(device, namespace=None):
if qdisc_attrs['qdisc_type'] == 'tbf': if qdisc_attrs['qdisc_type'] == 'tbf':
tca_options = _get_attr(qdisc, 'TCA_OPTIONS') tca_options = _get_attr(qdisc, 'TCA_OPTIONS')
tca_tbf_parms = _get_attr(tca_options, 'TCA_TBF_PARMS') tca_tbf_parms = _get_attr(tca_options, 'TCA_TBF_PARMS')
qdisc_attrs['max_kbps'] = int(tca_tbf_parms['rate'] * 8 / 1024) qdisc_attrs['max_kbps'] = int(tca_tbf_parms['rate'] * 8 / 1000)
burst_bytes = _calc_burst(tca_tbf_parms['rate'], burst_bytes = _calc_burst(tca_tbf_parms['rate'],
tca_tbf_parms['buffer']) tca_tbf_parms['buffer'])
qdisc_attrs['burst_kb'] = int(burst_bytes * 8 / 1024) qdisc_attrs['burst_kb'] = int(burst_bytes * 8 / 1000)
qdisc_attrs['latency_ms'] = _calc_latency_ms( qdisc_attrs['latency_ms'] = _calc_latency_ms(
tca_tbf_parms['limit'], burst_bytes, tca_tbf_parms['rate']) tca_tbf_parms['limit'], burst_bytes, tca_tbf_parms['rate'])
retval.append(qdisc_attrs) retval.append(qdisc_attrs)
@ -427,10 +427,10 @@ def add_tc_policy_class(device, parent, classid, max_kbps, min_kbps=None,
# - ceil (max bw): bytes/second # - ceil (max bw): bytes/second
# - burst: bytes # - burst: bytes
# [1] https://www.systutorials.com/docs/linux/man/8-tc/ # [1] https://www.systutorials.com/docs/linux/man/8-tc/
kwargs = {'ceil': int(max_kbps * 1024 / 8), kwargs = {'ceil': int(max_kbps * 1000 / 8),
'burst': int(burst_kb * 1024 / 8)} 'burst': int(burst_kb * 1000 / 8)}
rate = int((min_kbps or 0) * 1024 / 8) rate = int((min_kbps or 0) * 1000 / 8)
min_rate = _calc_min_rate(kwargs['burst']) min_rate = _calc_min_rate(kwargs['burst'])
if min_rate > rate: if min_rate > rate:
LOG.warning('TC HTB class policy rate %(rate)s (bytes/second) is ' LOG.warning('TC HTB class policy rate %(rate)s (bytes/second) is '
@ -460,9 +460,9 @@ def list_tc_policy_class(device, namespace=None):
tca_params = _get_attr(tca_options, tca_params = _get_attr(tca_options,
'TCA_' + qdisc_type.upper() + '_PARMS') 'TCA_' + qdisc_type.upper() + '_PARMS')
burst_kb = int( burst_kb = int(
_calc_burst(tca_params['rate'], tca_params['buffer']) * 8 / 1024) _calc_burst(tca_params['rate'], tca_params['buffer']) * 8 / 1000)
max_kbps = int(tca_params['ceil'] * 8 / 1024) max_kbps = int(tca_params['ceil'] * 8 / 1000)
min_kbps = int(tca_params['rate'] * 8 / 1024) min_kbps = int(tca_params['rate'] * 8 / 1000)
return max_kbps, min_kbps, burst_kb return max_kbps, min_kbps, burst_kb
tc_classes = priv_tc_lib.list_tc_policy_classes(device, tc_classes = priv_tc_lib.list_tc_policy_classes(device,
@ -562,8 +562,8 @@ def add_tc_filter_policy(device, parent, rate_kbps, burst_kb, mtu, action,
:param namespace: (string) (optional) namespace name :param namespace: (string) (optional) namespace name
""" """
rate = int(rate_kbps * 1024 / 8) rate = int(rate_kbps * 1000 / 8)
burst = int(burst_kb * 1024 / 8) burst = int(burst_kb * 1000 / 8)
priv_tc_lib.add_tc_filter_policy(device, parent, priority, rate, burst, priv_tc_lib.add_tc_filter_policy(device, parent, priority, rate, burst,
mtu, action, protocol=protocol, mtu, action, protocol=protocol,
namespace=namespace) namespace=namespace)
@ -604,10 +604,10 @@ def list_tc_filters(device, parent, namespace=None):
if tca_u32_police: if tca_u32_police:
tca_police_tbf = _get_attr(tca_u32_police, 'TCA_POLICE_TBF') tca_police_tbf = _get_attr(tca_u32_police, 'TCA_POLICE_TBF')
if tca_police_tbf: if tca_police_tbf:
value['rate_kbps'] = int(tca_police_tbf['rate'] * 8 / 1024) value['rate_kbps'] = int(tca_police_tbf['rate'] * 8 / 1000)
value['burst_kb'] = int( value['burst_kb'] = int(
_calc_burst(tca_police_tbf['rate'], _calc_burst(tca_police_tbf['rate'],
tca_police_tbf['burst']) * 8 / 1024) tca_police_tbf['burst']) * 8 / 1000)
value['mtu'] = tca_police_tbf['mtu'] value['mtu'] = tca_police_tbf['mtu']
retval.append(value) retval.append(value)

8
neutron/tests/functional/agent/linux/test_tc_lib.py
View File

@ -166,17 +166,17 @@ class TcPolicyClassTestCase(functional_base.BaseSudoTestCase):
max_kbps=2000, burst_kb=1000, max_kbps=2000, burst_kb=1000,
min_kbps=3, namespace=self.ns[0]) min_kbps=3, namespace=self.ns[0])
mock_log.warning.assert_called_once_with( mock_log.warning.assert_called_once_with(
*warning_args(3 * 128, tc_lib._calc_min_rate(1000 * 128))) *warning_args(3 * 125, tc_lib._calc_min_rate(1000 * 125)))
# rate < min_rate: min_rate = 466 with burst = 0.8 ceil = 256000 # rate < min_rate: min_rate = 455 with burst = 0.8 ceil = 256000
mock_log.reset_mock() mock_log.reset_mock()
tc_lib.add_tc_policy_class(self.device[0], '1:', '1:10', tc_lib.add_tc_policy_class(self.device[0], '1:', '1:10',
max_kbps=2000, burst_kb=None, max_kbps=2000, burst_kb=None,
min_kbps=5, namespace=self.ns[0]) min_kbps=5, namespace=self.ns[0])
min_rate = tc_lib._calc_min_rate(qos_consts.DEFAULT_BURST_RATE * min_rate = tc_lib._calc_min_rate(qos_consts.DEFAULT_BURST_RATE *
2000 * 128) 2000 * 125)
mock_log.warning.assert_called_once_with( mock_log.warning.assert_called_once_with(
*warning_args(5 * 128, min_rate)) *warning_args(5 * 125, min_rate))
class TcFiltersTestCase(functional_base.BaseSudoTestCase): class TcFiltersTestCase(functional_base.BaseSudoTestCase):

8
neutron/tests/functional/privileged/agent/linux/test_tc_lib.py
View File

@ -279,8 +279,8 @@ class TcFilterClassTestCase(functional_base.BaseSudoTestCase):
namespace=self.namespace) namespace=self.namespace)
# NOTE(ralonsoh): # NOTE(ralonsoh):
# - rate: 320000 bytes/sec (pyroute2 units) = 2500 kbits/sec (OS units) # - rate: 320000 bytes/sec (pyroute2 units) = 2560 kbits/sec (OS units)
# - burst: 192000 bytes/sec = 1500 kbits/sec # - burst: 192000 bytes/sec = 1536 kbits/sec
priv_tc_lib.add_tc_filter_policy( priv_tc_lib.add_tc_filter_policy(
self.device, 'ffff:', 49, 320000, 192000, 1200, 'drop', self.device, 'ffff:', 49, 320000, 192000, 1200, 'drop',
namespace=self.namespace) namespace=self.namespace)
@ -288,6 +288,6 @@ class TcFilterClassTestCase(functional_base.BaseSudoTestCase):
filters = tc_lib.list_tc_filters( filters = tc_lib.list_tc_filters(
self.device, 'ffff:', namespace=self.namespace) self.device, 'ffff:', namespace=self.namespace)
self.assertEqual(1, len(filters)) self.assertEqual(1, len(filters))
self.assertEqual(2500, filters[0]['rate_kbps']) self.assertEqual(2560, filters[0]['rate_kbps'])
self.assertEqual(1500, filters[0]['burst_kb']) self.assertEqual(1536, filters[0]['burst_kb'])
self.assertEqual(1200, filters[0]['mtu']) self.assertEqual(1200, filters[0]['mtu'])

18
neutron/tests/unit/agent/linux/test_tc_lib.py
View File

@ -270,9 +270,9 @@ class TcTestCase(base.BaseTestCase):
tc_lib.add_tc_qdisc('device', 'tbf', parent='root', max_kbps=10000, tc_lib.add_tc_qdisc('device', 'tbf', parent='root', max_kbps=10000,
burst_kb=1500, latency_ms=70, kernel_hz=250, burst_kb=1500, latency_ms=70, kernel_hz=250,
namespace=self.namespace) namespace=self.namespace)
burst = tc_lib._get_tbf_burst_value(10000, 1500, 70) * 1024 / 8 burst = tc_lib._get_tbf_burst_value(10000, 1500, 70) * 1000 / 8
self.mock_add_tc_qdisc.assert_called_once_with( self.mock_add_tc_qdisc.assert_called_once_with(
'device', parent=rtnl.TC_H_ROOT, kind='tbf', rate=10000 * 128, 'device', parent=rtnl.TC_H_ROOT, kind='tbf', rate=10000 * 125,
burst=burst, latency=70000, namespace=self.namespace) burst=burst, latency=70000, namespace=self.namespace)
def test_add_tc_qdisc_tbf_missing_arguments(self): def test_add_tc_qdisc_tbf_missing_arguments(self):
@ -317,8 +317,8 @@ class TcTestCase(base.BaseTestCase):
self.assertEqual('root', qdiscs[0]['parent']) self.assertEqual('root', qdiscs[0]['parent'])
self.assertEqual('5:1', qdiscs[0]['handle']) self.assertEqual('5:1', qdiscs[0]['handle'])
self.assertEqual('tbf', qdiscs[0]['qdisc_type']) self.assertEqual('tbf', qdiscs[0]['qdisc_type'])
self.assertEqual(2500, qdiscs[0]['max_kbps']) self.assertEqual(2560, qdiscs[0]['max_kbps'])
self.assertEqual(1500, qdiscs[0]['burst_kb']) self.assertEqual(1536, qdiscs[0]['burst_kb'])
self.assertEqual(50, qdiscs[0]['latency_ms']) self.assertEqual(50, qdiscs[0]['latency_ms'])
def test__get_tbf_burst_value_when_burst_bigger_then_minimal(self): def test__get_tbf_burst_value_when_burst_bigger_then_minimal(self):
@ -345,8 +345,8 @@ class TcPolicyClassTestCase(base.BaseTestCase):
'device', 'root', '1:10', min_kbps=1000, max_kbps=2000, 'device', 'root', '1:10', min_kbps=1000, max_kbps=2000,
burst_kb=1600, namespace=self.namespace) burst_kb=1600, namespace=self.namespace)
self.mock_add_tc_policy_class.assert_called_once_with( self.mock_add_tc_policy_class.assert_called_once_with(
'device', rtnl.TC_H_ROOT, '1:10', 'htb', rate=1000 * 128, 'device', rtnl.TC_H_ROOT, '1:10', 'htb', rate=1000 * 125,
ceil=2000 * 128, burst=1600 * 128, namespace=self.namespace) ceil=2000 * 125, burst=1600 * 125, namespace=self.namespace)
@mock.patch('pyroute2.netlink.rtnl.tcmsg.common.tick_in_usec', 15.625) @mock.patch('pyroute2.netlink.rtnl.tcmsg.common.tick_in_usec', 15.625)
def test_list_tc_policy_classes(self): def test_list_tc_policy_classes(self):
@ -366,9 +366,9 @@ class TcPolicyClassTestCase(base.BaseTestCase):
'parent': 'root', 'parent': 'root',
'classid': '1:1', 'classid': '1:1',
'qdisc_type': 'htb', 'qdisc_type': 'htb',
'min_kbps': 1500, 'min_kbps': 1536,
'max_kbps': 2000, 'max_kbps': 2048,
'burst_kb': 1200} 'burst_kb': 1228}
self.assertEqual(reference, _class) self.assertEqual(reference, _class)