```cs PtrType<sbyte> a = ???; PtrType<Ptr<sbyte>> b = a.PtrTo(); glfwGetError(b); ```

```cs PtrType a = ???; PtrType > b = a.PtrTo(); glfwGetError(b); ```

Maxine · 2023-08-04T20:22:09.742Z

```cs PtrType a = ???; PtrType > b = a.PtrTo(); glfwGetError(b); ```

K

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

int glfwError(ConstPtrType<Ptr<sbyte>>)

int glfwError(ConstPtrType<Ptr<sbyte>>)

int glfwError(ConstPtrType<Ptr<sbyte>>)

int glfwError(ConstPtrType<Ptr<sbyte>>)

MMaxine ```cs PtrType<sbyte> a = ???; PtrType<Ptr<sbyte>> b = a.PtrTo(); glfwGetError(...

K

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

and that

K

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

just ConstPtrType on the outside I think

M

MaxineOP•8/4/23, 8:23 PM

i foind a problem

P

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

and presumably if I did

PtrType<sbyte> a = nullptr;
PtrType<Ptr<sbyte> b = a.PtrTo();
glfwGetError(b);
Debug.Assert(a != nullptr);

PtrType<sbyte> a = nullptr;
PtrType<Ptr<sbyte> b = a.PtrTo();
glfwGetError(b);
Debug.Assert(a != nullptr);

PtrType<sbyte> a = nullptr;
PtrType<Ptr<sbyte> b = a.PtrTo();
glfwGetError(b);
Debug.Assert(a != nullptr);

PtrType<sbyte> a = nullptr;
PtrType<Ptr<sbyte> b = a.PtrTo();
glfwGetError(b);
Debug.Assert(a != nullptr);

it'd pass?

M

MaxineOP•8/4/23, 8:23 PM

PtrType<T> = contains a ref T
PtrType<Ptr<T>> = contains a ref Ptr<T> which contains a ref T, this is not allowed because Ptr is not a ref struct

M

MaxineOP•8/4/23, 8:23 PM

how would PtrType work in this scenario

P

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

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

P

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

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

M

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

we're having like 15 discussions at the same time

K

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

AsPtr2D I think turns

ref PtrType<sbyte>

ref PtrType<sbyte>

ref PtrType<sbyte>

ref PtrType<sbyte> into

PtrType<Ptr<sbyte>>

PtrType<Ptr<sbyte>>

PtrType<Ptr<sbyte>>

PtrType<Ptr<sbyte>> (so I guess it should be AsConstPtr2D()) and the given

ref

ref

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

K

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

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

M

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

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

K

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

K

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

I don't see how this is different from the

RefMut<sbyte>

RefMut<sbyte>

RefMut<sbyte>

RefMut<sbyte> type at runtime? It's just a

ref byte

ref byte

ref byte

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

K

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

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

K

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

(which I don't think is necessary)

M

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

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

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

M

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

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

great

K

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

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

M

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

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

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

no Ptr is empty

K

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

Ptr is just a compile-time marker

M

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

yeah ptr isn't anything

K

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

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

K

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)

K

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

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

See the Inner extension method

K

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

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

fair yeah

P

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

hmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm

K

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

there won't be indexers for ptr -> ptr

K

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

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

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

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

like either is ugly here tbh

```cs PtrType<sbyte> a = ???; PtrType<Ptr<sbyte>> b = a.PtrTo(); glfwGetError(b); ```

Similar Threads