error is `ConstPtr<sbyte>` in this instance

error is `ConstPtr ` in this instance

Perksey · 2023-08-04T20:16:11.445Z

error is `ConstPtr ` in this instance

AAqua maybe i have come in at the wrong time - but has the prospect of having 2 overlo...

K

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

unsafe overloads will stay, I'm very confident to say that

P

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

NO OVERLOADS

K

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

unsafe ways to call the function

K

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

whatever

M

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

a cast that doesn't change the underlying memory of the value is free

P

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

the JIT is smart enough that if for every

Ptr

Ptr

Ptr

Ptr you implicitly cast from a

something*

something*

something*

something*, it will be equivalent to fully unsafe

PPerksey error is `ConstPtr<sbyte>` in this instance

K

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

? So what does AsPtr2D() return? that makes no sense to me

P

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

ConstPtr<sbyte>

ConstPtr<sbyte>

incorrectly returns

ConstPtr2D<sbyte>

ConstPtr2D<sbyte>

ConstPtr2D<sbyte>

ConstPtr2D<sbyte> atm

KKai ? So what does AsPtr2D() return? that makes no sense to me

M

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

sbyte* to sbyte**, i presume

P

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

i.e. it converts a

ref this ConstPtr<sbyte>

ref this ConstPtr<sbyte>

ref this ConstPtr<sbyte>

ref this ConstPtr<sbyte> to a

ConstPtr2D<sbyte>

ConstPtr2D<sbyte>

ConstPtr2D<sbyte>

ConstPtr2D<sbyte>

P

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

(or in IL terms,

ldarg.0

ldarg.0

ldarg.0

ldarg.0

ret

ret

ret

ret)

K

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

ah

K

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

ref

K

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

I see where the extra comes from now

K

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

implicit ref

P

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

lmao

P

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

i'm sorry I just found that hilarious

P

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

PPerksey NO OVERLOADS

A

Aqua•8/4/23, 8:18 PM

hmm that's where i disagree
one of the big benefits of C# is that it has overloads
sure you can have too many of them
but if you only have a few they can work very well
a pointer overload and an array overload
maybe a span
i just feel like this

Ptr<T>

Ptr<T>

Ptr<T>

Ptr<T> stuff may be a bit hard to understand, certainly i'm looking at this and wondering what exactly this is supposed to mean
i feel like for most users, they will only ever want safe overloads that take an array/whatever else, instead of a

Ptr<T>

Ptr<T>

Ptr<T>

Ptr<T> struct that may leave (especially to beginners) some users scratching their heads
and for those that want pointer overloads, they are available as well

K

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

yeah so that way around I see no problem with my design? It would work fine, the same way it works now. Use some IL magic to load the arg ptr and then store it into the outer PtrType ref struct

K

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

(but also do generic magic so the compiler knows what indirection level we are at now, but this isn't a runtime thing)

K

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

(unfortunately the JIT won't see it that way and produce many re-compilations of the same IL but that's not on me)

K

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

(and also also the case with The RefMutRef design)

P

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

can you define an E2E of how it'll work with a dummy glfwGetError signature, sorry just being stupid and can't quite visualise it

K

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

eeeh

K

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

can you give me the E2E I'm supposed to translate? I don't know what it looks like right now

P

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

what would

int glfwGetError(const char**)

int glfwGetError(const char**)

int glfwGetError(const char**)

int glfwGetError(const char**) (i.e.

sbyte**

sbyte**

sbyte**

sbyte**) look like, how would the user use it, and what does the AsPtr2D (or whatever) have to do to make it work

M

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

PtrType<sbyte> a = ???;

PtrType<Ptr<sbyte>> b = a.PtrTo();

glfwGetError(b);

PtrType<sbyte> a = ???;

PtrType<Ptr<sbyte>> b = a.PtrTo();

glfwGetError(b);

PtrType<sbyte> a = ???;

PtrType<Ptr<sbyte>> b = a.PtrTo();

glfwGetError(b);

PtrType<sbyte> a = ???;

PtrType<Ptr<sbyte>> 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

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

i foind a problem

P

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

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

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

how would PtrType work in this scenario

P

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

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

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

M

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

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

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

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

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

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

error is `ConstPtr<sbyte>` in this instance

Similar Threads