Coverage for pyEDAA/OutputFilter/Xilinx/PlaceDesign.py: 100%

1# ==================================================================================================================== # 

2# _____ ____ _ _ ___ _ _ _____ _ _ _ # 

3# _ __ _ _| ____| _ \ / \ / \ / _ \ _ _| |_ _ __ _ _| |_| ___(_) | |_ ___ _ __ # 

4# | '_ \| | | | _| | | | |/ _ \ / _ \ | | | | | | | __| '_ \| | | | __| |_ | | | __/ _ \ '__| # 

5# | |_) | |_| | |___| |_| / ___ \ / ___ \ | |_| | |_| | |_| |_) | |_| | |_| _| | | | || __/ | # 

6# | .__/ \__, |_____|____/_/ \_\/_/ \_(_)___/ \__,_|\__| .__/ \__,_|\__|_| |_|_|\__\___|_| # 

7# |_| |___/ |_| # 

8# ==================================================================================================================== # 

9# Authors: # 

10# Patrick Lehmann # 

11# # 

12# License: # 

13# ==================================================================================================================== # 

14# Copyright 2025-2026 Electronic Design Automation Abstraction (EDA²) # 

15# # 

16# Licensed under the Apache License, Version 2.0 (the "License"); # 

17# you may not use this file except in compliance with the License. # 

18# You may obtain a copy of the License at # 

19# # 

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

21# # 

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

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

24# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # 

25# See the License for the specific language governing permissions and # 

26# limitations under the License. # 

27# # 

28# SPDX-License-Identifier: Apache-2.0 # 

29# ==================================================================================================================== # 

30# 

31"""A filtering anc classification processor for AMD/Xilinx Vivado Synthesis outputs.""" 

32from re import compile, Pattern 

33from typing import ClassVar, Type, Tuple 

34 

35from pyTooling.Decorators import export 

36 

37from pyEDAA.OutputFilter.Xilinx.Common2 import TaskWithPhases, NestedPhase, NestedTaskWithPhases, SubSubSubPhaseWithTasks 

38from pyEDAA.OutputFilter.Xilinx.Common2 import Phase, SubPhase, SubSubPhase, SubSubSubPhase 

39from pyEDAA.OutputFilter.Xilinx.Common2 import PhaseWithChildren, SubPhaseWithChildren, SubSubPhaseWithChildren 

40from pyEDAA.OutputFilter.Xilinx.Common2 import MAJOR, MAJOR_MINOR, MAJOR_MINOR_MICRO, MAJOR_MINOR_MICRO_NANO 

41 

42 

43@export 

44class SubPhase_PlacerInitializationNetlistSorting(SubPhase): 

45 """ 

46 *Placer Initialization Netlist Sorting* subphase. 

47 

48 Used by phase :class:`Phase_PlacerInitialization`. 

49 """ 

50 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Placer Initialization Netlist Sorting") 

51 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Placer Initialization Netlist Sorting | Checksum:" 

52 _TIME: ClassVar[str] = "Time (s):" 

53 

54 

55@export 

56class SubPhase_IOPlacement_ClockPlacement_BuildPlacerDevice(SubPhase): 

57 """ 

58 *IO Placement/ Clock Placement/ Build Placer Device* subphase. 

59 

60 Used by phase :class:`Phase_PlacerInitialization`. 

61 """ 

62 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} IO Placement/ Clock Placement/ Build Placer Device") 

63 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} IO Placement/ Clock Placement/ Build Placer Device | Checksum:" 

64 _TIME: ClassVar[str] = "Time (s):" 

65 

66 

67@export 

68class SubPhase_BuildPlacerNetlistModel(SubPhase): 

69 """ 

70 *Build Placer Netlist Model* subphase. 

71 

72 Used by phase :class:`Phase_PlacerInitialization`. 

73 """ 

74 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Build Placer Netlist Model") 

75 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Build Placer Netlist Model | Checksum:" 

76 _TIME: ClassVar[str] = "Time (s):" 

77 

78 

79@export 

80class SubPhase_ConstrainClocks_Macros(SubPhase): 

81 """ 

82 *Constrain Clocks/Macros* subphase. 

83 

84 Used by phase :class:`Phase_PlacerInitialization`. 

85 """ 

86 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Constrain Clocks/Macros") 

87 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Constrain Clocks/Macros | Checksum:" 

