[QUESTION] Struct deserialization

[DramaDesu]

Hello there!
I'm wondering, If I could eve::compress or eve::copy_if by bytes?
I have a struct:

size: uint8_t;
indices[size]: uint32;

I need to convert array of uint32.
Is it possible to do it in vector way, not just scalar. I've checked via godbolt, it hasn't been vectorized.

using face_t = std::uint32_t;

constexpr size_t face_num = 3;
constexpr size_t face_count = 1'000'000;

constexpr size_t face_struct_size = face_num * sizeof(face_t) + 1;

void convert_to_index_scalar(std::span<std::uint8_t const> in, std::uint8_t* out) {
	const auto faces = in.size_bytes() / face_struct_size;

	for (int i = 0; i < faces; ++i) {
		face_t const* source_face = reinterpret_cast<face_t const*>(in.data() + i * face_struct_size + 1);
		face_t* target_face = reinterpret_cast<face_t*>(out + i * (face_struct_size - 1));
		for (int fi = 0; fi < face_num; ++fi) {
			target_face[fi] = source_face[fi];
		}
	}
}

The scalar maximum approach is optimized by a single xmm0 (the lastest msvc).

[DenisYaroshevskiy]

Hi

1. MSVC unfortunately still isn't working, so if you need to support MSVC - I don't think we can help you.

2. copy_if by bytes absolutely works, but judging by what you wrote, this is not what you want. Never the less, here is an example: https://godbolt.org/z/Exqf8P9EM (there is a weird scalar unrolled - that looks like questionable, I will dig into that, gcc does less of it. [BUG] clang generates bizzare unrolled scalar code on copy_if #1885).
   The main simd loop looks OK.

3. It seems to me that you are trying to copy certain fields of the struct, is that fair to say? I find the byte manipulation code a bit non obvious - can you maybe write the code with structs? If you didn't do it because of the pointer alignment, let's address that separately.

[DramaDesu]

1. Almost no problems with MSVC if it's updated to the latest commits, but not the latest 2023 release. But since it has some issues, I'll move to mingw

2. Thank you, you're right. Great example. I see, but maybe in this case, it's not aligned, is it possible to pass to lambda index of byte?

3. It's a simple library for parsing PLY, just looking how to improve it for loading. Yes, it's mapping and simple byte manipulation. To be honest I've forgotten to align address.

namespace PLY {
	struct Data {
		struct vec2 { float x, y; };
		struct vec3 { float x, y, z; };
		struct color { uint8_t r, g, b; };

		std::vector<vec3> vertex;
		std::vector<color> vertex_colors;
		std::vector<std::int32_t> indices;
		std::vector<vec2> uvs;
		std::vector<std::int32_t> uv_indices;
	};

constexpr size_t face_num = 3;

#pragma pack(push, 1)
      struct raw_face { uint8_t num; std::int32_t face[face_num]; };
#pragma pop
}

// Reading code
PLY::Data out_data;
std::vector<char> raw_data; // inited from stream
const auto faces = raw_data.size() / sizeof(raw_face);
out_data.indices.resize(faces * face_num);

for (int i = 0; i < faces; ++i) {
  // Not aligned
  raw_face const* source_face = reinterpret_cast<raw_face const*>(raw_data.data() + i * sizeof(raw_face));

  out_data.indices[i * face_num] = raw_face->face[0];
  out_data.indices[i * face_num + 1] = raw_face->face[1];
  out_data.indices[i * face_num + 2] = raw_face->face[2];
} 

As you can see, the code is not ideal at all. As I understand, I need to align the address of raw_data, load to wide all bytes, and store it with mask and condition. I've tried to find how can I do it, didn't find any examples. In this example, I need to ignore first aligned bytes before raw_data address, then ignore every byte (bi % sizeof(raw_face) == 0), and also do not forget about right align border. Could you provide some examples, please?

Should I use shuffle in this case, or any alternatives exsist?

[DenisYaroshevskiy]

1. Almost no problems with MSVC if it's updated to the latest commits, but not the latest 2023 release.
   O_o, exciting.

2. index of the byte.
   You don't want to do it like that, I'm pretty sure.

3. I think pseudo-code causes some confusion, let's figure out the problem first and then I will hopefully be able to tell you how to solve it.

Can you confirm that this is this the loop you want? https://godbolt.org/z/748andb4c

[DramaDesu]

Thank you for the example.
Yes, I don't think so if I could make better, since it's not trivial, but maybe with 256i reg?

