Coverage for nova/virt/hardware.py: 95%

1# Copyright 2014 Red Hat, Inc 

2# 

3# Licensed under the Apache License, Version 2.0 (the "License"); you may 

4# not use this file except in compliance with the License. You may obtain 

5# a copy of the License at 

6# 

7# http://www.apache.org/licenses/LICENSE-2.0 

8# 

9# Unless required by applicable law or agreed to in writing, software 

10# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 

11# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 

12# License for the specific language governing permissions and limitations 

13# under the License. 

14 

15import collections 

16import itertools 

17import re 

18import typing as ty 

19 

20import os_resource_classes as orc 

21import os_traits 

22from oslo_log import log as logging 

23from oslo_utils import strutils 

24from oslo_utils import units 

25 

26from nova import compute 

27import nova.conf 

28from nova import exception 

29from nova.i18n import _ 

30from nova import objects 

31from nova.objects import compute_node 

32from nova.objects import fields 

33from nova.objects import service 

34from nova.pci import stats 

35from nova.scheduler.client import report 

36 

37 

38CONF = nova.conf.CONF 

39LOG = logging.getLogger(__name__) 

40 

41MEMPAGES_SMALL = -1 

42MEMPAGES_LARGE = -2 

43MEMPAGES_ANY = -3 

44 

45 

46class VTPMConfig(ty.NamedTuple): 

47 version: str 

48 model: str 

49 

50 

51def get_vcpu_pin_set(): 

52 """Parse ``vcpu_pin_set`` config. 

53 

54 :returns: A set of host CPU IDs that can be used for VCPU and PCPU 

55 allocations. 

56 """ 

57 if not CONF.vcpu_pin_set: 

58 return None 

59 

60 cpuset_ids = parse_cpu_spec(CONF.vcpu_pin_set) 

61 if not cpuset_ids: 

62 msg = _("No CPUs available after parsing 'vcpu_pin_set' config, %r") 

63 raise exception.Invalid(msg % CONF.vcpu_pin_set) 

64 return cpuset_ids 

65 

66 

67def get_cpu_dedicated_set(): 

68 """Parse ``[compute] cpu_dedicated_set`` config. 

69 

70 :returns: A set of host CPU IDs that can be used for PCPU allocations. 

71 """ 

72 if not CONF.compute.cpu_dedicated_set: 

73 return None 

74 

75 cpu_ids = parse_cpu_spec(CONF.compute.cpu_dedicated_set) 

76 if not cpu_ids: 

77 msg = _("No CPUs available after parsing '[compute] " 

78 "cpu_dedicated_set' config, %r") 

79 raise exception.Invalid(msg % CONF.compute.cpu_dedicated_set) 

80 return cpu_ids 

81 

82 

83def get_cpu_dedicated_set_nozero(): 

84 """Return cpu_dedicated_set without CPU0, if present""" 

85 return (get_cpu_dedicated_set() or set()) - {0} 

86 

87 

88def get_cpu_shared_set(): 

89 """Parse ``[compute] cpu_shared_set`` config. 

90 

91 :returns: A set of host CPU IDs that can be used for emulator threads and, 

92 optionally, for VCPU allocations. 

93 """ 

94 if not CONF.compute.cpu_shared_set: 

95 return None 

96 

97 shared_ids = parse_cpu_spec(CONF.compute.cpu_shared_set) 

98 if not shared_ids: 

99 msg = _("No CPUs available after parsing '[compute] cpu_shared_set' " 

100 "config, %r") 

101 raise exception.Invalid(msg % CONF.compute.cpu_shared_set) 

102 return shared_ids 

103 

104 

105def parse_cpu_spec(spec: str) -> ty.Set[int]: 

106 """Parse a CPU set specification. 

107 

108 Each element in the list is either a single CPU number, a range of 

109 CPU numbers, or a caret followed by a CPU number to be excluded 

110 from a previous range. 

111 

112 :param spec: cpu set string eg "1-4,^3,6" 

113 

114 :returns: a set of CPU indexes 

115 """ 

116 cpuset_ids: ty.Set[int] = set() 

117 cpuset_reject_ids: ty.Set[int] = set() 

118 for rule in spec.split(','): 

119 rule = rule.strip() 

120 # Handle multi ',' 

121 if len(rule) < 1: 

122 continue 

123 # Note the count limit in the .split() call 

124 range_parts = rule.split('-', 1) 

125 if len(range_parts) > 1: 

126 reject = False 

127 if range_parts[0] and range_parts[0][0] == '^': 

128 reject = True 

129 range_parts[0] = str(range_parts[0][1:]) 

130 

131 # So, this was a range; start by converting the parts to ints 

132 try: 

133 start, end = [int(p.strip()) for p in range_parts] 

134 except ValueError: 

135 raise exception.Invalid(_("Invalid range expression %r") 

136 % rule) 

137 # Make sure it's a valid range 

138 if start > end: 

139 raise exception.Invalid(_("Invalid range expression %r") 

140 % rule) 

141 # Add available CPU ids to set 

142 if not reject: 

143 cpuset_ids |= set(range(start, end + 1)) 

144 else: 

145 cpuset_reject_ids |= set(range(start, end + 1)) 

