Fix warnings reported by gen_doc.sh
[csit.git] / resources / libraries / python / CpuUtils.py
1 # Copyright (c) 2018 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
5 #
6 #     http://www.apache.org/licenses/LICENSE-2.0
7 #
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
13
14 """CPU utilities library."""
15
16 from resources.libraries.python.ssh import SSH
17
18 __all__ = ["CpuUtils"]
19
20
21 class CpuUtils(object):
22     """CPU utilities"""
23
24     # Number of threads per core.
25     NR_OF_THREADS = 2
26
27     @staticmethod
28     def __str2int(string):
29         """Conversion from string to integer, 0 in case of empty string.
30
31         :param string: Input string.
32         :type string: str
33         :returns: Integer converted from string, 0 in case of ValueError.
34         :rtype: int
35         """
36         try:
37             return int(string)
38         except ValueError:
39             return 0
40
41     @staticmethod
42     def is_smt_enabled(cpu_info):
43         """Uses CPU mapping to find out if SMT is enabled or not. If SMT is
44         enabled, the L1d,L1i,L2,L3 setting is the same for two processors. These
45         two processors are two threads of one core.
46
47         :param cpu_info: CPU info, the output of "lscpu -p".
48         :type cpu_info: list
49         :returns: True if SMT is enabled, False if SMT is disabled.
50         :rtype: bool
51         """
52
53         cpu_mems = [item[-4:] for item in cpu_info]
54         cpu_mems_len = len(cpu_mems) / CpuUtils.NR_OF_THREADS
55         count = 0
56         for cpu_mem in cpu_mems[:cpu_mems_len]:
57             if cpu_mem in cpu_mems[cpu_mems_len:]:
58                 count += 1
59         return bool(count == cpu_mems_len)
60
61     @staticmethod
62     def get_cpu_layout_from_all_nodes(nodes):
63         """Retrieve cpu layout from all nodes, assuming all nodes
64            are Linux nodes.
65
66         :param nodes: DICT__nodes from Topology.DICT__nodes.
67         :type nodes: dict
68         :raises RuntimeError: If the ssh command "lscpu -p" fails.
69         """
70         ssh = SSH()
71         for node in nodes.values():
72             ssh.connect(node)
73             cmd = "lscpu -p"
74             ret, stdout, stderr = ssh.exec_command(cmd)
75 #           parsing of "lscpu -p" output:
76 #           # CPU,Core,Socket,Node,,L1d,L1i,L2,L3
77 #           0,0,0,0,,0,0,0,0
78 #           1,1,0,0,,1,1,1,0
79             if ret != 0:
80                 raise RuntimeError(
81                     "Failed to execute ssh command, ret: {} err: {}".format(
82                         ret, stderr))
83             node['cpuinfo'] = list()
84             for line in stdout.split("\n"):
85                 if len(line) > 0 and line[0] != "#":
86                     node['cpuinfo'].append([CpuUtils.__str2int(x) for x in
87                                             line.split(",")])
88
89     @staticmethod
90     def cpu_node_count(node):
91         """Return count of numa nodes.
92
93         :param node: Targeted node.
94         :type node: dict
95         :returns: Count of numa nodes.
96         :rtype: int
97         :raises RuntimeError: If node cpuinfo is not available.
98         """
99         cpu_info = node.get("cpuinfo")
100         if cpu_info is not None:
101             return node["cpuinfo"][-1][3] + 1
102         else:
103             raise RuntimeError("Node cpuinfo not available.")
104
105     @staticmethod
106     def cpu_list_per_node(node, cpu_node, smt_used=False):
107         """Return node related list of CPU numbers.
108
109         :param node: Node dictionary with cpuinfo.
110         :param cpu_node: Numa node number.
111         :param smt_used: True - we want to use SMT, otherwise false.
112         :type node: dict
113         :type cpu_node: int
114         :type smt_used: bool
115         :returns: List of cpu numbers related to numa from argument.
116         :rtype: list of int
117         :raises RuntimeError: If node cpuinfo is not available
118             or if SMT is not enabled.
119         """
120
121         cpu_node = int(cpu_node)
122         cpu_info = node.get("cpuinfo")
123         if cpu_info is None:
124             raise RuntimeError("Node cpuinfo not available.")
125
126         smt_enabled = CpuUtils.is_smt_enabled(cpu_info)
127         if not smt_enabled and smt_used:
128             raise RuntimeError("SMT is not enabled.")
129
130         cpu_list = []
131         for cpu in cpu_info:
132             if cpu[3] == cpu_node:
133                 cpu_list.append(cpu[0])
134
135         if not smt_enabled or smt_enabled and smt_used:
136             pass
137
138         if smt_enabled and not smt_used:
139             cpu_list_len = len(cpu_list)
140             cpu_list = cpu_list[:cpu_list_len / CpuUtils.NR_OF_THREADS]
141
142         return cpu_list
143
144     @staticmethod
145     def cpu_slice_of_list_per_node(node, cpu_node, skip_cnt=0, cpu_cnt=0,
146                                    smt_used=False):
147         """Return string of node related list of CPU numbers.
148
149         :param node: Node dictionary with cpuinfo.
150         :param cpu_node: Numa node number.
151         :param skip_cnt: Skip first "skip_cnt" CPUs.
152         :param cpu_cnt: Count of cpus to return, if 0 then return all.
153         :param smt_used: True - we want to use SMT, otherwise false.
154         :type node: dict
155         :type cpu_node: int
156         :type skip_cnt: int
157         :type cpu_cnt: int
158         :type smt_used: bool
159         :returns: Cpu numbers related to numa from argument.
160         :rtype: list
161         :raises RuntimeError: If we require more cpus than available.
162         """
163
164         cpu_list = CpuUtils.cpu_list_per_node(node, cpu_node, smt_used)
165
166         cpu_list_len = len(cpu_list)
167         if cpu_cnt + skip_cnt > cpu_list_len:
168             raise RuntimeError("cpu_cnt + skip_cnt > length(cpu list).")
169
170         if cpu_cnt == 0:
171             cpu_cnt = cpu_list_len - skip_cnt
172
173         if smt_used:
174             cpu_list_0 = cpu_list[:cpu_list_len / CpuUtils.NR_OF_THREADS]
175             cpu_list_1 = cpu_list[cpu_list_len / CpuUtils.NR_OF_THREADS:]
176             cpu_list = [cpu for cpu in cpu_list_0[skip_cnt:skip_cnt + cpu_cnt]]
177             cpu_list_ex = [cpu for cpu in
178                            cpu_list_1[skip_cnt:skip_cnt + cpu_cnt]]
179             cpu_list.extend(cpu_list_ex)
180         else:
181             cpu_list = [cpu for cpu in cpu_list[skip_cnt:skip_cnt + cpu_cnt]]
182
183         return cpu_list
184
185     @staticmethod
186     def cpu_list_per_node_str(node, cpu_node, skip_cnt=0, cpu_cnt=0, sep=",",
187                               smt_used=False):
188         """Return string of node related list of CPU numbers.
189
190         :param node: Node dictionary with cpuinfo.
191         :param cpu_node: Numa node number.
192         :param skip_cnt: Skip first "skip_cnt" CPUs.
193         :param cpu_cnt: Count of cpus to return, if 0 then return all.
194         :param sep: Separator, default: 1,2,3,4,....
195         :param smt_used: True - we want to use SMT, otherwise false.
196         :type node: dict
197         :type cpu_node: int
198         :type skip_cnt: int
199         :type cpu_cnt: int
200         :type sep: str
201         :type smt_used: bool
202         :returns: Cpu numbers related to numa from argument.
203         :rtype: str
204         """
205
206         cpu_list = CpuUtils.cpu_slice_of_list_per_node(node, cpu_node,
207                                                        skip_cnt=skip_cnt,
208                                                        cpu_cnt=cpu_cnt,
209                                                        smt_used=smt_used)
210         return sep.join(str(cpu) for cpu in cpu_list)
211
212     @staticmethod
213     def cpu_range_per_node_str(node, cpu_node, skip_cnt=0, cpu_cnt=0, sep="-",
214                                smt_used=False):
215         """Return string of node related range of CPU numbers, e.g. 0-4.
216
217         :param node: Node dictionary with cpuinfo.
218         :param cpu_node: Numa node number.
219         :param skip_cnt: Skip first "skip_cnt" CPUs.
220         :param cpu_cnt: Count of cpus to return, if 0 then return all.
221         :param sep: Separator, default: "-".
222         :param smt_used: True - we want to use SMT, otherwise false.
223         :type node: dict
224         :type cpu_node: int
225         :type skip_cnt: int
226         :type cpu_cnt: int
227         :type sep: str
228         :type smt_used: bool
229         :returns: String of node related range of CPU numbers.
230         :rtype: str
231         """
232
233         cpu_list = CpuUtils.cpu_slice_of_list_per_node(node, cpu_node,
234                                                        skip_cnt=skip_cnt,
235                                                        cpu_cnt=cpu_cnt,
236                                                        smt_used=smt_used)
237         if smt_used:
238             cpu_list_len = len(cpu_list)
239             cpu_list_0 = cpu_list[:cpu_list_len / CpuUtils.NR_OF_THREADS]
240             cpu_list_1 = cpu_list[cpu_list_len / CpuUtils.NR_OF_THREADS:]
241             cpu_range = "{}{}{},{}{}{}".format(cpu_list_0[0], sep,
242                                                cpu_list_0[-1],
243                                                cpu_list_1[0], sep,
244                                                cpu_list_1[-1])
245         else:
246             cpu_range = "{}{}{}".format(cpu_list[0], sep, cpu_list[-1])
247
248         return cpu_range

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.