I've Zen 5 + target on AVX.

[DramaDesu]

For the last example, I've got the same result with my code.
So this is the easiest and simplest possible way to do it.

[DenisYaroshevskiy]

Zen 5 is very powerful. You can compile with full avx512 for that.
Eve doesn't support all the instructions that you'd want - we target weaker arch than you want.
I will do you an example on a weekend, if I don't forget.

The AVX target - are you sure it's not AVX2 target?
Regardless - there are things you can try there but I'm not sure how much it'd give you.

Chase me next week if I forget

[DenisYaroshevskiy]

Since you closed this issue, I assume you don't need this version any more.

[DramaDesu]

Sorry, I've missed the message.
I've used AVX2, and I've tried to check some operations with AVX512, it compiles, but doesn't work, it crashes in runtime. It seems to me, like my cpu doesn't support it, I've checked, only thread-rippers support it.
Yes, we resolved the issue, thank you very much

[DramaDesu]

#include <benchmark/benchmark.h>

#include <eve/eve.hpp>

using face_t = std::uint32_t;

constexpr std::size_t face_num = 3;
constexpr std::size_t face_count = 3'000'000;

constexpr std::size_t face_struct_size = face_num * sizeof(face_t) + 1;

static std::vector<std::uint8_t> raw_faces;

auto generate_face_data(std::size_t in_face_count = face_count)
{
	std::vector<std::uint8_t> data(in_face_count + in_face_count * face_num * sizeof(face_t));
	for (std::uint32_t i = 0; i < in_face_count; ++i)
	{
		auto* target_data = data.data() + i * face_struct_size;

		*target_data = face_num;

		face_t* face = reinterpret_cast<face_t*>(target_data + 1);

		face[0] = i * face_num;
		face[1] = i * face_num + 1;
		face[2] = i * face_num + 2;
	}

	return data;
}

void copy_faces_scalar(const std::uint8_t* source_faces, std::size_t n, face_t* out)
{
	while (n--) {
		std::memcpy(out, source_faces + 1, face_struct_size - 1);
		out += face_num;
		source_faces += face_struct_size;
	}
}

void copy_faces_vector(const std::uint8_t* source_faces, std::size_t n, face_t* out)
{
	while (n--) {
		auto loaded = eve::unsafe(eve::load)(source_faces + 1);
		eve::store(loaded, reinterpret_cast<unsigned char*>(out));

		out += face_num;
		source_faces += face_struct_size;
	}
}

using namespace std;

static void bm_copy_faces_scalar(benchmark::State& state) {

	std::vector<face_t> faces(face_count * face_num);

	for (auto _ : state) {
		copy_faces_scalar(raw_faces.data(), face_count, faces.data());
	}
}
BENCHMARK(bm_copy_faces_scalar);

static void bm_copy_faces_vector(benchmark::State& state) {

	std::vector<face_t> faces(face_count * face_num);

	for (auto _ : state) {
		copy_faces_vector(raw_faces.data(), face_count, faces.data());
	}
}
BENCHMARK(bm_copy_faces_vector);

int main(int* argc, char** argv)
{
	raw_faces = generate_face_data();

	std::vector<face_t> faces(face_count * face_num);
	copy_faces_vector(raw_faces.data(), face_count, faces.data());

	benchmark::SetDefaultTimeUnit(benchmark::kMillisecond);

	benchmark::RunSpecifiedBenchmarks();
	benchmark::Shutdown();

	return 0;
}

FYI
For 3'000'000 triangles

[DramaDesu]

I see, in this case just it's needed to be aligned by 4 bytes (it depends on) and copy with overlaps, I'll do example with multi-threading.

So I need eve for another tasks, I have plenty, vector min-max (since it's hardware operation) works so good, if I change my structs to soa it'll so fast.

[DenisYaroshevskiy]

this case just it's needed to be aligned by 4 bytes

I don't get what you mean here - but if you say so. memcpy doesn't need alignment.

So I need eve for another tasks

This doesn't make sense - please make a separate discussion if you have a separate problem. Ideally with valid scalar C++ code that does what you want.

[DramaDesu]

I meant when memcpy by power of 2, compiler automatically makes it vectorized.

Yeah, sure, all in a separate thread, anyway, thank you very much, it's really helpful.

[DramaDesu]

I'm a bit embarrassed to share what I've got, but I've managed to spread the data across cachelines and it works (should be limited false sharings), thanks for the tip with memcpy

[DenisYaroshevskiy]

success! thanks for using eve