146 elif rule[0] == '^': 

147 # Not a range, the rule is an exclusion rule; convert to int 

148 try: 

149 cpuset_reject_ids.add(int(rule[1:].strip())) 

150 except ValueError: 

151 raise exception.Invalid(_("Invalid exclusion " 

152 "expression %r") % rule) 

153 else: 

154 # OK, a single CPU to include; convert to int 

155 try: 

156 cpuset_ids.add(int(rule)) 

157 except ValueError: 

158 raise exception.Invalid(_("Invalid inclusion " 

159 "expression %r") % rule) 

160 

161 # Use sets to handle the exclusion rules for us 

162 cpuset_ids -= cpuset_reject_ids 

163 

164 return cpuset_ids 

165 

166 

167def format_cpu_spec( 

168 cpuset: ty.Set[int], 

169 allow_ranges: bool = True, 

170) -> str: 

171 """Format a libvirt CPU range specification. 

172 

173 Format a set/list of CPU indexes as a libvirt CPU range 

174 specification. If allow_ranges is true, it will try to detect 

175 continuous ranges of CPUs, otherwise it will just list each CPU 

176 index explicitly. 

177 

178 :param cpuset: set (or list) of CPU indexes 

179 :param allow_ranges: Whether we should attempt to detect continuous ranges 

180 of CPUs. 

181 

182 :returns: a formatted CPU range string 

183 """ 

184 # We attempt to detect ranges, but don't bother with 

185 # trying to do range negations to minimize the overall 

186 # spec string length 

187 if allow_ranges: 

188 ranges: ty.List[ty.List[int]] = [] 

189 previndex = None 

190 for cpuindex in sorted(cpuset): 

191 if previndex is None or previndex != (cpuindex - 1): 

192 ranges.append([]) 

193 ranges[-1].append(cpuindex) 

194 previndex = cpuindex 

195 

196 parts = [] 

197 for entry in ranges: 

198 if len(entry) == 1: 

199 parts.append(str(entry[0])) 

200 else: 

201 parts.append("%d-%d" % (entry[0], entry[len(entry) - 1])) 

202 return ",".join(parts) 

203 else: 

204 return ",".join(str(id) for id in sorted(cpuset)) 

205 

206 

207def get_number_of_serial_ports(flavor, image_meta): 

208 """Get the number of serial consoles from the flavor or image. 

209 

210 If flavor extra specs is not set, then any image meta value is 

211 permitted. If flavor extra specs *is* set, then this provides the 

212 default serial port count. The image meta is permitted to override 

213 the extra specs, but *only* with a lower value, i.e.: 

214 

215 - flavor hw:serial_port_count=4 

216 VM gets 4 serial ports 

217 - flavor hw:serial_port_count=4 and image hw_serial_port_count=2 

218 VM gets 2 serial ports 

219 - image hw_serial_port_count=6 

220 VM gets 6 serial ports 

221 - flavor hw:serial_port_count=4 and image hw_serial_port_count=6 

222 Abort guest boot - forbidden to exceed flavor value 

223 

224 :param flavor: Flavor object to read extra specs from 

225 :param image_meta: nova.objects.ImageMeta object instance 

226 

227 :raises: exception.ImageSerialPortNumberInvalid if the serial port count 

228 is not a valid integer 

229 :raises: exception.ImageSerialPortNumberExceedFlavorValue if the serial 

230 port count defined in image is greater than that of flavor 

231 :returns: number of serial ports 

232 """ 

233 flavor_num_ports, image_num_ports = _get_flavor_image_meta( 

234 'serial_port_count', flavor, image_meta) 

235 if flavor_num_ports: 

236 try: 

237 flavor_num_ports = int(flavor_num_ports) 

238 except ValueError: 

239 raise exception.ImageSerialPortNumberInvalid( 

240 num_ports=flavor_num_ports) 

241 

242 if flavor_num_ports and image_num_ports: 

243 if image_num_ports > flavor_num_ports: 

244 raise exception.ImageSerialPortNumberExceedFlavorValue() 

245 return image_num_ports 

246 

247 return flavor_num_ports or image_num_ports or 1 

248 

249 

250class InstanceInfo(object): 

251 

252 def __init__(self, state, internal_id=None): 

253 """Create a new Instance Info object 

254 

255 :param state: Required. The running state, one of the power_state codes 

256 :param internal_id: Optional. A unique ID for the instance. Need not be 

257 related to the Instance.uuid. 

258 """ 

259 self.state = state 

260 self.internal_id = internal_id 

261 

262 def __eq__(self, other): 

263 return (self.__class__ == other.__class__ and 

264 self.__dict__ == other.__dict__) 

265 

266 

267def _score_cpu_topology(topology, wanttopology): 

268 """Compare a topology against a desired configuration. 

269 

270 Calculate a score indicating how well a provided topology matches 

271 against a preferred topology, where: 

272 

273 a score of 3 indicates an exact match for sockets, cores and 

274 threads 

275 a score of 2 indicates a match of sockets and cores, or sockets 

276 and threads, or cores and threads 

277 a score of 1 indicates a match of sockets or cores or threads 

278 a score of 0 indicates no match 

279 

280 :param wanttopology: nova.objects.VirtCPUTopology instance for 

281 preferred topology 

282 

283 :returns: score in range 0 (worst) to 3 (best) 

284 """ 

