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

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

KaiOP•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

KaiOP•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

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

eeeeh

KaiOP•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 ...

Aqua•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

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

KaiOP•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

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

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

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

the problem is more what to do in those edge cases

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

so what is silk adding to the table if we go back to working on that principle

KaiOP•8/4/23, 8:57 PM

what if some things are a ptr and some things are a safe array

KaiOP•8/4/23, 8:57 PM

Ideally you can use a int*[]int*[] no problem

AAqua personally the main reason I use C# is because I hate C++ headers and rust sucks...

KaiOP•8/4/23, 8:57 PM

I get this a lot, but then I'm not sure what your problem with the idea of wrapped pointers are?

KaiOP•8/4/23, 8:58 PM

no need for unsafe, no need for weird types, just give something an array and it works

is exactly what we try to enable here

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

Deleted User#0000

we can't abolish any of those parameters, and can't really choose which ones are the right ones

Original Message

Click here

Quoted by perksey#0000

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

this is really what it boils down to

KaiOP•8/4/23, 9:00 PM

yeah, and in cases like
f(int***, void**, uint**, res*, float**)f(int***, void**, uint**, res*, float**) it's just ???

KaiOP•8/4/23, 9:00 PM

like which ones are the right overloads to have here

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

Aqua•8/4/23, 9:01 PM

i don't see why it's something that couldn't be returned to, just because it was in 1.0?
i'm not dismissing this Ptr<T>Ptr<T> idea of course, i am just trying to suggest stuff from a user's perspective. i love C#'s

unsafe

unsafe

, but I don't think it should be the norm for the end user, and I don't think that a custom type is the right way to do things - simply because to an end user, it is a type they may have never seen before, and may be confusing to use, to the point where one may have to read documentation to find out how to use it
now having documentation is fine, but personally if I were coming from say C++ opengl, I should not have to read documentation to be able to use it in C#, I should just be able to give it an array of data like normal and it just works
the intellisense says it is an array, I can see that it is an array, I give it array data, and it just works, no questions or errors or warnings asked by the compiler
sure there's faster options available, but it just works
for me, that is the advantage of C#
stuff just works, the intellisense makes it obvious what it does, no need to mess around reading documentation, you just give stuff data and off it goes.. then it doesn't work because you gave it the wrong offset but we don't talk about that

KaiOP•8/4/23, 9:02 PM

yeah this is great that we talk about this tbh

KaiOP•8/4/23, 9:02 PM

so the concern that we have had a few times when talking about this is that for functions like the one I gave above, it's really unclear to us which overloads to expose

AAqua i don't see why it's something that couldn't be returned to, just because it was...

Perksey•8/4/23, 9:02 PM

oh yeah sure, but all i'm saying there's a reason we moved away from the rigid 1.0 structure primarily because we got complaints about the overloads kinda being naff to use

KaiOP•8/4/23, 9:02 PM

and exposing all of them is problematic because then you get no intellisense and maybe your IDE just dies

KaiOP•8/4/23, 9:03 PM

which... yeah that's super bad

KKai yeah this is great that we talk about this tbh

Perksey•8/4/23, 9:03 PM

for sure, this is also why we refused to include overloads in the original 3.0 proposals haha

KaiOP•8/4/23, 9:04 PM

f(int***, void**, uint**, res*, float**)f(int***, void**, uint**, res*, float**)
here there is a very good argument that we should support passing
T[]T[] in place of T*T* everywhere, I think everyone agrees?
f(int**[], void*[], uint*[], res[], float*[])f(int**[], void*[], uint*[], res[], float*[]) should be a valid way to pass the args

Maxine•8/4/23, 9:04 PM

implicit casts to ptr might genuinely be a good alternative to having every permutation of argument as an overload

Maxine•8/4/23, 9:04 PM

but also doesn't work for every possible case

KaiOP•8/4/23, 9:04 PM

