[QUESTION][struct_support] load struct

[DramaDesu]

Hello!
Could you explain me or show me how I can load some data form ptr to my simd struct. There's some cast or convert?

struct vec3 : eve::struct_support<vec3, float, float, float>
{
	using eve_disable_ordering = void;
};

I need to load some data from float* to vec3.
Thanks.

[DenisYaroshevskiy]

Hi.

So - bad news - if you want it like this, it's not supported very well.

1. The good option.

We recommend using SoA for simd.
If you can, use eve::algo::soa_vector
https://jfalcou.github.io/eve/structeve_1_1algo_1_1soa__vector.html#a1cfd01b1cec55dd3fab8e0c6809764f4
And then all the algorithms and everything will work.

2. The bad option.

If you want to use std::vector<vec3> that's going to be quite slow.
We also don't have amazing support for it.

If you do the same operation for all of them - just cast to float*.
You can also do some masking, but since it's vec3 it won't be easy and you can't just use existing algorithm.

If you want to build wide<vec3> - you'd need to deinterleave the data somehow.

The easiest way to do it is with gather BUT IT'S BAD:

// This is pretty bad
eve::wide<kumi::tuple<int, int, int>> option1(const int* ptr) {
  const eve::wide<std::uint32_t> every_third {
    [](int i, int) { return i * 3; }
  };
  return eve::wide<kumi::tuple<int, int, int>>{
    eve::gather(ptr, every_third),
    eve::gather(ptr + 1, every_third),
    eve::gather(ptr + 2, every_third),
  };
}

You can also try to shuffle registers together but it's hard.
The shuffles we have in eve at the moment won't help you - just not implemented well enough for this.

You can try your luck with __builtin_shufflevector from clang/gcc.

[DenisYaroshevskiy]

Here is how you use builtin_shuffle with eve:
https://godbolt.org/z/7KW376sdq

[DramaDesu]

Hello Denis, thank you for supporting.

1. I'm considering soa, and it'll work with some small changes in my code, like add some operators. I've already optimized AABB for simd.

The only thing stopping me is the transformation from AOS to SOA, most of it is memory. Models in memory are around 100 megabytes, I don't want to have to convert everything all the time, on the other hand, I can rewrite everything to SOA, but then I have to convert it before sending it to GPU, dilemma.

2. I'm considering this options, yes it seems like a bad option, but any way. I've tried the same, but main idea to fits all vectors for current iteration and repeat. I wish I could load data with diff count of registers.

using wide_t = eve::wide<float>;
wide_t locations[3];

// n - count of vectors
while (n > 0)
{
	for (int i = 0; i < 3; ++i) {
		const auto left = n < wide_t::size() ? n : wide_t::size();

		locations[i] = eve::load(source);
		// locations[i] = (locations[i] - pivots[i]) * scales[i]; // transforms and store some where

		n = n - left;
		source = source + left;
		if (n == 0) break;
	}
}

Thank you, I might consider builtin_shuffle.

[jfalcou]

why would you need to convert back for GPU ? I guess your kernels are already written or is it for display purpose ?

[DramaDesu]

Hello, you're right, it's already written for display purpose (I use the same data to process), I use opengl to send it to GPU. Maybe there's another way to load it? I don't know :)

glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);

glBindVertexArray(VAO);

glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(Geometry::Mesh::Vertex) * in_loaded_mesh->vertex.size(), in_loaded_mesh->vertex.data(), GL_STATIC_DRAW);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(int32_t) * in_loaded_mesh->indices.size(), in_loaded_mesh->indices.data(), GL_STATIC_DRAW);

// Coords
glVertexAttribPointer(0, glm::vec3::length(), GL_FLOAT, GL_FALSE, sizeof(Geometry::Mesh::Vertex), nullptr);
glEnableVertexAttribArray(0);
// Normal
glVertexAttribPointer(1, glm::vec3::length(), GL_FLOAT, GL_FALSE, sizeof(Geometry::Mesh::Vertex), reinterpret_cast<void*>(offsetof(Geometry::Mesh::Vertex, normal)));
glEnableVertexAttribArray(1);
// UV
glVertexAttribPointer(2, glm::vec2::length(), GL_FLOAT, GL_FALSE, sizeof(Geometry::Mesh::Vertex), reinterpret_cast<void*>(offsetof(Geometry::Mesh::Vertex, uv)));
glEnableVertexAttribArray(2);
// Color
glVertexAttribPointer(3, glm::vec3::length(), GL_FLOAT, GL_FALSE, sizeof(Geometry::Mesh::Vertex), reinterpret_cast<void*>(offsetof(Geometry::Mesh::Vertex, color)));
glEnableVertexAttribArray(3);

glBindVertexArray(0);

indexes = in_loaded_mesh->indices.size();

vertex.data() is AOS

[DramaDesu]

In any case, it turns out that I'll need to do transformation from SOA to AOS