88 _TIME: ClassVar[str] = "Time (s):" 

89 

90 

91@export 

92class Phase_PlacerInitialization(PhaseWithChildren): 

93 """ 

94 *Placer Initialization* phase. 

95 

96 .. rubric:: Uses 

97 

98 * :class:`SubPhase_PlacerInitializationNetlistSorting` 

99 * :class:`SubPhase_IOPlacement_ClockPlacement_BuildPlacerDevice` 

100 * :class:`SubPhase_BuildPlacerNetlistModel` 

101 * :class:`SubPhase_ConstrainClocks_Macros` 

102 

103 Used by task :class:`PlacerTask`. 

104 """ 

105 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Placer Initialization") 

106 _FINISH: ClassVar[str] = "Phase {phaseIndex} Placer Initialization | Checksum:" 

107 _TIME: ClassVar[str] = "Time (s):" 

108 _FINAL: ClassVar[str] = None 

109 

110 _PARSERS: ClassVar[Tuple[Type[SubPhase], ...]] = ( 

111 SubPhase_PlacerInitializationNetlistSorting, 

112 SubPhase_IOPlacement_ClockPlacement_BuildPlacerDevice, 

113 SubPhase_BuildPlacerNetlistModel, 

114 SubPhase_ConstrainClocks_Macros 

115 ) 

116 

117 

118@export 

119class SubPhase_Floorplanning(SubPhase): 

120 """ 

121 *Floorplanning* subphase. 

122 

123 Used by phase :class:`Phase_GlobalPlacement`. 

124 """ 

125 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Floorplanning") 

126 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Floorplanning | Checksum:" 

127 _TIME: ClassVar[str] = "Time (s):" 

128 

129 

130@export 

131class SubPhase_UpdateTimingBeforeSLRPathOpt(SubPhase): 

132 """ 

133 *Update Timing before SLR Path Opt* subphase. 

134 

135 Used by phase :class:`Phase_GlobalPlacement`. 

136 """ 

137 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Update Timing before SLR Path Opt") 

138 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Update Timing before SLR Path Opt | Checksum:" 

139 _TIME: ClassVar[str] = "Time (s):" 

140 

141 

142@export 

143class SubPhase_PostProcessingInFloorplanning(SubPhase): 

144 """ 

145 *Post-Processing in Floorplanning* subphase. 

146 

147 Used by phase :class:`Phase_GlobalPlacement`. 

148 """ 

149 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Post-Processing in Floorplanning") 

150 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Post-Processing in Floorplanning | Checksum:" 

151 _TIME: ClassVar[str] = "Time (s):" 

152 

153 

154@export 

155class SubSubPhase_UpdateTimingBeforePhysicalSynthesis(SubSubPhase): 

156 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR_MICRO} UpdateTiming Before Physical Synthesis") 

157 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex}.{subSubPhaseIndex} UpdateTiming Before Physical Synthesis | Checksum:" 

158 _TIME: ClassVar[str] = "Time (s):" 

159 

160 

161@export 

162class SubSubPhase_PhysicalSynthesisInPlacer(SubSubPhase): 

163 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR_MICRO} Physical Synthesis In Placer") 

164 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex}.{subSubPhaseIndex} Physical Synthesis In Placer | Checksum:" 

165 _TIME: ClassVar[str] = "Time (s):" 

166 

167 

168@export 

169class SubPhase_GlobalPlacementCore(SubPhaseWithChildren): 

170 """ 

171 *Global Placement Core* subphase. 

172 

173 Used by phase :class:`Phase_GlobalPlacement`. 

174 """ 

175 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Global Placement Core") 

176 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Global Placement Core | Checksum:" 

177 _TIME: ClassVar[str] = "Time (s):" 

178 

179 _PARSERS: ClassVar[Tuple[Type[SubSubPhase], ...]] = ( 

180 SubSubPhase_UpdateTimingBeforePhysicalSynthesis, 

181 SubSubPhase_PhysicalSynthesisInPlacer 

182 ) 

183 

184 

185@export 

186class SubPhase_GlobalPlacePhase1(SubPhase): 

187 """ 

188 *Global Place Phase1* subphase. 

189 

190 Used by phase :class:`Phase_GlobalPlacement`. 

191 """ 

192 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Global Place Phase1") 

193 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Global Place Phase1 | Checksum:" 

194 _TIME: ClassVar[str] = "Time (s):" 