285 score = 0 

286 if wanttopology.sockets and topology.sockets == wanttopology.sockets: 

287 score = score + 1 

288 if wanttopology.cores and topology.cores == wanttopology.cores: 

289 score = score + 1 

290 if wanttopology.threads and topology.threads == wanttopology.threads: 

291 score = score + 1 

292 return score 

293 

294 

295def get_cpu_topology_constraints(flavor, image_meta): 

296 """Get the topology constraints declared in flavor or image 

297 

298 Extracts the topology constraints from the configuration defined in 

299 the flavor extra specs or the image metadata. In the flavor this 

300 will look for: 

301 

302 hw:cpu_sockets - preferred socket count 

303 hw:cpu_cores - preferred core count 

304 hw:cpu_threads - preferred thread count 

305 hw:cpu_max_sockets - maximum socket count 

306 hw:cpu_max_cores - maximum core count 

307 hw:cpu_max_threads - maximum thread count 

308 

309 In the image metadata this will look at: 

310 

311 hw_cpu_sockets - preferred socket count 

312 hw_cpu_cores - preferred core count 

313 hw_cpu_threads - preferred thread count 

314 hw_cpu_max_sockets - maximum socket count 

315 hw_cpu_max_cores - maximum core count 

316 hw_cpu_max_threads - maximum thread count 

317 

318 The image metadata must be strictly lower than any values set in 

319 the flavor. All values are, however, optional. 

320 

321 :param flavor: Flavor object to read extra specs from 

322 :param image_meta: nova.objects.ImageMeta object instance 

323 

324 :raises: exception.ImageVCPULimitsRangeExceeded if the maximum 

325 counts set against the image exceed the maximum counts 

326 set against the flavor 

327 :raises: exception.ImageVCPUTopologyRangeExceeded if the preferred 

328 counts set against the image exceed the maximum counts set 

329 against the image or flavor 

330 :raises: exception.InvalidRequest if one of the provided flavor properties 

331 is a non-integer 

332 :returns: A two-tuple of objects.VirtCPUTopology instances. The 

333 first element corresponds to the preferred topology, 

334 while the latter corresponds to the maximum topology, 

335 based on upper limits. 

336 """ 

337 flavor_max_sockets, image_max_sockets = _get_flavor_image_meta( 

338 'cpu_max_sockets', flavor, image_meta, 0) 

339 flavor_max_cores, image_max_cores = _get_flavor_image_meta( 

340 'cpu_max_cores', flavor, image_meta, 0) 

341 flavor_max_threads, image_max_threads = _get_flavor_image_meta( 

342 'cpu_max_threads', flavor, image_meta, 0) 

343 # image metadata is already of the correct type 

344 try: 

345 flavor_max_sockets = int(flavor_max_sockets) 

346 flavor_max_cores = int(flavor_max_cores) 

347 flavor_max_threads = int(flavor_max_threads) 

348 except ValueError as e: 

349 msg = _('Invalid flavor extra spec. Error: %s') % str(e) 

350 raise exception.InvalidRequest(msg) 

351 

352 LOG.debug("Flavor limits %(sockets)d:%(cores)d:%(threads)d", 

353 {"sockets": flavor_max_sockets, 

354 "cores": flavor_max_cores, 

355 "threads": flavor_max_threads}) 

356 LOG.debug("Image limits %(sockets)d:%(cores)d:%(threads)d", 

357 {"sockets": image_max_sockets, 

358 "cores": image_max_cores, 

359 "threads": image_max_threads}) 

360 

361 # Image limits are not permitted to exceed the flavor 

362 # limits. ie they can only lower what the flavor defines 

363 if ((flavor_max_sockets and image_max_sockets > flavor_max_sockets) or 

364 (flavor_max_cores and image_max_cores > flavor_max_cores) or 

365 (flavor_max_threads and image_max_threads > flavor_max_threads)): 

366 raise exception.ImageVCPULimitsRangeExceeded( 

367 image_sockets=image_max_sockets, 

368 image_cores=image_max_cores, 

369 image_threads=image_max_threads, 

370 flavor_sockets=flavor_max_sockets, 

371 flavor_cores=flavor_max_cores, 

372 flavor_threads=flavor_max_threads) 

373 

374 max_sockets = image_max_sockets or flavor_max_sockets or 65536 

375 max_cores = image_max_cores or flavor_max_cores or 65536 

376 max_threads = image_max_threads or flavor_max_threads or 65536 

377 

378 flavor_sockets, image_sockets = _get_flavor_image_meta( 

379 'cpu_sockets', flavor, image_meta, 0) 

380 flavor_cores, image_cores = _get_flavor_image_meta( 

381 'cpu_cores', flavor, image_meta, 0) 

382 flavor_threads, image_threads = _get_flavor_image_meta( 

383 'cpu_threads', flavor, image_meta, 0) 

384 try: 

385 flavor_sockets = int(flavor_sockets) 

386 flavor_cores = int(flavor_cores) 

387 flavor_threads = int(flavor_threads) 

388 except ValueError as e: 

389 msg = _('Invalid flavor extra spec. Error: %s') % str(e) 

