Coverage for pyEDAA/OutputFilter/Xilinx/RouteDesign.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 import TaskWithPhases, Phase, SubPhase, PhaseWithChildren, SubPhaseWithChildren 

38from pyEDAA.OutputFilter.Xilinx import MAJOR, MAJOR_MINOR, MAJOR_MINOR_MICRO 

39from pyEDAA.OutputFilter.Xilinx.PlaceDesign import SubSubPhase 

40 

41 

42@export 

43class Phase_BuildRTDesign(Phase): 

44 """ 

45 *Build RT Design* phase. 

46 

47 Used by task :class:`RoutingTask`. 

48 """ 

49 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Build RT Design") 

50 _FINISH: ClassVar[str] = "Phase {phaseIndex} Build RT Design | Checksum:" 

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

52 _FINAL: ClassVar[str] = None 

53 

54 

55@export 

56class SubPhase_CreateTimer(SubPhase): 

57 """ 

58 *Create Timer* subphase. 

59 

60 Used by phase :class:`Phase_RouterInitialization`. 

61 """ 

62 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Create Timer") 

63 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Create Timer | Checksum:" 

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

65 

66 

67@export 

68class SubPhase_FixTopologyConstraints(SubPhase): 

69 """ 

70 *Fix Topology Constraints* subphase. 

71 

72 Used by phase :class:`Phase_RouterInitialization`. 

73 """ 

74 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Fix Topology Constraints") 

75 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Fix Topology Constraints | Checksum:" 

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

77 

78 

79@export 

80class SubPhase_PreRouteCleanup(SubPhase): 

81 """ 

82 *Pre Route Cleanup* subphase. 

83 

84 Used by phase :class:`Phase_RouterInitialization`. 

85 """ 

86 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Pre Route Cleanup") 

87 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Pre Route Cleanup | Checksum:" 

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

89 

90 

91@export 

92class SubPhase_GlobalClockNetRouting(SubPhase): 

93 """ 

94 *Global Clock Net Routing* subphase. 

95 

96 Used by phase :class:`Phase_RouterInitialization`. 

97 """ 

98 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Global Clock Net Routing") 

99 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Global Clock Net Routing | Checksum:" 

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

101 

102 

103@export 

104class SubPhase_UpdateTiming(SubPhase): 

105 """ 

106 *Update Timing* subphase. 

107 

108 Used by phase :class:`Phase_RouterInitialization`. 

109 """ 

110 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Update Timing") 

111 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Update Timing | Checksum:" 

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

113 

114 

115@export 

116class SubPhase_SoftConstraintPins_FastBudgeting(SubPhase): 

117 """ 

118 *Soft Constraint Pins - Fast Budgeting* subphase. 

119 

120 Used by phase :class:`Phase_RouterInitialization`. 

121 """ 

122 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Soft Constraint Pins - Fast Budgeting") 

123 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Soft Constraint Pins - Fast Budgeting | Checksum:" 

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

125 

126 

127@export 

128class SubSubPhase_UpdateTiming(SubSubPhase): 

129 """ 

130 *Update Timing - Fast Budgeting* sub-subphase. 

131 

132 Used by phase :class:`SubPhase_UpdateTimingForBusSkew`. 

133 """ 

134 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR_MICRO} Update Timing") 

135 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex}.{subSubPhaseIndex} Update Timing | Checksum:" 

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

137 

138 

139@export 

140class SubPhase_UpdateTimingForBusSkew(SubPhaseWithChildren): 

141 """ 

142 *Update Timing for Bus Skew* subphase. 

143 

144 .. rubric:: Uses 

145 

146 * :class:`SubSubPhase_UpdateTiming` 

147 

148 Used by phase :class:`Phase_RouterInitialization`. 

149 """ 

150 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Update Timing for Bus Skew") 

151 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Update Timing for Bus Skew | Checksum:" 

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

153 

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

155 SubSubPhase_UpdateTiming, 

156 ) 

157 

158 

159@export 

160class Phase_RouterInitialization(PhaseWithChildren): 

