Silk.NET•3y ago

yeah I'm worried if we go this route we will accidentally make a GC hole

AAqua hmm that's where i disagree one of the big benefits of C# is that it *has* overl...

PerkseyOP•8/4/23, 8:24 PM

sorry i do have a response to this I just keep getitng distracted

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

we're having like 15 discussions at the same time

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

AsPtr2D I think turns

ref PtrType<sbyte>

ref PtrType<sbyte>

into

PtrType<Ptr<sbyte>>

PtrType<Ptr<sbyte>>

(so I guess it should be AsConstPtr2D()) and the given

ref

ref

is just stored as-is and the "the inner is also a ptr" is just tracked by the compiler via generics

MMaxine PtrType<T> = contains a ref T PtrType<Ptr<T>> = contains a ref Ptr<T> which cont...

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

No PtrType<Ptr<T>> just contaisn a ref byte, and so does PtrType<T>

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

oh so the char** isn't a pointer to a variable?

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

when calling functions it just then re-calculates the inner ref

PPerksey yeah I'm worried if we go this route we will accidentally make a GC hole

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

I don't see how this is different from the

RefMut<sbyte>

RefMut<sbyte>

type at runtime? It's just a

ref byte

ref byte

on the inside (or a readonly ref byte in this case, but same same)

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

In neither case do we GC track the inner ref the outer one points to

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

(which I don't think is necessary)

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

like here's a C usage of glfwGetError to my understanding

char* description = NULL;
if (glfwGetError(&description)) {
  printf(description);
}

char* description = NULL;
if (glfwGetError(&description)) {
  printf(description);
}

KKai In neither case do we GC track the inner ref the outer one points to

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

only works if the method doesn't dereference the char*

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

will work for GetError, yes

KKai I don't see how this is different from the `RefMut<sbyte>` type at runtime? It's...

PerkseyOP•8/4/23, 8:27 PM

it is a GC hole today for jagged arrays, but I've worked around that in marshalling (see

SilkMarshal.JaggedArrayToPointerArray

SilkMarshal.JaggedArrayToPointerArray

). if

InteriorRef

InteriorRef

is actually a

ref ConstPtr<int>

ref ConstPtr<int>

, the referencee will continue to be tracked and ergo the encapsulated reference will continue to be tracked

PerkseyOP•8/4/23, 8:27 PM

this would also be a GC hole if you could store a ConstPtr on the heap, but you can't as it's a ref struct

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

great

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

so then it's not a problem for

PtrType

PtrType

ConstPtrType

ConstPtrType

either given you can't put them on the heap either

MMaxine will work for GetError, yes

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

printf (or the C# equivalent) will dereference the char*. So it would be a problem, but perksey worked around it

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

maybe this isn't a gc hole because being ref structs, since you need to hold the outer one somewhere to have the inner one, the outer one is never gonna go out of scope before the inner one

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

so kai's idea actually works

KKai so then it's not a problem for `PtrType`/`ConstPtrType` either given you can't p...

PerkseyOP•8/4/23, 8:30 PM

but the main thing is

PtrType<Ptr<int>>

PtrType<Ptr<int>>

the inner

Ptr

Ptr

may reference a field on the heap, which presumably will be untracked when we go from

PtrType<int>

PtrType<int>

Ptr<int>

Ptr<int>

(or whatever we reinterpret it to)

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

no Ptr is empty

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

Ptr is just a compile-time marker

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

yeah ptr isn't anything

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

it's just there so ptr calculating things (like indexers) return the right thing

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

the biggest issue is that the inner IL implementation is stupid and has to check the types (similar to scalar)

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

it's not a big problem though given JIT is smart

PerkseyOP•8/4/23, 8:32 PM

but how would it return the right thing? if we had associated types we could do

Ptr<T>.RefType this[nuint idx]

Ptr<T>.RefType this[nuint idx]

KKai ```cs public ref struct PtrType<T> { // inner magic to store the arbitrary p...

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

See the Inner extension method

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

it's like associated types, just ugly

PerkseyOP•8/4/23, 8:33 PM

ah, right, no indexers.

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

fair yeah

PerkseyOP•8/4/23, 8:33 PM

hmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm

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

there won't be indexers for ptr -> ptr

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

but eh

PerkseyOP•8/4/23, 8:33 PM

i do like but i also do not like

PerkseyOP•8/4/23, 8:33 PM

i am

PerkseyOP•8/4/23, 8:33 PM

on The Fence

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

I don't like it either but I also don't like

MutRefMut

MutRefMut

PerkseyOP•8/4/23, 8:33 PM

yeah god no

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

PtrType<schar> marshalMyString = new string("chonkballs".ToCharArray()); // make a new string bc the string literal is in the constant pool
PtrType<Ptr<schar>> ptrToThatVariable = marshalMyString.PtrTo();

for (var i = 0; i < 5; i++)
  ptrToThatVariable.Get(0, i);

PtrType<schar> marshalMyString = new string("chonkballs".ToCharArray()); // make a new string bc the string literal is in the constant pool
PtrType<Ptr<schar>> ptrToThatVariable = marshalMyString.PtrTo();

for (var i = 0; i < 5; i++)
  ptrToThatVariable.Get(0, i);

PerkseyOP•8/4/23, 8:34 PM

FIFTY SIX POINTER TYPES LET'S GOOOO

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

like either is ugly here tbh

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

and either will produce 56 JIT type instantiations cause JIT stupid

PerkseyOP•8/4/23, 8:34 PM

ok so let's bikeshed a bit so that I can feel more comfortable

MMaxine ```cs PtrType<schar> marshalMyString = new string("chonkballs".ToCharArray()); /...

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

idk about multi-dimension

Get

Get

cause that'd get ugly

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

possible but ugly

PerkseyOP•8/4/23, 8:35 PM

nah it'd work

KKai idk about multi-dimension `Get` cause that'd get ugly

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

so Get2D(i)?

PerkseyOP•8/4/23, 8:35 PM

just whip out a T4

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

otherwise how do you differentiate Get on PtrType<T> vs Get on PtrType<Ptr<T>>

PtrType<schar> marshalMyString = new string("chonkballs".ToCharArray()); // make a new string bc the string literal is in the constant pool PtrType<Ptr<schar>> ptrToThatVariable = marshalMyString.PtrTo(); for (var i = 0; i < 5; i++) ptrToThatVariable.Get(0, i);

yeah I'm worried if we go this route we will accidentally make a GC hole

Similar Threads