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.Common2 import TaskWithPhases, Phase, SubPhase, PhaseWithChildren, SubPhaseWithChildren 

38from pyEDAA.OutputFilter.Xilinx.Common2 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 

53 

54@export 

55class SubPhase_CreateTimer(SubPhase): 

56 """ 

57 *Create Timer* subphase. 

58 

59 Used by phase :class:`Phase_RouterInitialization`. 

60 """ 

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

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

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

64 

65 

66@export 

67class SubPhase_FixTopologyConstraints(SubPhase): 

68 """ 

69 *Fix Topology Constraints* subphase. 

70 

71 Used by phase :class:`Phase_RouterInitialization`. 

72 """ 

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

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

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

76 

77 

78@export 

79class SubPhase_PreRouteCleanup(SubPhase): 

80 """ 

81 *Pre Route Cleanup* subphase. 

82 

83 Used by phase :class:`Phase_RouterInitialization`. 

84 """ 

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

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

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

88 

89 

90@export 

91class SubPhase_GlobalClockNetRouting(SubPhase): 

92 """ 

93 *Global Clock Net Routing* subphase. 

94 

95 Used by phase :class:`Phase_RouterInitialization`. 

96 """ 

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

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

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

100 

101 

102@export 

103class SubPhase_UpdateTiming(SubPhase): 

104 """ 

105 *Update Timing* subphase. 

106 

107 Used by phase :class:`Phase_RouterInitialization`. 

108 """ 

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

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

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

112 

113 

114@export 

115class SubPhase_SoftConstraintPins_FastBudgeting(SubPhase): 

116 """ 

117 *Soft Constraint Pins - Fast Budgeting* subphase. 

118 

119 Used by phase :class:`Phase_RouterInitialization`. 

120 """ 

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

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

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

124 

125 

126@export 

127class SubSubPhase_UpdateTiming(SubSubPhase): 

128 """ 

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

130 

131 Used by phase :class:`SubPhase_UpdateTimingForBusSkew`. 

132 """ 

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

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

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

136 

137 

138@export 

139class SubPhase_UpdateTimingForBusSkew(SubPhaseWithChildren): 

140 """ 

141 *Update Timing for Bus Skew* subphase. 

142 

143 .. rubric:: Uses 

144 

145 * :class:`SubSubPhase_UpdateTiming` 

146 

147 Used by phase :class:`Phase_RouterInitialization`. 

148 """ 

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

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

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

152 

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

154 SubSubPhase_UpdateTiming, 

155 ) 

156 

157 

158@export 

159class Phase_RouterInitialization(PhaseWithChildren): 

160 """ 

161 *Router Initialization* phase. 

162 

163 .. rubric:: Uses 

164 

165 * :class:`SubPhase_CreateTimer` 

166 * :class:`SubPhase_FixTopologyConstraints` 

167 * :class:`SubPhase_PreRouteCleanup` 

168 * :class:`SubPhase_GlobalClockNetRouting` 

169 * :class:`SubPhase_UpdateTiming` 

170 * :class:`SubPhase_UpdateTimingForBusSkew` 

171 * :class:`SubPhase_SoftConstraintPins_FastBudgeting` 

172 

173 Used by task :class:`RoutingTask`. 

174 """ 

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

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

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

178 

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

180 SubPhase_CreateTimer, 

181 SubPhase_FixTopologyConstraints, 

182 SubPhase_PreRouteCleanup, 

183 SubPhase_GlobalClockNetRouting, 

184 SubPhase_UpdateTiming, 

185 SubPhase_UpdateTimingForBusSkew, 

186 SubPhase_SoftConstraintPins_FastBudgeting 

187 ) 

188 

189 

190@export 

191class SubPhase_GlobalRouting(SubPhase): 

192 """ 

193 *Global Routing* subphase. 

194 

195 Used by phase :class:`Phase_Initial_Routing`. 

196 """ 

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

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

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

200 

201 

202@export 

203class SubPhase_InitialNetRouting(SubPhase): 

204 """ 

205 *Initial Net Routing* subphase. 

206 

207 Used by phase :class:`Phase_Initial_Routing`. 

208 """ 

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

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

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

212 

213 

214@export 

215class Phase_Initial_Routing(PhaseWithChildren): 

216 """ 

217 *Initial Routing* phase. 

218 

219 .. rubric:: Uses 

220 

221 * :class:`SubPhase_GlobalRouting` 

222 * :class:`SubPhase_InitialNetRouting` 

223 

224 Used by task :class:`RoutingTask`. 

225 """ 

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

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

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

229 

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

231 SubPhase_GlobalRouting, 

232 SubPhase_InitialNetRouting 

233 ) 

234 

235 

236@export 

237class Phase_GlobalRouting(Phase): 

