Coverage for pyEDAA/OutputFilter/Xilinx/OptimizeDesign.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 Task, TaskWithPhases, TaskWithSubTasks, SubTask 

38from pyEDAA.OutputFilter.Xilinx.Common2 import Phase, SubPhase, PhaseWithChildren 

39from pyEDAA.OutputFilter.Xilinx.Common2 import MAJOR, MAJOR_MINOR 

40 

41 

42@export 

43class Phase_Retarget(Phase): 

44 """ 

45 *Retarget* phase. 

46 

47 Used by task :class:`LogicOptimizationTask`. 

48 """ 

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

50 _FINISH: ClassVar[str] = "Phase {phaseIndex} Retarget | Checksum:" 

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

52 _FINAL: ClassVar[str] = "Retarget | Checksum:" 

53 

54 

55@export 

56class SubPhase_CoreGenerationAndDesignSetup(SubPhase): 

57 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Core Generation And Design Setup") 

58 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Core Generation And Design Setup | Checksum:" 

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

60 

61 

62@export 

63class SubPhase_SetupConstraintsAndSortNetlist(SubPhase): 

64 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Setup Constraints And Sort Netlist") 

65 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Setup Constraints And Sort Netlist | Checksum:" 

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

67 

68 

69@export 

70class Phase_Initialization(PhaseWithChildren): 

71 """ 

72 *Initialization* phase. 

73 

74 Used by task :class:`LogicOptimizationTask`. 

75 """ 

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

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

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

79 _FINAL: ClassVar[str] = None 

80 

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

82 SubPhase_CoreGenerationAndDesignSetup, 

83 SubPhase_SetupConstraintsAndSortNetlist 

84 ) 

85 

86 

87@export 

88class Phase_ConstantPropagation(Phase): 

89 """ 

90 *Constant propagation* phase. 

91 

92 Used by task :class:`LogicOptimizationTask`. 

93 """ 

94 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Constant propagation") 

95 _FINISH: ClassVar[str] = "Phase {phaseIndex} Constant propagation | Checksum:" 

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

97 _FINAL: ClassVar[str] = "Constant propagation | Checksum:" 

98 

99 

100@export 

101class SubPhase_TimerUpdate(SubPhase): 

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

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

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

105 

106 

107@export 

108class SubPhase_TimingDataCollection(SubPhase): 

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

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

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

112 

113 

114@export 

115class Phase_TimerUpdateAndTimingDataCollection(PhaseWithChildren): 

116 """ 

117 *Timer Update And Timing Data Collection* phase. 

118 

119 Used by task :class:`LogicOptimizationTask`. 

120 """ 

121 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Timer Update And Timing Data Collection") 

122 _FINISH: ClassVar[str] = "Phase {phaseIndex} Timer Update And Timing Data Collection | Checksum:" 

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

124 _FINAL: ClassVar[str] = None 

125 

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

127 SubPhase_TimerUpdate, 

128 SubPhase_TimingDataCollection 

129 ) 

130 

131 

132@export 

133class Phase_Sweep(Phase): 

134 """ 

135 *Sweep* phase. 

136 

137 Used by task :class:`LogicOptimizationTask`. 

138 """ 

139 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Sweep") 

140 _FINISH: ClassVar[str] = "Phase {phaseIndex} Sweep | Checksum:" 

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

142 _FINAL: ClassVar[str] = "Sweep | Checksum:" 

143 

144 

145@export 

146class Phase_BUFGOptimization(Phase): 

147 """ 

148 *BUFG optimization* phase. 

149 

150 Used by task :class:`LogicOptimizationTask`. 

151 """ 

152 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} BUFG optimization") 

153 _FINISH: ClassVar[str] = "Phase {phaseIndex} BUFG optimization | Checksum:" 

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

155 _FINAL: ClassVar[str] = "BUFG optimization | Checksum:" 

156 

157 

158@export 

159class Phase_ShiftRegisterOptimization(Phase): 

160 """ 

161 *Shift Register Optimization* phase. 

162 

163 Used by task :class:`LogicOptimizationTask`. 

164 """ 

165 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Shift Register Optimization") 

166 _FINISH: ClassVar[str] = "Phase {phaseIndex} Shift Register Optimization | Checksum:" 

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

