simplified macros

src/kiter/kiter.cpp

@@ -163,7 +163,7 @@ int main (int argc, char **argv)
         if (const auto *transformation = KiterRegistry<transformation_action_t>::get(name)) {
             VERBOSE_INFO ("Run transformation " << transformation->name);
             transformation->fun(csdf,params);
-        } else if (const auto *buffer_sizing = KiterRegistry<buffer_sizing_action_t>::get(name);) {
+        } else if (const auto *buffer_sizing = KiterRegistry<buffer_sizing_action_t>::get(name)) {
             VERBOSE_INFO ("Run buffer sizing " << buffer_sizing->name);
             models::BufferSizingResult res = buffer_sizing->fun(csdf,params);
             VERBOSE_INFO ("Total size is " << res.total_size());

src/libkiter/algorithms/analysis/cycle_detection.h

@@ -47,10 +47,8 @@ void cycle_detection       (models::Dataflow* const  dataflow, parameters_list_t
 }
 
 
-ADD_ANALYSIS(CycleDetection,
-                   analysis_action_t({ "CycleDetection" , "Returns 1 if there is a cycle in the graph and 0 if not..", algorithms::cycle_detection}));
-ADD_ANALYSIS(CycleCount,
-                   analysis_action_t({ "CycleCount" , "Count number of simple cycles in graph.", algorithms::find_simple_cycles}));
+ADD_ANALYSIS(CycleDetection, "Returns 1 if there is a cycle in the graph and 0 if not..", algorithms::cycle_detection);
+ADD_ANALYSIS(CycleCount,"Count number of simple cycles in graph.", algorithms::find_simple_cycles);
 
 
 

src/libkiter/algorithms/buffersizing/backpressure.h

@@ -18,8 +18,7 @@ class Dataflow;
 namespace algorithms {
     models::BufferSizingResult compute_backpressure_memory_sizing (models::Dataflow* const  dataflow, parameters_list_t);
 }
-ADD_BUFFER_SIZING(BackPressureSizing,
-		buffer_sizing_action_t({ "BackPressureSizing" , "Buffer sizing method from Wiggers et al DAC 2007 paper.", algorithms::compute_backpressure_memory_sizing}));
+ADD_BUFFER_SIZING(BackPressureSizing, "Buffer sizing method from Wiggers et al DAC 2007 paper.", algorithms::compute_backpressure_memory_sizing);
 
 
 #endif /* BACKPRESSURE_H_ */

src/libkiter/algorithms/buffersizing/periodic.h

@@ -21,6 +21,7 @@ namespace algorithms {
 
 
 ADD_BUFFER_SIZING(PeriodicSizing,
-		buffer_sizing_action_t({ "PeriodicSizing" , "Minimal Buffer size estimation by periodic scheduling method.", algorithms::compute_csdf_1periodic_memory}));
+    "Minimal Buffer size estimation by periodic scheduling method.",
+    algorithms::compute_csdf_1periodic_memory);
 
 #endif /* THROUGHPUT_H_ */

src/libkiter/algorithms/buffersizing/periodic_fixed.h

@@ -40,12 +40,8 @@ namespace algorithms {
 } // end of namespace algorithms
 
 //Buffer sizing techniques
-ADD_BUFFER_SIZING(SPeriodicSizing,
-buffer_sizing_action_t({ "SPeriodicSizing" , "Minimal Buffer size estimation by periodic scheduling with StrictlyPeriodic policy.", algorithms::compute_strictly_periodic_memory}));
-ADD_BUFFER_SIZING(FixedOffsetBufferSizing,
-                  buffer_sizing_action_t({ "FixedOffsetBufferSizing" , "Minimal Buffer size estimation by periodic scheduling with fixed offset buffer sizing techniques (BURST, AVERAGE, MINMAX, WIGGERS). Define chosen sizing technique as parameter.", algorithms::compute_fixed_offset_buffer_sizing}));
-
-ADD_TRANSFORMATION(AddVBuffers,
-transformation_action_t({ "AddVBuffers" , "Add virtual buffers for each edge in dataflow graph", algorithms::add_vbuffers}));
+ADD_BUFFER_SIZING(SPeriodicSizing, "Minimal Buffer size estimation by periodic scheduling with StrictlyPeriodic policy.", algorithms::compute_strictly_periodic_memory);
+ADD_BUFFER_SIZING(FixedOffsetBufferSizing, "Minimal Buffer size estimation by periodic scheduling with fixed offset buffer sizing techniques (BURST, AVERAGE, MINMAX, WIGGERS). Define chosen sizing technique as parameter.", algorithms::compute_fixed_offset_buffer_sizing);
 
+ADD_TRANSFORMATION(AddVBuffers, "Add virtual buffers for each edge in dataflow graph", algorithms::add_vbuffers);
 #endif /* PERIODIC_FIXED_H_ */

src/libkiter/algorithms/dse/ThroughputBufferingDSE.h

@@ -57,11 +57,8 @@ namespace algorithms {
 
 
 ADD_THROUGHPUT_BUFFERING_DSE(throughputbufferingDSE,
-                   throughput_buffering_dse_action_t({
-                                            "throughputbufferingDSE",
                                             "DSE that solve the throughputbuffering problem for a graph with \"feedback\" buffers",
-                                            algorithms::dse::throughput_buffering_dse}
-                   ));
+                                            algorithms::dse::throughput_buffering_dse);
 
 
 

src/libkiter/algorithms/dse/deep_dse.h

@@ -27,7 +27,6 @@ std::pair<TIME_UNIT, std::vector<StorageDistribution>> get_next_storage_distribu
                                                                                                          const std::map<Edge,Edge>& matching, const std::map<Edge, TOKEN_UNIT> & minStepSizes, bool approx) ;
 StorageDistribution update_storage_distribution_from_cc(const StorageDistribution &sd_g, const StorageDistribution& sd_cc);
 