390 raise exception.InvalidRequest(msg) 

391 

392 LOG.debug("Flavor pref %(sockets)d:%(cores)d:%(threads)d", 

393 {"sockets": flavor_sockets, 

394 "cores": flavor_cores, 

395 "threads": flavor_threads}) 

396 LOG.debug("Image pref %(sockets)d:%(cores)d:%(threads)d", 

397 {"sockets": image_sockets, 

398 "cores": image_cores, 

399 "threads": image_threads}) 

400 

401 # If the image limits have reduced the flavor limits we might need 

402 # to discard the preferred topology from the flavor 

403 if ((flavor_sockets > max_sockets) or 

404 (flavor_cores > max_cores) or 

405 (flavor_threads > max_threads)): 

406 flavor_sockets = flavor_cores = flavor_threads = 0 

407 

408 # However, image topology is not permitted to exceed image/flavor 

409 # limits 

410 if ((image_sockets > max_sockets) or 

411 (image_cores > max_cores) or 

412 (image_threads > max_threads)): 

413 raise exception.ImageVCPUTopologyRangeExceeded( 

414 image_sockets=image_sockets, 

415 image_cores=image_cores, 

416 image_threads=image_threads, 

417 max_sockets=max_sockets, 

418 max_cores=max_cores, 

419 max_threads=max_threads) 

420 

421 # If no preferred topology was set against the image then use the 

422 # preferred topology from the flavor. We use 'not or' rather than 

423 # 'not and', since if any value is set against the image this 

424 # invalidates the entire set of values from the flavor 

425 if not any((image_sockets, image_cores, image_threads)): 

426 sockets = flavor_sockets 

427 cores = flavor_cores 

428 threads = flavor_threads 

429 else: 

430 sockets = image_sockets 

431 cores = image_cores 

432 threads = image_threads 

433 

434 LOG.debug('Chose sockets=%(sockets)d, cores=%(cores)d, ' 

435 'threads=%(threads)d; limits were sockets=%(maxsockets)d, ' 

436 'cores=%(maxcores)d, threads=%(maxthreads)d', 

437 {"sockets": sockets, "cores": cores, 

438 "threads": threads, "maxsockets": max_sockets, 

439 "maxcores": max_cores, "maxthreads": max_threads}) 

440 

441 return (objects.VirtCPUTopology(sockets=sockets, cores=cores, 

442 threads=threads), 

443 objects.VirtCPUTopology(sockets=max_sockets, cores=max_cores, 

444 threads=max_threads)) 

445 

446 

447def _get_possible_cpu_topologies(vcpus, maxtopology, 

448 allow_threads): 

449 """Get a list of possible topologies for a vCPU count. 

450 

451 Given a total desired vCPU count and constraints on the maximum 

452 number of sockets, cores and threads, return a list of 

453 objects.VirtCPUTopology instances that represent every possible 

454 topology that satisfies the constraints. 

455 

456 :param vcpus: total number of CPUs for guest instance 

457 :param maxtopology: objects.VirtCPUTopology instance for upper 

458 limits 

459 :param allow_threads: True if the hypervisor supports CPU threads 

460 

461 :raises: exception.ImageVCPULimitsRangeImpossible if it is 

462 impossible to achieve the total vcpu count given 

463 the maximum limits on sockets, cores and threads 

464 :returns: list of objects.VirtCPUTopology instances 

465 """ 

466 # Clamp limits to number of vcpus to prevent 

467 # iterating over insanely large list 

468 maxsockets = min(vcpus, maxtopology.sockets) 

469 maxcores = min(vcpus, maxtopology.cores) 

470 maxthreads = min(vcpus, maxtopology.threads) 

471 

472 if not allow_threads: 

473 maxthreads = 1 

474 

475 LOG.debug("Build topologies for %(vcpus)d vcpu(s) " 

476 "%(maxsockets)d:%(maxcores)d:%(maxthreads)d", 

477 {"vcpus": vcpus, "maxsockets": maxsockets, 

478 "maxcores": maxcores, "maxthreads": maxthreads}) 

479 

480 # Figure out all possible topologies that match 

481 # the required vcpus count and satisfy the declared 

482 # limits. If the total vCPU count were very high 

483 # it might be more efficient to factorize the vcpu 

484 # count and then only iterate over its factors, but 

485 # that's overkill right now 

486 possible = [] 

487 for s in range(1, maxsockets + 1): 

488 for c in range(1, maxcores + 1): 

489 for t in range(1, maxthreads + 1): 

490 if (t * c * s) != vcpus: 

491 continue 

492 possible.append( 

493 objects.VirtCPUTopology(sockets=s, 

494 cores=c, 

495 threads=t)) 

496 

497 # We want to 

498 # - Minimize threads (ie larger sockets * cores is best) 

499 # - Prefer sockets over cores 

500 possible = sorted(possible, reverse=True, 

501 key=lambda x: (x.sockets * x.cores, 

502 x.sockets, 

503 x.threads)) 

504 

505 LOG.debug("Got %d possible topologies", len(possible)) 

506 if len(possible) == 0: 

507 raise exception.ImageVCPULimitsRangeImpossible(vcpus=vcpus, 

508 sockets=maxsockets, 

509 cores=maxcores, 

510 threads=maxthreads) 

