I tried rewriting it with raw arrays (without really knowing what sizes of tensors you are using), seems much faster
std::vector<at::Tensor> lltm_forward2(torch::Tensor dummy, torch::Tensor mult1, int element_per_filter, int mult1_shape_0, int y_index_2, int mult1_shape_1)
{
	TORCH_CHECK(dummy.is_contiguous(), " dummy must be a continous tensor");
	TORCH_CHECK(mult1.is_contiguous(), " mult1 must be a continous tensor");
	TORCH_CHECK(!dummy.is_cuda(), " dummy can't be CUDA tensor");
	TORCH_CHECK(!mult1.is_cuda(), " mult1 can't be CUDA tensor");

	auto dummyPtr = dummy.data_ptr<float>();
	auto mult1Ptr = mult1.data_ptr<float>();

	const size_t dummyPtr_stride = dummy.size(1);
	const size_t mult1Ptr_stride = mult1.size(1);

	int iterator = 0;
	float number = 0.0f;

	int temp = 0;
	int filternumber = -1;

	for (int i = 0; i < mult1_shape_0 + 1; i = i + y_index_2)
	{
		for (int j = 0; j < mult1_shape_1; j++)
		{
			number = 0.0f;

			for (int k = iterator; k < i; k++)
			{
				number += mult1Ptr[k * mult1Ptr_stride + j];
				temp = k;
			}

			dummyPtr[temp * dummyPtr_stride + j] = number;
		}
	}

	return { dummy };
}

Tested it with this:
void main(int argc, char** argv)
{
	try
	{
		int SZ1 = 30;
		int SZ2 = 40;

		torch::Tensor dummySrc = torch::randn({ SZ1, SZ2 });
		torch::Tensor mult1Src = torch::randn({ SZ1, SZ2 });

		torch::Tensor result1, result2;

		{
			auto dummy = dummySrc.detach().clone();
			auto mult1 = mult1Src.detach().clone();
			std::chrono::steady_clock::time_point begin1 = std::chrono::steady_clock::now();
			auto output1 = lltm_forward(dummy, mult1, 0, mult1.size(0), 1, mult1.size(1));
			std::chrono::steady_clock::time_point end1 = std::chrono::steady_clock::now();
			std::cout << "Time difference = " << std::chrono::duration_cast<std::chrono::microseconds>(end1 - begin1).count() << "[µs]" << std::endl;
			result1 = output1[0];

			//std::cout << output1[0] << std::endl;
		}

		{
			auto dummy = dummySrc.detach().clone();
			auto mult1 = mult1Src.detach().clone();
			std::chrono::steady_clock::time_point begin2 = std::chrono::steady_clock::now();
			auto output2 = lltm_forward2(dummy, mult1, 0, mult1.size(0), 1, mult1.size(1));
			std::chrono::steady_clock::time_point end2 = std::chrono::steady_clock::now();
			std::cout << "Time difference = " << std::chrono::duration_cast<std::chrono::microseconds>(end2 - begin2).count() << "[µs]" << std::endl;

			result2 = output2[0];

			//std::cout << output2[0] << std::endl;
		}

		std::cout << "Max error: " << (result2 - result1).abs().max() << std::endl;

		system("PAUSE"); return;
	}
	catch (std::runtime_error& e)
	{
		std::cout << e.what() << std::endl;
	}
	catch (const c10::Error& e)
	{
		std::cout << e.msg() << std::endl;
	}

	system("PAUSE");
}

EDIT: fixed stride values
EDIT2: changes from C++ assert to TORCH_CHECK