starpu-max/tests/StreamFMA_MAX5C_DFE_SIM/scratch/StreamFMA.max

#ifdef MAXCOMPILER_VERSION_INFO
#define MAXCOMPILER_VERSION_INFO_PRESENT 1
#define MAXFILE_MAXCOMPILER_VERSION_YEAR         2018
#define MAXFILE_MAXCOMPILER_VERSION_NUM          3
#define MAXFILE_MAXCOMPILER_VERSION_POINT        1
#define MAXFILE_MAXCOMPILER_VERSION_PATCH        ""
#define MAXFILE_MAXCOMPILER_VERSION_REV          "b189b8e"
#define MAXFILE_MAXCOMPILER_VERSION_RELEASE_DATE "2019-01-09"
#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/makni3/starpu.git/tests/./StreamFMA_MAX5C_DFE_SIM"
#define MAXFILE_BUILD_DATE  20191029
#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, false)
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(b, PCIePushSourceSync16, "b")
MANAGER_NODE_CPP_SIM_MODEL_CTOR(a, PCIePushSourceSync16, "a")
MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_15, FifoPushToPullSync, "Stream_15", false, 512, 128)
MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_11, FifoPushToPullSync, "Stream_11", 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_17, FifoPushToPullSync, "Stream_17", false, 512, 32)
MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_13, FifoPushToPullSync, "Stream_13", 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", "ac5fbbbe6e4b46179c07a7a26c8647de7cec6bb27a42f5ac58fd3d986dbdfa72")
#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(b, STREAM_FROM_HOST, 0)
PCIE_STREAM(a, 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("ac5fbbbe6e4b46179c07a7a26c8647de7cec6bb27a42f5ac58fd3d986dbdfa72")
#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("302c02143578f5aee3b838f55f88f02510321eee5917f7ab021400efececa243f79c7dc512190b3fd86bf70d0c0f")
#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