511 

512 return possible 

513 

514 

515def _sort_possible_cpu_topologies(possible, wanttopology): 

516 """Sort the topologies in order of preference. 

517 

518 Sort the provided list of possible topologies such that the 

519 configurations which most closely match the preferred topology are 

520 first. 

521 

522 :param possible: list of objects.VirtCPUTopology instances 

523 :param wanttopology: objects.VirtCPUTopology instance for preferred 

524 topology 

525 

526 :returns: sorted list of nova.objects.VirtCPUTopology instances 

527 """ 

528 

529 # Look at possible topologies and score them according 

530 # to how well they match the preferred topologies 

531 # We don't use python's sort(), since we want to 

532 # preserve the sorting done when populating the 

533 # 'possible' list originally 

534 scores: ty.Dict[int, ty.List['objects.VirtCPUTopology']] = ( 

535 collections.defaultdict(list) 

536 ) 

537 for topology in possible: 

538 score = _score_cpu_topology(topology, wanttopology) 

539 scores[score].append(topology) 

540 

541 # Build list of all possible topologies sorted 

542 # by the match score, best match first 

543 desired = [] 

544 desired.extend(scores[3]) 

545 desired.extend(scores[2]) 

546 desired.extend(scores[1]) 

547 desired.extend(scores[0]) 

548 

549 return desired 

550 

551 

552def _get_desirable_cpu_topologies(flavor, image_meta, allow_threads=True): 

553 """Identify desirable CPU topologies based for given constraints. 

554 

555 Look at the properties set in the flavor extra specs and the image 

556 metadata and build up a list of all possible valid CPU topologies 

557 that can be used in the guest. Then return this list sorted in 

558 order of preference. 

559 

560 :param flavor: objects.Flavor instance to query extra specs from 

561 :param image_meta: nova.objects.ImageMeta object instance 

562 :param allow_threads: if the hypervisor supports CPU threads 

563 

564 :returns: sorted list of objects.VirtCPUTopology instances 

565 """ 

566 

567 LOG.debug("Getting desirable topologies for flavor %(flavor)s " 

568 "and image_meta %(image_meta)s, allow threads: %(threads)s", 

569 {"flavor": flavor, "image_meta": image_meta, 

570 "threads": allow_threads}) 

571 

572 preferred, maximum = get_cpu_topology_constraints(flavor, image_meta) 

573 LOG.debug("Topology preferred %(preferred)s, maximum %(maximum)s", 

574 {"preferred": preferred, "maximum": maximum}) 

575 

576 possible = _get_possible_cpu_topologies(flavor.vcpus, 

577 maximum, 

578 allow_threads) 

579 LOG.debug("Possible topologies %s", possible) 

580 desired = _sort_possible_cpu_topologies(possible, preferred) 

581 LOG.debug("Sorted desired topologies %s", desired) 

582 return desired 

583 

584 

585def get_best_cpu_topology(flavor, image_meta, allow_threads=True): 

586 """Identify best CPU topology for given constraints. 

587 

588 Look at the properties set in the flavor extra specs and the image 

589 metadata and build up a list of all possible valid CPU topologies 

590 that can be used in the guest. Then return the best topology to use 

591 

592 :param flavor: objects.Flavor instance to query extra specs from 

593 :param image_meta: nova.objects.ImageMeta object instance 

594 :param allow_threads: if the hypervisor supports CPU threads 

595 

596 :returns: an objects.VirtCPUTopology instance for best topology 

597 """ 

598 return _get_desirable_cpu_topologies( 

599 flavor, image_meta, allow_threads)[0] 

600 

601 

602def _numa_cell_supports_pagesize_request(host_cell, inst_cell): 

603 """Determine whether the cell can accept the request. 

604 

605 :param host_cell: host cell to fit the instance cell onto 

606 :param inst_cell: instance cell we want to fit 

607 

608 :raises: exception.MemoryPageSizeNotSupported if custom page 

609 size not supported in host cell 

610 :returns: the page size able to be handled by host_cell 

611 """ 

612 avail_pagesize = [page.size_kb for page in host_cell.mempages] 

613 avail_pagesize.sort(reverse=True) 

614 

615 def verify_pagesizes(host_cell, inst_cell, avail_pagesize): 

616 inst_cell_mem = inst_cell.memory * units.Ki 

617 for pagesize in avail_pagesize: 

618 if host_cell.can_fit_pagesize(pagesize, inst_cell_mem): 

619 return pagesize 

620 

621 if inst_cell.pagesize == MEMPAGES_SMALL: 

622 return verify_pagesizes(host_cell, inst_cell, avail_pagesize[-1:]) 

623 elif inst_cell.pagesize == MEMPAGES_LARGE: 

624 return verify_pagesizes(host_cell, inst_cell, avail_pagesize[:-1]) 

625 elif inst_cell.pagesize == MEMPAGES_ANY: 

626 return verify_pagesizes(host_cell, inst_cell, avail_pagesize) 

627 else: 

628 return verify_pagesizes(host_cell, inst_cell, [inst_cell.pagesize]) 

629 

630 

