starpu-max/tests/perfmodels/StreamFMA.max

#ifdef MAXCOMPILER_VERSION_INFO
#define MAXCOMPILER_VERSION_INFO_PRESENT 1
#define MAXFILE_MAXCOMPILER_VERSION_YEAR         2018
#define MAXFILE_MAXCOMPILER_VERSION_NUM          2
#define MAXFILE_MAXCOMPILER_VERSION_POINT        1
#define MAXFILE_MAXCOMPILER_VERSION_PATCH        ""
#define MAXFILE_MAXCOMPILER_VERSION_REV          "8488566"
#define MAXFILE_MAXCOMPILER_VERSION_RELEASE_DATE "2018-07-18"
#define MAXFILE_MAXCOMPILER_VERSION_RELEASE_MODE true
#endif

#ifdef MAXFILE_BUILD_INFO
#define MAXFILE_BUILD_INFO_PRESENT 1
#define MAXFILE_BUILD_NAME "StreamFMA"
#define MAXFILE_BUILD_DIR  "/mnt/beegfs/home/jusers/makni1/jumax/./StreamFMA_MAX5C_DFE_SIM"
#define MAXFILE_BUILD_DATE  20190705
#define MAXFILE_BUILD_REV   1
#endif

#ifdef PARAM
#define PARAM_PRESENT 1
PARAM(DYNAMIC_CLOCKS_ENABLED, 0)
PARAM(APP_ID, 0)
PARAM(REV_ID, 0)
PARAM(CHAIN_LENGTH, 36)
PARAM(IS_SIMULATION, 1)
PARAM(MEC_SUPPORTED, 1)
PARAM(PCIE_SLAVE_STREAMING, 0)
PARAM(PCIE_ALIGNMENT, 16)
PARAM(NUM_IFPGA_LINKS, 0)
#endif

#ifdef STRING_PARAM
#define STRING_PARAM_PRESENT 1
STRING_PARAM(BOARD_MODEL, "MAX5_LIMA")
#endif



#ifdef INCLUDE_GENERATED_CPP_HEADERS
#include "StreamFMAKernel.h"
#endif



#ifdef ENGINE_PARAMETERS
#define ENGINE_PARAMETERS_PRESENT 1
ENGINE_PARAMETERS(DFEModel, DFEMODEL, MAIA)
ENGINE_PARAMETERS(maxFileName, STRING, "StreamFMA")
ENGINE_PARAMETERS(target, ENUM, DFE_SIM)
ENGINE_PARAMETERS(enableMPCX, BOOL, true)
ENGINE_PARAMETERS(MPPRStartCT, INT, 1)
ENGINE_PARAMETERS(MPPREndCT, INT, 1)
ENGINE_PARAMETERS(MPPRThreads, INT, 1)
ENGINE_PARAMETERS(MPPRRetryThreshold, INT, 0)
#endif








#ifdef MANAGER_NODE
#define MANAGER_NODE_PRESENT 1
MANAGER_NODE(StreamFMAKernel, Kernel)
MANAGER_NODE(a, PCIe_From_Host)
MANAGER_NODE(b, PCIe_From_Host)
MANAGER_NODE(output, PCIe_To_Host)
MANAGER_NODE(Stream_1, DualAspectMux)
MANAGER_NODE(Stream_4, DualAspectMux)
MANAGER_NODE(Stream_8, DualAspectReg)
MANAGER_NODE(Stream_21, StreamPullPushAdapter)
MANAGER_NODE(Stream_11, Fifo)
MANAGER_NODE(Stream_15, Fifo)
MANAGER_NODE(Stream_13, Fifo)
MANAGER_NODE(Stream_17, Fifo)
MANAGER_NODE(Stream_19, Fifo)
#endif

#ifdef MANAGER_NODE_IO
#define MANAGER_NODE_IO_PRESENT 1
MANAGER_NODE_IO(StreamFMAKernel, a, IN, STREAM, 32, PULL)
MANAGER_NODE_IO(StreamFMAKernel, b, IN, STREAM, 32, PULL)
MANAGER_NODE_IO(StreamFMAKernel, output, OUT, STREAM, 32, PUSH)
MANAGER_NODE_IO(a, a, OUT, PCIE, 128, PUSH)
MANAGER_NODE_IO(b, b, OUT, PCIE, 128, PUSH)
MANAGER_NODE_IO(output, output, IN, PCIE, 128, PUSH)
MANAGER_NODE_IO(Stream_1, input, IN, PCIE, 128, PULL)
MANAGER_NODE_IO(Stream_1, output, OUT, PCIE, 32, PUSH)
MANAGER_NODE_IO(Stream_4, input, IN, PCIE, 128, PULL)
MANAGER_NODE_IO(Stream_4, output, OUT, PCIE, 32, PUSH)
MANAGER_NODE_IO(Stream_8, input, IN, PCIE, 32, PULL)
MANAGER_NODE_IO(Stream_8, output, OUT, PCIE, 128, PULL)
MANAGER_NODE_IO(Stream_21, input, IN, PCIE, 128, PULL)
MANAGER_NODE_IO(Stream_21, output, OUT, PCIE, 128, PUSH)
MANAGER_NODE_IO(Stream_11, input, IN, PCIE, 128, PUSH)
MANAGER_NODE_IO(Stream_11, output, OUT, PCIE, 128, PULL)
MANAGER_NODE_IO(Stream_15, input, IN, PCIE, 128, PUSH)
MANAGER_NODE_IO(Stream_15, output, OUT, PCIE, 128, PULL)
MANAGER_NODE_IO(Stream_13, input, IN, PCIE, 32, PUSH)
MANAGER_NODE_IO(Stream_13, output, OUT, STREAM, 32, PULL)
MANAGER_NODE_IO(Stream_17, input, IN, PCIE, 32, PUSH)
MANAGER_NODE_IO(Stream_17, output, OUT, STREAM, 32, PULL)
MANAGER_NODE_IO(Stream_19, input, IN, STREAM, 32, PUSH)
MANAGER_NODE_IO(Stream_19, output, OUT, PCIE, 32, PULL)
#endif

#ifdef MANAGER_STREAM
#define MANAGER_STREAM_PRESENT 1
MANAGER_STREAM(a, a, Stream_11, input, 128)
MANAGER_STREAM(b, b, Stream_15, input, 128)
MANAGER_STREAM(StreamFMAKernel, output, Stream_19, input, 32)
MANAGER_STREAM(Stream_1, output, Stream_13, input, 32)
MANAGER_STREAM(Stream_4, output, Stream_17, input, 32)
MANAGER_STREAM(Stream_8, output, Stream_21, input, 128)
MANAGER_STREAM(Stream_21, output, output, output, 128)
MANAGER_STREAM(Stream_11, output, Stream_1, input, 128)
MANAGER_STREAM(Stream_15, output, Stream_4, input, 128)
MANAGER_STREAM(Stream_13, output, StreamFMAKernel, a, 32)
MANAGER_STREAM(Stream_17, output, StreamFMAKernel, b, 32)
MANAGER_STREAM(Stream_19, output, Stream_8, input, 32)
#endif

