About JL_GC_PUSH* operations

[ShuhuaGao]

As we can see from julia.h, the JL_GC_PUSH series like JL_GC_PUSH1 is just a macro in C. Consequently, there is no export in libjulia.dll. I am wondering how the code below works.

https://github.com/HyperSphereStudio/JULIA.Net/blob/4d1fbe4360cae909840641bb1f7e0b5537908acb/src/csharp/JuliaCalls.cs#L150-L151

[HyperSphereStudio]

You are correct, I left it in there for future a future fix but I personally had never needed to add it since I just used another solution to pin to the GC. I had forgotten I left it in.
Ill remove it

[HyperSphereStudio]

Macros such as PUSH_GC could be added.

There are other helpful macros like it aswell that I couldnt add

[HyperSphereStudio]

For the stuff that currently works I will keep as is. The extra .dll stuff is only for stuff that would be an absolute pain to add via c# like the GC_PUSH. I am sure other things in the future will arise where this will be very useful to have regardless.

It does complicate the project but I do think it will be quite useful

*I revise my previous statement about all native calls going through this. I will keep everything that works as is.

[HyperSphereStudio]

Perhaps C++/CLI will work for this?

Any thoughts?

Should I by hand implement the macros in C# (possible but will be tedious)

Make a cpp dll

Try it via cpp/cli

Any other methods / thoughts on the above?

[ShuhuaGao]

Thanks for the explanation. However, without JL_GC_PUSH, how did you achieve memory management of immutable types? For example, the code snippet from memory management as below:

// This functions shall be executed only once, during the initialization.
jl_value_t* refs = jl_eval_string("refs = IdDict()");
jl_function_t* setindex = jl_get_function(jl_base_module, "setindex!");
jl_datatype_t* reft = (jl_datatype_t*)jl_eval_string("Base.RefValue{Any}");

...

// `var` is the variable we want to protect between function calls.
jl_value_t* var = 0;

...

// `var` is a `Float64`, which is immutable.
var = jl_eval_string("sqrt(2.0)");

// Protect `var` until we add its reference to `refs`.
JL_GC_PUSH1(&var);

// Wrap `var` in `RefValue{Any}` and push to `refs` to protect it.
jl_value_t* rvar = jl_new_struct(reft, var);
JL_GC_POP();

jl_call3(setindex, refs, rvar, rvar);

I cannot figure out how to translate it in C#.

[HyperSphereStudio]

On answering your question I realized there I had left a vulnarability in my code. I have never had it occur but it does exist.

My method of preventing GC from preventing freeing is by push the type to a set. However I realized on calling the function push the GC may activate.

I will fix this by adding the push_gc macro.

My solution is better for long term handles on variables but for short term things its better to use the push macro.

I will patch my code my adding the push/pop before and after the push to the set to fix this bug

[HyperSphereStudio]

I believe I have solved the problem without a cpp dll! Please check to make sure it works... Its hard to tell from my end and it was a little odd to do.

I released this fix in version 2.5.0.

I removed the wrong functions from JuliaCalls