631def _pack_instance_onto_cores(host_cell, instance_cell, 

632 num_cpu_reserved=0): 

633 """Pack an instance onto a set of siblings. 

634 

635 Calculate the pinning for the given instance and its topology, 

636 making sure that hyperthreads of the instance match up with those 

637 of the host when the pinning takes effect. Also ensure that the 

638 physical cores reserved for hypervisor on this host NUMA node do 

639 not break any thread policies. 

640 

641 Currently the strategy for packing is to prefer siblings and try use 

642 cores evenly by using emptier cores first. This is achieved by the 

643 way we order cores in the sibling_sets structure, and the order in 

644 which we iterate through it. 

645 

646 The main packing loop that iterates over the sibling_sets dictionary 

647 will not currently try to look for a fit that maximizes number of 

648 siblings, but will simply rely on the iteration ordering and picking 

649 the first viable placement. 

650 

651 :param host_cell: objects.NUMACell instance - the host cell that 

652 the instance should be pinned to 

653 :param instance_cell: An instance of objects.InstanceNUMACell 

654 describing the pinning requirements of the 

655 instance 

656 :param num_cpu_reserved: number of pCPUs reserved for hypervisor 

657 

658 :returns: An instance of objects.InstanceNUMACell containing the 

659 pinning information, the physical cores reserved and 

660 potentially a new topology to be exposed to the 

661 instance. None if there is no valid way to satisfy the 

662 sibling requirements for the instance. 

663 """ 

664 # get number of threads per core in host's cell 

665 threads_per_core = max(map(len, host_cell.siblings)) or 1 

666 

667 LOG.debug('Packing an instance onto a set of siblings: ' 

668 ' host_cell_free_siblings: %(siblings)s' 

669 ' instance_cell: %(cells)s' 

670 ' host_cell_id: %(host_cell_id)s' 

671 ' threads_per_core: %(threads_per_core)s' 

672 ' num_cpu_reserved: %(num_cpu_reserved)s', 

673 {'siblings': host_cell.free_siblings, 

674 'cells': instance_cell, 

675 'host_cell_id': host_cell.id, 

676 'threads_per_core': threads_per_core, 

677 'num_cpu_reserved': num_cpu_reserved}) 

678 

679 # We build up a data structure that answers the question: 'Given the 

680 # number of threads I want to pack, give me a list of all the available 

681 # sibling sets (or groups thereof) that can accommodate it' 

682 sibling_sets: ty.Dict[int, ty.List[ty.Set[int]]] = ( 

683 collections.defaultdict(list) 

684 ) 

685 for sib in host_cell.free_siblings: 

686 for threads_no in range(1, len(sib) + 1): 

687 sibling_sets[threads_no].append(sib) 

688 LOG.debug('Built sibling_sets: %(siblings)s', {'siblings': sibling_sets}) 

689 

690 pinning = None 

691 threads_no = 1 

692 

693 def _get_pinning(threads_no, sibling_set, instance_cores): 

694 """Determines pCPUs/vCPUs mapping 

695 

696 Determines the pCPUs/vCPUs mapping regarding the number of 

697 threads which can be used per cores. 

698 

699 :param threads_no: Number of host threads per cores which can 

700 be used to pin vCPUs according to the 

701 policies. 

702 :param sibling_set: List of available threads per host cores 

703 on a specific host NUMA node. 

704 :param instance_cores: Set of vCPUs requested. 

705 

706 NOTE: Depending on how host is configured (HT/non-HT) a thread can 

707 be considered as an entire core. 

708 """ 

709 if threads_no * len(sibling_set) < (len(instance_cores)): 

710 return None 

711 

712 # Determines usable cores according the "threads number" 

713 # constraint. 

714 # 

715 # For a sibling_set=[(0, 1, 2, 3), (4, 5, 6, 7)] and thread_no 1: 

716 # usable_cores=[[0], [4]] 

717 # 

718 # For a sibling_set=[(0, 1, 2, 3), (4, 5, 6, 7)] and thread_no 2: 

719 # usable_cores=[[0, 1], [4, 5]] 

720 usable_cores = list(map(lambda s: list(s)[:threads_no], sibling_set)) 

721 

722 # Determines the mapping vCPUs/pCPUs based on the sets of 

723 # usable cores. 

724 # 

725 # For an instance_cores=[2, 3], usable_cores=[[0], [4]] 

726 # vcpus_pinning=[(2, 0), (3, 4)] 

727 vcpus_pinning = list(zip(sorted(instance_cores), 

728 itertools.chain(*usable_cores))) 

729 msg = ("Computed NUMA topology CPU pinning: usable pCPUs: " 

730 "%(usable_cores)s, vCPUs mapping: %(vcpus_pinning)s") 

731 msg_args = { 

732 'usable_cores': usable_cores, 

733 'vcpus_pinning': vcpus_pinning, 

734 } 

735 LOG.info(msg, msg_args) 

736 

737 return vcpus_pinning 

738 

739 def _get_reserved(sibling_set, vcpus_pinning, num_cpu_reserved=0, 

740 cpu_thread_isolate=False): 

