Are structs always allocated on the stack, even when created with new?

[ghost]

This is my conclusion after reading the Programming Manual. Please correct me if I'm wrong.

I'm considering using structs for performance reasons. I want to avoid boxing and unboxing, but I also prefer heap allocation over stack allocation. My struct is very simple. It contains a real number and a method that generates another real number using the original one through a mathematical formula (involving square root, exponential, and some trigonometric functions).

BTW, I’d like to ask: are there mathematical methods available for working with primitive types if I decide to use __float instead of real?

Thank you.

[arakov]

Yes, it is correct. To force it to be dynamic you have to declare it as nullable.

So the situation is following. The structure is a dump of memory. And when you declare a local variable it will reside in the stack. When you declare a field inside the structure, it will be placed inside this structure. If it is a normal class - it will be created dynamically

When you call the constructor in the worst case it will create a dynamic object and copy it content into the stack. There is an optimization which allow to call the constructor directly

For example the following code:

struct X
{
   real r;

   inc()
   {
      r += 1.0
   }
}

public program()
{
   X x := new X();

   x.inc();
}

If you look into bytecode generated you will notice it is stack allocated:

>@function program.function:#invoke
           xflush       sp:0
           open           :3, :8
           store        fp:1
           set       class:sandbox'$private'X
           xstore       sp:0, :0
           mov        mssg:function:#constructor
           call       mssg:function:#constructor, class:sandbox'$private'X#class
           store        fp:2
           store        sp:0
           // ; this means that the variable is stack allocated
           copy         dp:-4, :8
           set          dp:-4
           store        sp:0
           mov        mssg:inc[1]
           call       mssg:inc[1], class:sandbox'$private'X
           peek         fp:1
Lab00:     nop
           close          :8
           quit           
@end

But you may force the compiler to make it always dynamic simply be declaring it as nullable

// ...

public program()
{
   X? x := new X();

   x.inc();
}

And now look at byte code:

>@function program.function:#invoke
           xflush       sp:0
           open           :4, :0
           store        fp:1
           set       class:sandbox'$private'X
           xstore       sp:0, :0
           mov        mssg:function:#constructor
           call       mssg:function:#constructor, class:sandbox'$private'X#class
           store        fp:3
           store        fp:2
           store        sp:0
           mov        mssg:inc[1]
           call       mssg:inc[1], class:sandbox'$private'X
           peek         fp:1
Lab00:     nop
           close          :0
           quit           
@end

As you see no copy opcode, so the structure is pure dynamic. The only problem that it will give you warning about an operation with nullable object. But you either check if the object is not nil, or if you sure it is always not nil, similar to C# do something like this:

public program()
{
   <...>

   x!.inc();
}

As for primitive data types. All basic numeric operations with real type will be native, e.g.

public program()
{
   real n := 2.0;

   real r := n + 3
}

And the output is:

@function program.function:#invoke
           xflush       sp:0
           open           :3, :24
           store        fp:1
           xstore       sp:0, realconst:2
           copy         dp:-4, :8
           set          dp:-4
           store        sp:0
           xstore       sp:1, realconst:3
           copy         dp:-20, :8
           xmov         sp:0, :1
           // ; direct operation
           fadd         dp:-20, :8
           set          dp:-20
           store        sp:0
           copy         dp:-12, :8
           peek         fp:1
Lab00:     nop
           close          :24
           quit           
@end

You will see, that no methods were called.

With mathematical functions, it is still requires to call the method. But I could probably think about how to support it natively as well.
I will create an item for this. But if it is used properly no unnecessary boxing / unboxing will be generated. I put some significant efforts to avoid extra boxing in these cases