-ADD_THROUGHPUT_BUFFERING_DSE(DeepKPeriodicThroughputwithDSE,
-                   throughput_buffering_dse_action_t({"DeepKPeriodicThroughputwithDSE", "Experiment", algorithms::deep_dse_user}));
+ADD_THROUGHPUT_BUFFERING_DSE(DeepKPeriodicThroughputwithDSE, "Experiment", algorithms::deep_dse_user);
 
 #endif //KITER_DEEP_DSE_H

src/libkiter/algorithms/dse/dichotomous_search.h

@@ -23,8 +23,6 @@ namespace algorithms {
 	StorageDistributionSet compute_csdf_dse_from_function   (models::Dataflow* const  dataflow, const BufferSizingFun& sizing_fun, std::ostream& dseLog) ;
 }
 
-ADD_THROUGHPUT_BUFFERING_DSE(PeriodicDSE,
-		throughput_buffering_dse_action_t({ "PeriodicDSE" , "Bodin2013 Periodic DSE", algorithms::compute_csdf_dse_periodic}));
-ADD_THROUGHPUT_BUFFERING_DSE(SPeriodicDSE,
-		throughput_buffering_dse_action_t({ "SPeriodicDSE" , "Experimental Strictly Periodic DSE", algorithms::compute_csdf_dse_speriodic}));
+ADD_THROUGHPUT_BUFFERING_DSE(PeriodicDSE, "Bodin2013 Periodic DSE", algorithms::compute_csdf_dse_periodic);
+ADD_THROUGHPUT_BUFFERING_DSE(SPeriodicDSE,"Experimental Strictly Periodic DSE", algorithms::compute_csdf_dse_speriodic);
 #endif /* SRC_LIBKITER_ALGORITHMS_DSE_DICHOTOMOUS_SEARCH_H_ */

src/libkiter/algorithms/dse/kperiodic.h

@@ -47,8 +47,7 @@ void updateGraphwMatching(models::Dataflow* dataflow, const std::map<Edge,Edge>&
 
 
 
-ADD_THROUGHPUT_BUFFERING_DSE(KPeriodicThroughputwithDSE,
-		throughput_buffering_dse_action_t({"KPeriodicThroughputwithDSE", "Combine buffer space exploration with throughput evaluation of CSDF by K-periodic scheduling method", algorithms::compute_Kperiodic_throughput_dse_sd}));
+ADD_THROUGHPUT_BUFFERING_DSE(KPeriodicThroughputwithDSE, "Combine buffer space exploration with throughput evaluation of CSDF by K-periodic scheduling method", algorithms::compute_Kperiodic_throughput_dse_sd);
 
 
 #endif /* SRC_LIBKITER_ALGORITHMS_DSE_KPERIODIC_H_ */

src/libkiter/algorithms/experiments/expansion_experiment.h

@@ -19,5 +19,4 @@ void generate_expansion       (models::Dataflow* const  dataflow, parameters_lis
 }
 
 
-ADD_TRANSFORMATION(PartialExpansion,
-		transformation_action_t({ "PartialExpansion" , "Generate the Partial Expansion Graph from WIP.", algorithms::generate_expansion}));
+ADD_TRANSFORMATION(PartialExpansion,"Generate the Partial Expansion Graph from WIP.", algorithms::generate_expansion);

src/libkiter/algorithms/liveness/LivenessModularDSE.h

@@ -34,11 +34,8 @@ namespace algorithms {
 
 
 ADD_THROUGHPUT_BUFFERING_DSE(LivenessDSE,
-                   throughput_buffering_dse_action_t({
-                       "LivenessDSE" ,
                        "DSE that solve the liveness problem for a graph with \"feedback\" buffers",
-                       algorithms::dse::liveness_dse}
-                       ));
+                       algorithms::dse::liveness_dse);
 
 
 #endif //KITER_LIVENESS_MODULAR_DSE_H

src/libkiter/algorithms/liveness/SC.h

@@ -20,8 +20,7 @@ namespace algorithms {
     }
 }
 