741 """Given available sibling_set, returns the pCPUs reserved 

742 for hypervisor. 

743 

744 :param sibling_set: List of available threads per host cores 

745 on a specific host NUMA node. 

746 :param vcpus_pinning: List of tuple of (pCPU, vCPU) mapping. 

747 :param num_cpu_reserved: Number of additional host CPUs which 

748 need to be reserved. 

749 :param cpu_thread_isolate: True if CPUThreadAllocationPolicy 

750 is ISOLATE. 

751 """ 

752 if not vcpus_pinning: 

753 return None 

754 

755 cpuset_reserved = None 

756 usable_cores = list(map(lambda s: list(s), sibling_set)) 

757 

758 if num_cpu_reserved: 

759 # Updates the pCPUs used based on vCPUs pinned to. 

760 # For the case vcpus_pinning=[(0, 0), (1, 2)] and 

761 # usable_cores=[[0, 1], [2, 3], [4, 5]], 

762 # if CPUThreadAllocationPolicy is isolated, we want 

763 # to update usable_cores=[[4, 5]]. 

764 # If CPUThreadAllocationPolicy is *not* isolated, 

765 # we want to update usable_cores=[[1],[3],[4, 5]]. 

766 for vcpu, pcpu in vcpus_pinning: 

767 for sib in usable_cores: 

768 if pcpu in sib: 

769 if cpu_thread_isolate: 

770 usable_cores.remove(sib) 

771 else: 

772 sib.remove(pcpu) 

773 

774 # Determines the pCPUs reserved for hypervisor 

775 # 

776 # For usable_cores=[[1],[3],[4, 5]], num_cpu_reserved=1 

777 # cpuset_reserved=set([1]) 

778 cpuset_reserved = set(list( 

779 itertools.chain(*usable_cores))[:num_cpu_reserved]) 

780 msg = ("Computed NUMA topology reserved pCPUs: usable pCPUs: " 

781 "%(usable_cores)s, reserved pCPUs: %(cpuset_reserved)s") 

782 msg_args = { 

783 'usable_cores': usable_cores, 

784 'cpuset_reserved': cpuset_reserved, 

785 } 

786 LOG.info(msg, msg_args) 

787 

788 return cpuset_reserved or None 

789 

790 if (instance_cell.cpu_thread_policy == 

791 fields.CPUThreadAllocationPolicy.REQUIRE): 

792 LOG.debug("Requested 'require' thread policy for %d cores", 

793 len(instance_cell)) 

794 elif (instance_cell.cpu_thread_policy == 

795 fields.CPUThreadAllocationPolicy.PREFER): 

796 LOG.debug("Requested 'prefer' thread policy for %d cores", 

797 len(instance_cell)) 

798 elif (instance_cell.cpu_thread_policy == 

799 fields.CPUThreadAllocationPolicy.ISOLATE): 

800 LOG.debug("Requested 'isolate' thread policy for %d cores", 

801 len(instance_cell)) 

802 else: 

803 LOG.debug("User did not specify a thread policy. Using default " 

804 "for %d cores", len(instance_cell)) 

805 

806 if (instance_cell.cpu_thread_policy == 

807 fields.CPUThreadAllocationPolicy.ISOLATE): 

808 # make sure we have at least one fully free core 

809 if threads_per_core not in sibling_sets: 

810 LOG.debug('Host does not have any fully free thread sibling sets.' 

811 'It is not possible to emulate a non-SMT behavior ' 

812 'for the isolate policy without this.') 

813 return 

814 

815 # TODO(stephenfin): Drop this when we drop support for 'vcpu_pin_set' 

816 # NOTE(stephenfin): This is total hack. We're relying on the fact that 

817 # the libvirt driver, which is the only one that currently supports 

818 # pinned CPUs, will set cpuset and pcpuset to the same value if using 

819 # legacy configuration, i.e. 'vcpu_pin_set', as part of 

820 # '_get_host_numa_topology'. They can't be equal otherwise since 

821 # 'cpu_dedicated_set' and 'cpu_shared_set' must be disjoint. Therefore, 

822 # if these are equal, the host that this NUMA cell corresponds to is 

823 # using legacy configuration and it's okay to use the old, "pin a core 

824 # and reserve its siblings" implementation of the 'isolate' policy. If 

825 # they're not, the host is using new-style configuration and we've just 

826 # hit bug #1889633 

827 if threads_per_core != 1 and host_cell.pcpuset != host_cell.cpuset: 

828 LOG.warning( 

829 "Host supports hyperthreads, but instance requested no " 

830 "hyperthreads. This should have been rejected by the " 

831 "scheduler but we likely got here due to the fallback VCPU " 

832 "query. Consider setting '[workarounds] " 

833 "disable_fallback_pcpu_query' to 'True' once hosts are no " 

834 "longer using 'vcpu_pin_set'. Refer to bug #1889633 for more " 

835 "information." 

836 ) 

837 return 

838 

839 pinning = _get_pinning( 

840 1, # we only want to "use" one thread per core 

841 sibling_sets[threads_per_core], 

842 instance_cell.pcpuset) 

843 cpuset_reserved = _get_reserved( 

844 sibling_sets[1], pinning, num_cpu_reserved=num_cpu_reserved, 

845 cpu_thread_isolate=True) 

846 if not pinning or (num_cpu_reserved and not cpuset_reserved): 

