i can't think of a situation where someone would reasonably need to mix and match refs arrays and un

i can't think of a situation where someone would reasonably need to mix and match refs arrays and unsafe, in any combination
99.9% of people will either be using fully managed, or fully unsafe, i can almost guarantee
just look at opentk, i have never once seen anyone use the pointer overloads, span overloads, etc
i've only ever seen people use the safe overloads

LLyris the Kitori im going to inline every function and have a gigabyte bin

Maxine•8/4/23, 8:43 PM

the point of most of these functions is that they can be squished down to 0 native code when called :P

Kai•8/4/23, 8:43 PM

Honestly the JIT team has impressive speed when you show the some IL -> ASM dump that is "bad" and have at least a batshit crazy reason to do this (at least any reason)

AquaOP•8/4/23, 8:43 PM

i get wanting to make it feel at home in C#, i think that's a good way to go about doing things
but i don't personally think adding extra types is the right way to go

AquaOP•8/4/23, 8:43 PM

I did that with pie a long time ago, it was absolutely horrible to use

Maxine•8/4/23, 8:44 PM

what's your idea then?

Maxine•8/4/23, 8:44 PM

keep as-is, unsafe everything?

Perksey•8/4/23, 8:44 PM

it's worth noting what we're discussing here is not Silk.NET 3.0. This is SilkX, a completely different library. there is still room for another contributor to create a different library to propose that it gets blessed as 3.0

AAqua i can't think of a situation where someone would reasonably need to mix and matc...

khitiara•8/4/23, 8:44 PM

ive mixed arrays and ref at the same time in calls a ton actually, albeit not mixing safe and unsafe, mixing ref and span is useful a ton actually

MMaxine you guys know that if there is sufficient IL in a method the JIT will just refus...

Kai•8/4/23, 8:45 PM

Idk if this is up to date btw, but technically AggressiveInlining is guaranteed for top-level inlines so function A calling function B with AggressiveInlining is guaranteed, but then anything beyond is not, just a strong hint.
And then if it's huge huge you can just make it multiple functions, which will the also help with JIT not perishing when tracking variables and that.

Kai•8/4/23, 8:45 PM

but really if those functions have locals and things like that you're probably doing something wrong with AggressiveInlining....

Perksey•8/4/23, 8:45 PM

it's not guaranteed, there are still limits but there's just a lot of things that relax those limits now.

Perksey•8/4/23, 8:45 PM

oh right

Perksey•8/4/23, 8:46 PM

yeah just read your whole comment

Perksey•8/4/23, 8:46 PM

I WITHDRAW MY REMARK

Volte•8/4/23, 8:47 PM

Deleted User#0000

//   However, there are some caveats to this:
// - We use local functions in addition to the generic typeof(T) == typeof(whatever) pattern to work around some
//   unfortunate inlining issues in platforms older that .NET 5, where the inliner was going over budget despite
//   aggressively inlined functions supposedly being exempt from budgeting.
//   See also: https://github.com/dotnet/runtime/issues/38106

//   However, there are some caveats to this:
// - We use local functions in addition to the generic typeof(T) == typeof(whatever) pattern to work around some
//   unfortunate inlining issues in platforms older that .NET 5, where the inliner was going over budget despite
//   aggressively inlined functions supposedly being exempt from budgeting.
//   See also: https://github.com/dotnet/runtime/issues/38106

note that on net5 this is only solved for top-level inlines.

Original Message

Click here

Quoted by kaijellinghaus#0000

MMaxine keep as-is, unsafe everything?

AquaOP•8/4/23, 8:47 PM

not quite
keep unsafe, but have safe overloads as well
aka taking arrays
and perhaps a span as well, although as spans can be converted to pointers very easily i wouldn't say that span is a high priority - i don't see many people using spans (myself included, never seen the point of them)
if you remove the mix and matching, even with spans, you'd have a max of 3 overloads, and as i said before, i'm fairly confident 99% of people will only ever use the fully safe overloads
and having it obvious what they do will really help development and UX
i can say that as a beginner if I saw a

Ptr<T>

Ptr<T>

type instead of an array, I would be very confused
even now I would question why it is using a custom type instead of pure unsafe or safe
on a personal level, I just think

Ptr<T>

Ptr<T>

causes more problems than it solves
i may be missing something here, so this is just a personal opinion on what i've seen so far

Perksey•8/4/23, 8:47 PM

this is my point, this is literally Silk.NET 1.X

Maxine•8/4/23, 8:48 PM

arrays blow, we'd be constantly marshalling and allocating stuff

AquaOP•8/4/23, 8:48 PM

just internally convert it to a pointer?

Kai•8/4/23, 8:48 PM

tbh I'm not against having TerraFX style functions with raw ptr + the typed ptrs