but then what about
f(int*[][], void[][], uint[][], res[], float[][])f(int*[][], void[][], uint[][], res[], float[][]) (now next to void[][] not being valid, so it should stay void*[]void*[])
these seem fine?

AAqua i don't see why it's something that couldn't be returned to, just because it was...

Lyris the Kitori•8/4/23, 9:04 PM

i feel like this is also an IDE problem

Lyris the Kitori•8/4/23, 9:04 PM

intellisense should pick up on implicit casts and give you nice completions

PPerksey oh yeah sure, but all i'm saying there's a reason we moved away from the rigid 1...

Aqua•8/4/23, 9:05 PM

I'm not familliar with 1.0 so I can only say it from my own thoughts
one way to do it could be to simply stick to the spec, and don't provide any helpers etc
raw pointer overloads just have the exact same signature as the C API
and the safe overloads are similar, just any time there is a

length

length

and a pointer, remove that and convert it to an array
or something along those lines
in this way, you only need 2 or 3 overloads (if you include spans)

KaiOP•8/4/23, 9:05 PM

now we want to pass different versions of this to different args, so you take those 3 permutations I've shown and get 15 overloads (5 * 3 versions = 15) (minus the one void*[] that's not valid = 12 overloads)

AAqua I'm not familliar with 1.0 so I can only say it from my own thoughts one way to ...

KaiOP•8/4/23, 9:06 PM

This is true, but very much not ergonomic. C APIs will most likely not have a length or have a shared length for several of the arguments. It's hard to figure out what's what and even harder to really put this in an API

AAqua i don't see why it's something that couldn't be returned to, just because it was...

Lyris the Kitori•8/4/23, 9:06 PM

while i agree with the "its less visually obvious to newcomers", once you learn the way its structured its a lot better ergonomically, its just teaching people that way, we'd need excellent documentation for this to really be viable

KaiOP•8/4/23, 9:06 PM

and it also doesn't really offer a good solution for passing int*[][]int*[][] or int*[,]int*[,]

AAqua I'm not familliar with 1.0 so I can only say it from my own thoughts one way to ...

Perksey•8/4/23, 9:07 PM

tbh i'm content with having a wrapped overload and an unwrapped overload i.e. if you used only the unwrapped functions, Silk.NET is literally just TerraFX but with pretty names.

Aqua•8/4/23, 9:07 PM

if it's anything, these are the overloads I provide for creating a buffer in pie
https://github.com/piegfx/Pie/blob/main/src/Pie/GraphicsDevice.cs#L83-L122
they are not perfect and could do with a little refining, but they encompass pretty much everything one may want to do with them
the unsafe overload is there for those who want it, and there are safe options as well

PPerksey tbh i'm content with having a wrapped overload and an unwrapped overload i.e. if...

Maxine•8/4/23, 9:07 PM

yeah fuck it why not

PPerksey tbh i'm content with having a wrapped overload and an unwrapped overload i.e. if...

KaiOP•8/4/23, 9:07 PM

this I would prefer personally

KKai now we want to pass different versions of this to different args, so you take th...

Lyris the Kitori•8/4/23, 9:07 PM

yeah if your methods have a lot of thing* and you do array overloading you start getting to 3**11 overload territory

PPerksey tbh i'm content with having a wrapped overload and an unwrapped overload i.e. if...

Aqua•8/4/23, 9:07 PM

yeah, that could work quite well

Perksey•8/4/23, 9:07 PM

most of our users don't want that though, so we will encounter the education problem still.

Perksey•8/4/23, 9:08 PM

but again, my intention is to have a "Silk DSL 101" page that just tells you everything you need to know in using these wrappers

Maxine•8/4/23, 9:08 PM

silk documentation already isn't any good, it can't get worse

KaiOP•8/4/23, 9:08 PM

It's the same problem Span introduces though. These are advanced APIs, you spent hours digging through docs. Read the 2 lines the intellisense will give you once you hover over the Ptr type

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

Similar Threads