161 """ 

162 *Router Initialization* phase. 

163 

164 .. rubric:: Uses 

165 

166 * :class:`SubPhase_CreateTimer` 

167 * :class:`SubPhase_FixTopologyConstraints` 

168 * :class:`SubPhase_PreRouteCleanup` 

169 * :class:`SubPhase_GlobalClockNetRouting` 

170 * :class:`SubPhase_UpdateTiming` 

171 * :class:`SubPhase_UpdateTimingForBusSkew` 

172 * :class:`SubPhase_SoftConstraintPins_FastBudgeting` 

173 

174 Used by task :class:`RoutingTask`. 

175 """ 

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

177 _FINISH: ClassVar[str] = "Phase {phaseIndex} Router Initialization | Checksum:" 

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

179 _FINAL: ClassVar[str] = None 

180 

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

182 SubPhase_CreateTimer, 

183 SubPhase_FixTopologyConstraints, 

184 SubPhase_PreRouteCleanup, 

185 SubPhase_GlobalClockNetRouting, 

186 SubPhase_UpdateTiming, 

187 SubPhase_UpdateTimingForBusSkew, 

188 SubPhase_SoftConstraintPins_FastBudgeting 

189 ) 

190 

191 

192@export 

193class SubPhase_GlobalRouting(SubPhase): 

194 """ 

195 *Global Routing* subphase. 

196 

197 Used by phase :class:`Phase_Initial_Routing`. 

198 """ 

199 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Global Routing") 

200 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Global Routing | Checksum:" 

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

202 

203 

204@export 

205class SubPhase_InitialNetRouting(SubPhase): 

206 """ 

207 *Initial Net Routing* subphase. 

208 

209 Used by phase :class:`Phase_Initial_Routing`. 

210 """ 

211 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Initial Net Routing") 

212 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Initial Net Routing | Checksum:" 

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

214 

215 

216@export 

217class Phase_Initial_Routing(PhaseWithChildren): 

218 """ 

219 *Initial Routing* phase. 

220 

221 .. rubric:: Uses 

222 

223 * :class:`SubPhase_GlobalRouting` 

224 * :class:`SubPhase_InitialNetRouting` 

225 

226 Used by task :class:`RoutingTask`. 

227 """ 

228 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Initial Routing") 

229 _FINISH: ClassVar[str] = "Phase {phaseIndex} Initial Routing | Checksum:" 

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

231 _FINAL: ClassVar[str] = None 

232 

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

234 SubPhase_GlobalRouting, 

235 SubPhase_InitialNetRouting 

236 ) 

237 

238 

239@export 

240class Phase_GlobalRouting(Phase): 

241 """ 

242 *Global Routing* phase. 

243 

244 Used by task :class:`RoutingTask`. 

245 """ 

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

247 _FINISH: ClassVar[str] = "Phase {phaseIndex} Global Routing | Checksum:" 

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

249 _FINAL: ClassVar[str] = None 

250 

251 

252@export 

253class SubPhase_GlobalIteration0(SubPhase): 

254 """ 

255 *Global Iteration 0* subphase. 

256 

257 Used by phase :class:`Phase_RipUpAndReroute`. 

258 """ 

259 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Global Iteration 0") 

260 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Global Iteration 0 | Checksum:" 

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

262 

263 

264@export 

265class SubPhase_AdditionalIterationForHold(SubPhase): 

266 """ 

267 *Additional Iteration for Hold* subphase. 

268 

269 Used by phase :class:`Phase_RipUpAndReroute`. 

270 """ 

271 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Additional Iteration for Hold") 

272 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Additional Iteration for Hold | Checksum:" 

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

274 

275 

276@export 

277class SubPhase_GlobalIteration1(SubPhase): 

278 """ 

279 *Global Iteration 1* subphase. 

280 

281 Used by phase :class:`Phase_RipUpAndReroute`. 

282 """ 

283 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Global Iteration 1") 

284 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Global Iteration 1 | Checksum:" 

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

286 

287 

288@export 

289class SubPhase_GlobalIteration2(SubPhase): 