#ifdef MANAGER_NODE_STACK_TRACE
#define MANAGER_NODE_STACK_TRACE_PRESENT 1
MANAGER_NODE_STACK_TRACE(StreamFMAKernel, "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
MANAGER_NODE_STACK_TRACE(a, "com.maxeler.platform.max5.manager.Max5ManagerBase.addStreamFromCPU(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:14)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
MANAGER_NODE_STACK_TRACE(b, "com.maxeler.platform.max5.manager.Max5ManagerBase.addStreamFromCPU(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:15)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
MANAGER_NODE_STACK_TRACE(output, "com.maxeler.platform.max5.manager.Max5ManagerBase.addStreamToCPU(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:16)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
MANAGER_NODE_STACK_TRACE(Stream_1, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_4, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_8, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_21, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_11, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_15, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_13, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_17, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_19, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
#endif


#ifdef MANAGER_NODE_PROPERTY
#define MANAGER_NODE_PROPERTY_PRESENT 1
MANAGER_NODE_PROPERTY(StreamFMAKernel, control_pipelining_depth, 2)
#endif


#ifdef KERNEL_CORE
#define KERNEL_CORE_PRESENT 1
KERNEL_CORE(StreamFMAKernel)
#endif

#ifdef KERNEL_HOST_CONTROLLED
#define KERNEL_HOST_CONTROLLED_PRESENT 1
KERNEL_HOST_CONTROLLED(StreamFMAKernel, StreamFMAKernel)
#endif

#ifdef DEBUG_INPUT_BITS
#define DEBUG_INPUT_BITS_PRESENT 1
DEBUG_INPUT_BITS(StreamFMAKernel, a, 0)
DEBUG_INPUT_BITS(StreamFMAKernel, b, 1)
#endif

#ifdef DEBUG_OUTPUT_BITS
#define DEBUG_OUTPUT_BITS_PRESENT 1
DEBUG_OUTPUT_BITS(StreamFMAKernel, output, 0)
#endif

#ifdef MANAGER_NODE_CPP_SIM_MODEL_CTOR
#define MANAGER_NODE_CPP_SIM_MODEL_CTOR_PRESENT 1
MANAGER_NODE_CPP_SIM_MODEL_CTOR(a, PCIePushSourceSync16, "a")
MANAGER_NODE_CPP_SIM_MODEL_CTOR(b, PCIePushSourceSync16, "b")
MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_11, FifoPushToPullSync, "Stream_11", false, 512, 128)
MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_15, FifoPushToPullSync, "Stream_15", false, 512, 128)
MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_1, DualAspectMuxSync, "Stream_1", 32, 4)
MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_4, DualAspectMuxSync, "Stream_4", 32, 4)
MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_13, FifoPushToPullSync, "Stream_13", false, 512, 32)
MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_17, FifoPushToPullSync, "Stream_17", false, 512, 32)
MANAGER_NODE_CPP_SIM_MODEL_CTOR(StreamFMAKernel, StreamFMAKernel, "StreamFMAKernel")
MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_19, FifoPushToPullSync, "Stream_19", false, 512, 32)
MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_8, DualAspectRegSync, "Stream_8", 32, 4)
MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_21, PullToPushAdapterSync, "Stream_21")
MANAGER_NODE_CPP_SIM_MODEL_CTOR(output, PCIePushSinkSync16, "output")
MANAGER_NODE_CPP_SIM_MODEL_CTOR(CapabilityReg, CapRegs, "CapabilityReg", 0, 2, 1, 0, 0, 0, 0, 0, 36)
MANAGER_NODE_CPP_SIM_MODEL_CTOR(ifpga, IFPGARegs)
MANAGER_NODE_CPP_SIM_MODEL_CTOR(sfa, SFARegs)
MANAGER_NODE_CPP_SIM_MODEL_CTOR(ChecksumMemory, ChecksumMem, "ChecksumMemory", "ac5fbbbe6e4b46179c07a7a26c8647de7f8ceee21ed281c31027872a8e6038d8")
#endif

#ifdef MANAGER_NODE_CPP_SIM_MODEL_SETUP
#define MANAGER_NODE_CPP_SIM_MODEL_SETUP_PRESENT 1
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_ctld_almost_empty, 2, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_ctld_done, 2, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_ctld_empty, 2, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_ctld_read, 2, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_ctld_read_pipe_dbg, 6, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_ctld_request, 2, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_done_out, 1, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_fill_level, 4, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_flush_level, 4, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_flush_start, 1, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_flush_start_level, 4, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_flushing, 1, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_full_level, 4, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_out_stall, 1, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_out_valid, 1, 0)
MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_stall_vector, 1, 0)
#endif

#ifdef PCIE_STREAM
#define PCIE_STREAM_PRESENT 1
PCIE_STREAM(a, STREAM_FROM_HOST, 0)
PCIE_STREAM(b, STREAM_FROM_HOST, 1)
PCIE_STREAM(output, STREAM_TO_HOST, 0)
#endif

#ifdef REG
#define REG_PRESENT 1
REG(StreamFMAKernel.io_a_force_disabled, 0x0, 1, hwOffsetFix(1, 0, UNSIGNED))
REG(StreamFMAKernel.io_b_force_disabled, 0x1, 1, hwOffsetFix(1, 0, UNSIGNED))
REG(StreamFMAKernel.io_output_force_disabled, 0x2, 1, hwOffsetFix(1, 0, UNSIGNED))
REG(StreamFMAKernel.run_cycle_count, 0x3, 6, hwOffsetFix(48, 0, UNSIGNED))
REG(StreamFMAKernel.current_run_cycle_count, 0x9, 6, hwOffsetFix(48, 0, UNSIGNED))
REG(StreamFMAKernel.dbg_ctld_almost_empty, 0xf, 1, hwBits(2))
REG(StreamFMAKernel.dbg_ctld_done, 0x10, 1, hwBits(2))
REG(StreamFMAKernel.dbg_ctld_empty, 0x11, 1, hwBits(2))
REG(StreamFMAKernel.dbg_ctld_read, 0x12, 1, hwBits(2))
REG(StreamFMAKernel.dbg_ctld_read_pipe_dbg, 0x13, 1, hwBits(6))
REG(StreamFMAKernel.dbg_ctld_request, 0x14, 1, hwBits(2))
REG(StreamFMAKernel.dbg_done_out, 0x15, 1, hwBits(1))
REG(StreamFMAKernel.dbg_fill_level, 0x16, 1, hwBits(4))
REG(StreamFMAKernel.dbg_flush_level, 0x17, 1, hwBits(4))
REG(StreamFMAKernel.dbg_flush_start, 0x18, 1, hwBits(1))
REG(StreamFMAKernel.dbg_flush_start_level, 0x19, 1, hwBits(4))
REG(StreamFMAKernel.dbg_flushing, 0x1a, 1, hwBits(1))
REG(StreamFMAKernel.dbg_full_level, 0x1b, 1, hwBits(4))
REG(StreamFMAKernel.dbg_out_stall, 0x1c, 1, hwBits(1))
REG(StreamFMAKernel.dbg_out_valid, 0x1d, 1, hwBits(1))
REG(StreamFMAKernel.dbg_stall_vector, 0x1e, 1, hwBits(1))
REG(ifpga.ifpga_ctrl, 0x1f, 1, hwBits(8))
REG(SignalForwardingAdapter.SFA_FORWARD_EN, 0x20, 4, hwBits(32))
#endif