168 _FINAL: ClassVar[str] = "Shift Register Optimization | Checksum:" 

169 

170 

171@export 

172class Phase_PostProcessingNetlist(Phase): 

173 """ 

174 *Post Processing Netlist* phase. 

175 

176 Used by task :class:`LogicOptimizationTask`. 

177 """ 

178 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Post Processing Netlist") 

179 _FINISH: ClassVar[str] = "Phase {phaseIndex} Post Processing Netlist | Checksum:" 

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

181 _FINAL: ClassVar[str] = "Post Processing Netlist | Checksum:" 

182 

183 

184@export 

185class SubPhase_FinalizingDesignCoresAndUpdatingShapes(SubPhase): 

186 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Finalizing Design Cores and Updating Shapes") 

187 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Finalizing Design Cores and Updating Shapes | Checksum:" 

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

189 

190 

191@export 

192class SubPhase_VerifyingNetlistConnectivity(SubPhase): 

193 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR_MINOR} Verifying Netlist Connectivity") 

194 _FINISH: ClassVar[str] = "Phase {phaseIndex}.{subPhaseIndex} Verifying Netlist Connectivity | Checksum:" 

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

196 

197 

198@export 

199class Phase_Finalization(PhaseWithChildren): 

200 """ 

201 *Finalization* phase. 

202 

203 Used by task :class:`LogicOptimizationTask`. 

204 """ 

205 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Finalization") 

206 _FINISH: ClassVar[str] = "Phase {phaseIndex} Finalization | Checksum:" 

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

208 _FINAL: ClassVar[str] = None 

209 

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

211 SubPhase_FinalizingDesignCoresAndUpdatingShapes, 

212 SubPhase_VerifyingNetlistConnectivity 

213 ) 

214 

215 

216@export 

217class DRCTask(Task): 

218 _START: ClassVar[str] = "Starting DRC Task" 

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

220 

221 

222@export 

223class CacheTimingInformationTask(Task): 

224 _START: ClassVar[str] = "Starting Cache Timing Information Task" 

225 _FINISH: ClassVar[str] = "Ending Cache Timing Information Task" 

226 

227 

228@export 

229class LogicOptimizationTask(TaskWithPhases): 

230 """ 

231 *Logic Optimization* task. 

232 

233 Used by Vivado command :class:`~pyEDAA.OutputFilter.Xilinx.Commands.OptimizeDesign`. 

234 """ 

235 _START: ClassVar[str] = "Starting Logic Optimization Task" 

236 _FINISH: ClassVar[str] = "Ending Logic Optimization Task" 

237 

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

239 Phase_Initialization, 

240 Phase_TimerUpdateAndTimingDataCollection, 

241 Phase_Retarget, 

242 Phase_ConstantPropagation, 

243 Phase_Sweep, 

244 Phase_BUFGOptimization, 

245 Phase_ShiftRegisterOptimization, 

246 Phase_PostProcessingNetlist, 

247 Phase_Finalization 

248 ) 

249 

250 

251@export 

252class PowerOptPatchEnablesTask(SubTask): 

253 _START: ClassVar[str] = "Starting PowerOpt Patch Enables Task" 

254 _FINISH: ClassVar[str] = "Ending PowerOpt Patch Enables Task" 

255 

256 

257@export 

258class PowerOptimizationTask(TaskWithSubTasks): 

259 _START: ClassVar[str] = "Starting Power Optimization Task" 

260 _FINISH: ClassVar[str] = "Ending Power Optimization Task" 

261 

262 _PARSERS: ClassVar[Tuple[Type[SubTask], ...]] = ( 

263 PowerOptPatchEnablesTask, 

264 ) 

265 

266 

267@export 

268class FinalCleanupTask(TaskWithSubTasks): 

269 _START: ClassVar[str] = "Starting Final Cleanup Task" 

270 _FINISH: ClassVar[str] = "Ending Final Cleanup Task" 

271 

272 _PARSERS: ClassVar[Tuple[Type[SubTask], ...]] = ( 

273 LogicOptimizationTask, 

274 ) 

275 

276 

277@export 

278class NetlistObfuscationTask(Task): 

279 _START: ClassVar[str] = "Starting Netlist Obfuscation Task" 

280 _FINISH: ClassVar[str] = "Ending Netlist Obfuscation Task"