238 """ 

239 *Global Routing* phase. 

240 

241 Used by task :class:`RoutingTask`. 

242 """ 

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

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

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

246 

247 

248@export 

249class SubPhase_GlobalIteration0(SubPhase): 

250 """ 

251 *Global Iteration 0* subphase. 

252 

253 Used by phase :class:`Phase_RipUpAndReroute`. 

254 """ 

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

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

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

258 

259 

260@export 

261class SubPhase_AdditionalIterationForHold(SubPhase): 

262 """ 

263 *Additional Iteration for Hold* subphase. 

264 

265 Used by phase :class:`Phase_RipUpAndReroute`. 

266 """ 

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

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

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

270 

271 

272@export 

273class SubPhase_GlobalIteration1(SubPhase): 

274 """ 

275 *Global Iteration 1* subphase. 

276 

277 Used by phase :class:`Phase_RipUpAndReroute`. 

278 """ 

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

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

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

282 

283 

284@export 

285class SubPhase_GlobalIteration2(SubPhase): 

286 """ 

287 *Global Iteration 2* subphase. 

288 

289 Used by phase :class:`Phase_RipUpAndReroute`. 

290 """ 

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

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

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

294 

295 

296@export 

297class Phase_RipUpAndReroute(PhaseWithChildren): 

298 """ 

299 *Rip-up And Reroute* phase. 

300 

301 .. rubric:: Uses 

302 

303 * :class:`SubPhase_GlobalIteration0` 

304 * :class:`SubPhase_AdditionalIterationForHold` 

305 * :class:`SubPhase_GlobalIteration1` 

306 * :class:`SubPhase_GlobalIteration2` 

307 

308 Used by task :class:`RoutingTask`. 

309 """ 

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

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

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

313 

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

315 SubPhase_GlobalIteration0, 

316 SubPhase_AdditionalIterationForHold, 

317 SubPhase_GlobalIteration1, 

318 SubPhase_GlobalIteration2 

319 ) 

320 

321 

322@export 

323class SubPhase_InitialNetRoutingPass(SubPhase): 

324 """ 

325 *Initial Net Routing Pass* subphase. 

326 

327 Used by phase :class:`Phase_InitialRouting`. 

328 """ 

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

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

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

332 

333 

334@export 

335class Phase_InitialRouting(PhaseWithChildren): 

336 """ 

337 *Initial Routing* phase. 

338 

339 .. rubric:: Uses 

340 

341 * :class:`SubPhase_InitialNetRoutingPass` 

342 * :class:`SubPhase_GlobalRouting` 

343 * :class:`SubPhase_InitialNetRouting` 

344 

345 Used by task :class:`RoutingTask`. 

346 """ 

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

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

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

350 

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

352 SubPhase_InitialNetRoutingPass, 

353 SubPhase_GlobalRouting, 

354 SubPhase_InitialNetRouting 

355 ) 

356 

357 

358@export 

359class SubPhase_DelayCleanUp(SubPhase): 

360 """ 

361 *Delay CleanUp* subphase. 

362 

363 Used by phase :class:`Phase_DelayAndSkewOptimization`. 

364 """ 

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

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

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

368 

369 

370@export 

371class SubPhase_ClockSkewOptimization(SubPhase): 

372 """ 

373 *Clock Skew Optimization* subphase. 

374 

375 Used by phase :class:`Phase_DelayAndSkewOptimization`. 

376 """ 

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

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

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

380 

381 

382@export 

383class Phase_DelayAndSkewOptimization(PhaseWithChildren): 

384 """ 

385 *Delay and Skew Optimization* phase. 

386 

387 .. rubric:: Uses 

388 

389 * :class:`SubPhase_DelayCleanUp` 

390 * :class:`SubPhase_ClockSkewOptimization` 

391 

392 Used by task :class:`RoutingTask`. 

393 """ 

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

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

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

397 

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

399 SubPhase_DelayCleanUp, 

400 SubPhase_ClockSkewOptimization 

401 ) 

402 

403 

404@export 

405class SubPhase_HoldFixIter(SubPhase): 

406 """ 

407 *Hold Fix Iter* subphase. 

408 

409 Used by phase :class:`Phase_PostHoldFix`. 

410 """ 

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

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

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

414 

415 

416@export 

417class Phase_PostHoldFix(PhaseWithChildren): 

418 """ 

419 *Post Hold Fix* phase. 

420 

421 Used by task :class:`RoutingTask`. 

422 """ 

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

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

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

426 

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

428 SubPhase_HoldFixIter, 

429 ) 

430 

431 

432@export 

433class Phase_DelayAndSkewOptimization(PhaseWithChildren): 