#ifdef REG_V2
#define REG_V2_PRESENT 1
REG_V2(StreamFMAKernel.io_a_force_disabled, 0x0, 1, hwOffsetFix(1, 0, UNSIGNED), HOST_WRITE_ONLY, true)
REG_V2(StreamFMAKernel.io_b_force_disabled, 0x1, 1, hwOffsetFix(1, 0, UNSIGNED), HOST_WRITE_ONLY, true)
REG_V2(StreamFMAKernel.io_output_force_disabled, 0x2, 1, hwOffsetFix(1, 0, UNSIGNED), HOST_WRITE_ONLY, true)
REG_V2(StreamFMAKernel.run_cycle_count, 0x3, 6, hwOffsetFix(48, 0, UNSIGNED), HOST_WRITE_ONLY, false)
REG_V2(StreamFMAKernel.current_run_cycle_count, 0x9, 6, hwOffsetFix(48, 0, UNSIGNED), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_ctld_almost_empty, 0xf, 1, hwBits(2), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_ctld_done, 0x10, 1, hwBits(2), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_ctld_empty, 0x11, 1, hwBits(2), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_ctld_read, 0x12, 1, hwBits(2), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_ctld_read_pipe_dbg, 0x13, 1, hwBits(6), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_ctld_request, 0x14, 1, hwBits(2), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_done_out, 0x15, 1, hwBits(1), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_fill_level, 0x16, 1, hwBits(4), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_flush_level, 0x17, 1, hwBits(4), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_flush_start, 0x18, 1, hwBits(1), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_flush_start_level, 0x19, 1, hwBits(4), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_flushing, 0x1a, 1, hwBits(1), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_full_level, 0x1b, 1, hwBits(4), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_out_stall, 0x1c, 1, hwBits(1), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_out_valid, 0x1d, 1, hwBits(1), HOST_READ_ONLY, false)
REG_V2(StreamFMAKernel.dbg_stall_vector, 0x1e, 1, hwBits(1), HOST_READ_ONLY, false)
REG_V2(ifpga.ifpga_ctrl, 0x1f, 1, hwBits(8), HOST_READ_WRITE, false)
REG_V2(SignalForwardingAdapter.SFA_FORWARD_EN, 0x20, 4, hwBits(32), HOST_READ_WRITE, false)
#endif




#ifdef CHECKSUM
#define CHECKSUM_PRESENT 1
CHECKSUM("ac5fbbbe6e4b46179c07a7a26c8647de7f8ceee21ed281c31027872a8e6038d8")
#endif




#ifdef CAPABILITY
#define CAPABILITY_PRESENT 1
CAPABILITY(LIMAREV, LIMAREVA)
CAPABILITY(LIMARAM, DDR4_48GB)
CAPABILITY(LIMAFPGA, xcVU9P_FLGB2104_2_E)
#endif

#ifdef DEFINE_DESIGN_NAME
#define DESIGN_NAME StreamFMA
#endif /* DEFINE_DESIGN_NAME */

#ifndef SLIC_NO_DECLARATIONS
/**\file */
#ifndef SLIC_DECLARATIONS_StreamFMA_H
#define SLIC_DECLARATIONS_StreamFMA_H
#include "MaxSLiCInterface.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

#define StreamFMA_DYNAMIC_CLOCKS_ENABLED (0)
#define StreamFMA_PCIE_ALIGNMENT (16)


/*----------------------------------------------------------------------------*/
/*---------------------------- Interface default -----------------------------*/
/*----------------------------------------------------------------------------*/




/**
 * \brief Basic static function for the interface 'default'.
 * 
 * \param [in] ticks_StreamFMAKernel The number of ticks for which kernel "StreamFMAKernel" will run.
 * \param [in] instream_a Stream "a".
 * \param [in] instream_size_a The size of the stream instream_a in bytes.
 * \param [in] instream_b Stream "b".
 * \param [in] instream_size_b The size of the stream instream_b in bytes.
 * \param [out] outstream_output Stream "output".
 * \param [in] outstream_size_output The size of the stream outstream_output in bytes.
 */
void StreamFMA(
	uint64_t ticks_StreamFMAKernel,
	const void *instream_a,
	size_t instream_size_a,
	const void *instream_b,
	size_t instream_size_b,
	void *outstream_output,
	size_t outstream_size_output);

/**
 * \brief Basic static non-blocking function for the interface 'default'.
 * 
 * Schedule to run on an engine and return immediately.
 * The status of the run can be checked either by ::max_wait or ::max_nowait;
 * note that one of these *must* be called, so that associated memory can be released.
 * 
 * 
 * \param [in] ticks_StreamFMAKernel The number of ticks for which kernel "StreamFMAKernel" will run.
 * \param [in] instream_a Stream "a".
 * \param [in] instream_size_a The size of the stream instream_a in bytes.
 * \param [in] instream_b Stream "b".
 * \param [in] instream_size_b The size of the stream instream_b in bytes.
 * \param [out] outstream_output Stream "output".
 * \param [in] outstream_size_output The size of the stream outstream_output in bytes.
 * \return A handle on the execution status, or NULL in case of error.
 */
max_run_t *StreamFMA_nonblock(
	uint64_t ticks_StreamFMAKernel,
	const void *instream_a,
	size_t instream_size_a,
	const void *instream_b,
	size_t instream_size_b,
	void *outstream_output,
	size_t outstream_size_output);

/**
 * \brief Advanced static interface, structure for the engine interface 'default'
 * 
 */
typedef struct { 
	uint64_t ticks_StreamFMAKernel; /**<  [in] The number of ticks for which kernel "StreamFMAKernel" will run. */
	const void *instream_a; /**<  [in] Stream "a". */
	size_t instream_size_a; /**<  [in] The size of the stream instream_a in bytes. */
	const void *instream_b; /**<  [in] Stream "b". */
	size_t instream_size_b; /**<  [in] The size of the stream instream_b in bytes. */
	void *outstream_output; /**<  [out] Stream "output". */
	size_t outstream_size_output; /**<  [in] The size of the stream outstream_output in bytes. */
} StreamFMA_actions_t;

/**
 * \brief Advanced static function for the interface 'default'.
 * 
 * \param [in] engine The engine on which the actions will be executed.
 * \param [in,out] interface_actions Actions to be executed.
 */