290 """ 

291 *Global Iteration 2* subphase. 

292 

293 Used by phase :class:`Phase_RipUpAndReroute`. 

294 """ 

295 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Global Iteration 2") 

296 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Global Iteration 2 | Checksum:" 

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

298 

299 

300@export 

301class Phase_RipUpAndReroute(PhaseWithChildren): 

302 """ 

303 *Rip-up And Reroute* phase. 

304 

305 .. rubric:: Uses 

306 

307 * :class:`SubPhase_GlobalIteration0` 

308 * :class:`SubPhase_AdditionalIterationForHold` 

309 * :class:`SubPhase_GlobalIteration1` 

310 * :class:`SubPhase_GlobalIteration2` 

311 

312 Used by task :class:`RoutingTask`. 

313 """ 

314 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Rip-up And Reroute") 

315 _FINISH: ClassVar[str] = "Phase {phaseIndex} Rip-up And Reroute | Checksum:" 

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

317 _FINAL: ClassVar[str] = None 

318 

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

320 SubPhase_GlobalIteration0, 

321 SubPhase_AdditionalIterationForHold, 

322 SubPhase_GlobalIteration1, 

323 SubPhase_GlobalIteration2 

324 ) 

325 

326 

327@export 

328class SubPhase_InitialNetRoutingPass(SubPhase): 

329 """ 

330 *Initial Net Routing Pass* subphase. 

331 

332 Used by phase :class:`Phase_InitialRouting`. 

333 """ 

334 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Initial Net Routing Pass") 

335 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Initial Net Routing Pass | Checksum:" 

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

337 

338 

339@export 

340class Phase_InitialRouting(PhaseWithChildren): 

341 """ 

342 *Initial Routing* phase. 

343 

344 .. rubric:: Uses 

345 

346 * :class:`SubPhase_InitialNetRoutingPass` 

347 * :class:`SubPhase_GlobalRouting` 

348 * :class:`SubPhase_InitialNetRouting` 

349 

350 Used by task :class:`RoutingTask`. 

351 """ 

352 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Initial Routing") 

353 _FINISH: ClassVar[str] = "Phase {phaseIndex} Initial Routing | Checksum:" 

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

355 _FINAL: ClassVar[str] = None 

356 

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

358 SubPhase_InitialNetRoutingPass, 

359 SubPhase_GlobalRouting, 

360 SubPhase_InitialNetRouting 

361 ) 

362 

363 

364@export 

365class SubPhase_DelayCleanUp(SubPhase): 

366 """ 

367 *Delay CleanUp* subphase. 

368 

369 Used by phase :class:`Phase_DelayAndSkewOptimization`. 

370 """ 

371 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Delay CleanUp") 

372 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Delay CleanUp | Checksum:" 

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

374 

375 

376@export 

377class SubPhase_ClockSkewOptimization(SubPhase): 

378 """ 

379 *Clock Skew Optimization* subphase. 

380 

381 Used by phase :class:`Phase_DelayAndSkewOptimization`. 

382 """ 

383 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Clock Skew Optimization") 

384 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Clock Skew Optimization | Checksum:" 

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

386 

387 

388@export 

389class Phase_DelayAndSkewOptimization(PhaseWithChildren): 

390 """ 

391 *Delay and Skew Optimization* phase. 

392 

393 .. rubric:: Uses 

394 

395 * :class:`SubPhase_DelayCleanUp` 

396 * :class:`SubPhase_ClockSkewOptimization` 

397 

398 Used by task :class:`RoutingTask`. 

399 """ 

400 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Delay and Skew Optimization") 

401 _FINISH: ClassVar[str] = "Phase {phaseIndex} Delay and Skew Optimization | Checksum:" 

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

403 _FINAL: ClassVar[str] = None 

404 

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

406 SubPhase_DelayCleanUp, 

407 SubPhase_ClockSkewOptimization 

408 ) 

409 

410 

411@export 

412class SubPhase_HoldFixIter(SubPhase): 

413 """ 

414 *Hold Fix Iter* subphase. 

415 

416 Used by phase :class:`Phase_PostHoldFix`. 

417 """ 

418 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Hold Fix Iter") 