195 

196 

197# @export 

198# class SubSubPhase_UpdateTimingBeforePhysicalSynthesis(SubSubPhase): 

199# _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR_MICRO} UpdateTiming Before Physical Synthesis") 

200# _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex}.{subSubPhaseIndex} UpdateTiming Before Physical Synthesis | Checksum:" 

201# _TIME: ClassVar[str] = "Time (s):" 

202 

203 

204# @export 

205# class SubSubPhase_PhysicalSynthesisInPlacer(SubSubPhase): 

206# _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR_MICRO} Physical Synthesis In Placer") 

207# _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex}.{subSubPhaseIndex} Physical Synthesis In Placer | Checksum:" 

208# _TIME: ClassVar[str] = "Time (s):" 

209 

210 

211@export 

212class SubPhase_GlobalPlacePhase2(SubPhaseWithChildren): 

213 """ 

214 *Global Place Phase2* subphase. 

215 

216 Used by phase :class:`Phase_GlobalPlacement`. 

217 """ 

218 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Global Place Phase2") 

219 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Global Place Phase2 | Checksum:" 

220 _TIME: ClassVar[str] = "Time (s):" 

221 

222 _PARSERS: ClassVar[Tuple[Type[SubSubPhase], ...]] = ( 

223 SubSubPhase_UpdateTimingBeforePhysicalSynthesis, 

224 SubSubPhase_PhysicalSynthesisInPlacer 

225 ) 

226 

227 

228@export 

229class Phase_GlobalPlacement(PhaseWithChildren): 

230 """ 

231 *Global Placement* phase. 

232 

233 .. rubric:: Uses 

234 

235 * :class:`SubPhase_Floorplanning` 

236 * :class:`SubPhase_UpdateTimingBeforeSLRPathOpt` 

237 * :class:`SubPhase_PostProcessingInFloorplanning` 

238 * :class:`SubPhase_GlobalPlacePhase1` 

239 * :class:`SubPhase_GlobalPlacePhase2` 

240 * :class:`SubPhase_GlobalPlacementCore` 

241 

242 Used by task :class:`PlacerTask`. 

243 """ 

244 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Global Placement") 

245 _FINISH: ClassVar[str] = "Phase {phaseIndex} Global Placement | Checksum:" 

246 _TIME: ClassVar[str] = "Time (s):" 

247 _FINAL: ClassVar[str] = None 

248 

249 _PARSERS: ClassVar[Tuple[Type[SubPhase], ...]] = ( 

250 SubPhase_Floorplanning, 

251 SubPhase_UpdateTimingBeforeSLRPathOpt, 

252 SubPhase_PostProcessingInFloorplanning, 

253 SubPhase_GlobalPlacePhase1, 

254 SubPhase_GlobalPlacePhase2, 

255 SubPhase_GlobalPlacementCore 

256 ) 

257 

258 

259@export 

260class SubPhase_CommitMultiColumnMacros(SubPhase): 

261 """ 

262 *Commit Multi Column Macros* subphase. 

263 

264 Used by phase :class:`Phase_DetailPlacement`. 

265 """ 

266 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Commit Multi Column Macros") 

267 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Commit Multi Column Macros | Checksum:" 

268 _TIME: ClassVar[str] = "Time (s):" 

269 

270 

271@export 

272class SubPhase_CommitMostMacrosLUTRAMs(SubPhase): 

273 """ 

274 *Commit Most Macros & LUTRAMs* subphase. 

275 

276 Used by phase :class:`Phase_DetailPlacement`. 

277 """ 

278 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Commit Most Macros & LUTRAMs") 

279 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Commit Most Macros & LUTRAMs | Checksum:" 

280 _TIME: ClassVar[str] = "Time (s):" 

281 

282 

283@export 

284class SubSubPhase_SmallShapeClustering(SubSubPhase): 

285 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR_MICRO} Small Shape Clustering") 

286 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex}.{subSubPhaseIndex} Small Shape Clustering | Checksum:" 

287 _TIME: ClassVar[str] = "Time (s):" 

288 

289 

290@export 

291class SubSubSubPhase_SliceAreaSwapInitial(SubSubSubPhase): 

292 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR_MICRO_NANO} Slice Area Swap Initial") 

293 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex}.{subSubPhaseIndex}.{subSubSubPhaseIndex} Slice Area Swap Initial | Checksum:" 