void StreamFMA_run(
	max_engine_t *engine,
	StreamFMA_actions_t *interface_actions);

/**
 * \brief Advanced static non-blocking function for the interface 'default'.
 *
 * Schedule the actions to run on the engine and return immediately.
 * The status of the run can be checked either by ::max_wait or ::max_nowait;
 * note that one of these *must* be called, so that associated memory can be released.
 *
 * 
 * \param [in] engine The engine on which the actions will be executed.
 * \param [in] interface_actions Actions to be executed.
 * \return A handle on the execution status of the actions, or NULL in case of error.
 */
max_run_t *StreamFMA_run_nonblock(
	max_engine_t *engine,
	StreamFMA_actions_t *interface_actions);

/**
 * \brief Group run advanced static function for the interface 'default'.
 * 
 * \param [in] group Group to use.
 * \param [in,out] interface_actions Actions to run.
 *
 * Run the actions on the first device available in the group.
 */
void StreamFMA_run_group(max_group_t *group, StreamFMA_actions_t *interface_actions);

/**
 * \brief Group run advanced static non-blocking function for the interface 'default'.
 * 
 *
 * Schedule the actions to run on the first device available in the group and return immediately.
 * The status of the run must be checked with ::max_wait. 
 * Note that use of ::max_nowait is prohibited with non-blocking running on groups:
 * see the ::max_run_group_nonblock documentation for more explanation.
 *
 * \param [in] group Group to use.
 * \param [in] interface_actions Actions to run.
 * \return A handle on the execution status of the actions, or NULL in case of error.
 */
max_run_t *StreamFMA_run_group_nonblock(max_group_t *group, StreamFMA_actions_t *interface_actions);

/**
 * \brief Array run advanced static function for the interface 'default'.
 * 
 * \param [in] engarray The array of devices to use.
 * \param [in,out] interface_actions The array of actions to run.
 *
 * Run the array of actions on the array of engines.  The length of interface_actions
 * must match the size of engarray.
 */
void StreamFMA_run_array(max_engarray_t *engarray, StreamFMA_actions_t *interface_actions[]);

/**
 * \brief Array run advanced static non-blocking function for the interface 'default'.
 * 
 *
 * Schedule to run the array of actions on the array of engines, and return immediately.
 * The length of interface_actions must match the size of engarray.
 * The status of the run can be checked either by ::max_wait or ::max_nowait;
 * note that one of these *must* be called, so that associated memory can be released.
 *
 * \param [in] engarray The array of devices to use.
 * \param [in] interface_actions The array of actions to run.
 * \return A handle on the execution status of the actions, or NULL in case of error.
 */
max_run_t *StreamFMA_run_array_nonblock(max_engarray_t *engarray, StreamFMA_actions_t *interface_actions[]);

/**
 * \brief Converts a static-interface action struct into a dynamic-interface max_actions_t struct.
 *
 * Note that this is an internal utility function used by other functions in the static interface.
 *
 * \param [in] maxfile The maxfile to use.
 * \param [in] interface_actions The interface-specific actions to run.
 * \return The dynamic-interface actions to run, or NULL in case of error.
 */
max_actions_t* StreamFMA_convert(max_file_t *maxfile, StreamFMA_actions_t *interface_actions);

/**
 * \brief Initialise a maxfile.
 */
max_file_t* StreamFMA_init(void);

/* Error handling functions */
int StreamFMA_has_errors(void);
const char* StreamFMA_get_errors(void);
void StreamFMA_clear_errors(void);
/* Free statically allocated maxfile data */
void StreamFMA_free(void);
/* returns: -1 = error running command; 0 = no error reported */
int StreamFMA_simulator_start(void);
/* returns: -1 = error running command; 0 = no error reported */
int StreamFMA_simulator_stop(void);

#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* SLIC_DECLARATIONS_StreamFMA_H */

#endif /* SLIC_NO_DECLARATIONS */