419 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Hold Fix Iter | Checksum:" 

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

421 

422 

423@export 

424class Phase_PostHoldFix(PhaseWithChildren): 

425 """ 

426 *Post Hold Fix* phase. 

427 

428 Used by task :class:`RoutingTask`. 

429 """ 

430 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Post Hold Fix") 

431 _FINISH: ClassVar[str] = "Phase {phaseIndex} Post Hold Fix | Checksum:" 

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

433 _FINAL: ClassVar[str] = None 

434 

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

436 SubPhase_HoldFixIter, 

437 ) 

438 

439 

440@export 

441class Phase_DelayAndSkewOptimization(PhaseWithChildren): 

442 """ 

443 *Delay and Skew Optimization* phase. 

444 

445 .. rubric:: Uses 

446 

447 * :class:`SubPhase_DelayCleanUp` 

448 * :class:`SubPhase_ClockSkewOptimization` 

449 

450 Used by task :class:`RoutingTask`. 

451 """ 

452 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Delay and Skew Optimization") 

453 _FINISH: ClassVar[str] = "Phase {phaseIndex} Delay and Skew Optimization | Checksum:" 

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

455 _FINAL: ClassVar[str] = None 

456 

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

458 SubPhase_DelayCleanUp, 

459 SubPhase_ClockSkewOptimization 

460 ) 

461 

462 

463@export 

464class Phase_RouteFinalize_1(Phase): # todo: remove duplicates 

465 """ 

466 *Route finalize* phase. 

467 

468 Used by task :class:`RoutingTask`. 

469 """ 

470 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Route finalize") 

471 _FINISH: ClassVar[str] = "Phase {phaseIndex} Route finalize | Checksum:" 

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

473 _FINAL: ClassVar[str] = None 

474 

475 

476@export 

477class Phase_RouteFinalize_2(Phase): # todo: remove duplicates 

478 """ 

479 *Route finalize* phase. 

480 

481 Used by task :class:`RoutingTask`. 

482 """ 

483 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Route finalize") 

484 _FINISH: ClassVar[str] = "Phase {phaseIndex} Route finalize | Checksum:" 

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

486 _FINAL: ClassVar[str] = None 

487 

488 

489@export 

490class Phase_PostHoldFix(PhaseWithChildren): 

491 """ 

492 *Post Hold Fix* phase. 

493 

494 Used by task :class:`RoutingTask`. 

495 """ 

496 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Post Hold Fix") 

497 _FINISH: ClassVar[str] = "Phase {phaseIndex} Post Hold Fix | Checksum:" 

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

499 _FINAL: ClassVar[str] = None 

500 

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

502 SubPhase_HoldFixIter, 

503 ) 

504 

505 

506@export 

507class Phase_VerifyingRoutedNets(Phase): 

508 """ 

509 *Verifying routed nets* phase. 

510 

511 Used by task :class:`RoutingTask`. 

512 """ 

513 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Verifying routed nets") 

514 _FINISH: ClassVar[str] = "Phase {phaseIndex} Verifying routed nets | Checksum:" 

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

516 _FINAL: ClassVar[str] = None 

517 

518 

519@export 

520class Phase_DepositingRoutes(Phase): 

521 """ 

522 *Depositing Routes* phase. 

523 

524 Used by task :class:`RoutingTask`. 

525 """ 

526 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Depositing Routes") 

527 _FINISH: ClassVar[str] = "Phase {phaseIndex} Depositing Routes | Checksum:" 

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

529 _FINAL: ClassVar[str] = None 

530 

531 

532@export 

533class Phase_VerifyingRoutedNets(Phase): 

534 """ 

535 *Verifying routed nets* phase. 

536 

537 Used by task :class:`RoutingTask`. 

538 """ 

539 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Verifying routed nets") 

540 _FINISH: ClassVar[str] = "Phase {phaseIndex} Verifying routed nets | Checksum:" 

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

542 _FINAL: ClassVar[str] = None 

543 

544 

545@export 

546class Phase_ResolveXTalk(Phase): 

