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

K

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

(which I don't think is necessary)

M

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);
}

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

M

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

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

M

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

P

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

SilkMarshal.JaggedArrayToPointerArray

SilkMarshal.JaggedArrayToPointerArray). if

InteriorRef

InteriorRef

InteriorRef

InteriorRef is actually a

ref ConstPtr<int>

ref ConstPtr<int>

ref ConstPtr<int>

ref ConstPtr<int>, the referencee will continue to be tracked and ergo the encapsulated reference will continue to be tracked

P

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

K

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

great

K

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

so then it's not a problem for

PtrType

PtrType

PtrType

PtrType/

ConstPtrType

ConstPtrType

ConstPtrType

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

MMaxine will work for GetError, yes

K

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

M

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

M

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

P

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

but the main thing is

PtrType<Ptr<int>>

PtrType<Ptr<int>>

PtrType<Ptr<int>>

PtrType<Ptr<int>> the inner

Ptr

Ptr

Ptr

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

PtrType<int>

PtrType<int>

PtrType<int>

PtrType<int> to

Ptr<int>

Ptr<int>

Ptr<int>

Ptr<int> (or whatever we reinterpret it to)

K

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

no Ptr is empty

K

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

Ptr is just a compile-time marker

M

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

yeah ptr isn't anything

K

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

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

K

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

K

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

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

P

Perksey•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]

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

K

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

See the Inner extension method

K

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

it's like associated types, just ugly

P

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

ah, right, no indexers.

K

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

fair yeah

P

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

hmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm

K

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

there won't be indexers for ptr -> ptr

K

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

but eh

P

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

i do like but i also do not like

P

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

i am

P

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

on The Fence

K

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

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

MutRefMut

MutRefMut

MutRefMut

MutRefMut

P

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

yeah god no

M

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);

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);

P

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

FIFTY SIX POINTER TYPES LET'S GOOOO

K

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

like either is ugly here tbh

K

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

and either will produce 56 JIT type instantiations cause JIT stupid

P

Perksey•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()); /...

K

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

idk about multi-dimension

Get

Get

Get

Get cause that'd get ugly

K

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

possible but ugly

P

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

nah it'd work

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

M

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

so Get2D(i)?

P

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

just whip out a T4

M

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

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

M

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

there isn't a generic for "not this"

M

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

at one point there was a proposal for extension indexers but it never happened

P

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

it'd be

Get<T>(this Ptr<T> x)

Get<T>(this Ptr<T> x)

Get<T>(this Ptr<T> x)

Get<T>(this Ptr<T> x) where

T

T does not allow ref structs as a generic

P

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

oh fuck yeah

P

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

shit

K

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

can implement it on the inside with

public static class PtrAccessor  
{
    public static PtrType<T2> Get<T2, T>(this PtrType<T> self, int i)
        where T: IPtrMarker<T2>
    {
         // IDK take an index and do magic with the inner of PtrType
        throw null;
    }
    public static PtrType<T3> Get<T3, T2, T>(this PtrType<T> self, int i, int j)
        where T: IPtrMarker<T2>
        where T2: IPtrMarker<T3>
    {
        return self.Get(i).Get(j);
    }
}

public static class PtrAccessor  
{
    public static PtrType<T2> Get<T2, T>(this PtrType<T> self, int i)
        where T: IPtrMarker<T2>
    {
         // IDK take an index and do magic with the inner of PtrType
        throw null;
    }
    public static PtrType<T3> Get<T3, T2, T>(this PtrType<T> self, int i, int j)
        where T: IPtrMarker<T2>
        where T2: IPtrMarker<T3>
    {
        return self.Get(i).Get(j);
    }
}

public static class PtrAccessor  
{
    public static PtrType<T2> Get<T2, T>(this PtrType<T> self, int i)
        where T: IPtrMarker<T2>
    {
         // IDK take an index and do magic with the inner of PtrType
        throw null;
    }
    public static PtrType<T3> Get<T3, T2, T>(this PtrType<T> self, int i, int j)
        where T: IPtrMarker<T2>
        where T2: IPtrMarker<T3>
    {
        return self.Get(i).Get(j);
    }
}

public static class PtrAccessor  
{
    public static PtrType<T2> Get<T2, T>(this PtrType<T> self, int i)
        where T: IPtrMarker<T2>
    {
         // IDK take an index and do magic with the inner of PtrType
        throw null;
    }
    public static PtrType<T3> Get<T3, T2, T>(this PtrType<T> self, int i, int j)
        where T: IPtrMarker<T2>
        where T2: IPtrMarker<T3>
    {
        return self.Get(i).Get(j);
    }
}

K

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

try not to stare into the sun too long

M

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

we don't need the interface for this

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

Similar Threads