294 _TIME: ClassVar[str] = "Time (s):" 

295 

296 

297@export 

298class SubSubPhase_SliceAreaSwap(SubSubPhaseWithChildren): 

299 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR_MICRO} Slice Area Swap") 

300 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex}.{subSubPhaseIndex} Slice Area Swap | Checksum:" 

301 _TIME: ClassVar[str] = "Time (s):" 

302 

303 _PARSERS: ClassVar[Tuple[Type[SubSubSubPhase], ...]] = ( 

304 SubSubSubPhase_SliceAreaSwapInitial, 

305 ) 

306 

307 

308@export 

309class SubPhase_SmallShapeDP(SubPhaseWithChildren): 

310 """ 

311 *Small Shape DP* subphase. 

312 

313 Used by phase :class:`Phase_DetailPlacement`. 

314 """ 

315 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Small Shape DP") 

316 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Small Shape DP | Checksum:" 

317 _TIME: ClassVar[str] = "Time (s):" 

318 

319 _PARSERS: ClassVar[Tuple[Type[SubSubPhase], ...]] = ( 

320 SubSubPhase_SmallShapeClustering, 

321 SubSubPhase_SliceAreaSwap 

322 ) 

323 

324 

325@export 

326class SubPhase_AreaSwapOptimization(SubPhase): 

327 """ 

328 *Area Swap Optimization* subphase. 

329 

330 Used by phase :class:`Phase_DetailPlacement`. 

331 """ 

332 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Area Swap Optimization") 

333 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Area Swap Optimization | Checksum:" 

334 _TIME: ClassVar[str] = "Time (s):" 

335 

336 

337@export 

338class SubPhase_ReassignLUTPins(SubPhase): 

339 """ 

340 *Re-assign LUT pins* subphase. 

341 

342 Used by phase :class:`Phase_DetailPlacement`. 

343 """ 

344 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Re-assign LUT pins") 

345 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Re-assign LUT pins | Checksum:" 

346 _TIME: ClassVar[str] = "Time (s):" 

347 

348 

349@export 

350class SubPhase_PipelineRegisterOptimization_1(SubPhase): 

351 """ 

352 *Floorplanning* subphase. 

353 

354 Used by phase :class:`Phase_DetailPlacement`. 

355 """ 

356 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Pipeline Register Optimization") 

357 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Pipeline Register Optimization | Checksum:" 

358 _TIME: ClassVar[str] = "Time (s):" 

359 

360 

361@export 

362class SubPhase_PipelineRegisterOptimization_2(SubPhase): 

363 """ 

364 *Pipeline Register Optimization* subphase. 

365 

366 Used by phase :class:`Phase_DetailPlacement`. 

367 """ 

368 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Pipeline Register Optimization") 

369 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Pipeline Register Optimization | Checksum:" 

370 _TIME: ClassVar[str] = "Time (s):" 

371 

372 

373@export 

374class SubPhase_FastOptimization_1(SubPhase): 

375 """ 

376 *Fast Optimization* subphase. 

377 

378 Used by phase :class:`Phase_DetailPlacement`. 

379 """ 

380 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Fast Optimization") 

381 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Fast Optimization | Checksum:" 

382 _TIME: ClassVar[str] = "Time (s):" 

383 

384 

385@export 

386class SubPhase_FastOptimization_2(SubPhase): 

387 """ 

388 *Fast Optimization* subphase. 

389 

390 Used by phase :class:`Phase_DetailPlacement`. 

391 """ 

392 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Fast Optimization") 

393 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Fast Optimization | Checksum:" 

394 _TIME: ClassVar[str] = "Time (s):" 

395 

396 

397@export 

398class SubPhase_SmallShapeDetailPlacement(SubPhase): 

399 """ 

400 *Small Shape Detail Placement* subphase. 

401 

402 Used by phase :class:`Phase_DetailPlacement`. 

403 """ 

404 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Small Shape Detail Placement") 

405 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Small Shape Detail Placement | Checksum:" 

406 _TIME: ClassVar[str] = "Time (s):" 

407 

408 

409@export 

410class Phase_DetailPlacement(PhaseWithChildren): 

