Unclear way to free memory that was allocated by `new`

[kyasbal]

Hi, I think it is very important to write about this topic explicitly.

---

class Vector2{
   public x:u32;

   public y:u32;
}

When you created such a class shown above, you may use new keyword to create an instance like the code below.

for(let i:u32 = 0; i < 10000000; i++){
   let v = new Vector2();
   // Some of code using vector2 here
}

However, AssemblyScript has no GC feature at this point, the v allocated for each loop iteration will not be released. You can confirm this phenomenon with inspecting exports.memory.buffer.byteLength from javascript. To remove class instance explicitly like C++ languages, AssemblyScript require you to write release code explicitly.

This can be done with memory.free method. This method receive a pointer to release. We can retrive a pointer to the instance by calling changeType<usize>(instance).

for(let i:u32 = 0; i < 10000000; i++){
   let v = new Vector2();
   // Some of code using vector2 here
   memory.free(changeType<usize>(v));
}

---

I don't think this way is so clear since the memory.free can't receive class instance variable directly. Even that, it is very hard to notice how it shoud be done.

[dcodeIO]

Yeah, using new anticipates a GC to be present. An initial implementation is here. One day this will be the default.

Without a GC, this is essentially simply equivalent to:

var v = changetype<Vector2>(memory.allocate(offsetof<Vector2>()));
...
memory.free(changetype<usize>(v));

With a GC:

import "allocator/tlsf";
import "collector/itcm";

var v: Vector2 | null = new Vector2();
v = null;

gc.collect();

[kyasbal]

Im definitely looking forward to see that GC feature be implemented!
Anyway, such a knowledge to release memory and the manual instance creation you have pointed out are not clear from the documents. I suggest you to append these knowledge to the wiki.
Thanks.

[kyasbal]

And I have one more question related to this topic. If I need to release memory that was allocated with an array, I wonder it is not good to write memory.free(changeType<usize>(theArray)). Since that array should contain internal buffer as ArrayBuffer and it should be released internally.
How can we write release array safely?

[dcodeIO]

Most of the standard library has been designed with eventual GC support in mind, so freeing the respective structures is not straight forward. It can be done, though.

function freeArray<T>(arr: T[]): void {
  assert(arr !== null);
  memory.free(load<usize>(changetype<usize>(arr) + offsetof<T[]>("buffer_")));
  memory.free(changetype<usize>(arr));
}

That frees both the backing ArrayBuffer and the Array structure (in this order). Careful, though, because if there are any other references to that array afterwards, that might result in a use-after-free situation.

Another thing to note is that arrays can resize their buffer automatically, i.e. when more space is needed, leaving an unreferenced buffer behind that can't be accessed anymore. Do this only with fixed size arrays, like

var arr = new Array<i32>(32);

and take special care that it doesn't have to resize.

[Macmee]

hi @dcodeIO am I safe now to import and use import "collector/itcm"; for my project, or should I instead implement my own form of manual reference counting on top of tlsf until itcm has matured? Thanks!

[dcodeIO]

The itcm GC is still somewhat experimental and hasn't been tested a lot yet. If you are fine with investigating and reporting potential bugs, you can use it, of course.

[dcodeIO]

Closing this issue for now as it hasn't received any replies recently. Feel free to reopen it if necessary!