-ADD_ANALYSIS(LivenessSC,
- analysis_action_t({ "LivenessSC" , "Use the SC1 and SC2 liveness condition to check liveness over a dataflow (Benazouz, DAC13).", algorithms::liveness::LivenessSC}));
+ADD_ANALYSIS(LivenessSC, "Use the SC1 and SC2 liveness condition to check liveness over a dataflow (Benazouz, DAC13).", algorithms::liveness::LivenessSC);
 
 
 

src/libkiter/algorithms/mappings.h

@@ -38,31 +38,15 @@ namespace algorithms {
 
 }
 // Helpers to map vertex to cores, need a way to also consider routers
-ADD_TRANSFORMATION(createNoC,
-	transformation_action_t({ "createNoC" , "Create NoC based on file inserted", algorithms::mapping::createNoC} )
-);
-ADD_TRANSFORMATION(randomMapping,
-		transformation_action_t({ "randomMapping" , "This command will associate a mapping to each task of the graph. Task unspecified as parameters will be randomly allocated to a core.", algorithms::mapping::randomMapping} )
-);
-ADD_TRANSFORMATION(generateTDMA,
-		transformation_action_t({ "generateTDMA" , "Change seed.", algorithms::mapping::generateTDMA} )
-);
-ADD_TRANSFORMATION(moduloMapping,
-		transformation_action_t({ "moduloMapping" , "This command will associate a mapping to each task of the graph. Task unspecified as parameters will be randomly allocated to a core.", algorithms::mapping::moduloMapping} )
-);
-ADD_TRANSFORMATION(BufferlessNoCMapAndRoute,
-		transformation_action_t({ "BufferlessNoCMapAndRoute" , "Mapping and Routing combined.", algorithms::mapping::BufferlessNoCMapAndRoute} )
-);
-ADD_TRANSFORMATION(xyRouting,
-		transformation_action_t({ "xyRouting" , "Create X-Y routing", algorithms::mapping::xyRouting} )
-);
-
-ADD_TRANSFORMATION(randomRouting,
-		transformation_action_t({ "randomRouting" , "Create random X-Y routing", algorithms::mapping::randomRouting} )
-);
-ADD_TRANSFORMATION(ModelNoCConflictFreeCommunication,
-		transformation_action_t({ "ModelNoCConflictFreeCommunication" , "Given a graph with Mapping, can add fictive task to model network", algorithms::ModelNoCConflictFreeCommunication} )
-);
+ADD_TRANSFORMATION(createNoC, "Create NoC based on file inserted", algorithms::mapping::createNoC);
+ADD_TRANSFORMATION(randomMapping, "This command will associate a mapping to each task of the graph. Task unspecified as parameters will be randomly allocated to a core.", algorithms::mapping::randomMapping);
+ADD_TRANSFORMATION(generateTDMA, "Change seed.", algorithms::mapping::generateTDMA);
+ADD_TRANSFORMATION(moduloMapping, "This command will associate a mapping to each task of the graph. Task unspecified as parameters will be randomly allocated to a core.", algorithms::mapping::moduloMapping);
+ADD_TRANSFORMATION(BufferlessNoCMapAndRoute, "Mapping and Routing combined.", algorithms::mapping::BufferlessNoCMapAndRoute);
+ADD_TRANSFORMATION(xyRouting, "Create X-Y routing", algorithms::mapping::xyRouting);
+
+ADD_TRANSFORMATION(randomRouting, "Create random X-Y routing", algorithms::mapping::randomRouting);
+ADD_TRANSFORMATION(ModelNoCConflictFreeCommunication , "Given a graph with Mapping, can add fictive task to model network", algorithms::ModelNoCConflictFreeCommunication);
 
 
 #endif