#ifdef PHOTON_NODE_DATA
#define PHOTON_NODE_DATA_PRESENT 1
PHOTON_NODE_DATA(StreamFMAKernel, 8, NodeInputMappedReg, "Scalar input (io_output_force_disabled)", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.output(IO.java:836)\ntests.StreamFMAKernel.<init>(StreamFMAKernel.maxj:21)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 9, NodeNot, "~", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.output(IO.java:836)\ntests.StreamFMAKernel.<init>(StreamFMAKernel.maxj:21)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 0, NodeInputMappedReg, "Scalar input (io_a_force_disabled)", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\ntests.StreamFMAKernel.<init>(StreamFMAKernel.maxj:15)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 1, NodeNot, "~", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\ntests.StreamFMAKernel.<init>(StreamFMAKernel.maxj:15)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 2, NodeInput, "Input(a)", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\ntests.StreamFMAKernel.<init>(StreamFMAKernel.maxj:15)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 3, NodeInputMappedReg, "Scalar input (io_b_force_disabled)", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\ntests.StreamFMAKernel.<init>(StreamFMAKernel.maxj:16)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 4, NodeNot, "~", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\ntests.StreamFMAKernel.<init>(StreamFMAKernel.maxj:16)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 5, NodeInput, "Input(b)", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\ntests.StreamFMAKernel.<init>(StreamFMAKernel.maxj:16)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 6, NodeAdd, "+", "com.maxeler.maxcompiler.v2.kernelcompiler.types.base.DFEVar.add(DFEVar.java:1010)\ntests.StreamFMAKernel.<init>(StreamFMAKernel.maxj:19)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 11, NodeOutput, "Output(output)", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.output(IO.java:836)\ntests.StreamFMAKernel.<init>(StreamFMAKernel.maxj:21)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 16, NodeConstantRawBits, "{HWOffsetFix:1, 0, UNSIGNED}\n0x1; 1.0", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 26, NodeConstantRawBits, "{HWOffsetFix:1, 0, UNSIGNED}\n0x1; 1.0", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 13, NodeConstantRawBits, "{HWOffsetFix:49, 0, UNSIGNED}\n0x1000000000000; 2.81474976710656E14", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 14, NodeCounter, "Counter(NUMERIC_INCREMENTING)\nInc: 1\nReset: 0\nInit: 0", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 15, NodeStreamOffset, "stream offset: 1", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 17, NodeOutputMappedReg, "Scalar output (current_run_cycle_count)", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 25, NodeConstantRawBits, "{HWOffsetFix:1, 0, UNSIGNED}\n0x1; 1.0", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 19, NodeConstantRawBits, "{HWOffsetFix:49, 0, UNSIGNED}\n0x1000000000000; 2.81474976710656E14", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 20, NodeCounter, "Counter(NUMERIC_INCREMENTING)\nInc: 1\nReset: 0\nInit: 0", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 22, NodeInputMappedReg, "Scalar input (run_cycle_count)", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 24, NodeEqInlined, "==", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 21, NodeFlush, "flush on trigger", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
#endif

#ifdef SLIC_USE_DEFINITIONS
#include <stdio.h>
#include <math.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
static max_file_t *stored_maxfile = NULL;
static max_engine_t *stored_engine = NULL;
static char *stored_error = NULL;
static int stored_has_error = 0;
static pthread_once_t slic_bs_is_initialised = PTHREAD_ONCE_INIT;

static void set_error(const char *error_str)
{
	stored_has_error = 1; 
	if(stored_error == NULL) {
		stored_error = strdup(error_str);
	} else {
		char *nerr = malloc(strlen(stored_error) + strlen(error_str) + 2);
		sprintf(nerr, "%s\n%s", stored_error, error_str);
		free(stored_error);
		stored_error = nerr;
	}
}
static void set_error_and_free(char *error_str){
	set_error(error_str);
	free(error_str);
}
int StreamFMA_has_errors(void)
{	return stored_has_error; }
const char* StreamFMA_get_errors(void)
{	return stored_error; }
void StreamFMA_clear_errors(void)
{
	free(stored_error);
	stored_error = NULL;
	stored_has_error = 0;
}

static char StreamFMA_use_simulation[16];
static void StreamFMA_def_use_simulation(void)
{
	long pid = ((long) getpid()) % 100000;
	snprintf(StreamFMA_use_simulation, 16, "StreamFM_%05ld_", pid);
}
static const char *StreamFMA_check_use_simulation(void)
{
	StreamFMA_def_use_simulation();
	const char *use_sim = max_config_get_string(MAX_CONFIG_USE_SIMULATION);
	if (use_sim == NULL) {
		use_sim = StreamFMA_use_simulation;
		max_config_set_string(MAX_CONFIG_USE_SIMULATION, use_sim);
	}
	return use_sim;
}

static int StreamFMA_simulation_launch = 0;
int StreamFMA_simulator_start(void)
{
	int retval = 0;
	const char *use_sim = StreamFMA_check_use_simulation();
	char buff[1024];
	snprintf(buff, 1024, "PATH=simutils:$PATH maxcompilersim -d 1 -n %s -c MAX5C -S simutils restart", use_sim);
	FILE *pipe_fp = popen(buff, "r");
	if (pipe_fp == NULL) {
		strncat(buff, " : failed to execute.", (1024 - strlen(buff)));
		set_error(buff);
		return -1;
	}
	while (fgets(buff, 1024, pipe_fp) != NULL) {
		/* Uncomment this to get simulator command output */
		/* fprintf(stderr, buff); */
		if (strstr(buff, "Error")) {
			set_error(buff);
			retval = -1;
		}
	}
	pclose(pipe_fp);
	return retval;
}

int StreamFMA_simulator_stop(void)
{
	const char *use_sim = StreamFMA_check_use_simulation();
	char buff[1024];
	snprintf(buff, 1024, "PATH=simutils:$PATH maxcompilersim -d 1 -n %s -c MAX5C -S simutils stop", use_sim);
	FILE *pipe_fp = popen(buff, "r");
	if (pipe_fp == NULL) {
		strncat(buff, " : failed to execute.", (1024 - strlen(buff)));
		set_error(buff);
		return -1;
	}
	while (fgets(buff, 1024, pipe_fp) != NULL) {
		/* Uncomment this to get simulator command output */
		/* fprintf(stderr, buff); */
		;
	}
	pclose(pipe_fp);
	return 0;
}

static void StreamFMA_static_init(void) 
{
	stored_maxfile = StreamFMA_init();
	if (stored_maxfile == NULL || !max_ok(stored_maxfile->errors)) {
		stored_maxfile = NULL;
		if(max_config_get_bool(MAX_CONFIG_STATIC_INTERFACE_ABORT_ON_ERROR)) abort();
		else { set_error("Unable to load maxfile"); return; }
	}
	if(!max_ok(max_global_errors())) {
		set_error_and_free(max_errors_trace(max_global_errors()));
		return;
	}
	if(!max_config_get_bool(MAX_CONFIG_STATIC_INTERFACE_ABORT_ON_ERROR))
		max_errors_mode(stored_maxfile->errors, 0);
	time_t timeout_previous = max_load_timeout(stored_maxfile, 30);
	const char *use_sim = StreamFMA_check_use_simulation();
	if (max_ping_daemon(stored_maxfile, use_sim) == 0) {
		int sim_stat = StreamFMA_simulator_start();
		if ((sim_stat == 0) && (max_ping_daemon(stored_maxfile, use_sim) == 1)) {
			StreamFMA_simulation_launch = 1;
		} else {
			set_error("Error: An error occurred while trying to start the simulation infrastructure automatically.");
			set_error("Error: Check that 'use_simulation=<simulator_name>' is set correctly in your SLiC configuration");
			set_error("Error: and that the associated simulated system daemon is running.");
			max_file_free(stored_maxfile);
			stored_maxfile = NULL;
			return;
		}
	}
	stored_engine = max_load(stored_maxfile, "*");
	if (!max_ok(stored_maxfile->errors)) {
		if(max_config_get_bool(MAX_CONFIG_STATIC_INTERFACE_ABORT_ON_ERROR)) {
			fprintf(stderr, "\nUnable to load engine: aborting now.\n\n");
			fflush(stderr);
			abort();
		} else {
			set_error_and_free(max_errors_trace(stored_maxfile->errors));
			max_file_free(stored_maxfile);
			stored_maxfile = NULL;
			return;
		} 
	} 
	max_load_timeout(stored_maxfile, timeout_previous);
}
void StreamFMA_free(void)
{
	if (stored_engine != NULL) {
		max_unload(stored_engine);
		stored_engine = NULL;
	}
	if (stored_maxfile != NULL) {
		max_file_free(stored_maxfile);
		stored_maxfile = NULL;
	}
	if (stored_error != NULL) {
		free(stored_error);
		stored_error = NULL;
	}
	if (StreamFMA_simulation_launch == 1) {
		int sim_stat = StreamFMA_simulator_stop();
		if (sim_stat != 0 ) {
			fprintf(stderr, "Error stopping simulator.");
		}
		StreamFMA_simulation_launch = 0;
	}
}

static int StreamFMA_get_pcie_alignment(void)
{
#ifdef StreamFMA_PCIE_ALIGNMENT
	return ((StreamFMA_PCIE_ALIGNMENT < 1) ? 16 : StreamFMA_PCIE_ALIGNMENT);
#else
	return 16;
#endif
}

static int StreamFMA_check_aligned(const void *data)
{
	uintptr_t pointer = (uintptr_t) data;
	int alignment = StreamFMA_get_pcie_alignment();
	return (pointer % alignment) ? 1 : 0;
}

static void *StreamFMA_malloc_aligned(const size_t size)
{
	void *ptr;
	int alignment = StreamFMA_get_pcie_alignment();
	posix_memalign(&ptr, alignment, size);
	return ptr;
}



/*----------------------------------------------------------------------------*/
/*---------------------------- Interface default -----------------------------*/
/*----------------------------------------------------------------------------*/



#define CHECK_ERRORS_ST(ST, RET) if(!max_ok(ST->errors)) { if(max_config_get_bool(MAX_CONFIG_STATIC_INTERFACE_ABORT_ON_ERROR)) { fprintf(stderr, "%s\n", max_errors_trace(ST->errors)); abort(); } set_error_and_free(max_errors_trace(ST->errors)); return RET; } 
#define CHECK_NULL(VALUE, MESSAGE, RET) if(VALUE == NULL) { if (max_config_get_bool(MAX_CONFIG_STATIC_INTERFACE_ABORT_ON_ERROR)) { fprintf(stderr, "%s\n%s\n", (stored_error == NULL) ? "" : stored_error, MESSAGE); abort(); } set_error(MESSAGE); return RET; }

 
typedef struct StreamFMA_callback_stream {
	uint8_t *user_ptr;
	uint8_t *aligned_ptr;
	size_t   size;
	int      is_output;
} StreamFMA_callback_stream_t;

typedef struct StreamFMA_callback_data {
	StreamFMA_callback_stream_t stream[3]; 
	int count;
	int max_count;
} StreamFMA_callback_data_t;

static void StreamFMA_callback_internal(void *cb_data)
{
	StreamFMA_callback_data_t *data = (StreamFMA_callback_data_t*) cb_data;
	for (int i = 0 ; i < data->count ; i++ ) {
		StreamFMA_callback_stream_t *s = &data->stream[i];
		if (s->is_output && (s->size > 0)) {
			memcpy(s->user_ptr, s->aligned_ptr, s->size);
		}
		free(s->aligned_ptr);
	}
	free(data);
}

static max_actions_t* StreamFMA_convert_internal(
	max_file_t *maxfile,
	StreamFMA_actions_t *interface_actions,
	int  is_internal_call,
	void (**callback_func)(void*),
	void **callback_data)
{
	max_actions_t *actions = max_actions_init(maxfile, NULL);
	if(actions == NULL) return NULL;

#define CHECK_ERRORS if(!max_ok(actions->errors)) { set_error_and_free(max_errors_trace(actions->errors)); return NULL; } 

	StreamFMA_callback_data_t *cb_data = NULL;
	int use_callback = (callback_func != NULL) && (callback_data != NULL);
	if (use_callback) {
		cb_data = malloc(sizeof(StreamFMA_callback_data_t));
		if (cb_data == NULL) {
			fprintf(stderr, "Unable to allocate memory for stream callback data in function StreamFMA_convert_internal\n");
			return NULL;
		}
		cb_data->max_count = 3;
		cb_data->count     = 0;
		*callback_data     = cb_data;
		*callback_func     = &StreamFMA_callback_internal;
	}

	/* code for scalar StreamFMAKernel.run_cycle_count */
	uint64_t ticks_StreamFMAKernel = interface_actions->ticks_StreamFMAKernel;
	max_set_ticks(actions, "StreamFMAKernel", ticks_StreamFMAKernel);
	CHECK_ERRORS;
	/* end of code for scalar StreamFMAKernel.run_cycle_count*/
	
	/* code for stream a */
	size_t instream_size_a = interface_actions->instream_size_a;
	if (instream_size_a > 0) {
		const void *stream_ptr = interface_actions->instream_a;
		if (use_callback && (1 == StreamFMA_check_aligned(interface_actions->instream_a))) {
			void *aligned_instream_a = malloc(instream_size_a);
			if (aligned_instream_a == NULL) {
				max_report_error_slic(actions->errors, __FILE__, __LINE__, 526, "Failed to allocate aligned memory for stream 'a'");
				CHECK_ERRORS;
			}
			(&cb_data->stream[cb_data->count])->user_ptr    = (uint8_t*) interface_actions->instream_a;
			(&cb_data->stream[cb_data->count])->aligned_ptr = (uint8_t*) aligned_instream_a;
			(&cb_data->stream[cb_data->count])->size        = instream_size_a;
			(&cb_data->stream[cb_data->count])->is_output   = 0;
			cb_data->count += 1;
			memcpy(aligned_instream_a, interface_actions->instream_a, instream_size_a);
			stream_ptr = aligned_instream_a;
		}
		max_queue_input(actions, "a", stream_ptr, instream_size_a);
		CHECK_ERRORS;
	}
	/* end of code for stream a */
	
	/* code for stream b */
	size_t instream_size_b = interface_actions->instream_size_b;
	if (instream_size_b > 0) {
		const void *stream_ptr = interface_actions->instream_b;
		if (use_callback && (1 == StreamFMA_check_aligned(interface_actions->instream_b))) {
			void *aligned_instream_b = malloc(instream_size_b);
			if (aligned_instream_b == NULL) {
				max_report_error_slic(actions->errors, __FILE__, __LINE__, 526, "Failed to allocate aligned memory for stream 'b'");
				CHECK_ERRORS;
			}
			(&cb_data->stream[cb_data->count])->user_ptr    = (uint8_t*) interface_actions->instream_b;
			(&cb_data->stream[cb_data->count])->aligned_ptr = (uint8_t*) aligned_instream_b;
			(&cb_data->stream[cb_data->count])->size        = instream_size_b;
			(&cb_data->stream[cb_data->count])->is_output   = 0;
			cb_data->count += 1;
			memcpy(aligned_instream_b, interface_actions->instream_b, instream_size_b);
			stream_ptr = aligned_instream_b;
		}
		max_queue_input(actions, "b", stream_ptr, instream_size_b);
		CHECK_ERRORS;
	}
	/* end of code for stream b */
	
	/* code for stream output */
	size_t outstream_size_output = interface_actions->outstream_size_output;
	if (outstream_size_output > 0) {
		void *stream_ptr = interface_actions->outstream_output;
		if (use_callback && (1 == StreamFMA_check_aligned(interface_actions->outstream_output))) {
			void *aligned_outstream_output = malloc(outstream_size_output);
			if (aligned_outstream_output == NULL) {
				max_report_error_slic(actions->errors, __FILE__, __LINE__, 526, "Failed to allocate aligned memory for stream 'output'");
				CHECK_ERRORS;
			}
			(&cb_data->stream[cb_data->count])->user_ptr    = (uint8_t*) interface_actions->outstream_output;
			(&cb_data->stream[cb_data->count])->aligned_ptr = (uint8_t*) aligned_outstream_output;
			(&cb_data->stream[cb_data->count])->size        = outstream_size_output;
			(&cb_data->stream[cb_data->count])->is_output   = 1;
			cb_data->count += 1;
			stream_ptr = aligned_outstream_output;
		}
		max_queue_output(actions, "output", stream_ptr, outstream_size_output);
		CHECK_ERRORS;
	}
	/* end of code for stream output */
	
	if (use_callback && cb_data->count == 0) {
		*callback_data = NULL;
		*callback_func = NULL;
		free(cb_data);
	}
	return actions;
#undef CHECK_ERRORS
}

void StreamFMA(
	uint64_t ticks_StreamFMAKernel,
	const void *instream_a,
	size_t instream_size_a,
	const void *instream_b,
	size_t instream_size_b,
	void *outstream_output,
	size_t outstream_size_output)
{
	(void) pthread_once(&slic_bs_is_initialised, StreamFMA_static_init);
	CHECK_NULL(stored_maxfile, "Maxfile was not loaded", );
	max_run_t *run = StreamFMA_nonblock(ticks_StreamFMAKernel, instream_a, instream_size_a, instream_b, instream_size_b, outstream_output, outstream_size_output);
	CHECK_NULL(run, "Unable to run actions", );
	max_wait(run);
}

max_run_t *StreamFMA_nonblock(
	uint64_t ticks_StreamFMAKernel,
	const void *instream_a,
	size_t instream_size_a,
	const void *instream_b,
	size_t instream_size_b,
	void *outstream_output,
	size_t outstream_size_output)
{
	StreamFMA_actions_t interface_actions;
	interface_actions.ticks_StreamFMAKernel = ticks_StreamFMAKernel;
	interface_actions.instream_a = instream_a;
	interface_actions.instream_size_a = instream_size_a;
	interface_actions.instream_b = instream_b;
	interface_actions.instream_size_b = instream_size_b;
	interface_actions.outstream_output = outstream_output;
	interface_actions.outstream_size_output = outstream_size_output;
	(void) pthread_once(&slic_bs_is_initialised, StreamFMA_static_init);
	CHECK_NULL(stored_maxfile, "Maxfile was not loaded", NULL);
	void (*cb_func)(void*) = NULL;
	void  *cb_data         = NULL;
	max_actions_t *actions = StreamFMA_convert_internal(stored_maxfile, &interface_actions, 1, &cb_func, &cb_data);
	CHECK_NULL(actions, "Unable to build actions", NULL);
	max_validate(actions);
	CHECK_ERRORS_ST(actions, NULL);
	CHECK_ERRORS_ST(stored_engine, NULL);
	max_run_t *run;
	if (cb_func == NULL) {
		run = max_run_nonblock(stored_engine, actions);
	} else {
		run = max_run_nonblock_with_cb(stored_engine, actions, cb_func, cb_data);
	}
	CHECK_NULL(run, "Unable to run actions", NULL);
	CHECK_ERRORS_ST(actions, NULL);
	max_actions_free(actions);
	return run;
}

void StreamFMA_run(
	max_engine_t *engine,
	StreamFMA_actions_t *interface_actions)
{
	max_run_t *run = StreamFMA_run_nonblock(engine, interface_actions);
	CHECK_NULL(run, "Unable to run actions", );
	max_wait(run);
}

max_run_t *StreamFMA_run_nonblock(
	max_engine_t *engine,
	StreamFMA_actions_t *interface_actions)
{
	max_file_t *maxfile = max_engine_get_max_file(engine); 
	void (*cb_func)(void*) = NULL;
	void  *cb_data         = NULL;
	max_actions_t *actions = StreamFMA_convert_internal(maxfile, interface_actions, 1, &cb_func, &cb_data);
	CHECK_NULL(actions, "Unable to build actions", NULL);
	max_validate(actions);
	CHECK_ERRORS_ST(actions, NULL);
	max_run_t *run;
	if (cb_func == NULL) {
		run = max_run_nonblock(engine, actions);
	} else {
		run = max_run_nonblock_with_cb(engine, actions, cb_func, cb_data);
	}
	CHECK_NULL(run, "Unable to run actions", NULL);
	max_actions_free(actions);
	return run;
}


/**
 * \brief Group run advanced static function for the interface 'default'.
 * 
 * \param [in] group Group to use.
 * \param [in,out] interface_actions Actions to run.
 *
 * Run the actions on the first device available in the group.
 */
void StreamFMA_run_group(max_group_t *group, StreamFMA_actions_t *interface_actions)
{
	max_run_t *run = StreamFMA_run_group_nonblock(group, interface_actions);
	CHECK_NULL(run, "Unable to run actions", );
	max_wait(run);
}


/**
 * \brief Group run advanced static non-blocking function for the interface 'default'.
 * 
 *
 * Schedule the actions to run on the first device available in the group and return immediately.
 * The status of the run must be checked with ::max_wait. 
 * Note that use of ::max_nowait is prohibited with non-blocking running on groups:
 * see the ::max_run_group_nonblock documentation for more explanation.
 *
 * \param [in] group Group to use.
 * \param [in] interface_actions Actions to run.
 * \return A handle on the execution status of the actions, or NULL in case of error.
 */
max_run_t *StreamFMA_run_group_nonblock(max_group_t *group, StreamFMA_actions_t *interface_actions)
{
	max_file_t *maxfile = max_group_get_max_file(group);
	max_actions_t *actions = StreamFMA_convert_internal(maxfile, interface_actions, 1, NULL, NULL);
	if(actions == NULL) return NULL;
	if(!max_ok(actions->errors)) return NULL;
	max_validate(actions);
	max_run_t *run = max_run_group_nonblock(group, actions);
	max_actions_free(actions);
	return run;
}


/**
 * \brief Array run advanced static function for the interface 'default'.
 * 
 * \param [in] engarray The array of devices to use.
 * \param [in,out] interface_actions The array of actions to run.
 *
 * Run the array of actions on the array of engines.  The length of interface_actions
 * must match the size of engarray.
 */
void StreamFMA_run_array(max_engarray_t *engarray, StreamFMA_actions_t *interface_actions[])
{
	max_run_t *run = StreamFMA_run_array_nonblock(engarray, interface_actions);
	CHECK_NULL(run, "Unable to run actions", );
	max_wait(run);
}


/**
 * \brief Array run advanced static non-blocking function for the interface 'default'.
 * 
 *
 * Schedule to run the array of actions on the array of engines, and return immediately.
 * The length of interface_actions must match the size of engarray.
 * The status of the run can be checked either by ::max_wait or ::max_nowait;
 * note that one of these *must* be called, so that associated memory can be released.
 *
 * \param [in] engarray The array of devices to use.
 * \param [in] interface_actions The array of actions to run.
 * \return A handle on the execution status of the actions, or NULL in case of error.
 */
max_run_t *StreamFMA_run_array_nonblock(max_engarray_t *engarray, StreamFMA_actions_t *interface_actions[])
{
	max_file_t *maxfile = max_engarray_get_max_file(engarray, 0);
	int i;
	max_actarray_t *actarray = max_actarray_init(maxfile, engarray->size);
	if (actarray == NULL) return NULL;
	max_actions_t **arr_actions = malloc(engarray->size * sizeof(max_actions_t*));
	for ( i = 0 ; i < actarray->size; i++ ) {
		max_actions_t *actions = StreamFMA_convert_internal(maxfile, interface_actions[i], 1, NULL, NULL);
		if (actions == NULL) return NULL;
		arr_actions[i] = actions;
		max_set_action(actarray, i, actions);
	}
	max_run_t *run = max_run_array_nonblock(engarray, actarray);
	for ( i = 0 ; i < actarray->size ; i++ ) { max_actions_free(arr_actions[i]); }
	max_actarray_free(actarray);
	free(arr_actions);
	return run;
}


/**
 * \brief Converts a static-interface action struct into a dynamic-interface max_actions_t struct.
 *
 * Note that this is an internal utility function used by other functions in the static interface.
 *
 * \param [in] maxfile The maxfile to use.
 * \param [in] interface_actions The interface-specific actions to run.
 * \return The dynamic-interface actions to run, or NULL in case of error.
 */
max_actions_t* StreamFMA_convert(max_file_t *maxfile, StreamFMA_actions_t *interface_actions)
{
	return StreamFMA_convert_internal(maxfile, interface_actions, 0, NULL, NULL);
}

#undef CHECK_ERRORS_ST
#undef CHECK_NULL



#endif /* SLIC_USE_DEFINITIONS */

#ifdef SLIC_DYNAMIC_CODE
SLIC_MODE_START(default)	
SLIC_MODE_END(default)

#endif /* SLIC_DYNAMIC_CODE */

#ifdef SKIN_META_DATA
PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9Im5vIj8+PG1h
eGZpbGUgZm9ybWF0LXZlcnNpb249IjIwMTIwMjAwIiBoZWFkZXI9IlN0cmVhbUZNQS5oIiBuYW1l
PSJTdHJlYW1GTUEiPjxjb25zdGFudCBuYW1lPSJEWU5BTUlDX0NMT0NLU19FTkFCTEVEIiB0eXBl
PSJsb25nIiB2YWx1ZT0iMCIvPjxjb25zdGFudCBuYW1lPSJQQ0lFX0FMSUdOTUVOVCIgdHlwZT0i
bG9uZyIgdmFsdWU9IjE2Ii8+PGVuZ2luZW1vZGUgbmFtZT0iZGVmYXVsdCI+PGZ1bmN0aW9uIG5h
bWU9IlN0cmVhbUZNQSIgcmV0dXJuLXZhbHVlPSJ2b2lkIj48c2NhbGFyIGRlc2M9IlRoZSBudW1i
ZXIgb2YgdGlja3MgZm9yIHdoaWNoIGtlcm5lbCAmcXVvdDtTdHJlYW1GTUFLZXJuZWwmcXVvdDsg
d2lsbCBydW4uIiBkaXJlY3Rpb249IklucHV0IiBuYW1lPSJ0aWNrc19TdHJlYW1GTUFLZXJuZWwi
IHR5cGU9InVpbnQ2NF90Ii8+PGFycmF5IGRlc2M9IlN0cmVhbSAmcXVvdDthJnF1b3Q7LiIgZGly
ZWN0aW9uPSJJbnB1dCIgbmFtZT0iaW5zdHJlYW1fYSIgc2l6ZT0iaW5zdHJlYW1fc2l6ZV9hIiB0
cmFuc3Bvc2U9ImZhbHNlIiB0eXBlPSJ2b2lkIi8+PHNjYWxhciBkZXNjPSJUaGUgc2l6ZSBvZiB0
aGUgc3RyZWFtIGluc3RyZWFtX2EgaW4gYnl0ZXMuIiBkaXJlY3Rpb249IklucHV0IiBuYW1lPSJp
bnN0cmVhbV9zaXplX2EiIHR5cGU9InVpbnQ2NF90Ii8+PGFycmF5IGRlc2M9IlN0cmVhbSAmcXVv
dDtiJnF1b3Q7LiIgZGlyZWN0aW9uPSJJbnB1dCIgbmFtZT0iaW5zdHJlYW1fYiIgc2l6ZT0iaW5z
dHJlYW1fc2l6ZV9iIiB0cmFuc3Bvc2U9ImZhbHNlIiB0eXBlPSJ2b2lkIi8+PHNjYWxhciBkZXNj
PSJUaGUgc2l6ZSBvZiB0aGUgc3RyZWFtIGluc3RyZWFtX2IgaW4gYnl0ZXMuIiBkaXJlY3Rpb249
IklucHV0IiBuYW1lPSJpbnN0cmVhbV9zaXplX2IiIHR5cGU9InVpbnQ2NF90Ii8+PGFycmF5IGRl
c2M9IlN0cmVhbSAmcXVvdDtvdXRwdXQmcXVvdDsuIiBkaXJlY3Rpb249Ik91dHB1dCIgbmFtZT0i
b3V0c3RyZWFtX291dHB1dCIgc2l6ZT0ib3V0c3RyZWFtX3NpemVfb3V0cHV0IiB0cmFuc3Bvc2U9
ImZhbHNlIiB0eXBlPSJ2b2lkIi8+PHNjYWxhciBkZXNjPSJUaGUgc2l6ZSBvZiB0aGUgc3RyZWFt
IG91dHN0cmVhbV9vdXRwdXQgaW4gYnl0ZXMuIiBkaXJlY3Rpb249IklucHV0IiBuYW1lPSJvdXRz
dHJlYW1fc2l6ZV9vdXRwdXQiIHR5cGU9InVpbnQ2NF90Ii8+PC9mdW5jdGlvbj48L2VuZ2luZW1v
ZGU+PC9tYXhmaWxlPg==
#endif /* SKIN_META_DATA */

#ifdef SLIC_B64_DEFINITIONS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#endif /* SLIC_B64_DEFINITIONS */

#ifdef SLIC_EXTRA_FILES
PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9Im5vIj8+PHVz
ZXJmaWxlcyBmb3JtYXQtdmVyc2lvbj0iMjAxMjAyMDAiLz4=
#endif /* SLIC_EXTRA_FILES */

#ifdef PHOTON_NODE_ADD_DATA
#define PHOTON_NODE_ADD_DATA_PRESENT 1
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 8, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 9, "SquashFactor", 1.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 0, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 1, "SquashFactor", 1.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 2, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 3, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 4, "SquashFactor", 1.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 5, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 6, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 11, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 16, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 26, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 13, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 14, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 15, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 17, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 25, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 19, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 20, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 22, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 24, "SquashFactor", 0.0)
PHOTON_NODE_ADD_DATA(StreamFMAKernel, 21, "SquashFactor", 0.0)
#endif

#ifdef MAXFILE_SIGNATURE
#define MAXFILE_SIGNATURE_PRESENT 1
MAXFILE_SIGNATURE("302c021403bb77cd00b6cbb7e95b17f03f1a583509e1176802144b3bd7c15b0c30281360483daae602853543039c")
#endif

#ifdef PARAM
#define PARAM_PRESENT 1
PARAM(TIMING_SCORE, 0)
#endif

#ifdef BITSTREAM
#error You are using too old sliccompile to compile this maxfile.
#endif
#ifdef BITSTREAM_NEW
#define BITSTREAM_COMPRESSED 1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#endif

#ifdef PARAM
PARAM(BITSTREAM_SIZE, 289368)
#endif