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, Phase, SubPhase, TaskWithPhases, TaskWithSubTasks, SubTask, \ 

38 PhaseWithChildren 

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

40 

41 

42@export 

43class Phase_Retarget(Phase): 

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

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

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

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

48 

49 

50@export 

51class SubPhase_CoreGenerationAndDesignSetup(SubPhase): 

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

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

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

55 

56 

57@export 

58class SubPhase_SetupConstraintsAndSortNetlist(SubPhase): 

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

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

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

62 

63 

64@export 

65class Phase_Initialization(PhaseWithChildren): 

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

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

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

69 _FINAL: ClassVar[str] = None 

70 

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

72 SubPhase_CoreGenerationAndDesignSetup, 

73 SubPhase_SetupConstraintsAndSortNetlist 

74 ) 

75 

76 

77@export 

78class Phase_ConstantPropagation(Phase): 

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

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

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

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

83 

84 

85@export 

86class SubPhase_TimerUpdate(SubPhase): 

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

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

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

90 

91 

92@export 

93class SubPhase_TimingDataCollection(SubPhase): 

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

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

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

97 

98 

99@export 

100class Phase_TimerUpdateAndTimingDataCollection(PhaseWithChildren): 

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

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

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

104 _FINAL: ClassVar[str] = None 

105 

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

107 SubPhase_TimerUpdate, 

108 SubPhase_TimingDataCollection 

109 ) 

110 

111 

112@export 

113class Phase_Sweep(Phase): 

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

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

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

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

118 

119 

120@export 

121class Phase_BUFGOptimization(Phase): 

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

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

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

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

126 

127 

128@export 

129class Phase_ConstantPropagation(Phase): 

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

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

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

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

134 

135 

136@export 

137class Phase_ShiftRegisterOptimization(Phase): 

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

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

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

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

142 

143 

144@export 

145class Phase_Sweep(Phase): 

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

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

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

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

150 

151 

152@export 

153class Phase_PostProcessingNetlist(Phase): 

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

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

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

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

158 

159 

160@export 

161class Phase_BUFGOptimization(Phase): 

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

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

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

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

166 

167 

168@export 

169class Phase_ShiftRegisterOptimization(Phase): 

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

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

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

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

174 

175 

176@export 

177class Phase_PostProcessingNetlist(Phase): 

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 _START: ClassVar[Pattern] = compile(f"^Phase {MAJOR} Finalization") 

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

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

203 _FINAL: ClassVar[str] = None 

204 

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

206 SubPhase_FinalizingDesignCoresAndUpdatingShapes, 

207 SubPhase_VerifyingNetlistConnectivity 

208 ) 

209 

210 

211@export 

212class DRCTask(Task): 

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

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

215 

216 

217@export 

218class CacheTimingInformationTask(Task): 

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

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

221 

222 

223@export 

224class LogicOptimizationTask(TaskWithPhases): 

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

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

227 

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

229 Phase_Initialization, 

230 Phase_TimerUpdateAndTimingDataCollection, 

231 Phase_Retarget, 

232 Phase_ConstantPropagation, 

233 Phase_Sweep, 

234 Phase_BUFGOptimization, 

235 Phase_ShiftRegisterOptimization, 

236 Phase_PostProcessingNetlist, 

237 Phase_Finalization 

238 ) 

239 

240 

241@export 

242class PowerOptPatchEnablesTask(SubTask): 

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

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

245 

246 

247@export 

248class PowerOptimizationTask(TaskWithSubTasks): 

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

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

251 

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

253 PowerOptPatchEnablesTask, 

254 ) 

255 

256 

257@export 

258class LogicOptimizationTask(SubTask): 

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

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

261 

262 

263@export 

264class FinalCleanupTask(TaskWithSubTasks): 

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

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

267 

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

269 LogicOptimizationTask, 

270 ) 

271 

272 

273@export 

274class NetlistObfuscationTask(Task): 

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

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