Pit'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
Kive 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
KIdk 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.
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.
Kbut really if those functions have locals and things like that you're probably doing something wrong with AggressiveInlining....
Pit's not guaranteed, there are still limits but there's just a lot of things that relax those limits now.
Poh right
Pyeah just read your whole comment
PI WITHDRAW MY REMARK
VDeleted User#0000
note that on net5 this is only solved for top-level inlines.
note that on net5 this is only solved for top-level inlines.
Original Message
Quoted by kaijellinghaus#0000
Anot 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
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
i may be missing something here, so this is just a personal opinion on what i've seen so far
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>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>i may be missing something here, so this is just a personal opinion on what i've seen so far
Pthis is my point, this is literally Silk.NET 1.X
Marrays blow, we'd be constantly marshalling and allocating stuff
Ajust internally convert it to a pointer?
Ktbh I'm not against having TerraFX style functions with raw ptr + the typed ptrs
Monly works one way
KI don't see why not + it provides compat with external libs that work with ptrs
AVDeleted User#0000
I just submitted repro code for an issue regarding AggressiveInlining that doesn't even contain a single AggressiveInlining
Original Message
Quoted by kaijellinghaus#0000
Kmore inlining docs
Kbut what do we do for char**
Kconst char** to be specificKwe can't do T[][] that's just not correct
Mthat would be ref T[]?
Kand
T*[] helps with nothingKand
ROSpan<Span<T>> is just not validAno - 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
but again, very easy for the user
and the performance hit that will be encountered is really not enough to matter
Ai 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
Pfor 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
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
Athe 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
if you wanted raw performance, don't use C#, simple as
Athe garbage collector gives far more of a performance hit than a little bit of allocation here and there
Ato make something safe, there is always some compromise
KIs 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
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
KIt's well established that with performance and allocation minded code C# can be some of the fastest code around
Ksee ASP.NET Core
Mif what you want are very high level bindings can't cppsharp do that
Keeeeh
KI mean that's what TerraFX does, provide 100% unsafe raw methods
Apersonally 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
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
Mi meant the opposite, 100% safe methods
KNo
Kno one can do 100% safe methods
M90% safe
Mno pointers
Ksure, but we have been able to do that for a long time
Kthe problem is more what to do in those edge cases
Mso what is silk adding to the table if we go back to working on that principle
Kwhat if some things are a ptr and some things are a safe array
KIdeally you can use a
int*[] no problemKI get this a lot, but then I'm not sure what your problem with the idea of wrapped pointers are?
Kno need for unsafe, no need for weird types, just give something an array and it worksis exactly what we try to enable here
