4 ## Copyright (c) 2020 Intel Corporation
6 ## Licensed under the Apache License, Version 2.0 (the "License");
7 ## you may not use this file except in compliance with the License.
8 ## You may obtain a copy of the License at
10 ## http://www.apache.org/licenses/LICENSE-2.0
12 ## Unless required by applicable law or agreed to in writing, software
13 ## distributed under the License is distributed on an "AS IS" BASIS,
14 ## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 ## See the License for the specific language governing permissions and
16 ## limitations under the License.
19 from rapid_log import RapidLog
20 from prox_ctrl import prox_ctrl
25 class RapidMachine(object):
27 Class to deal with a PROX instance (VM, bare metal, container)
29 def __init__(self, key, user, password, vim, rundir, resultsdir,
30 machine_params, configonly):
31 self.name = machine_params['name']
32 self.ip = machine_params['admin_ip']
35 self.password = password
37 self.resultsdir = resultsdir
39 self.dpdk_port_index = []
40 self.configonly = configonly
43 ip_key = 'dp_ip{}'.format(index)
44 mac_key = 'dp_mac{}'.format(index)
45 if ip_key in machine_params.keys():
46 if mac_key in machine_params.keys():
47 dp_port = {'ip': machine_params[ip_key], 'mac' : machine_params[mac_key]}
49 dp_port = {'ip': machine_params[ip_key], 'mac' : None}
50 self.dp_ports.append(dict(dp_port))
51 self.dpdk_port_index.append(index - 1)
55 self.machine_params = machine_params
57 self.cpu_mapping = None
58 if 'config_file' in self.machine_params.keys():
59 PROXConfigfile = open (self.machine_params['config_file'], 'r')
60 PROXConfig = PROXConfigfile.read()
61 PROXConfigfile.close()
62 self.all_tasks_for_this_cfg = set(re.findall("task\s*=\s*(\d+)",PROXConfig))
65 return (self.machine_params['cores'])
67 def expand_list_format(self, list):
68 """Expand cpuset list format provided as comma-separated list of
69 numbers and ranges of numbers. For more information please see
70 https://man7.org/linux/man-pages/man7/cpuset.7.html
73 for num in list.split(','):
75 num_range = num.split('-')
76 list_expanded += range(int(num_range[0]), int(num_range[1]) + 1)
78 list_expanded.append(int(num))
81 def read_cpuset(self):
82 """Read list of cpus on which we allowed to execute
84 cpu_set_file = '/sys/fs/cgroup/cpuset.cpus'
85 cmd = 'test -e {0} && echo exists'.format(cpu_set_file)
86 if (self._client.run_cmd(cmd).decode().rstrip()):
87 cmd = 'cat {}'.format(cpu_set_file)
89 cpu_set_file = '/sys/fs/cgroup/cpuset/cpuset.cpus'
90 cmd = 'test -e {0} && echo exists'.format(cpu_set_file)
91 if (self._client.run_cmd(cmd).decode().rstrip()):
92 cmd = 'cat {}'.format(cpu_set_file)
94 RapidLog.critical('{Cannot determine cpuset')
95 cpuset_cpus = self._client.run_cmd(cmd).decode().rstrip()
96 RapidLog.debug('{} ({}): Allocated cpuset: {}'.format(self.name, self.ip, cpuset_cpus))
97 self.cpu_mapping = self.expand_list_format(cpuset_cpus)
98 RapidLog.debug('{} ({}): Expanded cpuset: {}'.format(self.name, self.ip, self.cpu_mapping))
100 # Log CPU core mapping for user information
102 for i in range(len(self.cpu_mapping)):
103 cpu_mapping_str = cpu_mapping_str + '[' + str(i) + '->' + str(self.cpu_mapping[i]) + '], '
104 cpu_mapping_str = cpu_mapping_str[:-2]
105 RapidLog.debug('{} ({}): CPU mapping: {}'.format(self.name, self.ip, cpu_mapping_str))
107 def remap_cpus(self, cpus):
108 """Convert relative cpu ids provided as function parameter to match
109 cpu ids from allocated list
113 cpus_remapped.append(self.cpu_mapping[cpu])
116 def remap_all_cpus(self):
117 """Convert relative cpu ids for different parameters (mcore, cores)
119 if self.cpu_mapping is None:
120 RapidLog.debug('{} ({}): cpu mapping is not defined! Please check the configuration!'.format(self.name, self.ip))
123 if 'mcore' in self.machine_params.keys():
124 cpus_remapped = self.remap_cpus(self.machine_params['mcore'])
125 RapidLog.debug('{} ({}): mcore {} remapped to {}'.format(self.name, self.ip, self.machine_params['mcore'], cpus_remapped))
126 self.machine_params['mcore'] = cpus_remapped
128 if 'cores' in self.machine_params.keys():
129 cpus_remapped = self.remap_cpus(self.machine_params['cores'])
130 RapidLog.debug('{} ({}): cores {} remapped to {}'.format(self.name, self.ip, self.machine_params['cores'], cpus_remapped))
131 self.machine_params['cores'] = cpus_remapped
133 if 'altcores' in self.machine_params.keys():
134 cpus_remapped = self.remap_cpus(self.machine_params['altcores'])
135 RapidLog.debug('{} ({}): altcores {} remapped to {}'.format(self.name, self.ip, self.machine_params['altcores'], cpus_remapped))
136 self.machine_params['altcores'] = cpus_remapped
139 # Script to bind the right network interface to the poll mode driver
140 for index, dp_port in enumerate(self.dp_ports, start = 1):
141 DevBindFileName = self.rundir + '/devbind-{}-port{}.sh'.format(self.ip, index)
142 self._client.scp_put('./devbind.sh', DevBindFileName)
143 cmd = 'sed -i \'s/MACADDRESS/' + dp_port['mac'] + '/\' ' + DevBindFileName
144 result = self._client.run_cmd(cmd)
145 RapidLog.debug('devbind.sh MAC updated for port {} on {} {}'.format(index, self.name, result))
146 if ((not self.configonly) and self.machine_params['prox_launch_exit']):
147 result = self._client.run_cmd(DevBindFileName)
148 RapidLog.debug('devbind.sh running for port {} on {} {}'.format(index, self.name, result))
150 def generate_lua(self, appendix = ''):
151 self.LuaFileName = 'parameters-{}.lua'.format(self.ip)
152 with open(self.LuaFileName, "w") as LuaFile:
153 LuaFile.write('require "helper"\n')
154 LuaFile.write('name="%s"\n'% self.name)
155 for index, dp_port in enumerate(self.dp_ports, start = 1):
156 LuaFile.write('local_ip{}="{}"\n'.format(index, dp_port['ip']))
157 LuaFile.write('local_hex_ip{}=convertIPToHex(local_ip{})\n'.format(index, index))
158 if self.vim in ['kubernetes']:
159 cmd = 'cat /opt/rapid/dpdk_version'
160 dpdk_version = self._client.run_cmd(cmd).decode().rstrip()
161 if (dpdk_version >= '20.11.0'):
162 allow_parameter = 'allow'
164 allow_parameter = 'pci-whitelist'
165 eal_line = 'eal=\"--file-prefix {}{} --{} {} --force-max-simd-bitwidth=512'.format(
166 self.name, str(uuid.uuid4()), allow_parameter,
167 self.machine_params['dp_pci_dev'])
168 looking_for_qat = True
170 while (looking_for_qat):
171 if 'qat_pci_dev{}'.format(index) in self.machine_params:
172 eal_line += ' --{} {}'.format(allow_parameter,
173 self.machine_params['qat_pci_dev{}'.format(index)])
176 looking_for_qat = False
178 LuaFile.write(eal_line)
180 LuaFile.write("eal=\"\"\n")
181 if 'mcore' in self.machine_params.keys():
182 LuaFile.write('mcore="%s"\n'% ','.join(map(str,
183 self.machine_params['mcore'])))
184 if 'cores' in self.machine_params.keys():
185 LuaFile.write('cores="%s"\n'% ','.join(map(str,
186 self.machine_params['cores'])))
187 if 'altcores' in self.machine_params.keys():
188 LuaFile.write('altcores="%s"\n'% ','.join(map(str,
189 self.machine_params['altcores'])))
190 if 'ports' in self.machine_params.keys():
191 LuaFile.write('ports="%s"\n'% ','.join(map(str,
192 self.machine_params['ports'])))
193 if 'dest_ports' in self.machine_params.keys():
194 for index, dest_port in enumerate(self.machine_params['dest_ports'], start = 1):
195 LuaFile.write('dest_ip{}="{}"\n'.format(index, dest_port['ip']))
196 LuaFile.write('dest_hex_ip{}=convertIPToHex(dest_ip{})\n'.format(index, index))
198 LuaFile.write('dest_hex_mac{}="{}"\n'.format(index ,
199 dest_port['mac'].replace(':',' ')))
200 if 'gw_vm' in self.machine_params.keys():
201 for index, gw_ip in enumerate(self.machine_params['gw_ips'],
203 LuaFile.write('gw_ip{}="{}"\n'.format(index, gw_ip))
204 LuaFile.write('gw_hex_ip{}=convertIPToHex(gw_ip{})\n'.
205 format(index, index))
206 LuaFile.write(appendix)
207 self._client.scp_put(self.LuaFileName, self.rundir + '/parameters.lua')
208 self._client.scp_put('helper.lua', self.rundir + '/helper.lua')
210 def start_prox(self, autostart=''):
211 if self.machine_params['prox_socket']:
212 self._client = prox_ctrl(self.ip, self.key, self.user,
214 self._client.test_connection()
215 if self.vim in ['OpenStack']:
217 if self.vim in ['kubernetes']:
219 self.remap_all_cpus()
220 _, prox_config_file_name = os.path.split(self.
221 machine_params['config_file'])
222 if self.machine_params['prox_launch_exit']:
224 self._client.scp_put(self.machine_params['config_file'], '{}/{}'.
225 format(self.rundir, prox_config_file_name))
226 if not self.configonly:
227 cmd = 'sudo {}/prox {} -t -o cli -f {}/{}'.format(self.rundir,
228 autostart, self.rundir, prox_config_file_name)
229 RapidLog.debug("Starting PROX on {}: {}".format(self.name,
231 result = self._client.run_cmd(cmd)
232 RapidLog.debug("Finished PROX on {}: {}".format(self.name,
235 def close_prox(self):
236 if (not self.configonly) and self.machine_params[
237 'prox_socket'] and self.machine_params['prox_launch_exit']:
238 self.socket.quit_prox()
239 self._client.scp_get('/prox.log', '{}/{}.prox.log'.format(
240 self.resultsdir, self.name))
242 def connect_prox(self):
243 if self.machine_params['prox_socket']:
244 self.socket = self._client.connect_socket()
247 self.socket.start(self.get_cores())
250 self.socket.stop(self.get_cores())
252 def reset_stats(self):
253 self.socket.reset_stats()
255 def core_stats(self):
256 return (self.socket.core_stats(self.get_cores(), self.all_tasks_for_this_cfg))
258 def multi_port_stats(self):
259 return (self.socket.multi_port_stats(self.dpdk_port_index))