434 """ 

435 *Delay and Skew Optimization* phase. 

436 

437 .. rubric:: Uses 

438 

439 * :class:`SubPhase_DelayCleanUp` 

440 * :class:`SubPhase_ClockSkewOptimization` 

441 

442 Used by task :class:`RoutingTask`. 

443 """ 

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

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

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

447 

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

449 SubPhase_DelayCleanUp, 

450 SubPhase_ClockSkewOptimization 

451 ) 

452 

453 

454@export 

455class Phase_RouteFinalize_1(Phase): 

456 """ 

457 *Route finalize* phase. 

458 

459 Used by task :class:`RoutingTask`. 

460 """ 

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

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

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

464 

465 

466@export 

467class Phase_RouteFinalize_2(Phase): 

468 """ 

469 *Route finalize* phase. 

470 

471 Used by task :class:`RoutingTask`. 

472 """ 

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

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

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

476 

477 

478@export 

479class Phase_PostHoldFix(PhaseWithChildren): 

480 """ 

481 *Post Hold Fix* phase. 

482 

483 Used by task :class:`RoutingTask`. 

484 """ 

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

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

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

488 

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

490 SubPhase_HoldFixIter, 

491 ) 

492 

493 

494@export 

495class Phase_VerifyingRoutedNets(Phase): 

496 """ 

497 *Verifying routed nets* phase. 

498 

499 Used by task :class:`RoutingTask`. 

500 """ 

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

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

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

504 

505 

506@export 

507class Phase_DepositingRoutes(Phase): 

508 """ 

509 *Depositing Routes* phase. 

510 

511 Used by task :class:`RoutingTask`. 

512 """ 

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

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

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

516 

517 

518@export 

519class Phase_VerifyingRoutedNets(Phase): 

520 """ 

521 *Verifying routed nets* phase. 

522 

523 Used by task :class:`RoutingTask`. 

524 """ 

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

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

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

528 

529 

530@export 

531class Phase_ResolveXTalk(Phase): 

532 """ 

533 *Resolve XTalk* phase. 

534 

535 Used by task :class:`RoutingTask`. 

536 """ 

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

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

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

540 

541 

542@export 

543class Phase_DepositingRoutes(Phase): 

544 """ 

545 *Depositing Routes* phase. 

546 

547 Used by task :class:`RoutingTask`. 

548 """ 

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

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

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

552 

553 

554@export 

555class Phase_PostProcessRouting(Phase): 

556 """ 

557 *Post Process Routing* phase. 

558 

559 Used by task :class:`RoutingTask`. 

560 """ 

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

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

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

564 

565 

566@export 

567class Phase_PostRouterTiming(Phase): 

568 """ 

569 *Post Router Timing* phase. 

570 

571 Used by task :class:`RoutingTask`. 

572 """ 

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

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

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

576 

577 

578@export 

579class Phase_PostRouteEventProcessing(Phase): 

580 """ 

581 *Post-Route Event Processing* phase. 

582 

583 Used by task :class:`RoutingTask`. 

584 """ 

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

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

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

588 

589 

590@export 

591class RoutingTask(TaskWithPhases): 

592 """ 

593 *Routing* task. 

594 

595 .. rubric:: Uses 

596 

597 * :class:`Phase_BuildRTDesign` 

598 * :class:`Phase_RouterInitialization` 

599 * :class:`Phase_GlobalRouting` 

600 * :class:`Phase_InitialRouting` 

601 * :class:`Phase_RipUpAndReroute` 

602 * :class:`Phase_DelayAndSkewOptimization` 

603 * :class:`Phase_PostHoldFix` 

604 * :class:`Phase_RouteFinalize_1` 

605 * :class:`Phase_VerifyingRoutedNets` 

606 * :class:`Phase_DepositingRoutes` 

607 * :class:`Phase_ResolveXTalk` 

608 * :class:`Phase_RouteFinalize_2` 

609 * :class:`Phase_PostRouterTiming` 

610 * :class:`Phase_PostProcessRouting` 

611 * :class:`Phase_PostRouterTiming` 

612 * :class:`Phase_PostRouteEventProcessing` 

613 

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

615 """ 

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

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

618 

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

620 Phase_BuildRTDesign, 

621 Phase_RouterInitialization, 

622 Phase_GlobalRouting, 

623 Phase_InitialRouting, 

624 Phase_RipUpAndReroute, 

625 Phase_DelayAndSkewOptimization, 

626 Phase_PostHoldFix, 

627 Phase_RouteFinalize_1, 

628 Phase_VerifyingRoutedNets, 

629 Phase_DepositingRoutes, 

630 Phase_ResolveXTalk, 

631 Phase_RouteFinalize_2, 

632 Phase_PostRouterTiming, 

633 Phase_PostProcessRouting, 

634 Phase_PostRouterTiming, # FIXME: duplicate 

635 Phase_PostRouteEventProcessing 

636 )