/**
 * Document: MaxCompiler Tutorial (maxcompiler-tutorial.pdf)
 * Chapter: 13      Example: 2      Name: LMem Loopback
 * MaxFile name: LMemLoopback
 * Summary:
 *       Connects the Kernel's input / output streams to LMem. Also creates one
 *  input and one output stream for accessing the LMem directly from the CPU
 *  software.
 */

package perfmodels;

import com.maxeler.maxcompiler.v2.build.EngineParameters;
import com.maxeler.maxcompiler.v2.kernelcompiler.Kernel;
import com.maxeler.maxcompiler.v2.managers.custom.DFELink;
import com.maxeler.maxcompiler.v2.managers.custom.blocks.KernelBlock;
import com.maxeler.maxcompiler.v2.managers.custom.stdlib.LMemCommandGroup;
import com.maxeler.maxcompiler.v2.managers.custom.stdlib.LMemInterface;
import com.maxeler.maxcompiler.v2.managers.engine_interfaces.CPUTypes;
import com.maxeler.maxcompiler.v2.managers.engine_interfaces.EngineInterface;
import com.maxeler.maxcompiler.v2.managers.engine_interfaces.EngineInterface.Direction;
import com.maxeler.maxcompiler.v2.managers.engine_interfaces.InterfaceParam;
import com.maxeler.platform.max5.manager.MAX5CManager;

public class LMemLoopbackMAX5CManager extends MAX5CManager {

	private static final CPUTypes TYPE = CPUTypes.INT32;

	public LMemLoopbackMAX5CManager(EngineParameters params) {
		super(params);

		Kernel kernel = new LMemLoopbackKernel(makeKernelParameters("LMemLoopbackKernel"));
		KernelBlock kernelBlock = addKernel(kernel);

		LMemInterface iface = addLMemInterface();
		DFELink cpu2lmem = iface.addStreamToLMem("cpu2lmem", LMemCommandGroup.MemoryAccessPattern.LINEAR_1D);
		DFELink lmem2cpu = iface.addStreamFromLMem("lmem2cpu", LMemCommandGroup.MemoryAccessPattern.LINEAR_1D);

		DFELink fromcpu = addStreamFromCPU("fromcpu");
		DFELink tocpu = addStreamToCPU("tocpu");

		cpu2lmem <== fromcpu;
		tocpu <== lmem2cpu;

		DFELink inA = iface.addStreamFromLMem("inA", LMemCommandGroup.MemoryAccessPattern.LINEAR_1D);
		DFELink inB = iface.addStreamFromLMem("inB", LMemCommandGroup.MemoryAccessPattern.LINEAR_1D);

		kernelBlock.getInput("inA") <== inA;
		kernelBlock.getInput("inB") <== inB;

		DFELink oData = iface.addStreamToLMem("oData", LMemCommandGroup.MemoryAccessPattern.LINEAR_1D);
		oData <== kernelBlock.getOutput("oData");

		createSlicInterface(interfaceDefault());
		createSlicInterface(interfaceWrite("writeLMem"));
		createSlicInterface(interfaceRead("readLMem"));
	}

	public static void main(String[] args) {
		LMemLoopbackMAX5CManager manager = new LMemLoopbackMAX5CManager(new EngineParameters(args));
		manager.build();
	}

	private static EngineInterface interfaceDefault() {
		EngineInterface ei = new EngineInterface();

		InterfaceParam N    = ei.addParam("N", TYPE);
		InterfaceParam zero = ei.addConstant(0l);
		ei.setTicks("LMemLoopbackKernel", N);
		InterfaceParam sizeInBytes = N * TYPE.sizeInBytes();

		ei.setLMemLinear("inA", zero, sizeInBytes);
		ei.setLMemLinear("inB", sizeInBytes, sizeInBytes);
		ei.setLMemLinear("oData", 2 * sizeInBytes, sizeInBytes);
		ei.ignoreAll(Direction.IN_OUT);
		return ei;
	}

	private static EngineInterface interfaceWrite(String name) {
		EngineInterface ei = new EngineInterface(name);

		InterfaceParam size  = ei.addParam("size", TYPE);
		InterfaceParam start = ei.addParam("start", TYPE);
		InterfaceParam sizeInBytes = size * TYPE.sizeInBytes();

		ei.setStream("fromcpu", TYPE, sizeInBytes );
		ei.setLMemLinear("cpu2lmem", start * TYPE.sizeInBytes(), sizeInBytes);
		ei.ignoreAll(Direction.IN_OUT);
		return ei;
	}

	private static EngineInterface interfaceRead(String name) {
		EngineInterface ei = new EngineInterface(name);

		InterfaceParam size  = ei.addParam("size", TYPE);
		InterfaceParam start = ei.addParam("start", TYPE);
		InterfaceParam sizeInBytes = size * TYPE.sizeInBytes();

		ei.setLMemLinear("lmem2cpu", start * TYPE.sizeInBytes(), sizeInBytes);
		ei.setStream("tocpu", TYPE, sizeInBytes);
		ei.ignoreAll(Direction.IN_OUT);
		return ei;
	}

}