AAqua just internally convert it to a pointer?

Maxine•8/4/23, 8:48 PM

only works one way

Kai•8/4/23, 8:48 PM

I don't see why not + it provides compat with external libs that work with ptrs

AquaOP•8/4/23, 8:49 PM

void glDoStuff<T>(T[] myArray) where T : unmanaged {
  fixed (void* arrPtr = myArray)
    glDoStuff((nuint) myArray.Length, arrPtr);
}

void glDoStuff<T>(T[] myArray) where T : unmanaged {
  fixed (void* arrPtr = myArray)
    glDoStuff((nuint) myArray.Length, arrPtr);
}

Volte•8/4/23, 8:49 PM

Deleted User#0000

I just submitted repro code for an issue regarding AggressiveInlining that doesn't even contain a single AggressiveInlining

Original Message

Click here

Quoted by kaijellinghaus#0000

Kai•8/4/23, 8:49 PM

more inlining docs

AAqua ```cs void glDoStuff<T>(T[] myArray) where T : unmanaged { fixed (void* arrPtr...

Kai•8/4/23, 8:49 PM

but what do we do for char**

Kai•8/4/23, 8:49 PM

const char**

const char**

to be specific

Kai•8/4/23, 8:50 PM

we can't do T[][] that's just not correct

Maxine•8/4/23, 8:50 PM

that would be ref T[]?

Kai•8/4/23, 8:50 PM

and

T*[]

T*[]

helps with nothing

Kai•8/4/23, 8:50 PM

and

ROSpan<Span<T>>

ROSpan<Span<T>>

is just not valid

AquaOP•8/4/23, 8:50 PM

no - and that will potentially require some allocation
but again, very easy for the user
and the performance hit that will be encountered is really not enough to matter

AquaOP•8/4/23, 8:51 PM

i created a very fast alloc + buffer copy system in pie and you can't tell the difference between using that system and just sending the data over raw in tests

Perksey•8/4/23, 8:52 PM

for reference, these were the overloads in 1.9:
https://github.com/dotnet/Silk.NET/blob/v1.9.0/src/Vulkan/Silk.NET.Vulkan/Vk.gen.cs
https://github.com/dotnet/Silk.NET/blob/v1.9.0/src/OpenGL/Silk.NET.OpenGL/GL.gen.cs

AquaOP•8/4/23, 8:52 PM

the thing is, with any safe context, you will always lose some performance to make it clean
if you wanted raw performance, don't use C#, simple as

AquaOP•8/4/23, 8:52 PM

the garbage collector gives far more of a performance hit than a little bit of allocation here and there

AquaOP•8/4/23, 8:53 PM

to make something safe, there is always some compromise

Kai•8/4/23, 8:54 PM

Is C# the best language to do this? Maybe not. But there's very good reason you and everyone else here does it anyways....
And the GC hurting performance more then a little bit of allocation is just wrong. The whole reason the GC may hurt performance is because of those allocations

Kai•8/4/23, 8:54 PM

It's well established that with performance and allocation minded code C# can be some of the fastest code around

Kai•8/4/23, 8:54 PM

see ASP.NET Core

Maxine•8/4/23, 8:54 PM

if what you want are very high level bindings can't cppsharp do that

Kai•8/4/23, 8:55 PM

eeeeh

Kai•8/4/23, 8:55 PM

I mean that's what TerraFX does, provide 100% unsafe raw methods

KKai Is C# the best language to do this? Maybe not. But there's very good reason you ...

AquaOP•8/4/23, 8:55 PM

personally the main reason I use C# is because I hate C++ headers and rust sucks for gamedev
that is literally the only reason
my opinion of C# as a language has gone way down the drain, I wish I did not have to use it
however that's not to say it doesn't have its merits, and clean and understandable code is one major benefit of the language, no need for unsafe, no need for weird types, just give something an array and it works

KKai I mean that's what TerraFX does, provide 100% unsafe raw methods

Maxine•8/4/23, 8:55 PM

i meant the opposite, 100% safe methods

Kai•8/4/23, 8:55 PM

Kai•8/4/23, 8:55 PM

no one can do 100% safe methods

Maxine•8/4/23, 8:56 PM

90% safe

Maxine•8/4/23, 8:56 PM

no pointers

Kai•8/4/23, 8:56 PM

sure, but we have been able to do that for a long time

// However, there are some caveats to this: // - We use local functions in addition to the generic typeof(T) == typeof(whatever) pattern to work around some // unfortunate inlining issues in platforms older that .NET 5, where the inliner was going over budget despite // aggressively inlined functions supposedly being exempt from budgeting. // See also: https://github.com/dotnet/runtime/issues/38106

i can't think of a situation where someone would reasonably need to mix and match refs arrays and un

Similar Threads

Similar Threads

Similar Threads