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/makni1/starpu.git/tests/./StreamFMA_MAX5C_DFE_SIM"
#define MAXFILE_BUILD_DATE  20190806
#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)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
MANAGER_NODE_STACK_TRACE(a, "com.maxeler.platform.max5.manager.Max5ManagerBase.addStreamFromCPU(Unknown Source)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:14)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
MANAGER_NODE_STACK_TRACE(b, "com.maxeler.platform.max5.manager.Max5ManagerBase.addStreamFromCPU(Unknown Source)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:15)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
MANAGER_NODE_STACK_TRACE(output, "com.maxeler.platform.max5.manager.Max5ManagerBase.addStreamToCPU(Unknown Source)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:16)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
MANAGER_NODE_STACK_TRACE(Stream_1, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_4, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_8, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_21, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_11, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_15, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_13, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_17, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n")
MANAGER_NODE_STACK_TRACE(Stream_19, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.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", "ac5fbbbe6e4b46179c07a7a26c8647de0de48fefece43aedcc48ed718ab8231f")
#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("ac5fbbbe6e4b46179c07a7a26c8647de0de48fefece43aedcc48ed718ab8231f")
#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)\nperfmodels.StreamFMAKernel.<init>(StreamFMAKernel.maxj:21)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 9, NodeNot, "~", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.output(IO.java:836)\nperfmodels.StreamFMAKernel.<init>(StreamFMAKernel.maxj:21)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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)\nperfmodels.StreamFMAKernel.<init>(StreamFMAKernel.maxj:15)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 1, NodeNot, "~", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\nperfmodels.StreamFMAKernel.<init>(StreamFMAKernel.maxj:15)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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)\nperfmodels.StreamFMAKernel.<init>(StreamFMAKernel.maxj:15)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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)\nperfmodels.StreamFMAKernel.<init>(StreamFMAKernel.maxj:16)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 4, NodeNot, "~", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\nperfmodels.StreamFMAKernel.<init>(StreamFMAKernel.maxj:16)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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)\nperfmodels.StreamFMAKernel.<init>(StreamFMAKernel.maxj:16)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 6, NodeAdd, "+", "com.maxeler.maxcompiler.v2.kernelcompiler.types.base.DFEVar.add(DFEVar.java:1010)\nperfmodels.StreamFMAKernel.<init>(StreamFMAKernel.maxj:19)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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)\nperfmodels.StreamFMAKernel.<init>(StreamFMAKernel.maxj:21)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 15, NodeStreamOffset, "stream offset: 1", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 24, NodeEqInlined, "==", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n")
PHOTON_NODE_DATA(StreamFMAKernel, 21, NodeFlush, "flush on trigger", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.<init>(StreamFMAManager.maxj:13)\nperfmodels.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("302c021461a601567e38d5664b44983cf48ec81fd01b7e0502144f49e4059e4317ae3c55b895000584a51207a3de")
#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