847 pinning, cpuset_reserved = (None, None) 

848 

849 else: # REQUIRE, PREFER (explicit, implicit) 

850 if (instance_cell.cpu_thread_policy == 

851 fields.CPUThreadAllocationPolicy.REQUIRE): 

852 # make sure we actually have some siblings to play with 

853 if threads_per_core <= 1: 

854 LOG.info("Host does not support hyperthreading or " 

855 "hyperthreading is disabled, but 'require' " 

856 "threads policy was requested.") 

857 return 

858 

859 # NOTE(ndipanov): We iterate over the sibling sets in descending order 

860 # of cores that can be packed. This is an attempt to evenly distribute 

861 # instances among physical cores 

862 for threads_no, sibling_set in sorted( 

863 (t for t in sibling_sets.items()), reverse=True): 

864 

865 # NOTE(sfinucan): The key difference between the require and 

866 # prefer policies is that require will not settle for non-siblings 

867 # if this is all that is available. Enforce this by ensuring we're 

868 # using sibling sets that contain at least one sibling 

869 if (instance_cell.cpu_thread_policy == 

870 fields.CPUThreadAllocationPolicy.REQUIRE): 

871 if threads_no <= 1: 

872 LOG.debug('Skipping threads_no: %s, as it does not satisfy' 

873 ' the require policy', threads_no) 

874 continue 

875 

876 pinning = _get_pinning( 

877 threads_no, sibling_set, 

878 instance_cell.pcpuset) 

879 cpuset_reserved = _get_reserved( 

880 sibling_sets[1], pinning, num_cpu_reserved=num_cpu_reserved) 

881 if pinning is None or (num_cpu_reserved and not cpuset_reserved): 

882 continue 

883 break 

884 

885 # NOTE(sfinucan): If siblings weren't available and we're using PREFER 

886 # (implicitly or explicitly), fall back to linear assignment across 

887 # cores 

888 if (instance_cell.cpu_thread_policy != 

889 fields.CPUThreadAllocationPolicy.REQUIRE and 

890 not pinning): 

891 # we create a fake sibling set by splitting all sibling sets and 

892 # treating each core as if it has no siblings. This is necessary 

893 # because '_get_pinning' will normally only take the same amount of 

894 # cores ('threads_no' cores) from each sibling set. This is rather 

895 # desirable when we're seeking to apply a thread policy but it is 

896 # less desirable when we only care about resource usage as we do 

897 # here. By treating each core as independent, as we do here, we 

898 # maximize resource usage for almost-full nodes at the expense of a 

899 # possible performance impact to the guest. 

900 sibling_set = [set([x]) for x in itertools.chain(*sibling_sets[1])] 

901 pinning = _get_pinning( 

902 threads_no, sibling_set, 

903 instance_cell.pcpuset) 

904 cpuset_reserved = _get_reserved( 

905 sibling_set, pinning, num_cpu_reserved=num_cpu_reserved) 

906 

907 if pinning is None or (num_cpu_reserved and not cpuset_reserved): 

908 return 

909 LOG.debug('Selected cores for pinning: %s, in cell %s', pinning, 

910 host_cell.id) 

911 

912 instance_cell.pin_vcpus(*pinning) 

913 instance_cell.id = host_cell.id 

914 instance_cell.cpuset_reserved = cpuset_reserved 

915 return instance_cell 

916 

917 

918def _numa_fit_instance_cell( 

919 host_cell: 'objects.NUMACell', 

920 instance_cell: 'objects.InstanceNUMACell', 

921 limits: ty.Optional['objects.NUMATopologyLimit'] = None, 

922 cpuset_reserved: int = 0, 

923) -> ty.Optional['objects.InstanceNUMACell']: 

924 """Ensure an instance cell can fit onto a host cell 

925 

926 Ensure an instance cell can fit onto a host cell and, if so, return 

927 a new objects.InstanceNUMACell with the id set to that of the host. 

928 Returns None if the instance cell exceeds the limits of the host. 

929 

930 :param host_cell: host cell to fit the instance cell onto 

931 :param instance_cell: instance cell we want to fit 

932 :param limits: an objects.NUMATopologyLimit or None 

933 :param cpuset_reserved: An int to indicate the number of CPUs overhead 

934 

935 :returns: objects.InstanceNUMACell with the id set to that of the 

936 host, or None 

937 """ 

938 LOG.debug('Attempting to fit instance cell %(cell)s on host_cell ' 

939 '%(host_cell)s', {'cell': instance_cell, 'host_cell': host_cell}) 

940 

941 if 'pagesize' in instance_cell and instance_cell.pagesize: 

942 # The instance has requested a page size. Verify that the requested 

943 # size is valid and that there are available pages of that size on the 

944 # host. 

945 pagesize = _numa_cell_supports_pagesize_request( 

946 host_cell, instance_cell) 

947 if not pagesize: 

948 LOG.debug('Host does not support requested memory pagesize, ' 

949 'or not enough free pages of the requested size. ' 

950 'Requested memory pagesize: %d ' 

951 '(small = -1, large = -2, any = -3)', 

952 instance_cell.pagesize) 

953 return None 

954 LOG.debug('Selected memory pagesize: %(selected_mem_pagesize)d kB. '