PandA-2024.02
hls_flow_step_factory.cpp
Go to the documentation of this file.
1 /*
2  *
3  * _/_/_/ _/_/ _/ _/ _/_/_/ _/_/
4  * _/ _/ _/ _/ _/_/ _/ _/ _/ _/ _/
5  * _/_/_/ _/_/_/_/ _/ _/_/ _/ _/ _/_/_/_/
6  * _/ _/ _/ _/ _/ _/ _/ _/ _/
7  * _/ _/ _/ _/ _/ _/_/_/ _/ _/
8  *
9  * ***********************************************
10  * PandA Project
11  * URL: http://panda.dei.polimi.it
12  * Politecnico di Milano - DEIB
13  * System Architectures Group
14  * ***********************************************
15  * Copyright (C) 2004-2024 Politecnico di Milano
16  *
17  * This file is part of the PandA framework.
18  *
19  * The PandA framework is free software; you can redistribute it and/or modify
20  * it under the terms of the GNU General Public License as published by
21  * the Free Software Foundation; either version 3 of the License, or
22  * (at your option) any later version.
23  *
24  * This program is distributed in the hope that it will be useful,
25  * but WITHOUT ANY WARRANTY; without even the implied warranty of
26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27  * GNU General Public License for more details.
28  *
29  * You should have received a copy of the GNU General Public License
30  * along with this program. If not, see <http://www.gnu.org/licenses/>.
31  *
32  */
40 #include "hls_flow_step_factory.hpp"
41 
42 #include "BB_based_stg.hpp"
43 #include "CTestbenchExecution.hpp"
44 #include "CallGraphUnfolding.hpp"
45 #include "FSM_NI_SSA_liveness.hpp"
46 #include "Parameter.hpp"
47 #include "TopEntityMemoryMapped.hpp"
48 #include "WB4Intercon_interface.hpp"
49 #include "WB4_interface.hpp"
50 #include "add_library.hpp"
51 #include "allocation.hpp"
52 #include "call_graph_manager.hpp"
53 #include "cdfc_module_binding.hpp"
54 #include "chordal_coloring_register.hpp"
55 #include "classic_datapath.hpp"
56 #include "classical_synthesis_flow.hpp"
57 #include "compatibility_based_register.hpp"
58 #include "control_flow_checker.hpp"
59 #include "controller_cs.hpp"
60 #include "cs_interface.hpp"
61 #include "custom_set.hpp"
62 #include "datapath_cs.hpp"
63 #include "datapath_parallel_cs.hpp"
64 #include "dbgPrintHelper.hpp"
65 #include "design_flow_step.hpp"
66 #include "dominator_allocation.hpp"
67 #include "dry_run_evaluation.hpp"
68 #include "easy_module_binding.hpp"
69 #include "evaluation.hpp"
70 #include "fsm_controller.hpp"
71 #include "fun_dominator_allocation.hpp"
72 #include "generate_hdl.hpp"
73 #include "generate_simulation_scripts.hpp"
74 #include "generate_synthesis_scripts.hpp"
75 #include "hls_function_bit_value.hpp"
76 #include "hls_synthesis_flow.hpp"
77 #include "initialize_hls.hpp"
78 #include "mem_dominator_allocation.hpp"
79 #include "mem_dominator_allocation_cs.hpp"
80 #include "memory.hpp"
81 #include "minimal_interface.hpp"
82 #include "mux_connection_binding.hpp"
83 #include "parametric_list_based.hpp"
84 #include "pipeline_controller.hpp"
85 #include "port_swapping.hpp"
86 #include "sched_based_chaining_computation.hpp"
87 #include "scheduling.hpp"
88 #include "simulation_evaluation.hpp"
89 #include "standard_hls.hpp"
90 #include "string_manipulation.hpp"
91 #include "synthesis_evaluation.hpp"
92 #include "test_vector_parser.hpp"
93 #include "testbench_generation.hpp"
94 #include "top_entity.hpp"
95 #include "top_entity_cs.hpp"
96 #include "top_entity_parallel_cs.hpp"
97 #include "tree_manager.hpp"
98 #include "unique_binding.hpp"
99 #include "unique_binding_register.hpp"
100 #include "values_scheme.hpp"
101 #include "vertex_coloring_register.hpp"
102 #include "virtual_hls.hpp"
103 #include "weighted_clique_register.hpp"
104 #include "write_hls_summary.hpp"
105 
106 #if HAVE_TASTE
107 #include "generate_taste_hdl_architecture.hpp"
108 #include "generate_taste_synthesis_script.hpp"
109 #include "taste_interface_generation.hpp"
110 #endif
111 
112 #if HAVE_FROM_PRAGMA_BUILT
113 #include "omp_allocation.hpp"
114 #include "omp_body_loop_synthesis_flow.hpp"
115 #include "omp_for_wrapper_cs_synthesis_flow.hpp"
116 #include "omp_function_allocation.hpp"
117 #include "omp_function_allocation_CS.hpp"
118 #endif
119 
120 #if HAVE_ILP_BUILT
121 #include "sdc_scheduling.hpp"
122 #endif
123 
124 #if HAVE_VCD_BUILT
125 #include "HWDiscrepancyAnalysis.hpp"
126 #include "HWPathComputation.hpp"
127 #include "VcdSignalSelection.hpp"
128 #include "vcd_utility.hpp"
129 #endif
130 
131 #include "config_HAVE_ILP_BUILT.hpp"
132 
133 #include <string>
134 #include <utility>
135 
136 HLSFlowStepFactory::HLSFlowStepFactory(const DesignFlowManagerConstRef _design_flow_manager,
137  const HLS_managerRef _HLS_mgr, const ParameterConstRef _parameters)
138  : DesignFlowStepFactory(_design_flow_manager, _parameters), HLS_mgr(_HLS_mgr)
139 {
140  debug_level = parameters->get_class_debug_level(GET_CLASS(*this));
141 }
142 
143 HLSFlowStepFactory::~HLSFlowStepFactory() = default;
144 
145 const std::string HLSFlowStepFactory::GetPrefix() const
146 {
147  return "HLS";
148 }
149 
150 DesignFlowStepRef
151 HLSFlowStepFactory::CreateHLSFlowStep(const HLSFlowStep_Type type, const unsigned int funId,
152  const HLSFlowStepSpecializationConstRef hls_flow_step_specialization) const
153 {
154  INDENT_DBG_MEX(DEBUG_LEVEL_VERY_PEDANTIC, debug_level,
155  "-->Creating step " +
156  (funId ? HLSFunctionStep::ComputeSignature(type, hls_flow_step_specialization, funId) :
157  HLS_step::ComputeSignature(type, hls_flow_step_specialization)) +
158  " (" + HLS_step::EnumToName(type) + ")");
159  DesignFlowStepRef design_flow_step = DesignFlowStepRef();
160  switch(type)
161  {
162  case HLSFlowStep_Type::ADD_LIBRARY:
163  {
164  design_flow_step = DesignFlowStepRef(
165  new add_library(parameters, HLS_mgr, funId, design_flow_manager.lock(), hls_flow_step_specialization));
166  break;
167  }
168  case HLSFlowStep_Type::ALLOCATION:
169  {
170  design_flow_step = DesignFlowStepRef(new allocation(parameters, HLS_mgr, funId, design_flow_manager.lock()));
171  break;
172  }
173  case HLSFlowStep_Type::BB_STG_CREATOR:
174  {
175  design_flow_step = DesignFlowStepRef(new BB_based_stg(parameters, HLS_mgr, funId, design_flow_manager.lock()));
176  break;
177  }
178  case HLSFlowStep_Type::CALL_GRAPH_UNFOLDING:
179  {
180  design_flow_step = DesignFlowStepRef(new CallGraphUnfolding(parameters, HLS_mgr, design_flow_manager.lock()));
181  break;
182  }
183  case HLSFlowStep_Type::CDFC_MODULE_BINDING:
184  {
185  design_flow_step = DesignFlowStepRef(new cdfc_module_binding(
186  parameters, HLS_mgr, funId, design_flow_manager.lock(), hls_flow_step_specialization));
187  break;
188  }
189  case HLSFlowStep_Type::CHORDAL_COLORING_REGISTER_BINDING:
190  {
191  design_flow_step =
192  DesignFlowStepRef(new chordal_coloring_register(parameters, HLS_mgr, funId, design_flow_manager.lock()));
193  break;
194  }
195  case HLSFlowStep_Type::CLASSIC_DATAPATH_CREATOR:
196  {
197  design_flow_step =
198  DesignFlowStepRef(new classic_datapath(parameters, HLS_mgr, funId, design_flow_manager.lock()));
199  break;
200  }
201  case HLSFlowStep_Type::DATAPATH_CS_CREATOR:
202  {
203  design_flow_step = DesignFlowStepRef(new datapath_cs(parameters, HLS_mgr, funId, design_flow_manager.lock(),
204  HLSFlowStep_Type::DATAPATH_CS_CREATOR));
205  break;
206  }
207  case HLSFlowStep_Type::DATAPATH_CS_PARALLEL_CREATOR:
208  {
209  design_flow_step = DesignFlowStepRef(new datapath_parallel_cs(
210  parameters, HLS_mgr, funId, design_flow_manager.lock(), HLSFlowStep_Type::DATAPATH_CS_PARALLEL_CREATOR));
211  break;
212  }
213  case HLSFlowStep_Type::CLASSICAL_HLS_SYNTHESIS_FLOW:
214  {
215  design_flow_step =
216  DesignFlowStepRef(new ClassicalHLSSynthesisFlow(parameters, HLS_mgr, design_flow_manager.lock()));
217  break;
218  }
219  case HLSFlowStep_Type::COLORING_REGISTER_BINDING:
220  {
221  design_flow_step =
222  DesignFlowStepRef(new vertex_coloring_register(parameters, HLS_mgr, funId, design_flow_manager.lock()));
223  break;
224  }
225  case HLSFlowStep_Type::CONTROL_FLOW_CHECKER:
226  {
227  design_flow_step =
228  DesignFlowStepRef(new ControlFlowChecker(parameters, HLS_mgr, funId, design_flow_manager.lock()));
229  break;
230  }
231  case HLSFlowStep_Type::C_TESTBENCH_EXECUTION:
232  {
233  design_flow_step = DesignFlowStepRef(
234  new CTestbenchExecution(parameters, HLS_mgr, design_flow_manager.lock(), hls_flow_step_specialization));
235  break;
236  }
237  case HLSFlowStep_Type::DOMINATOR_ALLOCATION:
238  {
239  design_flow_step =
240  DesignFlowStepRef(new dominator_allocation(parameters, HLS_mgr, design_flow_manager.lock()));
241  break;
242  }
243  case HLSFlowStep_Type::DOMINATOR_FUNCTION_ALLOCATION:
244  {
245  design_flow_step =
246  DesignFlowStepRef(new fun_dominator_allocation(parameters, HLS_mgr, design_flow_manager.lock()));
247  break;
248  }
249  case HLSFlowStep_Type::DOMINATOR_MEMORY_ALLOCATION:
250  {
251  design_flow_step = DesignFlowStepRef(new mem_dominator_allocation(
252  parameters, HLS_mgr, design_flow_manager.lock(), hls_flow_step_specialization));
253  break;
254  }
255  case HLSFlowStep_Type::DOMINATOR_MEMORY_ALLOCATION_CS:
256  {
257  design_flow_step = DesignFlowStepRef(new mem_dominator_allocation_cs(
258  parameters, HLS_mgr, design_flow_manager.lock(), hls_flow_step_specialization,
259  HLSFlowStep_Type::DOMINATOR_MEMORY_ALLOCATION_CS));
260  break;
261  }
262  case HLSFlowStep_Type::DRY_RUN_EVALUATION:
263  {
264  design_flow_step = DesignFlowStepRef(new DryRunEvaluation(parameters, HLS_mgr, design_flow_manager.lock()));
265  break;
266  }
267  case HLSFlowStep_Type::EASY_MODULE_BINDING:
268  {
269  design_flow_step =
270  DesignFlowStepRef(new easy_module_binding(parameters, HLS_mgr, funId, design_flow_manager.lock()));
271  break;
272  }
273  case HLSFlowStep_Type::LIST_BASED_SCHEDULING:
274  {
275  design_flow_step = DesignFlowStepRef(new parametric_list_based(
276  parameters, HLS_mgr, funId, design_flow_manager.lock(), hls_flow_step_specialization));
277  break;
278  }
279  case HLSFlowStep_Type::EVALUATION:
280  {
281  design_flow_step = DesignFlowStepRef(new Evaluation(parameters, HLS_mgr, design_flow_manager.lock()));
282  break;
283  }
284  case HLSFlowStep_Type::FSM_CONTROLLER_CREATOR:
285  {
286  design_flow_step =
287  DesignFlowStepRef(new fsm_controller(parameters, HLS_mgr, funId, design_flow_manager.lock()));
288  break;
289  }
290  case HLSFlowStep_Type::FSM_CS_CONTROLLER_CREATOR:
291  {
292  design_flow_step = DesignFlowStepRef(new controller_cs(parameters, HLS_mgr, funId, design_flow_manager.lock(),
293  HLSFlowStep_Type::FSM_CS_CONTROLLER_CREATOR));
294  break;
295  }
296  case HLSFlowStep_Type::FSM_NI_SSA_LIVENESS:
297  {
298  design_flow_step =
299  DesignFlowStepRef(new FSM_NI_SSA_liveness(parameters, HLS_mgr, funId, design_flow_manager.lock()));
300  break;
301  }
302  case HLSFlowStep_Type::GENERATE_HDL:
303  {
304  design_flow_step = DesignFlowStepRef(new generate_hdl(parameters, HLS_mgr, design_flow_manager.lock()));
305  break;
306  }
307 #if HAVE_SIMULATION_WRAPPER_BUILT
308  case HLSFlowStep_Type::GENERATE_SIMULATION_SCRIPT:
309  {
310  design_flow_step =
311  DesignFlowStepRef(new GenerateSimulationScripts(parameters, HLS_mgr, design_flow_manager.lock()));
312  break;
313  }
314 #endif
315  case HLSFlowStep_Type::GENERATE_SYNTHESIS_SCRIPT:
316  {
317  design_flow_step =
318  DesignFlowStepRef(new GenerateSynthesisScripts(parameters, HLS_mgr, design_flow_manager.lock()));
319  break;
320  }
321 #if HAVE_TASTE
322  case HLSFlowStep_Type::GENERATE_TASTE_HDL_ARCHITECTURE:
323  {
324  design_flow_step =
325  DesignFlowStepRef(new GenerateTasteHDLArchitecture(parameters, HLS_mgr, design_flow_manager.lock()));
326  break;
327  }
328  case HLSFlowStep_Type::GENERATE_TASTE_SYNTHESIS_SCRIPT:
329  {
330  design_flow_step =
331  DesignFlowStepRef(new GenerateTasteSynthesisScript(parameters, HLS_mgr, design_flow_manager.lock()));
332  break;
333  }
334 #endif
335  case HLSFlowStep_Type::HLS_FUNCTION_BIT_VALUE:
336  {
337  design_flow_step =
338  DesignFlowStepRef(new HLSFunctionBitValue(parameters, HLS_mgr, funId, design_flow_manager.lock()));
339  break;
340  }
341  case HLSFlowStep_Type::HLS_SYNTHESIS_FLOW:
342  {
343  design_flow_step =
344  DesignFlowStepRef(new HLSSynthesisFlow(parameters, HLS_mgr, funId, design_flow_manager.lock()));
345  break;
346  }
347  case HLSFlowStep_Type::HW_PATH_COMPUTATION:
348  {
349  design_flow_step = DesignFlowStepRef(new HWPathComputation(parameters, HLS_mgr, design_flow_manager.lock()));
350  break;
351  }
352  case HLSFlowStep_Type::HW_DISCREPANCY_ANALYSIS:
353  {
354  design_flow_step =
355  DesignFlowStepRef(new HWDiscrepancyAnalysis(parameters, HLS_mgr, design_flow_manager.lock()));
356  break;
357  }
358  case HLSFlowStep_Type::INITIALIZE_HLS:
359  {
360  design_flow_step =
361  DesignFlowStepRef(new InitializeHLS(parameters, HLS_mgr, funId, design_flow_manager.lock()));
362  break;
363  }
364  case HLSFlowStep_Type::INTERFACE_CS_GENERATION:
365  {
366  design_flow_step = DesignFlowStepRef(new cs_interface(parameters, HLS_mgr, funId, design_flow_manager.lock()));
367  break;
368  }
369  case HLSFlowStep_Type::MINIMAL_INTERFACE_GENERATION:
370  {
371  design_flow_step =
372  DesignFlowStepRef(new minimal_interface(parameters, HLS_mgr, funId, design_flow_manager.lock()));
373  break;
374  }
375  case HLSFlowStep_Type::INFERRED_INTERFACE_GENERATION:
376  {
377  design_flow_step =
378  DesignFlowStepRef(new minimal_interface(parameters, HLS_mgr, funId, design_flow_manager.lock()));
379  break;
380  }
381  case HLSFlowStep_Type::MUX_INTERCONNECTION_BINDING:
382  {
383  design_flow_step =
384  DesignFlowStepRef(new mux_connection_binding(parameters, HLS_mgr, funId, design_flow_manager.lock()));
385  break;
386  }
387 #if HAVE_FROM_PRAGMA_BUILT
388  case HLSFlowStep_Type::OMP_ALLOCATION:
389  {
390  design_flow_step =
391  DesignFlowStepRef(new OmpAllocation(parameters, HLS_mgr, funId, design_flow_manager.lock()));
392  break;
393  }
394 #endif
395 #if HAVE_FROM_PRAGMA_BUILT
396  case HLSFlowStep_Type::OMP_BODY_LOOP_SYNTHESIS_FLOW:
397  {
398  design_flow_step =
399  DesignFlowStepRef(new OmpBodyLoopSynthesisFlow(parameters, HLS_mgr, funId, design_flow_manager.lock()));
400  break;
401  }
402 #endif
403 #if HAVE_FROM_PRAGMA_BUILT
404  case HLSFlowStep_Type::OMP_FOR_WRAPPER_CS_SYNTHESIS_FLOW:
405  {
406  design_flow_step = DesignFlowStepRef(
407  new OmpForWrapperCSSynthesisFlow(parameters, HLS_mgr, funId, design_flow_manager.lock()));
408  break;
409  }
410 #endif
411 #if HAVE_FROM_PRAGMA_BUILT
412  case HLSFlowStep_Type::OMP_FUNCTION_ALLOCATION:
413  {
414  design_flow_step =
415  DesignFlowStepRef(new OmpFunctionAllocation(parameters, HLS_mgr, design_flow_manager.lock()));
416  break;
417  }
418 #endif
419 #if HAVE_FROM_PRAGMA_BUILT
420  case HLSFlowStep_Type::OMP_FUNCTION_ALLOCATION_CS:
421  {
422  design_flow_step =
423  DesignFlowStepRef(new OmpFunctionAllocationCS(parameters, HLS_mgr, design_flow_manager.lock()));
424  break;
425  }
426 #endif
427  case HLSFlowStep_Type::PIPELINE_CONTROLLER_CREATOR:
428  {
429  design_flow_step =
430  DesignFlowStepRef(new pipeline_controller(parameters, HLS_mgr, funId, design_flow_manager.lock()));
431  break;
432  }
433  case HLSFlowStep_Type::PORT_SWAPPING:
434  {
435  design_flow_step =
436  DesignFlowStepRef(new port_swapping(parameters, HLS_mgr, funId, design_flow_manager.lock()));
437  break;
438  }
439  case HLSFlowStep_Type::SCHED_CHAINING:
440  {
441  design_flow_step = DesignFlowStepRef(
442  new sched_based_chaining_computation(parameters, HLS_mgr, funId, design_flow_manager.lock()));
443  break;
444  }
445 #if HAVE_ILP_BUILT
446  case HLSFlowStep_Type::SDC_SCHEDULING:
447  {
448  design_flow_step = DesignFlowStepRef(
449  new SDCScheduling(parameters, HLS_mgr, funId, design_flow_manager.lock(), hls_flow_step_specialization));
450  break;
451  }
452 #endif
453  case HLSFlowStep_Type::SIMULATION_EVALUATION:
454  {
455  design_flow_step =
456  DesignFlowStepRef(new SimulationEvaluation(parameters, HLS_mgr, design_flow_manager.lock()));
457  break;
458  }
459  case HLSFlowStep_Type::STANDARD_HLS_FLOW:
460  {
461  design_flow_step = DesignFlowStepRef(new standard_hls(parameters, HLS_mgr, funId, design_flow_manager.lock()));
462  break;
463  }
464 #if HAVE_LIBRARY_CHARACTERIZATION_BUILT
465  case HLSFlowStep_Type::SYNTHESIS_EVALUATION:
466  {
467  design_flow_step = DesignFlowStepRef(new SynthesisEvaluation(parameters, HLS_mgr, design_flow_manager.lock()));
468  break;
469  }
470 #endif
471 #if HAVE_TASTE
472  case HLSFlowStep_Type::TASTE_INTERFACE_GENERATION:
473  {
474  design_flow_step =
475  DesignFlowStepRef(new TasteInterfaceGeneration(parameters, HLS_mgr, funId, design_flow_manager.lock()));
476  break;
477  }
478 #endif
479  case HLSFlowStep_Type::TESTBENCH_GENERATION:
480  {
481  design_flow_step = DesignFlowStepRef(new TestbenchGeneration(parameters, HLS_mgr, design_flow_manager.lock()));
482  break;
483  }
484  case HLSFlowStep_Type::TEST_VECTOR_PARSER:
485  {
486  design_flow_step = DesignFlowStepRef(new TestVectorParser(parameters, HLS_mgr, design_flow_manager.lock()));
487  break;
488  }
489  case HLSFlowStep_Type::TOP_ENTITY_CREATION:
490  {
491  design_flow_step = DesignFlowStepRef(new top_entity(parameters, HLS_mgr, funId, design_flow_manager.lock()));
492  break;
493  }
494 
495  case HLSFlowStep_Type::TOP_ENTITY_CS_CREATION:
496  {
497  design_flow_step = DesignFlowStepRef(new top_entity_cs(parameters, HLS_mgr, funId, design_flow_manager.lock(),
498  HLSFlowStep_Type::TOP_ENTITY_CS_CREATION));
499  break;
500  }
501 
502  case HLSFlowStep_Type::TOP_ENTITY_CS_PARALLEL_CREATION:
503  {
504  design_flow_step =
505  DesignFlowStepRef(new top_entity_parallel_cs(parameters, HLS_mgr, funId, design_flow_manager.lock(),
506  HLSFlowStep_Type::TOP_ENTITY_CS_PARALLEL_CREATION));
507  break;
508  }
509  case HLSFlowStep_Type::TOP_ENTITY_MEMORY_MAPPED_CREATION:
510  {
511  design_flow_step =
512  DesignFlowStepRef(new TopEntityMemoryMapped(parameters, HLS_mgr, funId, design_flow_manager.lock()));
513  break;
514  }
515  case HLSFlowStep_Type::UNIQUE_MODULE_BINDING:
516  {
517  design_flow_step =
518  DesignFlowStepRef(new unique_binding(parameters, HLS_mgr, funId, design_flow_manager.lock()));
519  break;
520  }
521  case HLSFlowStep_Type::UNIQUE_REGISTER_BINDING:
522  {
523  design_flow_step =
524  DesignFlowStepRef(new unique_binding_register(parameters, HLS_mgr, funId, design_flow_manager.lock()));
525  break;
526  }
527  case HLSFlowStep_Type::VALUES_SCHEME_STORAGE_VALUE_INSERTION:
528  {
529  design_flow_step =
530  DesignFlowStepRef(new values_scheme(parameters, HLS_mgr, funId, design_flow_manager.lock()));
531  break;
532  }
533 #if HAVE_VCD_BUILT
534  case HLSFlowStep_Type::VCD_SIGNAL_SELECTION:
535  {
536  design_flow_step = DesignFlowStepRef(new VcdSignalSelection(parameters, HLS_mgr, design_flow_manager.lock()));
537  break;
538  }
539  case HLSFlowStep_Type::VCD_UTILITY:
540  {
541  design_flow_step = DesignFlowStepRef(new vcd_utility(parameters, HLS_mgr, design_flow_manager.lock()));
542  break;
543  }
544 #endif
545  case HLSFlowStep_Type::VIRTUAL_DESIGN_FLOW:
546  {
547  design_flow_step = DesignFlowStepRef(new virtual_hls(parameters, HLS_mgr, funId, design_flow_manager.lock()));
548  break;
549  }
550  case HLSFlowStep_Type::WB4_INTERFACE_GENERATION:
551  {
552  design_flow_step =
553  DesignFlowStepRef(new WB4_interface(parameters, HLS_mgr, funId, design_flow_manager.lock()));
554  break;
555  }
556  case HLSFlowStep_Type::WB4_INTERCON_INTERFACE_GENERATION:
557  {
558  design_flow_step =
559  DesignFlowStepRef(new WB4Intercon_interface(parameters, HLS_mgr, funId, design_flow_manager.lock()));
560  break;
561  }
562  case HLSFlowStep_Type::WEIGHTED_CLIQUE_REGISTER_BINDING:
563  {
564  design_flow_step = DesignFlowStepRef(new weighted_clique_register(
565  parameters, HLS_mgr, funId, design_flow_manager.lock(), hls_flow_step_specialization));
566  break;
567  }
568  case HLSFlowStep_Type::WRITE_HLS_SUMMARY:
569  {
570  design_flow_step = DesignFlowStepRef(new WriteHLSSummary(parameters, HLS_mgr, design_flow_manager.lock()));
571  break;
572  }
573  case HLSFlowStep_Type::UNKNOWN:
574  {
575  THROW_UNREACHABLE("");
576  break;
577  }
578  default:
579  THROW_UNREACHABLE("HLSFlowStep algorithm not supported");
580  }
581  INDENT_DBG_MEX(DEBUG_LEVEL_VERY_PEDANTIC, debug_level, "<--Created step " + design_flow_step->GetName());
582  return design_flow_step;
583 }
584 
585 const DesignFlowStepSet HLSFlowStepFactory::CreateHLSFlowSteps(
586  const CustomUnorderedSet<std::pair<HLSFlowStep_Type, HLSFlowStepSpecializationConstRef>>& hls_flow_steps) const
587 {
588  const CallGraphManagerConstRef call_graph_manager = HLS_mgr->CGetCallGraphManager();
589  DesignFlowStepSet ret;
590 
591  for(const auto& hls_flow_step : hls_flow_steps)
592  {
593  INDENT_DBG_MEX(DEBUG_LEVEL_VERY_PEDANTIC, debug_level,
594  "-->Creating step " + HLS_step::EnumToName(hls_flow_step.first));
595  switch(hls_flow_step.first)
596  {
597  case HLSFlowStep_Type::DRY_RUN_EVALUATION:
598  case HLSFlowStep_Type::EVALUATION:
599  case HLSFlowStep_Type::GENERATE_HDL:
600  case HLSFlowStep_Type::TEST_VECTOR_PARSER:
601  case HLSFlowStep_Type::CALL_GRAPH_UNFOLDING:
602  case HLSFlowStep_Type::CLASSICAL_HLS_SYNTHESIS_FLOW:
603  case HLSFlowStep_Type::DOMINATOR_ALLOCATION:
604  case HLSFlowStep_Type::DOMINATOR_MEMORY_ALLOCATION:
605  case HLSFlowStep_Type::DOMINATOR_MEMORY_ALLOCATION_CS:
606  case HLSFlowStep_Type::DOMINATOR_FUNCTION_ALLOCATION:
607 #if HAVE_SIMULATION_WRAPPER_BUILT
608  case HLSFlowStep_Type::GENERATE_SIMULATION_SCRIPT:
609 #endif
610  case HLSFlowStep_Type::GENERATE_SYNTHESIS_SCRIPT:
611  case HLSFlowStep_Type::HLS_SYNTHESIS_FLOW:
612  case HLSFlowStep_Type::HW_PATH_COMPUTATION:
613  case HLSFlowStep_Type::HW_DISCREPANCY_ANALYSIS:
614  case HLSFlowStep_Type::TESTBENCH_GENERATION:
615 #if HAVE_VCD_BUILT
616  case HLSFlowStep_Type::VCD_SIGNAL_SELECTION:
617  case HLSFlowStep_Type::VCD_UTILITY:
618 #endif
619  case HLSFlowStep_Type::WRITE_HLS_SUMMARY:
620 
621  {
622  ret.insert(CreateHLSFlowStep(hls_flow_step.first, 0, hls_flow_step.second));
623  break;
624  }
625  case HLSFlowStep_Type::UNKNOWN:
626  case HLSFlowStep_Type::ADD_LIBRARY:
627  case HLSFlowStep_Type::ALLOCATION:
628  case HLSFlowStep_Type::BB_STG_CREATOR:
629  case HLSFlowStep_Type::HLS_FUNCTION_BIT_VALUE:
630  case HLSFlowStep_Type::CDFC_MODULE_BINDING:
631  case HLSFlowStep_Type::CHORDAL_COLORING_REGISTER_BINDING:
632  case HLSFlowStep_Type::CLASSIC_DATAPATH_CREATOR:
633  case HLSFlowStep_Type::COLORING_REGISTER_BINDING:
634  case HLSFlowStep_Type::CONTROL_FLOW_CHECKER:
635  case HLSFlowStep_Type::C_TESTBENCH_EXECUTION:
636  case HLSFlowStep_Type::DATAPATH_CS_CREATOR:
637  case HLSFlowStep_Type::DATAPATH_CS_PARALLEL_CREATOR:
638  case HLSFlowStep_Type::EASY_MODULE_BINDING:
639  case HLSFlowStep_Type::FSM_CONTROLLER_CREATOR:
640  case HLSFlowStep_Type::FSM_CS_CONTROLLER_CREATOR:
641  case HLSFlowStep_Type::FSM_NI_SSA_LIVENESS:
642 #if HAVE_TASTE
643  case HLSFlowStep_Type::GENERATE_TASTE_HDL_ARCHITECTURE:
644  case HLSFlowStep_Type::GENERATE_TASTE_SYNTHESIS_SCRIPT:
645 #endif
646  case HLSFlowStep_Type::INFERRED_INTERFACE_GENERATION:
647  case HLSFlowStep_Type::INITIALIZE_HLS:
648  case HLSFlowStep_Type::INTERFACE_CS_GENERATION:
649  case HLSFlowStep_Type::LIST_BASED_SCHEDULING:
650  case HLSFlowStep_Type::MINIMAL_INTERFACE_GENERATION:
651  case HLSFlowStep_Type::MUX_INTERCONNECTION_BINDING:
652 #if HAVE_FROM_PRAGMA_BUILT
653  case HLSFlowStep_Type::OMP_ALLOCATION:
654 #endif
655 #if HAVE_FROM_PRAGMA_BUILT
656  case HLSFlowStep_Type::OMP_BODY_LOOP_SYNTHESIS_FLOW:
657 #endif
658 #if HAVE_FROM_PRAGMA_BUILT
659  case HLSFlowStep_Type::OMP_FOR_WRAPPER_CS_SYNTHESIS_FLOW:
660 #endif
661 #if HAVE_FROM_PRAGMA_BUILT
662  case HLSFlowStep_Type::OMP_FUNCTION_ALLOCATION:
663 #endif
664 #if HAVE_FROM_PRAGMA_BUILT
665  case HLSFlowStep_Type::OMP_FUNCTION_ALLOCATION_CS:
666 #endif
667  case HLSFlowStep_Type::PIPELINE_CONTROLLER_CREATOR:
668  case HLSFlowStep_Type::PORT_SWAPPING:
669  case HLSFlowStep_Type::SCHED_CHAINING:
670 #if HAVE_ILP_BUILT
671  case HLSFlowStep_Type::SDC_SCHEDULING:
672 #endif
673 #if HAVE_SIMULATION_WRAPPER_BUILT
674  case HLSFlowStep_Type::SIMULATION_EVALUATION:
675 #endif
676  case HLSFlowStep_Type::STANDARD_HLS_FLOW:
677 #if HAVE_LIBRARY_CHARACTERIZATION_BUILT
678  case HLSFlowStep_Type::SYNTHESIS_EVALUATION:
679 #endif
680 #if HAVE_TASTE
681  case HLSFlowStep_Type::TASTE_INTERFACE_GENERATION:
682 #endif
683  case HLSFlowStep_Type::TOP_ENTITY_CREATION:
684  case HLSFlowStep_Type::TOP_ENTITY_CS_CREATION:
685  case HLSFlowStep_Type::TOP_ENTITY_CS_PARALLEL_CREATION:
686  case HLSFlowStep_Type::TOP_ENTITY_MEMORY_MAPPED_CREATION:
687  case HLSFlowStep_Type::UNIQUE_MODULE_BINDING:
688  case HLSFlowStep_Type::UNIQUE_REGISTER_BINDING:
689  case HLSFlowStep_Type::VALUES_SCHEME_STORAGE_VALUE_INSERTION:
690  case HLSFlowStep_Type::VIRTUAL_DESIGN_FLOW:
691  case HLSFlowStep_Type::WB4_INTERCON_INTERFACE_GENERATION:
692  case HLSFlowStep_Type::WB4_INTERFACE_GENERATION:
693  case HLSFlowStep_Type::WEIGHTED_CLIQUE_REGISTER_BINDING:
694  default:
695  THROW_UNREACHABLE("Step not expected: " + HLS_step::EnumToName(hls_flow_step.first));
696  }
697  INDENT_DBG_MEX(DEBUG_LEVEL_VERY_PEDANTIC, debug_level,
698  "<--Created step " + HLS_step::EnumToName(hls_flow_step.first));
699  }
700  return ret;
701 }
702 
703 const DesignFlowStepSet HLSFlowStepFactory::CreateHLSFlowSteps(
704  const std::pair<HLSFlowStep_Type, HLSFlowStepSpecializationConstRef>& hls_flow_step) const
705 {
706  CustomUnorderedSet<std::pair<HLSFlowStep_Type, HLSFlowStepSpecializationConstRef>> hls_flow_steps;
707  hls_flow_steps.insert(hls_flow_step);
708  return CreateHLSFlowSteps(hls_flow_steps);
709 }
710 
711 const DesignFlowStepSet
712 HLSFlowStepFactory::CreateHLSFlowSteps(const HLSFlowStep_Type type,
713  const HLSFlowStepSpecializationConstRef hls_flow_step_specialization) const
714 {
715  const std::pair<HLSFlowStep_Type, HLSFlowStepSpecializationConstRef> hls_flow_step(type,
716  hls_flow_step_specialization);
717  return CreateHLSFlowSteps(hls_flow_step);
718 }
719 
720 const DesignFlowStepRef HLSFlowStepFactory::CreateHLSFlowStep(
721  const std::pair<HLSFlowStep_Type, HLSFlowStepSpecializationConstRef>& hls_flow_step) const
722 {
723  return *CreateHLSFlowSteps(hls_flow_step).cbegin();
724 }
725 
726 const DesignFlowStepRef
727 HLSFlowStepFactory::CreateHLSFlowStep(const HLSFlowStep_Type type,
728  const HLSFlowStepSpecializationConstRef hls_flow_step_specialization) const
729 {
730  return *CreateHLSFlowSteps(type, hls_flow_step_specialization).cbegin();
731 }
evaluation.hpp
Class to compute evaluations about high-level synthesis.
HLS_step::ComputeSignature
static const std::string ComputeSignature(const HLSFlowStep_Type hls_flow_step_type, const HLSFlowStepSpecializationConstRef hls_flow_step_specialization)
Compute the signature of a hls flow step.
Definition: hls_step.cpp:116
standard_hls
Definition: standard_hls.hpp:48
HLSFlowStep_Type::UNIQUE_REGISTER_BINDING
HLSFlowStep_Type::CALL_GRAPH_UNFOLDING
HLSFlowStepFactory::HLS_mgr
const HLS_managerRef HLS_mgr
The HLS manager.
Definition: hls_flow_step_factory.hpp:60
DEBUG_LEVEL_VERY_PEDANTIC
#define DEBUG_LEVEL_VERY_PEDANTIC
extremely verbose debugging print is performed.
Definition: dbgPrintHelper.hpp:86
HLSFlowStep_Type::C_TESTBENCH_EXECUTION
DesignFlowStepFactory::parameters
const ParameterConstRef parameters
The set of input parameters.
Definition: design_flow_step_factory.hpp:61
INDENT_DBG_MEX
#define INDENT_DBG_MEX(dbgLevel, curDbgLevel, mex)
We are producing a debug version of the program, so the message is printed;.
Definition: dbgPrintHelper.hpp:140
cdfc_module_binding.hpp
Module binding based on the analysis of the control data flow chained graph.
HLSFlowStep_Type::INTERFACE_CS_GENERATION
HLSFlowStepFactory::CreateHLSFlowSteps
const DesignFlowStepSet CreateHLSFlowSteps(const CustomUnorderedSet< std::pair< HLSFlowStep_Type, HLSFlowStepSpecializationConstRef >> &hls_flow_steps) const
Create the frontend design flow steps.
Definition: hls_flow_step_factory.cpp:585
dbgPrintHelper.hpp
File containing functions and utilities to support the printing of debug messagges.
controller_cs.hpp
Base class for all the controller creation algorithms.
HLSFlowStep_Type::TOP_ENTITY_CS_PARALLEL_CREATION
add_library.hpp
This step adds the current module to the technology library.
vertex_coloring_register
Definition: vertex_coloring_register.hpp:48
HLSFlowStep_Type::TOP_ENTITY_CS_CREATION
synthesis_evaluation.hpp
HLSFlowStep_Type::DOMINATOR_MEMORY_ALLOCATION_CS
HLSFlowStep_Type::MINIMAL_INTERFACE_GENERATION
HLSFlowStep_Type::VIRTUAL_DESIGN_FLOW
generate_simulation_scripts.hpp
Wrapper used to generate simulation scripts.
GET_CLASS
#define GET_CLASS(obj)
Macro returning the actual type of an object.
Definition: string_manipulation.hpp:178
weighted_clique_register.hpp
Weighted clique covering register allocation procedure.
hls_function_bit_value.hpp
Proxy class calling the bit value analysis just before the hls_bit_value step taking into account the...
taste_interface_generation.hpp
Class to generate interface for taste architecture.
HLSFlowStep_Type::FSM_CS_CONTROLLER_CREATOR
HLSFlowStep_Type::GENERATE_HDL
test_panda.type
type
Definition: test_panda.py:447
HLSFlowStep_Type::TOP_ENTITY_MEMORY_MAPPED_CREATION
HLSFlowStep_Type::WEIGHTED_CLIQUE_REGISTER_BINDING
fsm_controller.hpp
Header class for the creation of the classical FSM controller.
datapath_parallel_cs
Definition: datapath_parallel_cs.hpp:50
top_entity.hpp
Base class for the top entity creation.
generate_hdl
Definition: generate_hdl.hpp:50
HLSFlowStep_Type::VALUES_SCHEME_STORAGE_VALUE_INSERTION
classic_datapath.hpp
Base class for usual datapath creation.
omp_function_allocation_CS.hpp
pipeline_controller
Definition: pipeline_controller.hpp:52
testbench_generation.hpp
Generate HDL testbench for the top-level kernel testing.
values_scheme
Definition: values_scheme.hpp:65
WB4_interface
Definition: WB4_interface.hpp:63
HLSFlowStep_Type::TESTBENCH_GENERATION
SynthesisEvaluation
superclass include
Definition: synthesis_evaluation.hpp:56
top_entity_cs
Definition: top_entity_cs.hpp:44
HLSFlowStep_Type::MUX_INTERCONNECTION_BINDING
HLSFlowStep_Type::EVALUATION
HLSFlowStepFactory::HLSFlowStepFactory
HLSFlowStepFactory(const DesignFlowManagerConstRef design_flow_manager, const HLS_managerRef _HLS_mgr, const ParameterConstRef parameters)
Constructor.
Definition: hls_flow_step_factory.cpp:136
HLSFlowStep_Type::UNIQUE_MODULE_BINDING
WB4Intercon_interface.hpp
Module for the generation of the top WB4 component.
HLSFunctionStep::ComputeSignature
static std::string ComputeSignature(const HLSFlowStep_Type hls_flow_step_type, const HLSFlowStepSpecializationConstRef hls_flow_step_specialization, const unsigned int function_id)
Compute the signature of a hls flow step.
Definition: hls_function_step.cpp:123
HLSFlowStep_Type::LIST_BASED_SCHEDULING
HLSFlowStep_Type::DRY_RUN_EVALUATION
datapath_parallel_cs.hpp
chordal_coloring_register
Class containing the chordal coloring algorithm implementation.
Definition: chordal_coloring_register.hpp:54
mem_dominator_allocation
Definition: mem_dominator_allocation.hpp:59
HLSFlowStep_Type::CHORDAL_COLORING_REGISTER_BINDING
string_manipulation.hpp
Auxiliary methods for manipulating string.
HLSFlowStep_Type::OMP_BODY_LOOP_SYNTHESIS_FLOW
hls_synthesis_flow.hpp
Definition of the class to create the structural description of a function.
HLSFlowStep_Type::GENERATE_SIMULATION_SCRIPT
dry_run_evaluation.hpp
HLSFlowStep_Type::WB4_INTERFACE_GENERATION
simulation_evaluation.hpp
HLSFlowStep_Type::HW_PATH_COMPUTATION
THROW_UNREACHABLE
#define THROW_UNREACHABLE(str_expr)
helper function used to specify that some points should never be reached
Definition: exceptions.hpp:292
controller_cs
Definition: controller_cs.hpp:44
hls_flow_step_factory.hpp
Factory for hls flow step.
HLS_step::EnumToName
static std::string EnumToName(const HLSFlowStep_Type hls_flow_step_type)
Given a HLS flow step type, return the name of the type.
Definition: hls_step.cpp:134
HLSFlowStep_Type::TOP_ENTITY_CREATION
scheduling.hpp
Base class for all scheduling algorithms.
vcd_utility.hpp
BB_based_stg
Definition: BB_based_stg.hpp:50
design_flow_step.hpp
Base class for step of design flow.
virtual_hls
Definition: virtual_hls.hpp:48
HLSFlowStep_Type::ADD_LIBRARY
HLSFlowStep_Type::DOMINATOR_MEMORY_ALLOCATION
classical_synthesis_flow.hpp
Classical synthesis flow.
mem_dominator_allocation.hpp
Class to allocate memories in HLS based on dominators.
HLSFlowStep_Type::BB_STG_CREATOR
WB4Intercon_interface
Class generating the top WB4 module.
Definition: WB4Intercon_interface.hpp:46
sched_based_chaining_computation
Definition: sched_based_chaining_computation.hpp:46
omp_body_loop_synthesis_flow.hpp
Definition of the class to create the structural description for body loop of openmp for...
fun_dominator_allocation
Definition: fun_dominator_allocation.hpp:49
HLSFlowStep_Type::SCHED_CHAINING
chordal_coloring_register.hpp
Class specification of the register allocation algorithms based on chordal algorithm.
cdfc_module_binding
Class managing the module allocation.
Definition: cdfc_module_binding.hpp:378
HLSFlowStep_Type
HLSFlowStep_Type
Definition: hls_step.hpp:95
initialize_hls.hpp
Step which intializes hls data structur.
FSM_NI_SSA_liveness
Definition: FSM_NI_SSA_liveness.hpp:50
control_flow_checker.hpp
fun_dominator_allocation.hpp
Class to allocate function in HLS based on dominators.
HLSFlowStep_Type::DOMINATOR_FUNCTION_ALLOCATION
generate_taste_synthesis_script.hpp
Wrapper used to generate synthesis script for taste.
mem_dominator_allocation_cs
Definition: mem_dominator_allocation_cs.hpp:45
mem_dominator_allocation_cs.hpp
weighted_clique_register
Definition: weighted_clique_register.hpp:72
custom_set.hpp
redefinition of set to manage ordered/unordered structures
DryRunEvaluation
base class include
Definition: dry_run_evaluation.hpp:48
HLSFlowStep_Type::FSM_NI_SSA_LIVENESS
sched_based_chaining_computation.hpp
chaining computation starting from the results of the scheduling step
add_library
Definition: add_library.hpp:81
test_vector_parser.hpp
sdc_scheduling.hpp
Class definition of the sdc scheduling.
easy_module_binding
superclass include
Definition: easy_module_binding.hpp:51
HLSFlowStep_Type::FSM_CONTROLLER_CREATOR
top_entity_parallel_cs
Definition: top_entity_parallel_cs.hpp:46
TopEntityMemoryMapped.hpp
Construction of top entity memory mapped interface.
HLSFlowStep_Type::DOMINATOR_ALLOCATION
datapath_cs
Definition: datapath_cs.hpp:46
standard_hls.hpp
Definition of the class to create the structural description of the component.
parametric_list_based
Class managing list based scheduling algorithms.
Definition: parametric_list_based.hpp:144
HLSFlowStep_Type::CLASSIC_DATAPATH_CREATOR
minimal_interface.hpp
Class to generate minimal interfaces for high-level synthesis.
HLSFlowStep_Type::EASY_MODULE_BINDING
HLSFlowStep_Type::CONTROL_FLOW_CHECKER
allocation
This wrapper collects all the methods used by the High-level synthesis classes to retrieve informatio...
Definition: allocation.hpp:102
BB_based_stg.hpp
HLSFlowStep_Type::INITIALIZE_HLS
vcd_utility
Definition: vcd_utility.hpp:96
values_scheme.hpp
Class specification of values scheme for the storage value insertion phase.
unique_binding_register
Definition: unique_binding_register.hpp:51
HLSFlowStep_Type::DATAPATH_CS_PARALLEL_CREATOR
write_hls_summary.hpp
Class to dump hls summary.
HLSFlowStep_Type::COLORING_REGISTER_BINDING
parametric_list_based.hpp
Class definition of the list_based structure.
Wrefcount::lock
refcount< T > lock() const
Definition: refcount.hpp:212
HLSFlowStep_Type::HW_DISCREPANCY_ANALYSIS
generate_hdl.hpp
Class used to generate HDL files.
HLSFlowStep_Type::STANDARD_HLS_FLOW
vertex_coloring_register.hpp
Class specification of a coloring based register allocation algorithm.
port_swapping
superclass include
Definition: port_swapping.hpp:53
OmpAllocation
Superclass include.
Definition: omp_allocation.hpp:50
HLSFlowStep_Type::CDFC_MODULE_BINDING
DesignFlowStepRef
refcount< DesignFlowStep > DesignFlowStepRef
Definition: design_flow_step.hpp:229
HLSFlowStep_Type::HLS_FUNCTION_BIT_VALUE
cs_interface
Definition: cs_interface.hpp:47
pipeline_controller.hpp
Header class for the creation of a shift register controlling a pipeline.
top_entity_parallel_cs.hpp
DesignFlowStepFactory::design_flow_manager
const Wrefcount< const DesignFlowManager > design_flow_manager
The design flow manager.
Definition: design_flow_step_factory.hpp:58
HLSFlowStep_Type::PIPELINE_CONTROLLER_CREATOR
DesignFlowStepFactory::debug_level
int debug_level
The debug level.
Definition: design_flow_step_factory.hpp:64
unique_binding_register.hpp
Class specification of unique binding register allocation algorithm.
omp_for_wrapper_cs_synthesis_flow.hpp
HLSFlowStep_Type::HLS_SYNTHESIS_FLOW
cs_interface.hpp
Class to generate the interface for the context switch project.
refcount
Template borrowed from the ANTLR library by Terence Parr (http://www.jGuru.com - Software rights: htt...
Definition: refcount.hpp:94
HLSFlowStepFactory::GetPrefix
const std::string GetPrefix() const override
Return the prefix of the steps created by the factory.
Definition: hls_flow_step_factory.cpp:145
fsm_controller
Definition: fsm_controller.hpp:52
WB4_interface.hpp
Class to generate WB4 interfaces for high-level synthesis.
dominator_allocation
Definition: dominator_allocation.hpp:49
HLSFlowStep_Type::CLASSICAL_HLS_SYNTHESIS_FLOW
HLSFlowStepFactory::~HLSFlowStepFactory
~HLSFlowStepFactory() override
Destructor.
virtual_hls.hpp
Basic HLS flow.
generate_synthesis_scripts.hpp
Wrapper used to generate synthesis scripts.
omp_function_allocation.hpp
Class to allocate function in HLS based on dominators and openmp information.
Parameter.hpp
this class is used to manage the command-line or XML options.
dominator_allocation.hpp
Composed pass to wrap function and memory dominator allocation.
HLSFlowStep_Type::WB4_INTERCON_INTERFACE_GENERATION
datapath_cs.hpp
compatibility_based_register.hpp
Base class specification for register allocation algorithm based on a compatibility graph...
FSM_NI_SSA_liveness.hpp
liveness analysis exploiting the SSA form of the IR
HLSFlowStep_Type::UNKNOWN
unique_binding
Class managing the module allocation.
Definition: unique_binding.hpp:50
HLSFlowStep_Type::DATAPATH_CS_CREATOR
call_graph_manager.hpp
Wrapper to call graph.
HLSFlowStep_Type::GENERATE_SYNTHESIS_SCRIPT
classic_datapath
Definition: classic_datapath.hpp:53
mux_connection_binding.hpp
Class to manage mux-based interconnections based on the FSM controller.
allocation.hpp
This package is used by all HLS packages to manage resource constraints and characteristics.
TopEntityMemoryMapped
Build a wrapper layer on the top entity implementing the momory mapped interface. ...
Definition: TopEntityMemoryMapped.hpp:68
TasteInterfaceGeneration
Class generating taste interfaces.
Definition: taste_interface_generation.hpp:54
top_entity_cs.hpp
WriteHLSSummary
Superclass include.
Definition: write_hls_summary.hpp:46
mux_connection_binding
Class managing the connection binding of datapath.
Definition: mux_connection_binding.hpp:72
HLSFlowStep_Type::ALLOCATION
minimal_interface
Class generating minimal interfaces.
Definition: minimal_interface.hpp:56
easy_module_binding.hpp
Partial module binding based on simple conditions.
generate_taste_hdl_architecture.hpp
Implementation of the class to generate the top HDL taste architecture.
port_swapping.hpp
Implementation of the port swapping algorithm described in the following paper: Hao Cong...
HLSFlowStep_Type::WRITE_HLS_SUMMARY
unique_binding.hpp
Class to create a unique binding.
omp_allocation.hpp
This package is used by all HLS packages to manage resource constraints and characteristics.
top_entity
Definition: top_entity.hpp:50
HLSFlowStep_Type::PORT_SWAPPING
memory.hpp
Datastructure to represent memory information in high-level synthesis.
HLSFlowStepFactory::CreateHLSFlowStep
DesignFlowStepRef CreateHLSFlowStep(const HLSFlowStep_Type hls_flow_step_type, const unsigned int funId, const HLSFlowStepSpecializationConstRef hls_flow_step_specialization=HLSFlowStepSpecializationConstRef()) const
Create a scheduling design flow step.
Definition: hls_flow_step_factory.cpp:151
tree_manager.hpp
Class specification of the manager of the tree structures extracted from the raw file.
HLSFlowStep_Type::INFERRED_INTERFACE_GENERATION
HLSFlowStep_Type::TEST_VECTOR_PARSER
Generated on Mon Feb 12 2024 13:02:53 for PandA-2024.02 by doxygen 1.8.13