From a9ead100ef6dc6f71083322482b69536cc30b205 Mon Sep 17 00:00:00 2001 From: Matthias Date: Mon, 24 Jul 2017 16:52:05 +0200 Subject: [PATCH] Initial commit. --- CMakeLists.txt | 46 + src/.directory | 4 + src/01.original/CMakeLists.txt | 8 + src/01.original/raincloud.cpp | 454 ++ src/01.original/raincloud.h | 111 + src/02.loopunswitching/CMakeLists.txt | 8 + src/02.loopunswitching/raincloud.cpp | 546 +++ src/02.loopunswitching/raincloud.h | 135 + src/03.loopunrolling/CMakeLists.txt | 8 + src/03.loopunrolling/raincloud.cpp | 2148 +++++++++ src/03.loopunrolling/raincloud.h | 615 +++ src/04.loopnesting/CMakeLists.txt | 8 + src/04.loopnesting/raincloud.cpp | 2248 ++++++++++ src/04.loopnesting/raincloud.h | 648 +++ src/05.ifoptimization01/CMakeLists.txt | 8 + src/05.ifoptimization01/ifoptimization.cpp | 324 ++ src/05.ifoptimization01/ifoptimization.h | 91 + src/06.ifoptimization02/CMakeLists.txt | 8 + src/06.ifoptimization02/ifoptimization.cpp | 290 ++ src/06.ifoptimization02/ifoptimization.h | 82 + src/07.softwarepipelining01/CMakeLists.txt | 8 + src/07.softwarepipelining01/pipelining.cpp | 208 + src/07.softwarepipelining01/pipelining.h | 61 + src/08.softwarepipelining02/CMakeLists.txt | 8 + src/08.softwarepipelining02/pipelining.cpp | 319 ++ src/08.softwarepipelining02/pipelining.h | 97 + src/09.reduction01/CMakeLists.txt | 8 + src/09.reduction01/reduction.cpp | 176 + src/09.reduction01/reduction.h | 51 + src/10.reduction02/CMakeLists.txt | 8 + src/10.reduction02/reduction.cpp | 249 + src/10.reduction02/reduction.h | 73 + src/11.elimination01/CMakeLists.txt | 8 + src/11.elimination01/elimination.cpp | 264 ++ src/11.elimination01/elimination.h | 83 + src/12.elimination02/CMakeLists.txt | 8 + src/12.elimination02/elimination.cpp | 233 + src/12.elimination02/elimination.h | 73 + src/13.loophoisting01/CMakeLists.txt | 8 + src/13.loophoisting01/loophoisting.cpp | 205 + src/13.loophoisting01/loophoisting.h | 62 + src/14.loophoisting02/CMakeLists.txt | 8 + src/14.loophoisting02/loophoisting.cpp | 205 + src/14.loophoisting02/loophoisting.h | 62 + src/15.meteoag01/CMakeLists.txt | 8 + src/15.meteoag01/meteoag01.cpp | 460 ++ src/15.meteoag01/meteoag01.h | 140 + src/16.meteoag02/CMakeLists.txt | 8 + src/16.meteoag02/meteoag02.cpp | 675 +++ src/16.meteoag02/meteoag02.h | 211 + src/17.meteoag03/CMakeLists.txt | 8 + src/17.meteoag03/meteoag03.cpp | 4739 ++++++++++++++++++++ src/17.meteoag03/meteoag03.h | 1580 +++++++ src/18.blast01/CMakeLists.txt | 8 + src/18.blast01/blast01.cpp | 316 ++ src/18.blast01/blast01.h | 99 + src/19.blast02/CMakeLists.txt | 8 + src/19.blast02/blast02.cpp | 500 +++ src/19.blast02/blast02.h | 156 + 59 files changed, 19191 insertions(+) create mode 100644 CMakeLists.txt create mode 100644 src/.directory create mode 100644 src/01.original/CMakeLists.txt create mode 100644 src/01.original/raincloud.cpp create mode 100644 src/01.original/raincloud.h create mode 100644 src/02.loopunswitching/CMakeLists.txt create mode 100644 src/02.loopunswitching/raincloud.cpp create mode 100644 src/02.loopunswitching/raincloud.h create mode 100644 src/03.loopunrolling/CMakeLists.txt create mode 100644 src/03.loopunrolling/raincloud.cpp create mode 100644 src/03.loopunrolling/raincloud.h create mode 100644 src/04.loopnesting/CMakeLists.txt create mode 100644 src/04.loopnesting/raincloud.cpp create mode 100644 src/04.loopnesting/raincloud.h create mode 100644 src/05.ifoptimization01/CMakeLists.txt create mode 100644 src/05.ifoptimization01/ifoptimization.cpp create mode 100644 src/05.ifoptimization01/ifoptimization.h create mode 100644 src/06.ifoptimization02/CMakeLists.txt create mode 100644 src/06.ifoptimization02/ifoptimization.cpp create mode 100644 src/06.ifoptimization02/ifoptimization.h create mode 100644 src/07.softwarepipelining01/CMakeLists.txt create mode 100644 src/07.softwarepipelining01/pipelining.cpp create mode 100644 src/07.softwarepipelining01/pipelining.h create mode 100644 src/08.softwarepipelining02/CMakeLists.txt create mode 100644 src/08.softwarepipelining02/pipelining.cpp create mode 100644 src/08.softwarepipelining02/pipelining.h create mode 100644 src/09.reduction01/CMakeLists.txt create mode 100644 src/09.reduction01/reduction.cpp create mode 100644 src/09.reduction01/reduction.h create mode 100644 src/10.reduction02/CMakeLists.txt create mode 100644 src/10.reduction02/reduction.cpp create mode 100644 src/10.reduction02/reduction.h create mode 100644 src/11.elimination01/CMakeLists.txt create mode 100644 src/11.elimination01/elimination.cpp create mode 100644 src/11.elimination01/elimination.h create mode 100644 src/12.elimination02/CMakeLists.txt create mode 100644 src/12.elimination02/elimination.cpp create mode 100644 src/12.elimination02/elimination.h create mode 100644 src/13.loophoisting01/CMakeLists.txt create mode 100644 src/13.loophoisting01/loophoisting.cpp create mode 100644 src/13.loophoisting01/loophoisting.h create mode 100644 src/14.loophoisting02/CMakeLists.txt create mode 100644 src/14.loophoisting02/loophoisting.cpp create mode 100644 src/14.loophoisting02/loophoisting.h create mode 100644 src/15.meteoag01/CMakeLists.txt create mode 100644 src/15.meteoag01/meteoag01.cpp create mode 100644 src/15.meteoag01/meteoag01.h create mode 100644 src/16.meteoag02/CMakeLists.txt create mode 100644 src/16.meteoag02/meteoag02.cpp create mode 100644 src/16.meteoag02/meteoag02.h create mode 100644 src/17.meteoag03/CMakeLists.txt create mode 100644 src/17.meteoag03/meteoag03.cpp create mode 100644 src/17.meteoag03/meteoag03.h create mode 100644 src/18.blast01/CMakeLists.txt create mode 100644 src/18.blast01/blast01.cpp create mode 100644 src/18.blast01/blast01.h create mode 100644 src/19.blast02/CMakeLists.txt create mode 100644 src/19.blast02/blast02.cpp create mode 100644 src/19.blast02/blast02.h diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..8efb14f --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,46 @@ +cmake_minimum_required(VERSION 2.8) +project(CCGrid-raincloud-experiments C CXX) + +find_package (Threads) + +set(WFR_DIR /home/matthias/Uni/Work/WorkflowsOnManycores/wfr-eclipse-workspace/dist/) +get_filename_component(INSTALL_DIR "bin" ABSOLUTE) + +set(WFR_INCLUDES ${WFR_DIR}/include) +set(WFR_LIBS + ${WFR_DIR}/lib/libwfr.a + ${WFR_DIR}/lib/libboost_filesystem.a + ${WFR_DIR}/lib/libboost_program_options.a + ${WFR_DIR}/lib/libboost_system.a + ${WFR_DIR}/lib/libodb-sqlite.a + ${WFR_DIR}/lib/libodb.a + ${WFR_DIR}/lib/libsqlite3.a + ${CMAKE_THREAD_LIBS_INIT} + ${CMAKE_DL_LIBS} +) +set(CMAKE_CXX_FLAGS "-O3 -g3 -DNDEBUG -Wall") +set(CMAKE_C_FLAGS "-O3 -g3 -DNDEBUG -Wall") + +file(MAKE_DIRECTORY ${INSTALL_DIR}) + +add_subdirectory(src/01.original) +add_subdirectory(src/02.loopunswitching) +add_subdirectory(src/03.loopunrolling) +add_subdirectory(src/04.loopnesting) +add_subdirectory(src/05.ifoptimization01) +add_subdirectory(src/06.ifoptimization02) +add_subdirectory(src/07.softwarepipelining01) +add_subdirectory(src/08.softwarepipelining02) +add_subdirectory(src/09.reduction01) +add_subdirectory(src/10.reduction02) +add_subdirectory(src/11.elimination01) +add_subdirectory(src/12.elimination02) +add_subdirectory(src/13.loophoisting01) +add_subdirectory(src/14.loophoisting02) + +add_subdirectory(src/15.meteoag01) +add_subdirectory(src/16.meteoag02) +add_subdirectory(src/17.meteoag03) + +add_subdirectory(src/18.blast01) +add_subdirectory(src/19.blast02) diff --git a/src/.directory b/src/.directory new file mode 100644 index 0000000..d8d4d71 --- /dev/null +++ b/src/.directory @@ -0,0 +1,4 @@ +[Dolphin] +Timestamp=2016,11,17,12,54,17 +Version=3 +ViewMode=1 diff --git a/src/01.original/CMakeLists.txt b/src/01.original/CMakeLists.txt new file mode 100644 index 0000000..a8cf1d0 --- /dev/null +++ b/src/01.original/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(raincloud-01-original C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin raincloud.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/01.original/raincloud.cpp b/src/01.original/raincloud.cpp new file mode 100644 index 0000000..3f59c63 --- /dev/null +++ b/src/01.original/raincloud.cpp @@ -0,0 +1,454 @@ +#include "raincloud.h" +#include +#include +#include +#include + +std::atomic iterCount = ATOMIC_VAR_INIT(0); + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_PORT_INIT_COLLECTION(sout->finalTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + WFR_CHILD_OUTBUFFER_GET(a1out, DecisionNode_2_out, a1, 7, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->finalTars, a1out->LMtarsList)); + } + WFR_CHILD_OUTBUFFER_GET(a2out, ParallelForEach_1_out, a2, 3, 0); + if (a2out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->outfiles, a2out->outfiles)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->finalTars.isReady() && sout->outfiles.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(prepareLMInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, prepareLM_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->FAC1, a1in->Fac1)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->VAR2, a1in->Var2)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->datain, a1in->datain)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->VAR1, a1in->Var1)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->topo, a1in->topo)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->NGroup, a1in->NGroup)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->FAC2, a1in->Fac2)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->topo.isReady() && sin->datain.isReady() && sin->NGroup.isReady() && sin->VAR1.isReady() && sin->FAC1.isReady() && sin->VAR2.isReady() && sin->FAC2.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(prepareLMExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, prepareLM_in); + WFR_SELF_OUTBUFFER_INIT(sout, prepareLM_out); + WFR_PORT_INIT_COLLECTION(sout->PLMlistTars); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../prepareLMDummy.sh %d", wpath.string().c_str(), sin->NGroup.getValue()); + printf("%s\n", cmd); + int ret = system(cmd); + for (int t = 0; t < sin->NGroup.getValue(); t++) { + char file[1024]; + snprintf(file, 1024, "%s/PLMout_g_uid%d.tar.gz", wpath.string().c_str(), t+1); + sout->PLMlistTars.setEntryValue(t, std::string(file)); + } + sout->PLMlistTars.setFinalised(true);*/ + + for (int t = 0; t < sin->NGroup.getValue(); t++) { + sout->PLMlistTars.setEntryValue(t, std::string("file")); + } + sout->PLMlistTars.setFinalised(true); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(ParallelForEach_1InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, ParallelForEach_1_in); + WFR_PORT_INIT_COLLECTION(sin->PLMTars); + WFR_PRED_OUTBUFFER_GET(a1in, prepareLM_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a1in->PLMlistTars)); + } + WFR_PARENT_INBUFFER_GET(a2in, toplevel_in, a2); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->cond_decisionPostProcessSingle, a2in->decisionPostProcessSingle)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(ParallelForEach_1OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, ParallelForEach_1_out); + WFR_PORT_INIT_COLLECTION(sout->PPSlistTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->PPSlistTars, DecisionNode_1_out, PPSlistTars, 5); + WFR_LOOP_FINALIZE_COLLECTION(sout, PPSlistTars); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->outfiles, linearModel_out, outfile, 4); + WFR_LOOP_FINALIZE_COLLECTION(sout, outfiles); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->PPSlistTars.isReady() && sout->outfiles.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(ParallelForEach_1CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, ParallelForEach_1_in); + if (sin != nullptr && sin->PLMTars.isReady() && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution) { + wfr_size_t minLoopElementcount = std::min({sin->PLMTars.getSize()}); + WFR_SELF_SETITERATIONCOUNT(minLoopElementcount); + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_in); + WFR_PARENT_INBUFFER_GET(a1in, ParallelForEach_1_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTars.getEntry(WFR_SELF_GETITERATIONID()))); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModelExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + iterCount.fetch_add(1); + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(DecisionNode_1InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, DecisionNode_1_in); + WFR_PARENT_INBUFFER_GET(a1in, ParallelForEach_1_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->cond_decisionPostProcessSingle, a1in->cond_decisionPostProcessSingle)); + } + WFR_PRED_OUTBUFFER_GET(a2in, linearModel_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a2in->LMTar)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(DecisionNode_1OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, DecisionNode_1_out); + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, postProcessSingle_out, a1, 6, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->PPSlistTars, a1out->PPSTar)); + } + } else { + WFR_SELF_INBUFFER_GET(a1in, DecisionNode_1_in); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->PPSlistTars, a1in->LMTar)); + if (retval) { + instance.setInstanceStatus(wfs::ActivityInstanceStatus::Finished); + ((wfs::CompositeActivityInstance&)instance).notifyChildHasFinished(instance); + } + } + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->PPSlistTars.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_BRANCHCONDITION_HOOK(DecisionNode_1BranchConditionFunc) { + WFR_BRANCHCONDITION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, DecisionNode_1_in); + if (sin != nullptr && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution && sin->cond_decisionPostProcessSingle.isReady() ) { + if ((sin->cond_decisionPostProcessSingle.getValue() == true)) { + instance.setExecutionBranchID(0); + } else { + instance.setExecutionBranchID(1); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_BRANCHCONDITION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingleInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_in); + WFR_PARENT_INBUFFER_GET(a1in, DecisionNode_1_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingleExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(DecisionNode_2InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, DecisionNode_2_in); + WFR_PORT_INIT_COLLECTION(sin->PPSlistTars); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->cond_decisionPostProcessFinal, a1in->decisionPostProcessFinal)); + } + WFR_PRED_OUTBUFFER_GET(a2in, ParallelForEach_1_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSlistTars, a2in->PPSlistTars)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(DecisionNode_2OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, DecisionNode_2_out); + WFR_PORT_INIT_COLLECTION(sout->LMtarsList); + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, postProcessFinal_out, a1, 8, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->LMtarsList, a1out->finalTar, 0)); + WFR_FINALIZE_COLLECTION(sout, LMtarsList); + } + } else { + WFR_SELF_INBUFFER_GET(a1in, DecisionNode_2_in); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->LMtarsList, a1in->PPSlistTars)); + if (retval) { + instance.setInstanceStatus(wfs::ActivityInstanceStatus::Finished); + ((wfs::CompositeActivityInstance&)instance).notifyChildHasFinished(instance); + } + } + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->LMtarsList.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_BRANCHCONDITION_HOOK(DecisionNode_2BranchConditionFunc) { + WFR_BRANCHCONDITION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, DecisionNode_2_in); + if (sin != nullptr && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution && sin->cond_decisionPostProcessFinal.isReady() ) { + if (sin->cond_decisionPostProcessFinal.getValue() == true) { + instance.setExecutionBranchID(0); + } else { + instance.setExecutionBranchID(1); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_BRANCHCONDITION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessFinalInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessFinal_in); + WFR_PORT_INIT_COLLECTION(sin->PPSlistTars); + WFR_PARENT_INBUFFER_GET(a1in, DecisionNode_2_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSlistTars, a1in->PPSlistTars)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PPSlistTars.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessFinalExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessFinal_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessFinal_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessFinalDummy.sh", wpath.string().c_str()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/FINAL.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->finalTar.setValue("file1"); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( prepareLMImplementations, "prepareLMImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(prepareLMExecFunc_0, "prepareLMExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModelImplementations, "linearModelImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModelExecFunc_0, "linearModelExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingleImplementations, "postProcessSingleImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingleExecFunc_0, "postProcessSingleExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessFinalImplementations, "postProcessFinalImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessFinalExecFunc_0, "postProcessFinalExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "Raincloud", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::atomic(2, "prepareLM", 1, 0, {3}, {}, prepareLMInputFunc, prepareLMImplementations), \ + wfr::wfs::ActivityTemplate::forLoop(3, "ParallelForEach_1", 1, 0, {7}, {2}, ParallelForEach_1InputFunc, ParallelForEach_1OutputFunc, ParallelForEach_1CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(4, "linearModel", 3, 0, {5}, {}, linearModelInputFunc, linearModelImplementations), \ + wfr::wfs::ActivityTemplate::conditional(5, "DecisionNode_1", 3, 0, {}, {4}, DecisionNode_1InputFunc, DecisionNode_1OutputFunc, DecisionNode_1BranchConditionFunc), \ + wfr::wfs::ActivityTemplate::atomic(6, "postProcessSingle", 5, 0, {}, {}, postProcessSingleInputFunc, postProcessSingleImplementations), \ + wfr::wfs::ActivityTemplate::conditional(7, "DecisionNode_2", 1, 0, {}, {3}, DecisionNode_2InputFunc, DecisionNode_2OutputFunc, DecisionNode_2BranchConditionFunc), \ + wfr::wfs::ActivityTemplate::atomic(8, "postProcessFinal", 7, 0, {}, {}, postProcessFinalInputFunc, postProcessFinalImplementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + std::string var1 = "0:2500:12000"; + long fac1 = 1; + std::string var2 = "250:10:310"; + long fac2 = 1; + long ngroup = 8; + bool decisionPostProcessFinal = true; + bool decisionPostProcessSingle = true; + std::string topo = "input/Topography.tar.gz"; + std::string datain = "input/DataIN.tar.gz"; + bool isHelp = false; + boost::program_options::options_description opts("Raincloud Options"); + opts.add_options() + ("help", "Print help message.") + ("var1", boost::program_options::value(), "Var1 parameter.") + ("fac1", boost::program_options::value(), "Fac1 parameter.") + ("var2", boost::program_options::value(), "Var2 parameter.") + ("fac2", boost::program_options::value(), "Fac2 parameter.") + ("ngroup", boost::program_options::value(), "NGroup parameter.") + ("decisionPostProcessFinal", boost::program_options::value(), "DecisionPostProcessFinal parameter.") + ("decisionPostProcessSingle", boost::program_options::value(), "DecisionPostProcessSingle parameter.") + ("topo", boost::program_options::value(), "Topography file.") + ("datain", boost::program_options::value(), "DataIN file."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("var1")) { + var1 = vm["var1"].as(); + } + if (vm.count("fac1")) { + fac1 = vm["fac1"].as(); + } + if (vm.count("var2")) { + var2 = vm["var2"].as(); + } + if (vm.count("fac2")) { + fac2 = vm["fac2"].as(); + } + if (vm.count("ngroup")) { + ngroup = vm["ngroup"].as(); + } + if (vm.count("decisionPostProcessFinal")) { + decisionPostProcessFinal = vm["decisionPostProcessFinal"].as(); + } + if (vm.count("decisionPostProcessSingle")) { + decisionPostProcessSingle = vm["decisionPostProcessSingle"].as(); + } + if (vm.count("topo")) { + topo = vm["topo"].as(); + } + if (vm.count("datain")) { + datain = vm["datain"].as(); + } + std::cerr << "var1 = " << var1 << std::endl; + std::cerr << "fac1 = " << fac1 << std::endl; + std::cerr << "var2 = " << var2 << std::endl; + std::cerr << "fac2 = " << fac2 << std::endl; + std::cerr << "ngroup = " << ngroup << std::endl; + std::cerr << "decisionPostProcessFinal = " << decisionPostProcessFinal << std::endl; + std::cerr << "decisionPostProcessSingle = " << decisionPostProcessSingle << std::endl; + std::cerr << "topo = " << topo << std::endl; + std::cerr << "datain = " << datain << std::endl; + } + wfInput.Var1.setValue(var1); + wfInput.Fac1.setValue(fac1); + wfInput.Var2.setValue(var2); + wfInput.Fac2.setValue(fac2); + wfInput.NGroup.setValue(ngroup); + wfInput.decisionPostProcessFinal.setValue(decisionPostProcessFinal); + wfInput.decisionPostProcessSingle.setValue(decisionPostProcessSingle); + wfInput.topo.setValue(topo); + wfInput.datain.setValue(datain); + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + std::cout << "IterCount = " << iterCount.load() << std::endl; + + return 0; +} diff --git a/src/01.original/raincloud.h b/src/01.original/raincloud.h new file mode 100644 index 0000000..445c181 --- /dev/null +++ b/src/01.original/raincloud.h @@ -0,0 +1,111 @@ +#ifndef RAINCLOUD_H +#define RAINCLOUD_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRBOOL(decisionPostProcessSingle) \ + WFR_PORT_MEMBER_IWIRBOOL(decisionPostProcessFinal) \ + WFR_PORT_MEMBER_IWIRFILE(topo) \ + WFR_PORT_MEMBER_IWIRFILE(datain) \ + WFR_PORT_MEMBER_IWIRINT(NGroup) \ + WFR_PORT_MEMBER_IWIRSTRING(Var1) \ + WFR_PORT_MEMBER_IWIRINT(Fac1) \ + WFR_PORT_MEMBER_IWIRSTRING(Var2) \ + WFR_PORT_MEMBER_IWIRINT(Fac2) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(finalTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* prepareLM INSTRUCT */ +WFR_PORT_STRUCT( prepareLM_in, 3, \ + WFR_PORT_MEMBER_IWIRFILE(topo) \ + WFR_PORT_MEMBER_IWIRFILE(datain) \ + WFR_PORT_MEMBER_IWIRINT(NGroup) \ + WFR_PORT_MEMBER_IWIRSTRING(VAR1) \ + WFR_PORT_MEMBER_IWIRINT(FAC1) \ + WFR_PORT_MEMBER_IWIRSTRING(VAR2) \ + WFR_PORT_MEMBER_IWIRINT(FAC2) \ +) + +/* prepareLM OUTSTRUCT */ +WFR_PORT_STRUCT( prepareLM_out, 4, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* ParallelForEach_1 INSTRUCT */ +WFR_PORT_STRUCT( ParallelForEach_1_in, 5, \ + WFR_PORT_MEMBER_IWIRBOOL(cond_decisionPostProcessSingle) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* ParallelForEach_1 OUTSTRUCT */ +WFR_PORT_STRUCT( ParallelForEach_1_out, 6, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* linearModel INSTRUCT */ +WFR_PORT_STRUCT( linearModel_in, 7, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_out, 8, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* DecisionNode_1 INSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_1_in, 9, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRBOOL(cond_decisionPostProcessSingle) \ +) + +/* DecisionNode_1 OUTSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_1_out, 10, \ + WFR_PORT_MEMBER_IWIRFILE(PPSlistTars) \ +) + +/* postProcessSingle INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_in, 11, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_out, 12, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* DecisionNode_2 INSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_2_in, 13, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRBOOL(cond_decisionPostProcessFinal) \ +) + +/* DecisionNode_2 OUTSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_2_out, 14, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(LMtarsList, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* postProcessFinal INSTRUCT */ +WFR_PORT_STRUCT( postProcessFinal_in, 15, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* postProcessFinal OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessFinal_out, 16, \ + WFR_PORT_MEMBER_IWIRFILE(finalTar) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* RAINCLOUD_H */ diff --git a/src/02.loopunswitching/CMakeLists.txt b/src/02.loopunswitching/CMakeLists.txt new file mode 100644 index 0000000..7a5ccd9 --- /dev/null +++ b/src/02.loopunswitching/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(raincloud-02-loopunswitching C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin raincloud.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/02.loopunswitching/raincloud.cpp b/src/02.loopunswitching/raincloud.cpp new file mode 100644 index 0000000..2165846 --- /dev/null +++ b/src/02.loopunswitching/raincloud.cpp @@ -0,0 +1,546 @@ +#include "raincloud.h" +#include +#include +#include +#include + +std::atomic iterCount = ATOMIC_VAR_INIT(0); + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_PORT_INIT_COLLECTION(sout->finalTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + WFR_CHILD_OUTBUFFER_GET(a1out, DecisionNode_1_out, a1, 3, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->outfiles, a1out->outfiles)); + } + WFR_CHILD_OUTBUFFER_GET(a2out, DecisionNode_2_out, a2, 9, 0); + if (a2out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->finalTars, a2out->LMtarsList)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->finalTars.isReady() && sout->outfiles.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(prepareLMInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, prepareLM_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->datain, a1in->datain)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->NGroup, a1in->NGroup)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->VAR1, a1in->Var1)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->FAC1, a1in->Fac1)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->VAR2, a1in->Var2)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->FAC2, a1in->Fac2)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->topo, a1in->topo)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->topo.isReady() && sin->datain.isReady() && sin->NGroup.isReady() && sin->VAR1.isReady() && sin->FAC1.isReady() && sin->VAR2.isReady() && sin->FAC2.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(prepareLMExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, prepareLM_in); + WFR_SELF_OUTBUFFER_INIT(sout, prepareLM_out); + WFR_PORT_INIT_COLLECTION(sout->PLMlistTars); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../prepareLMDummy.sh %d", wpath.string().c_str(), sin->NGroup.getValue()); + printf("%s\n", cmd); + int ret = system(cmd); + for (int t = 0; t < sin->NGroup.getValue(); t++) { + char file[1024]; + snprintf(file, 1024, "%s/PLMout_g_uid%d.tar.gz", wpath.string().c_str(), t+1); + sout->PLMlistTars.setEntryValue(t, std::string(file)); + } + sout->PLMlistTars.setFinalised(true);*/ + + for (int t = 0; t < sin->NGroup.getValue(); t++) { + sout->PLMlistTars.setEntryValue(t, std::string("file")); + } + sout->PLMlistTars.setFinalised(true); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(DecisionNode_1InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, DecisionNode_1_in); + WFR_PORT_INIT_COLLECTION(sin->PLMTars); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->condDecisionPostProcessSingle, a1in->decisionPostProcessSingle)); + } + WFR_PRED_OUTBUFFER_GET(a2in, prepareLM_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a2in->PLMlistTars)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(DecisionNode_1OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, DecisionNode_1_out); + WFR_PORT_INIT_COLLECTION(sout->PPSlistTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, ParallelForEach_1_thenBranch_out, a1, 4, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->PPSlistTars, a1out->PPSlistTars)); + } + } else if (WFR_SELF_GETCONDBRANCHID() == 1) { + WFR_CHILD_OUTBUFFER_GET(a1out, ParallelForEach_1_elseBranch_out, a1, 7, 1); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->PPSlistTars, a1out->PPSlistTars)); + } + } + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, ParallelForEach_1_thenBranch_out, a1, 4, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->outfiles, a1out->outfiles)); + } + } else if (WFR_SELF_GETCONDBRANCHID() == 1) { + WFR_CHILD_OUTBUFFER_GET(a1out, ParallelForEach_1_elseBranch_out, a1, 7, 1); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->outfiles, a1out->outfiles)); + } + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->PPSlistTars.isReady() && sout->outfiles.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_BRANCHCONDITION_HOOK(DecisionNode_1BranchConditionFunc) { + WFR_BRANCHCONDITION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, DecisionNode_1_in); + if (sin != nullptr && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution && sin->condDecisionPostProcessSingle.isReady() ) { + if ((sin->condDecisionPostProcessSingle.getValue() == true)) { + instance.setExecutionBranchID(0); + } else { + instance.setExecutionBranchID(1); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_BRANCHCONDITION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(ParallelForEach_1_thenBranchInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, ParallelForEach_1_thenBranch_in); + WFR_PORT_INIT_COLLECTION(sin->PLMTars); + WFR_PARENT_INBUFFER_GET(a1in, DecisionNode_1_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a1in->PLMTars)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->condDecisionPostProcessSingle, a1in->condDecisionPostProcessSingle)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(ParallelForEach_1_thenBranchOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, ParallelForEach_1_thenBranch_out); + WFR_PORT_INIT_COLLECTION(sout->PPSlistTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->outfiles, linearModel_then_out, outfile, 5); + WFR_LOOP_FINALIZE_COLLECTION(sout, outfiles); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->PPSlistTars, postProcessSingle_then_out, PPSTar, 6); + WFR_LOOP_FINALIZE_COLLECTION(sout, PPSlistTars); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->PPSlistTars.isReady() && sout->outfiles.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(ParallelForEach_1_thenBranchCounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, ParallelForEach_1_thenBranch_in); + if (sin != nullptr && sin->PLMTars.isReady() && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution) { + wfr_size_t minLoopElementcount = std::min({sin->PLMTars.getSize()}); + WFR_SELF_SETITERATIONCOUNT(minLoopElementcount); + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_then_in); + WFR_PARENT_INBUFFER_GET(a1in, ParallelForEach_1_thenBranch_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTars.getEntry(WFR_SELF_GETITERATIONID()))); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + iterCount.fetch_add(1); + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(ParallelForEach_1_elseBranchInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, ParallelForEach_1_elseBranch_in); + WFR_PORT_INIT_COLLECTION(sin->PLMTars); + WFR_PARENT_INBUFFER_GET(a1in, DecisionNode_1_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a1in->PLMTars)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->condDecisionPostProcessSingle, a1in->condDecisionPostProcessSingle)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(ParallelForEach_1_elseBranchOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, ParallelForEach_1_elseBranch_out); + WFR_PORT_INIT_COLLECTION(sout->PPSlistTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->PPSlistTars, linearModel_else_out, LMTar, 8); + WFR_LOOP_FINALIZE_COLLECTION(sout, PPSlistTars); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->outfiles, linearModel_else_out, outfile, 8); + WFR_LOOP_FINALIZE_COLLECTION(sout, outfiles); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->PPSlistTars.isReady() && sout->outfiles.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(ParallelForEach_1_elseBranchCounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, ParallelForEach_1_elseBranch_in); + if (sin != nullptr && sin->PLMTars.isReady() && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution) { + wfr_size_t minLoopElementcount = std::min({sin->PLMTars.getSize()}); + WFR_SELF_SETITERATIONCOUNT(minLoopElementcount); + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_else_in); + WFR_PARENT_INBUFFER_GET(a1in, ParallelForEach_1_elseBranch_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTars.getEntry(WFR_SELF_GETITERATIONID()))); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(DecisionNode_2InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, DecisionNode_2_in); + WFR_PORT_INIT_COLLECTION(sin->PPSlistTars); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->condDecisionPostProcessFinal, a1in->decisionPostProcessFinal)); + } + WFR_PRED_OUTBUFFER_GET(a2in, DecisionNode_1_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSlistTars, a2in->PPSlistTars)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(DecisionNode_2OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, DecisionNode_2_out); + WFR_PORT_INIT_COLLECTION(sout->LMtarsList); + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, postProcessFinal_out, a1, 10, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->LMtarsList, a1out->finalTar, 0)); + WFR_FINALIZE_COLLECTION(sout, LMtarsList); + } + } else { + WFR_SELF_INBUFFER_GET(a1in, DecisionNode_2_in); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->LMtarsList, a1in->PPSlistTars)); + if (retval) { + instance.setInstanceStatus(wfs::ActivityInstanceStatus::Finished); + ((wfs::CompositeActivityInstance&)instance).notifyChildHasFinished(instance); + } + } + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->LMtarsList.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_BRANCHCONDITION_HOOK(DecisionNode_2BranchConditionFunc) { + WFR_BRANCHCONDITION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, DecisionNode_2_in); + if (sin != nullptr && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution && sin->condDecisionPostProcessFinal.isReady() ) { + if (sin->condDecisionPostProcessFinal.getValue() == true) { + instance.setExecutionBranchID(0); + } else { + instance.setExecutionBranchID(1); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_BRANCHCONDITION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessFinalInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessFinal_in); + WFR_PORT_INIT_COLLECTION(sin->PPSlistTars); + WFR_PARENT_INBUFFER_GET(a1in, DecisionNode_2_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSlistTars, a1in->PPSlistTars)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PPSlistTars.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessFinalExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessFinal_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessFinal_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessFinalDummy.sh", wpath.string().c_str()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/FINAL.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->finalTar.setValue("file1"); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( prepareLMImplementations, "prepareLMImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(prepareLMExecFunc_0, "prepareLMExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_thenImplementations, "linearModel_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_thenExecFunc_0, "linearModel_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_thenImplementations, "postProcessSingle_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_thenExecFunc_0, "postProcessSingle_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_elseImplementations, "linearModel_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_elseExecFunc_0, "linearModel_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessFinalImplementations, "postProcessFinalImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessFinalExecFunc_0, "postProcessFinalExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "generatedWorkflow", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::atomic(2, "prepareLM", 1, 0, {3}, {}, prepareLMInputFunc, prepareLMImplementations), \ + wfr::wfs::ActivityTemplate::conditional(3, "DecisionNode_1", 1, 0, {9}, {2}, DecisionNode_1InputFunc, DecisionNode_1OutputFunc, DecisionNode_1BranchConditionFunc), \ + wfr::wfs::ActivityTemplate::forLoop(4, "ParallelForEach_1_thenBranch", 3, 0, {}, {}, ParallelForEach_1_thenBranchInputFunc, ParallelForEach_1_thenBranchOutputFunc, ParallelForEach_1_thenBranchCounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(5, "linearModel_then", 4, 0, {6}, {}, linearModel_thenInputFunc, linearModel_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(6, "postProcessSingle_then", 4, 0, {}, {5}, postProcessSingle_thenInputFunc, postProcessSingle_thenImplementations), \ + wfr::wfs::ActivityTemplate::forLoop(7, "ParallelForEach_1_elseBranch", 3, 1, {}, {}, ParallelForEach_1_elseBranchInputFunc, ParallelForEach_1_elseBranchOutputFunc, ParallelForEach_1_elseBranchCounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(8, "linearModel_else", 7, 0, {}, {}, linearModel_elseInputFunc, linearModel_elseImplementations), \ + wfr::wfs::ActivityTemplate::conditional(9, "DecisionNode_2", 1, 0, {}, {3}, DecisionNode_2InputFunc, DecisionNode_2OutputFunc, DecisionNode_2BranchConditionFunc), \ + wfr::wfs::ActivityTemplate::atomic(10, "postProcessFinal", 9, 0, {}, {}, postProcessFinalInputFunc, postProcessFinalImplementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + std::string var1 = "0:2500:12000"; + long fac1 = 1; + std::string var2 = "250:10:310"; + long fac2 = 1; + long ngroup = 8; + bool decisionPostProcessFinal = true; + bool decisionPostProcessSingle = true; + std::string topo = "input/Topography.tar.gz"; + std::string datain = "input/DataIN.tar.gz"; + bool isHelp = false; + boost::program_options::options_description opts("Raincloud Options"); + opts.add_options() + ("help", "Print help message.") + ("var1", boost::program_options::value(), "Var1 parameter.") + ("fac1", boost::program_options::value(), "Fac1 parameter.") + ("var2", boost::program_options::value(), "Var2 parameter.") + ("fac2", boost::program_options::value(), "Fac2 parameter.") + ("ngroup", boost::program_options::value(), "NGroup parameter.") + ("decisionPostProcessFinal", boost::program_options::value(), "DecisionPostProcessFinal parameter.") + ("decisionPostProcessSingle", boost::program_options::value(), "DecisionPostProcessSingle parameter.") + ("topo", boost::program_options::value(), "Topography file.") + ("datain", boost::program_options::value(), "DataIN file."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("var1")) { + var1 = vm["var1"].as(); + } + if (vm.count("fac1")) { + fac1 = vm["fac1"].as(); + } + if (vm.count("var2")) { + var2 = vm["var2"].as(); + } + if (vm.count("fac2")) { + fac2 = vm["fac2"].as(); + } + if (vm.count("ngroup")) { + ngroup = vm["ngroup"].as(); + } + if (vm.count("decisionPostProcessFinal")) { + decisionPostProcessFinal = vm["decisionPostProcessFinal"].as(); + } + if (vm.count("decisionPostProcessSingle")) { + decisionPostProcessSingle = vm["decisionPostProcessSingle"].as(); + } + if (vm.count("topo")) { + topo = vm["topo"].as(); + } + if (vm.count("datain")) { + datain = vm["datain"].as(); + } + std::cerr << "var1 = " << var1 << std::endl; + std::cerr << "fac1 = " << fac1 << std::endl; + std::cerr << "var2 = " << var2 << std::endl; + std::cerr << "fac2 = " << fac2 << std::endl; + std::cerr << "ngroup = " << ngroup << std::endl; + std::cerr << "decisionPostProcessFinal = " << decisionPostProcessFinal << std::endl; + std::cerr << "decisionPostProcessSingle = " << decisionPostProcessSingle << std::endl; + std::cerr << "topo = " << topo << std::endl; + std::cerr << "datain = " << datain << std::endl; + } + wfInput.Var1.setValue(var1); + wfInput.Fac1.setValue(fac1); + wfInput.Var2.setValue(var2); + wfInput.Fac2.setValue(fac2); + wfInput.NGroup.setValue(ngroup); + wfInput.decisionPostProcessFinal.setValue(decisionPostProcessFinal); + wfInput.decisionPostProcessSingle.setValue(decisionPostProcessSingle); + wfInput.topo.setValue(topo); + wfInput.datain.setValue(datain); + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + std::cout << "IterCount = " << iterCount.load() << std::endl; + + + return 0; +} diff --git a/src/02.loopunswitching/raincloud.h b/src/02.loopunswitching/raincloud.h new file mode 100644 index 0000000..ca7c000 --- /dev/null +++ b/src/02.loopunswitching/raincloud.h @@ -0,0 +1,135 @@ +#ifndef RAINCLOUD_TRANSFORMED_H +#define RAINCLOUD_TRANSFORMED_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRBOOL(decisionPostProcessSingle) \ + WFR_PORT_MEMBER_IWIRBOOL(decisionPostProcessFinal) \ + WFR_PORT_MEMBER_IWIRFILE(topo) \ + WFR_PORT_MEMBER_IWIRFILE(datain) \ + WFR_PORT_MEMBER_IWIRINT(NGroup) \ + WFR_PORT_MEMBER_IWIRSTRING(Var1) \ + WFR_PORT_MEMBER_IWIRINT(Fac1) \ + WFR_PORT_MEMBER_IWIRSTRING(Var2) \ + WFR_PORT_MEMBER_IWIRINT(Fac2) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(finalTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* prepareLM INSTRUCT */ +WFR_PORT_STRUCT( prepareLM_in, 3, \ + WFR_PORT_MEMBER_IWIRFILE(topo) \ + WFR_PORT_MEMBER_IWIRFILE(datain) \ + WFR_PORT_MEMBER_IWIRINT(NGroup) \ + WFR_PORT_MEMBER_IWIRSTRING(VAR1) \ + WFR_PORT_MEMBER_IWIRINT(FAC1) \ + WFR_PORT_MEMBER_IWIRSTRING(VAR2) \ + WFR_PORT_MEMBER_IWIRINT(FAC2) \ +) + +/* prepareLM OUTSTRUCT */ +WFR_PORT_STRUCT( prepareLM_out, 4, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* DecisionNode_1 INSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_1_in, 5, \ + WFR_PORT_MEMBER_IWIRBOOL(condDecisionPostProcessSingle) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* DecisionNode_1 OUTSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_1_out, 6, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* ParallelForEach_1_thenBranch INSTRUCT */ +WFR_PORT_STRUCT( ParallelForEach_1_thenBranch_in, 7, \ + WFR_PORT_MEMBER_IWIRBOOL(condDecisionPostProcessSingle) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* ParallelForEach_1_thenBranch OUTSTRUCT */ +WFR_PORT_STRUCT( ParallelForEach_1_thenBranch_out, 8, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* linearModel_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_then_in, 9, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_then_out, 10, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* postProcessSingle_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_then_in, 11, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_then_out, 12, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* ParallelForEach_1_elseBranch INSTRUCT */ +WFR_PORT_STRUCT( ParallelForEach_1_elseBranch_in, 13, \ + WFR_PORT_MEMBER_IWIRBOOL(condDecisionPostProcessSingle) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* ParallelForEach_1_elseBranch OUTSTRUCT */ +WFR_PORT_STRUCT( ParallelForEach_1_elseBranch_out, 14, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* linearModel_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_else_in, 15, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_else_out, 16, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* DecisionNode_2 INSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_2_in, 17, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRBOOL(condDecisionPostProcessFinal) \ +) + +/* DecisionNode_2 OUTSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_2_out, 18, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(LMtarsList, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* postProcessFinal INSTRUCT */ +WFR_PORT_STRUCT( postProcessFinal_in, 19, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* postProcessFinal OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessFinal_out, 20, \ + WFR_PORT_MEMBER_IWIRFILE(finalTar) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* RAINCLOUD_TRANSFORMED_H */ diff --git a/src/03.loopunrolling/CMakeLists.txt b/src/03.loopunrolling/CMakeLists.txt new file mode 100644 index 0000000..ea3b8f7 --- /dev/null +++ b/src/03.loopunrolling/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(raincloud-03-loopunrolling C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin raincloud.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/03.loopunrolling/raincloud.cpp b/src/03.loopunrolling/raincloud.cpp new file mode 100644 index 0000000..417d801 --- /dev/null +++ b/src/03.loopunrolling/raincloud.cpp @@ -0,0 +1,2148 @@ +#include "raincloud.h" +#include +#include +#include +#include + +std::atomic iterCount = ATOMIC_VAR_INIT(0); + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_PORT_INIT_COLLECTION(sout->finalTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + WFR_CHILD_OUTBUFFER_GET(a1out, DecisionNode_2_out, a1, 51, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->finalTars, a1out->LMtarsList)); + } + WFR_CHILD_OUTBUFFER_GET(a2out, DecisionNode_1_out, a2, 4, 0); + if (a2out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->outfiles, a2out->outfiles)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->finalTars.isReady() && sout->outfiles.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(prepareLMInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, prepareLM_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->datain, a1in->datain)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->NGroup, a1in->NGroup)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->VAR1, a1in->Var1)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->FAC1, a1in->Fac1)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->VAR2, a1in->Var2)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->FAC2, a1in->Fac2)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->topo, a1in->topo)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->topo.isReady() && sin->datain.isReady() && sin->NGroup.isReady() && sin->VAR1.isReady() && sin->FAC1.isReady() && sin->VAR2.isReady() && sin->FAC2.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(prepareLMExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, prepareLM_in); + WFR_SELF_OUTBUFFER_INIT(sout, prepareLM_out); + WFR_PORT_INIT_COLLECTION(sout->PLMlistTars); + for (int t = 0; t < sin->NGroup.getValue(); t++) { + sout->PLMlistTars.setEntryValue(t, std::string("file")); + } + sout->PLMlistTars.setFinalised(true); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper02_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->NGroup, a1in->NGroup)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->NGroup.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper02_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper02_out); +sout->NewNGroup.setValue(sin->NGroup.getValue()/10); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(DecisionNode_1InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, DecisionNode_1_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->NGroup, a1in->NewNGroup)); + } + WFR_PRED_OUTBUFFER_GET(a2in, prepareLM_out, a2, 1); + if (a2in != nullptr) { + if (!sin->PLMTars.isReady() && a2in->PLMlistTars.isReady()) { + sin->PLMTars.setValue(&a2in->PLMlistTars); + } + } + WFR_PARENT_INBUFFER_GET(a3in, toplevel_in, a3); + if (a3in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->condDecisionPostProcessSingle, a3in->decisionPostProcessSingle)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(DecisionNode_1OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, DecisionNode_1_out); + WFR_PORT_INIT_COLLECTION(sout->PPSlistTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, ParallelFor_1_thenBranch_out, a1, 5, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->PPSlistTars, a1out->PPSlistTars)); + } + } else if (WFR_SELF_GETCONDBRANCHID() == 1) { + WFR_CHILD_OUTBUFFER_GET(a1out, ParallelFor_1_elseBranch_out, a1, 28, 1); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->PPSlistTars, a1out->PPSlistTars)); + } + } + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, ParallelFor_1_thenBranch_out, a1, 5, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->outfiles, a1out->outfiles)); + } + } else if (WFR_SELF_GETCONDBRANCHID() == 1) { + WFR_CHILD_OUTBUFFER_GET(a1out, ParallelFor_1_elseBranch_out, a1, 28, 1); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->outfiles, a1out->outfiles)); + } + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->PPSlistTars.isReady() && sout->outfiles.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_BRANCHCONDITION_HOOK(DecisionNode_1BranchConditionFunc) { + WFR_BRANCHCONDITION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, DecisionNode_1_in); + if (sin != nullptr && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution && sin->condDecisionPostProcessSingle.isReady() ) { + if ((sin->condDecisionPostProcessSingle.getValue() == true)) { + instance.setExecutionBranchID(0); + } else { + instance.setExecutionBranchID(1); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_BRANCHCONDITION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(ParallelFor_1_thenBranchInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, ParallelFor_1_thenBranch_in); + WFR_PARENT_INBUFFER_GET(a1in, DecisionNode_1_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a1in->PLMTars)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->NGroup)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->condDecisionPostProcessSingle, a1in->condDecisionPostProcessSingle)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(ParallelFor_1_thenBranchOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, ParallelFor_1_thenBranch_out); + WFR_PORT_INIT_COLLECTION(sout->PPSlistTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN_FLATTEN(sout->PPSlistTars, 1, helper04_then_out, PPSTars, 27); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->outfiles, linearModel_1_then_out, outfile, 8); + WFR_LOOP_FINALIZE_COLLECTION(sout, outfiles); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->PPSlistTars.isReady() && sout->outfiles.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(ParallelFor_1_thenBranchCounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, ParallelFor_1_thenBranch_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper03_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper03_then_in); + WFR_PARENT_INBUFFER_GET(a1in, ParallelFor_1_thenBranch_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a1in->PLMTars)); + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->index); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTars.isReady() && sin->index.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper03_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper03_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper03_then_out); + + auto i = (sin->index.getValue()-1)*10; + sout->PLMTar0.setValue(sin->PLMTars.getValue()->getEntryValue(i)); + sout->PLMTar1.setValue(sin->PLMTars.getValue()->getEntryValue(i+1)); + sout->PLMTar2.setValue(sin->PLMTars.getValue()->getEntryValue(i+2)); + sout->PLMTar3.setValue(sin->PLMTars.getValue()->getEntryValue(i+3)); + sout->PLMTar4.setValue(sin->PLMTars.getValue()->getEntryValue(i+4)); + sout->PLMTar5.setValue(sin->PLMTars.getValue()->getEntryValue(i+5)); + sout->PLMTar6.setValue(sin->PLMTars.getValue()->getEntryValue(i+6)); + sout->PLMTar7.setValue(sin->PLMTars.getValue()->getEntryValue(i+7)); + sout->PLMTar8.setValue(sin->PLMTars.getValue()->getEntryValue(i+8)); + sout->PLMTar9.setValue(sin->PLMTars.getValue()->getEntryValue(i+9)); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_0_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_0_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar0)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_0_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_0_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_0_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + iterCount.fetch_add(1); + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_1_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_1_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar1)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_1_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_1_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_1_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_2_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_2_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar2)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_2_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_2_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_2_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_3_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_3_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar3)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_3_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_3_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_3_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_4_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_4_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar4)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_4_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_4_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_4_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_5_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_5_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar5)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_5_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_5_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_5_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_6_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_6_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar6)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_6_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_6_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_6_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_7_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_7_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar7)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_7_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_7_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_7_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_8_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_8_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar8)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_8_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_8_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_8_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_9_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_9_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar9)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_9_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_9_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_9_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_0_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_0_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_0_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_0_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_0_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_0_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_1_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_1_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_1_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_1_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_1_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_1_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_2_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_2_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_2_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_2_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_2_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_2_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_3_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_3_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_3_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_3_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_3_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_3_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_4_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_4_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_4_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_4_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_4_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_4_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_5_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_5_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_5_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_5_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_5_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_5_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_6_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_6_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_6_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_6_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_6_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_6_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_7_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_7_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_7_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_7_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_7_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_7_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_8_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_8_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_8_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_8_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_8_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_8_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_9_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_9_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_9_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_9_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_9_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_9_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper04_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper04_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, postProcessSingle_4_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar4, a1in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a2in, postProcessSingle_9_then_out, a2, 1); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar9, a2in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a3in, postProcessSingle_5_then_out, a3, 2); + if (a3in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar5, a3in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a4in, postProcessSingle_8_then_out, a4, 3); + if (a4in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar8, a4in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a5in, postProcessSingle_0_then_out, a5, 4); + if (a5in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar0, a5in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a6in, postProcessSingle_7_then_out, a6, 5); + if (a6in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar7, a6in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a7in, postProcessSingle_1_then_out, a7, 6); + if (a7in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar1, a7in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a8in, postProcessSingle_3_then_out, a8, 7); + if (a8in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar3, a8in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a9in, postProcessSingle_6_then_out, a9, 8); + if (a9in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar6, a9in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a10in, postProcessSingle_2_then_out, a10, 9); + if (a10in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar2, a10in->PPSTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PPSTar0.isReady() && sin->PPSTar1.isReady() && sin->PPSTar2.isReady() && sin->PPSTar3.isReady() && sin->PPSTar4.isReady() && sin->PPSTar5.isReady() && sin->PPSTar6.isReady() && sin->PPSTar7.isReady() && sin->PPSTar8.isReady() && sin->PPSTar9.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper04_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper04_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper04_then_out); + WFR_PORT_INIT_COLLECTION(sout->PPSTars); +sout->PPSTars.setEntryValue(0, sin->PPSTar0.getValue()); +sout->PPSTars.setEntryValue(1, sin->PPSTar1.getValue()); +sout->PPSTars.setEntryValue(2, sin->PPSTar2.getValue()); +sout->PPSTars.setEntryValue(3, sin->PPSTar3.getValue()); +sout->PPSTars.setEntryValue(4, sin->PPSTar4.getValue()); +sout->PPSTars.setEntryValue(5, sin->PPSTar5.getValue()); +sout->PPSTars.setEntryValue(6, sin->PPSTar6.getValue()); +sout->PPSTars.setEntryValue(7, sin->PPSTar7.getValue()); +sout->PPSTars.setEntryValue(8, sin->PPSTar8.getValue()); +sout->PPSTars.setEntryValue(9, sin->PPSTar9.getValue()); +sout->PPSTars.setFinalised(true); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(ParallelFor_1_elseBranchInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, ParallelFor_1_elseBranch_in); + WFR_PARENT_INBUFFER_GET(a1in, DecisionNode_1_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a1in->PLMTars)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->condDecisionPostProcessSingle, a1in->condDecisionPostProcessSingle)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(ParallelFor_1_elseBranchOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, ParallelFor_1_elseBranch_out); + WFR_PORT_INIT_COLLECTION(sout->PPSlistTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->outfiles, linearModel_1_else_out, outfile, 31); + WFR_LOOP_FINALIZE_COLLECTION(sout, outfiles); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN_FLATTEN(sout->PPSlistTars, 1, helper04_else_out, PPSTars, 50); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->PPSlistTars.isReady() && sout->outfiles.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(ParallelFor_1_elseBranchCounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, ParallelFor_1_elseBranch_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper03_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper03_else_in); + WFR_PARENT_INBUFFER_GET(a1in, ParallelFor_1_elseBranch_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a1in->PLMTars)); + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->index); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTars.isReady() && sin->index.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper03_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper03_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper03_else_out); + + auto i = (sin->index.getValue()-1)*10; + sout->PLMTar0.setValue(sin->PLMTars.getValue()->getEntryValue(i)); + sout->PLMTar1.setValue(sin->PLMTars.getValue()->getEntryValue(i+1)); + sout->PLMTar2.setValue(sin->PLMTars.getValue()->getEntryValue(i+2)); + sout->PLMTar3.setValue(sin->PLMTars.getValue()->getEntryValue(i+3)); + sout->PLMTar4.setValue(sin->PLMTars.getValue()->getEntryValue(i+4)); + sout->PLMTar5.setValue(sin->PLMTars.getValue()->getEntryValue(i+5)); + sout->PLMTar6.setValue(sin->PLMTars.getValue()->getEntryValue(i+6)); + sout->PLMTar7.setValue(sin->PLMTars.getValue()->getEntryValue(i+7)); + sout->PLMTar8.setValue(sin->PLMTars.getValue()->getEntryValue(i+8)); + sout->PLMTar9.setValue(sin->PLMTars.getValue()->getEntryValue(i+9)); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_0_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_0_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar0)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_0_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_0_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_0_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_1_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_1_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar1)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_1_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_1_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_1_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_2_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_2_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar2)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_2_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_2_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_2_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_3_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_3_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar3)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_3_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_3_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_3_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_4_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_4_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar4)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_4_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_4_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_4_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_5_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_5_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar5)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_5_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_5_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_5_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_6_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_6_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar6)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_6_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_6_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_6_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_7_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_7_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar7)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_7_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_7_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_7_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_8_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_8_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar8)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_8_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_8_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_8_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_9_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_9_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper03_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar9)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_9_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_9_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_9_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_0_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_0_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_0_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_0_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_0_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_0_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_1_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_1_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_1_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_1_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_1_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_1_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_2_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_2_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_2_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_2_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_2_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_2_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_3_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_3_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_3_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_3_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_3_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_3_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_4_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_4_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_4_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_4_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_4_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_4_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_5_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_5_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_5_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_5_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_5_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_5_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_6_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_6_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_6_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_6_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_6_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_6_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_7_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_7_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_7_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_7_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_7_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_7_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_8_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_8_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_8_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_8_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_8_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_8_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_9_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_9_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_9_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_9_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_9_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_9_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper04_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper04_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, postProcessSingle_2_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar2, a1in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a2in, postProcessSingle_0_else_out, a2, 1); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar0, a2in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a3in, postProcessSingle_3_else_out, a3, 2); + if (a3in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar3, a3in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a4in, postProcessSingle_5_else_out, a4, 3); + if (a4in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar5, a4in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a5in, postProcessSingle_7_else_out, a5, 4); + if (a5in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar7, a5in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a6in, postProcessSingle_1_else_out, a6, 5); + if (a6in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar1, a6in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a7in, postProcessSingle_8_else_out, a7, 6); + if (a7in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar8, a7in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a8in, postProcessSingle_9_else_out, a8, 7); + if (a8in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar9, a8in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a9in, postProcessSingle_4_else_out, a9, 8); + if (a9in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar4, a9in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a10in, postProcessSingle_6_else_out, a10, 9); + if (a10in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar6, a10in->PPSTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PPSTar0.isReady() && sin->PPSTar1.isReady() && sin->PPSTar2.isReady() && sin->PPSTar3.isReady() && sin->PPSTar4.isReady() && sin->PPSTar5.isReady() && sin->PPSTar6.isReady() && sin->PPSTar7.isReady() && sin->PPSTar8.isReady() && sin->PPSTar9.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper04_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper04_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper04_else_out); + WFR_PORT_INIT_COLLECTION(sout->PPSTars); +sout->PPSTars.setEntryValue(0, sin->PPSTar0.getValue()); +sout->PPSTars.setEntryValue(1, sin->PPSTar1.getValue()); +sout->PPSTars.setEntryValue(2, sin->PPSTar2.getValue()); +sout->PPSTars.setEntryValue(3, sin->PPSTar3.getValue()); +sout->PPSTars.setEntryValue(4, sin->PPSTar4.getValue()); +sout->PPSTars.setEntryValue(5, sin->PPSTar5.getValue()); +sout->PPSTars.setEntryValue(6, sin->PPSTar6.getValue()); +sout->PPSTars.setEntryValue(7, sin->PPSTar7.getValue()); +sout->PPSTars.setEntryValue(8, sin->PPSTar8.getValue()); +sout->PPSTars.setEntryValue(9, sin->PPSTar9.getValue()); +sout->PPSTars.setFinalised(true); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(DecisionNode_2InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, DecisionNode_2_in); + WFR_PORT_INIT_COLLECTION(sin->PPSlistTars); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->condDecisionPostProcessFinal, a1in->decisionPostProcessFinal)); + } + WFR_PRED_OUTBUFFER_GET(a2in, DecisionNode_1_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSlistTars, a2in->PPSlistTars)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(DecisionNode_2OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, DecisionNode_2_out); + WFR_PORT_INIT_COLLECTION(sout->LMtarsList); + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, postProcessFinal_out, a1, 52, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->LMtarsList, a1out->finalTar, 0)); + WFR_FINALIZE_COLLECTION(sout, LMtarsList); + } + } else { + WFR_SELF_INBUFFER_GET(a1in, DecisionNode_2_in); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->LMtarsList, a1in->PPSlistTars)); + if (retval) { + instance.setInstanceStatus(wfs::ActivityInstanceStatus::Finished); + ((wfs::CompositeActivityInstance&)instance).notifyChildHasFinished(instance); + } + } + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->LMtarsList.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_BRANCHCONDITION_HOOK(DecisionNode_2BranchConditionFunc) { + WFR_BRANCHCONDITION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, DecisionNode_2_in); + if (sin != nullptr && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution && sin->condDecisionPostProcessFinal.isReady() ) { + if (sin->condDecisionPostProcessFinal.getValue() == true) { + instance.setExecutionBranchID(0); + } else { + instance.setExecutionBranchID(1); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_BRANCHCONDITION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessFinalInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessFinal_in); + WFR_PORT_INIT_COLLECTION(sin->PPSlistTars); + WFR_PARENT_INBUFFER_GET(a1in, DecisionNode_2_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSlistTars, a1in->PPSlistTars)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PPSlistTars.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessFinalExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessFinal_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessFinal_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessFinalDummy.sh", wpath.string().c_str()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/FINAL.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->finalTar.setValue("file1"); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( prepareLMImplementations, "prepareLMImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(prepareLMExecFunc_0, "prepareLMExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( helper02Implementations, "helper02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(helper02ExecFunc_0, "helper02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( helper03_thenImplementations, "helper03_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(helper03_thenExecFunc_0, "helper03_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_0_thenImplementations, "linearModel_0_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_0_thenExecFunc_0, "linearModel_0_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_1_thenImplementations, "linearModel_1_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_1_thenExecFunc_0, "linearModel_1_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_2_thenImplementations, "linearModel_2_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_2_thenExecFunc_0, "linearModel_2_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_3_thenImplementations, "linearModel_3_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_3_thenExecFunc_0, "linearModel_3_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_4_thenImplementations, "linearModel_4_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_4_thenExecFunc_0, "linearModel_4_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_5_thenImplementations, "linearModel_5_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_5_thenExecFunc_0, "linearModel_5_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_6_thenImplementations, "linearModel_6_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_6_thenExecFunc_0, "linearModel_6_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_7_thenImplementations, "linearModel_7_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_7_thenExecFunc_0, "linearModel_7_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_8_thenImplementations, "linearModel_8_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_8_thenExecFunc_0, "linearModel_8_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_9_thenImplementations, "linearModel_9_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_9_thenExecFunc_0, "linearModel_9_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_0_thenImplementations, "postProcessSingle_0_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_0_thenExecFunc_0, "postProcessSingle_0_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_1_thenImplementations, "postProcessSingle_1_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_1_thenExecFunc_0, "postProcessSingle_1_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_2_thenImplementations, "postProcessSingle_2_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_2_thenExecFunc_0, "postProcessSingle_2_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_3_thenImplementations, "postProcessSingle_3_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_3_thenExecFunc_0, "postProcessSingle_3_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_4_thenImplementations, "postProcessSingle_4_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_4_thenExecFunc_0, "postProcessSingle_4_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_5_thenImplementations, "postProcessSingle_5_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_5_thenExecFunc_0, "postProcessSingle_5_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_6_thenImplementations, "postProcessSingle_6_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_6_thenExecFunc_0, "postProcessSingle_6_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_7_thenImplementations, "postProcessSingle_7_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_7_thenExecFunc_0, "postProcessSingle_7_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_8_thenImplementations, "postProcessSingle_8_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_8_thenExecFunc_0, "postProcessSingle_8_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_9_thenImplementations, "postProcessSingle_9_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_9_thenExecFunc_0, "postProcessSingle_9_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( helper04_thenImplementations, "helper04_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(helper04_thenExecFunc_0, "helper04_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( helper03_elseImplementations, "helper03_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(helper03_elseExecFunc_0, "helper03_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_0_elseImplementations, "linearModel_0_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_0_elseExecFunc_0, "linearModel_0_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_1_elseImplementations, "linearModel_1_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_1_elseExecFunc_0, "linearModel_1_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_2_elseImplementations, "linearModel_2_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_2_elseExecFunc_0, "linearModel_2_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_3_elseImplementations, "linearModel_3_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_3_elseExecFunc_0, "linearModel_3_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_4_elseImplementations, "linearModel_4_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_4_elseExecFunc_0, "linearModel_4_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_5_elseImplementations, "linearModel_5_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_5_elseExecFunc_0, "linearModel_5_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_6_elseImplementations, "linearModel_6_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_6_elseExecFunc_0, "linearModel_6_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_7_elseImplementations, "linearModel_7_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_7_elseExecFunc_0, "linearModel_7_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_8_elseImplementations, "linearModel_8_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_8_elseExecFunc_0, "linearModel_8_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_9_elseImplementations, "linearModel_9_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_9_elseExecFunc_0, "linearModel_9_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_0_elseImplementations, "postProcessSingle_0_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_0_elseExecFunc_0, "postProcessSingle_0_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_1_elseImplementations, "postProcessSingle_1_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_1_elseExecFunc_0, "postProcessSingle_1_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_2_elseImplementations, "postProcessSingle_2_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_2_elseExecFunc_0, "postProcessSingle_2_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_3_elseImplementations, "postProcessSingle_3_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_3_elseExecFunc_0, "postProcessSingle_3_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_4_elseImplementations, "postProcessSingle_4_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_4_elseExecFunc_0, "postProcessSingle_4_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_5_elseImplementations, "postProcessSingle_5_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_5_elseExecFunc_0, "postProcessSingle_5_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_6_elseImplementations, "postProcessSingle_6_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_6_elseExecFunc_0, "postProcessSingle_6_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_7_elseImplementations, "postProcessSingle_7_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_7_elseExecFunc_0, "postProcessSingle_7_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_8_elseImplementations, "postProcessSingle_8_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_8_elseExecFunc_0, "postProcessSingle_8_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_9_elseImplementations, "postProcessSingle_9_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_9_elseExecFunc_0, "postProcessSingle_9_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( helper04_elseImplementations, "helper04_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(helper04_elseExecFunc_0, "helper04_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessFinalImplementations, "postProcessFinalImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessFinalExecFunc_0, "postProcessFinalExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "generatedWorkflow", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::atomic(2, "prepareLM", 1, 0, {4}, {}, prepareLMInputFunc, prepareLMImplementations), \ + wfr::wfs::ActivityTemplate::atomic(3, "helper02", 1, 0, {4}, {}, helper02InputFunc, helper02Implementations), \ + wfr::wfs::ActivityTemplate::conditional(4, "DecisionNode_1", 1, 0, {51}, {3, 2}, DecisionNode_1InputFunc, DecisionNode_1OutputFunc, DecisionNode_1BranchConditionFunc), \ + wfr::wfs::ActivityTemplate::forLoop(5, "ParallelFor_1_thenBranch", 4, 0, {}, {}, ParallelFor_1_thenBranchInputFunc, ParallelFor_1_thenBranchOutputFunc, ParallelFor_1_thenBranchCounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(6, "helper03_then", 5, 0, {7, 13, 10, 12, 14, 16, 8, 15, 11, 9}, {}, helper03_thenInputFunc, helper03_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(7, "linearModel_0_then", 5, 0, {17}, {6}, linearModel_0_thenInputFunc, linearModel_0_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(8, "linearModel_1_then", 5, 0, {18}, {6}, linearModel_1_thenInputFunc, linearModel_1_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(9, "linearModel_2_then", 5, 0, {19}, {6}, linearModel_2_thenInputFunc, linearModel_2_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(10, "linearModel_3_then", 5, 0, {20}, {6}, linearModel_3_thenInputFunc, linearModel_3_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(11, "linearModel_4_then", 5, 0, {21}, {6}, linearModel_4_thenInputFunc, linearModel_4_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(12, "linearModel_5_then", 5, 0, {22}, {6}, linearModel_5_thenInputFunc, linearModel_5_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(13, "linearModel_6_then", 5, 0, {23}, {6}, linearModel_6_thenInputFunc, linearModel_6_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(14, "linearModel_7_then", 5, 0, {24}, {6}, linearModel_7_thenInputFunc, linearModel_7_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(15, "linearModel_8_then", 5, 0, {25}, {6}, linearModel_8_thenInputFunc, linearModel_8_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(16, "linearModel_9_then", 5, 0, {26}, {6}, linearModel_9_thenInputFunc, linearModel_9_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(17, "postProcessSingle_0_then", 5, 0, {27}, {7}, postProcessSingle_0_thenInputFunc, postProcessSingle_0_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(18, "postProcessSingle_1_then", 5, 0, {27}, {8}, postProcessSingle_1_thenInputFunc, postProcessSingle_1_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(19, "postProcessSingle_2_then", 5, 0, {27}, {9}, postProcessSingle_2_thenInputFunc, postProcessSingle_2_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(20, "postProcessSingle_3_then", 5, 0, {27}, {10}, postProcessSingle_3_thenInputFunc, postProcessSingle_3_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(21, "postProcessSingle_4_then", 5, 0, {27}, {11}, postProcessSingle_4_thenInputFunc, postProcessSingle_4_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(22, "postProcessSingle_5_then", 5, 0, {27}, {12}, postProcessSingle_5_thenInputFunc, postProcessSingle_5_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(23, "postProcessSingle_6_then", 5, 0, {27}, {13}, postProcessSingle_6_thenInputFunc, postProcessSingle_6_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(24, "postProcessSingle_7_then", 5, 0, {27}, {14}, postProcessSingle_7_thenInputFunc, postProcessSingle_7_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(25, "postProcessSingle_8_then", 5, 0, {27}, {15}, postProcessSingle_8_thenInputFunc, postProcessSingle_8_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(26, "postProcessSingle_9_then", 5, 0, {27}, {16}, postProcessSingle_9_thenInputFunc, postProcessSingle_9_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(27, "helper04_then", 5, 0, {}, {21, 26, 22, 25, 17, 24, 18, 20, 23, 19}, helper04_thenInputFunc, helper04_thenImplementations), \ + wfr::wfs::ActivityTemplate::forLoop(28, "ParallelFor_1_elseBranch", 4, 1, {}, {}, ParallelFor_1_elseBranchInputFunc, ParallelFor_1_elseBranchOutputFunc, ParallelFor_1_elseBranchCounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(29, "helper03_else", 28, 0, {31, 37, 35, 36, 38, 32, 34, 39, 30, 33}, {}, helper03_elseInputFunc, helper03_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(30, "linearModel_0_else", 28, 0, {40}, {29}, linearModel_0_elseInputFunc, linearModel_0_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(31, "linearModel_1_else", 28, 0, {41}, {29}, linearModel_1_elseInputFunc, linearModel_1_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(32, "linearModel_2_else", 28, 0, {42}, {29}, linearModel_2_elseInputFunc, linearModel_2_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(33, "linearModel_3_else", 28, 0, {43}, {29}, linearModel_3_elseInputFunc, linearModel_3_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(34, "linearModel_4_else", 28, 0, {44}, {29}, linearModel_4_elseInputFunc, linearModel_4_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(35, "linearModel_5_else", 28, 0, {45}, {29}, linearModel_5_elseInputFunc, linearModel_5_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(36, "linearModel_6_else", 28, 0, {46}, {29}, linearModel_6_elseInputFunc, linearModel_6_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(37, "linearModel_7_else", 28, 0, {47}, {29}, linearModel_7_elseInputFunc, linearModel_7_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(38, "linearModel_8_else", 28, 0, {48}, {29}, linearModel_8_elseInputFunc, linearModel_8_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(39, "linearModel_9_else", 28, 0, {49}, {29}, linearModel_9_elseInputFunc, linearModel_9_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(40, "postProcessSingle_0_else", 28, 0, {50}, {30}, postProcessSingle_0_elseInputFunc, postProcessSingle_0_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(41, "postProcessSingle_1_else", 28, 0, {50}, {31}, postProcessSingle_1_elseInputFunc, postProcessSingle_1_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(42, "postProcessSingle_2_else", 28, 0, {50}, {32}, postProcessSingle_2_elseInputFunc, postProcessSingle_2_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(43, "postProcessSingle_3_else", 28, 0, {50}, {33}, postProcessSingle_3_elseInputFunc, postProcessSingle_3_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(44, "postProcessSingle_4_else", 28, 0, {50}, {34}, postProcessSingle_4_elseInputFunc, postProcessSingle_4_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(45, "postProcessSingle_5_else", 28, 0, {50}, {35}, postProcessSingle_5_elseInputFunc, postProcessSingle_5_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(46, "postProcessSingle_6_else", 28, 0, {50}, {36}, postProcessSingle_6_elseInputFunc, postProcessSingle_6_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(47, "postProcessSingle_7_else", 28, 0, {50}, {37}, postProcessSingle_7_elseInputFunc, postProcessSingle_7_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(48, "postProcessSingle_8_else", 28, 0, {50}, {38}, postProcessSingle_8_elseInputFunc, postProcessSingle_8_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(49, "postProcessSingle_9_else", 28, 0, {50}, {39}, postProcessSingle_9_elseInputFunc, postProcessSingle_9_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(50, "helper04_else", 28, 0, {}, {42, 40, 43, 45, 47, 41, 48, 49, 44, 46}, helper04_elseInputFunc, helper04_elseImplementations), \ + wfr::wfs::ActivityTemplate::conditional(51, "DecisionNode_2", 1, 0, {}, {4}, DecisionNode_2InputFunc, DecisionNode_2OutputFunc, DecisionNode_2BranchConditionFunc), \ + wfr::wfs::ActivityTemplate::atomic(52, "postProcessFinal", 51, 0, {}, {}, postProcessFinalInputFunc, postProcessFinalImplementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + std::string var1 = "0:2500:12000"; + long fac1 = 1; + std::string var2 = "250:10:310"; + long fac2 = 1; + long ngroup = 8; + bool decisionPostProcessFinal = true; + bool decisionPostProcessSingle = true; + std::string topo = "input/Topography.tar.gz"; + std::string datain = "input/DataIN.tar.gz"; + bool isHelp = false; + boost::program_options::options_description opts("Raincloud Options"); + opts.add_options() + ("help", "Print help message.") + ("var1", boost::program_options::value(), "Var1 parameter.") + ("fac1", boost::program_options::value(), "Fac1 parameter.") + ("var2", boost::program_options::value(), "Var2 parameter.") + ("fac2", boost::program_options::value(), "Fac2 parameter.") + ("ngroup", boost::program_options::value(), "NGroup parameter.") + ("decisionPostProcessFinal", boost::program_options::value(), "DecisionPostProcessFinal parameter.") + ("decisionPostProcessSingle", boost::program_options::value(), "DecisionPostProcessSingle parameter.") + ("topo", boost::program_options::value(), "Topography file.") + ("datain", boost::program_options::value(), "DataIN file."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("var1")) { + var1 = vm["var1"].as(); + } + if (vm.count("fac1")) { + fac1 = vm["fac1"].as(); + } + if (vm.count("var2")) { + var2 = vm["var2"].as(); + } + if (vm.count("fac2")) { + fac2 = vm["fac2"].as(); + } + if (vm.count("ngroup")) { + ngroup = vm["ngroup"].as(); + } + if (vm.count("decisionPostProcessFinal")) { + decisionPostProcessFinal = vm["decisionPostProcessFinal"].as(); + } + if (vm.count("decisionPostProcessSingle")) { + decisionPostProcessSingle = vm["decisionPostProcessSingle"].as(); + } + if (vm.count("topo")) { + topo = vm["topo"].as(); + } + if (vm.count("datain")) { + datain = vm["datain"].as(); + } + std::cerr << "var1 = " << var1 << std::endl; + std::cerr << "fac1 = " << fac1 << std::endl; + std::cerr << "var2 = " << var2 << std::endl; + std::cerr << "fac2 = " << fac2 << std::endl; + std::cerr << "ngroup = " << ngroup << std::endl; + std::cerr << "decisionPostProcessFinal = " << decisionPostProcessFinal << std::endl; + std::cerr << "decisionPostProcessSingle = " << decisionPostProcessSingle << std::endl; + std::cerr << "topo = " << topo << std::endl; + std::cerr << "datain = " << datain << std::endl; + } + wfInput.Var1.setValue(var1); + wfInput.Fac1.setValue(fac1); + wfInput.Var2.setValue(var2); + wfInput.Fac2.setValue(fac2); + wfInput.NGroup.setValue(ngroup); + wfInput.decisionPostProcessFinal.setValue(decisionPostProcessFinal); + wfInput.decisionPostProcessSingle.setValue(decisionPostProcessSingle); + wfInput.topo.setValue(topo); + wfInput.datain.setValue(datain); + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + std::cout << "IterCount = " << iterCount.load() << std::endl; + + return 0; +} diff --git a/src/03.loopunrolling/raincloud.h b/src/03.loopunrolling/raincloud.h new file mode 100644 index 0000000..f8ed7c3 --- /dev/null +++ b/src/03.loopunrolling/raincloud.h @@ -0,0 +1,615 @@ +#ifndef RAINCLOUD_TEST01_H +#define RAINCLOUD_TEST01_H + +#include + +typedef wfr::lwd::iwir_collection* filecollref; + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRBOOL(decisionPostProcessSingle) \ + WFR_PORT_MEMBER_IWIRBOOL(decisionPostProcessFinal) \ + WFR_PORT_MEMBER_IWIRFILE(topo) \ + WFR_PORT_MEMBER_IWIRFILE(datain) \ + WFR_PORT_MEMBER_IWIRINT(NGroup) \ + WFR_PORT_MEMBER_IWIRSTRING(Var1) \ + WFR_PORT_MEMBER_IWIRINT(Fac1) \ + WFR_PORT_MEMBER_IWIRSTRING(Var2) \ + WFR_PORT_MEMBER_IWIRINT(Fac2) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(finalTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* prepareLM INSTRUCT */ +WFR_PORT_STRUCT( prepareLM_in, 3, \ + WFR_PORT_MEMBER_IWIRFILE(topo) \ + WFR_PORT_MEMBER_IWIRFILE(datain) \ + WFR_PORT_MEMBER_IWIRINT(NGroup) \ + WFR_PORT_MEMBER_IWIRSTRING(VAR1) \ + WFR_PORT_MEMBER_IWIRINT(FAC1) \ + WFR_PORT_MEMBER_IWIRSTRING(VAR2) \ + WFR_PORT_MEMBER_IWIRINT(FAC2) \ +) + +/* prepareLM OUTSTRUCT */ +WFR_PORT_STRUCT( prepareLM_out, 4, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* helper02 INSTRUCT */ +WFR_PORT_STRUCT( helper02_in, 5, \ + WFR_PORT_MEMBER_IWIRINT(NGroup) \ +) + +/* helper02 OUTSTRUCT */ +WFR_PORT_STRUCT( helper02_out, 6, \ + WFR_PORT_MEMBER_IWIRINT(NewNGroup) \ +) + +/* DecisionNode_1 INSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_1_in, 7, \ + WFR_PORT_MEMBER_IWIRBOOL(condDecisionPostProcessSingle) \ + WFR_PORT_MEMBER(PLMTars, filecollref) \ + WFR_PORT_MEMBER_IWIRINT(NGroup) \ +) + +/* DecisionNode_1 OUTSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_1_out, 8, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* ParallelFor_1_thenBranch INSTRUCT */ +WFR_PORT_STRUCT( ParallelFor_1_thenBranch_in, 9, \ + WFR_PORT_MEMBER_IWIRBOOL(condDecisionPostProcessSingle) \ + WFR_PORT_MEMBER(PLMTars, filecollref) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* ParallelFor_1_thenBranch OUTSTRUCT */ +WFR_PORT_STRUCT( ParallelFor_1_thenBranch_out, 10, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* helper03_then INSTRUCT */ +WFR_PORT_STRUCT( helper03_then_in, 11, \ + WFR_PORT_MEMBER(PLMTars, filecollref) \ + WFR_PORT_MEMBER_IWIRINT(index) \ +) + +/* helper03_then OUTSTRUCT */ +WFR_PORT_STRUCT( helper03_then_out, 12, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar0) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar1) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar2) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar3) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar4) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar5) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar6) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar7) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar8) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar9) \ +) + +/* linearModel_0_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_0_then_in, 13, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_0_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_0_then_out, 14, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_1_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_1_then_in, 15, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_1_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_1_then_out, 16, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_2_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_2_then_in, 17, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_2_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_2_then_out, 18, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_3_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_3_then_in, 19, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_3_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_3_then_out, 20, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_4_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_4_then_in, 21, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_4_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_4_then_out, 22, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_5_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_5_then_in, 23, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_5_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_5_then_out, 24, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_6_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_6_then_in, 25, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_6_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_6_then_out, 26, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_7_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_7_then_in, 27, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_7_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_7_then_out, 28, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_8_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_8_then_in, 29, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_8_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_8_then_out, 30, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_9_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_9_then_in, 31, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_9_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_9_then_out, 32, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* postProcessSingle_0_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_0_then_in, 33, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_0_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_0_then_out, 34, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_1_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_1_then_in, 35, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_1_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_1_then_out, 36, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_2_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_2_then_in, 37, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_2_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_2_then_out, 38, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_3_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_3_then_in, 39, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_3_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_3_then_out, 40, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_4_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_4_then_in, 41, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_4_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_4_then_out, 42, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_5_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_5_then_in, 43, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_5_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_5_then_out, 44, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_6_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_6_then_in, 45, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_6_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_6_then_out, 46, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_7_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_7_then_in, 47, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_7_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_7_then_out, 48, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_8_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_8_then_in, 49, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_8_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_8_then_out, 50, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_9_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_9_then_in, 51, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_9_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_9_then_out, 52, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* helper04_then INSTRUCT */ +WFR_PORT_STRUCT( helper04_then_in, 53, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar0) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar1) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar2) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar3) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar4) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar5) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar6) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar7) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar8) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar9) \ +) + +/* helper04_then OUTSTRUCT */ +WFR_PORT_STRUCT( helper04_then_out, 54, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* ParallelFor_1_elseBranch INSTRUCT */ +WFR_PORT_STRUCT( ParallelFor_1_elseBranch_in, 55, \ + WFR_PORT_MEMBER_IWIRBOOL(condDecisionPostProcessSingle) \ + WFR_PORT_MEMBER(PLMTars, filecollref) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* ParallelFor_1_elseBranch OUTSTRUCT */ +WFR_PORT_STRUCT( ParallelFor_1_elseBranch_out, 56, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* helper03_else INSTRUCT */ +WFR_PORT_STRUCT( helper03_else_in, 57, \ + WFR_PORT_MEMBER(PLMTars, filecollref) \ + WFR_PORT_MEMBER_IWIRINT(index) \ +) + +/* helper03_else OUTSTRUCT */ +WFR_PORT_STRUCT( helper03_else_out, 58, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar0) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar1) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar2) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar3) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar4) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar5) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar6) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar7) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar8) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar9) \ +) + +/* linearModel_0_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_0_else_in, 59, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_0_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_0_else_out, 60, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_1_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_1_else_in, 61, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_1_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_1_else_out, 62, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_2_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_2_else_in, 63, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_2_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_2_else_out, 64, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_3_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_3_else_in, 65, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_3_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_3_else_out, 66, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_4_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_4_else_in, 67, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_4_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_4_else_out, 68, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_5_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_5_else_in, 69, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_5_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_5_else_out, 70, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_6_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_6_else_in, 71, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_6_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_6_else_out, 72, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_7_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_7_else_in, 73, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_7_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_7_else_out, 74, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_8_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_8_else_in, 75, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_8_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_8_else_out, 76, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_9_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_9_else_in, 77, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_9_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_9_else_out, 78, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* postProcessSingle_0_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_0_else_in, 79, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_0_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_0_else_out, 80, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_1_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_1_else_in, 81, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_1_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_1_else_out, 82, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_2_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_2_else_in, 83, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_2_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_2_else_out, 84, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_3_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_3_else_in, 85, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_3_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_3_else_out, 86, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_4_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_4_else_in, 87, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_4_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_4_else_out, 88, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_5_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_5_else_in, 89, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_5_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_5_else_out, 90, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_6_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_6_else_in, 91, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_6_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_6_else_out, 92, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_7_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_7_else_in, 93, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_7_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_7_else_out, 94, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_8_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_8_else_in, 95, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_8_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_8_else_out, 96, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_9_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_9_else_in, 97, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_9_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_9_else_out, 98, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* helper04_else INSTRUCT */ +WFR_PORT_STRUCT( helper04_else_in, 99, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar0) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar1) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar2) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar3) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar4) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar5) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar6) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar7) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar8) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar9) \ +) + +/* helper04_else OUTSTRUCT */ +WFR_PORT_STRUCT( helper04_else_out, 100, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* DecisionNode_2 INSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_2_in, 101, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRBOOL(condDecisionPostProcessFinal) \ +) + +/* DecisionNode_2 OUTSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_2_out, 102, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(LMtarsList, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* postProcessFinal INSTRUCT */ +WFR_PORT_STRUCT( postProcessFinal_in, 103, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* postProcessFinal OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessFinal_out, 104, \ + WFR_PORT_MEMBER_IWIRFILE(finalTar) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* RAINCLOUD_TEST01_H */ diff --git a/src/04.loopnesting/CMakeLists.txt b/src/04.loopnesting/CMakeLists.txt new file mode 100644 index 0000000..78f4752 --- /dev/null +++ b/src/04.loopnesting/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(raincloud-04-loopnesting C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin raincloud.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/04.loopnesting/raincloud.cpp b/src/04.loopnesting/raincloud.cpp new file mode 100644 index 0000000..3db968b --- /dev/null +++ b/src/04.loopnesting/raincloud.cpp @@ -0,0 +1,2248 @@ +#include "raincloud.h" +#include +#include +#include +#include + +std::atomic iterCount = ATOMIC_VAR_INIT(0); + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_PORT_INIT_COLLECTION(sout->finalTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + WFR_CHILD_OUTBUFFER_GET(a1out, DecisionNode_1_out, a1, 4, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->outfiles, a1out->outfiles)); + } + WFR_CHILD_OUTBUFFER_GET(a2out, DecisionNode_2_out, a2, 53, 0); + if (a2out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->finalTars, a2out->LMtarsList)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->finalTars.isReady() && sout->outfiles.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(prepareLMInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, prepareLM_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->datain, a1in->datain)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->NGroup, a1in->NGroup)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->VAR1, a1in->Var1)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->FAC1, a1in->Fac1)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->VAR2, a1in->Var2)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->FAC2, a1in->Fac2)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->topo, a1in->topo)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->topo.isReady() && sin->datain.isReady() && sin->NGroup.isReady() && sin->VAR1.isReady() && sin->FAC1.isReady() && sin->VAR2.isReady() && sin->FAC2.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(prepareLMExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, prepareLM_in); + WFR_SELF_OUTBUFFER_INIT(sout, prepareLM_out); + WFR_PORT_INIT_COLLECTION(sout->PLMlistTars); + for (int t = 0; t < sin->NGroup.getValue(); t++) { + sout->PLMlistTars.setEntryValue(t, std::string("file")); + } + sout->PLMlistTars.setFinalised(true); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper05_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->NGroup, a1in->NGroup)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->NGroup.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper05ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper05_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper05_out); + + auto tmp01 = std::sqrt(sin->NGroup.getValue()/10); + sout->innerLoopIterCount.setValue(tmp01); + sout->outerLoopIterCount.setValue(tmp01); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(DecisionNode_1InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, DecisionNode_1_in); + WFR_PORT_INIT_COLLECTION(sin->PLMTars); + WFR_PRED_OUTBUFFER_GET(a1in, helper05_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->outerLoopIterCount, a1in->outerLoopIterCount)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->innerLoopIterCount, a1in->innerLoopIterCount)); + } + WFR_PRED_OUTBUFFER_GET(a2in, prepareLM_out, a2, 1); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a2in->PLMlistTars)); + } + WFR_PARENT_INBUFFER_GET(a3in, toplevel_in, a3); + if (a3in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->condDecisionPostProcessSingle, a3in->decisionPostProcessSingle)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(DecisionNode_1OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, DecisionNode_1_out); + WFR_PORT_INIT_COLLECTION(sout->PPSlistTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, ParallelFor_1_thenBranch_out, a1, 5, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->PPSlistTars, a1out->PPSlistTars)); + } + } else if (WFR_SELF_GETCONDBRANCHID() == 1) { + WFR_CHILD_OUTBUFFER_GET(a1out, ParallelFor_1_elseBranch_out, a1, 29, 1); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->PPSlistTars, a1out->PPSlistTars)); + } + } + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, ParallelFor_1_thenBranch_out, a1, 5, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->outfiles, a1out->outfiles)); + } + } else if (WFR_SELF_GETCONDBRANCHID() == 1) { + WFR_CHILD_OUTBUFFER_GET(a1out, ParallelFor_1_elseBranch_out, a1, 29, 1); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->outfiles, a1out->outfiles)); + } + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->PPSlistTars.isReady() && sout->outfiles.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_BRANCHCONDITION_HOOK(DecisionNode_1BranchConditionFunc) { + WFR_BRANCHCONDITION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, DecisionNode_1_in); + if (sin != nullptr && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution && sin->condDecisionPostProcessSingle.isReady() ) { + if ((sin->condDecisionPostProcessSingle.getValue() == true)) { + instance.setExecutionBranchID(0); + } else { + instance.setExecutionBranchID(1); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_BRANCHCONDITION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(ParallelFor_1_thenBranchInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, ParallelFor_1_thenBranch_in); + WFR_PORT_INIT_COLLECTION(sin->PLMTars); + WFR_PARENT_INBUFFER_GET(a1in, DecisionNode_1_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a1in->PLMTars)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->outerLoopIterCount)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->innerLoopIterCount, a1in->innerLoopIterCount)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->condDecisionPostProcessSingle, a1in->condDecisionPostProcessSingle)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(ParallelFor_1_thenBranchOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, ParallelFor_1_thenBranch_out); + WFR_PORT_INIT_COLLECTION(sout->PPSlistTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN_FLATTEN(sout->outfiles, 1, ParallelFor_2_thenBranch_out, outfiles, 6); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN_FLATTEN(sout->PPSlistTars, 1, ParallelFor_2_thenBranch_out, PPSlistTars, 6); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->PPSlistTars.isReady() && sout->outfiles.isReady()); + + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(ParallelFor_1_thenBranchCounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, ParallelFor_1_thenBranch_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(ParallelFor_2_thenBranchInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, ParallelFor_2_thenBranch_in); + WFR_PORT_INIT_COLLECTION(sin->PLMTars); + WFR_PARENT_INBUFFER_GET(a1in, ParallelFor_1_thenBranch_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->condDecisionPostProcessSingle, a1in->condDecisionPostProcessSingle)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a1in->PLMTars)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->innerLoopIterCount)); + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->parentLoopCounter); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(ParallelFor_2_thenBranchOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, ParallelFor_2_thenBranch_out); + WFR_PORT_INIT_COLLECTION(sout->PPSlistTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN_FLATTEN(sout->PPSlistTars, 1, helper04_then_out, PPSTars, 28); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->outfiles, linearModel_1_then_out, outfile, 9); + WFR_LOOP_FINALIZE_COLLECTION(sout, outfiles); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->PPSlistTars.isReady() && sout->outfiles.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(ParallelFor_2_thenBranchCounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, ParallelFor_2_thenBranch_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper06_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper06_then_in); + WFR_PORT_INIT_COLLECTION(sin->PLMTars); + WFR_PARENT_INBUFFER_GET(a1in, ParallelFor_2_thenBranch_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a1in->PLMTars)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->index1, a1in->parentLoopCounter)); + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->index2); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTars.isReady() && sin->index1.isReady() && sin->index2.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper06_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper06_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper06_then_out); + + auto i = (sin->index1.getValue()-1)*10; + sout->PLMTar0.setValue(sin->PLMTars.getEntryValue(i)); + sout->PLMTar1.setValue(sin->PLMTars.getEntryValue(i+1)); + sout->PLMTar2.setValue(sin->PLMTars.getEntryValue(i+2)); + sout->PLMTar3.setValue(sin->PLMTars.getEntryValue(i+3)); + sout->PLMTar4.setValue(sin->PLMTars.getEntryValue(i+4)); + sout->PLMTar5.setValue(sin->PLMTars.getEntryValue(i+5)); + sout->PLMTar6.setValue(sin->PLMTars.getEntryValue(i+6)); + sout->PLMTar7.setValue(sin->PLMTars.getEntryValue(i+7)); + sout->PLMTar8.setValue(sin->PLMTars.getEntryValue(i+8)); + sout->PLMTar9.setValue(sin->PLMTars.getEntryValue(i+9)); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_0_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_0_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar0)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_0_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_0_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_0_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + iterCount.fetch_add(1); + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_1_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_1_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar1)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_1_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_1_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_1_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_2_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_2_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar2)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_2_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_2_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_2_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_3_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_3_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar3)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_3_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_3_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_3_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_4_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_4_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar4)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_4_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_4_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_4_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_5_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_5_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar5)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_5_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_5_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_5_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_6_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_6_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar6)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_6_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_6_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_6_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_7_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_7_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar7)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_7_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_7_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_7_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_8_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_8_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar8)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_8_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_8_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_8_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_9_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_9_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar9)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_9_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_9_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_9_then_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_0_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_0_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_0_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_0_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_0_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_0_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_1_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_1_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_1_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_1_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_1_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_1_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_2_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_2_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_2_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_2_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_2_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_2_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_3_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_3_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_3_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_3_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_3_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_3_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_4_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_4_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_4_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_4_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_4_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_4_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_5_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_5_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_5_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_5_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_5_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_5_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_6_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_6_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_6_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_6_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_6_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_6_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_7_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_7_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_7_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_7_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_7_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_7_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_8_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_8_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_8_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_8_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_8_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_8_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_9_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_9_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_9_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_9_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_9_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_9_then_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper04_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper04_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, postProcessSingle_6_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar6, a1in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a2in, postProcessSingle_3_then_out, a2, 1); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar3, a2in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a3in, postProcessSingle_9_then_out, a3, 2); + if (a3in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar9, a3in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a4in, postProcessSingle_2_then_out, a4, 3); + if (a4in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar2, a4in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a5in, postProcessSingle_1_then_out, a5, 4); + if (a5in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar1, a5in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a6in, postProcessSingle_5_then_out, a6, 5); + if (a6in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar5, a6in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a7in, postProcessSingle_7_then_out, a7, 6); + if (a7in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar7, a7in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a8in, postProcessSingle_8_then_out, a8, 7); + if (a8in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar8, a8in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a9in, postProcessSingle_0_then_out, a9, 8); + if (a9in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar0, a9in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a10in, postProcessSingle_4_then_out, a10, 9); + if (a10in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar4, a10in->PPSTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PPSTar0.isReady() && sin->PPSTar1.isReady() && sin->PPSTar2.isReady() && sin->PPSTar3.isReady() && sin->PPSTar4.isReady() && sin->PPSTar5.isReady() && sin->PPSTar6.isReady() && sin->PPSTar7.isReady() && sin->PPSTar8.isReady() && sin->PPSTar9.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper04_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper04_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper04_then_out); + WFR_PORT_INIT_COLLECTION(sout->PPSTars); + sout->PPSTars.setEntryValue(0, sin->PPSTar0.getValue()); + sout->PPSTars.setEntryValue(1, sin->PPSTar1.getValue()); + sout->PPSTars.setEntryValue(2, sin->PPSTar2.getValue()); + sout->PPSTars.setEntryValue(3, sin->PPSTar3.getValue()); + sout->PPSTars.setEntryValue(4, sin->PPSTar4.getValue()); + sout->PPSTars.setEntryValue(5, sin->PPSTar5.getValue()); + sout->PPSTars.setEntryValue(6, sin->PPSTar6.getValue()); + sout->PPSTars.setEntryValue(7, sin->PPSTar7.getValue()); + sout->PPSTars.setEntryValue(8, sin->PPSTar8.getValue()); + sout->PPSTars.setEntryValue(9, sin->PPSTar9.getValue()); + sout->PPSTars.setFinalised(true); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(ParallelFor_1_elseBranchInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, ParallelFor_1_elseBranch_in); + WFR_PORT_INIT_COLLECTION(sin->PLMTars); + WFR_PARENT_INBUFFER_GET(a1in, DecisionNode_1_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a1in->PLMTars)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->outerLoopIterCount)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->innerLoopIterCount, a1in->innerLoopIterCount)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->condDecisionPostProcessSingle, a1in->condDecisionPostProcessSingle)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(ParallelFor_1_elseBranchOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, ParallelFor_1_elseBranch_out); + WFR_PORT_INIT_COLLECTION(sout->PPSlistTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN_FLATTEN(sout->outfiles, 1, ParallelFor_2_elseBranch_out, outfiles, 30); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN_FLATTEN(sout->PPSlistTars, 1, ParallelFor_2_elseBranch_out, PPSlistTars, 30); + + //WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->PPSlistTars.isReady() && sout->outfiles.isReady()); + if (sout->PPSlistTars.isReady() && sout->outfiles.isReady()) { + instance.setAllOutputsAvailable(true); + } + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(ParallelFor_1_elseBranchCounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, ParallelFor_1_elseBranch_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(ParallelFor_2_elseBranchInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, ParallelFor_2_elseBranch_in); + WFR_PORT_INIT_COLLECTION(sin->PLMTars); + WFR_PARENT_INBUFFER_GET(a1in, ParallelFor_1_elseBranch_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->condDecisionPostProcessSingle, a1in->condDecisionPostProcessSingle)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a1in->PLMTars)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->innerLoopIterCount)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(ParallelFor_2_elseBranchOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, ParallelFor_2_elseBranch_out); + WFR_PORT_INIT_COLLECTION(sout->PPSlistTars); + WFR_PORT_INIT_COLLECTION(sout->outfiles); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->outfiles, linearModel_1_else_out, outfile, 33); + WFR_LOOP_FINALIZE_COLLECTION(sout, outfiles); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN_FLATTEN(sout->PPSlistTars, 1, helper04_else_out, PPSTars, 52); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->PPSlistTars.isReady() && sout->outfiles.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(ParallelFor_2_elseBranchCounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, ParallelFor_2_elseBranch_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper06_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper06_else_in); + WFR_PORT_INIT_COLLECTION(sin->PLMTars); + WFR_PARENT_INBUFFER_GET(a1in, ParallelFor_2_elseBranch_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTars, a1in->PLMTars)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->index1, a1in->parentLoopCounter)); + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->index2); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTars.isReady() && sin->index1.isReady() && sin->index2.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper06_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper06_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper06_else_out); + + auto i = (sin->index1.getValue()-1)*10; + sout->PLMTar0.setValue(sin->PLMTars.getEntryValue(i)); + sout->PLMTar1.setValue(sin->PLMTars.getEntryValue(i+1)); + sout->PLMTar2.setValue(sin->PLMTars.getEntryValue(i+2)); + sout->PLMTar3.setValue(sin->PLMTars.getEntryValue(i+3)); + sout->PLMTar4.setValue(sin->PLMTars.getEntryValue(i+4)); + sout->PLMTar5.setValue(sin->PLMTars.getEntryValue(i+5)); + sout->PLMTar6.setValue(sin->PLMTars.getEntryValue(i+6)); + sout->PLMTar7.setValue(sin->PLMTars.getEntryValue(i+7)); + sout->PLMTar8.setValue(sin->PLMTars.getEntryValue(i+8)); + sout->PLMTar9.setValue(sin->PLMTars.getEntryValue(i+9)); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_0_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_0_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar0)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_0_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_0_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_0_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_1_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_1_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar1)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_1_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_1_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_1_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_2_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_2_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar2)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_2_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_2_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_2_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_3_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_3_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar3)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_3_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_3_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_3_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_4_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_4_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar4)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_4_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_4_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_4_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_5_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_5_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar5)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_5_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_5_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_5_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_6_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_6_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar6)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_6_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_6_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_6_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_7_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_7_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar7)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_7_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_7_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_7_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_8_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_8_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar8)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_8_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_8_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_8_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(linearModel_9_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, linearModel_9_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper06_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PLMTar, a1in->PLMTar9)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PLMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(linearModel_9_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, linearModel_9_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, linearModel_9_else_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../linearModelDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/LMout_g.tar.gz", wpath.string().c_str()); + sout->LMTar.setValue(std::string(file1)); + char file2[1024]; + snprintf(file2, 1024, "%s/out.txt", wpath.string().c_str()); + sout->outfile.setValue(std::string(file2));*/ + + sout->LMTar.setValue(std::string("file1")); + sout->outfile.setValue(std::string("file2")); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_0_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_0_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_0_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_0_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_0_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_0_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_1_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_1_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_1_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_1_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_1_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_1_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_2_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_2_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_2_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_2_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_2_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_2_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_3_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_3_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_3_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_3_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_3_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_3_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_4_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_4_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_4_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_4_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_4_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_4_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_5_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_5_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_5_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_5_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_5_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_5_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_6_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_6_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_6_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_6_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_6_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_6_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_7_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_7_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_7_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_7_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_7_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_7_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_8_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_8_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_8_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_8_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_8_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_8_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessSingle_9_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessSingle_9_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, linearModel_9_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->LMTar, a1in->LMTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->LMTar.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessSingle_9_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessSingle_9_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessSingle_9_else_out); + /*auto lmtar = sin->LMTar.getValue(); + boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessSingleDummy.sh %d", wpath.string().c_str(), WFR_SELF_GETITERATIONID()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/PPSout_g.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->PPSTar.setValue("file1"); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper04_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper04_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, postProcessSingle_2_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar2, a1in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a2in, postProcessSingle_8_else_out, a2, 1); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar8, a2in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a3in, postProcessSingle_3_else_out, a3, 2); + if (a3in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar3, a3in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a4in, postProcessSingle_4_else_out, a4, 3); + if (a4in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar4, a4in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a5in, postProcessSingle_5_else_out, a5, 4); + if (a5in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar5, a5in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a6in, postProcessSingle_7_else_out, a6, 5); + if (a6in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar7, a6in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a7in, postProcessSingle_6_else_out, a7, 6); + if (a7in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar6, a7in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a8in, postProcessSingle_9_else_out, a8, 7); + if (a8in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar9, a8in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a9in, postProcessSingle_1_else_out, a9, 8); + if (a9in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar1, a9in->PPSTar)); + } + WFR_PRED_OUTBUFFER_GET(a10in, postProcessSingle_0_else_out, a10, 9); + if (a10in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSTar0, a10in->PPSTar)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PPSTar0.isReady() && sin->PPSTar1.isReady() && sin->PPSTar2.isReady() && sin->PPSTar3.isReady() && sin->PPSTar4.isReady() && sin->PPSTar5.isReady() && sin->PPSTar6.isReady() && sin->PPSTar7.isReady() && sin->PPSTar8.isReady() && sin->PPSTar9.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper04_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper04_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper04_else_out); + WFR_PORT_INIT_COLLECTION(sout->PPSTars); +sout->PPSTars.setEntryValue(0, sin->PPSTar0.getValue()); +sout->PPSTars.setEntryValue(1, sin->PPSTar1.getValue()); +sout->PPSTars.setEntryValue(2, sin->PPSTar2.getValue()); +sout->PPSTars.setEntryValue(3, sin->PPSTar3.getValue()); +sout->PPSTars.setEntryValue(4, sin->PPSTar4.getValue()); +sout->PPSTars.setEntryValue(5, sin->PPSTar5.getValue()); +sout->PPSTars.setEntryValue(6, sin->PPSTar6.getValue()); +sout->PPSTars.setEntryValue(7, sin->PPSTar7.getValue()); +sout->PPSTars.setEntryValue(8, sin->PPSTar8.getValue()); +sout->PPSTars.setEntryValue(9, sin->PPSTar9.getValue()); +sout->PPSTars.setFinalised(true); + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(DecisionNode_2InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, DecisionNode_2_in); + WFR_PORT_INIT_COLLECTION(sin->PPSlistTars); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->condDecisionPostProcessFinal, a1in->decisionPostProcessFinal)); + } + WFR_PRED_OUTBUFFER_GET(a2in, DecisionNode_1_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSlistTars, a2in->PPSlistTars)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(DecisionNode_2OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, DecisionNode_2_out); + WFR_PORT_INIT_COLLECTION(sout->LMtarsList); + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, postProcessFinal_out, a1, 54, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->LMtarsList, a1out->finalTar, 0)); + WFR_FINALIZE_COLLECTION(sout, LMtarsList); + } + } else { + WFR_SELF_INBUFFER_GET(a1in, DecisionNode_2_in); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->LMtarsList, a1in->PPSlistTars)); + if (retval) { + instance.setInstanceStatus(wfs::ActivityInstanceStatus::Finished); + ((wfs::CompositeActivityInstance&)instance).notifyChildHasFinished(instance); + } + } + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->LMtarsList.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_BRANCHCONDITION_HOOK(DecisionNode_2BranchConditionFunc) { + WFR_BRANCHCONDITION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, DecisionNode_2_in); + if (sin != nullptr && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution && sin->condDecisionPostProcessFinal.isReady() ) { + if (sin->condDecisionPostProcessFinal.getValue() == true) { + instance.setExecutionBranchID(0); + } else { + instance.setExecutionBranchID(1); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_BRANCHCONDITION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(postProcessFinalInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, postProcessFinal_in); + WFR_PORT_INIT_COLLECTION(sin->PPSlistTars); + WFR_PARENT_INBUFFER_GET(a1in, DecisionNode_2_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->PPSlistTars, a1in->PPSlistTars)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->PPSlistTars.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(postProcessFinalExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, postProcessFinal_in); + WFR_SELF_OUTBUFFER_INIT(sout, postProcessFinal_out); + /*boost::filesystem::path wpath = wfr::filesystem::createWorkingFolder(instance); + char cmd[2048]; + snprintf(cmd, 2048, "cd %s && ../postProcessFinalDummy.sh", wpath.string().c_str()); + int ret = system(cmd); + char file1[1024]; + snprintf(file1, 1024, "%s/FINAL.tar.gz", wpath.string().c_str()); + sout->finalTar.setValue(file1);*/ + + sout->finalTar.setValue("file1"); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( prepareLMImplementations, "prepareLMImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(prepareLMExecFunc_0, "prepareLMExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( helper05Implementations, "helper05Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(helper05ExecFunc_0, "helper05ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( helper06_thenImplementations, "helper06_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(helper06_thenExecFunc_0, "helper06_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_0_thenImplementations, "linearModel_0_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_0_thenExecFunc_0, "linearModel_0_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_1_thenImplementations, "linearModel_1_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_1_thenExecFunc_0, "linearModel_1_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_2_thenImplementations, "linearModel_2_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_2_thenExecFunc_0, "linearModel_2_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_3_thenImplementations, "linearModel_3_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_3_thenExecFunc_0, "linearModel_3_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_4_thenImplementations, "linearModel_4_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_4_thenExecFunc_0, "linearModel_4_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_5_thenImplementations, "linearModel_5_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_5_thenExecFunc_0, "linearModel_5_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_6_thenImplementations, "linearModel_6_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_6_thenExecFunc_0, "linearModel_6_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_7_thenImplementations, "linearModel_7_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_7_thenExecFunc_0, "linearModel_7_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_8_thenImplementations, "linearModel_8_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_8_thenExecFunc_0, "linearModel_8_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_9_thenImplementations, "linearModel_9_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_9_thenExecFunc_0, "linearModel_9_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_0_thenImplementations, "postProcessSingle_0_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_0_thenExecFunc_0, "postProcessSingle_0_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_1_thenImplementations, "postProcessSingle_1_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_1_thenExecFunc_0, "postProcessSingle_1_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_2_thenImplementations, "postProcessSingle_2_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_2_thenExecFunc_0, "postProcessSingle_2_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_3_thenImplementations, "postProcessSingle_3_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_3_thenExecFunc_0, "postProcessSingle_3_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_4_thenImplementations, "postProcessSingle_4_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_4_thenExecFunc_0, "postProcessSingle_4_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_5_thenImplementations, "postProcessSingle_5_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_5_thenExecFunc_0, "postProcessSingle_5_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_6_thenImplementations, "postProcessSingle_6_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_6_thenExecFunc_0, "postProcessSingle_6_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_7_thenImplementations, "postProcessSingle_7_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_7_thenExecFunc_0, "postProcessSingle_7_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_8_thenImplementations, "postProcessSingle_8_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_8_thenExecFunc_0, "postProcessSingle_8_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_9_thenImplementations, "postProcessSingle_9_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_9_thenExecFunc_0, "postProcessSingle_9_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( helper04_thenImplementations, "helper04_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(helper04_thenExecFunc_0, "helper04_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( helper06_elseImplementations, "helper06_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(helper06_elseExecFunc_0, "helper06_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_0_elseImplementations, "linearModel_0_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_0_elseExecFunc_0, "linearModel_0_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_1_elseImplementations, "linearModel_1_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_1_elseExecFunc_0, "linearModel_1_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_2_elseImplementations, "linearModel_2_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_2_elseExecFunc_0, "linearModel_2_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_3_elseImplementations, "linearModel_3_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_3_elseExecFunc_0, "linearModel_3_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_4_elseImplementations, "linearModel_4_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_4_elseExecFunc_0, "linearModel_4_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_5_elseImplementations, "linearModel_5_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_5_elseExecFunc_0, "linearModel_5_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_6_elseImplementations, "linearModel_6_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_6_elseExecFunc_0, "linearModel_6_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_7_elseImplementations, "linearModel_7_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_7_elseExecFunc_0, "linearModel_7_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_8_elseImplementations, "linearModel_8_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_8_elseExecFunc_0, "linearModel_8_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( linearModel_9_elseImplementations, "linearModel_9_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(linearModel_9_elseExecFunc_0, "linearModel_9_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_0_elseImplementations, "postProcessSingle_0_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_0_elseExecFunc_0, "postProcessSingle_0_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_1_elseImplementations, "postProcessSingle_1_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_1_elseExecFunc_0, "postProcessSingle_1_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_2_elseImplementations, "postProcessSingle_2_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_2_elseExecFunc_0, "postProcessSingle_2_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_3_elseImplementations, "postProcessSingle_3_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_3_elseExecFunc_0, "postProcessSingle_3_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_4_elseImplementations, "postProcessSingle_4_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_4_elseExecFunc_0, "postProcessSingle_4_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_5_elseImplementations, "postProcessSingle_5_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_5_elseExecFunc_0, "postProcessSingle_5_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_6_elseImplementations, "postProcessSingle_6_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_6_elseExecFunc_0, "postProcessSingle_6_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_7_elseImplementations, "postProcessSingle_7_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_7_elseExecFunc_0, "postProcessSingle_7_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_8_elseImplementations, "postProcessSingle_8_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_8_elseExecFunc_0, "postProcessSingle_8_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessSingle_9_elseImplementations, "postProcessSingle_9_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessSingle_9_elseExecFunc_0, "postProcessSingle_9_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( helper04_elseImplementations, "helper04_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(helper04_elseExecFunc_0, "helper04_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( postProcessFinalImplementations, "postProcessFinalImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(postProcessFinalExecFunc_0, "postProcessFinalExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "generatedWorkflow", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::atomic(2, "prepareLM", 1, 0, {4}, {}, prepareLMInputFunc, prepareLMImplementations), \ + wfr::wfs::ActivityTemplate::assign(3, "helper05", 1, 0, {4}, {}, helper05InputFunc, helper05ExecFunc_0), \ + wfr::wfs::ActivityTemplate::conditional(4, "DecisionNode_1", 1, 0, {53}, {3, 2}, DecisionNode_1InputFunc, DecisionNode_1OutputFunc, DecisionNode_1BranchConditionFunc), \ + wfr::wfs::ActivityTemplate::forLoop(5, "ParallelFor_1_thenBranch", 4, 0, {}, {}, ParallelFor_1_thenBranchInputFunc, ParallelFor_1_thenBranchOutputFunc, ParallelFor_1_thenBranchCounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::forLoop(6, "ParallelFor_2_thenBranch", 5, 0, {}, {}, ParallelFor_2_thenBranchInputFunc, ParallelFor_2_thenBranchOutputFunc, ParallelFor_2_thenBranchCounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::assign(7, "helper06_then", 6, 0, {8, 9, 16, 17, 11, 12, 10, 13, 15, 14}, {}, helper06_thenInputFunc, helper06_thenExecFunc_0), \ + wfr::wfs::ActivityTemplate::atomic(8, "linearModel_0_then", 6, 0, {18}, {7}, linearModel_0_thenInputFunc, linearModel_0_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(9, "linearModel_1_then", 6, 0, {19}, {7}, linearModel_1_thenInputFunc, linearModel_1_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(10, "linearModel_2_then", 6, 0, {20}, {7}, linearModel_2_thenInputFunc, linearModel_2_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(11, "linearModel_3_then", 6, 0, {21}, {7}, linearModel_3_thenInputFunc, linearModel_3_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(12, "linearModel_4_then", 6, 0, {22}, {7}, linearModel_4_thenInputFunc, linearModel_4_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(13, "linearModel_5_then", 6, 0, {23}, {7}, linearModel_5_thenInputFunc, linearModel_5_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(14, "linearModel_6_then", 6, 0, {24}, {7}, linearModel_6_thenInputFunc, linearModel_6_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(15, "linearModel_7_then", 6, 0, {25}, {7}, linearModel_7_thenInputFunc, linearModel_7_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(16, "linearModel_8_then", 6, 0, {26}, {7}, linearModel_8_thenInputFunc, linearModel_8_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(17, "linearModel_9_then", 6, 0, {27}, {7}, linearModel_9_thenInputFunc, linearModel_9_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(18, "postProcessSingle_0_then", 6, 0, {28}, {8}, postProcessSingle_0_thenInputFunc, postProcessSingle_0_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(19, "postProcessSingle_1_then", 6, 0, {28}, {9}, postProcessSingle_1_thenInputFunc, postProcessSingle_1_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(20, "postProcessSingle_2_then", 6, 0, {28}, {10}, postProcessSingle_2_thenInputFunc, postProcessSingle_2_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(21, "postProcessSingle_3_then", 6, 0, {28}, {11}, postProcessSingle_3_thenInputFunc, postProcessSingle_3_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(22, "postProcessSingle_4_then", 6, 0, {28}, {12}, postProcessSingle_4_thenInputFunc, postProcessSingle_4_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(23, "postProcessSingle_5_then", 6, 0, {28}, {13}, postProcessSingle_5_thenInputFunc, postProcessSingle_5_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(24, "postProcessSingle_6_then", 6, 0, {28}, {14}, postProcessSingle_6_thenInputFunc, postProcessSingle_6_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(25, "postProcessSingle_7_then", 6, 0, {28}, {15}, postProcessSingle_7_thenInputFunc, postProcessSingle_7_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(26, "postProcessSingle_8_then", 6, 0, {28}, {16}, postProcessSingle_8_thenInputFunc, postProcessSingle_8_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(27, "postProcessSingle_9_then", 6, 0, {28}, {17}, postProcessSingle_9_thenInputFunc, postProcessSingle_9_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(28, "helper04_then", 6, 0, {}, {24, 21, 27, 20, 19, 23, 25, 26, 18, 22}, helper04_thenInputFunc, helper04_thenImplementations), \ + wfr::wfs::ActivityTemplate::forLoop(29, "ParallelFor_1_elseBranch", 4, 1, {}, {}, ParallelFor_1_elseBranchInputFunc, ParallelFor_1_elseBranchOutputFunc, ParallelFor_1_elseBranchCounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::forLoop(30, "ParallelFor_2_elseBranch", 29, 0, {}, {}, ParallelFor_2_elseBranchInputFunc, ParallelFor_2_elseBranchOutputFunc, ParallelFor_2_elseBranchCounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::assign(31, "helper06_else", 30, 0, {33, 40, 39, 41, 38, 35, 37, 36, 34, 32}, {}, helper06_elseInputFunc, helper06_elseExecFunc_0), \ + wfr::wfs::ActivityTemplate::atomic(32, "linearModel_0_else", 30, 0, {42}, {31}, linearModel_0_elseInputFunc, linearModel_0_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(33, "linearModel_1_else", 30, 0, {43}, {31}, linearModel_1_elseInputFunc, linearModel_1_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(34, "linearModel_2_else", 30, 0, {44}, {31}, linearModel_2_elseInputFunc, linearModel_2_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(35, "linearModel_3_else", 30, 0, {45}, {31}, linearModel_3_elseInputFunc, linearModel_3_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(36, "linearModel_4_else", 30, 0, {46}, {31}, linearModel_4_elseInputFunc, linearModel_4_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(37, "linearModel_5_else", 30, 0, {47}, {31}, linearModel_5_elseInputFunc, linearModel_5_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(38, "linearModel_6_else", 30, 0, {48}, {31}, linearModel_6_elseInputFunc, linearModel_6_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(39, "linearModel_7_else", 30, 0, {49}, {31}, linearModel_7_elseInputFunc, linearModel_7_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(40, "linearModel_8_else", 30, 0, {50}, {31}, linearModel_8_elseInputFunc, linearModel_8_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(41, "linearModel_9_else", 30, 0, {51}, {31}, linearModel_9_elseInputFunc, linearModel_9_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(42, "postProcessSingle_0_else", 30, 0, {52}, {32}, postProcessSingle_0_elseInputFunc, postProcessSingle_0_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(43, "postProcessSingle_1_else", 30, 0, {52}, {33}, postProcessSingle_1_elseInputFunc, postProcessSingle_1_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(44, "postProcessSingle_2_else", 30, 0, {52}, {34}, postProcessSingle_2_elseInputFunc, postProcessSingle_2_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(45, "postProcessSingle_3_else", 30, 0, {52}, {35}, postProcessSingle_3_elseInputFunc, postProcessSingle_3_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(46, "postProcessSingle_4_else", 30, 0, {52}, {36}, postProcessSingle_4_elseInputFunc, postProcessSingle_4_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(47, "postProcessSingle_5_else", 30, 0, {52}, {37}, postProcessSingle_5_elseInputFunc, postProcessSingle_5_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(48, "postProcessSingle_6_else", 30, 0, {52}, {38}, postProcessSingle_6_elseInputFunc, postProcessSingle_6_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(49, "postProcessSingle_7_else", 30, 0, {52}, {39}, postProcessSingle_7_elseInputFunc, postProcessSingle_7_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(50, "postProcessSingle_8_else", 30, 0, {52}, {40}, postProcessSingle_8_elseInputFunc, postProcessSingle_8_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(51, "postProcessSingle_9_else", 30, 0, {52}, {41}, postProcessSingle_9_elseInputFunc, postProcessSingle_9_elseImplementations), \ + wfr::wfs::ActivityTemplate::assign(52, "helper04_else", 30, 0, {}, {44, 50, 45, 46, 47, 49, 48, 51, 43, 42}, helper04_elseInputFunc, helper04_elseExecFunc_0), \ + wfr::wfs::ActivityTemplate::conditional(53, "DecisionNode_2", 1, 0, {}, {4}, DecisionNode_2InputFunc, DecisionNode_2OutputFunc, DecisionNode_2BranchConditionFunc), \ + wfr::wfs::ActivityTemplate::atomic(54, "postProcessFinal", 53, 0, {}, {}, postProcessFinalInputFunc, postProcessFinalImplementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + std::string var1 = "0:2500:12000"; + long fac1 = 1; + std::string var2 = "250:10:310"; + long fac2 = 1; + long ngroup = 8; + bool decisionPostProcessFinal = true; + bool decisionPostProcessSingle = true; + std::string topo = "input/Topography.tar.gz"; + std::string datain = "input/DataIN.tar.gz"; + bool isHelp = false; + boost::program_options::options_description opts("Raincloud Options"); + opts.add_options() + ("help", "Print help message.") + ("var1", boost::program_options::value(), "Var1 parameter.") + ("fac1", boost::program_options::value(), "Fac1 parameter.") + ("var2", boost::program_options::value(), "Var2 parameter.") + ("fac2", boost::program_options::value(), "Fac2 parameter.") + ("ngroup", boost::program_options::value(), "NGroup parameter.") + ("decisionPostProcessFinal", boost::program_options::value(), "DecisionPostProcessFinal parameter.") + ("decisionPostProcessSingle", boost::program_options::value(), "DecisionPostProcessSingle parameter.") + ("topo", boost::program_options::value(), "Topography file.") + ("datain", boost::program_options::value(), "DataIN file."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("var1")) { + var1 = vm["var1"].as(); + } + if (vm.count("fac1")) { + fac1 = vm["fac1"].as(); + } + if (vm.count("var2")) { + var2 = vm["var2"].as(); + } + if (vm.count("fac2")) { + fac2 = vm["fac2"].as(); + } + if (vm.count("ngroup")) { + ngroup = vm["ngroup"].as(); + } + if (vm.count("decisionPostProcessFinal")) { + decisionPostProcessFinal = vm["decisionPostProcessFinal"].as(); + } + if (vm.count("decisionPostProcessSingle")) { + decisionPostProcessSingle = vm["decisionPostProcessSingle"].as(); + } + if (vm.count("topo")) { + topo = vm["topo"].as(); + } + if (vm.count("datain")) { + datain = vm["datain"].as(); + } + std::cerr << "var1 = " << var1 << std::endl; + std::cerr << "fac1 = " << fac1 << std::endl; + std::cerr << "var2 = " << var2 << std::endl; + std::cerr << "fac2 = " << fac2 << std::endl; + std::cerr << "ngroup = " << ngroup << std::endl; + std::cerr << "decisionPostProcessFinal = " << decisionPostProcessFinal << std::endl; + std::cerr << "decisionPostProcessSingle = " << decisionPostProcessSingle << std::endl; + std::cerr << "topo = " << topo << std::endl; + std::cerr << "datain = " << datain << std::endl; + } + wfInput.Var1.setValue(var1); + wfInput.Fac1.setValue(fac1); + wfInput.Var2.setValue(var2); + wfInput.Fac2.setValue(fac2); + wfInput.NGroup.setValue(ngroup); + wfInput.decisionPostProcessFinal.setValue(decisionPostProcessFinal); + wfInput.decisionPostProcessSingle.setValue(decisionPostProcessSingle); + wfInput.topo.setValue(topo); + wfInput.datain.setValue(datain); + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + std::cout << "IterCount = " << iterCount.load() << std::endl; + + + return 0; +} diff --git a/src/04.loopnesting/raincloud.h b/src/04.loopnesting/raincloud.h new file mode 100644 index 0000000..ac353d0 --- /dev/null +++ b/src/04.loopnesting/raincloud.h @@ -0,0 +1,648 @@ +#ifndef RAINCLOUD_TEST01_H +#define RAINCLOUD_TEST01_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRBOOL(decisionPostProcessSingle) \ + WFR_PORT_MEMBER_IWIRBOOL(decisionPostProcessFinal) \ + WFR_PORT_MEMBER_IWIRFILE(topo) \ + WFR_PORT_MEMBER_IWIRFILE(datain) \ + WFR_PORT_MEMBER_IWIRINT(NGroup) \ + WFR_PORT_MEMBER_IWIRSTRING(Var1) \ + WFR_PORT_MEMBER_IWIRINT(Fac1) \ + WFR_PORT_MEMBER_IWIRSTRING(Var2) \ + WFR_PORT_MEMBER_IWIRINT(Fac2) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(finalTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* prepareLM INSTRUCT */ +WFR_PORT_STRUCT( prepareLM_in, 3, \ + WFR_PORT_MEMBER_IWIRFILE(topo) \ + WFR_PORT_MEMBER_IWIRFILE(datain) \ + WFR_PORT_MEMBER_IWIRINT(NGroup) \ + WFR_PORT_MEMBER_IWIRSTRING(VAR1) \ + WFR_PORT_MEMBER_IWIRINT(FAC1) \ + WFR_PORT_MEMBER_IWIRSTRING(VAR2) \ + WFR_PORT_MEMBER_IWIRINT(FAC2) \ +) + +/* prepareLM OUTSTRUCT */ +WFR_PORT_STRUCT( prepareLM_out, 4, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* helper05 INSTRUCT */ +WFR_PORT_STRUCT( helper05_in, 5, \ + WFR_PORT_MEMBER_IWIRINT(NGroup) \ +) + +/* helper05 OUTSTRUCT */ +WFR_PORT_STRUCT( helper05_out, 6, \ + WFR_PORT_MEMBER_IWIRINT(outerLoopIterCount) \ + WFR_PORT_MEMBER_IWIRINT(innerLoopIterCount) \ +) + +/* DecisionNode_1 INSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_1_in, 7, \ + WFR_PORT_MEMBER_IWIRBOOL(condDecisionPostProcessSingle) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRINT(outerLoopIterCount) \ + WFR_PORT_MEMBER_IWIRINT(innerLoopIterCount) \ +) + +/* DecisionNode_1 OUTSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_1_out, 8, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* ParallelFor_1_thenBranch INSTRUCT */ +WFR_PORT_STRUCT( ParallelFor_1_thenBranch_in, 9, \ + WFR_PORT_MEMBER_IWIRBOOL(condDecisionPostProcessSingle) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRINT(innerLoopIterCount) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* ParallelFor_1_thenBranch OUTSTRUCT */ +WFR_PORT_STRUCT( ParallelFor_1_thenBranch_out, 10, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* ParallelFor_2_thenBranch INSTRUCT */ +WFR_PORT_STRUCT( ParallelFor_2_thenBranch_in, 11, \ + WFR_PORT_MEMBER_IWIRBOOL(condDecisionPostProcessSingle) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRINT(parentLoopCounter) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* ParallelFor_2_thenBranch OUTSTRUCT */ +WFR_PORT_STRUCT( ParallelFor_2_thenBranch_out, 12, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* helper06_then INSTRUCT */ +WFR_PORT_STRUCT( helper06_then_in, 13, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRINT(index1) \ + WFR_PORT_MEMBER_IWIRINT(index2) \ +) + +/* helper06_then OUTSTRUCT */ +WFR_PORT_STRUCT( helper06_then_out, 14, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar0) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar1) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar2) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar3) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar4) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar5) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar6) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar7) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar8) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar9) \ +) + +/* linearModel_0_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_0_then_in, 15, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_0_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_0_then_out, 16, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_1_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_1_then_in, 17, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_1_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_1_then_out, 18, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_2_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_2_then_in, 19, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_2_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_2_then_out, 20, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_3_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_3_then_in, 21, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_3_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_3_then_out, 22, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_4_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_4_then_in, 23, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_4_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_4_then_out, 24, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_5_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_5_then_in, 25, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_5_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_5_then_out, 26, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_6_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_6_then_in, 27, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_6_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_6_then_out, 28, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_7_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_7_then_in, 29, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_7_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_7_then_out, 30, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_8_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_8_then_in, 31, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_8_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_8_then_out, 32, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_9_then INSTRUCT */ +WFR_PORT_STRUCT( linearModel_9_then_in, 33, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_9_then OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_9_then_out, 34, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* postProcessSingle_0_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_0_then_in, 35, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_0_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_0_then_out, 36, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_1_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_1_then_in, 37, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_1_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_1_then_out, 38, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_2_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_2_then_in, 39, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_2_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_2_then_out, 40, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_3_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_3_then_in, 41, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_3_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_3_then_out, 42, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_4_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_4_then_in, 43, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_4_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_4_then_out, 44, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_5_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_5_then_in, 45, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_5_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_5_then_out, 46, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_6_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_6_then_in, 47, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_6_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_6_then_out, 48, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_7_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_7_then_in, 49, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_7_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_7_then_out, 50, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_8_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_8_then_in, 51, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_8_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_8_then_out, 52, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_9_then INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_9_then_in, 53, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_9_then OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_9_then_out, 54, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* helper04_then INSTRUCT */ +WFR_PORT_STRUCT( helper04_then_in, 55, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar0) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar1) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar2) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar3) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar4) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar5) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar6) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar7) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar8) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar9) \ +) + +/* helper04_then OUTSTRUCT */ +WFR_PORT_STRUCT( helper04_then_out, 56, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* ParallelFor_1_elseBranch INSTRUCT */ +WFR_PORT_STRUCT( ParallelFor_1_elseBranch_in, 57, \ + WFR_PORT_MEMBER_IWIRBOOL(condDecisionPostProcessSingle) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRINT(innerLoopIterCount) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* ParallelFor_1_elseBranch OUTSTRUCT */ +WFR_PORT_STRUCT( ParallelFor_1_elseBranch_out, 58, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* ParallelFor_2_elseBranch INSTRUCT */ +WFR_PORT_STRUCT( ParallelFor_2_elseBranch_in, 59, \ + WFR_PORT_MEMBER_IWIRBOOL(condDecisionPostProcessSingle) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRINT(parentLoopCounter) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* ParallelFor_2_elseBranch OUTSTRUCT */ +WFR_PORT_STRUCT( ParallelFor_2_elseBranch_out, 60, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(outfiles, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* helper06_else INSTRUCT */ +WFR_PORT_STRUCT( helper06_else_in, 61, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PLMTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRINT(index1) \ + WFR_PORT_MEMBER_IWIRINT(index2) \ +) + +/* helper06_else OUTSTRUCT */ +WFR_PORT_STRUCT( helper06_else_out, 62, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar0) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar1) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar2) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar3) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar4) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar5) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar6) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar7) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar8) \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar9) \ +) + +/* linearModel_0_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_0_else_in, 63, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_0_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_0_else_out, 64, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_1_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_1_else_in, 65, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_1_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_1_else_out, 66, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_2_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_2_else_in, 67, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_2_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_2_else_out, 68, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_3_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_3_else_in, 69, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_3_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_3_else_out, 70, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_4_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_4_else_in, 71, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_4_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_4_else_out, 72, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_5_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_5_else_in, 73, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_5_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_5_else_out, 74, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_6_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_6_else_in, 75, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_6_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_6_else_out, 76, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_7_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_7_else_in, 77, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_7_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_7_else_out, 78, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_8_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_8_else_in, 79, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_8_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_8_else_out, 80, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* linearModel_9_else INSTRUCT */ +WFR_PORT_STRUCT( linearModel_9_else_in, 81, \ + WFR_PORT_MEMBER_IWIRFILE(PLMTar) \ +) + +/* linearModel_9_else OUTSTRUCT */ +WFR_PORT_STRUCT( linearModel_9_else_out, 82, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ + WFR_PORT_MEMBER_IWIRFILE(outfile) \ +) + +/* postProcessSingle_0_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_0_else_in, 83, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_0_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_0_else_out, 84, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_1_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_1_else_in, 85, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_1_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_1_else_out, 86, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_2_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_2_else_in, 87, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_2_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_2_else_out, 88, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_3_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_3_else_in, 89, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_3_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_3_else_out, 90, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_4_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_4_else_in, 91, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_4_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_4_else_out, 92, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_5_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_5_else_in, 93, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_5_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_5_else_out, 94, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_6_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_6_else_in, 95, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_6_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_6_else_out, 96, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_7_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_7_else_in, 97, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_7_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_7_else_out, 98, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_8_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_8_else_in, 99, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_8_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_8_else_out, 100, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* postProcessSingle_9_else INSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_9_else_in, 101, \ + WFR_PORT_MEMBER_IWIRFILE(LMTar) \ +) + +/* postProcessSingle_9_else OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessSingle_9_else_out, 102, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar) \ +) + +/* helper04_else INSTRUCT */ +WFR_PORT_STRUCT( helper04_else_in, 103, \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar0) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar1) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar2) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar3) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar4) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar5) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar6) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar7) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar8) \ + WFR_PORT_MEMBER_IWIRFILE(PPSTar9) \ +) + +/* helper04_else OUTSTRUCT */ +WFR_PORT_STRUCT( helper04_else_out, 104, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* DecisionNode_2 INSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_2_in, 105, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRBOOL(condDecisionPostProcessFinal) \ +) + +/* DecisionNode_2 OUTSTRUCT */ +WFR_PORT_STRUCT( DecisionNode_2_out, 106, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(LMtarsList, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* postProcessFinal INSTRUCT */ +WFR_PORT_STRUCT( postProcessFinal_in, 107, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(PPSlistTars, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* postProcessFinal OUTSTRUCT */ +WFR_PORT_STRUCT( postProcessFinal_out, 108, \ + WFR_PORT_MEMBER_IWIRFILE(finalTar) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* RAINCLOUD_TEST01_H */ diff --git a/src/05.ifoptimization01/CMakeLists.txt b/src/05.ifoptimization01/CMakeLists.txt new file mode 100644 index 0000000..f47f9dd --- /dev/null +++ b/src/05.ifoptimization01/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(ifoptimization-original C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin ifoptimization.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/05.ifoptimization01/ifoptimization.cpp b/src/05.ifoptimization01/ifoptimization.cpp new file mode 100644 index 0000000..27c8326 --- /dev/null +++ b/src/05.ifoptimization01/ifoptimization.cpp @@ -0,0 +1,324 @@ +#include "ifoptimization.h" + +#include +#include +#include + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_CHILD_OUTBUFFER_GET(a1out, for01_out, a1, 2, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(for01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, for01_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->iterCount)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(for01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, for01_out); + + WFR_CHILD_OUTBUFFER_GET(a1out, if02_out, a1, 6, WFR_SELF_GETHANDLEDITERATIONCOUNT()-1); + if (a1out != nullptr) { + if (WFR_SELF_GETITERATIONCOUNT() <= WFR_SELF_GETHANDLEDITERATIONCOUNT()) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + } + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(for01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for01_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_LOOPITERATION_HOOK(for01IterationFunc) { + WFR_LOOPITERATION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for01_in); + WFR_LOOPITERATION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(if01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, if01_in); + WFR_PARENT_INBUFFER_GET(a1in, for01_in, a1); + if (a1in != nullptr) { + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->loopCounter); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(if01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, if01_out); + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, task01_1_out, a1, 4, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + } else if (WFR_SELF_GETCONDBRANCHID() == 1) { + WFR_CHILD_OUTBUFFER_GET(a1out, task01_2_out, a1, 5, 1); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_BRANCHCONDITION_HOOK(if01BranchConditionFunc) { + WFR_BRANCHCONDITION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, if01_in); + if (sin != nullptr && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution && sin->loopCounter.isReady() ) { + if (sin->loopCounter.getValue() > 0) { + instance.setExecutionBranchID(0); + } else { + instance.setExecutionBranchID(1); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_BRANCHCONDITION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_1InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_1_in); + WFR_PARENT_INBUFFER_GET(a1in, if01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->loopCounter)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->loopCounter.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_1ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_1_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_1_out); + + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_2InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_2_in); + WFR_PARENT_INBUFFER_GET(a1in, if01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->loopCounter)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->loopCounter.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_2ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_2_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_2_out); + + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(if02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, if02_in); + WFR_PRED_OUTBUFFER_GET(a1in, if01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(if02OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, if02_out); + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, task01_3_out, a1, 7, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + } else if (WFR_SELF_GETCONDBRANCHID() == 1) { + WFR_CHILD_OUTBUFFER_GET(a1out, task01_4_out, a1, 8, 1); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_BRANCHCONDITION_HOOK(if02BranchConditionFunc) { + WFR_BRANCHCONDITION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, if02_in); + if (sin != nullptr && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution && sin->loopCounter.isReady() ) { + if (sin->loopCounter.getValue() > 0) { + instance.setExecutionBranchID(0); + } else { + instance.setExecutionBranchID(1); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_BRANCHCONDITION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_3InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_3_in); + WFR_PARENT_INBUFFER_GET(a1in, if02_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->loopCounter)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->loopCounter.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_3ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_3_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_3_out); + + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_4InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_4_in); + WFR_PARENT_INBUFFER_GET(a1in, if02_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->loopCounter)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->loopCounter.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_4ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_4_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_4_out); + + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_1Implementations, "task01_1Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_1ExecFunc_0, "task01_1ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_2Implementations, "task01_2Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_2ExecFunc_0, "task01_2ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_3Implementations, "task01_3Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_3ExecFunc_0, "task01_3ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_4Implementations, "task01_4Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_4ExecFunc_0, "task01_4ExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "generatedWorkflow", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::forLoop(2, "for01", 1, 0, {}, {}, for01InputFunc, for01OutputFunc, for01CounterFunc, for01IterationFunc, false), \ + wfr::wfs::ActivityTemplate::conditional(3, "if01", 2, 0, {6}, {}, if01InputFunc, if01OutputFunc, if01BranchConditionFunc), \ + wfr::wfs::ActivityTemplate::atomic(4, "task01_1", 3, 0, {}, {}, task01_1InputFunc, task01_1Implementations), \ + wfr::wfs::ActivityTemplate::atomic(5, "task01_2", 3, 1, {}, {}, task01_2InputFunc, task01_2Implementations), \ + wfr::wfs::ActivityTemplate::conditional(6, "if02", 2, 0, {}, {3}, if02InputFunc, if02OutputFunc, if02BranchConditionFunc), \ + wfr::wfs::ActivityTemplate::atomic(7, "task01_3", 6, 0, {}, {}, task01_3InputFunc, task01_3Implementations), \ + wfr::wfs::ActivityTemplate::atomic(8, "task01_4", 6, 1, {}, {}, task01_4InputFunc, task01_4Implementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + long iterCount = 8; + bool isHelp = false; + boost::program_options::options_description opts("Raincloud Options"); + opts.add_options() + ("help", "Print help message.") + ("iterCount", boost::program_options::value(), "NGroup parameter."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("iterCount")) { + iterCount = vm["iterCount"].as(); + } + std::cerr << "iterCount = " << iterCount << std::endl; + } + wfInput.iterCount.setValue(iterCount); + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} diff --git a/src/05.ifoptimization01/ifoptimization.h b/src/05.ifoptimization01/ifoptimization.h new file mode 100644 index 0000000..36475e0 --- /dev/null +++ b/src/05.ifoptimization01/ifoptimization.h @@ -0,0 +1,91 @@ +#ifndef RAINCLOUD_TEST01_H +#define RAINCLOUD_TEST01_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRINT(iterCount) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* for01 INSTRUCT */ +WFR_PORT_STRUCT( for01_in, 3, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* for01 OUTSTRUCT */ +WFR_PORT_STRUCT( for01_out, 4, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* if01 INSTRUCT */ +WFR_PORT_STRUCT( if01_in, 5, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* if01 OUTSTRUCT */ +WFR_PORT_STRUCT( if01_out, 6, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task01_1 INSTRUCT */ +WFR_PORT_STRUCT( task01_1_in, 7, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_1 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_1_out, 8, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task01_2 INSTRUCT */ +WFR_PORT_STRUCT( task01_2_in, 9, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_2 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_2_out, 10, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* if02 INSTRUCT */ +WFR_PORT_STRUCT( if02_in, 11, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* if02 OUTSTRUCT */ +WFR_PORT_STRUCT( if02_out, 12, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task01_3 INSTRUCT */ +WFR_PORT_STRUCT( task01_3_in, 13, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_3 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_3_out, 14, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task01_4 INSTRUCT */ +WFR_PORT_STRUCT( task01_4_in, 15, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_4 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_4_out, 16, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* RAINCLOUD_TEST01_H */ diff --git a/src/06.ifoptimization02/CMakeLists.txt b/src/06.ifoptimization02/CMakeLists.txt new file mode 100644 index 0000000..b5329b9 --- /dev/null +++ b/src/06.ifoptimization02/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(ifoptimization-transformed C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin ifoptimization.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/06.ifoptimization02/ifoptimization.cpp b/src/06.ifoptimization02/ifoptimization.cpp new file mode 100644 index 0000000..1dc0cf9 --- /dev/null +++ b/src/06.ifoptimization02/ifoptimization.cpp @@ -0,0 +1,290 @@ +#include "ifoptimization.h" + +#include +#include +#include + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_CHILD_OUTBUFFER_GET(a1out, for01_out, a1, 2, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(for01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, for01_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->iterCount)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(for01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, for01_out); + + WFR_CHILD_OUTBUFFER_GET(a1out, if01_out, a1, 3, WFR_SELF_GETHANDLEDITERATIONCOUNT()-1); + if (a1out != nullptr) { + if (WFR_SELF_GETITERATIONCOUNT() <= WFR_SELF_GETHANDLEDITERATIONCOUNT()) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + } + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(for01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for01_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_LOOPITERATION_HOOK(for01IterationFunc) { + WFR_LOOPITERATION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for01_in); + WFR_LOOPITERATION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(if01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, if01_in); + WFR_PARENT_INBUFFER_GET(a1in, for01_in, a1); + if (a1in != nullptr) { + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->loopCounter); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(if01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, if01_out); + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, task01_1_out, a1, 4, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + } else if (WFR_SELF_GETCONDBRANCHID() == 1) { + WFR_CHILD_OUTBUFFER_GET(a1out, task01_2_out, a1, 6, 1); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + } + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, task01_3_out, a1, 5, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output2, a1out->output)); + } + } else if (WFR_SELF_GETCONDBRANCHID() == 1) { + WFR_CHILD_OUTBUFFER_GET(a1out, task01_4_out, a1, 7, 1); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output2, a1out->output)); + } + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady() && sout->output2.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_BRANCHCONDITION_HOOK(if01BranchConditionFunc) { + WFR_BRANCHCONDITION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, if01_in); + if (sin != nullptr && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution && sin->loopCounter.isReady() ) { + if (sin->loopCounter.getValue() > 0) { + instance.setExecutionBranchID(0); + } else { + instance.setExecutionBranchID(1); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_BRANCHCONDITION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_1InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_1_in); + WFR_PARENT_INBUFFER_GET(a1in, if01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->loopCounter)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->loopCounter.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_1ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_1_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_1_out); + + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_3InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_3_in); + WFR_PARENT_INBUFFER_GET(a1in, if01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->loopCounter)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->loopCounter.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_3ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_3_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_3_out); + + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_2InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_2_in); + WFR_PARENT_INBUFFER_GET(a1in, if01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->loopCounter)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->loopCounter.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_2ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_2_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_2_out); + + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_4InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_4_in); + WFR_PARENT_INBUFFER_GET(a1in, if01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->loopCounter)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->loopCounter.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_4ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_4_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_4_out); + + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_1Implementations, "task01_1Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_1ExecFunc_0, "task01_1ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_3Implementations, "task01_3Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_3ExecFunc_0, "task01_3ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_2Implementations, "task01_2Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_2ExecFunc_0, "task01_2ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_4Implementations, "task01_4Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_4ExecFunc_0, "task01_4ExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "generatedWorkflow", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::forLoop(2, "for01", 1, 0, {}, {}, for01InputFunc, for01OutputFunc, for01CounterFunc, for01IterationFunc, false), \ + wfr::wfs::ActivityTemplate::conditional(3, "if01", 2, 0, {}, {}, if01InputFunc, if01OutputFunc, if01BranchConditionFunc), \ + wfr::wfs::ActivityTemplate::atomic(4, "task01_1", 3, 0, {}, {}, task01_1InputFunc, task01_1Implementations), \ + wfr::wfs::ActivityTemplate::atomic(5, "task01_3", 3, 0, {}, {}, task01_3InputFunc, task01_3Implementations), \ + wfr::wfs::ActivityTemplate::atomic(6, "task01_2", 3, 1, {}, {}, task01_2InputFunc, task01_2Implementations), \ + wfr::wfs::ActivityTemplate::atomic(7, "task01_4", 3, 1, {}, {}, task01_4InputFunc, task01_4Implementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + long iterCount = 8; + bool isHelp = false; + boost::program_options::options_description opts("Raincloud Options"); + opts.add_options() + ("help", "Print help message.") + ("iterCount", boost::program_options::value(), "NGroup parameter."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("iterCount")) { + iterCount = vm["iterCount"].as(); + } + std::cerr << "iterCount = " << iterCount << std::endl; + } + wfInput.iterCount.setValue(iterCount); + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} + diff --git a/src/06.ifoptimization02/ifoptimization.h b/src/06.ifoptimization02/ifoptimization.h new file mode 100644 index 0000000..a3b4936 --- /dev/null +++ b/src/06.ifoptimization02/ifoptimization.h @@ -0,0 +1,82 @@ +#ifndef RAINCLOUD_TEST01_H +#define RAINCLOUD_TEST01_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRINT(iterCount) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* for01 INSTRUCT */ +WFR_PORT_STRUCT( for01_in, 3, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* for01 OUTSTRUCT */ +WFR_PORT_STRUCT( for01_out, 4, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* if01 INSTRUCT */ +WFR_PORT_STRUCT( if01_in, 5, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* if01 OUTSTRUCT */ +WFR_PORT_STRUCT( if01_out, 6, \ + WFR_PORT_MEMBER_IWIRINT(output) \ + WFR_PORT_MEMBER_IWIRINT(output2) \ +) + +/* task01_1 INSTRUCT */ +WFR_PORT_STRUCT( task01_1_in, 7, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_1 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_1_out, 8, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task01_3 INSTRUCT */ +WFR_PORT_STRUCT( task01_3_in, 9, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_3 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_3_out, 10, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task01_2 INSTRUCT */ +WFR_PORT_STRUCT( task01_2_in, 11, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_2 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_2_out, 12, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task01_4 INSTRUCT */ +WFR_PORT_STRUCT( task01_4_in, 13, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_4 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_4_out, 14, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* RAINCLOUD_TEST01_H */ diff --git a/src/07.softwarepipelining01/CMakeLists.txt b/src/07.softwarepipelining01/CMakeLists.txt new file mode 100644 index 0000000..9547048 --- /dev/null +++ b/src/07.softwarepipelining01/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(pipelining-original C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin pipelining.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/07.softwarepipelining01/pipelining.cpp b/src/07.softwarepipelining01/pipelining.cpp new file mode 100644 index 0000000..03a9fd9 --- /dev/null +++ b/src/07.softwarepipelining01/pipelining.cpp @@ -0,0 +1,208 @@ +#include +#include +#include +#include +#include +#include "pipelining.h" + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_CHILD_OUTBUFFER_GET(a1out, for01_out, a1, 2, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(for01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, for01_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->iterCount)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(for01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, for01_out); + + WFR_CHILD_OUTBUFFER_GET(a1out, task01_3_out, a1, 5, WFR_SELF_GETHANDLEDITERATIONCOUNT()-1); + if (a1out != nullptr) { + if (WFR_SELF_GETITERATIONCOUNT() <= WFR_SELF_GETHANDLEDITERATIONCOUNT()) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + } + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(for01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for01_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_LOOPITERATION_HOOK(for01IterationFunc) { + WFR_LOOPITERATION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for01_in); + WFR_LOOPITERATION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_1InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_1_in); + WFR_PARENT_INBUFFER_GET(a1in, for01_in, a1); + if (a1in != nullptr) { + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->loopCounter); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION2(sin->loopCounter.isReady(), WFR_PARENT_ISPREVITERFINISHED()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_1ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_1_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_1_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_2InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_2_in); + WFR_PRED_OUTBUFFER_GET(a1in, task01_1_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION2(sin->loopCounter.isReady(), WFR_PARENT_ISPREVITERFINISHED()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_2ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_2_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_2_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_3InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_3_in); + WFR_PRED_OUTBUFFER_GET(a1in, task01_2_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION2(sin->loopCounter.isReady(), WFR_PARENT_ISPREVITERFINISHED()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_3ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_3_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_3_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_1Implementations, "task01_1Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_1ExecFunc_0, "task01_1ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_2Implementations, "task01_2Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_2ExecFunc_0, "task01_2ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_3Implementations, "task01_3Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_3ExecFunc_0, "task01_3ExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "generatedWorkflow", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::forLoop(2, "for01", 1, 0, {}, {}, for01InputFunc, for01OutputFunc, for01CounterFunc, for01IterationFunc, false), \ + wfr::wfs::ActivityTemplate::atomic(3, "task01_1", 2, 0, {4}, {}, task01_1InputFunc, task01_1Implementations), \ + wfr::wfs::ActivityTemplate::atomic(4, "task01_2", 2, 0, {5}, {3}, task01_2InputFunc, task01_2Implementations), \ + wfr::wfs::ActivityTemplate::atomic(5, "task01_3", 2, 0, {}, {4}, task01_3InputFunc, task01_3Implementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + long iterCount = 8; + bool isHelp = false; + boost::program_options::options_description opts("Raincloud Options"); + opts.add_options() + ("help", "Print help message.") + ("iterCount", boost::program_options::value(), "NGroup parameter."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("iterCount")) { + iterCount = vm["iterCount"].as(); + } + std::cerr << "iterCount = " << iterCount << std::endl; + } + wfInput.iterCount.setValue(iterCount); + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} diff --git a/src/07.softwarepipelining01/pipelining.h b/src/07.softwarepipelining01/pipelining.h new file mode 100644 index 0000000..a9f45b1 --- /dev/null +++ b/src/07.softwarepipelining01/pipelining.h @@ -0,0 +1,61 @@ +#ifndef RAINCLOUD_TEST01_H +#define RAINCLOUD_TEST01_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRINT(iterCount) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* for01 INSTRUCT */ +WFR_PORT_STRUCT( for01_in, 3, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* for01 OUTSTRUCT */ +WFR_PORT_STRUCT( for01_out, 4, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task01_1 INSTRUCT */ +WFR_PORT_STRUCT( task01_1_in, 5, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_1 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_1_out, 6, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task01_2 INSTRUCT */ +WFR_PORT_STRUCT( task01_2_in, 7, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_2 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_2_out, 8, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task01_3 INSTRUCT */ +WFR_PORT_STRUCT( task01_3_in, 9, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_3 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_3_out, 10, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* RAINCLOUD_TEST01_H */ diff --git a/src/08.softwarepipelining02/CMakeLists.txt b/src/08.softwarepipelining02/CMakeLists.txt new file mode 100644 index 0000000..94694ea --- /dev/null +++ b/src/08.softwarepipelining02/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(pipelining-transformed C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin pipelining.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/08.softwarepipelining02/pipelining.cpp b/src/08.softwarepipelining02/pipelining.cpp new file mode 100644 index 0000000..cbe5574 --- /dev/null +++ b/src/08.softwarepipelining02/pipelining.cpp @@ -0,0 +1,319 @@ +#include "pipelining.h" + +#include +#include +#include +#include +#include + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_CHILD_OUTBUFFER_GET(a1out, for01_out, a1, 5, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output1, a1out->output1)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output2, a1out->output2)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output3, a1out->output3)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output1.isReady() && sout->output2.isReady() && sout->output3.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_1_iInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_1_i_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->iterCount)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->loopCounter.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_1_iExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_1_i_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_1_i_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_1_i1InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_1_i1_in); + WFR_PRED_OUTBUFFER_GET(a1in, task01_1_i_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->loopCounter.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_1_i1ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_1_i1_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_1_i1_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_2_iInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_2_i_in); + WFR_PRED_OUTBUFFER_GET(a1in, task01_1_i_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->loopCounter.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_2_iExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_2_i_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_2_i_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(for01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, for01_in); + WFR_PRED_OUTBUFFER_GET(a1in, task01_1_i1_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input1, a1in->output)); + } + WFR_PARENT_INBUFFER_GET(a2in, toplevel_in, a2); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a2in->iterCount)); + } + WFR_PRED_OUTBUFFER_GET(a3in, task01_2_i_out, a3, 1); + if (a3in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input2, a3in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(for01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, for01_out); + + WFR_CHILD_OUTBUFFER_GET(a1out, task01_1_i2_out, a1, 6, WFR_SELF_GETHANDLEDITERATIONCOUNT()-1); + if (a1out != nullptr) { + if (WFR_SELF_GETITERATIONCOUNT() <= WFR_SELF_GETHANDLEDITERATIONCOUNT()) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output1, a1out->output)); + } + } + WFR_CHILD_OUTBUFFER_GET(a2out, task01_2_i1_out, a2, 7, WFR_SELF_GETHANDLEDITERATIONCOUNT()-1); + if (a2out != nullptr) { + if (WFR_SELF_GETITERATIONCOUNT() <= WFR_SELF_GETHANDLEDITERATIONCOUNT()) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output2, a2out->output)); + } + } + WFR_CHILD_OUTBUFFER_GET(a3out, task01_3_i_out, a3, 8, WFR_SELF_GETHANDLEDITERATIONCOUNT()-1); + if (a3out != nullptr) { + if (WFR_SELF_GETITERATIONCOUNT() <= WFR_SELF_GETHANDLEDITERATIONCOUNT()) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output3, a3out->output)); + } + } + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output1.isReady() && sout->output2.isReady() && sout->output3.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(for01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for01_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_LOOPITERATION_HOOK(for01IterationFunc) { + WFR_LOOPITERATION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for01_in); + WFR_LOOPITERATION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_1_i2InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_1_i2_in); + WFR_PARENT_INBUFFER_GET(a1in, for01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->input1)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION2(sin->loopCounter.isReady(), WFR_PARENT_ISPREVITERFINISHED()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_1_i2ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_1_i2_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_1_i2_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_2_i1InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_2_i1_in); + WFR_PARENT_INBUFFER_GET(a1in, for01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->input1)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION2(sin->loopCounter.isReady(), WFR_PARENT_ISPREVITERFINISHED()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_2_i1ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_2_i1_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_2_i1_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01_3_iInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_3_i_in); + WFR_PARENT_INBUFFER_GET(a1in, for01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter, a1in->input2)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION2(sin->loopCounter.isReady(), WFR_PARENT_ISPREVITERFINISHED()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01_3_iExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_3_i_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_3_i_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_1_iImplementations, "task01_1_iImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_1_iExecFunc_0, "task01_1_iExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_1_i1Implementations, "task01_1_i1Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_1_i1ExecFunc_0, "task01_1_i1ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_2_iImplementations, "task01_2_iImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_2_iExecFunc_0, "task01_2_iExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_1_i2Implementations, "task01_1_i2Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_1_i2ExecFunc_0, "task01_1_i2ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_2_i1Implementations, "task01_2_i1Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_2_i1ExecFunc_0, "task01_2_i1ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task01_3_iImplementations, "task01_3_iImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01_3_iExecFunc_0, "task01_3_iExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "generatedWorkflow", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::atomic(2, "task01_1_i", 1, 0, {3, 4}, {}, task01_1_iInputFunc, task01_1_iImplementations), \ + wfr::wfs::ActivityTemplate::atomic(3, "task01_1_i1", 1, 0, {5}, {2}, task01_1_i1InputFunc, task01_1_i1Implementations), \ + wfr::wfs::ActivityTemplate::atomic(4, "task01_2_i", 1, 0, {5}, {2}, task01_2_iInputFunc, task01_2_iImplementations), \ + wfr::wfs::ActivityTemplate::forLoop(5, "for01", 1, 0, {}, {3, 4}, for01InputFunc, for01OutputFunc, for01CounterFunc, for01IterationFunc, false), \ + wfr::wfs::ActivityTemplate::atomic(6, "task01_1_i2", 5, 0, {}, {}, task01_1_i2InputFunc, task01_1_i2Implementations), \ + wfr::wfs::ActivityTemplate::atomic(7, "task01_2_i1", 5, 0, {}, {}, task01_2_i1InputFunc, task01_2_i1Implementations), \ + wfr::wfs::ActivityTemplate::atomic(8, "task01_3_i", 5, 0, {}, {}, task01_3_iInputFunc, task01_3_iImplementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + long iterCount = 8; + bool isHelp = false; + boost::program_options::options_description opts("Raincloud Options"); + opts.add_options() + ("help", "Print help message.") + ("iterCount", boost::program_options::value(), "NGroup parameter."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("iterCount")) { + iterCount = vm["iterCount"].as(); + } + std::cerr << "iterCount = " << iterCount << std::endl; + } + wfInput.iterCount.setValue(iterCount); + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} diff --git a/src/08.softwarepipelining02/pipelining.h b/src/08.softwarepipelining02/pipelining.h new file mode 100644 index 0000000..42e3dce --- /dev/null +++ b/src/08.softwarepipelining02/pipelining.h @@ -0,0 +1,97 @@ +#ifndef RAINCLOUD_TEST01_H +#define RAINCLOUD_TEST01_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRINT(iterCount) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRINT(output1) \ + WFR_PORT_MEMBER_IWIRINT(output2) \ + WFR_PORT_MEMBER_IWIRINT(output3) \ +) + +/* task01_1_i INSTRUCT */ +WFR_PORT_STRUCT( task01_1_i_in, 3, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_1_i OUTSTRUCT */ +WFR_PORT_STRUCT( task01_1_i_out, 4, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task01_1_i1 INSTRUCT */ +WFR_PORT_STRUCT( task01_1_i1_in, 5, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_1_i1 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_1_i1_out, 6, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task01_2_i INSTRUCT */ +WFR_PORT_STRUCT( task01_2_i_in, 7, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_2_i OUTSTRUCT */ +WFR_PORT_STRUCT( task01_2_i_out, 8, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* for01 INSTRUCT */ +WFR_PORT_STRUCT( for01_in, 9, \ + WFR_PORT_MEMBER_IWIRINT(input1) \ + WFR_PORT_MEMBER_IWIRINT(input2) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* for01 OUTSTRUCT */ +WFR_PORT_STRUCT( for01_out, 10, \ + WFR_PORT_MEMBER_IWIRINT(output1) \ + WFR_PORT_MEMBER_IWIRINT(output2) \ + WFR_PORT_MEMBER_IWIRINT(output3) \ +) + +/* task01_1_i2 INSTRUCT */ +WFR_PORT_STRUCT( task01_1_i2_in, 11, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_1_i2 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_1_i2_out, 12, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task01_2_i1 INSTRUCT */ +WFR_PORT_STRUCT( task01_2_i1_in, 13, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_2_i1 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_2_i1_out, 14, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task01_3_i INSTRUCT */ +WFR_PORT_STRUCT( task01_3_i_in, 15, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01_3_i OUTSTRUCT */ +WFR_PORT_STRUCT( task01_3_i_out, 16, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* RAINCLOUD_TEST01_H */ diff --git a/src/09.reduction01/CMakeLists.txt b/src/09.reduction01/CMakeLists.txt new file mode 100644 index 0000000..6067b38 --- /dev/null +++ b/src/09.reduction01/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(reduction-original C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin reduction.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/09.reduction01/reduction.cpp b/src/09.reduction01/reduction.cpp new file mode 100644 index 0000000..5f00233 --- /dev/null +++ b/src/09.reduction01/reduction.cpp @@ -0,0 +1,176 @@ +#include "reduction.h" + +#include +#include +#include +#include +#include + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_CHILD_OUTBUFFER_GET(a1out, reduce01_out, a1, 4, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(for01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, for01_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->iterCount)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(for01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, for01_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, task01_out, output, 3); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(for01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for01_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_in); + WFR_PARENT_INBUFFER_GET(a1in, for01_in, a1); + if (a1in != nullptr) { + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->loopCounter); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->loopCounter.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_out); + + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(reduce01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, reduce01_in); + WFR_PORT_INIT_COLLECTION(sin->input); + WFR_PRED_OUTBUFFER_GET(a1in, for01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(reduce01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, reduce01_in); + WFR_SELF_OUTBUFFER_INIT(sout, reduce01_out); + + long r = 0; + for (auto& d : sin->input.getValue()) { + r += d.getValue(); + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + sout->output.setValue(r); + + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( task01Implementations, "task01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01ExecFunc_0, "task01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( reduce01Implementations, "reduce01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(reduce01ExecFunc_0, "reduce01ExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "generatedWorkflow", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::forLoop(2, "for01", 1, 0, {4}, {}, for01InputFunc, for01OutputFunc, for01CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(3, "task01", 2, 0, {}, {}, task01InputFunc, task01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(4, "reduce01", 1, 0, {}, {2}, reduce01InputFunc, reduce01Implementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + long iterCount = 8; + bool isHelp = false; + boost::program_options::options_description opts("Raincloud Options"); + opts.add_options() + ("help", "Print help message.") + ("iterCount", boost::program_options::value(), "NGroup parameter."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("iterCount")) { + iterCount = vm["iterCount"].as(); + } + std::cerr << "iterCount = " << iterCount << std::endl; + } + wfInput.iterCount.setValue(iterCount); + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} + diff --git a/src/09.reduction01/reduction.h b/src/09.reduction01/reduction.h new file mode 100644 index 0000000..87c3845 --- /dev/null +++ b/src/09.reduction01/reduction.h @@ -0,0 +1,51 @@ +#ifndef RAINCLOUD_TEST01_H +#define RAINCLOUD_TEST01_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRINT(iterCount) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* for01 INSTRUCT */ +WFR_PORT_STRUCT( for01_in, 3, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* for01 OUTSTRUCT */ +WFR_PORT_STRUCT( for01_out, 4, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_int, 1) \ +) + +/* task01 INSTRUCT */ +WFR_PORT_STRUCT( task01_in, 5, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_out, 6, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* reduce01 INSTRUCT */ +WFR_PORT_STRUCT( reduce01_in, 7, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input, wfr::lwd::_lwd_iwir_basetype_int, 1) \ +) + +/* reduce01 OUTSTRUCT */ +WFR_PORT_STRUCT( reduce01_out, 8, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* RAINCLOUD_TEST01_H */ diff --git a/src/10.reduction02/CMakeLists.txt b/src/10.reduction02/CMakeLists.txt new file mode 100644 index 0000000..5d86cd3 --- /dev/null +++ b/src/10.reduction02/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(reduction-transformed C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin reduction.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/10.reduction02/reduction.cpp b/src/10.reduction02/reduction.cpp new file mode 100644 index 0000000..bca9d2b --- /dev/null +++ b/src/10.reduction02/reduction.cpp @@ -0,0 +1,249 @@ +#include "reduction.h" + +#include +#include +#include +#include +#include + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_CHILD_OUTBUFFER_GET(a1out, reduce02_out, a1, 6, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(for00InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, for00_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->iterCount1)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->iterCount2, a1in->iterCount2)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(for00OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, for00_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, reduce01_out, output, 5); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(for00CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for00_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(for01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, for01_in); + WFR_PARENT_INBUFFER_GET(a1in, for00_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->iterCount2)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(for01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, for01_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, task01_out, output, 4); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(for01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for01_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_in); + WFR_PARENT_INBUFFER_GET(a1in, for01_in, a1); + if (a1in != nullptr) { + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->loopCounter); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->loopCounter.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_out); + + sout->output.setValue(sin->loopCounter.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(reduce01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, reduce01_in); + WFR_PORT_INIT_COLLECTION(sin->input); + WFR_PRED_OUTBUFFER_GET(a1in, for01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(reduce01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, reduce01_in); + WFR_SELF_OUTBUFFER_INIT(sout, reduce01_out); + + long r = 0; + for (auto& d : sin->input.getValue()) { + r += d.getValue(); + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + sout->output.setValue(r); + + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(reduce02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, reduce02_in); + WFR_PORT_INIT_COLLECTION(sin->input); + WFR_PRED_OUTBUFFER_GET(a1in, for00_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(reduce02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, reduce02_in); + WFR_SELF_OUTBUFFER_INIT(sout, reduce02_out); + + long r = 0; + for (auto& d : sin->input.getValue()) { + r += d.getValue(); + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + sout->output.setValue(r); + + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( task01Implementations, "task01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01ExecFunc_0, "task01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( reduce01Implementations, "reduce01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(reduce01ExecFunc_0, "reduce01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( reduce02Implementations, "reduce02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(reduce02ExecFunc_0, "reduce02ExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "generatedWorkflow", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::forLoop(2, "for00", 1, 0, {6}, {}, for00InputFunc, for00OutputFunc, for00CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::forLoop(3, "for01", 2, 0, {5}, {}, for01InputFunc, for01OutputFunc, for01CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(4, "task01", 3, 0, {}, {}, task01InputFunc, task01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(5, "reduce01", 2, 0, {}, {3}, reduce01InputFunc, reduce01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(6, "reduce02", 1, 0, {}, {2}, reduce02InputFunc, reduce02Implementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + long iterCount = 8; + bool isHelp = false; + boost::program_options::options_description opts("Raincloud Options"); + opts.add_options() + ("help", "Print help message.") + ("iterCount", boost::program_options::value(), "NGroup parameter."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("iterCount")) { + iterCount = vm["iterCount"].as(); + } + std::cerr << "iterCount = " << iterCount << std::endl; + } + wfInput.iterCount1.setValue(10); + wfInput.iterCount2.setValue(iterCount/10); + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} diff --git a/src/10.reduction02/reduction.h b/src/10.reduction02/reduction.h new file mode 100644 index 0000000..5a673d3 --- /dev/null +++ b/src/10.reduction02/reduction.h @@ -0,0 +1,73 @@ +#ifndef RAINCLOUD_TEST01_H +#define RAINCLOUD_TEST01_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRINT(iterCount1) \ + WFR_PORT_MEMBER_IWIRINT(iterCount2) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* for00 INSTRUCT */ +WFR_PORT_STRUCT( for00_in, 3, \ + WFR_PORT_MEMBER_IWIRINT(iterCount2) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* for00 OUTSTRUCT */ +WFR_PORT_STRUCT( for00_out, 4, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_int, 1) \ +) + +/* for01 INSTRUCT */ +WFR_PORT_STRUCT( for01_in, 5, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* for01 OUTSTRUCT */ +WFR_PORT_STRUCT( for01_out, 6, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_int, 1) \ +) + +/* task01 INSTRUCT */ +WFR_PORT_STRUCT( task01_in, 7, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* task01 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_out, 8, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* reduce01 INSTRUCT */ +WFR_PORT_STRUCT( reduce01_in, 9, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input, wfr::lwd::_lwd_iwir_basetype_int, 1) \ +) + +/* reduce01 OUTSTRUCT */ +WFR_PORT_STRUCT( reduce01_out, 10, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* reduce02 INSTRUCT */ +WFR_PORT_STRUCT( reduce02_in, 11, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input, wfr::lwd::_lwd_iwir_basetype_int, 1) \ +) + +/* reduce02 OUTSTRUCT */ +WFR_PORT_STRUCT( reduce02_out, 12, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* RAINCLOUD_TEST01_H */ diff --git a/src/11.elimination01/CMakeLists.txt b/src/11.elimination01/CMakeLists.txt new file mode 100644 index 0000000..f94b9f7 --- /dev/null +++ b/src/11.elimination01/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(elimination-original C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin elimination.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/11.elimination01/elimination.cpp b/src/11.elimination01/elimination.cpp new file mode 100644 index 0000000..c0d482c --- /dev/null +++ b/src/11.elimination01/elimination.cpp @@ -0,0 +1,264 @@ +#include "elimination.h" + +#include +#include +#include +#include +#include + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_PORT_INIT_COLLECTION(sout->output1); + WFR_PORT_INIT_COLLECTION(sout->output2); + WFR_CHILD_OUTBUFFER_GET(a1out, for01_out, a1, 2, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output1, a1out->output1)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output2, a1out->output2)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output1.isReady() && sout->output2.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(for01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, for01_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->iterCount)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(for01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, for01_out); + WFR_PORT_INIT_COLLECTION(sout->output1); + WFR_PORT_INIT_COLLECTION(sout->output2); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output1, task03_out, output, 5); + WFR_LOOP_FINALIZE_COLLECTION(sout, output1); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output2, task04_out, output, 7); + WFR_LOOP_FINALIZE_COLLECTION(sout, output2); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output1.isReady() && sout->output2.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(for01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for01_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_in); + WFR_PARENT_INBUFFER_GET(a1in, for01_in, a1); + if (a1in != nullptr) { + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->input); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task02_1InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task02_1_in); + WFR_PRED_OUTBUFFER_GET(a1in, task01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task02_1ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task02_1_in); + WFR_SELF_OUTBUFFER_INIT(sout, task02_1_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task03_in); + WFR_PRED_OUTBUFFER_GET(a1in, task02_1_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task03_in); + WFR_SELF_OUTBUFFER_INIT(sout, task03_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task02_2InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task02_2_in); + WFR_PRED_OUTBUFFER_GET(a1in, task01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task02_2ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task02_2_in); + WFR_SELF_OUTBUFFER_INIT(sout, task02_2_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task04_in); + WFR_PRED_OUTBUFFER_GET(a1in, task02_2_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task04ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task04_in); + WFR_SELF_OUTBUFFER_INIT(sout, task04_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( task01Implementations, "task01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01ExecFunc_0, "task01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task02_1Implementations, "task02_1Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task02_1ExecFunc_0, "task02_1ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task03Implementations, "task03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task03ExecFunc_0, "task03ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task02_2Implementations, "task02_2Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task02_2ExecFunc_0, "task02_2ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task04Implementations, "task04Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task04ExecFunc_0, "task04ExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "generatedWorkflow", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::forLoop(2, "for01", 1, 0, {}, {}, for01InputFunc, for01OutputFunc, for01CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(3, "task01", 2, 0, {6, 4}, {}, task01InputFunc, task01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(4, "task02_1", 2, 0, {5}, {3}, task02_1InputFunc, task02_1Implementations), \ + wfr::wfs::ActivityTemplate::atomic(5, "task03", 2, 0, {}, {4}, task03InputFunc, task03Implementations), \ + wfr::wfs::ActivityTemplate::atomic(6, "task02_2", 2, 0, {7}, {3}, task02_2InputFunc, task02_2Implementations), \ + wfr::wfs::ActivityTemplate::atomic(7, "task04", 2, 0, {}, {6}, task04InputFunc, task04Implementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + long iterCount = 8; + bool isHelp = false; + boost::program_options::options_description opts("Raincloud Options"); + opts.add_options() + ("help", "Print help message.") + ("iterCount", boost::program_options::value(), "NGroup parameter."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("iterCount")) { + iterCount = vm["iterCount"].as(); + } + std::cerr << "iterCount = " << iterCount << std::endl; + } + wfInput.iterCount.setValue(iterCount); + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} diff --git a/src/11.elimination01/elimination.h b/src/11.elimination01/elimination.h new file mode 100644 index 0000000..aec5803 --- /dev/null +++ b/src/11.elimination01/elimination.h @@ -0,0 +1,83 @@ +#ifndef RAINCLOUD_TEST01_H +#define RAINCLOUD_TEST01_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRINT(iterCount) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output1, wfr::lwd::_lwd_iwir_basetype_int, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output2, wfr::lwd::_lwd_iwir_basetype_int, 1) \ +) + +/* for01 INSTRUCT */ +WFR_PORT_STRUCT( for01_in, 3, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* for01 OUTSTRUCT */ +WFR_PORT_STRUCT( for01_out, 4, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output1, wfr::lwd::_lwd_iwir_basetype_int, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output2, wfr::lwd::_lwd_iwir_basetype_int, 1) \ +) + +/* task01 INSTRUCT */ +WFR_PORT_STRUCT( task01_in, 5, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task01 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_out, 6, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task02_1 INSTRUCT */ +WFR_PORT_STRUCT( task02_1_in, 7, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task02_1 OUTSTRUCT */ +WFR_PORT_STRUCT( task02_1_out, 8, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task03 INSTRUCT */ +WFR_PORT_STRUCT( task03_in, 9, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task03 OUTSTRUCT */ +WFR_PORT_STRUCT( task03_out, 10, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task02_2 INSTRUCT */ +WFR_PORT_STRUCT( task02_2_in, 11, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task02_2 OUTSTRUCT */ +WFR_PORT_STRUCT( task02_2_out, 12, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task04 INSTRUCT */ +WFR_PORT_STRUCT( task04_in, 13, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task04 OUTSTRUCT */ +WFR_PORT_STRUCT( task04_out, 14, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* RAINCLOUD_TEST01_H */ diff --git a/src/12.elimination02/CMakeLists.txt b/src/12.elimination02/CMakeLists.txt new file mode 100644 index 0000000..7d6010f --- /dev/null +++ b/src/12.elimination02/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(elimination-transformed C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin elimination.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/12.elimination02/elimination.cpp b/src/12.elimination02/elimination.cpp new file mode 100644 index 0000000..1b76d5d --- /dev/null +++ b/src/12.elimination02/elimination.cpp @@ -0,0 +1,233 @@ +#include "elimination.h" + +#include +#include +#include +#include +#include + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_PORT_INIT_COLLECTION(sout->output1); + WFR_PORT_INIT_COLLECTION(sout->output2); + WFR_CHILD_OUTBUFFER_GET(a1out, for01_out, a1, 2, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output1, a1out->output1)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output2, a1out->output2)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output1.isReady() && sout->output2.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(for01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, for01_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->iterCount)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(for01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, for01_out); + WFR_PORT_INIT_COLLECTION(sout->output1); + WFR_PORT_INIT_COLLECTION(sout->output2); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output2, task04_out, output, 6); + WFR_LOOP_FINALIZE_COLLECTION(sout, output2); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output1, task03_out, output, 5); + WFR_LOOP_FINALIZE_COLLECTION(sout, output1); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output1.isReady() && sout->output2.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(for01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for01_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_in); + WFR_PARENT_INBUFFER_GET(a1in, for01_in, a1); + if (a1in != nullptr) { + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->input); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task02_1InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task02_1_in); + WFR_PRED_OUTBUFFER_GET(a1in, task01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task02_1ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task02_1_in); + WFR_SELF_OUTBUFFER_INIT(sout, task02_1_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task03_in); + WFR_PRED_OUTBUFFER_GET(a1in, task02_1_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task03_in); + WFR_SELF_OUTBUFFER_INIT(sout, task03_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task04_in); + WFR_PRED_OUTBUFFER_GET(a1in, task02_1_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task04ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task04_in); + WFR_SELF_OUTBUFFER_INIT(sout, task04_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( task01Implementations, "task01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01ExecFunc_0, "task01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task02_1Implementations, "task02_1Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task02_1ExecFunc_0, "task02_1ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task03Implementations, "task03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task03ExecFunc_0, "task03ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task04Implementations, "task04Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task04ExecFunc_0, "task04ExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "generatedWorkflow", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::forLoop(2, "for01", 1, 0, {}, {}, for01InputFunc, for01OutputFunc, for01CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(3, "task01", 2, 0, {4}, {}, task01InputFunc, task01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(4, "task02_1", 2, 0, {6, 5}, {3}, task02_1InputFunc, task02_1Implementations), \ + wfr::wfs::ActivityTemplate::atomic(5, "task03", 2, 0, {}, {4}, task03InputFunc, task03Implementations), \ + wfr::wfs::ActivityTemplate::atomic(6, "task04", 2, 0, {}, {4}, task04InputFunc, task04Implementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + long iterCount = 8; + bool isHelp = false; + boost::program_options::options_description opts("Raincloud Options"); + opts.add_options() + ("help", "Print help message.") + ("iterCount", boost::program_options::value(), "NGroup parameter."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("iterCount")) { + iterCount = vm["iterCount"].as(); + } + std::cerr << "iterCount = " << iterCount << std::endl; + } + wfInput.iterCount.setValue(iterCount); + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} diff --git a/src/12.elimination02/elimination.h b/src/12.elimination02/elimination.h new file mode 100644 index 0000000..c6034b1 --- /dev/null +++ b/src/12.elimination02/elimination.h @@ -0,0 +1,73 @@ +#ifndef RAINCLOUD_TEST01_H +#define RAINCLOUD_TEST01_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRINT(iterCount) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output1, wfr::lwd::_lwd_iwir_basetype_int, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output2, wfr::lwd::_lwd_iwir_basetype_int, 1) \ +) + +/* for01 INSTRUCT */ +WFR_PORT_STRUCT( for01_in, 3, \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* for01 OUTSTRUCT */ +WFR_PORT_STRUCT( for01_out, 4, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output1, wfr::lwd::_lwd_iwir_basetype_int, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output2, wfr::lwd::_lwd_iwir_basetype_int, 1) \ +) + +/* task01 INSTRUCT */ +WFR_PORT_STRUCT( task01_in, 5, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task01 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_out, 6, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task02_1 INSTRUCT */ +WFR_PORT_STRUCT( task02_1_in, 7, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task02_1 OUTSTRUCT */ +WFR_PORT_STRUCT( task02_1_out, 8, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task03 INSTRUCT */ +WFR_PORT_STRUCT( task03_in, 9, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task03 OUTSTRUCT */ +WFR_PORT_STRUCT( task03_out, 10, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task04 INSTRUCT */ +WFR_PORT_STRUCT( task04_in, 11, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task04 OUTSTRUCT */ +WFR_PORT_STRUCT( task04_out, 12, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* RAINCLOUD_TEST01_H */ diff --git a/src/13.loophoisting01/CMakeLists.txt b/src/13.loophoisting01/CMakeLists.txt new file mode 100644 index 0000000..854d662 --- /dev/null +++ b/src/13.loophoisting01/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(loophoisting-original C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin loophoisting.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/13.loophoisting01/loophoisting.cpp b/src/13.loophoisting01/loophoisting.cpp new file mode 100644 index 0000000..974f5bf --- /dev/null +++ b/src/13.loophoisting01/loophoisting.cpp @@ -0,0 +1,205 @@ +#include "loophoisting.h" + +#include +#include +#include +#include +#include + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_PORT_INIT_COLLECTION(sout->output); + WFR_CHILD_OUTBUFFER_GET(a1out, for01_out, a1, 3, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->iterCount)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(for01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, for01_in); + WFR_PRED_OUTBUFFER_GET(a1in, task01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_PARENT_INBUFFER_GET(a2in, toplevel_in, a2); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a2in->iterCount)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(for01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, for01_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, task03_out, output, 5); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(for01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for01_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task02_in); + WFR_PARENT_INBUFFER_GET(a1in, for01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task02_in); + WFR_SELF_OUTBUFFER_INIT(sout, task02_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task03_in); + WFR_PRED_OUTBUFFER_GET(a1in, task02_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task03_in); + WFR_SELF_OUTBUFFER_INIT(sout, task03_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( task01Implementations, "task01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01ExecFunc_0, "task01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task02Implementations, "task02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task02ExecFunc_0, "task02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task03Implementations, "task03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task03ExecFunc_0, "task03ExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "generatedWorkflow", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::atomic(2, "task01", 1, 0, {3}, {}, task01InputFunc, task01Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(3, "for01", 1, 0, {}, {2}, for01InputFunc, for01OutputFunc, for01CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(4, "task02", 3, 0, {5}, {}, task02InputFunc, task02Implementations), \ + wfr::wfs::ActivityTemplate::atomic(5, "task03", 3, 0, {}, {4}, task03InputFunc, task03Implementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + long iterCount = 8; + bool isHelp = false; + boost::program_options::options_description opts("Raincloud Options"); + opts.add_options() + ("help", "Print help message.") + ("iterCount", boost::program_options::value(), "NGroup parameter."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("iterCount")) { + iterCount = vm["iterCount"].as(); + } + std::cerr << "iterCount = " << iterCount << std::endl; + } + wfInput.iterCount.setValue(iterCount); + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} diff --git a/src/13.loophoisting01/loophoisting.h b/src/13.loophoisting01/loophoisting.h new file mode 100644 index 0000000..cf5ed23 --- /dev/null +++ b/src/13.loophoisting01/loophoisting.h @@ -0,0 +1,62 @@ +#ifndef RAINCLOUD_TEST01_H +#define RAINCLOUD_TEST01_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRINT(iterCount) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_int, 1) \ +) + +/* task01 INSTRUCT */ +WFR_PORT_STRUCT( task01_in, 3, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task01 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_out, 4, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* for01 INSTRUCT */ +WFR_PORT_STRUCT( for01_in, 5, \ + WFR_PORT_MEMBER_IWIRINT(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* for01 OUTSTRUCT */ +WFR_PORT_STRUCT( for01_out, 6, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_int, 1) \ +) + +/* task02 INSTRUCT */ +WFR_PORT_STRUCT( task02_in, 7, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task02 OUTSTRUCT */ +WFR_PORT_STRUCT( task02_out, 8, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task03 INSTRUCT */ +WFR_PORT_STRUCT( task03_in, 9, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task03 OUTSTRUCT */ +WFR_PORT_STRUCT( task03_out, 10, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* RAINCLOUD_TEST01_H */ diff --git a/src/14.loophoisting02/CMakeLists.txt b/src/14.loophoisting02/CMakeLists.txt new file mode 100644 index 0000000..00d6a42 --- /dev/null +++ b/src/14.loophoisting02/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(loophoisting-transformed C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin loophoisting.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/14.loophoisting02/loophoisting.cpp b/src/14.loophoisting02/loophoisting.cpp new file mode 100644 index 0000000..effc0ac --- /dev/null +++ b/src/14.loophoisting02/loophoisting.cpp @@ -0,0 +1,205 @@ +#include "loophoisting.h" + +#include +#include +#include +#include +#include + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_PORT_INIT_COLLECTION(sout->output); + WFR_CHILD_OUTBUFFER_GET(a1out, for01_out, a1, 4, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task01_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->iterCount)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task01_in); + WFR_SELF_OUTBUFFER_INIT(sout, task01_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task02_in); + WFR_PRED_OUTBUFFER_GET(a1in, task01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task02_in); + WFR_SELF_OUTBUFFER_INIT(sout, task02_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(for01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, for01_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->iterCount)); + } + WFR_PRED_OUTBUFFER_GET(a2in, task02_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(for01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, for01_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, task03_out, output, 5); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(for01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, for01_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(1, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(task03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, task03_in); + WFR_PARENT_INBUFFER_GET(a1in, for01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(task03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, task03_in); + WFR_SELF_OUTBUFFER_INIT(sout, task03_out); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + sout->output.setValue(sin->input.getValue()); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( task01Implementations, "task01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task01ExecFunc_0, "task01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task02Implementations, "task02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task02ExecFunc_0, "task02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( task03Implementations, "task03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(task03ExecFunc_0, "task03ExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "generatedWorkflow", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::atomic(2, "task01", 1, 0, {3}, {}, task01InputFunc, task01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(3, "task02", 1, 0, {4}, {2}, task02InputFunc, task02Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(4, "for01", 1, 0, {}, {3}, for01InputFunc, for01OutputFunc, for01CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(5, "task03", 4, 0, {}, {}, task03InputFunc, task03Implementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + long iterCount = 8; + bool isHelp = false; + boost::program_options::options_description opts("Raincloud Options"); + opts.add_options() + ("help", "Print help message.") + ("iterCount", boost::program_options::value(), "NGroup parameter."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("iterCount")) { + iterCount = vm["iterCount"].as(); + } + std::cerr << "iterCount = " << iterCount << std::endl; + } + wfInput.iterCount.setValue(iterCount); + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} diff --git a/src/14.loophoisting02/loophoisting.h b/src/14.loophoisting02/loophoisting.h new file mode 100644 index 0000000..0d14acc --- /dev/null +++ b/src/14.loophoisting02/loophoisting.h @@ -0,0 +1,62 @@ +#ifndef RAINCLOUD_TEST01_H +#define RAINCLOUD_TEST01_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRINT(iterCount) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_int, 1) \ +) + +/* task01 INSTRUCT */ +WFR_PORT_STRUCT( task01_in, 3, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task01 OUTSTRUCT */ +WFR_PORT_STRUCT( task01_out, 4, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* task02 INSTRUCT */ +WFR_PORT_STRUCT( task02_in, 5, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task02 OUTSTRUCT */ +WFR_PORT_STRUCT( task02_out, 6, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + +/* for01 INSTRUCT */ +WFR_PORT_STRUCT( for01_in, 7, \ + WFR_PORT_MEMBER_IWIRINT(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* for01 OUTSTRUCT */ +WFR_PORT_STRUCT( for01_out, 8, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_int, 1) \ +) + +/* task03 INSTRUCT */ +WFR_PORT_STRUCT( task03_in, 9, \ + WFR_PORT_MEMBER_IWIRINT(input) \ +) + +/* task03 OUTSTRUCT */ +WFR_PORT_STRUCT( task03_out, 10, \ + WFR_PORT_MEMBER_IWIRINT(output) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* RAINCLOUD_TEST01_H */ diff --git a/src/15.meteoag01/CMakeLists.txt b/src/15.meteoag01/CMakeLists.txt new file mode 100644 index 0000000..0b83f75 --- /dev/null +++ b/src/15.meteoag01/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(meteoag01 C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin meteoag01.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/15.meteoag01/meteoag01.cpp b/src/15.meteoag01/meteoag01.cpp new file mode 100644 index 0000000..866af2c --- /dev/null +++ b/src/15.meteoag01/meteoag01.cpp @@ -0,0 +1,460 @@ +#include "meteoag01.h" +#include +#include +#include + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_PORT_INIT_COLLECTION(sout->output); + WFR_CHILD_OUTBUFFER_GET(a1out, pForEach01_out, a1, 3, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(simulation_initInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, simulation_init_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_file, a1in->input_file)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->chunk_count, a1in->chunk_count)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input_file.isReady() && sin->chunk_count.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(simulation_initExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, simulation_init_in); + WFR_SELF_OUTBUFFER_INIT(sout, simulation_init_out); + WFR_PORT_INIT_COLLECTION(sout->input_chunks); + + for (long i = 0; i < sin->chunk_count.getValue(); ++i) { + sout->input_chunks.setEntryValue(i, "input_chunk"); + } + sout->input_chunks.setFinalised(true); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pForEach01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pForEach01_in); + WFR_PORT_INIT_COLLECTION(sin->input_chunks); + WFR_PRED_OUTBUFFER_GET(a1in, simulation_init_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_chunks, a1in->input_chunks)); + } + WFR_PARENT_INBUFFER_GET(a2in, toplevel_in, a2); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->if_condition, a2in->if_condition)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->pForIterations, a2in->pForIterations)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pForEach01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pForEach01_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, pFor01_out, output, 5); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pForEach01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pForEach01_in); + if (sin != nullptr && sin->input_chunks.isReady() && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution) { + wfr_size_t minLoopElementcount = std::min({sin->input_chunks.getSize()}); + WFR_SELF_SETITERATIONCOUNT(minLoopElementcount); + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_initInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input_chunks.getEntry(WFR_SELF_GETITERATIONID()))); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_initExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->if_condition, a1in->if_condition)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, if01_out, output, 10); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfileInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfileExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_initInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_initExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compareInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compareExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raverInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raverExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(if01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, if01_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->if_condition, a1in->if_condition)); + } + WFR_PRED_OUTBUFFER_GET(a2in, raver_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(if01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, if01_out); + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, revu_dump_out, a1, 12, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + } else { + WFR_SELF_INBUFFER_GET(a1in, if01_in); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1in->input)); + if (retval) { + instance.setInstanceStatus(wfs::ActivityInstanceStatus::Finished); + ((wfs::CompositeActivityInstance&)instance).notifyChildHasFinished(instance); + } + } + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_BRANCHCONDITION_HOOK(if01BranchConditionFunc) { + WFR_BRANCHCONDITION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, if01_in); + if (sin != nullptr && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution && sin->if_condition.isReady() ) { + if (sin->if_condition.getValue() == true) { + instance.setExecutionBranchID(0); + } else { + instance.setExecutionBranchID(1); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_BRANCHCONDITION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_histInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_hist_in); + WFR_PARENT_INBUFFER_GET(a1in, if01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_histExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_hist_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_hist_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_dumpInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_dump_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_hist_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_dumpExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_dump_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_dump_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( simulation_initImplementations, "simulation_initImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(simulation_initExecFunc_0, "simulation_initExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_initImplementations, "case_initImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_initExecFunc_0, "case_initExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfileImplementations, "rams_makevfileImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfileExecFunc_0, "rams_makevfileExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_initImplementations, "rams_initImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_initExecFunc_0, "rams_initExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compareImplementations, "revu_compareImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compareExecFunc_0, "revu_compareExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raverImplementations, "raverImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raverExecFunc_0, "raverExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_histImplementations, "rams_histImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_histExecFunc_0, "rams_histExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_dumpImplementations, "revu_dumpImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_dumpExecFunc_0, "revu_dumpExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "meteoAG", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::atomic(2, "simulation_init", 1, 0, {3}, {}, simulation_initInputFunc, simulation_initImplementations), \ + wfr::wfs::ActivityTemplate::forLoop(3, "pForEach01", 1, 0, {}, {2}, pForEach01InputFunc, pForEach01OutputFunc, pForEach01CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(4, "case_init", 3, 0, {5}, {}, case_initInputFunc, case_initImplementations), \ + wfr::wfs::ActivityTemplate::forLoop(5, "pFor01", 3, 0, {}, {4}, pFor01InputFunc, pFor01OutputFunc, pFor01CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(6, "rams_makevfile", 5, 0, {7}, {}, rams_makevfileInputFunc, rams_makevfileImplementations), \ + wfr::wfs::ActivityTemplate::atomic(7, "rams_init", 5, 0, {8}, {6}, rams_initInputFunc, rams_initImplementations), \ + wfr::wfs::ActivityTemplate::atomic(8, "revu_compare", 5, 0, {9}, {7}, revu_compareInputFunc, revu_compareImplementations), \ + wfr::wfs::ActivityTemplate::atomic(9, "raver", 5, 0, {10}, {8}, raverInputFunc, raverImplementations), \ + wfr::wfs::ActivityTemplate::conditional(10, "if01", 5, 0, {}, {9}, if01InputFunc, if01OutputFunc, if01BranchConditionFunc), \ + wfr::wfs::ActivityTemplate::atomic(11, "rams_hist", 10, 0, {12}, {}, rams_histInputFunc, rams_histImplementations), \ + wfr::wfs::ActivityTemplate::atomic(12, "revu_dump", 10, 0, {}, {11}, revu_dumpInputFunc, revu_dumpImplementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + + std::string inputFile = "input.file"; + long chunkCount = 10; + long pForIterations = 10; + bool ifCondition = true; + bool isHelp = false; + boost::program_options::options_description opts("MeteoAG Options"); + opts.add_options() + ("help", "Print help message.") + ("inputchunks", boost::program_options::value(), "Number of input chunks.") + ("pforiterations", boost::program_options::value(), "Number of pFor iterations.") + ("ifcondition", boost::program_options::value(), "If condition."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("inputchunks")) { + chunkCount = vm["inputchunks"].as(); + } + if (vm.count("pforiterations")) { + pForIterations = vm["pforiterations"].as(); + } + if (vm.count("ifcondition")) { + ifCondition = vm["ifcondition"].as(); + } + std::cerr << "inputChunks = " << chunkCount << std::endl; + std::cerr << "pForIterations = " << pForIterations << std::endl; + std::cerr << "IfCondition = " << ifCondition << std::endl; + } + wfInput.input_file.setValue("input_file"); + wfInput.chunk_count.setValue(chunkCount); + wfInput.pForIterations.setValue(pForIterations); + wfInput.if_condition.setValue(ifCondition); + + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} diff --git a/src/15.meteoag01/meteoag01.h b/src/15.meteoag01/meteoag01.h new file mode 100644 index 0000000..76c0426 --- /dev/null +++ b/src/15.meteoag01/meteoag01.h @@ -0,0 +1,140 @@ +#ifndef METEOAG01_H +#define METEOAG01_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRFILE(input_file) \ + WFR_PORT_MEMBER_IWIRINT(chunk_count) \ + WFR_PORT_MEMBER_IWIRBOOL(if_condition) \ + WFR_PORT_MEMBER_IWIRINT(pForIterations) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 2) \ +) + +/* simulation_init INSTRUCT */ +WFR_PORT_STRUCT( simulation_init_in, 3, \ + WFR_PORT_MEMBER_IWIRFILE(input_file) \ + WFR_PORT_MEMBER_IWIRINT(chunk_count) \ +) + +/* simulation_init OUTSTRUCT */ +WFR_PORT_STRUCT( simulation_init_out, 4, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* pForEach01 INSTRUCT */ +WFR_PORT_STRUCT( pForEach01_in, 5, \ + WFR_PORT_MEMBER_IWIRBOOL(if_condition) \ + WFR_PORT_MEMBER_IWIRINT(pForIterations) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* pForEach01 OUTSTRUCT */ +WFR_PORT_STRUCT( pForEach01_out, 6, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 2) \ +) + +/* case_init INSTRUCT */ +WFR_PORT_STRUCT( case_init_in, 7, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_out, 8, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_in, 9, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRBOOL(if_condition) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_out, 10, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_in, 11, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_out, 12, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init INSTRUCT */ +WFR_PORT_STRUCT( rams_init_in, 13, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_out, 14, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_in, 15, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_out, 16, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver INSTRUCT */ +WFR_PORT_STRUCT( raver_in, 17, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver OUTSTRUCT */ +WFR_PORT_STRUCT( raver_out, 18, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* if01 INSTRUCT */ +WFR_PORT_STRUCT( if01_in, 19, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRBOOL(if_condition) \ +) + +/* if01 OUTSTRUCT */ +WFR_PORT_STRUCT( if01_out, 20, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_hist INSTRUCT */ +WFR_PORT_STRUCT( rams_hist_in, 21, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_hist OUTSTRUCT */ +WFR_PORT_STRUCT( rams_hist_out, 22, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_dump INSTRUCT */ +WFR_PORT_STRUCT( revu_dump_in, 23, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_dump OUTSTRUCT */ +WFR_PORT_STRUCT( revu_dump_out, 24, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* METEOAG01_H */ diff --git a/src/16.meteoag02/CMakeLists.txt b/src/16.meteoag02/CMakeLists.txt new file mode 100644 index 0000000..0e05ff7 --- /dev/null +++ b/src/16.meteoag02/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(meteoag02 C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin meteoag02.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/16.meteoag02/meteoag02.cpp b/src/16.meteoag02/meteoag02.cpp new file mode 100644 index 0000000..974e9bd --- /dev/null +++ b/src/16.meteoag02/meteoag02.cpp @@ -0,0 +1,675 @@ +#include "meteoag02.h" +#include +#include +#include + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_PORT_INIT_COLLECTION(sout->output); + WFR_CHILD_OUTBUFFER_GET(a1out, if01_out, a1, 3, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(simulation_initInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, simulation_init_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_file, a1in->input_file)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->chunk_count, a1in->chunk_count)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input_file.isReady() && sin->chunk_count.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(simulation_initExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, simulation_init_in); + WFR_SELF_OUTBUFFER_INIT(sout, simulation_init_out); + WFR_PORT_INIT_COLLECTION(sout->input_chunks); + + for (long i = 0; i < sin->chunk_count.getValue(); ++i) { + sout->input_chunks.setEntryValue(i, "input_chunk"); + } + sout->input_chunks.setFinalised(true); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(if01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, if01_in); + WFR_PORT_INIT_COLLECTION(sin->input_chunks); + WFR_PRED_OUTBUFFER_GET(a1in, simulation_init_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_chunks, a1in->input_chunks)); + } + WFR_PARENT_INBUFFER_GET(a2in, toplevel_in, a2); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->if_condition, a2in->if_condition)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->pForIterations, a2in->pForIterations)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(if01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, if01_out); + WFR_PORT_INIT_COLLECTION(sout->output); + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, pForEach01_then_out, a1, 4, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + } else if (WFR_SELF_GETCONDBRANCHID() == 1) { + WFR_CHILD_OUTBUFFER_GET(a1out, pForEach01_else_out, a1, 13, 1); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_BRANCHCONDITION_HOOK(if01BranchConditionFunc) { + WFR_BRANCHCONDITION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, if01_in); + if (sin != nullptr && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution && sin->if_condition.isReady() ) { + if (sin->if_condition.getValue() == true) { + instance.setExecutionBranchID(0); + } else { + instance.setExecutionBranchID(1); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_BRANCHCONDITION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pForEach01_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pForEach01_then_in); + WFR_PORT_INIT_COLLECTION(sin->input_chunks); + WFR_PARENT_INBUFFER_GET(a1in, if01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_chunks, a1in->input_chunks)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->pForIterations, a1in->pForIterations)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pForEach01_thenOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pForEach01_then_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, pFor01_then_out, output, 6); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pForEach01_thenCounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pForEach01_then_in); + if (sin != nullptr && sin->input_chunks.isReady() && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution) { + wfr_size_t minLoopElementcount = std::min({sin->input_chunks.getSize()}); + WFR_SELF_SETITERATIONCOUNT(minLoopElementcount); + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_then_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_then_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input_chunks.getEntry(WFR_SELF_GETITERATIONID()))); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_then_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_then_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_then_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_then_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_thenOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_then_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, revu_dump_then_out, output, 12); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_thenCounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_then_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_then_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_then_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_then_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_then_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_then_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_then_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_hist_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_hist_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, raver_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_hist_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_hist_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_hist_then_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_dump_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_dump_then_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_hist_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_dump_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_dump_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_dump_then_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pForEach01_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pForEach01_else_in); + WFR_PORT_INIT_COLLECTION(sin->input_chunks); + WFR_PARENT_INBUFFER_GET(a1in, if01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_chunks, a1in->input_chunks)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->pForIterations, a1in->pForIterations)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pForEach01_elseOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pForEach01_else_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, pFor01_else_out, output, 15); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pForEach01_elseCounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pForEach01_else_in); + if (sin != nullptr && sin->input_chunks.isReady() && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution) { + wfr_size_t minLoopElementcount = std::min({sin->input_chunks.getSize()}); + WFR_SELF_SETITERATIONCOUNT(minLoopElementcount); + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_else_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_else_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input_chunks.getEntry(WFR_SELF_GETITERATIONID()))); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_else_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, case_init_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_PARENT_INBUFFER_GET(a2in, pForEach01_else_in, a2); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a2in->pForIterations)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_elseOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_else_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, raver_else_out, output, 19); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_elseCounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_else_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_else_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_else_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_else_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_else_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_else_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_else_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_else_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( simulation_initImplementations, "simulation_initImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(simulation_initExecFunc_0, "simulation_initExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_thenImplementations, "case_init_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_thenExecFunc_0, "case_init_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_thenImplementations, "rams_makevfile_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_thenExecFunc_0, "rams_makevfile_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_thenImplementations, "rams_init_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_thenExecFunc_0, "rams_init_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_thenImplementations, "revu_compare_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_thenExecFunc_0, "revu_compare_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_thenImplementations, "raver_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_thenExecFunc_0, "raver_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_hist_thenImplementations, "rams_hist_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_hist_thenExecFunc_0, "rams_hist_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_dump_thenImplementations, "revu_dump_thenImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_dump_thenExecFunc_0, "revu_dump_thenExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_elseImplementations, "case_init_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_elseExecFunc_0, "case_init_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_elseImplementations, "rams_makevfile_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_elseExecFunc_0, "rams_makevfile_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_elseImplementations, "rams_init_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_elseExecFunc_0, "rams_init_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_elseImplementations, "revu_compare_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_elseExecFunc_0, "revu_compare_elseExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_elseImplementations, "raver_elseImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_elseExecFunc_0, "raver_elseExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "meteoAG", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::atomic(2, "simulation_init", 1, 0, {3}, {}, simulation_initInputFunc, simulation_initImplementations), \ + wfr::wfs::ActivityTemplate::conditional(3, "if01", 1, 0, {}, {2}, if01InputFunc, if01OutputFunc, if01BranchConditionFunc), \ + wfr::wfs::ActivityTemplate::forLoop(4, "pForEach01_then", 3, 0, {}, {}, pForEach01_thenInputFunc, pForEach01_thenOutputFunc, pForEach01_thenCounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(5, "case_init_then", 4, 0, {6}, {}, case_init_thenInputFunc, case_init_thenImplementations), \ + wfr::wfs::ActivityTemplate::forLoop(6, "pFor01_then", 4, 0, {}, {5}, pFor01_thenInputFunc, pFor01_thenOutputFunc, pFor01_thenCounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(7, "rams_makevfile_then", 6, 0, {8}, {}, rams_makevfile_thenInputFunc, rams_makevfile_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(8, "rams_init_then", 6, 0, {9}, {7}, rams_init_thenInputFunc, rams_init_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(9, "revu_compare_then", 6, 0, {10}, {8}, revu_compare_thenInputFunc, revu_compare_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(10, "raver_then", 6, 0, {11}, {9}, raver_thenInputFunc, raver_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(11, "rams_hist_then", 6, 0, {12}, {10}, rams_hist_thenInputFunc, rams_hist_thenImplementations), \ + wfr::wfs::ActivityTemplate::atomic(12, "revu_dump_then", 6, 0, {}, {11}, revu_dump_thenInputFunc, revu_dump_thenImplementations), \ + wfr::wfs::ActivityTemplate::forLoop(13, "pForEach01_else", 3, 1, {}, {}, pForEach01_elseInputFunc, pForEach01_elseOutputFunc, pForEach01_elseCounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(14, "case_init_else", 13, 0, {15}, {}, case_init_elseInputFunc, case_init_elseImplementations), \ + wfr::wfs::ActivityTemplate::forLoop(15, "pFor01_else", 13, 0, {}, {14}, pFor01_elseInputFunc, pFor01_elseOutputFunc, pFor01_elseCounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(16, "rams_makevfile_else", 15, 0, {17}, {}, rams_makevfile_elseInputFunc, rams_makevfile_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(17, "rams_init_else", 15, 0, {18}, {16}, rams_init_elseInputFunc, rams_init_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(18, "revu_compare_else", 15, 0, {19}, {17}, revu_compare_elseInputFunc, revu_compare_elseImplementations), \ + wfr::wfs::ActivityTemplate::atomic(19, "raver_else", 15, 0, {}, {18}, raver_elseInputFunc, raver_elseImplementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + + std::string inputFile = "input.file"; + long chunkCount = 10; + long pForIterations = 10; + bool ifCondition = true; + bool isHelp = false; + boost::program_options::options_description opts("MeteoAG Options"); + opts.add_options() + ("help", "Print help message.") + ("inputchunks", boost::program_options::value(), "Number of input chunks.") + ("pforiterations", boost::program_options::value(), "Number of pFor iterations.") + ("ifcondition", boost::program_options::value(), "If condition."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("inputchunks")) { + chunkCount = vm["inputchunks"].as(); + } + if (vm.count("pforiterations")) { + pForIterations = vm["pforiterations"].as(); + } + if (vm.count("ifcondition")) { + ifCondition = vm["ifcondition"].as(); + } + std::cerr << "inputChunks = " << chunkCount << std::endl; + std::cerr << "pForIterations = " << pForIterations << std::endl; + std::cerr << "IfCondition = " << ifCondition << std::endl; + } + wfInput.input_file.setValue("input_file"); + wfInput.chunk_count.setValue(chunkCount); + wfInput.pForIterations.setValue(pForIterations); + wfInput.if_condition.setValue(ifCondition); + + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} diff --git a/src/16.meteoag02/meteoag02.h b/src/16.meteoag02/meteoag02.h new file mode 100644 index 0000000..a2900d0 --- /dev/null +++ b/src/16.meteoag02/meteoag02.h @@ -0,0 +1,211 @@ +#ifndef METEOAG02_H +#define METEOAG02_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRFILE(input_file) \ + WFR_PORT_MEMBER_IWIRINT(chunk_count) \ + WFR_PORT_MEMBER_IWIRBOOL(if_condition) \ + WFR_PORT_MEMBER_IWIRINT(pForIterations) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 2) \ +) + +/* simulation_init INSTRUCT */ +WFR_PORT_STRUCT( simulation_init_in, 3, \ + WFR_PORT_MEMBER_IWIRFILE(input_file) \ + WFR_PORT_MEMBER_IWIRINT(chunk_count) \ +) + +/* simulation_init OUTSTRUCT */ +WFR_PORT_STRUCT( simulation_init_out, 4, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* if01 INSTRUCT */ +WFR_PORT_STRUCT( if01_in, 5, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRINT(pForIterations) \ + WFR_PORT_MEMBER_IWIRBOOL(if_condition) \ +) + +/* if01 OUTSTRUCT */ +WFR_PORT_STRUCT( if01_out, 6, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 2) \ +) + +/* pForEach01_then INSTRUCT */ +WFR_PORT_STRUCT( pForEach01_then_in, 7, \ + WFR_PORT_MEMBER_IWIRINT(pForIterations) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* pForEach01_then OUTSTRUCT */ +WFR_PORT_STRUCT( pForEach01_then_out, 8, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 2) \ +) + +/* case_init_then INSTRUCT */ +WFR_PORT_STRUCT( case_init_then_in, 9, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_then OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_then_out, 10, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_then INSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_in, 11, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_then OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_out, 12, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_then INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_in, 13, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_then OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_out, 14, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_then INSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_in, 15, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_then OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_out, 16, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_then INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_in, 17, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_then OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_out, 18, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_then INSTRUCT */ +WFR_PORT_STRUCT( raver_then_in, 19, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_then OUTSTRUCT */ +WFR_PORT_STRUCT( raver_then_out, 20, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_hist_then INSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_in, 21, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_hist_then OUTSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_out, 22, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_dump_then INSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_in, 23, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_dump_then OUTSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_out, 24, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pForEach01_else INSTRUCT */ +WFR_PORT_STRUCT( pForEach01_else_in, 25, \ + WFR_PORT_MEMBER_IWIRINT(pForIterations) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* pForEach01_else OUTSTRUCT */ +WFR_PORT_STRUCT( pForEach01_else_out, 26, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 2) \ +) + +/* case_init_else INSTRUCT */ +WFR_PORT_STRUCT( case_init_else_in, 27, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_else OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_else_out, 28, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_else INSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_in, 29, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_else OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_out, 30, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_else INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_in, 31, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_else OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_out, 32, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_else INSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_in, 33, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_else OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_out, 34, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_else INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_in, 35, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_else OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_out, 36, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_else INSTRUCT */ +WFR_PORT_STRUCT( raver_else_in, 37, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_else OUTSTRUCT */ +WFR_PORT_STRUCT( raver_else_out, 38, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* METEOAG02_H */ diff --git a/src/17.meteoag03/CMakeLists.txt b/src/17.meteoag03/CMakeLists.txt new file mode 100644 index 0000000..975ddb7 --- /dev/null +++ b/src/17.meteoag03/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(meteoag03 C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin meteoag03.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/17.meteoag03/meteoag03.cpp b/src/17.meteoag03/meteoag03.cpp new file mode 100644 index 0000000..5d4e0e9 --- /dev/null +++ b/src/17.meteoag03/meteoag03.cpp @@ -0,0 +1,4739 @@ +#include "meteoag03.h" +#include +#include +#include + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_PORT_INIT_COLLECTION(sout->output); + WFR_CHILD_OUTBUFFER_GET(a1out, if01_out, a1, 4, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(simulation_initInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, simulation_init_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_file, a1in->input_file)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->chunk_count, a1in->chunk_count)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input_file.isReady() && sin->chunk_count.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(simulation_initExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, simulation_init_in); + WFR_SELF_OUTBUFFER_INIT(sout, simulation_init_out); + WFR_PORT_INIT_COLLECTION(sout->input_chunks); + + for (long i = 0; i < sin->chunk_count.getValue(); ++i) { + sout->input_chunks.setEntryValue(i, "input_chunk"); + } + sout->input_chunks.setFinalised(true); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper01_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->chunk_count, a1in->chunk_count)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->chunk_count.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper01_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper01_out); + + sout->pForEachIterations.setValue((sin->chunk_count.getValue()/10) - 1); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(if01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, if01_in); + WFR_PORT_INIT_COLLECTION(sin->input_chunks); + WFR_PRED_OUTBUFFER_GET(a1in, helper01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->pForEachIterations, a1in->pForEachIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, simulation_init_out, a2, 1); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_chunks, a2in->input_chunks)); + } + WFR_PARENT_INBUFFER_GET(a3in, toplevel_in, a3); + if (a3in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->if_condition, a3in->if_condition)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->pForIterations, a3in->pForIterations)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(if01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, if01_out); + WFR_PORT_INIT_COLLECTION(sout->output); + if (WFR_SELF_GETCONDBRANCHID() == 0) { + WFR_CHILD_OUTBUFFER_GET(a1out, pForEach01_then_out, a1, 5, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + } else if (WFR_SELF_GETCONDBRANCHID() == 1) { + WFR_CHILD_OUTBUFFER_GET(a1out, pForEach01_else_out, a1, 88, 1); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->output, a1out->output)); + } + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_BRANCHCONDITION_HOOK(if01BranchConditionFunc) { + WFR_BRANCHCONDITION_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, if01_in); + if (sin != nullptr && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution && sin->if_condition.isReady() ) { + if (sin->if_condition.getValue() == true) { + instance.setExecutionBranchID(0); + } else { + instance.setExecutionBranchID(1); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_BRANCHCONDITION_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pForEach01_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pForEach01_then_in); + WFR_PORT_INIT_COLLECTION(sin->input_chunks); + WFR_PARENT_INBUFFER_GET(a1in, if01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_chunks, a1in->input_chunks)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->counter_to, a1in->pForEachIterations)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->pForIterations, a1in->pForIterations)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pForEach01_thenOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pForEach01_then_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, helper03_then_out, output, 87); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pForEach01_thenCounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pForEach01_then_in); + if(sin != nullptr && sin->counter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->counter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper02_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper02_then_in); + WFR_PORT_INIT_COLLECTION(sin->input_chunks); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_then_in, a1); + if (a1in != nullptr) { + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->counter); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_chunks, a1in->input_chunks)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->counter.isReady() && sin->input_chunks.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper02_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper02_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper02_then_out); + + sout->input01.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10)); + sout->input02.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 1)); + sout->input03.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 2)); + sout->input04.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 3)); + sout->input05.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 4)); + sout->input06.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 5)); + sout->input07.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 6)); + sout->input08.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 7)); + sout->input09.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 8)); + sout->input10.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 9)); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_then_01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_then_01_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input01)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_then_01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_then_01_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_then_01_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_then_01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_then_01_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_then_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_then_01_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_then_01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_then_01_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, revu_dump_then_01_out, output, 14); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_then_01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_then_01_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_then_01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_then_01_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_then_01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_then_01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_then_01_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_then_01_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_then_01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_then_01_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_then_01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_then_01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_then_01_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_then_01_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_then_01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_then_01_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_then_01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_then_01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_then_01_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_then_01_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_then_01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_then_01_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_then_01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_then_01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_then_01_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_then_01_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_hist_then_01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_hist_then_01_in); + WFR_PRED_OUTBUFFER_GET(a1in, raver_then_01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_hist_then_01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_hist_then_01_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_hist_then_01_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_dump_then_01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_dump_then_01_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_hist_then_01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_dump_then_01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_dump_then_01_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_dump_then_01_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_then_02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_then_02_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input02)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_then_02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_then_02_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_then_02_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_then_02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_then_02_in); + WFR_PRED_OUTBUFFER_GET(a1in, case_init_then_02_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_PARENT_INBUFFER_GET(a2in, pForEach01_then_in, a2); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a2in->pForIterations)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_then_02OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_then_02_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, revu_dump_then_02_out, output, 22); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_then_02CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_then_02_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_then_02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_then_02_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_then_02_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_then_02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_then_02_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_then_02_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_then_02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_then_02_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_then_02_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_then_02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_then_02_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_then_02_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_then_02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_then_02_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_then_02_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_then_02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_then_02_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_then_02_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_then_02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_then_02_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_then_02_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_then_02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_then_02_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_then_02_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_hist_then_02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_hist_then_02_in); + WFR_PRED_OUTBUFFER_GET(a1in, raver_then_02_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_hist_then_02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_hist_then_02_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_hist_then_02_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_dump_then_02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_dump_then_02_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_hist_then_02_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_dump_then_02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_dump_then_02_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_dump_then_02_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_then_03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_then_03_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input03)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_then_03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_then_03_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_then_03_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_then_03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_then_03_in); + WFR_PRED_OUTBUFFER_GET(a1in, case_init_then_03_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_PARENT_INBUFFER_GET(a2in, pForEach01_then_in, a2); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a2in->pForIterations)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_then_03OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_then_03_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, revu_dump_then_03_out, output, 30); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_then_03CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_then_03_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_then_03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_then_03_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_then_03_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_then_03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_then_03_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_then_03_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_then_03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_then_03_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_then_03_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_then_03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_then_03_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_then_03_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_then_03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_then_03_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_then_03_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_then_03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_then_03_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_then_03_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_then_03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_then_03_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_then_03_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_then_03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_then_03_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_then_03_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_hist_then_03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_hist_then_03_in); + WFR_PRED_OUTBUFFER_GET(a1in, raver_then_03_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_hist_then_03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_hist_then_03_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_hist_then_03_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_dump_then_03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_dump_then_03_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_hist_then_03_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_dump_then_03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_dump_then_03_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_dump_then_03_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_then_04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_then_04_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input04)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_then_04ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_then_04_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_then_04_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_then_04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_then_04_in); + WFR_PRED_OUTBUFFER_GET(a1in, case_init_then_04_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_PARENT_INBUFFER_GET(a2in, pForEach01_then_in, a2); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a2in->pForIterations)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_then_04OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_then_04_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, revu_dump_then_04_out, output, 38); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_then_04CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_then_04_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_then_04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_then_04_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_then_04_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_then_04ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_then_04_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_then_04_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_then_04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_then_04_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_then_04_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_then_04ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_then_04_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_then_04_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_then_04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_then_04_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_then_04_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_then_04ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_then_04_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_then_04_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_then_04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_then_04_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_then_04_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_then_04ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_then_04_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_then_04_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_hist_then_04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_hist_then_04_in); + WFR_PRED_OUTBUFFER_GET(a1in, raver_then_04_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_hist_then_04ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_hist_then_04_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_hist_then_04_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_dump_then_04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_dump_then_04_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_hist_then_04_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_dump_then_04ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_dump_then_04_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_dump_then_04_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_then_05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_then_05_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input05)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_then_05ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_then_05_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_then_05_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_then_05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_then_05_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_then_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_then_05_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_then_05OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_then_05_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, revu_dump_then_05_out, output, 46); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_then_05CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_then_05_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_then_05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_then_05_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_then_05_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_then_05ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_then_05_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_then_05_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_then_05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_then_05_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_then_05_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_then_05ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_then_05_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_then_05_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_then_05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_then_05_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_then_05_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_then_05ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_then_05_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_then_05_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_then_05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_then_05_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_then_05_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_then_05ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_then_05_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_then_05_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_hist_then_05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_hist_then_05_in); + WFR_PRED_OUTBUFFER_GET(a1in, raver_then_05_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_hist_then_05ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_hist_then_05_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_hist_then_05_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_dump_then_05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_dump_then_05_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_hist_then_05_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_dump_then_05ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_dump_then_05_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_dump_then_05_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_then_06InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_then_06_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input06)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_then_06ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_then_06_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_then_06_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_then_06InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_then_06_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_then_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_then_06_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_then_06OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_then_06_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, revu_dump_then_06_out, output, 54); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_then_06CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_then_06_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_then_06InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_then_06_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_then_06_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_then_06ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_then_06_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_then_06_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_then_06InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_then_06_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_then_06_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_then_06ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_then_06_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_then_06_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_then_06InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_then_06_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_then_06_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_then_06ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_then_06_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_then_06_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_then_06InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_then_06_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_then_06_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_then_06ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_then_06_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_then_06_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_hist_then_06InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_hist_then_06_in); + WFR_PRED_OUTBUFFER_GET(a1in, raver_then_06_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_hist_then_06ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_hist_then_06_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_hist_then_06_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_dump_then_06InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_dump_then_06_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_hist_then_06_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_dump_then_06ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_dump_then_06_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_dump_then_06_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_then_07InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_then_07_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input07)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_then_07ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_then_07_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_then_07_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_then_07InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_then_07_in); + WFR_PRED_OUTBUFFER_GET(a1in, case_init_then_07_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_PARENT_INBUFFER_GET(a2in, pForEach01_then_in, a2); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a2in->pForIterations)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_then_07OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_then_07_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, revu_dump_then_07_out, output, 62); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_then_07CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_then_07_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_then_07InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_then_07_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_then_07_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_then_07ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_then_07_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_then_07_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_then_07InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_then_07_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_then_07_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_then_07ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_then_07_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_then_07_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_then_07InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_then_07_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_then_07_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_then_07ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_then_07_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_then_07_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_then_07InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_then_07_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_then_07_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_then_07ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_then_07_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_then_07_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_hist_then_07InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_hist_then_07_in); + WFR_PRED_OUTBUFFER_GET(a1in, raver_then_07_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_hist_then_07ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_hist_then_07_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_hist_then_07_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_dump_then_07InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_dump_then_07_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_hist_then_07_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_dump_then_07ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_dump_then_07_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_dump_then_07_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_then_08InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_then_08_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input08)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_then_08ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_then_08_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_then_08_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_then_08InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_then_08_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_then_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_then_08_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_then_08OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_then_08_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, revu_dump_then_08_out, output, 70); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_then_08CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_then_08_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_then_08InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_then_08_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_then_08_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_then_08ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_then_08_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_then_08_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_then_08InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_then_08_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_then_08_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_then_08ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_then_08_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_then_08_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_then_08InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_then_08_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_then_08_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_then_08ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_then_08_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_then_08_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_then_08InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_then_08_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_then_08_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_then_08ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_then_08_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_then_08_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_hist_then_08InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_hist_then_08_in); + WFR_PRED_OUTBUFFER_GET(a1in, raver_then_08_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_hist_then_08ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_hist_then_08_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_hist_then_08_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_dump_then_08InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_dump_then_08_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_hist_then_08_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_dump_then_08ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_dump_then_08_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_dump_then_08_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_then_09InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_then_09_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input09)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_then_09ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_then_09_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_then_09_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_then_09InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_then_09_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_then_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_then_09_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_then_09OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_then_09_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, revu_dump_then_09_out, output, 78); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_then_09CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_then_09_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_then_09InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_then_09_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_then_09_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_then_09ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_then_09_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_then_09_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_then_09InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_then_09_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_then_09_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_then_09ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_then_09_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_then_09_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_then_09InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_then_09_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_then_09_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_then_09ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_then_09_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_then_09_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_then_09InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_then_09_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_then_09_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_then_09ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_then_09_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_then_09_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_hist_then_09InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_hist_then_09_in); + WFR_PRED_OUTBUFFER_GET(a1in, raver_then_09_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_hist_then_09ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_hist_then_09_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_hist_then_09_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_dump_then_09InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_dump_then_09_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_hist_then_09_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_dump_then_09ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_dump_then_09_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_dump_then_09_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_then_10InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_then_10_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_then_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input10)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_then_10ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_then_10_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_then_10_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_then_10InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_then_10_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_then_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_then_10_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_then_10OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_then_10_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, revu_dump_then_10_out, output, 86); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_then_10CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_then_10_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_then_10InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_then_10_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_then_10_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_then_10ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_then_10_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_then_10_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_then_10InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_then_10_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_then_10_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_then_10ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_then_10_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_then_10_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_then_10InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_then_10_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_then_10_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_then_10ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_then_10_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_then_10_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_then_10InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_then_10_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_then_10_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_then_10ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_then_10_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_then_10_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_hist_then_10InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_hist_then_10_in); + WFR_PRED_OUTBUFFER_GET(a1in, raver_then_10_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_hist_then_10ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_hist_then_10_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_hist_then_10_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_dump_then_10InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_dump_then_10_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_hist_then_10_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_dump_then_10ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_dump_then_10_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_dump_then_10_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper03_thenInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper03_then_in); + WFR_PORT_INIT_COLLECTION(sin->output01); + WFR_PORT_INIT_COLLECTION(sin->output02); + WFR_PORT_INIT_COLLECTION(sin->output03); + WFR_PORT_INIT_COLLECTION(sin->output04); + WFR_PORT_INIT_COLLECTION(sin->output05); + WFR_PORT_INIT_COLLECTION(sin->output06); + WFR_PORT_INIT_COLLECTION(sin->output07); + WFR_PORT_INIT_COLLECTION(sin->output08); + WFR_PORT_INIT_COLLECTION(sin->output09); + WFR_PORT_INIT_COLLECTION(sin->output10); + WFR_PRED_OUTBUFFER_GET(a1in, pFor01_then_09_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output09, a1in->output)); + } + WFR_PRED_OUTBUFFER_GET(a2in, pFor01_then_04_out, a2, 1); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output04, a2in->output)); + } + WFR_PRED_OUTBUFFER_GET(a3in, pFor01_then_08_out, a3, 2); + if (a3in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output08, a3in->output)); + } + WFR_PRED_OUTBUFFER_GET(a4in, pFor01_then_10_out, a4, 3); + if (a4in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output10, a4in->output)); + } + WFR_PRED_OUTBUFFER_GET(a5in, pFor01_then_05_out, a5, 4); + if (a5in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output05, a5in->output)); + } + WFR_PRED_OUTBUFFER_GET(a6in, pFor01_then_02_out, a6, 5); + if (a6in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output02, a6in->output)); + } + WFR_PRED_OUTBUFFER_GET(a7in, pFor01_then_03_out, a7, 6); + if (a7in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output03, a7in->output)); + } + WFR_PRED_OUTBUFFER_GET(a8in, pFor01_then_06_out, a8, 7); + if (a8in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output06, a8in->output)); + } + WFR_PRED_OUTBUFFER_GET(a9in, pFor01_then_07_out, a9, 8); + if (a9in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output07, a9in->output)); + } + WFR_PRED_OUTBUFFER_GET(a10in, pFor01_then_01_out, a10, 9); + if (a10in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output01, a10in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->output01.isReady() && sin->output02.isReady() && sin->output03.isReady() && sin->output04.isReady() && sin->output05.isReady() && sin->output06.isReady() && sin->output07.isReady() && sin->output08.isReady() && sin->output09.isReady() && sin->output10.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper03_thenExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper03_then_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper03_then_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + long i = 0; + for ( auto& o : sin->output01.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output02.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output03.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output04.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output05.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output06.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output07.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output08.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output09.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output10.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + sout->output.setFinalised(true); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pForEach01_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pForEach01_else_in); + WFR_PORT_INIT_COLLECTION(sin->input_chunks); + WFR_PARENT_INBUFFER_GET(a1in, if01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_chunks, a1in->input_chunks)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->counter_to, a1in->pForEachIterations)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->pForIterations, a1in->pForIterations)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pForEach01_elseOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pForEach01_else_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, helper03_else_out, output, 150); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pForEach01_elseCounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pForEach01_else_in); + if(sin != nullptr && sin->counter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->counter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper02_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper02_else_in); + WFR_PORT_INIT_COLLECTION(sin->input_chunks); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_else_in, a1); + if (a1in != nullptr) { + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->counter); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_chunks, a1in->input_chunks)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->counter.isReady() && sin->input_chunks.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper02_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper02_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper02_else_out); + + sout->input01.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10)); + sout->input02.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 1)); + sout->input03.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 2)); + sout->input04.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 3)); + sout->input05.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 4)); + sout->input06.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 5)); + sout->input07.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 6)); + sout->input08.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 7)); + sout->input09.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 8)); + sout->input10.setValue(sin->input_chunks.getEntryValue(sin->counter.getValue() * 10 + 9)); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_else_01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_else_01_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input01)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_else_01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_else_01_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_else_01_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_else_01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_else_01_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_else_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_else_01_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_else_01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_else_01_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, raver_else_01_out, output, 95); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_else_01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_else_01_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_else_01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_else_01_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_else_01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_else_01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_else_01_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_else_01_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_else_01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_else_01_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_else_01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_else_01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_else_01_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_else_01_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_else_01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_else_01_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_else_01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_else_01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_else_01_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_else_01_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_else_01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_else_01_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_else_01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_else_01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_else_01_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_else_01_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_else_02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_else_02_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input02)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_else_02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_else_02_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_else_02_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_else_02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_else_02_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_else_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_else_02_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_else_02OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_else_02_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, raver_else_02_out, output, 101); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_else_02CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_else_02_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_else_02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_else_02_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_else_02_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_else_02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_else_02_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_else_02_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_else_02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_else_02_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_else_02_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_else_02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_else_02_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_else_02_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_else_02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_else_02_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_else_02_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_else_02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_else_02_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_else_02_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_else_02InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_else_02_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_else_02_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_else_02ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_else_02_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_else_02_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_else_03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_else_03_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input03)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_else_03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_else_03_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_else_03_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_else_03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_else_03_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_else_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_else_03_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_else_03OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_else_03_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, raver_else_03_out, output, 107); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_else_03CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_else_03_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_else_03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_else_03_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_else_03_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_else_03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_else_03_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_else_03_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_else_03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_else_03_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_else_03_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_else_03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_else_03_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_else_03_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_else_03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_else_03_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_else_03_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_else_03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_else_03_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_else_03_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_else_03InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_else_03_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_else_03_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_else_03ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_else_03_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_else_03_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_else_04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_else_04_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input04)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_else_04ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_else_04_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_else_04_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_else_04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_else_04_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_else_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_else_04_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_else_04OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_else_04_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, raver_else_04_out, output, 113); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_else_04CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_else_04_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_else_04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_else_04_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_else_04_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_else_04ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_else_04_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_else_04_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_else_04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_else_04_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_else_04_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_else_04ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_else_04_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_else_04_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_else_04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_else_04_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_else_04_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_else_04ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_else_04_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_else_04_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_else_04InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_else_04_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_else_04_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_else_04ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_else_04_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_else_04_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_else_05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_else_05_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input05)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_else_05ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_else_05_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_else_05_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_else_05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_else_05_in); + WFR_PRED_OUTBUFFER_GET(a1in, case_init_else_05_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_PARENT_INBUFFER_GET(a2in, pForEach01_else_in, a2); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a2in->pForIterations)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_else_05OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_else_05_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, raver_else_05_out, output, 119); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_else_05CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_else_05_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_else_05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_else_05_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_else_05_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_else_05ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_else_05_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_else_05_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_else_05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_else_05_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_else_05_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_else_05ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_else_05_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_else_05_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_else_05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_else_05_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_else_05_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_else_05ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_else_05_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_else_05_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_else_05InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_else_05_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_else_05_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_else_05ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_else_05_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_else_05_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_else_06InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_else_06_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input06)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_else_06ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_else_06_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_else_06_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_else_06InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_else_06_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_else_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_else_06_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_else_06OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_else_06_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, raver_else_06_out, output, 125); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_else_06CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_else_06_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_else_06InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_else_06_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_else_06_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_else_06ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_else_06_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_else_06_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_else_06InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_else_06_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_else_06_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_else_06ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_else_06_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_else_06_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_else_06InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_else_06_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_else_06_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_else_06ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_else_06_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_else_06_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_else_06InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_else_06_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_else_06_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_else_06ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_else_06_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_else_06_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_else_07InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_else_07_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input07)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_else_07ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_else_07_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_else_07_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_else_07InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_else_07_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_else_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_else_07_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_else_07OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_else_07_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, raver_else_07_out, output, 131); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_else_07CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_else_07_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_else_07InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_else_07_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_else_07_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_else_07ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_else_07_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_else_07_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_else_07InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_else_07_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_else_07_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_else_07ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_else_07_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_else_07_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_else_07InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_else_07_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_else_07_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_else_07ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_else_07_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_else_07_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_else_07InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_else_07_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_else_07_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_else_07ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_else_07_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_else_07_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_else_08InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_else_08_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input08)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_else_08ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_else_08_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_else_08_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_else_08InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_else_08_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_else_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_else_08_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_else_08OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_else_08_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, raver_else_08_out, output, 137); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_else_08CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_else_08_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_else_08InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_else_08_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_else_08_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_else_08ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_else_08_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_else_08_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_else_08InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_else_08_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_else_08_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_else_08ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_else_08_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_else_08_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_else_08InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_else_08_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_else_08_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_else_08ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_else_08_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_else_08_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_else_08InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_else_08_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_else_08_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_else_08ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_else_08_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_else_08_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_else_09InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_else_09_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input09)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_else_09ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_else_09_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_else_09_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_else_09InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_else_09_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_else_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_else_09_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_else_09OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_else_09_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, raver_else_09_out, output, 143); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_else_09CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_else_09_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_else_09InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_else_09_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_else_09_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_else_09ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_else_09_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_else_09_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_else_09InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_else_09_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_else_09_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_else_09ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_else_09_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_else_09_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_else_09InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_else_09_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_else_09_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_else_09ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_else_09_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_else_09_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_else_09InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_else_09_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_else_09_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_else_09ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_else_09_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_else_09_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(case_init_else_10InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, case_init_else_10_in); + WFR_PRED_OUTBUFFER_GET(a1in, helper02_else_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input10)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(case_init_else_10ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, case_init_else_10_in); + WFR_SELF_OUTBUFFER_INIT(sout, case_init_else_10_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01_else_10InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_else_10_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_else_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->loopCounter_to, a1in->pForIterations)); + } + WFR_PRED_OUTBUFFER_GET(a2in, case_init_else_10_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a2in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01_else_10OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_else_10_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, raver_else_10_out, output, 149); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01_else_10CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_else_10_in); + if(sin != nullptr && sin->loopCounter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->loopCounter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_makevfile_else_10InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_makevfile_else_10_in); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_else_10_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_makevfile_else_10ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_makevfile_else_10_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_makevfile_else_10_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(rams_init_else_10InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, rams_init_else_10_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_makevfile_else_10_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(rams_init_else_10ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, rams_init_else_10_in); + WFR_SELF_OUTBUFFER_INIT(sout, rams_init_else_10_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(revu_compare_else_10InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, revu_compare_else_10_in); + WFR_PRED_OUTBUFFER_GET(a1in, rams_init_else_10_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(revu_compare_else_10ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, revu_compare_else_10_in); + WFR_SELF_OUTBUFFER_INIT(sout, revu_compare_else_10_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(raver_else_10InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, raver_else_10_in); + WFR_PRED_OUTBUFFER_GET(a1in, revu_compare_else_10_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(raver_else_10ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, raver_else_10_in); + WFR_SELF_OUTBUFFER_INIT(sout, raver_else_10_out); + + sout->output.setValue(sin->input); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper03_elseInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper03_else_in); + WFR_PORT_INIT_COLLECTION(sin->output01); + WFR_PORT_INIT_COLLECTION(sin->output02); + WFR_PORT_INIT_COLLECTION(sin->output03); + WFR_PORT_INIT_COLLECTION(sin->output04); + WFR_PORT_INIT_COLLECTION(sin->output05); + WFR_PORT_INIT_COLLECTION(sin->output06); + WFR_PORT_INIT_COLLECTION(sin->output07); + WFR_PORT_INIT_COLLECTION(sin->output08); + WFR_PORT_INIT_COLLECTION(sin->output09); + WFR_PORT_INIT_COLLECTION(sin->output10); + WFR_PRED_OUTBUFFER_GET(a1in, pFor01_else_06_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output06, a1in->output)); + } + WFR_PRED_OUTBUFFER_GET(a2in, pFor01_else_04_out, a2, 1); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output04, a2in->output)); + } + WFR_PRED_OUTBUFFER_GET(a3in, pFor01_else_05_out, a3, 2); + if (a3in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output05, a3in->output)); + } + WFR_PRED_OUTBUFFER_GET(a4in, pFor01_else_07_out, a4, 3); + if (a4in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output07, a4in->output)); + } + WFR_PRED_OUTBUFFER_GET(a5in, pFor01_else_01_out, a5, 4); + if (a5in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output01, a5in->output)); + } + WFR_PRED_OUTBUFFER_GET(a6in, pFor01_else_02_out, a6, 5); + if (a6in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output02, a6in->output)); + } + WFR_PRED_OUTBUFFER_GET(a7in, pFor01_else_09_out, a7, 6); + if (a7in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output09, a7in->output)); + } + WFR_PRED_OUTBUFFER_GET(a8in, pFor01_else_10_out, a8, 7); + if (a8in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output10, a8in->output)); + } + WFR_PRED_OUTBUFFER_GET(a9in, pFor01_else_03_out, a9, 8); + if (a9in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output03, a9in->output)); + } + WFR_PRED_OUTBUFFER_GET(a10in, pFor01_else_08_out, a10, 9); + if (a10in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output08, a10in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->output01.isReady() && sin->output02.isReady() && sin->output03.isReady() && sin->output04.isReady() && sin->output05.isReady() && sin->output06.isReady() && sin->output07.isReady() && sin->output08.isReady() && sin->output09.isReady() && sin->output10.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper03_elseExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper03_else_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper03_else_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + long i = 0; + for ( auto& o : sin->output01.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output02.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output03.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output04.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output05.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output06.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output07.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output08.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output09.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + for ( auto& o : sin->output10.getValue()) { + sout->output.setEntryValue(i++, o.getValue()); + } + sout->output.setFinalised(true); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( simulation_initImplementations, "simulation_initImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(simulation_initExecFunc_0, "simulation_initExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_then_01Implementations, "case_init_then_01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_then_01ExecFunc_0, "case_init_then_01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_then_01Implementations, "rams_makevfile_then_01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_then_01ExecFunc_0, "rams_makevfile_then_01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_then_01Implementations, "rams_init_then_01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_then_01ExecFunc_0, "rams_init_then_01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_then_01Implementations, "revu_compare_then_01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_then_01ExecFunc_0, "revu_compare_then_01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_then_01Implementations, "raver_then_01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_then_01ExecFunc_0, "raver_then_01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_hist_then_01Implementations, "rams_hist_then_01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_hist_then_01ExecFunc_0, "rams_hist_then_01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_dump_then_01Implementations, "revu_dump_then_01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_dump_then_01ExecFunc_0, "revu_dump_then_01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_then_02Implementations, "case_init_then_02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_then_02ExecFunc_0, "case_init_then_02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_then_02Implementations, "rams_makevfile_then_02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_then_02ExecFunc_0, "rams_makevfile_then_02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_then_02Implementations, "rams_init_then_02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_then_02ExecFunc_0, "rams_init_then_02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_then_02Implementations, "revu_compare_then_02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_then_02ExecFunc_0, "revu_compare_then_02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_then_02Implementations, "raver_then_02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_then_02ExecFunc_0, "raver_then_02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_hist_then_02Implementations, "rams_hist_then_02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_hist_then_02ExecFunc_0, "rams_hist_then_02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_dump_then_02Implementations, "revu_dump_then_02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_dump_then_02ExecFunc_0, "revu_dump_then_02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_then_03Implementations, "case_init_then_03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_then_03ExecFunc_0, "case_init_then_03ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_then_03Implementations, "rams_makevfile_then_03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_then_03ExecFunc_0, "rams_makevfile_then_03ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_then_03Implementations, "rams_init_then_03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_then_03ExecFunc_0, "rams_init_then_03ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_then_03Implementations, "revu_compare_then_03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_then_03ExecFunc_0, "revu_compare_then_03ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_then_03Implementations, "raver_then_03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_then_03ExecFunc_0, "raver_then_03ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_hist_then_03Implementations, "rams_hist_then_03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_hist_then_03ExecFunc_0, "rams_hist_then_03ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_dump_then_03Implementations, "revu_dump_then_03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_dump_then_03ExecFunc_0, "revu_dump_then_03ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_then_04Implementations, "case_init_then_04Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_then_04ExecFunc_0, "case_init_then_04ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_then_04Implementations, "rams_makevfile_then_04Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_then_04ExecFunc_0, "rams_makevfile_then_04ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_then_04Implementations, "rams_init_then_04Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_then_04ExecFunc_0, "rams_init_then_04ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_then_04Implementations, "revu_compare_then_04Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_then_04ExecFunc_0, "revu_compare_then_04ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_then_04Implementations, "raver_then_04Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_then_04ExecFunc_0, "raver_then_04ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_hist_then_04Implementations, "rams_hist_then_04Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_hist_then_04ExecFunc_0, "rams_hist_then_04ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_dump_then_04Implementations, "revu_dump_then_04Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_dump_then_04ExecFunc_0, "revu_dump_then_04ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_then_05Implementations, "case_init_then_05Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_then_05ExecFunc_0, "case_init_then_05ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_then_05Implementations, "rams_makevfile_then_05Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_then_05ExecFunc_0, "rams_makevfile_then_05ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_then_05Implementations, "rams_init_then_05Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_then_05ExecFunc_0, "rams_init_then_05ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_then_05Implementations, "revu_compare_then_05Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_then_05ExecFunc_0, "revu_compare_then_05ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_then_05Implementations, "raver_then_05Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_then_05ExecFunc_0, "raver_then_05ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_hist_then_05Implementations, "rams_hist_then_05Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_hist_then_05ExecFunc_0, "rams_hist_then_05ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_dump_then_05Implementations, "revu_dump_then_05Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_dump_then_05ExecFunc_0, "revu_dump_then_05ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_then_06Implementations, "case_init_then_06Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_then_06ExecFunc_0, "case_init_then_06ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_then_06Implementations, "rams_makevfile_then_06Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_then_06ExecFunc_0, "rams_makevfile_then_06ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_then_06Implementations, "rams_init_then_06Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_then_06ExecFunc_0, "rams_init_then_06ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_then_06Implementations, "revu_compare_then_06Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_then_06ExecFunc_0, "revu_compare_then_06ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_then_06Implementations, "raver_then_06Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_then_06ExecFunc_0, "raver_then_06ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_hist_then_06Implementations, "rams_hist_then_06Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_hist_then_06ExecFunc_0, "rams_hist_then_06ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_dump_then_06Implementations, "revu_dump_then_06Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_dump_then_06ExecFunc_0, "revu_dump_then_06ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_then_07Implementations, "case_init_then_07Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_then_07ExecFunc_0, "case_init_then_07ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_then_07Implementations, "rams_makevfile_then_07Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_then_07ExecFunc_0, "rams_makevfile_then_07ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_then_07Implementations, "rams_init_then_07Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_then_07ExecFunc_0, "rams_init_then_07ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_then_07Implementations, "revu_compare_then_07Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_then_07ExecFunc_0, "revu_compare_then_07ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_then_07Implementations, "raver_then_07Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_then_07ExecFunc_0, "raver_then_07ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_hist_then_07Implementations, "rams_hist_then_07Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_hist_then_07ExecFunc_0, "rams_hist_then_07ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_dump_then_07Implementations, "revu_dump_then_07Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_dump_then_07ExecFunc_0, "revu_dump_then_07ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_then_08Implementations, "case_init_then_08Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_then_08ExecFunc_0, "case_init_then_08ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_then_08Implementations, "rams_makevfile_then_08Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_then_08ExecFunc_0, "rams_makevfile_then_08ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_then_08Implementations, "rams_init_then_08Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_then_08ExecFunc_0, "rams_init_then_08ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_then_08Implementations, "revu_compare_then_08Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_then_08ExecFunc_0, "revu_compare_then_08ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_then_08Implementations, "raver_then_08Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_then_08ExecFunc_0, "raver_then_08ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_hist_then_08Implementations, "rams_hist_then_08Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_hist_then_08ExecFunc_0, "rams_hist_then_08ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_dump_then_08Implementations, "revu_dump_then_08Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_dump_then_08ExecFunc_0, "revu_dump_then_08ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_then_09Implementations, "case_init_then_09Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_then_09ExecFunc_0, "case_init_then_09ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_then_09Implementations, "rams_makevfile_then_09Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_then_09ExecFunc_0, "rams_makevfile_then_09ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_then_09Implementations, "rams_init_then_09Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_then_09ExecFunc_0, "rams_init_then_09ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_then_09Implementations, "revu_compare_then_09Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_then_09ExecFunc_0, "revu_compare_then_09ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_then_09Implementations, "raver_then_09Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_then_09ExecFunc_0, "raver_then_09ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_hist_then_09Implementations, "rams_hist_then_09Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_hist_then_09ExecFunc_0, "rams_hist_then_09ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_dump_then_09Implementations, "revu_dump_then_09Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_dump_then_09ExecFunc_0, "revu_dump_then_09ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_then_10Implementations, "case_init_then_10Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_then_10ExecFunc_0, "case_init_then_10ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_then_10Implementations, "rams_makevfile_then_10Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_then_10ExecFunc_0, "rams_makevfile_then_10ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_then_10Implementations, "rams_init_then_10Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_then_10ExecFunc_0, "rams_init_then_10ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_then_10Implementations, "revu_compare_then_10Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_then_10ExecFunc_0, "revu_compare_then_10ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_then_10Implementations, "raver_then_10Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_then_10ExecFunc_0, "raver_then_10ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_hist_then_10Implementations, "rams_hist_then_10Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_hist_then_10ExecFunc_0, "rams_hist_then_10ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_dump_then_10Implementations, "revu_dump_then_10Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_dump_then_10ExecFunc_0, "revu_dump_then_10ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_else_01Implementations, "case_init_else_01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_else_01ExecFunc_0, "case_init_else_01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_else_01Implementations, "rams_makevfile_else_01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_else_01ExecFunc_0, "rams_makevfile_else_01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_else_01Implementations, "rams_init_else_01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_else_01ExecFunc_0, "rams_init_else_01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_else_01Implementations, "revu_compare_else_01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_else_01ExecFunc_0, "revu_compare_else_01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_else_01Implementations, "raver_else_01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_else_01ExecFunc_0, "raver_else_01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_else_02Implementations, "case_init_else_02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_else_02ExecFunc_0, "case_init_else_02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_else_02Implementations, "rams_makevfile_else_02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_else_02ExecFunc_0, "rams_makevfile_else_02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_else_02Implementations, "rams_init_else_02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_else_02ExecFunc_0, "rams_init_else_02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_else_02Implementations, "revu_compare_else_02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_else_02ExecFunc_0, "revu_compare_else_02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_else_02Implementations, "raver_else_02Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_else_02ExecFunc_0, "raver_else_02ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_else_03Implementations, "case_init_else_03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_else_03ExecFunc_0, "case_init_else_03ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_else_03Implementations, "rams_makevfile_else_03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_else_03ExecFunc_0, "rams_makevfile_else_03ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_else_03Implementations, "rams_init_else_03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_else_03ExecFunc_0, "rams_init_else_03ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_else_03Implementations, "revu_compare_else_03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_else_03ExecFunc_0, "revu_compare_else_03ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_else_03Implementations, "raver_else_03Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_else_03ExecFunc_0, "raver_else_03ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_else_04Implementations, "case_init_else_04Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_else_04ExecFunc_0, "case_init_else_04ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_else_04Implementations, "rams_makevfile_else_04Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_else_04ExecFunc_0, "rams_makevfile_else_04ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_else_04Implementations, "rams_init_else_04Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_else_04ExecFunc_0, "rams_init_else_04ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_else_04Implementations, "revu_compare_else_04Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_else_04ExecFunc_0, "revu_compare_else_04ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_else_04Implementations, "raver_else_04Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_else_04ExecFunc_0, "raver_else_04ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_else_05Implementations, "case_init_else_05Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_else_05ExecFunc_0, "case_init_else_05ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_else_05Implementations, "rams_makevfile_else_05Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_else_05ExecFunc_0, "rams_makevfile_else_05ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_else_05Implementations, "rams_init_else_05Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_else_05ExecFunc_0, "rams_init_else_05ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_else_05Implementations, "revu_compare_else_05Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_else_05ExecFunc_0, "revu_compare_else_05ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_else_05Implementations, "raver_else_05Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_else_05ExecFunc_0, "raver_else_05ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_else_06Implementations, "case_init_else_06Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_else_06ExecFunc_0, "case_init_else_06ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_else_06Implementations, "rams_makevfile_else_06Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_else_06ExecFunc_0, "rams_makevfile_else_06ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_else_06Implementations, "rams_init_else_06Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_else_06ExecFunc_0, "rams_init_else_06ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_else_06Implementations, "revu_compare_else_06Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_else_06ExecFunc_0, "revu_compare_else_06ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_else_06Implementations, "raver_else_06Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_else_06ExecFunc_0, "raver_else_06ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_else_07Implementations, "case_init_else_07Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_else_07ExecFunc_0, "case_init_else_07ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_else_07Implementations, "rams_makevfile_else_07Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_else_07ExecFunc_0, "rams_makevfile_else_07ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_else_07Implementations, "rams_init_else_07Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_else_07ExecFunc_0, "rams_init_else_07ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_else_07Implementations, "revu_compare_else_07Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_else_07ExecFunc_0, "revu_compare_else_07ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_else_07Implementations, "raver_else_07Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_else_07ExecFunc_0, "raver_else_07ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_else_08Implementations, "case_init_else_08Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_else_08ExecFunc_0, "case_init_else_08ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_else_08Implementations, "rams_makevfile_else_08Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_else_08ExecFunc_0, "rams_makevfile_else_08ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_else_08Implementations, "rams_init_else_08Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_else_08ExecFunc_0, "rams_init_else_08ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_else_08Implementations, "revu_compare_else_08Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_else_08ExecFunc_0, "revu_compare_else_08ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_else_08Implementations, "raver_else_08Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_else_08ExecFunc_0, "raver_else_08ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_else_09Implementations, "case_init_else_09Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_else_09ExecFunc_0, "case_init_else_09ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_else_09Implementations, "rams_makevfile_else_09Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_else_09ExecFunc_0, "rams_makevfile_else_09ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_else_09Implementations, "rams_init_else_09Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_else_09ExecFunc_0, "rams_init_else_09ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_else_09Implementations, "revu_compare_else_09Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_else_09ExecFunc_0, "revu_compare_else_09ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_else_09Implementations, "raver_else_09Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_else_09ExecFunc_0, "raver_else_09ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( case_init_else_10Implementations, "case_init_else_10Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(case_init_else_10ExecFunc_0, "case_init_else_10ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_makevfile_else_10Implementations, "rams_makevfile_else_10Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_makevfile_else_10ExecFunc_0, "rams_makevfile_else_10ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( rams_init_else_10Implementations, "rams_init_else_10Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(rams_init_else_10ExecFunc_0, "rams_init_else_10ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( revu_compare_else_10Implementations, "revu_compare_else_10Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(revu_compare_else_10ExecFunc_0, "revu_compare_else_10ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( raver_else_10Implementations, "raver_else_10Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(raver_else_10ExecFunc_0, "raver_else_10ExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "meteoAG", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::atomic(2, "simulation_init", 1, 0, {4}, {}, simulation_initInputFunc, simulation_initImplementations), \ + wfr::wfs::ActivityTemplate::assign(3, "helper01", 1, 0, {4}, {}, helper01InputFunc, helper01ExecFunc_0), \ + wfr::wfs::ActivityTemplate::conditional(4, "if01", 1, 0, {}, {3, 2}, if01InputFunc, if01OutputFunc, if01BranchConditionFunc), \ + wfr::wfs::ActivityTemplate::forLoop(5, "pForEach01_then", 4, 0, {}, {}, pForEach01_thenInputFunc, pForEach01_thenOutputFunc, pForEach01_thenCounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::assign(6, "helper02_then", 5, 0, {15, 31, 23, 55, 63, 39, 71, 79, 7, 47}, {}, helper02_thenInputFunc, helper02_thenExecFunc_0), \ + wfr::wfs::ActivityTemplate::atomic(7, "case_init_then_01", 5, 0, {8}, {6}, case_init_then_01InputFunc, case_init_then_01Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(8, "pFor01_then_01", 5, 0, {87}, {7}, pFor01_then_01InputFunc, pFor01_then_01OutputFunc, pFor01_then_01CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(9, "rams_makevfile_then_01", 8, 0, {10}, {}, rams_makevfile_then_01InputFunc, rams_makevfile_then_01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(10, "rams_init_then_01", 8, 0, {11}, {9}, rams_init_then_01InputFunc, rams_init_then_01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(11, "revu_compare_then_01", 8, 0, {12}, {10}, revu_compare_then_01InputFunc, revu_compare_then_01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(12, "raver_then_01", 8, 0, {13}, {11}, raver_then_01InputFunc, raver_then_01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(13, "rams_hist_then_01", 8, 0, {14}, {12}, rams_hist_then_01InputFunc, rams_hist_then_01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(14, "revu_dump_then_01", 8, 0, {}, {13}, revu_dump_then_01InputFunc, revu_dump_then_01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(15, "case_init_then_02", 5, 0, {16}, {6}, case_init_then_02InputFunc, case_init_then_02Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(16, "pFor01_then_02", 5, 0, {87}, {15}, pFor01_then_02InputFunc, pFor01_then_02OutputFunc, pFor01_then_02CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(17, "rams_makevfile_then_02", 16, 0, {18}, {}, rams_makevfile_then_02InputFunc, rams_makevfile_then_02Implementations), \ + wfr::wfs::ActivityTemplate::atomic(18, "rams_init_then_02", 16, 0, {19}, {17}, rams_init_then_02InputFunc, rams_init_then_02Implementations), \ + wfr::wfs::ActivityTemplate::atomic(19, "revu_compare_then_02", 16, 0, {20}, {18}, revu_compare_then_02InputFunc, revu_compare_then_02Implementations), \ + wfr::wfs::ActivityTemplate::atomic(20, "raver_then_02", 16, 0, {21}, {19}, raver_then_02InputFunc, raver_then_02Implementations), \ + wfr::wfs::ActivityTemplate::atomic(21, "rams_hist_then_02", 16, 0, {22}, {20}, rams_hist_then_02InputFunc, rams_hist_then_02Implementations), \ + wfr::wfs::ActivityTemplate::atomic(22, "revu_dump_then_02", 16, 0, {}, {21}, revu_dump_then_02InputFunc, revu_dump_then_02Implementations), \ + wfr::wfs::ActivityTemplate::atomic(23, "case_init_then_03", 5, 0, {24}, {6}, case_init_then_03InputFunc, case_init_then_03Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(24, "pFor01_then_03", 5, 0, {87}, {23}, pFor01_then_03InputFunc, pFor01_then_03OutputFunc, pFor01_then_03CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(25, "rams_makevfile_then_03", 24, 0, {26}, {}, rams_makevfile_then_03InputFunc, rams_makevfile_then_03Implementations), \ + wfr::wfs::ActivityTemplate::atomic(26, "rams_init_then_03", 24, 0, {27}, {25}, rams_init_then_03InputFunc, rams_init_then_03Implementations), \ + wfr::wfs::ActivityTemplate::atomic(27, "revu_compare_then_03", 24, 0, {28}, {26}, revu_compare_then_03InputFunc, revu_compare_then_03Implementations), \ + wfr::wfs::ActivityTemplate::atomic(28, "raver_then_03", 24, 0, {29}, {27}, raver_then_03InputFunc, raver_then_03Implementations), \ + wfr::wfs::ActivityTemplate::atomic(29, "rams_hist_then_03", 24, 0, {30}, {28}, rams_hist_then_03InputFunc, rams_hist_then_03Implementations), \ + wfr::wfs::ActivityTemplate::atomic(30, "revu_dump_then_03", 24, 0, {}, {29}, revu_dump_then_03InputFunc, revu_dump_then_03Implementations), \ + wfr::wfs::ActivityTemplate::atomic(31, "case_init_then_04", 5, 0, {32}, {6}, case_init_then_04InputFunc, case_init_then_04Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(32, "pFor01_then_04", 5, 0, {87}, {31}, pFor01_then_04InputFunc, pFor01_then_04OutputFunc, pFor01_then_04CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(33, "rams_makevfile_then_04", 32, 0, {34}, {}, rams_makevfile_then_04InputFunc, rams_makevfile_then_04Implementations), \ + wfr::wfs::ActivityTemplate::atomic(34, "rams_init_then_04", 32, 0, {35}, {33}, rams_init_then_04InputFunc, rams_init_then_04Implementations), \ + wfr::wfs::ActivityTemplate::atomic(35, "revu_compare_then_04", 32, 0, {36}, {34}, revu_compare_then_04InputFunc, revu_compare_then_04Implementations), \ + wfr::wfs::ActivityTemplate::atomic(36, "raver_then_04", 32, 0, {37}, {35}, raver_then_04InputFunc, raver_then_04Implementations), \ + wfr::wfs::ActivityTemplate::atomic(37, "rams_hist_then_04", 32, 0, {38}, {36}, rams_hist_then_04InputFunc, rams_hist_then_04Implementations), \ + wfr::wfs::ActivityTemplate::atomic(38, "revu_dump_then_04", 32, 0, {}, {37}, revu_dump_then_04InputFunc, revu_dump_then_04Implementations), \ + wfr::wfs::ActivityTemplate::atomic(39, "case_init_then_05", 5, 0, {40}, {6}, case_init_then_05InputFunc, case_init_then_05Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(40, "pFor01_then_05", 5, 0, {87}, {39}, pFor01_then_05InputFunc, pFor01_then_05OutputFunc, pFor01_then_05CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(41, "rams_makevfile_then_05", 40, 0, {42}, {}, rams_makevfile_then_05InputFunc, rams_makevfile_then_05Implementations), \ + wfr::wfs::ActivityTemplate::atomic(42, "rams_init_then_05", 40, 0, {43}, {41}, rams_init_then_05InputFunc, rams_init_then_05Implementations), \ + wfr::wfs::ActivityTemplate::atomic(43, "revu_compare_then_05", 40, 0, {44}, {42}, revu_compare_then_05InputFunc, revu_compare_then_05Implementations), \ + wfr::wfs::ActivityTemplate::atomic(44, "raver_then_05", 40, 0, {45}, {43}, raver_then_05InputFunc, raver_then_05Implementations), \ + wfr::wfs::ActivityTemplate::atomic(45, "rams_hist_then_05", 40, 0, {46}, {44}, rams_hist_then_05InputFunc, rams_hist_then_05Implementations), \ + wfr::wfs::ActivityTemplate::atomic(46, "revu_dump_then_05", 40, 0, {}, {45}, revu_dump_then_05InputFunc, revu_dump_then_05Implementations), \ + wfr::wfs::ActivityTemplate::atomic(47, "case_init_then_06", 5, 0, {48}, {6}, case_init_then_06InputFunc, case_init_then_06Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(48, "pFor01_then_06", 5, 0, {87}, {47}, pFor01_then_06InputFunc, pFor01_then_06OutputFunc, pFor01_then_06CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(49, "rams_makevfile_then_06", 48, 0, {50}, {}, rams_makevfile_then_06InputFunc, rams_makevfile_then_06Implementations), \ + wfr::wfs::ActivityTemplate::atomic(50, "rams_init_then_06", 48, 0, {51}, {49}, rams_init_then_06InputFunc, rams_init_then_06Implementations), \ + wfr::wfs::ActivityTemplate::atomic(51, "revu_compare_then_06", 48, 0, {52}, {50}, revu_compare_then_06InputFunc, revu_compare_then_06Implementations), \ + wfr::wfs::ActivityTemplate::atomic(52, "raver_then_06", 48, 0, {53}, {51}, raver_then_06InputFunc, raver_then_06Implementations), \ + wfr::wfs::ActivityTemplate::atomic(53, "rams_hist_then_06", 48, 0, {54}, {52}, rams_hist_then_06InputFunc, rams_hist_then_06Implementations), \ + wfr::wfs::ActivityTemplate::atomic(54, "revu_dump_then_06", 48, 0, {}, {53}, revu_dump_then_06InputFunc, revu_dump_then_06Implementations), \ + wfr::wfs::ActivityTemplate::atomic(55, "case_init_then_07", 5, 0, {56}, {6}, case_init_then_07InputFunc, case_init_then_07Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(56, "pFor01_then_07", 5, 0, {87}, {55}, pFor01_then_07InputFunc, pFor01_then_07OutputFunc, pFor01_then_07CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(57, "rams_makevfile_then_07", 56, 0, {58}, {}, rams_makevfile_then_07InputFunc, rams_makevfile_then_07Implementations), \ + wfr::wfs::ActivityTemplate::atomic(58, "rams_init_then_07", 56, 0, {59}, {57}, rams_init_then_07InputFunc, rams_init_then_07Implementations), \ + wfr::wfs::ActivityTemplate::atomic(59, "revu_compare_then_07", 56, 0, {60}, {58}, revu_compare_then_07InputFunc, revu_compare_then_07Implementations), \ + wfr::wfs::ActivityTemplate::atomic(60, "raver_then_07", 56, 0, {61}, {59}, raver_then_07InputFunc, raver_then_07Implementations), \ + wfr::wfs::ActivityTemplate::atomic(61, "rams_hist_then_07", 56, 0, {62}, {60}, rams_hist_then_07InputFunc, rams_hist_then_07Implementations), \ + wfr::wfs::ActivityTemplate::atomic(62, "revu_dump_then_07", 56, 0, {}, {61}, revu_dump_then_07InputFunc, revu_dump_then_07Implementations), \ + wfr::wfs::ActivityTemplate::atomic(63, "case_init_then_08", 5, 0, {64}, {6}, case_init_then_08InputFunc, case_init_then_08Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(64, "pFor01_then_08", 5, 0, {87}, {63}, pFor01_then_08InputFunc, pFor01_then_08OutputFunc, pFor01_then_08CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(65, "rams_makevfile_then_08", 64, 0, {66}, {}, rams_makevfile_then_08InputFunc, rams_makevfile_then_08Implementations), \ + wfr::wfs::ActivityTemplate::atomic(66, "rams_init_then_08", 64, 0, {67}, {65}, rams_init_then_08InputFunc, rams_init_then_08Implementations), \ + wfr::wfs::ActivityTemplate::atomic(67, "revu_compare_then_08", 64, 0, {68}, {66}, revu_compare_then_08InputFunc, revu_compare_then_08Implementations), \ + wfr::wfs::ActivityTemplate::atomic(68, "raver_then_08", 64, 0, {69}, {67}, raver_then_08InputFunc, raver_then_08Implementations), \ + wfr::wfs::ActivityTemplate::atomic(69, "rams_hist_then_08", 64, 0, {70}, {68}, rams_hist_then_08InputFunc, rams_hist_then_08Implementations), \ + wfr::wfs::ActivityTemplate::atomic(70, "revu_dump_then_08", 64, 0, {}, {69}, revu_dump_then_08InputFunc, revu_dump_then_08Implementations), \ + wfr::wfs::ActivityTemplate::atomic(71, "case_init_then_09", 5, 0, {72}, {6}, case_init_then_09InputFunc, case_init_then_09Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(72, "pFor01_then_09", 5, 0, {87}, {71}, pFor01_then_09InputFunc, pFor01_then_09OutputFunc, pFor01_then_09CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(73, "rams_makevfile_then_09", 72, 0, {74}, {}, rams_makevfile_then_09InputFunc, rams_makevfile_then_09Implementations), \ + wfr::wfs::ActivityTemplate::atomic(74, "rams_init_then_09", 72, 0, {75}, {73}, rams_init_then_09InputFunc, rams_init_then_09Implementations), \ + wfr::wfs::ActivityTemplate::atomic(75, "revu_compare_then_09", 72, 0, {76}, {74}, revu_compare_then_09InputFunc, revu_compare_then_09Implementations), \ + wfr::wfs::ActivityTemplate::atomic(76, "raver_then_09", 72, 0, {77}, {75}, raver_then_09InputFunc, raver_then_09Implementations), \ + wfr::wfs::ActivityTemplate::atomic(77, "rams_hist_then_09", 72, 0, {78}, {76}, rams_hist_then_09InputFunc, rams_hist_then_09Implementations), \ + wfr::wfs::ActivityTemplate::atomic(78, "revu_dump_then_09", 72, 0, {}, {77}, revu_dump_then_09InputFunc, revu_dump_then_09Implementations), \ + wfr::wfs::ActivityTemplate::atomic(79, "case_init_then_10", 5, 0, {80}, {6}, case_init_then_10InputFunc, case_init_then_10Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(80, "pFor01_then_10", 5, 0, {87}, {79}, pFor01_then_10InputFunc, pFor01_then_10OutputFunc, pFor01_then_10CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(81, "rams_makevfile_then_10", 80, 0, {82}, {}, rams_makevfile_then_10InputFunc, rams_makevfile_then_10Implementations), \ + wfr::wfs::ActivityTemplate::atomic(82, "rams_init_then_10", 80, 0, {83}, {81}, rams_init_then_10InputFunc, rams_init_then_10Implementations), \ + wfr::wfs::ActivityTemplate::atomic(83, "revu_compare_then_10", 80, 0, {84}, {82}, revu_compare_then_10InputFunc, revu_compare_then_10Implementations), \ + wfr::wfs::ActivityTemplate::atomic(84, "raver_then_10", 80, 0, {85}, {83}, raver_then_10InputFunc, raver_then_10Implementations), \ + wfr::wfs::ActivityTemplate::atomic(85, "rams_hist_then_10", 80, 0, {86}, {84}, rams_hist_then_10InputFunc, rams_hist_then_10Implementations), \ + wfr::wfs::ActivityTemplate::atomic(86, "revu_dump_then_10", 80, 0, {}, {85}, revu_dump_then_10InputFunc, revu_dump_then_10Implementations), \ + wfr::wfs::ActivityTemplate::assign(87, "helper03_then", 5, 0, {}, {72, 32, 64, 80, 40, 16, 24, 48, 56, 8}, helper03_thenInputFunc, helper03_thenExecFunc_0), \ + wfr::wfs::ActivityTemplate::forLoop(88, "pForEach01_else", 4, 1, {}, {}, pForEach01_elseInputFunc, pForEach01_elseOutputFunc, pForEach01_elseCounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::assign(89, "helper02_else", 88, 0, {114, 120, 138, 108, 126, 132, 90, 144, 96, 102}, {}, helper02_elseInputFunc, helper02_elseExecFunc_0), \ + wfr::wfs::ActivityTemplate::atomic(90, "case_init_else_01", 88, 0, {91}, {89}, case_init_else_01InputFunc, case_init_else_01Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(91, "pFor01_else_01", 88, 0, {150}, {90}, pFor01_else_01InputFunc, pFor01_else_01OutputFunc, pFor01_else_01CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(92, "rams_makevfile_else_01", 91, 0, {93}, {}, rams_makevfile_else_01InputFunc, rams_makevfile_else_01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(93, "rams_init_else_01", 91, 0, {94}, {92}, rams_init_else_01InputFunc, rams_init_else_01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(94, "revu_compare_else_01", 91, 0, {95}, {93}, revu_compare_else_01InputFunc, revu_compare_else_01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(95, "raver_else_01", 91, 0, {}, {94}, raver_else_01InputFunc, raver_else_01Implementations), \ + wfr::wfs::ActivityTemplate::atomic(96, "case_init_else_02", 88, 0, {97}, {89}, case_init_else_02InputFunc, case_init_else_02Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(97, "pFor01_else_02", 88, 0, {150}, {96}, pFor01_else_02InputFunc, pFor01_else_02OutputFunc, pFor01_else_02CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(98, "rams_makevfile_else_02", 97, 0, {99}, {}, rams_makevfile_else_02InputFunc, rams_makevfile_else_02Implementations), \ + wfr::wfs::ActivityTemplate::atomic(99, "rams_init_else_02", 97, 0, {100}, {98}, rams_init_else_02InputFunc, rams_init_else_02Implementations), \ + wfr::wfs::ActivityTemplate::atomic(100, "revu_compare_else_02", 97, 0, {101}, {99}, revu_compare_else_02InputFunc, revu_compare_else_02Implementations), \ + wfr::wfs::ActivityTemplate::atomic(101, "raver_else_02", 97, 0, {}, {100}, raver_else_02InputFunc, raver_else_02Implementations), \ + wfr::wfs::ActivityTemplate::atomic(102, "case_init_else_03", 88, 0, {103}, {89}, case_init_else_03InputFunc, case_init_else_03Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(103, "pFor01_else_03", 88, 0, {150}, {102}, pFor01_else_03InputFunc, pFor01_else_03OutputFunc, pFor01_else_03CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(104, "rams_makevfile_else_03", 103, 0, {105}, {}, rams_makevfile_else_03InputFunc, rams_makevfile_else_03Implementations), \ + wfr::wfs::ActivityTemplate::atomic(105, "rams_init_else_03", 103, 0, {106}, {104}, rams_init_else_03InputFunc, rams_init_else_03Implementations), \ + wfr::wfs::ActivityTemplate::atomic(106, "revu_compare_else_03", 103, 0, {107}, {105}, revu_compare_else_03InputFunc, revu_compare_else_03Implementations), \ + wfr::wfs::ActivityTemplate::atomic(107, "raver_else_03", 103, 0, {}, {106}, raver_else_03InputFunc, raver_else_03Implementations), \ + wfr::wfs::ActivityTemplate::atomic(108, "case_init_else_04", 88, 0, {109}, {89}, case_init_else_04InputFunc, case_init_else_04Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(109, "pFor01_else_04", 88, 0, {150}, {108}, pFor01_else_04InputFunc, pFor01_else_04OutputFunc, pFor01_else_04CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(110, "rams_makevfile_else_04", 109, 0, {111}, {}, rams_makevfile_else_04InputFunc, rams_makevfile_else_04Implementations), \ + wfr::wfs::ActivityTemplate::atomic(111, "rams_init_else_04", 109, 0, {112}, {110}, rams_init_else_04InputFunc, rams_init_else_04Implementations), \ + wfr::wfs::ActivityTemplate::atomic(112, "revu_compare_else_04", 109, 0, {113}, {111}, revu_compare_else_04InputFunc, revu_compare_else_04Implementations), \ + wfr::wfs::ActivityTemplate::atomic(113, "raver_else_04", 109, 0, {}, {112}, raver_else_04InputFunc, raver_else_04Implementations), \ + wfr::wfs::ActivityTemplate::atomic(114, "case_init_else_05", 88, 0, {115}, {89}, case_init_else_05InputFunc, case_init_else_05Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(115, "pFor01_else_05", 88, 0, {150}, {114}, pFor01_else_05InputFunc, pFor01_else_05OutputFunc, pFor01_else_05CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(116, "rams_makevfile_else_05", 115, 0, {117}, {}, rams_makevfile_else_05InputFunc, rams_makevfile_else_05Implementations), \ + wfr::wfs::ActivityTemplate::atomic(117, "rams_init_else_05", 115, 0, {118}, {116}, rams_init_else_05InputFunc, rams_init_else_05Implementations), \ + wfr::wfs::ActivityTemplate::atomic(118, "revu_compare_else_05", 115, 0, {119}, {117}, revu_compare_else_05InputFunc, revu_compare_else_05Implementations), \ + wfr::wfs::ActivityTemplate::atomic(119, "raver_else_05", 115, 0, {}, {118}, raver_else_05InputFunc, raver_else_05Implementations), \ + wfr::wfs::ActivityTemplate::atomic(120, "case_init_else_06", 88, 0, {121}, {89}, case_init_else_06InputFunc, case_init_else_06Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(121, "pFor01_else_06", 88, 0, {150}, {120}, pFor01_else_06InputFunc, pFor01_else_06OutputFunc, pFor01_else_06CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(122, "rams_makevfile_else_06", 121, 0, {123}, {}, rams_makevfile_else_06InputFunc, rams_makevfile_else_06Implementations), \ + wfr::wfs::ActivityTemplate::atomic(123, "rams_init_else_06", 121, 0, {124}, {122}, rams_init_else_06InputFunc, rams_init_else_06Implementations), \ + wfr::wfs::ActivityTemplate::atomic(124, "revu_compare_else_06", 121, 0, {125}, {123}, revu_compare_else_06InputFunc, revu_compare_else_06Implementations), \ + wfr::wfs::ActivityTemplate::atomic(125, "raver_else_06", 121, 0, {}, {124}, raver_else_06InputFunc, raver_else_06Implementations), \ + wfr::wfs::ActivityTemplate::atomic(126, "case_init_else_07", 88, 0, {127}, {89}, case_init_else_07InputFunc, case_init_else_07Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(127, "pFor01_else_07", 88, 0, {150}, {126}, pFor01_else_07InputFunc, pFor01_else_07OutputFunc, pFor01_else_07CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(128, "rams_makevfile_else_07", 127, 0, {129}, {}, rams_makevfile_else_07InputFunc, rams_makevfile_else_07Implementations), \ + wfr::wfs::ActivityTemplate::atomic(129, "rams_init_else_07", 127, 0, {130}, {128}, rams_init_else_07InputFunc, rams_init_else_07Implementations), \ + wfr::wfs::ActivityTemplate::atomic(130, "revu_compare_else_07", 127, 0, {131}, {129}, revu_compare_else_07InputFunc, revu_compare_else_07Implementations), \ + wfr::wfs::ActivityTemplate::atomic(131, "raver_else_07", 127, 0, {}, {130}, raver_else_07InputFunc, raver_else_07Implementations), \ + wfr::wfs::ActivityTemplate::atomic(132, "case_init_else_08", 88, 0, {133}, {89}, case_init_else_08InputFunc, case_init_else_08Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(133, "pFor01_else_08", 88, 0, {150}, {132}, pFor01_else_08InputFunc, pFor01_else_08OutputFunc, pFor01_else_08CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(134, "rams_makevfile_else_08", 133, 0, {135}, {}, rams_makevfile_else_08InputFunc, rams_makevfile_else_08Implementations), \ + wfr::wfs::ActivityTemplate::atomic(135, "rams_init_else_08", 133, 0, {136}, {134}, rams_init_else_08InputFunc, rams_init_else_08Implementations), \ + wfr::wfs::ActivityTemplate::atomic(136, "revu_compare_else_08", 133, 0, {137}, {135}, revu_compare_else_08InputFunc, revu_compare_else_08Implementations), \ + wfr::wfs::ActivityTemplate::atomic(137, "raver_else_08", 133, 0, {}, {136}, raver_else_08InputFunc, raver_else_08Implementations), \ + wfr::wfs::ActivityTemplate::atomic(138, "case_init_else_09", 88, 0, {139}, {89}, case_init_else_09InputFunc, case_init_else_09Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(139, "pFor01_else_09", 88, 0, {150}, {138}, pFor01_else_09InputFunc, pFor01_else_09OutputFunc, pFor01_else_09CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(140, "rams_makevfile_else_09", 139, 0, {141}, {}, rams_makevfile_else_09InputFunc, rams_makevfile_else_09Implementations), \ + wfr::wfs::ActivityTemplate::atomic(141, "rams_init_else_09", 139, 0, {142}, {140}, rams_init_else_09InputFunc, rams_init_else_09Implementations), \ + wfr::wfs::ActivityTemplate::atomic(142, "revu_compare_else_09", 139, 0, {143}, {141}, revu_compare_else_09InputFunc, revu_compare_else_09Implementations), \ + wfr::wfs::ActivityTemplate::atomic(143, "raver_else_09", 139, 0, {}, {142}, raver_else_09InputFunc, raver_else_09Implementations), \ + wfr::wfs::ActivityTemplate::atomic(144, "case_init_else_10", 88, 0, {145}, {89}, case_init_else_10InputFunc, case_init_else_10Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(145, "pFor01_else_10", 88, 0, {150}, {144}, pFor01_else_10InputFunc, pFor01_else_10OutputFunc, pFor01_else_10CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(146, "rams_makevfile_else_10", 145, 0, {147}, {}, rams_makevfile_else_10InputFunc, rams_makevfile_else_10Implementations), \ + wfr::wfs::ActivityTemplate::atomic(147, "rams_init_else_10", 145, 0, {148}, {146}, rams_init_else_10InputFunc, rams_init_else_10Implementations), \ + wfr::wfs::ActivityTemplate::atomic(148, "revu_compare_else_10", 145, 0, {149}, {147}, revu_compare_else_10InputFunc, revu_compare_else_10Implementations), \ + wfr::wfs::ActivityTemplate::atomic(149, "raver_else_10", 145, 0, {}, {148}, raver_else_10InputFunc, raver_else_10Implementations), \ + wfr::wfs::ActivityTemplate::assign(150, "helper03_else", 88, 0, {}, {121, 109, 115, 127, 91, 97, 139, 145, 103, 133}, helper03_elseInputFunc, helper03_elseExecFunc_0), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + + std::string inputFile = "input.file"; + long chunkCount = 10; + long pForIterations = 10; + bool ifCondition = true; + bool isHelp = false; + boost::program_options::options_description opts("MeteoAG Options"); + opts.add_options() + ("help", "Print help message.") + ("inputchunks", boost::program_options::value(), "Number of input chunks.") + ("pforiterations", boost::program_options::value(), "Number of pFor iterations.") + ("ifcondition", boost::program_options::value(), "If condition."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("inputchunks")) { + chunkCount = vm["inputchunks"].as(); + } + if (vm.count("pforiterations")) { + pForIterations = vm["pforiterations"].as(); + } + if (vm.count("ifcondition")) { + ifCondition = vm["ifcondition"].as(); + } + std::cerr << "inputChunks = " << chunkCount << std::endl; + std::cerr << "pForIterations = " << pForIterations << std::endl; + std::cerr << "IfCondition = " << ifCondition << std::endl; + } + wfInput.input_file.setValue("input_file"); + wfInput.chunk_count.setValue(chunkCount); + wfInput.pForIterations.setValue(pForIterations); + wfInput.if_condition.setValue(ifCondition); + + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} diff --git a/src/17.meteoag03/meteoag03.h b/src/17.meteoag03/meteoag03.h new file mode 100644 index 0000000..5da5f59 --- /dev/null +++ b/src/17.meteoag03/meteoag03.h @@ -0,0 +1,1580 @@ +#ifndef METEOAG03_H +#define METEOAG03_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRFILE(input_file) \ + WFR_PORT_MEMBER_IWIRINT(chunk_count) \ + WFR_PORT_MEMBER_IWIRBOOL(if_condition) \ + WFR_PORT_MEMBER_IWIRINT(pForIterations) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 2) \ +) + +/* simulation_init INSTRUCT */ +WFR_PORT_STRUCT( simulation_init_in, 3, \ + WFR_PORT_MEMBER_IWIRFILE(input_file) \ + WFR_PORT_MEMBER_IWIRINT(chunk_count) \ +) + +/* simulation_init OUTSTRUCT */ +WFR_PORT_STRUCT( simulation_init_out, 4, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* helper01 INSTRUCT */ +WFR_PORT_STRUCT( helper01_in, 5, \ + WFR_PORT_MEMBER_IWIRINT(chunk_count) \ +) + +/* helper01 OUTSTRUCT */ +WFR_PORT_STRUCT( helper01_out, 6, \ + WFR_PORT_MEMBER_IWIRINT(pForEachIterations) \ +) + +/* if01 INSTRUCT */ +WFR_PORT_STRUCT( if01_in, 7, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRINT(pForEachIterations) \ + WFR_PORT_MEMBER_IWIRINT(pForIterations) \ + WFR_PORT_MEMBER_IWIRBOOL(if_condition) \ +) + +/* if01 OUTSTRUCT */ +WFR_PORT_STRUCT( if01_out, 8, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 2) \ +) + +/* pForEach01_then INSTRUCT */ +WFR_PORT_STRUCT( pForEach01_then_in, 9, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRINT(pForIterations) \ + WFR_PORT_MEMBER_IWIRINT(counter_to) \ +) + +/* pForEach01_then OUTSTRUCT */ +WFR_PORT_STRUCT( pForEach01_then_out, 10, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 2) \ +) + +/* helper02_then INSTRUCT */ +WFR_PORT_STRUCT( helper02_then_in, 11, \ + WFR_PORT_MEMBER_IWIRINT(counter) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* helper02_then OUTSTRUCT */ +WFR_PORT_STRUCT( helper02_then_out, 12, \ + WFR_PORT_MEMBER_IWIRFILE(input01) \ + WFR_PORT_MEMBER_IWIRFILE(input02) \ + WFR_PORT_MEMBER_IWIRFILE(input03) \ + WFR_PORT_MEMBER_IWIRFILE(input04) \ + WFR_PORT_MEMBER_IWIRFILE(input05) \ + WFR_PORT_MEMBER_IWIRFILE(input06) \ + WFR_PORT_MEMBER_IWIRFILE(input07) \ + WFR_PORT_MEMBER_IWIRFILE(input08) \ + WFR_PORT_MEMBER_IWIRFILE(input09) \ + WFR_PORT_MEMBER_IWIRFILE(input10) \ +) + +/* case_init_then_01 INSTRUCT */ +WFR_PORT_STRUCT( case_init_then_01_in, 13, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_then_01 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_then_01_out, 14, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_then_01 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_01_in, 15, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_then_01 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_01_out, 16, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_then_01 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_01_in, 17, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_then_01 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_01_out, 18, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_then_01 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_01_in, 19, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_then_01 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_01_out, 20, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_then_01 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_01_in, 21, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_then_01 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_01_out, 22, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_then_01 INSTRUCT */ +WFR_PORT_STRUCT( raver_then_01_in, 23, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_then_01 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_then_01_out, 24, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_hist_then_01 INSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_01_in, 25, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_hist_then_01 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_01_out, 26, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_dump_then_01 INSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_01_in, 27, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_dump_then_01 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_01_out, 28, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_then_02 INSTRUCT */ +WFR_PORT_STRUCT( case_init_then_02_in, 29, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_then_02 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_then_02_out, 30, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_then_02 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_02_in, 31, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_then_02 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_02_out, 32, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_then_02 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_02_in, 33, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_then_02 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_02_out, 34, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_then_02 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_02_in, 35, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_then_02 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_02_out, 36, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_then_02 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_02_in, 37, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_then_02 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_02_out, 38, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_then_02 INSTRUCT */ +WFR_PORT_STRUCT( raver_then_02_in, 39, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_then_02 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_then_02_out, 40, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_hist_then_02 INSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_02_in, 41, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_hist_then_02 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_02_out, 42, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_dump_then_02 INSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_02_in, 43, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_dump_then_02 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_02_out, 44, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_then_03 INSTRUCT */ +WFR_PORT_STRUCT( case_init_then_03_in, 45, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_then_03 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_then_03_out, 46, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_then_03 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_03_in, 47, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_then_03 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_03_out, 48, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_then_03 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_03_in, 49, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_then_03 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_03_out, 50, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_then_03 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_03_in, 51, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_then_03 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_03_out, 52, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_then_03 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_03_in, 53, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_then_03 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_03_out, 54, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_then_03 INSTRUCT */ +WFR_PORT_STRUCT( raver_then_03_in, 55, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_then_03 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_then_03_out, 56, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_hist_then_03 INSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_03_in, 57, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_hist_then_03 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_03_out, 58, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_dump_then_03 INSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_03_in, 59, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_dump_then_03 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_03_out, 60, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_then_04 INSTRUCT */ +WFR_PORT_STRUCT( case_init_then_04_in, 61, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_then_04 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_then_04_out, 62, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_then_04 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_04_in, 63, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_then_04 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_04_out, 64, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_then_04 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_04_in, 65, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_then_04 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_04_out, 66, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_then_04 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_04_in, 67, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_then_04 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_04_out, 68, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_then_04 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_04_in, 69, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_then_04 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_04_out, 70, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_then_04 INSTRUCT */ +WFR_PORT_STRUCT( raver_then_04_in, 71, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_then_04 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_then_04_out, 72, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_hist_then_04 INSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_04_in, 73, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_hist_then_04 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_04_out, 74, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_dump_then_04 INSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_04_in, 75, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_dump_then_04 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_04_out, 76, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_then_05 INSTRUCT */ +WFR_PORT_STRUCT( case_init_then_05_in, 77, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_then_05 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_then_05_out, 78, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_then_05 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_05_in, 79, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_then_05 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_05_out, 80, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_then_05 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_05_in, 81, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_then_05 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_05_out, 82, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_then_05 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_05_in, 83, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_then_05 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_05_out, 84, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_then_05 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_05_in, 85, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_then_05 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_05_out, 86, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_then_05 INSTRUCT */ +WFR_PORT_STRUCT( raver_then_05_in, 87, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_then_05 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_then_05_out, 88, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_hist_then_05 INSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_05_in, 89, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_hist_then_05 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_05_out, 90, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_dump_then_05 INSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_05_in, 91, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_dump_then_05 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_05_out, 92, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_then_06 INSTRUCT */ +WFR_PORT_STRUCT( case_init_then_06_in, 93, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_then_06 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_then_06_out, 94, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_then_06 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_06_in, 95, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_then_06 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_06_out, 96, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_then_06 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_06_in, 97, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_then_06 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_06_out, 98, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_then_06 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_06_in, 99, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_then_06 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_06_out, 100, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_then_06 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_06_in, 101, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_then_06 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_06_out, 102, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_then_06 INSTRUCT */ +WFR_PORT_STRUCT( raver_then_06_in, 103, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_then_06 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_then_06_out, 104, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_hist_then_06 INSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_06_in, 105, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_hist_then_06 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_06_out, 106, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_dump_then_06 INSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_06_in, 107, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_dump_then_06 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_06_out, 108, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_then_07 INSTRUCT */ +WFR_PORT_STRUCT( case_init_then_07_in, 109, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_then_07 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_then_07_out, 110, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_then_07 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_07_in, 111, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_then_07 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_07_out, 112, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_then_07 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_07_in, 113, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_then_07 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_07_out, 114, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_then_07 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_07_in, 115, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_then_07 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_07_out, 116, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_then_07 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_07_in, 117, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_then_07 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_07_out, 118, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_then_07 INSTRUCT */ +WFR_PORT_STRUCT( raver_then_07_in, 119, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_then_07 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_then_07_out, 120, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_hist_then_07 INSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_07_in, 121, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_hist_then_07 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_07_out, 122, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_dump_then_07 INSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_07_in, 123, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_dump_then_07 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_07_out, 124, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_then_08 INSTRUCT */ +WFR_PORT_STRUCT( case_init_then_08_in, 125, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_then_08 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_then_08_out, 126, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_then_08 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_08_in, 127, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_then_08 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_08_out, 128, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_then_08 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_08_in, 129, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_then_08 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_08_out, 130, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_then_08 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_08_in, 131, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_then_08 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_08_out, 132, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_then_08 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_08_in, 133, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_then_08 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_08_out, 134, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_then_08 INSTRUCT */ +WFR_PORT_STRUCT( raver_then_08_in, 135, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_then_08 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_then_08_out, 136, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_hist_then_08 INSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_08_in, 137, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_hist_then_08 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_08_out, 138, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_dump_then_08 INSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_08_in, 139, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_dump_then_08 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_08_out, 140, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_then_09 INSTRUCT */ +WFR_PORT_STRUCT( case_init_then_09_in, 141, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_then_09 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_then_09_out, 142, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_then_09 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_09_in, 143, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_then_09 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_09_out, 144, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_then_09 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_09_in, 145, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_then_09 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_09_out, 146, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_then_09 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_09_in, 147, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_then_09 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_09_out, 148, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_then_09 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_09_in, 149, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_then_09 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_09_out, 150, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_then_09 INSTRUCT */ +WFR_PORT_STRUCT( raver_then_09_in, 151, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_then_09 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_then_09_out, 152, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_hist_then_09 INSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_09_in, 153, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_hist_then_09 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_09_out, 154, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_dump_then_09 INSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_09_in, 155, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_dump_then_09 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_09_out, 156, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_then_10 INSTRUCT */ +WFR_PORT_STRUCT( case_init_then_10_in, 157, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_then_10 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_then_10_out, 158, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_then_10 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_10_in, 159, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_then_10 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_then_10_out, 160, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_then_10 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_10_in, 161, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_then_10 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_then_10_out, 162, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_then_10 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_10_in, 163, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_then_10 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_then_10_out, 164, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_then_10 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_10_in, 165, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_then_10 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_then_10_out, 166, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_then_10 INSTRUCT */ +WFR_PORT_STRUCT( raver_then_10_in, 167, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_then_10 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_then_10_out, 168, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_hist_then_10 INSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_10_in, 169, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_hist_then_10 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_hist_then_10_out, 170, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_dump_then_10 INSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_10_in, 171, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_dump_then_10 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_dump_then_10_out, 172, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* helper03_then INSTRUCT */ +WFR_PORT_STRUCT( helper03_then_in, 173, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output01, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output02, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output03, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output04, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output05, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output06, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output07, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output08, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output09, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output10, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* helper03_then OUTSTRUCT */ +WFR_PORT_STRUCT( helper03_then_out, 174, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* pForEach01_else INSTRUCT */ +WFR_PORT_STRUCT( pForEach01_else_in, 175, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRINT(pForIterations) \ + WFR_PORT_MEMBER_IWIRINT(counter_to) \ +) + +/* pForEach01_else OUTSTRUCT */ +WFR_PORT_STRUCT( pForEach01_else_out, 176, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 2) \ +) + +/* helper02_else INSTRUCT */ +WFR_PORT_STRUCT( helper02_else_in, 177, \ + WFR_PORT_MEMBER_IWIRINT(counter) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* helper02_else OUTSTRUCT */ +WFR_PORT_STRUCT( helper02_else_out, 178, \ + WFR_PORT_MEMBER_IWIRFILE(input01) \ + WFR_PORT_MEMBER_IWIRFILE(input02) \ + WFR_PORT_MEMBER_IWIRFILE(input03) \ + WFR_PORT_MEMBER_IWIRFILE(input04) \ + WFR_PORT_MEMBER_IWIRFILE(input05) \ + WFR_PORT_MEMBER_IWIRFILE(input06) \ + WFR_PORT_MEMBER_IWIRFILE(input07) \ + WFR_PORT_MEMBER_IWIRFILE(input08) \ + WFR_PORT_MEMBER_IWIRFILE(input09) \ + WFR_PORT_MEMBER_IWIRFILE(input10) \ +) + +/* case_init_else_01 INSTRUCT */ +WFR_PORT_STRUCT( case_init_else_01_in, 179, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_else_01 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_else_01_out, 180, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_else_01 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_01_in, 181, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_else_01 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_01_out, 182, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_else_01 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_01_in, 183, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_else_01 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_01_out, 184, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_else_01 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_01_in, 185, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_else_01 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_01_out, 186, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_else_01 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_01_in, 187, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_else_01 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_01_out, 188, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_else_01 INSTRUCT */ +WFR_PORT_STRUCT( raver_else_01_in, 189, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_else_01 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_else_01_out, 190, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_else_02 INSTRUCT */ +WFR_PORT_STRUCT( case_init_else_02_in, 191, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_else_02 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_else_02_out, 192, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_else_02 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_02_in, 193, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_else_02 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_02_out, 194, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_else_02 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_02_in, 195, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_else_02 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_02_out, 196, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_else_02 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_02_in, 197, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_else_02 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_02_out, 198, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_else_02 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_02_in, 199, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_else_02 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_02_out, 200, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_else_02 INSTRUCT */ +WFR_PORT_STRUCT( raver_else_02_in, 201, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_else_02 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_else_02_out, 202, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_else_03 INSTRUCT */ +WFR_PORT_STRUCT( case_init_else_03_in, 203, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_else_03 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_else_03_out, 204, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_else_03 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_03_in, 205, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_else_03 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_03_out, 206, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_else_03 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_03_in, 207, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_else_03 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_03_out, 208, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_else_03 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_03_in, 209, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_else_03 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_03_out, 210, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_else_03 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_03_in, 211, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_else_03 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_03_out, 212, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_else_03 INSTRUCT */ +WFR_PORT_STRUCT( raver_else_03_in, 213, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_else_03 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_else_03_out, 214, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_else_04 INSTRUCT */ +WFR_PORT_STRUCT( case_init_else_04_in, 215, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_else_04 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_else_04_out, 216, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_else_04 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_04_in, 217, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_else_04 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_04_out, 218, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_else_04 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_04_in, 219, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_else_04 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_04_out, 220, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_else_04 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_04_in, 221, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_else_04 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_04_out, 222, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_else_04 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_04_in, 223, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_else_04 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_04_out, 224, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_else_04 INSTRUCT */ +WFR_PORT_STRUCT( raver_else_04_in, 225, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_else_04 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_else_04_out, 226, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_else_05 INSTRUCT */ +WFR_PORT_STRUCT( case_init_else_05_in, 227, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_else_05 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_else_05_out, 228, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_else_05 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_05_in, 229, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_else_05 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_05_out, 230, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_else_05 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_05_in, 231, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_else_05 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_05_out, 232, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_else_05 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_05_in, 233, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_else_05 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_05_out, 234, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_else_05 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_05_in, 235, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_else_05 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_05_out, 236, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_else_05 INSTRUCT */ +WFR_PORT_STRUCT( raver_else_05_in, 237, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_else_05 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_else_05_out, 238, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_else_06 INSTRUCT */ +WFR_PORT_STRUCT( case_init_else_06_in, 239, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_else_06 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_else_06_out, 240, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_else_06 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_06_in, 241, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_else_06 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_06_out, 242, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_else_06 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_06_in, 243, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_else_06 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_06_out, 244, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_else_06 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_06_in, 245, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_else_06 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_06_out, 246, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_else_06 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_06_in, 247, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_else_06 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_06_out, 248, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_else_06 INSTRUCT */ +WFR_PORT_STRUCT( raver_else_06_in, 249, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_else_06 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_else_06_out, 250, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_else_07 INSTRUCT */ +WFR_PORT_STRUCT( case_init_else_07_in, 251, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_else_07 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_else_07_out, 252, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_else_07 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_07_in, 253, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_else_07 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_07_out, 254, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_else_07 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_07_in, 255, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_else_07 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_07_out, 256, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_else_07 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_07_in, 257, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_else_07 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_07_out, 258, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_else_07 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_07_in, 259, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_else_07 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_07_out, 260, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_else_07 INSTRUCT */ +WFR_PORT_STRUCT( raver_else_07_in, 261, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_else_07 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_else_07_out, 262, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_else_08 INSTRUCT */ +WFR_PORT_STRUCT( case_init_else_08_in, 263, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_else_08 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_else_08_out, 264, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_else_08 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_08_in, 265, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_else_08 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_08_out, 266, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_else_08 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_08_in, 267, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_else_08 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_08_out, 268, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_else_08 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_08_in, 269, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_else_08 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_08_out, 270, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_else_08 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_08_in, 271, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_else_08 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_08_out, 272, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_else_08 INSTRUCT */ +WFR_PORT_STRUCT( raver_else_08_in, 273, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_else_08 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_else_08_out, 274, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_else_09 INSTRUCT */ +WFR_PORT_STRUCT( case_init_else_09_in, 275, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_else_09 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_else_09_out, 276, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_else_09 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_09_in, 277, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_else_09 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_09_out, 278, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_else_09 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_09_in, 279, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_else_09 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_09_out, 280, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_else_09 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_09_in, 281, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_else_09 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_09_out, 282, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_else_09 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_09_in, 283, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_else_09 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_09_out, 284, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_else_09 INSTRUCT */ +WFR_PORT_STRUCT( raver_else_09_in, 285, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_else_09 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_else_09_out, 286, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* case_init_else_10 INSTRUCT */ +WFR_PORT_STRUCT( case_init_else_10_in, 287, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* case_init_else_10 OUTSTRUCT */ +WFR_PORT_STRUCT( case_init_else_10_out, 288, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* pFor01_else_10 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_10_in, 289, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter_to) \ +) + +/* pFor01_else_10 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_else_10_out, 290, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* rams_makevfile_else_10 INSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_10_in, 291, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_makevfile_else_10 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_makevfile_else_10_out, 292, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* rams_init_else_10 INSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_10_in, 293, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* rams_init_else_10 OUTSTRUCT */ +WFR_PORT_STRUCT( rams_init_else_10_out, 294, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* revu_compare_else_10 INSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_10_in, 295, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* revu_compare_else_10 OUTSTRUCT */ +WFR_PORT_STRUCT( revu_compare_else_10_out, 296, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* raver_else_10 INSTRUCT */ +WFR_PORT_STRUCT( raver_else_10_in, 297, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* raver_else_10 OUTSTRUCT */ +WFR_PORT_STRUCT( raver_else_10_out, 298, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* helper03_else INSTRUCT */ +WFR_PORT_STRUCT( helper03_else_in, 299, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output01, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output02, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output03, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output04, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output05, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output06, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output07, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output08, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output09, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output10, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* helper03_else OUTSTRUCT */ +WFR_PORT_STRUCT( helper03_else_out, 300, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* METEOAG03_H */ diff --git a/src/18.blast01/CMakeLists.txt b/src/18.blast01/CMakeLists.txt new file mode 100644 index 0000000..c5771c7 --- /dev/null +++ b/src/18.blast01/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(blast01 C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin blast01.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/18.blast01/blast01.cpp b/src/18.blast01/blast01.cpp new file mode 100644 index 0000000..88e22e1 --- /dev/null +++ b/src/18.blast01/blast01.cpp @@ -0,0 +1,316 @@ +#include "blast01.h" +#include +#include +#include +#include + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_CHILD_OUTBUFFER_GET(a1out, finish_job_out, a1, 8, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->result, a1out->result)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->result.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(split_inputsInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, split_inputs_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_file, a1in->input_file)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->chunk_count, a1in->chunk_count)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input_file.isReady() && sin->chunk_count.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(split_inputsExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, split_inputs_in); + WFR_SELF_OUTBUFFER_INIT(sout, split_inputs_out); + WFR_PORT_INIT_COLLECTION(sout->input_chunks); + + EXECUTE_SIMULATION_MODE + for (long i = 0; i < sin->chunk_count.getValue(); ++i) { + sout->input_chunks.setEntryValue(i, "input_chunk"); + } + sout->input_chunks.setFinalised(true); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pForEach01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pForEach01_in); + WFR_PORT_INIT_COLLECTION(sin->input_chunks); + WFR_PRED_OUTBUFFER_GET(a1in, split_inputs_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_chunks, a1in->input_chunks)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pForEach01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pForEach01_out); + WFR_PORT_INIT_COLLECTION(sout->output); + WFR_PORT_INIT_COLLECTION(sout->error); + WFR_PORT_INIT_COLLECTION(sout->total); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, distributed_script_out, output, 4); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->error, distributed_script_out, error, 4); + WFR_LOOP_FINALIZE_COLLECTION(sout, error); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->total, distributed_script_out, total, 4); + WFR_LOOP_FINALIZE_COLLECTION(sout, total); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady() && sout->error.isReady() && sout->total.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pForEach01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pForEach01_in); + if (sin != nullptr && sin->input_chunks.isReady() && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution) { + wfr_size_t minLoopElementcount = std::min({sin->input_chunks.getSize()}); + WFR_SELF_SETITERATIONCOUNT(minLoopElementcount); + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(distributed_scriptInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, distributed_script_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input_chunks.getEntry(WFR_SELF_GETITERATIONID()))); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(distributed_scriptExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, distributed_script_in); + WFR_SELF_OUTBUFFER_INIT(sout, distributed_script_out); + + EXECUTE_SIMULATION_MODE + sout->output.setValue("output.file"); + sout->error.setValue("error.file"); + sout->total.setValue("total.file"); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(cat_outputInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, cat_output_in); + WFR_PORT_INIT_COLLECTION(sin->input); + WFR_PRED_OUTBUFFER_GET(a1in, pForEach01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(cat_outputExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, cat_output_in); + WFR_SELF_OUTBUFFER_INIT(sout, cat_output_out); + + auto sleeptime = sin->input.getSize(); // per file the original code roughly needed 0.7 ms (let's round that to 1 ms). + std::this_thread::sleep_for(std::chrono::milliseconds((long int)sleeptime)); + sout->output.setValue("cat_output.file"); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(cat_errorInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, cat_error_in); + WFR_PORT_INIT_COLLECTION(sin->input); + WFR_PRED_OUTBUFFER_GET(a1in, pForEach01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->error)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(cat_errorExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, cat_error_in); + WFR_SELF_OUTBUFFER_INIT(sout, cat_error_out); + + auto sleeptime = sin->input.getSize(); // per file the original code roughly needed 0.7 ms (let's round that to 1 ms). + std::this_thread::sleep_for(std::chrono::milliseconds((long int)sleeptime)); + sout->output.setValue("cat_output.file"); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(cat_totalInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, cat_total_in); + WFR_PORT_INIT_COLLECTION(sin->input); + WFR_PRED_OUTBUFFER_GET(a1in, pForEach01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->total)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(cat_totalExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, cat_total_in); + WFR_SELF_OUTBUFFER_INIT(sout, cat_total_out); + + auto sleeptime = sin->input.getSize(); // per file the original code roughly needed 0.7 ms (let's round that to 1 ms). + std::this_thread::sleep_for(std::chrono::milliseconds((long int)sleeptime)); + sout->output.setValue("cat_output.file"); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(finish_jobInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, finish_job_in); + WFR_PRED_OUTBUFFER_GET(a1in, cat_total_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->total, a1in->output)); + } + WFR_PRED_OUTBUFFER_GET(a2in, cat_error_out, a2, 1); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->error, a2in->output)); + } + WFR_PRED_OUTBUFFER_GET(a3in, cat_output_out, a3, 2); + if (a3in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output, a3in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->output.isReady() && sin->error.isReady() && sin->total.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(finish_jobExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, finish_job_in); + WFR_SELF_OUTBUFFER_INIT(sout, finish_job_out); + + EXECUTE_SIMULATION_MODE + sout->result.setValue("result.file"); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( split_inputsImplementations, "split_inputsImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(split_inputsExecFunc_0, "split_inputsExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( distributed_scriptImplementations, "distributed_scriptImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(distributed_scriptExecFunc_0, "distributed_scriptExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( cat_outputImplementations, "cat_outputImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(cat_outputExecFunc_0, "cat_outputExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( cat_errorImplementations, "cat_errorImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(cat_errorExecFunc_0, "cat_errorExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( cat_totalImplementations, "cat_totalImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(cat_totalExecFunc_0, "cat_totalExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( finish_jobImplementations, "finish_jobImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(finish_jobExecFunc_0, "finish_jobExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "Blast", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::atomic(2, "split_inputs", 1, 0, {3}, {}, split_inputsInputFunc, split_inputsImplementations), \ + wfr::wfs::ActivityTemplate::forLoop(3, "pForEach01", 1, 0, {7, 6, 5}, {2}, pForEach01InputFunc, pForEach01OutputFunc, pForEach01CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(4, "distributed_script", 3, 0, {}, {}, distributed_scriptInputFunc, distributed_scriptImplementations), \ + wfr::wfs::ActivityTemplate::atomic(5, "cat_output", 1, 0, {8}, {3}, cat_outputInputFunc, cat_outputImplementations), \ + wfr::wfs::ActivityTemplate::atomic(6, "cat_error", 1, 0, {8}, {3}, cat_errorInputFunc, cat_errorImplementations), \ + wfr::wfs::ActivityTemplate::atomic(7, "cat_total", 1, 0, {8}, {3}, cat_totalInputFunc, cat_totalImplementations), \ + wfr::wfs::ActivityTemplate::atomic(8, "finish_job", 1, 0, {}, {7, 6, 5}, finish_jobInputFunc, finish_jobImplementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + + long chunkCount = 10; + bool isHelp = false; + boost::program_options::options_description opts("MeteoAG Options"); + opts.add_options() + ("help", "Print help message.") + ("inputchunks", boost::program_options::value(), "Number of input chunks."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("inputchunks")) { + chunkCount = vm["inputchunks"].as(); + } + std::cerr << "inputChunks = " << chunkCount << std::endl; + } + wfInput.input_file.setValue("input_file"); + wfInput.chunk_count.setValue(chunkCount); + + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} diff --git a/src/18.blast01/blast01.h b/src/18.blast01/blast01.h new file mode 100644 index 0000000..6cc90e0 --- /dev/null +++ b/src/18.blast01/blast01.h @@ -0,0 +1,99 @@ +#ifndef BLAST01_H +#define BLAST01_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRFILE(input_file) \ + WFR_PORT_MEMBER_IWIRINT(chunk_count) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRFILE(result) \ +) + +/* split_inputs INSTRUCT */ +WFR_PORT_STRUCT( split_inputs_in, 3, \ + WFR_PORT_MEMBER_IWIRFILE(input_file) \ + WFR_PORT_MEMBER_IWIRINT(chunk_count) \ +) + +/* split_inputs OUTSTRUCT */ +WFR_PORT_STRUCT( split_inputs_out, 4, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* pForEach01 INSTRUCT */ +WFR_PORT_STRUCT( pForEach01_in, 5, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* pForEach01 OUTSTRUCT */ +WFR_PORT_STRUCT( pForEach01_out, 6, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(error, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(total, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* distributed_script INSTRUCT */ +WFR_PORT_STRUCT( distributed_script_in, 7, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* distributed_script OUTSTRUCT */ +WFR_PORT_STRUCT( distributed_script_out, 8, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ + WFR_PORT_MEMBER_IWIRFILE(error) \ + WFR_PORT_MEMBER_IWIRFILE(total) \ +) + +/* cat_output INSTRUCT */ +WFR_PORT_STRUCT( cat_output_in, 9, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* cat_output OUTSTRUCT */ +WFR_PORT_STRUCT( cat_output_out, 10, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* cat_error INSTRUCT */ +WFR_PORT_STRUCT( cat_error_in, 11, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* cat_error OUTSTRUCT */ +WFR_PORT_STRUCT( cat_error_out, 12, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* cat_total INSTRUCT */ +WFR_PORT_STRUCT( cat_total_in, 13, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* cat_total OUTSTRUCT */ +WFR_PORT_STRUCT( cat_total_out, 14, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* finish_job INSTRUCT */ +WFR_PORT_STRUCT( finish_job_in, 15, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ + WFR_PORT_MEMBER_IWIRFILE(error) \ + WFR_PORT_MEMBER_IWIRFILE(total) \ +) + +/* finish_job OUTSTRUCT */ +WFR_PORT_STRUCT( finish_job_out, 16, \ + WFR_PORT_MEMBER_IWIRFILE(result) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* BLAST01_H */ diff --git a/src/19.blast02/CMakeLists.txt b/src/19.blast02/CMakeLists.txt new file mode 100644 index 0000000..b31a75d --- /dev/null +++ b/src/19.blast02/CMakeLists.txt @@ -0,0 +1,8 @@ + cmake_minimum_required(VERSION 2.8) +project(blast02 C CXX) + +ADD_DEFINITIONS( -std=c++11 ) +include_directories(${WFR_INCLUDES}) +add_executable(${PROJECT_NAME}.bin blast02.cpp) +target_link_libraries(${PROJECT_NAME}.bin ${WFR_LIBS}) +install(TARGETS ${PROJECT_NAME}.bin DESTINATION ${INSTALL_DIR}) diff --git a/src/19.blast02/blast02.cpp b/src/19.blast02/blast02.cpp new file mode 100644 index 0000000..a0db214 --- /dev/null +++ b/src/19.blast02/blast02.cpp @@ -0,0 +1,500 @@ +#include "blast02.h" +#include +#include +#include +#include + + + +WFR_INPUT_HOOK(toplevelInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, toplevel_in); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(toplevelOutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, toplevel_out); + WFR_CHILD_OUTBUFFER_GET(a1out, finish_job_out, a1, 13, 0); + if (a1out != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sout->result, a1out->result)); + } + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->result.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(split_inputsInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, split_inputs_in); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_file, a1in->input_file)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->chunk_count, a1in->chunk_count)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input_file.isReady() && sin->chunk_count.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(split_inputsExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, split_inputs_in); + WFR_SELF_OUTBUFFER_INIT(sout, split_inputs_out); + WFR_PORT_INIT_COLLECTION(sout->input_chunks); + + EXECUTE_SIMULATION_MODE + for (long i = 0; i < sin->chunk_count.getValue(); ++i) { + sout->input_chunks.setEntryValue(i, "input_chunk"); + } + sout->input_chunks.setFinalised(true); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pFor01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pFor01_in); + WFR_PORT_INIT_COLLECTION(sin->input_chunks); + WFR_PARENT_INBUFFER_GET(a1in, toplevel_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->parallelReductions, a1in->parallelReductions)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->counter_to, a1in->parallelReductions)); + } + WFR_PRED_OUTBUFFER_GET(a2in, split_inputs_out, a2, 0); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_chunks, a2in->input_chunks)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pFor01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pFor01_out); + WFR_PORT_INIT_COLLECTION(sout->output); + WFR_PORT_INIT_COLLECTION(sout->error); + WFR_PORT_INIT_COLLECTION(sout->total); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, cat_output_out, output, 7); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->error, cat_error_out, output, 8); + WFR_LOOP_FINALIZE_COLLECTION(sout, error); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->total, cat_total_out, output, 9); + WFR_LOOP_FINALIZE_COLLECTION(sout, total); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady() && sout->error.isReady() && sout->total.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pFor01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pFor01_in); + if(sin != nullptr && sin->counter_to.isReady()) { + WFR_SELF_SETFORLOOPCOUNTERVALUES(0, 1, sin->counter_to.getValue()) + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(helper01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, helper01_in); + WFR_PORT_INIT_COLLECTION(sin->input_chunks); + WFR_PARENT_INBUFFER_GET(a1in, pFor01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_chunks, a1in->input_chunks)); + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->parallelReductions, a1in->parallelReductions)); + WFR_FORLOOP_GET_COUNTER_VALUE(a1, sin->loopCounter); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input_chunks.isReady() && sin->parallelReductions.isReady() && sin->loopCounter.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(helper01ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, helper01_in); + WFR_SELF_OUTBUFFER_INIT(sout, helper01_out); + WFR_PORT_INIT_COLLECTION(sout->output); + + for (long i = 0; i < sin->input_chunks.getSize()/(sin->parallelReductions.getValue()+1); ++i) { + sout->output.setEntryValue(i, sin->input_chunks.getEntryValue(i)); + } + sout->output.setFinalised(true); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(pForEach01InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, pForEach01_in); + WFR_PORT_INIT_COLLECTION(sin->input_chunks); + WFR_PRED_OUTBUFFER_GET(a1in, helper01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input_chunks, a1in->output)); + } + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_OUTPUT_HOOK(pForEach01OutputFunc) { + WFR_OUTPUT_HOOK_PROLOG; + WFR_SELF_OUTBUFFER_INIT(sout, pForEach01_out); + WFR_PORT_INIT_COLLECTION(sout->output); + WFR_PORT_INIT_COLLECTION(sout->error); + WFR_PORT_INIT_COLLECTION(sout->total); + + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->output, distributed_script_out, output, 6); + WFR_LOOP_FINALIZE_COLLECTION(sout, output); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->error, distributed_script_out, error, 6); + WFR_LOOP_FINALIZE_COLLECTION(sout, error); + WFR_COLLECT_OUTVALUES_FROM_CHILDREN(sout->total, distributed_script_out, total, 6); + WFR_LOOP_FINALIZE_COLLECTION(sout, total); + + WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(sout->output.isReady() && sout->error.isReady() && sout->total.isReady()); + WFR_OUTPUT_HOOK_EPILOG; +} + + +WFR_FORCOUNTER_HOOK(pForEach01CounterFunc) { + WFR_FORCOUNTER_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, pForEach01_in); + if (sin != nullptr && sin->input_chunks.isReady() && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution) { + wfr_size_t minLoopElementcount = std::min({sin->input_chunks.getSize()}); + WFR_SELF_SETITERATIONCOUNT(minLoopElementcount); + WFR_LOOP_FINALIZE(); + WFR_SELF_CHECK_ISREADYFOREXECUTION(true); + } + WFR_FORCOUNTER_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(distributed_scriptInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, distributed_script_in); + WFR_PARENT_INBUFFER_GET(a1in, pForEach01_in, a1); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->input_chunks.getEntry(WFR_SELF_GETITERATIONID()))); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(distributed_scriptExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, distributed_script_in); + WFR_SELF_OUTBUFFER_INIT(sout, distributed_script_out); + + EXECUTE_SIMULATION_MODE + sout->output.setValue("output.file"); + sout->error.setValue("error.file"); + sout->total.setValue("total.file"); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(cat_outputInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, cat_output_in); + WFR_PORT_INIT_COLLECTION(sin->input); + WFR_PRED_OUTBUFFER_GET(a1in, pForEach01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(cat_outputExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, cat_output_in); + WFR_SELF_OUTBUFFER_INIT(sout, cat_output_out); + + auto sleeptime = sin->input.getSize(); // per file the original code roughly needed 0.7 ms (let's round that to 1 ms). + std::this_thread::sleep_for(std::chrono::milliseconds((long int)sleeptime)); + sout->output.setValue("cat_output.file"); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(cat_errorInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, cat_error_in); + WFR_PORT_INIT_COLLECTION(sin->input); + WFR_PRED_OUTBUFFER_GET(a1in, pForEach01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->error)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(cat_errorExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, cat_error_in); + WFR_SELF_OUTBUFFER_INIT(sout, cat_error_out); + + auto sleeptime = sin->input.getSize(); // per file the original code roughly needed 0.7 ms (let's round that to 1 ms). + std::this_thread::sleep_for(std::chrono::milliseconds((long int)sleeptime)); + sout->output.setValue("cat_output.file"); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(cat_totalInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, cat_total_in); + WFR_PORT_INIT_COLLECTION(sin->input); + WFR_PRED_OUTBUFFER_GET(a1in, pForEach01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->total)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(cat_totalExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, cat_total_in); + WFR_SELF_OUTBUFFER_INIT(sout, cat_total_out); + + auto sleeptime = sin->input.getSize(); // per file the original code roughly needed 0.7 ms (let's round that to 1 ms). + std::this_thread::sleep_for(std::chrono::milliseconds((long int)sleeptime)); + sout->output.setValue("cat_output.file"); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(cat_output_2InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, cat_output_2_in); + WFR_PORT_INIT_COLLECTION(sin->input); + WFR_PRED_OUTBUFFER_GET(a1in, pFor01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(cat_output_2ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, cat_output_2_in); + WFR_SELF_OUTBUFFER_INIT(sout, cat_output_2_out); + + auto sleeptime = sin->input.getSize(); // per file the original code roughly needed 0.7 ms (let's round that to 1 ms). + std::this_thread::sleep_for(std::chrono::milliseconds((long int)sleeptime)); + sout->output.setValue("cat_output.file"); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(cat_error_2InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, cat_error_2_in); + WFR_PORT_INIT_COLLECTION(sin->input); + WFR_PRED_OUTBUFFER_GET(a1in, pFor01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->error)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(cat_error_2ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, cat_error_2_in); + WFR_SELF_OUTBUFFER_INIT(sout, cat_error_2_out); + + auto sleeptime = sin->input.getSize(); // per file the original code roughly needed 0.7 ms (let's round that to 1 ms). + std::this_thread::sleep_for(std::chrono::milliseconds((long int)sleeptime)); + sout->output.setValue("cat_output.file"); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(cat_total_2InputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, cat_total_2_in); + WFR_PORT_INIT_COLLECTION(sin->input); + WFR_PRED_OUTBUFFER_GET(a1in, pFor01_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->input, a1in->total)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->input.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(cat_total_2ExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, cat_total_2_in); + WFR_SELF_OUTBUFFER_INIT(sout, cat_total_2_out); + + auto sleeptime = sin->input.getSize(); // per file the original code roughly needed 0.7 ms (let's round that to 1 ms). + std::this_thread::sleep_for(std::chrono::milliseconds((long int)sleeptime)); + sout->output.setValue("cat_output.file"); + + WFR_EXEC_HOOK_EPILOG; +} + + +WFR_INPUT_HOOK(finish_jobInputFunc) { + WFR_INPUT_HOOK_PROLOG; + WFR_SELF_INBUFFER_INIT(sin, finish_job_in); + WFR_PRED_OUTBUFFER_GET(a1in, cat_output_2_out, a1, 0); + if (a1in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->output, a1in->output)); + } + WFR_PRED_OUTBUFFER_GET(a2in, cat_total_2_out, a2, 1); + if (a2in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->total, a2in->output)); + } + WFR_PRED_OUTBUFFER_GET(a3in, cat_error_2_out, a3, 2); + if (a3in != nullptr) { + WFR_HOOK_SET_RETVAL( portbuffer_copy(sin->error, a3in->output)); + } + WFR_SELF_CHECK_ISREADYFOREXECUTION(sin->output.isReady() && sin->error.isReady() && sin->total.isReady()); + WFR_INPUT_HOOK_EPILOG; +} + + +WFR_EXEC_HOOK(finish_jobExecFunc_0) { + WFR_EXEC_HOOK_PROLOG; + WFR_SELF_INBUFFER_GET(sin, finish_job_in); + WFR_SELF_OUTBUFFER_INIT(sout, finish_job_out); + + EXECUTE_SIMULATION_MODE + sout->result.setValue("result.file"); + + WFR_EXEC_HOOK_EPILOG; +} + +WFR_ACTIVITY_IMPLEMENTATIONS( split_inputsImplementations, "split_inputsImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(split_inputsExecFunc_0, "split_inputsExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( helper01Implementations, "helper01Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(helper01ExecFunc_0, "helper01ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( distributed_scriptImplementations, "distributed_scriptImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(distributed_scriptExecFunc_0, "distributed_scriptExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( cat_outputImplementations, "cat_outputImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(cat_outputExecFunc_0, "cat_outputExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( cat_errorImplementations, "cat_errorImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(cat_errorExecFunc_0, "cat_errorExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( cat_totalImplementations, "cat_totalImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(cat_totalExecFunc_0, "cat_totalExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( cat_output_2Implementations, "cat_output_2Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(cat_output_2ExecFunc_0, "cat_output_2ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( cat_error_2Implementations, "cat_error_2Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(cat_error_2ExecFunc_0, "cat_error_2ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( cat_total_2Implementations, "cat_total_2Implementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(cat_total_2ExecFunc_0, "cat_total_2ExecFunc_0" ) +); + +WFR_ACTIVITY_IMPLEMENTATIONS( finish_jobImplementations, "finish_jobImplementations", \ + wfr::wfs::AtomicActivityImplementation::PThread(finish_jobExecFunc_0, "finish_jobExecFunc_0" ) +); + + +WFR_WORKFLOW(workflow, "Blast", wfActivityTable, 1, \ + wfr::wfs::ActivityTemplate::container(1, "toplevel", 0, 0, {}, {}, nullptr, toplevelOutputFunc), \ + wfr::wfs::ActivityTemplate::atomic(2, "split_inputs", 1, 0, {3}, {}, split_inputsInputFunc, split_inputsImplementations), \ + wfr::wfs::ActivityTemplate::forLoop(3, "pFor01", 1, 0, {10, 12, 11}, {2}, pFor01InputFunc, pFor01OutputFunc, pFor01CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(4, "helper01", 3, 0, {5}, {}, helper01InputFunc, helper01Implementations), \ + wfr::wfs::ActivityTemplate::forLoop(5, "pForEach01", 3, 0, {7, 8, 9}, {4}, pForEach01InputFunc, pForEach01OutputFunc, pForEach01CounterFunc, nullptr, true), \ + wfr::wfs::ActivityTemplate::atomic(6, "distributed_script", 5, 0, {}, {}, distributed_scriptInputFunc, distributed_scriptImplementations), \ + wfr::wfs::ActivityTemplate::atomic(7, "cat_output", 3, 0, {}, {5}, cat_outputInputFunc, cat_outputImplementations), \ + wfr::wfs::ActivityTemplate::atomic(8, "cat_error", 3, 0, {}, {5}, cat_errorInputFunc, cat_errorImplementations), \ + wfr::wfs::ActivityTemplate::atomic(9, "cat_total", 3, 0, {}, {5}, cat_totalInputFunc, cat_totalImplementations), \ + wfr::wfs::ActivityTemplate::atomic(10, "cat_output_2", 1, 0, {13}, {3}, cat_output_2InputFunc, cat_output_2Implementations), \ + wfr::wfs::ActivityTemplate::atomic(11, "cat_error_2", 1, 0, {13}, {3}, cat_error_2InputFunc, cat_error_2Implementations), \ + wfr::wfs::ActivityTemplate::atomic(12, "cat_total_2", 1, 0, {13}, {3}, cat_total_2InputFunc, cat_total_2Implementations), \ + wfr::wfs::ActivityTemplate::atomic(13, "finish_job", 1, 0, {}, {10, 12, 11}, finish_jobInputFunc, finish_jobImplementations), \ +); + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc, char** argv) { + wfr::WorkflowRuntime::init(argc, argv); + workflow->execute(&wfInput, &wfOutput); + wfr::WorkflowRuntime::finish(); + return 0; +} + + +int main(int argc, char** argv) { + + toplevel_in wfInput; + // Fill workflow input struct + + long chunkCount = 10; + long parallelreductions = 10; + bool isHelp = false; + boost::program_options::options_description opts("MeteoAG Options"); + opts.add_options() + ("help", "Print help message.") + ("inputchunks", boost::program_options::value(), "Number of input chunks.") + ("parallelreductions", boost::program_options::value(), "Number of parallel reductions."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } else { + if (vm.count("inputchunks")) { + chunkCount = vm["inputchunks"].as(); + } + if (vm.count("parallelreductions")) { + parallelreductions = vm["parallelreductions"].as(); + } + std::cerr << "inputChunks = " << chunkCount << std::endl; + std::cerr << "parallelreductions = " << parallelreductions << std::endl; + } + wfInput.input_file.setValue("input_file"); + wfInput.chunk_count.setValue(chunkCount); + wfInput.parallelReductions.setValue(parallelreductions); + + + toplevel_out wfOutput; + + wfstart(wfInput, wfOutput, argc, argv); + // Do something with workflow output + + + return 0; +} diff --git a/src/19.blast02/blast02.h b/src/19.blast02/blast02.h new file mode 100644 index 0000000..e065745 --- /dev/null +++ b/src/19.blast02/blast02.h @@ -0,0 +1,156 @@ +#ifndef BLAST02_H +#define BLAST02_H + +#include + + +/* toplevel INSTRUCT */ +WFR_PORT_STRUCT( toplevel_in, 1, \ + WFR_PORT_MEMBER_IWIRFILE(input_file) \ + WFR_PORT_MEMBER_IWIRINT(chunk_count) \ + WFR_PORT_MEMBER_IWIRINT(parallelReductions) \ +) + +/* toplevel OUTSTRUCT */ +WFR_PORT_STRUCT( toplevel_out, 2, \ + WFR_PORT_MEMBER_IWIRFILE(result) \ +) + +/* split_inputs INSTRUCT */ +WFR_PORT_STRUCT( split_inputs_in, 3, \ + WFR_PORT_MEMBER_IWIRFILE(input_file) \ + WFR_PORT_MEMBER_IWIRINT(chunk_count) \ +) + +/* split_inputs OUTSTRUCT */ +WFR_PORT_STRUCT( split_inputs_out, 4, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* pFor01 INSTRUCT */ +WFR_PORT_STRUCT( pFor01_in, 5, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRINT(parallelReductions) \ + WFR_PORT_MEMBER_IWIRINT(counter_to) \ +) + +/* pFor01 OUTSTRUCT */ +WFR_PORT_STRUCT( pFor01_out, 6, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(error, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(total, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* helper01 INSTRUCT */ +WFR_PORT_STRUCT( helper01_in, 7, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRINT(parallelReductions) \ + WFR_PORT_MEMBER_IWIRINT(loopCounter) \ +) + +/* helper01 OUTSTRUCT */ +WFR_PORT_STRUCT( helper01_out, 8, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* pForEach01 INSTRUCT */ +WFR_PORT_STRUCT( pForEach01_in, 9, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input_chunks, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* pForEach01 OUTSTRUCT */ +WFR_PORT_STRUCT( pForEach01_out, 10, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(output, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(error, wfr::lwd::_lwd_iwir_basetype_file, 1) \ + WFR_PORT_MEMBER_IWIRCOLLECTION(total, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* distributed_script INSTRUCT */ +WFR_PORT_STRUCT( distributed_script_in, 11, \ + WFR_PORT_MEMBER_IWIRFILE(input) \ +) + +/* distributed_script OUTSTRUCT */ +WFR_PORT_STRUCT( distributed_script_out, 12, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ + WFR_PORT_MEMBER_IWIRFILE(error) \ + WFR_PORT_MEMBER_IWIRFILE(total) \ +) + +/* cat_output INSTRUCT */ +WFR_PORT_STRUCT( cat_output_in, 13, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* cat_output OUTSTRUCT */ +WFR_PORT_STRUCT( cat_output_out, 14, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* cat_error INSTRUCT */ +WFR_PORT_STRUCT( cat_error_in, 15, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* cat_error OUTSTRUCT */ +WFR_PORT_STRUCT( cat_error_out, 16, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* cat_total INSTRUCT */ +WFR_PORT_STRUCT( cat_total_in, 17, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* cat_total OUTSTRUCT */ +WFR_PORT_STRUCT( cat_total_out, 18, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* cat_output_2 INSTRUCT */ +WFR_PORT_STRUCT( cat_output_2_in, 19, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* cat_output_2 OUTSTRUCT */ +WFR_PORT_STRUCT( cat_output_2_out, 20, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* cat_error_2 INSTRUCT */ +WFR_PORT_STRUCT( cat_error_2_in, 21, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* cat_error_2 OUTSTRUCT */ +WFR_PORT_STRUCT( cat_error_2_out, 22, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* cat_total_2 INSTRUCT */ +WFR_PORT_STRUCT( cat_total_2_in, 23, \ + WFR_PORT_MEMBER_IWIRCOLLECTION(input, wfr::lwd::_lwd_iwir_basetype_file, 1) \ +) + +/* cat_total_2 OUTSTRUCT */ +WFR_PORT_STRUCT( cat_total_2_out, 24, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ +) + +/* finish_job INSTRUCT */ +WFR_PORT_STRUCT( finish_job_in, 25, \ + WFR_PORT_MEMBER_IWIRFILE(output) \ + WFR_PORT_MEMBER_IWIRFILE(error) \ + WFR_PORT_MEMBER_IWIRFILE(total) \ +) + +/* finish_job OUTSTRUCT */ +WFR_PORT_STRUCT( finish_job_out, 26, \ + WFR_PORT_MEMBER_IWIRFILE(result) \ +) + + +int wfstart(toplevel_in &wfInput, toplevel_out &wfOutput, int argc = 0, char** argv = nullptr); + + +#endif /* BLAST02_H */