Field offsets?

[untodesu]

C-family languages have a specific macro that allows you to get a byte offset for a certain field in a structure:

struct funny_struct {
    int padding;
    int value;
};
size_t offset = offsetof(struct funny_struct, value); // 4

In terms of C#, Framework provides Marshal.OffsetOf method but it isn't reliable if we talk about managed structures.
In any other case C# has no offsetof equivalent at the time.

What it could look like:

struct FunnyStruct
{
    int Padding;
    int Value;
}

// ...
int offset = offsetof(FunnyStruct, Value); // 4

[jnm2]

How could offsetof be more reliable than Marshal.OffsetOf?

[untodesu]

I recently was experimenting with Silk.NET.OpenGL and there's not a single example in the repo where a vertices are represented as structures (instead, a simple float array is used).

As you can guess, it's no good for a somewhat complex applications.

OpenGL itself inputs vertex formats as a couple of values including relative offset to each field that refers to the position in memory of a field if we are using a structure. And here's a thing: to achieve true modularity (say, using attributes on fields to generate vertex attributes using reflection) I need a way of getting this relative offset and relying on it all times.

[CyrusNajmabadi]

Why do you need a language feature here, instead of say a library feature that can answer this?

This also feels like something an SG could provide, emitting the offsets as constants (or static readonly values) into some type you just reference by name. E.g. Offsets.FunnyStruct_Value

[untodesu]

Why do you need a language feature here, instead of say a library feature that can answer this?

If there's just a way to achieve this without a language feature then I guess don't need a language feature...

This also feels like something an SG could provide, emitting the offsets as constants (or static readonly values) into some type you just reference by name. E.g. Offsets.FunnyStruct_Value

I really don't want to use source generators as they would complicate things

[jnm2]

It seems quite dangerous to be exposing managed memory in a raw form to OpenGL. If the structs are unmanaged (allowed by where T : unmanaged), then this is in unmanaged territory and Marshal.SizeOf seems right.

[untodesu]

Ah, fair enough then, thanks

[huoyaoyuan]

Unsafe.ByteOffset(ref Unsafe.As<FunnyStruct, byte>(ref funnyStruct), ref Unsafe.As<int, byte>(ref funnyStruct.Value))

JIT can't optimize this into a constant though.

[CyrusNajmabadi]

Why can't it?

[huoyaoyuan]

It doesn't optimize it now, but nothing prevents it.

[CyrusNajmabadi]

You said it "can't", so I thought there was an implication that there was something intrinsic about that that was blocking the runtime. Thanks for the clarification.

[untodesu]

jnm2 said:

It seems quite dangerous to be exposing managed memory in a raw form to OpenGL. If the structs are unmanaged (allowed by where T : unmanaged), then this is in unmanaged territory and Marshal.SizeOf seems right.

aye fair enough

[The-Futurist]

The reservations expressed here refer to the danger of exposing details of managed memory but there's no reason to assume that this is going to refer to managed memory. We have the unsafe operator sizeof today that we can use for an unmanaged type so perhaps we can consider offsetof to tell us the offset of a member field within an unmanaged type.

Without this operator it is cumbersome at best to determine the offset of a member field and since the padding and alignment are potentially unpredictable it involves making some assumptions or performing pointer subtraction.

[CyrusNajmabadi]

Try out your scenarios and see :-)

Regardless, this feels firmly as an API question. I'd recommend conversing with the runtime team if you need more clarity or capabilities here.

This is far from clear if we read the docs.

Doc improvement requests can go to the runtime, or the docs team. Regardless, as above, this is well out of bounds of being a language question/discussion.

[CyrusNajmabadi]

I'd rather have an answer from the C# team.

The question is not a language one, but a runtime one. As i mentioned, I'd recommend conversing with the runtime team if you need more clarity or capabilities here.

I wonder why you even participated in the discussion.

To direct you at the right people. You're asking questions to the wrong team here. The discussion is better suited to those who own this domain.

[CyrusNajmabadi]

You clearly don't know the answer

I gave the answer on how the language thinks about it. From an actual impl perspective, i also gave answers on potential options you can take, including the approach i use. More details beyond that can go to the owners of those respective areas (like the doc owners or runtime owners).

[richlander]

@Korporal -- Your statements read like personal attacks. I'm certain I'm not the only one that feels that way. The guidance you were given was quite clearly given in good faith and (as a member of the team) seems like the correct advice. Please adopt a more professional style of communication. Your approach in this thread isn't helping anyone, including achieve your goals.

[CyrusNajmabadi]

disparaging response of "Try out your scenarios and see :-)"

This was a friendly suggestion, made in good faith. Often it's good to just try things out and find out first hand what happens in the scenarios in question. :)

and then mislead them

There was no misleading. It's an option, with its own set of caveats (just like all things). That's why i mentioned options to use, suggested you try them, but also pushed heavily that you seek out the best expertise on the topic (multiple times). That's not misleading, that's sharing what is known but also recommending a great path to get the most knowledge possible to take on a challenge :)

Good luck! :)

[richlander]

In the interest of helping ... Here, this is directed at anyone that wants to listen.

If you see something you feel is disparaging and then (objectively) escalate the situation, then the entire burden of the problem conversation is on you. It's not a question of whether you accept this. This is "how it works".

Human interactions can be asymmetric (as is the case here). You often don't get an opportunity to reframe other people's perception of your behavior. The only good option is to play by the rules of the crowd. Your specific opinion on what is right and wrong doesn't matter or apply, unless you can get the crowd to listen. Again, this is "how it works", not just in this forum.