411 """ 

412 *Detail Placement* phase. 

413 

414 .. rubric:: Uses 

415 

416 * :class:`SubPhase_CommitMultiColumnMacros` 

417 * :class:`SubPhase_CommitMostMacrosLUTRAMs` 

418 * :class:`SubPhase_SmallShapeDP` 

419 * :class:`SubPhase_AreaSwapOptimization` 

420 * :class:`SubPhase_PipelineRegisterOptimization_1` 

421 * :class:`SubPhase_PipelineRegisterOptimization_2` 

422 * :class:`SubPhase_FastOptimization_1` 

423 * :class:`SubPhase_FastOptimization_2` 

424 * :class:`SubPhase_SmallShapeDetailPlacement` 

425 * :class:`SubPhase_ReassignLUTPins` 

426 

427 Used by task :class:`PlacerTask`. 

428 """ 

429 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Detail Placement") 

430 _FINISH: ClassVar[str] = "Phase {phaseIndex} Detail Placement | Checksum:" 

431 _TIME: ClassVar[str] = "Time (s):" 

432 _FINAL: ClassVar[str] = None 

433 

434 _PARSERS: ClassVar[Tuple[Type[SubPhase], ...]] = ( 

435 SubPhase_CommitMultiColumnMacros, 

436 SubPhase_CommitMostMacrosLUTRAMs, 

437 SubPhase_SmallShapeDP, 

438 SubPhase_AreaSwapOptimization, 

439 SubPhase_PipelineRegisterOptimization_1, 

440 SubPhase_PipelineRegisterOptimization_2, 

441 SubPhase_FastOptimization_1, 

442 SubPhase_FastOptimization_2, 

443 SubPhase_SmallShapeDetailPlacement, 

444 SubPhase_ReassignLUTPins 

445 ) 

446 

447 

448@export 

449class NestedPhase_PhysicalSynthesisInitialization(NestedPhase): 

450 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Physical Synthesis Initialization") 

451 _FINISH: ClassVar[str] = "Phase {phaseIndex} Physical Synthesis Initialization | Checksum:" 

452 _TIME: ClassVar[str] = "Time (s):" 

453 

454 

455@export 

456class NestedTask_PhysicalSynthesis(NestedTaskWithPhases): 

457 _START: ClassVar[str] = "Starting Physical Synthesis Task" 

458 _FINISH: ClassVar[str] = "Ending Physical Synthesis Task | Checksum:" 

459 _TIME: ClassVar[str] = "Time (s):" 

460 

461 _PARSERS: ClassVar[Tuple[Type[NestedPhase], ...]] = ( 

462 NestedPhase_PhysicalSynthesisInitialization, 

463 ) 

464 

465 

466@export 

467class SubSubSubPhase_BUFGInsertion(SubSubSubPhaseWithTasks): 

468 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR_MICRO_NANO} BUFG Insertion") 

469 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex}.{subSubPhaseIndex}.{subSubSubPhaseIndex} BUFG Insertion | Checksum:" 

470 _TIME: ClassVar[str] = "Time (s):" 

471 

472 _PARSERS: ClassVar[Tuple[Type[NestedTaskWithPhases], ...]] = ( 

473 NestedTask_PhysicalSynthesis, 

474 ) 

475 

476 

477@export 

478class SubSubSubPhase_PostPlacementTimingOptimization(SubSubSubPhase): 

479 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR_MICRO_NANO} Post Placement Timing Optimization") 

480 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex}.{subSubPhaseIndex}.{subSubSubPhaseIndex} Post Placement Timing Optimization | Checksum:" 

481 _TIME: ClassVar[str] = "Time (s):" 

482 

483 

484@export 

485class SubSubPhase_PostPlacementOptimization(SubSubPhaseWithChildren): 

486 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR_MICRO} Post Placement Optimization") 

487 _FINISH: ClassVar[str] = None # Phase 4.1.1 Post Placement Optimization | Checksum:" 

488 _TIME: ClassVar[str] = "Time (s):" 

489 

490 _PARSERS: ClassVar[Tuple[Type[SubSubSubPhase], ...]] = ( 

491 SubSubSubPhase_BUFGInsertion, 

492 SubSubSubPhase_PostPlacementTimingOptimization 

493 ) 

494 

495 

496@export 

497class SubPhase_PostCommitOptimization(SubPhaseWithChildren): 

498 """ 

499 *Post Commit Optimization* subphase. 

500 

501 Used by phase :class:`Phase_PostPlacementOptimizationAndCleanUp`. 

502 """ 