547 """ 

548 *Resolve XTalk* phase. 

549 

550 Used by task :class:`RoutingTask`. 

551 """ 

552 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Resolve XTalk") 

553 _FINISH: ClassVar[str] = "Phase {phaseIndex} Resolve XTalk | Checksum:" 

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

555 _FINAL: ClassVar[str] = None 

556 

557 

558@export 

559class Phase_DepositingRoutes(Phase): 

560 """ 

561 *Depositing Routes* phase. 

562 

563 Used by task :class:`RoutingTask`. 

564 """ 

565 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Depositing Routes") 

566 _FINISH: ClassVar[str] = "Phase {phaseIndex} Depositing Routes | Checksum:" 

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

568 _FINAL: ClassVar[str] = None 

569 

570 

571@export 

572class Phase_PostProcessRouting(Phase): 

573 """ 

574 *Post Process Routing* phase. 

575 

576 Used by task :class:`RoutingTask`. 

577 """ 

578 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Post Process Routing") 

579 _FINISH: ClassVar[str] = "Phase {phaseIndex} Post Process Routing | Checksum:" 

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

581 _FINAL: ClassVar[str] = None 

582 

583 

584@export 

585class Phase_PostRouterTiming(Phase): 

586 """ 

587 *Post Router Timing* phase. 

588 

589 Used by task :class:`RoutingTask`. 

590 """ 

591 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Post Router Timing") 

592 _FINISH: ClassVar[str] = "Phase {phaseIndex} Post Router Timing | Checksum:" 

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

594 _FINAL: ClassVar[str] = None 

595 

596 

597@export 

598class Phase_PostRouteEventProcessing(Phase): 

599 """ 

600 *Post-Route Event Processing* phase. 

601 

602 Used by task :class:`RoutingTask`. 

603 """ 

604 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Post-Route Event Processing") 

605 _FINISH: ClassVar[str] = "Phase {phaseIndex} Post-Route Event Processing | Checksum:" 

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

607 _FINAL: ClassVar[str] = None 

608 

609 

610@export 

611class RoutingTask(TaskWithPhases): 

612 """ 

613 *Routing* task. 

614 

615 .. rubric:: Uses 

616 

617 * :class:`Phase_BuildRTDesign` 

618 * :class:`Phase_RouterInitialization` 

619 * :class:`Phase_GlobalRouting` 

620 * :class:`Phase_InitialRouting` 

621 * :class:`Phase_RipUpAndReroute` 

622 * :class:`Phase_DelayAndSkewOptimization` 

623 * :class:`Phase_PostHoldFix` 

624 * :class:`Phase_RouteFinalize_1` 

625 * :class:`Phase_VerifyingRoutedNets` 

626 * :class:`Phase_DepositingRoutes` 

627 * :class:`Phase_ResolveXTalk` 

628 * :class:`Phase_RouteFinalize_2` 

629 * :class:`Phase_PostRouterTiming` 

630 * :class:`Phase_PostProcessRouting` 

631 * :class:`Phase_PostRouterTiming` 

632 * :class:`Phase_PostRouteEventProcessing` 

633 

634 Used by Vivado command :class:`~pyEDAA.OutputFilter.Xilinx.Commands.RouteDesign`. 

635 """ 

636 _START: ClassVar[str] = "Starting Routing Task" 

637 _FINISH: ClassVar[str] = "Ending Routing Task" 

638 

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

640 Phase_BuildRTDesign, 

641 Phase_RouterInitialization, 

642 Phase_GlobalRouting, 

643 Phase_InitialRouting, 

644 Phase_RipUpAndReroute, 

645 Phase_DelayAndSkewOptimization, 

646 Phase_PostHoldFix, 

647 Phase_RouteFinalize_1, 

648 Phase_VerifyingRoutedNets, 

649 Phase_DepositingRoutes, 

650 Phase_ResolveXTalk, 

651 Phase_RouteFinalize_2, 

652 Phase_PostRouterTiming, 

653 Phase_PostProcessRouting, 

654 Phase_PostRouterTiming, # FIXME: duplicate 

655 Phase_PostRouteEventProcessing 

656 )