src/libkiter/algorithms/scheduling/TDMAScheduler.h

@@ -122,7 +122,6 @@ void TDMASchedule    (models::Dataflow* const , parameters_list_t  parameters  )
 }
 
 
-ADD_ANALYSIS(TDMASchedule,
-		analysis_action_t({ "TDMASchedule" , "Execute the TDMA schedule for given list of packets", algorithms::scheduling::TDMASchedule}));
+ADD_ANALYSIS(TDMASchedule, "Execute the TDMA schedule for given list of packets", algorithms::scheduling::TDMASchedule);
 
 #endif /* SRC_LIBKITER_ALGORITHMS_SCHEDULING_TDMASCHEDULER_H_ */

src/libkiter/algorithms/schedulings.h

@@ -75,39 +75,17 @@ models::Scheduling BufferlessNoCScheduling(models::Dataflow* const  dataflow, pa
 
 // Recent stuff
 
-ADD_SCHEDULING(REALLP1,
-scheduling_action_t({ "REALLP1" , "Fully periodic scheduling for CSDF inefficient way", algorithms::scheduling::CSDF_Real1PeriodicScheduling_LP}));
-
-ADD_SCHEDULING(LP1,
-scheduling_action_t({ "LP1" , "Rewriting Bodin2016 Threshold CSDF 1-Periodic Scheduling with Bufferless channel using Linear Programming", algorithms::scheduling::CSDF_1PeriodicScheduling_LP}));
-ADD_SCHEDULING(LPN,
-scheduling_action_t({ "LPN" , "Rewriting Bodin2016 Threshold CSDF N-Periodic Scheduling with Bufferless channel using Linear Programming", algorithms::scheduling::CSDF_NPeriodicScheduling_LP}));
-
-ADD_THROUGHPUT(EG1,
-throughput_action_t({ "EG1" , "Rewriting Bodin2013 CSDF 1-Periodic Scheduling", algorithms::scheduling::CSDF_1PeriodicThroughput}));
-ADD_THROUGHPUT(EGN,
-throughput_action_t({ "EGN" , "Rewriting Bodin2013 CSDF N-Periodic Scheduling", algorithms::scheduling::CSDF_NPeriodicThroughput}));
-ADD_SCHEDULING(BufferlessKPeriodicScheduling,
-		scheduling_action_t({ "BufferlessKPeriodicScheduling" , "Run Bufferless Kperiodic", algorithms::scheduling::bufferlessKPeriodicScheduling} )
-	);
-
-
-
-ADD_SCHEDULING(SPeriodicScheduling,
-scheduling_action_t({ "SPeriodicScheduling" , "Experimental", algorithms::scheduling::SPeriodicScheduling}));
-
-ADD_SCHEDULING(OnePeriodicScheduling,
-scheduling_action_t({ "1PeriodicScheduling" , "CSDF 1-Periodic Scheduling [Bodin2013]", algorithms::scheduling::OnePeriodicScheduling}));
-
-ADD_SCHEDULING(ASAPScheduling,
-scheduling_action_t({ "ASAPScheduling" , "Symbolic Execution", algorithms::scheduling::ASAPScheduling}));
-
-ADD_SCHEDULING(So4Scheduling,
-scheduling_action_t({ "So4Scheduling" , "Symbolic Execution with TDMA", algorithms::scheduling::So4Scheduling}));
-
-// Throughput techniques
-ADD_SCHEDULING(BufferlessNoCScheduling,
-		scheduling_action_t({ "BufferlessNoCScheduling" , "BufferlessNoCScheduling, WIP", algorithms::BufferlessNoCScheduling}));
+ADD_SCHEDULING(REALLP1, "Fully periodic scheduling for CSDF inefficient way", algorithms::scheduling::CSDF_Real1PeriodicScheduling_LP);
+ADD_SCHEDULING(LP1,"Rewriting Bodin2016 Threshold CSDF 1-Periodic Scheduling with Bufferless channel using Linear Programming", algorithms::scheduling::CSDF_1PeriodicScheduling_LP);
+ADD_SCHEDULING(LPN, "Rewriting Bodin2016 Threshold CSDF N-Periodic Scheduling with Bufferless channel using Linear Programming", algorithms::scheduling::CSDF_NPeriodicScheduling_LP);
+ADD_THROUGHPUT(EG1,"Rewriting Bodin2013 CSDF 1-Periodic Scheduling", algorithms::scheduling::CSDF_1PeriodicThroughput);
+ADD_THROUGHPUT(EGN,"Rewriting Bodin2013 CSDF N-Periodic Scheduling", algorithms::scheduling::CSDF_NPeriodicThroughput);
+ADD_SCHEDULING(BufferlessKPeriodicScheduling, "Run Bufferless Kperiodic", algorithms::scheduling::bufferlessKPeriodicScheduling);
+ADD_SCHEDULING(SPeriodicScheduling,"Experimental", algorithms::scheduling::SPeriodicScheduling);
+ADD_SCHEDULING(OnePeriodicScheduling,"CSDF 1-Periodic Scheduling [Bodin2013]", algorithms::scheduling::OnePeriodicScheduling);
+ADD_SCHEDULING(ASAPScheduling,"Symbolic Execution", algorithms::scheduling::ASAPScheduling);
+ADD_SCHEDULING(So4Scheduling,"Symbolic Execution with TDMA", algorithms::scheduling::So4Scheduling);
+ADD_SCHEDULING(BufferlessNoCScheduling, "BufferlessNoCScheduling, WIP", algorithms::BufferlessNoCScheduling);
 
 
 #endif /* SRC_LIBKITER_ALGORITHMS_SCHEDULINGS_H_ */

src/libkiter/algorithms/software_noc.h

@@ -26,9 +26,7 @@ namespace algorithms {
 	bool isConflictPresent(LARGE_INT HP, TIME_UNIT si, LARGE_INT ni, TIME_UNIT sj, LARGE_INT nj);
 }
 
-ADD_TRANSFORMATION(SoftwareControlledNoCBufferless,
-		transformation_action_t({"SoftwareControlledNoCBufferless" , "Perform Bufferless NoC scheduling after deciding task mapping and routing.", algorithms::software_noc_bufferless})
-);
+ADD_TRANSFORMATION(SoftwareControlledNoCBufferless, "Perform Bufferless NoC scheduling after deciding task mapping and routing.", algorithms::software_noc_bufferless);
 
 
 

src/libkiter/algorithms/symbolic_execution.h

@@ -18,10 +18,8 @@ namespace algorithms {
     void packet_list(models::Dataflow* const  dataflow, parameters_list_t ) ;
 }
 
-ADD_ANALYSIS(SymbolicExecutionWP,
-		analysis_action_t({ "SymbolicExecutionWP" , "Execute task in ASAP fashion and print out the scheduling.", algorithms::symbolic_execution_with_packets}));
-ADD_ANALYSIS(SymbolicExecution,
-		analysis_action_t({ "SymbolicExecution" , "Execute task in ASAP fashion.", algorithms::symbolic_execution}));
+ADD_ANALYSIS(SymbolicExecutionWP, "Execute task in ASAP fashion and print out the scheduling.", algorithms::symbolic_execution_with_packets);
+ADD_ANALYSIS(SymbolicExecution,"Execute task in ASAP fashion.", algorithms::symbolic_execution);
 
 
 

src/libkiter/algorithms/throughput/csdf_strictly_periodic.h

@@ -22,7 +22,5 @@ namespace algorithms {
 }
 
 
-ADD_THROUGHPUT(SPeriodicThroughput,
-		throughput_action_t({ "SPeriodicThroughput" , "Strictly Periodic schedule (Exact)", algorithms::compute_SPeriodic_throughput}));
-ADD_THROUGHPUT(ASPeriodicThroughput,
-		throughput_action_t({ "ASPeriodicThroughput" , "Strictly Periodic schedule (Approx)", algorithms::compute_ASPeriodic_throughput}));
+ADD_THROUGHPUT(SPeriodicThroughput,"Strictly Periodic schedule (Exact)", algorithms::compute_SPeriodic_throughput);
+ADD_THROUGHPUT(ASPeriodicThroughput,"Strictly Periodic schedule (Approx)", algorithms::compute_ASPeriodic_throughput);

src/libkiter/algorithms/throughput/degroote.h

@@ -26,10 +26,8 @@ void                    clean_LCG   		                  (models::EventGraph*
 
 }
 
-ADD_THROUGHPUT(deGrooteThroughput,
-		throughput_action_t({ "deGrooteThroughput" , "Throughput analysis from deGroote2012 paper except event graph reduction.", algorithms::compute_deGroote_throughput}));
+ADD_THROUGHPUT(deGrooteThroughput,"Throughput analysis from deGroote2012 paper except event graph reduction.", algorithms::compute_deGroote_throughput);
 
-ADD_THROUGHPUT(deGrooteCleanThroughput,
-		throughput_action_t({ "deGrooteCleanThroughput" , "Throughput analysis from deGroote2012 paper.", algorithms::compute_deGrooteClean_throughput}));
+ADD_THROUGHPUT(deGrooteCleanThroughput,"Throughput analysis from deGroote2012 paper.", algorithms::compute_deGrooteClean_throughput);
 
 #endif /* DEGROOTE_H_ */

src/libkiter/algorithms/throughput/kperiodic.h

@@ -51,19 +51,14 @@ TIME_UNIT                compute_Kperiodic_throughput              (models::Data
     bool 									 updateVectorWithFineNi   (models::Dataflow * const   ,  periodicity_vector_t * , critical_circuit_t *  );
 
 }
-ADD_THROUGHPUT(KPeriodicThroughput,
-		throughput_action_t({ "KPeriodicThroughput" , "Optimal Throughput evaluation of CSDF by K-Periodic scheduling method 2.", algorithms::compute_Kperiodic_throughput}));
+ADD_THROUGHPUT(KPeriodicThroughput,"Optimal Throughput evaluation of CSDF by K-Periodic scheduling method 2.", algorithms::compute_Kperiodic_throughput);
 
-ADD_THROUGHPUT(UnPeriodicThroughput,
-		throughput_action_t({ "1PeriodicThroughput" , "Optimal 1-Periodic Throughput evaluation of CSDF by K-Periodic scheduling method.", algorithms::compute_1Kperiodic_throughput}));
-ADD_THROUGHPUT(DeuxPeriodicThroughput,
-				throughput_action_t({ "2PeriodicThroughput" , "Optimal 1-Periodic Throughput evaluation of CSDF by K-Periodic scheduling method.", algorithms::compute_2Kperiodic_throughput}));
-ADD_THROUGHPUT(NKPeriodicThroughput,
-		throughput_action_t({ "NKPeriodicThroughput" , "Optimal Throughput evaluation of CSDF by using N-periodic method.", algorithms::compute_NKperiodic_throughput}));
+ADD_THROUGHPUT(UnPeriodicThroughput,"Optimal 1-Periodic Throughput evaluation of CSDF by K-Periodic scheduling method.", algorithms::compute_1Kperiodic_throughput);
+ADD_THROUGHPUT(DeuxPeriodicThroughput,"Optimal 1-Periodic Throughput evaluation of CSDF by K-Periodic scheduling method.", algorithms::compute_2Kperiodic_throughput);
+ADD_THROUGHPUT(NKPeriodicThroughput,"Optimal Throughput evaluation of CSDF by using N-periodic method.", algorithms::compute_NKperiodic_throughput);
 
 
-ADD_PRINTER(PrintKPeriodicScheduling,
-		printer_action_t({ "PrintKPeriodicScheduling" , "Print KPeriodicScheduling", algorithms::print_kperiodic_scheduling})
-);
+ADD_PRINTER(PrintKPeriodicScheduling, "Print KPeriodicScheduling", algorithms::print_kperiodic_scheduling);
+
 
 #endif /* KPERIODIC_H_ */

src/libkiter/algorithms/throughput/symbolic_execution.h

@@ -51,9 +51,7 @@ namespace algorithms {
 
 }
 
-ADD_THROUGHPUT(SymbExec,
-                   throughput_action_t({ "SymbExec" , "Execute graph using ASAP scheduling.", algorithms::compute_asap_throughput}));
-ADD_THROUGHPUT(SymbExecDebug,
-                   throughput_action_t({ "SymbExecDebug" , "Test SymbExec with preset storage distribution.", algorithms::compute_asap_throughput_and_cycles_debug}));
+ADD_THROUGHPUT(SymbExec, "Execute graph using ASAP scheduling.", algorithms::compute_asap_throughput);
+ADD_THROUGHPUT(SymbExecDebug, "Test SymbExec with preset storage distribution.", algorithms::compute_asap_throughput_and_cycles_debug);
 
 #endif /* SYMBOLIC_EXECUTION_H_ */