503 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Post Commit Optimization") 

504 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Post Commit Optimization | Checksum:" 

505 _TIME: ClassVar[str] = "Time (s):" 

506 

507 _PARSERS: ClassVar[Tuple[Type[SubSubPhase], ...]] = ( 

508 SubSubPhase_PostPlacementOptimization, 

509 ) 

510 

511 

512@export 

513class SubPhase_PostPlacementCleanup(SubPhase): 

514 """ 

515 *Post Placement Cleanup* subphase. 

516 

517 Used by phase :class:`Phase_PostPlacementOptimizationAndCleanUp`. 

518 """ 

519 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Post Placement Cleanup") 

520 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Post Placement Cleanup | Checksum:" 

521 _TIME: ClassVar[str] = "Time (s):" 

522 

523 

524@export 

525class SubSubPhase_PrintEstimatedCongestion(SubSubPhase): 

526 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR_MICRO} Print Estimated Congestion") 

527 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex}.{subSubPhaseIndex} Print Estimated Congestion | Checksum:" 

528 _TIME: ClassVar[str] = "Time (s):" 

529 

530 

531@export 

532class SubPhase_PlacerReporting(SubPhaseWithChildren): 

533 """ 

534 *Placer Reporting* subphase. 

535 

536 Used by phase :class:`Phase_PostPlacementOptimizationAndCleanUp`. 

537 """ 

538 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Placer Reporting") 

539 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Placer Reporting | Checksum:" 

540 _TIME: ClassVar[str] = "Time (s):" 

541 

542 _PARSERS: ClassVar[Tuple[Type[SubSubPhase], ...]] = ( 

543 SubSubPhase_PrintEstimatedCongestion, 

544 ) 

545 

546 

547@export 

548class SubPhase_FinalPlacementCleanup(SubPhase): 

549 """ 

550 *Final Placement Cleanup* subphase. 

551 

552 Used by phase :class:`Phase_PostPlacementOptimizationAndCleanUp`. 

553 """ 

554 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Final Placement Cleanup") 

555 _FINISH: ClassVar[str] = "Time (s):" 

556 _TIME: ClassVar[str] = None 

557 

558 

559@export 

560class Phase_PostPlacementOptimizationAndCleanUp(PhaseWithChildren): 

561 """ 

562 *Post Placement Optimization and Clean-Up* phase. 

563 

564 .. rubric:: Uses 

565 

566 * :class:`SubPhase_PostCommitOptimization` 

567 * :class:`SubPhase_PostPlacementCleanup` 

568 * :class:`SubPhase_PlacerReporting` 

569 * :class:`SubPhase_FinalPlacementCleanup` 

570 

571 Used by task :class:`PlacerTask`. 

572 """ 

573 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Post Placement Optimization and Clean-Up") 

574 _FINISH: ClassVar[str] = "Phase {phaseIndex} Post Placement Optimization and Clean-Up | Checksum:" 

575 _TIME: ClassVar[str] = "Time (s):" 

576 _FINAL: ClassVar[str] = None 

577 

578 _PARSERS: ClassVar[Tuple[Type[SubPhase], ...]] = ( 

579 SubPhase_PostCommitOptimization, 

580 SubPhase_PostPlacementCleanup, 

581 SubPhase_PlacerReporting, 

582 SubPhase_FinalPlacementCleanup 

583 ) 

584 

585 

586@export 

587class PlacerTask(TaskWithPhases): 

588 """ 

589 *Placer* task. 

590 

591 .. rubric:: Uses 

592 

593 * :class:`Phase_PlacerInitialization` 

594 * :class:`Phase_GlobalPlacement` 

595 * :class:`Phase_DetailPlacement` 

596 * :class:`Phase_PostPlacementOptimizationAndCleanUp` 

597 

598 Used by Vivado command :class:`~pyEDAA.OutputFilter.Xilinx.Commands.PlaceDesign`. 

599 """ 

600 _START: ClassVar[str] = "Starting Placer Task" 

601 _FINISH: ClassVar[str] = "Ending Placer Task" 

602 

603 _PARSERS: ClassVar[Tuple[Type[Phase], ...]] = ( 

604 Phase_PlacerInitialization, 

605 Phase_GlobalPlacement, 

606 Phase_DetailPlacement, 

607 Phase_PostPlacementOptimizationAndCleanUp 

608 )